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(__WXMOTIF__)
  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\n"
 214                              "Client ready\n"),
 215                            wxDefaultPosition, wxDefaultSize,
 216                            wxTE_MULTILINE | wxTE_READONLY);
 217
 218   // Create the socket
 219   m_sock = new wxSocketClient();
 220
 221   // Setup the event handler and subscribe to most events
 222   m_sock->SetEventHandler(*this, SOCKET_ID);
 223   m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG |
 224                     wxSOCKET_INPUT_FLAG |
 225                     wxSOCKET_LOST_FLAG);
 226   m_sock->Notify(TRUE);
 227
 228   m_busy = FALSE;
 229   UpdateStatusBar();
 230 }
 231
 232 MyFrame::~MyFrame()
 233 {
 234   // No delayed deletion here, as the frame is dying anyway
 235   delete m_sock;
 236 }
 237
 238 // event handlers
 239
 240 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 241 {
 242   // TRUE is to force the frame to close
 243   Close(TRUE);
 244 }
 245
 246 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 247 {
 248   wxMessageBox(_("wxSocket demo: Client\n"
 249                  "(c) 1999 Guillermo Rodriguez Garcia\n"),
 250                _("About Client"),
 251                wxOK | wxICON_INFORMATION, this);
 252 }
 253
 254 void MyFrame::OnOpenConnection(wxCommandEvent& WXUNUSED(event))
 255 {
 256   wxIPV4address addr;
 257
 258   m_menuSocket->Enable(CLIENT_OPEN, FALSE);
 259   m_menuSocket->Enable(CLIENT_CLOSE, FALSE);
 260
 261   // Ask user for server address
 262   wxString hostname = wxGetTextFromUser(
 263     _("Enter the address of the wxSocket demo server:"),
 264     _("Connect ..."),
 265     _("localhost"));
 266
 267   addr.Hostname(hostname);
 268   addr.Service(3000);
 269
 270   // Mini-tutorial for Connect() :-)
 271   // ---------------------------
 272   //
 273   // There are two ways to use Connect(): blocking and non-blocking,
 274   // depending on the value passed as the 'wait' (2nd) parameter.
 275   //
 276   // Connect(addr, TRUE) will wait until the connection completes,
 277   // returning TRUE on success and FALSE on failure. This call blocks
 278   // the GUI (this might be changed in future releases to honour the
 279   // wxSOCKET_BLOCK flag).
 280   //
 281   // Connect(addr, FALSE) will issue a nonblocking connection request
 282   // and return immediately. If the return value is TRUE, then the
 283   // connection has been already succesfully established. If it is
 284   // FALSE, you must wait for the request to complete, either with
 285   // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
 286   // events (please read the documentation).
 287   //
 288   // WaitOnConnect() itself never blocks the GUI (this might change
 289   // in the future to honour the wxSOCKET_BLOCK flag). This call will
 290   // return FALSE on timeout, or TRUE if the connection request
 291   // completes, which in turn might mean:
 292   //
 293   //   a) That the connection was successfully established
 294   //   b) That the connection request failed (for example, because
 295   //      it was refused by the peer.
 296   //
 297   // Use IsConnected() to distinguish between these two.
 298   //
 299   // So, in a brief, you should do one of the following things:
 300   //
 301   // For blocking Connect:
 302   //
 303   //   bool success = client->Connect(addr, TRUE);
 304   //
 305   // For nonblocking Connect:
 306   //
 307   //   client->Connect(addr, FALSE);
 308   //
 309   //   bool waitmore = TRUE;
 310   //   while (! client->WaitOnConnect(seconds, millis) && waitmore )
 311   //   {
 312   //     // possibly give some feedback to the user,
 313   //     // update waitmore if needed.
 314   //   }
 315   //   bool success = client->IsConnected();
 316   //
 317   // And that's all :-)
 318
 319   m_text->AppendText(_("\nTrying to connect (timeout = 10 sec) ...\n"));
 320   m_sock->Connect(addr, FALSE);
 321   m_sock->WaitOnConnect(10);
 322
 323   if (m_sock->IsConnected())
 324     m_text->AppendText(_("Succeeded ! Connection established\n"));
 325   else
 326   {
 327     m_sock->Close();
 328     m_text->AppendText(_("Failed ! Unable to connect\n"));
 329     wxMessageBox(_("Can't connect to the specified host"), _("Alert !"));
 330   }
 331
 332   UpdateStatusBar();
 333 }
 334
 335 void MyFrame::OnTest1(wxCommandEvent& WXUNUSED(event))
 336 {
 337   const char *buf1;
 338   char       *buf2;
 339   unsigned char len;
 340
 341   // Disable socket menu entries (exception: Close Session)
 342   m_busy = TRUE;
 343   UpdateStatusBar();
 344
 345   m_text->AppendText(_("\n=== Test 1 begins ===\n"));
 346
 347   // Tell the server which test we are running
 348   unsigned char c = 0xBE;
 349   m_sock->Write(&c, 1);
 350
 351   // Send some data and read it back. We know the size of the
 352   // buffer, so we can specify the exact number of bytes to be
 353   // sent or received and use the wxSOCKET_WAITALL flag. Also,
 354   // we have disabled menu entries which could interfere with
 355   // the test, so we can safely avoid the wxSOCKET_BLOCK flag.
 356   //
 357   // First we send a byte with the length of the string, then
 358   // we send the string itself (do NOT try to send any integral
 359   // value larger than a byte "as is" across the network, or
 360   // you might be in trouble! Ever heard about big and little
 361   // endian computers?)
 362
 363   m_sock->SetFlags(wxSOCKET_WAITALL);
 364
 365   buf1 = _("Test string (less than 256 chars!)");
 366   len  = wxStrlen(buf1) + 1;
 367   buf2 = new char[len];
 368
 369   m_text->AppendText(_("Sending a test buffer to the server ..."));
 370   m_sock->Write(&len, 1);
 371   m_sock->Write(buf1, len);
 372   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 373
 374   m_text->AppendText(_("Receiving the buffer back from server ..."));
 375   m_sock->Read(buf2, len);
 376   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 377
 378   m_text->AppendText(_("Comparing the two buffers ..."));
 379   if (memcmp(buf1, buf2, len) != 0)
 380   {
 381     m_text->AppendText(_("failed!\n"));
 382     m_text->AppendText(_("Test 1 failed !\n"));
 383   }
 384   else
 385   {
 386     m_text->AppendText(_("done\n"));
 387     m_text->AppendText(_("Test 1 passed !\n"));
 388   }
 389   m_text->AppendText(_("=== Test 1 ends ===\n"));
 390
 391   delete[] buf2;
 392   m_busy = FALSE;
 393   UpdateStatusBar();
 394 }
 395
 396 void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
 397 {
 398   char *msg1;
 399   char *msg2;
 400   size_t len;
 401
 402   // Disable socket menu entries (exception: Close Session)
 403   m_busy = TRUE;
 404   UpdateStatusBar();
 405
 406   m_text->AppendText(_("\n=== Test 2 begins ===\n"));
 407
 408   // Tell the server which test we are running
 409   unsigned char c = 0xCE;
 410   m_sock->Write(&c, 1);
 411
 412   // Here we use ReadMsg and WriteMsg to send messages with
 413   // a header with size information. Also, the reception is
 414   // event triggered, so we test input events as well.
 415   //
 416   // We need to set no flags here (ReadMsg and WriteMsg are
 417   // not affected by flags)
 418
 419   m_sock->SetFlags(wxSOCKET_WAITALL);
 420
 421   wxString s = wxGetTextFromUser(
 422     _("Enter an arbitrary string to send to the server:"),
 423     _("Test 2 ..."),
 424     _("Yes I like wxWindows!"));
 425
 426   msg1 = (char *)s.c_str();
 427   len  = wxStrlen(msg1) + 1;
 428   msg2 = new char[len];
 429
 430   m_text->AppendText(_("Sending the string with WriteMsg ..."));
 431   m_sock->WriteMsg(msg1, len);
 432   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 433   m_text->AppendText(_("Waiting for an event (timeout = 2 sec)\n"));
 434
 435   // Wait until data available (will also return if the connection is lost)
 436   m_sock->WaitForRead(2);
 437
 438   if (m_sock->IsData())
 439   {
 440     m_text->AppendText(_("Reading the string back with ReadMsg ..."));
 441     m_sock->ReadMsg(msg2, len);
 442     m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 443     m_text->AppendText(_("Comparing the two buffers ..."));
 444     if (memcmp(msg1, msg2, len) != 0)
 445     {
 446       m_text->AppendText(_("failed!\n"));
 447       m_text->AppendText(_("Test 2 failed !\n"));
 448     }
 449     else
 450     {
 451       m_text->AppendText(_("done\n"));
 452       m_text->AppendText(_("Test 2 passed !\n"));
 453     }
 454   }
 455   else
 456     m_text->AppendText(_("Timeout ! Test 2 failed.\n"));
 457
 458   m_text->AppendText(_("=== Test 2 ends ===\n"));
 459
 460   delete[] msg2;
 461   m_busy = FALSE;
 462   UpdateStatusBar();
 463 }
 464
 465 void MyFrame::OnTest3(wxCommandEvent& WXUNUSED(event))
 466 {
 467   char *buf1;
 468   char *buf2;
 469   unsigned char len;
 470
 471   // Disable socket menu entries (exception: Close Session)
 472   m_busy = TRUE;
 473   UpdateStatusBar();
 474
 475   m_text->AppendText(_("\n=== Test 3 begins ===\n"));
 476
 477   // Tell the server which test we are running
 478   unsigned char c = 0xDE;
 479   m_sock->Write(&c, 1);
 480
 481   // This test also is similar to the first one but it sends a
 482   // large buffer so that wxSocket is actually forced to split
 483   // it into pieces and take care of sending everything before
 484   // returning.
 485
 486   m_sock->SetFlags(wxSOCKET_WAITALL);
 487
 488   // Note that len is in kbytes here!
 489   len  = 32;
 490   buf1 = new char[len * 1024];
 491   buf2 = new char[len * 1024];
 492
 493   for (int i = 0; i < len * 1024; i ++)
 494     buf1[i] = (char)(i % 256);
 495
 496   m_text->AppendText(_("Sending a large buffer (32K) to the server ..."));
 497   m_sock->Write(&len, 1);
 498   m_sock->Write(buf1, len * 1024);
 499   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 500
 501   m_text->AppendText(_("Receiving the buffer back from server ..."));
 502   m_sock->Read(buf2, len * 1024);
 503   m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 504
 505   m_text->AppendText(_("Comparing the two buffers ..."));
 506   if (memcmp(buf1, buf2, len) != 0)
 507   {
 508     m_text->AppendText(_("failed!\n"));
 509     m_text->AppendText(_("Test 3 failed !\n"));
 510   }
 511   else
 512   {
 513     m_text->AppendText(_("done\n"));
 514     m_text->AppendText(_("Test 3 passed !\n"));
 515   }
 516   m_text->AppendText(_("=== Test 3 ends ===\n"));
 517
 518   delete[] buf2;
 519   m_busy = FALSE;
 520   UpdateStatusBar();
 521 }
 522
 523 void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
 524 {
 525   m_sock->Close();
 526   UpdateStatusBar();
 527 }
 528
 529 void MyFrame::OnDatagram(wxCommandEvent& WXUNUSED(event))
 530 {
 531   m_text->AppendText(_("\n=== Datagram test begins ===\n"));
 532   m_text->AppendText(_("Sorry, not implemented\n"));
 533   m_text->AppendText(_("=== Datagram test ends ===\n"));
 534 }
 535
 536 void MyFrame::OnTestURL(wxCommandEvent& WXUNUSED(event))
 537 {
 538   // Note that we are creating a new socket here, so this
 539   // won't mess with the client/server demo.
 540
 541   // Ask for the URL
 542   m_text->AppendText(_("\n=== URL test begins ===\n"));
 543   wxString urlname = wxGetTextFromUser(_("Enter an URL to get"),
 544                                        _("URL:"),
 545                                        _T("http://localhost"));
 546
 547   // Parse the URL
 548   wxURL url(urlname);
 549   if (url.GetError() != wxURL_NOERR)
 550   {
 551     m_text->AppendText(_("Error: couldn't parse URL\n"));
 552     m_text->AppendText(_("=== URL test ends ===\n"));
 553     return;
 554   }
 555
 556   // Try to get the input stream (connects to the given URL)
 557   m_text->AppendText(_("Trying to establish connection...\n"));
 558   wxYield();
 559   wxInputStream *data = url.GetInputStream();
 560   if (!data)
 561   {
 562     m_text->AppendText(_("Error: couldn't read from URL\n"));
 563     m_text->AppendText(_("=== URL test ends ===\n"));
 564     return;
 565   }
 566
 567   // Print the contents type and file size
 568   wxString s;
 569   s.Printf(_("Contents type: %s\n"
 570              "File size: %i\n"
 571              "Starting to download...\n"),
 572              url.GetProtocol().GetContentType().c_str(),
 573              data->GetSize());
 574   m_text->AppendText(s);
 575   wxYield();
 576
 577   // Get the data
 578   wxFileOutputStream sout(wxString("test.url"));
 579   if (!sout.Ok())
 580   {
 581     m_text->AppendText(_("Error: couldn't open file for output\n"));
 582     m_text->AppendText(_("=== URL test ends ===\n"));
 583     return;
 584   }
 585
 586   data->Read(sout);
 587   m_text->AppendText(_("Results written to file: test.url\n"));
 588   m_text->AppendText(_("Done.\n"));
 589   m_text->AppendText(_("=== URL test ends ===\n"));
 590
 591   delete data;
 592 }
 593
 594 void MyFrame::OnSocketEvent(wxSocketEvent& event)
 595 {
 596   wxString s = _("OnSocketEvent: ");
 597
 598   switch(event.GetSocketEvent())
 599   {
 600     case wxSOCKET_INPUT      : s.Append(_("wxSOCKET_INPUT\n")); break;
 601     case wxSOCKET_LOST       : s.Append(_("wxSOCKET_LOST\n")); break;
 602     case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
 603     default                  : s.Append(_("Unexpected event !\n")); break;
 604   }
 605
 606   m_text->AppendText(s);
 607   UpdateStatusBar();
 608 }
 609
 610 // convenience functions
 611
 612 void MyFrame::UpdateStatusBar()
 613 {
 614   wxString s;
 615
 616   if (!m_sock->IsConnected())
 617   {
 618     s.Printf(_("Not connected"));
 619   }
 620   else
 621   {
 622     wxIPV4address addr;
 623
 624     m_sock->GetPeer(addr);
 625     s.Printf(_("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
 626   }
 627
 628   SetStatusText(s, 1);
 629
 630   m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
 631   m_menuSocket->Enable(CLIENT_TEST1, m_sock->IsConnected() && !m_busy);
 632   m_menuSocket->Enable(CLIENT_TEST2, m_sock->IsConnected() && !m_busy);
 633   m_menuSocket->Enable(CLIENT_TEST3, m_sock->IsConnected() && !m_busy);
 634   m_menuSocket->Enable(CLIENT_CLOSE, m_sock->IsConnected());
 635 }