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