samples/sockets/client.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        client.cpp
   3 // Purpose:     Client for wxSocket demo
   4 // Author:      Guillermo Rodriguez Garcia <guille@iies.es>
   5 // Modified by:
   6 // Created:     1999/09/19
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Guillermo Rodriguez Garcia
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ==========================================================================
  13 // declarations
  14 // ==========================================================================
  15
  16 // --------------------------------------------------------------------------
  17 // headers
  18 // --------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx/wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24 #  pragma hdrstop
  25 #endif
  26
  27 // for all others, include the necessary headers
  28 #ifndef WX_PRECOMP
  29 #  include "wx/wx.h"
  30 #endif
  31
  32 #include "wx/socket.h"
  33 #include "wx/url.h"
  34 #include "wx/wfstream.h"
  35
  36 // --------------------------------------------------------------------------
  37 // resources
  38 // --------------------------------------------------------------------------
  39
  40 // the application icon
  41 #if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__)
  42 #  include "mondrian.xpm"
  43 #endif
  44
  45 // --------------------------------------------------------------------------
  46 // classes
  47 // --------------------------------------------------------------------------
  48
  49 // Define a new application type
  50 class MyApp : public wxApp
  51 {
  52 public:
  53   virtual bool OnInit();
  54 };
  55
  56 // Define a new frame type: this is going to be our main frame
  57 class MyFrame : public wxFrame
  58 {
  59 public:
  60   MyFrame();
  61   ~MyFrame();
  62
  63   // event handlers for File menu
  64   void OnQuit(wxCommandEvent& event);
  65   void OnAbout(wxCommandEvent& event);
  66
  67   // event handlers for Socket menu
  68   void OnOpenConnection(wxCommandEvent& event);
  69   void OnTest1(wxCommandEvent& event);
  70   void OnTest2(wxCommandEvent& event);
  71   void OnTest3(wxCommandEvent& event);
  72   void OnCloseConnection(wxCommandEvent& event);
  73
  74 #if wxUSE_URL
  75   // event handlers for Protocols menu
  76   void OnTestURL(wxCommandEvent& event);
  77 #endif
  78
  79   // event handlers for DatagramSocket menu (stub)
  80   void OnDatagram(wxCommandEvent& event);
  81
  82   // socket event handler
  83   void OnSocketEvent(wxSocketEvent& event);
  84
  85   // convenience functions
  86   void UpdateStatusBar();
  87
  88 private:
  89   wxSocketClient *m_sock;
  90   wxTextCtrl     *m_text;
  91   wxMenu         *m_menuFile;
  92   wxMenu         *m_menuSocket;
  93   wxMenu         *m_menuDatagramSocket;
  94   wxMenu         *m_menuProtocols;
  95   wxMenuBar      *m_menuBar;
  96   bool            m_busy;
  97
  98   // any class wishing to process wxWidgets events must use this macro
  99   DECLARE_EVENT_TABLE()
 100 };
 101
 102 // --------------------------------------------------------------------------
 103 // constants
 104 // --------------------------------------------------------------------------
 105
 106 // IDs for the controls and the menu commands
 107 enum
 108 {
 109   // menu items
 110   CLIENT_QUIT = wxID_EXIT,
 111   CLIENT_ABOUT = wxID_ABOUT,
 112   CLIENT_OPEN = 100,
 113   CLIENT_TEST1,
 114   CLIENT_TEST2,
 115   CLIENT_TEST3,
 116   CLIENT_CLOSE,
 117 #if wxUSE_URL
 118   CLIENT_TESTURL,
 119 #endif
 120   CLIENT_DGRAM,
 121
 122   // id for socket
 123   SOCKET_ID
 124 };
 125
 126 // --------------------------------------------------------------------------
 127 // event tables and other macros for wxWidgets
 128 // --------------------------------------------------------------------------
 129
 130 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 131   EVT_MENU(CLIENT_QUIT,     MyFrame::OnQuit)
 132   EVT_MENU(CLIENT_ABOUT,    MyFrame::OnAbout)
 133   EVT_MENU(CLIENT_OPEN,     MyFrame::OnOpenConnection)
 134   EVT_MENU(CLIENT_TEST1,    MyFrame::OnTest1)
 135   EVT_MENU(CLIENT_TEST2,    MyFrame::OnTest2)
 136   EVT_MENU(CLIENT_TEST3,    MyFrame::OnTest3)
 137   EVT_MENU(CLIENT_CLOSE,    MyFrame::OnCloseConnection)
 138   EVT_MENU(CLIENT_DGRAM,    MyFrame::OnDatagram)
 139 #if wxUSE_URL
 140   EVT_MENU(CLIENT_TESTURL,  MyFrame::OnTestURL)
 141 #endif
 142   EVT_SOCKET(SOCKET_ID,     MyFrame::OnSocketEvent)
 143 END_EVENT_TABLE()
 144
 145 IMPLEMENT_APP(MyApp)
 146
 147 // ==========================================================================
 148 // implementation
 149 // ==========================================================================
 150
 151 // --------------------------------------------------------------------------
 152 // the application class
 153 // --------------------------------------------------------------------------
 154
 155 bool MyApp::OnInit()
 156 {
 157   if ( !wxApp::OnInit() )
 158       return false;
 159
 160   // Create the main application window
 161   MyFrame *frame = new MyFrame();
 162
 163   // Show it and tell the application that it's our main window
 164   frame->Show(true);
 165   SetTopWindow(frame);
 166
 167   // success
 168   return true;
 169 }
 170
 171 // --------------------------------------------------------------------------
 172 // main frame
 173 // --------------------------------------------------------------------------
 174
 175 // frame constructor
 176 MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
 177                              _("wxSocket demo: Client"),
 178                              wxDefaultPosition, wxSize(300, 200))
 179 {
 180   // Give the frame an icon
 181   SetIcon(wxICON(mondrian));
 182
 183   // Make menus
 184   m_menuFile = new wxMenu();
 185   m_menuFile->Append(CLIENT_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
 186   m_menuFile->AppendSeparator();
 187   m_menuFile->Append(CLIENT_QUIT, _("E&xit\tAlt-X"), _("Quit client"));
 188
 189   m_menuSocket = new wxMenu();
 190   m_menuSocket->Append(CLIENT_OPEN, _("&Open session"), _("Connect to server"));
 191   m_menuSocket->AppendSeparator();
 192   m_menuSocket->Append(CLIENT_TEST1, _("Test &1"), _("Test basic functionality"));
 193   m_menuSocket->Append(CLIENT_TEST2, _("Test &2"), _("Test ReadMsg and WriteMsg"));
 194   m_menuSocket->Append(CLIENT_TEST3, _("Test &3"), _("Test large data transfer"));
 195   m_menuSocket->AppendSeparator();
 196   m_menuSocket->Append(CLIENT_CLOSE, _("&Close session"), _("Close connection"));
 197
 198   m_menuDatagramSocket = new wxMenu();
 199   m_menuDatagramSocket->Append(CLIENT_DGRAM, _("Send Datagram"), _("Test UDP sockets"));
 200
 201 #if wxUSE_URL
 202   m_menuProtocols = new wxMenu();
 203   m_menuProtocols->Append(CLIENT_TESTURL, _("Test URL"), _("Get data from the specified URL"));
 204 #endif
 205
 206   // Append menus to the menubar
 207   m_menuBar = new wxMenuBar();
 208   m_menuBar->Append(m_menuFile, _("&File"));
 209   m_menuBar->Append(m_menuSocket, _("&SocketClient"));
 210   m_menuBar->Append(m_menuDatagramSocket, _("&DatagramSocket"));
 211 #if wxUSE_URL
 212   m_menuBar->Append(m_menuProtocols, _("&Protocols"));
 213 #endif
 214   SetMenuBar(m_menuBar);
 215
 216 #if wxUSE_STATUSBAR
 217   // Status bar
 218   CreateStatusBar(2);
 219 #endif // wxUSE_STATUSBAR
 220
 221   // Make a textctrl for logging
 222   m_text  = new wxTextCtrl(this, wxID_ANY,
 223                            _("Welcome to wxSocket demo: Client\nClient ready\n"),
 224                            wxDefaultPosition, wxDefaultSize,
 225                            wxTE_MULTILINE | wxTE_READONLY);
 226
 227   // Create the socket
 228   m_sock = new wxSocketClient();
 229
 230   // Setup the event handler and subscribe to most events
 231   m_sock->SetEventHandler(*this, SOCKET_ID);
 232   m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG |
 233                     wxSOCKET_INPUT_FLAG |
 234                     wxSOCKET_LOST_FLAG);
 235   m_sock->Notify(true);
 236
 237   m_busy = false;
 238   UpdateStatusBar();
 239 }
 240
 241 MyFrame::~MyFrame()
 242 {
 243   // No delayed deletion here, as the frame is dying anyway
 244   delete m_sock;
 245 }
 246
 247 // event handlers
 248
 249 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 250 {
 251   // true is to force the frame to close
 252   Close(true);
 253 }
 254
 255 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 256 {
 257   wxMessageBox(_("wxSocket demo: Client\n(c) 1999 Guillermo Rodriguez Garcia\n"),
 258                _("About Client"),
 259                wxOK | wxICON_INFORMATION, this);
 260 }
 261
 262 void MyFrame::OnOpenConnection(wxCommandEvent& WXUNUSED(event))
 263 {
 264   wxIPV4address addr;
 265
 266   m_menuSocket->Enable(CLIENT_OPEN, false);
 267   m_menuSocket->Enable(CLIENT_CLOSE, false);
 268
 269   // Ask user for server address
 270   wxString hostname = wxGetTextFromUser(
 271     _("Enter the address of the wxSocket demo server:"),
 272     _("Connect ..."),
 273     _("localhost"));
 274
 275   addr.Hostname(hostname);
 276   addr.Service(3000);
 277
 278   // Mini-tutorial for Connect() :-)
 279   // ---------------------------
 280   //
 281   // There are two ways to use Connect(): blocking and non-blocking,
 282   // depending on the value passed as the 'wait' (2nd) parameter.
 283   //
 284   // Connect(addr, true) will wait until the connection completes,
 285   // returning true on success and false on failure. This call blocks
 286   // the GUI (this might be changed in future releases to honour the
 287   // wxSOCKET_BLOCK flag).
 288   //
 289   // Connect(addr, false) will issue a nonblocking connection request
 290   // and return immediately. If the return value is true, then the
 291   // connection has been already successfully established. If it is
 292   // false, you must wait for the request to complete, either with
 293   // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
 294   // events (please read the documentation).
 295   //
 296   // WaitOnConnect() itself never blocks the GUI (this might change
 297   // in the future to honour the wxSOCKET_BLOCK flag). This call will
 298   // return false on timeout, or true if the connection request
 299   // completes, which in turn might mean:
 300   //
 301   //   a) That the connection was successfully established
 302   //   b) That the connection request failed (for example, because
 303   //      it was refused by the peer.
 304   //
 305   // Use IsConnected() to distinguish between these two.
 306   //
 307   // So, in a brief, you should do one of the following things:
 308   //
 309   // For blocking Connect:
 310   //
 311   //   bool success = client->Connect(addr, true);
 312   //
 313   // For nonblocking Connect:
 314   //
 315   //   client->Connect(addr, false);
 316   //
 317   //   bool waitmore = true;
 318   //   while (! client->WaitOnConnect(seconds, millis) && waitmore )
 319   //   {
 320   //     // possibly give some feedback to the user,
 321   //     // update waitmore if needed.
 322   //   }
 323   //   bool success = client->IsConnected();
 324   //
 325   // And that's all :-)
 326
 327   m_text->AppendText(_("\nTrying to connect (timeout = 10 sec) ...\n"));
 328   m_sock->Connect(addr, false);
 329   m_sock->WaitOnConnect(10);
 330
 331   if (m_sock->IsConnected())
 332     m_text->AppendText(_("Succeeded ! Connection established\n"));
 333   else
 334   {
 335     m_sock->Close();
 336     m_text->AppendText(_("Failed ! Unable to connect\n"));
 337     wxMessageBox(_("Can't connect to the specified host"), _("Alert !"));
 338   }
 339
 340   UpdateStatusBar();
 341 }
 342
 343 void MyFrame::OnTest1(wxCommandEvent& WXUNUSED(event))
 344 {
 345   const wxChar *buf1;
 346   wxChar       *buf2;
 347   unsigned char len;
 348
 349   // Disable socket menu entries (exception: Close Session)
 350   m_busy = true;
 351   UpdateStatusBar();
 352
 353   m_text->AppendText(_("\n=== Test 1 begins ===\n"));
 354
 355   // Tell the server which test we are running
 356   unsigned char c = 0xBE;
 357   m_sock->Write(&c, 1);
 358
 359   // Send some data and read it back. We know the size of the
 360   // buffer, so we can specify the exact number of bytes to be
 361   // sent or received and use the wxSOCKET_WAITALL flag. Also,
 362   // we have disabled menu entries which could interfere with
 363   // the test, so we can safely avoid the wxSOCKET_BLOCK flag.
 364   //
 365   // First we send a byte with the length of the string, then
 366   // we send the string itself (do NOT try to send any integral
 367   // value larger than a byte "as is" across the network, or
 368   // you might be in trouble! Ever heard about big and little
 369   // endian computers?)
 370
 371   m_sock->SetFlags(wxSOCKET_WAITALL);
 372
 373   buf1 = _("Test string (less than 256 chars!)");
 374   len  = (unsigned char)((wxStrlen(buf1) + 1) * sizeof(wxChar));
 375   buf2 = new wxChar[wxStrlen(buf1) + 1];
 376
 377   m_text->AppendText(_("Sending a test buffer to the server ..."));
 378   m_sock->Write(&len, 1);
 379   m_sock->Write(buf1, len);
 380   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 381
 382   m_text->AppendText(_("Receiving the buffer back from server ..."));
 383   m_sock->Read(buf2, len);
 384   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 385
 386   m_text->AppendText(_("Comparing the two buffers ..."));
 387   if (memcmp(buf1, buf2, len) != 0)
 388   {
 389     m_text->AppendText(_("failed!\n"));
 390     m_text->AppendText(_("Test 1 failed !\n"));
 391   }
 392   else
 393   {
 394     m_text->AppendText(_("done\n"));
 395     m_text->AppendText(_("Test 1 passed !\n"));
 396   }
 397   m_text->AppendText(_("=== Test 1 ends ===\n"));
 398
 399   delete[] buf2;
 400   m_busy = false;
 401   UpdateStatusBar();
 402 }
 403
 404 void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
 405 {
 406   const wxChar *msg1;
 407   wxChar *msg2;
 408   size_t len;
 409
 410   // Disable socket menu entries (exception: Close Session)
 411   m_busy = true;
 412   UpdateStatusBar();
 413
 414   m_text->AppendText(_("\n=== Test 2 begins ===\n"));
 415
 416   // Tell the server which test we are running
 417   unsigned char c = 0xCE;
 418   m_sock->Write(&c, 1);
 419
 420   // Here we use ReadMsg and WriteMsg to send messages with
 421   // a header with size information. Also, the reception is
 422   // event triggered, so we test input events as well.
 423   //
 424   // We need to set no flags here (ReadMsg and WriteMsg are
 425   // not affected by flags)
 426
 427   m_sock->SetFlags(wxSOCKET_WAITALL);
 428
 429   wxString s = wxGetTextFromUser(
 430     _("Enter an arbitrary string to send to the server:"),
 431     _("Test 2 ..."),
 432     _("Yes I like wxWidgets!"));
 433
 434   msg1 = s.c_str();
 435   len  = (wxStrlen(msg1) + 1) * sizeof(wxChar);
 436   msg2 = new wxChar[wxStrlen(msg1) + 1];
 437
 438   m_text->AppendText(_("Sending the string with WriteMsg ..."));
 439   m_sock->WriteMsg(msg1, len);
 440   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 441   m_text->AppendText(_("Waiting for an event (timeout = 2 sec)\n"));
 442
 443   // Wait until data available (will also return if the connection is lost)
 444   m_sock->WaitForRead(2);
 445
 446   if (m_sock->IsData())
 447   {
 448     m_text->AppendText(_("Reading the string back with ReadMsg ..."));
 449     m_sock->ReadMsg(msg2, len);
 450     m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 451     m_text->AppendText(_("Comparing the two buffers ..."));
 452     if (memcmp(msg1, msg2, len) != 0)
 453     {
 454       m_text->AppendText(_("failed!\n"));
 455       m_text->AppendText(_("Test 2 failed !\n"));
 456     }
 457     else
 458     {
 459       m_text->AppendText(_("done\n"));
 460       m_text->AppendText(_("Test 2 passed !\n"));
 461     }
 462   }
 463   else
 464     m_text->AppendText(_("Timeout ! Test 2 failed.\n"));
 465
 466   m_text->AppendText(_("=== Test 2 ends ===\n"));
 467
 468   delete[] msg2;
 469   m_busy = false;
 470   UpdateStatusBar();
 471 }
 472
 473 void MyFrame::OnTest3(wxCommandEvent& WXUNUSED(event))
 474 {
 475   char *buf1;
 476   char *buf2;
 477   unsigned char len;
 478
 479   // Disable socket menu entries (exception: Close Session)
 480   m_busy = true;
 481   UpdateStatusBar();
 482
 483   m_text->AppendText(_("\n=== Test 3 begins ===\n"));
 484
 485   // Tell the server which test we are running
 486   unsigned char c = 0xDE;
 487   m_sock->Write(&c, 1);
 488
 489   // This test also is similar to the first one but it sends a
 490   // large buffer so that wxSocket is actually forced to split
 491   // it into pieces and take care of sending everything before
 492   // returning.
 493
 494   m_sock->SetFlags(wxSOCKET_WAITALL);
 495
 496   // Note that len is in kbytes here!
 497   len  = 32;
 498   buf1 = new char[len * 1024];
 499   buf2 = new char[len * 1024];
 500
 501   for (int i = 0; i < len * 1024; i ++)
 502     buf1[i] = (char)(i % 256);
 503
 504   m_text->AppendText(_("Sending a large buffer (32K) to the server ..."));
 505   m_sock->Write(&len, 1);
 506   m_sock->Write(buf1, len * 1024);
 507   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 508
 509   m_text->AppendText(_("Receiving the buffer back from server ..."));
 510   m_sock->Read(buf2, len * 1024);
 511   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 512
 513   m_text->AppendText(_("Comparing the two buffers ..."));
 514   if (memcmp(buf1, buf2, len) != 0)
 515   {
 516     m_text->AppendText(_("failed!\n"));
 517     m_text->AppendText(_("Test 3 failed !\n"));
 518   }
 519   else
 520   {
 521     m_text->AppendText(_("done\n"));
 522     m_text->AppendText(_("Test 3 passed !\n"));
 523   }
 524   m_text->AppendText(_("=== Test 3 ends ===\n"));
 525
 526   delete[] buf2;
 527   m_busy = false;
 528   UpdateStatusBar();
 529 }
 530
 531 void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
 532 {
 533   m_sock->Close();
 534   UpdateStatusBar();
 535 }
 536
 537 void MyFrame::OnDatagram(wxCommandEvent& WXUNUSED(event))
 538 {
 539   m_text->AppendText(_("\n=== Datagram test begins ===\n"));
 540   m_text->AppendText(_("Sorry, not implemented\n"));
 541   m_text->AppendText(_("=== Datagram test ends ===\n"));
 542 }
 543
 544 #if wxUSE_URL
 545
 546 void MyFrame::OnTestURL(wxCommandEvent& WXUNUSED(event))
 547 {
 548   // Note that we are creating a new socket here, so this
 549   // won't mess with the client/server demo.
 550
 551   // Ask for the URL
 552   m_text->AppendText(_("\n=== URL test begins ===\n"));
 553   wxString urlname = wxGetTextFromUser(_("Enter an URL to get"),
 554                                        _("URL:"),
 555                                        _T("http://localhost"));
 556
 557   // Parse the URL
 558   wxURL url(urlname);
 559   if (url.GetError() != wxURL_NOERR)
 560   {
 561     m_text->AppendText(_("Error: couldn't parse URL\n"));
 562     m_text->AppendText(_("=== URL test ends ===\n"));
 563     return;
 564   }
 565
 566   // Try to get the input stream (connects to the given URL)
 567   m_text->AppendText(_("Trying to establish connection...\n"));
 568   wxYield();
 569   wxInputStream *data = url.GetInputStream();
 570   if (!data)
 571   {
 572     m_text->AppendText(_("Error: couldn't read from URL\n"));
 573     m_text->AppendText(_("=== URL test ends ===\n"));
 574     return;
 575   }
 576
 577   // Print the contents type and file size
 578   wxString s;
 579   s.Printf(_("Contents type: %s\nFile size: %i\nStarting to download...\n"),
 580              url.GetProtocol().GetContentType().c_str(),
 581              data->GetSize());
 582   m_text->AppendText(s);
 583   wxYield();
 584
 585   // Get the data
 586   wxFile fileTest(wxT("test.url"), wxFile::write);
 587   wxFileOutputStream sout(fileTest);
 588   if (!sout.Ok())
 589   {
 590     m_text->AppendText(_("Error: couldn't open file for output\n"));
 591     m_text->AppendText(_("=== URL test ends ===\n"));
 592     return;
 593   }
 594
 595   data->Read(sout);
 596   m_text->AppendText(_("Results written to file: test.url\n"));
 597   m_text->AppendText(_("Done.\n"));
 598   m_text->AppendText(_("=== URL test ends ===\n"));
 599
 600   delete data;
 601 }
 602
 603 #endif
 604
 605 void MyFrame::OnSocketEvent(wxSocketEvent& event)
 606 {
 607   wxString s = _("OnSocketEvent: ");
 608
 609   switch(event.GetSocketEvent())
 610   {
 611     case wxSOCKET_INPUT      : s.Append(_("wxSOCKET_INPUT\n")); break;
 612     case wxSOCKET_LOST       : s.Append(_("wxSOCKET_LOST\n")); break;
 613     case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
 614     default                  : s.Append(_("Unexpected event !\n")); break;
 615   }
 616
 617   m_text->AppendText(s);
 618   UpdateStatusBar();
 619 }
 620
 621 // convenience functions
 622
 623 void MyFrame::UpdateStatusBar()
 624 {
 625   wxString s;
 626
 627   if (!m_sock->IsConnected())
 628   {
 629     s.Printf(_("Not connected"));
 630   }
 631   else
 632   {
 633     wxIPV4address addr;
 634
 635     m_sock->GetPeer(addr);
 636     s.Printf(_("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
 637   }
 638
 639 #if wxUSE_STATUSBAR
 640   SetStatusText(s, 1);
 641 #endif // wxUSE_STATUSBAR
 642
 643   m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
 644   m_menuSocket->Enable(CLIENT_TEST1, m_sock->IsConnected() && !m_busy);
 645   m_menuSocket->Enable(CLIENT_TEST2, m_sock->IsConnected() && !m_busy);
 646   m_menuSocket->Enable(CLIENT_TEST3, m_sock->IsConnected() && !m_busy);
 647   m_menuSocket->Enable(CLIENT_CLOSE, m_sock->IsConnected());
 648 }