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   // Disable socket menu entries (exception: Close Session)
 346   m_busy = true;
 347   UpdateStatusBar();
 348
 349   m_text->AppendText(_("\n=== Test 1 begins ===\n"));
 350
 351   // Tell the server which test we are running
 352   unsigned char c = 0xBE;
 353   m_sock->Write(&c, 1);
 354
 355   // Send some data and read it back. We know the size of the
 356   // buffer, so we can specify the exact number of bytes to be
 357   // sent or received and use the wxSOCKET_WAITALL flag. Also,
 358   // we have disabled menu entries which could interfere with
 359   // the test, so we can safely avoid the wxSOCKET_BLOCK flag.
 360   //
 361   // First we send a byte with the length of the string, then
 362   // we send the string itself (do NOT try to send any integral
 363   // value larger than a byte "as is" across the network, or
 364   // you might be in trouble! Ever heard about big and little
 365   // endian computers?)
 366
 367   m_sock->SetFlags(wxSOCKET_WAITALL);
 368
 369   const wxChar *buf1 = _T("Test string (less than 256 chars!)");
 370   unsigned char len  = (unsigned char)((wxStrlen(buf1) + 1)*sizeof(wxChar));
 371   wxChar *buf2 = new wxChar[wxStrlen(buf1) + 1];
 372
 373   m_text->AppendText(_("Sending a test buffer to the server ..."));
 374   m_sock->Write(&len, 1);
 375   m_sock->Write(buf1, len);
 376   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 377
 378   m_text->AppendText(_("Receiving the buffer back from server ..."));
 379   m_sock->Read(buf2, len);
 380   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 381
 382   m_text->AppendText(_("Comparing the two buffers ..."));
 383   if (memcmp(buf1, buf2, len) != 0)
 384   {
 385     m_text->AppendText(_("failed!\n"));
 386     m_text->AppendText(_("Test 1 failed !\n"));
 387   }
 388   else
 389   {
 390     m_text->AppendText(_("done\n"));
 391     m_text->AppendText(_("Test 1 passed !\n"));
 392   }
 393   m_text->AppendText(_("=== Test 1 ends ===\n"));
 394
 395   delete[] buf2;
 396   m_busy = false;
 397   UpdateStatusBar();
 398 }
 399
 400 void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
 401 {
 402   const wxChar *msg1;
 403   wxChar *msg2;
 404   size_t len;
 405
 406   // Disable socket menu entries (exception: Close Session)
 407   m_busy = true;
 408   UpdateStatusBar();
 409
 410   m_text->AppendText(_("\n=== Test 2 begins ===\n"));
 411
 412   // Tell the server which test we are running
 413   unsigned char c = 0xCE;
 414   m_sock->Write(&c, 1);
 415
 416   // Here we use ReadMsg and WriteMsg to send messages with
 417   // a header with size information. Also, the reception is
 418   // event triggered, so we test input events as well.
 419   //
 420   // We need to set no flags here (ReadMsg and WriteMsg are
 421   // not affected by flags)
 422
 423   m_sock->SetFlags(wxSOCKET_WAITALL);
 424
 425   wxString s = wxGetTextFromUser(
 426     _("Enter an arbitrary string to send to the server:"),
 427     _("Test 2 ..."),
 428     _("Yes I like wxWidgets!"));
 429
 430   msg1 = s.c_str();
 431   len  = (wxStrlen(msg1) + 1) * sizeof(wxChar);
 432   msg2 = new wxChar[wxStrlen(msg1) + 1];
 433
 434   m_text->AppendText(_("Sending the string with WriteMsg ..."));
 435   m_sock->WriteMsg(msg1, len);
 436   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 437   m_text->AppendText(_("Waiting for an event (timeout = 2 sec)\n"));
 438
 439   // Wait until data available (will also return if the connection is lost)
 440   m_sock->WaitForRead(2);
 441
 442   if (m_sock->IsData())
 443   {
 444     m_text->AppendText(_("Reading the string back with ReadMsg ..."));
 445     m_sock->ReadMsg(msg2, len);
 446     m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 447     m_text->AppendText(_("Comparing the two buffers ..."));
 448     if (memcmp(msg1, msg2, len) != 0)
 449     {
 450       m_text->AppendText(_("failed!\n"));
 451       m_text->AppendText(_("Test 2 failed !\n"));
 452     }
 453     else
 454     {
 455       m_text->AppendText(_("done\n"));
 456       m_text->AppendText(_("Test 2 passed !\n"));
 457     }
 458   }
 459   else
 460     m_text->AppendText(_("Timeout ! Test 2 failed.\n"));
 461
 462   m_text->AppendText(_("=== Test 2 ends ===\n"));
 463
 464   delete[] msg2;
 465   m_busy = false;
 466   UpdateStatusBar();
 467 }
 468
 469 void MyFrame::OnTest3(wxCommandEvent& WXUNUSED(event))
 470 {
 471   char *buf1;
 472   char *buf2;
 473   unsigned char len;
 474
 475   // Disable socket menu entries (exception: Close Session)
 476   m_busy = true;
 477   UpdateStatusBar();
 478
 479   m_text->AppendText(_("\n=== Test 3 begins ===\n"));
 480
 481   // Tell the server which test we are running
 482   unsigned char c = 0xDE;
 483   m_sock->Write(&c, 1);
 484
 485   // This test also is similar to the first one but it sends a
 486   // large buffer so that wxSocket is actually forced to split
 487   // it into pieces and take care of sending everything before
 488   // returning.
 489
 490   m_sock->SetFlags(wxSOCKET_WAITALL);
 491
 492   // Note that len is in kbytes here!
 493   len  = 32;
 494   buf1 = new char[len * 1024];
 495   buf2 = new char[len * 1024];
 496
 497   for (int i = 0; i < len * 1024; i ++)
 498     buf1[i] = (char)(i % 256);
 499
 500   m_text->AppendText(_("Sending a large buffer (32K) to the server ..."));
 501   m_sock->Write(&len, 1);
 502   m_sock->Write(buf1, len * 1024);
 503   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 504
 505   m_text->AppendText(_("Receiving the buffer back from server ..."));
 506   m_sock->Read(buf2, len * 1024);
 507   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 508
 509   m_text->AppendText(_("Comparing the two buffers ..."));
 510   if (memcmp(buf1, buf2, len) != 0)
 511   {
 512     m_text->AppendText(_("failed!\n"));
 513     m_text->AppendText(_("Test 3 failed !\n"));
 514   }
 515   else
 516   {
 517     m_text->AppendText(_("done\n"));
 518     m_text->AppendText(_("Test 3 passed !\n"));
 519   }
 520   m_text->AppendText(_("=== Test 3 ends ===\n"));
 521
 522   delete[] buf2;
 523   m_busy = false;
 524   UpdateStatusBar();
 525 }
 526
 527 void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
 528 {
 529   m_sock->Close();
 530   UpdateStatusBar();
 531 }
 532
 533 void MyFrame::OnDatagram(wxCommandEvent& WXUNUSED(event))
 534 {
 535   m_text->AppendText(_("\n=== Datagram test begins ===\n"));
 536   m_text->AppendText(_("Sorry, not implemented\n"));
 537   m_text->AppendText(_("=== Datagram test ends ===\n"));
 538 }
 539
 540 #if wxUSE_URL
 541
 542 void MyFrame::OnTestURL(wxCommandEvent& WXUNUSED(event))
 543 {
 544   // Note that we are creating a new socket here, so this
 545   // won't mess with the client/server demo.
 546
 547   // Ask for the URL
 548   m_text->AppendText(_("\n=== URL test begins ===\n"));
 549   wxString urlname = wxGetTextFromUser(_("Enter an URL to get"),
 550                                        _("URL:"),
 551                                        _T("http://localhost"));
 552
 553   // Parse the URL
 554   wxURL url(urlname);
 555   if (url.GetError() != wxURL_NOERR)
 556   {
 557     m_text->AppendText(_("Error: couldn't parse URL\n"));
 558     m_text->AppendText(_("=== URL test ends ===\n"));
 559     return;
 560   }
 561
 562   // Try to get the input stream (connects to the given URL)
 563   m_text->AppendText(_("Trying to establish connection...\n"));
 564   wxYield();
 565   wxInputStream *data = url.GetInputStream();
 566   if (!data)
 567   {
 568     m_text->AppendText(_("Error: couldn't read from URL\n"));
 569     m_text->AppendText(_("=== URL test ends ===\n"));
 570     return;
 571   }
 572
 573   // Print the contents type and file size
 574   wxString s;
 575   s.Printf(_("Contents type: %s\nFile size: %i\nStarting to download...\n"),
 576              url.GetProtocol().GetContentType().c_str(),
 577              data->GetSize());
 578   m_text->AppendText(s);
 579   wxYield();
 580
 581   // Get the data
 582   wxFile fileTest(wxT("test.url"), wxFile::write);
 583   wxFileOutputStream sout(fileTest);
 584   if (!sout.Ok())
 585   {
 586     m_text->AppendText(_("Error: couldn't open file for output\n"));
 587     m_text->AppendText(_("=== URL test ends ===\n"));
 588     return;
 589   }
 590
 591   data->Read(sout);
 592   m_text->AppendText(_("Results written to file: test.url\n"));
 593   m_text->AppendText(_("Done.\n"));
 594   m_text->AppendText(_("=== URL test ends ===\n"));
 595
 596   delete data;
 597 }
 598
 599 #endif
 600
 601 void MyFrame::OnSocketEvent(wxSocketEvent& event)
 602 {
 603   wxString s = _("OnSocketEvent: ");
 604
 605   switch(event.GetSocketEvent())
 606   {
 607     case wxSOCKET_INPUT      : s.Append(_("wxSOCKET_INPUT\n")); break;
 608     case wxSOCKET_LOST       : s.Append(_("wxSOCKET_LOST\n")); break;
 609     case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
 610     default                  : s.Append(_("Unexpected event !\n")); break;
 611   }
 612
 613   m_text->AppendText(s);
 614   UpdateStatusBar();
 615 }
 616
 617 // convenience functions
 618
 619 void MyFrame::UpdateStatusBar()
 620 {
 621   wxString s;
 622
 623   if (!m_sock->IsConnected())
 624   {
 625     s.Printf(_("Not connected"));
 626   }
 627   else
 628   {
 629     wxIPV4address addr;
 630
 631     m_sock->GetPeer(addr);
 632     s.Printf(_("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
 633   }
 634
 635 #if wxUSE_STATUSBAR
 636   SetStatusText(s, 1);
 637 #endif // wxUSE_STATUSBAR
 638
 639   m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
 640   m_menuSocket->Enable(CLIENT_TEST1, m_sock->IsConnected() && !m_busy);
 641   m_menuSocket->Enable(CLIENT_TEST2, m_sock->IsConnected() && !m_busy);
 642   m_menuSocket->Enable(CLIENT_TEST3, m_sock->IsConnected() && !m_busy);
 643   m_menuSocket->Enable(CLIENT_CLOSE, m_sock->IsConnected());
 644 }