samples/sockets/server.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        server.cpp
   3 // Purpose:     Server for wxSocket demo
   4 // Author:      Guillermo Rodriguez Garcia <guille@iies.es>
   5 // Created:     1999/09/19
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 1999 Guillermo Rodriguez Garcia
   8 //              (c) 2009 Vadim Zeitlin
   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/busyinfo.h"
  33 #include "wx/socket.h"
  34
  35 // this example is currently written to use only IP or only IPv6 sockets, it
  36 // should be extended to allow using either in the future
  37 #if wxUSE_IPV6
  38     typedef wxIPV6address IPaddress;
  39 #else
  40     typedef wxIPV4address IPaddress;
  41 #endif
  42
  43 // --------------------------------------------------------------------------
  44 // resources
  45 // --------------------------------------------------------------------------
  46
  47 // the application icon
  48 #ifndef wxHAS_IMAGES_IN_RESOURCES
  49     #include "../sample.xpm"
  50 #endif
  51
  52 // --------------------------------------------------------------------------
  53 // classes
  54 // --------------------------------------------------------------------------
  55
  56 // Define a new application type
  57 class MyApp : public wxApp
  58 {
  59 public:
  60   virtual bool OnInit();
  61 };
  62
  63 // Define a new frame type: this is going to be our main frame
  64 class MyFrame : public wxFrame
  65 {
  66 public:
  67   MyFrame();
  68   ~MyFrame();
  69
  70   // event handlers (these functions should _not_ be virtual)
  71   void OnUDPTest(wxCommandEvent& event);
  72   void OnWaitForAccept(wxCommandEvent& event);
  73   void OnQuit(wxCommandEvent& event);
  74   void OnAbout(wxCommandEvent& event);
  75   void OnServerEvent(wxSocketEvent& event);
  76   void OnSocketEvent(wxSocketEvent& event);
  77
  78   void Test1(wxSocketBase *sock);
  79   void Test2(wxSocketBase *sock);
  80   void Test3(wxSocketBase *sock);
  81
  82   // convenience functions
  83   void UpdateStatusBar();
  84
  85 private:
  86   wxSocketServer *m_server;
  87   wxTextCtrl     *m_text;
  88   wxMenu         *m_menuFile;
  89   wxMenuBar      *m_menuBar;
  90   bool            m_busy;
  91   int             m_numClients;
  92
  93   // any class wishing to process wxWidgets events must use this macro
  94   DECLARE_EVENT_TABLE()
  95 };
  96
  97 // simple helper class to log start and end of each test
  98 class TestLogger
  99 {
 100 public:
 101     TestLogger(const wxString& name) : m_name(name)
 102     {
 103         wxLogMessage("=== %s begins ===", m_name);
 104     }
 105
 106     ~TestLogger()
 107     {
 108         wxLogMessage("=== %s ends ===", m_name);
 109     }
 110
 111 private:
 112     const wxString m_name;
 113 };
 114
 115 // --------------------------------------------------------------------------
 116 // constants
 117 // --------------------------------------------------------------------------
 118
 119 // IDs for the controls and the menu commands
 120 enum
 121 {
 122   // menu items
 123   SERVER_UDPTEST = 10,
 124   SERVER_WAITFORACCEPT,
 125   SERVER_QUIT = wxID_EXIT,
 126   SERVER_ABOUT = wxID_ABOUT,
 127
 128   // id for sockets
 129   SERVER_ID = 100,
 130   SOCKET_ID
 131 };
 132
 133 // --------------------------------------------------------------------------
 134 // event tables and other macros for wxWidgets
 135 // --------------------------------------------------------------------------
 136
 137 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 138   EVT_MENU(SERVER_QUIT,  MyFrame::OnQuit)
 139   EVT_MENU(SERVER_ABOUT, MyFrame::OnAbout)
 140   EVT_MENU(SERVER_UDPTEST, MyFrame::OnUDPTest)
 141   EVT_MENU(SERVER_WAITFORACCEPT, MyFrame::OnWaitForAccept)
 142   EVT_SOCKET(SERVER_ID,  MyFrame::OnServerEvent)
 143   EVT_SOCKET(SOCKET_ID,  MyFrame::OnSocketEvent)
 144 END_EVENT_TABLE()
 145
 146 IMPLEMENT_APP(MyApp)
 147
 148
 149 // ==========================================================================
 150 // implementation
 151 // ==========================================================================
 152
 153 // --------------------------------------------------------------------------
 154 // the application class
 155 // --------------------------------------------------------------------------
 156
 157 bool MyApp::OnInit()
 158 {
 159   if ( !wxApp::OnInit() )
 160       return false;
 161
 162   // Create the main application window
 163   MyFrame *frame = new MyFrame();
 164
 165   // Show it
 166   frame->Show(true);
 167
 168   // Success
 169   return true;
 170 }
 171
 172 // --------------------------------------------------------------------------
 173 // main frame
 174 // --------------------------------------------------------------------------
 175
 176 // frame constructor
 177
 178 MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
 179                              _("wxSocket demo: Server"),
 180                              wxDefaultPosition, wxSize(300, 200))
 181 {
 182   // Give the frame an icon
 183   SetIcon(wxICON(sample));
 184
 185   // Make menus
 186   m_menuFile = new wxMenu();
 187   m_menuFile->Append(SERVER_WAITFORACCEPT, "&Wait for connection\tCtrl-W");
 188   m_menuFile->Append(SERVER_UDPTEST, "&UDP test\tCtrl-U");
 189   m_menuFile->AppendSeparator();
 190   m_menuFile->Append(SERVER_ABOUT, _("&About\tCtrl-A"), _("Show about dialog"));
 191   m_menuFile->AppendSeparator();
 192   m_menuFile->Append(SERVER_QUIT, _("E&xit\tAlt-X"), _("Quit server"));
 193
 194   // Append menus to the menubar
 195   m_menuBar = new wxMenuBar();
 196   m_menuBar->Append(m_menuFile, _("&File"));
 197   SetMenuBar(m_menuBar);
 198
 199 #if wxUSE_STATUSBAR
 200   // Status bar
 201   CreateStatusBar(2);
 202 #endif // wxUSE_STATUSBAR
 203
 204   // Make a textctrl for logging
 205   m_text  = new wxTextCtrl(this, wxID_ANY,
 206                            _("Welcome to wxSocket demo: Server\n"),
 207                            wxDefaultPosition, wxDefaultSize,
 208                            wxTE_MULTILINE | wxTE_READONLY);
 209   delete wxLog::SetActiveTarget(new wxLogTextCtrl(m_text));
 210
 211   // Create the address - defaults to localhost:0 initially
 212   IPaddress addr;
 213   addr.Service(3000);
 214
 215   wxLogMessage("Creating server at %s:%u", addr.IPAddress(), addr.Service());
 216
 217   // Create the socket
 218   m_server = new wxSocketServer(addr);
 219
 220   // We use IsOk() here to see if the server is really listening
 221   if (! m_server->IsOk())
 222   {
 223     wxLogMessage("Could not listen at the specified port !");
 224     return;
 225   }
 226
 227   IPaddress addrReal;
 228   if ( !m_server->GetLocal(addrReal) )
 229   {
 230     wxLogMessage("ERROR: couldn't get the address we bound to");
 231   }
 232   else
 233   {
 234     wxLogMessage("Server listening at %s:%u",
 235                  addrReal.IPAddress(), addrReal.Service());
 236   }
 237
 238   // Setup the event handler and subscribe to connection events
 239   m_server->SetEventHandler(*this, SERVER_ID);
 240   m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
 241   m_server->Notify(true);
 242
 243   m_busy = false;
 244   m_numClients = 0;
 245   UpdateStatusBar();
 246 }
 247
 248 MyFrame::~MyFrame()
 249 {
 250   // No delayed deletion here, as the frame is dying anyway
 251   delete m_server;
 252 }
 253
 254 // event handlers
 255
 256 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 257 {
 258   // true is to force the frame to close
 259   Close(true);
 260 }
 261
 262 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 263 {
 264   wxMessageBox(_("wxSocket demo: Server\n(c) 1999 Guillermo Rodriguez Garcia\n"),
 265                _("About Server"),
 266                wxOK | wxICON_INFORMATION, this);
 267 }
 268
 269 void MyFrame::OnUDPTest(wxCommandEvent& WXUNUSED(event))
 270 {
 271     TestLogger logtest("UDP test");
 272
 273     IPaddress addr;
 274     addr.Service(3000);
 275     wxDatagramSocket sock(addr);
 276
 277     char buf[1024];
 278     size_t n = sock.RecvFrom(addr, buf, sizeof(buf)).LastCount();
 279     if ( !n )
 280     {
 281         wxLogMessage("ERROR: failed to receive data");
 282         return;
 283     }
 284
 285     wxLogMessage("Received \"%s\" from %s:%u.",
 286                  wxString::From8BitData(buf, n),
 287                  addr.IPAddress(), addr.Service());
 288
 289     for ( size_t i = 0; i < n; i++ )
 290     {
 291         char& c = buf[i];
 292         if ( (c >= 'A' && c <= 'M') || (c >= 'a' && c <= 'm') )
 293             c += 13;
 294         else if ( (c >= 'N' && c <= 'Z') || (c >= 'n' && c <= 'z') )
 295             c -= 13;
 296     }
 297
 298     if ( sock.SendTo(addr, buf, n).LastCount() != n )
 299     {
 300         wxLogMessage("ERROR: failed to send data");
 301         return;
 302     }
 303 }
 304
 305 void MyFrame::OnWaitForAccept(wxCommandEvent& WXUNUSED(event))
 306 {
 307     TestLogger logtest("WaitForAccept() test");
 308
 309     wxBusyInfo("Waiting for connection for 10 seconds...", this);
 310     if ( m_server->WaitForAccept(10) )
 311         wxLogMessage("Accepted client connection.");
 312     else
 313         wxLogMessage("Connection error or timeout expired.");
 314 }
 315
 316 void MyFrame::Test1(wxSocketBase *sock)
 317 {
 318   TestLogger logtest("Test 1");
 319
 320   // Receive data from socket and send it back. We will first
 321   // get a byte with the buffer size, so we can specify the
 322   // exact size and use the wxSOCKET_WAITALL flag. Also, we
 323   // disabled input events so we won't have unwanted reentrance.
 324   // This way we can avoid the infamous wxSOCKET_BLOCK flag.
 325
 326   sock->SetFlags(wxSOCKET_WAITALL);
 327
 328   // Read the size
 329   unsigned char len;
 330   sock->Read(&len, 1);
 331   wxCharBuffer buf(len);
 332
 333   // Read the data
 334   sock->Read(buf.data(), len);
 335   wxLogMessage("Got the data, sending it back");
 336
 337   // Write it back
 338   sock->Write(buf, len);
 339 }
 340
 341 void MyFrame::Test2(wxSocketBase *sock)
 342 {
 343   char buf[4096];
 344
 345   TestLogger logtest("Test 2");
 346
 347   // We don't need to set flags because ReadMsg and WriteMsg
 348   // are not affected by them anyway.
 349
 350   // Read the message
 351   wxUint32 len = sock->ReadMsg(buf, sizeof(buf)).LastCount();
 352   if ( !len )
 353   {
 354       wxLogError("Failed to read message.");
 355       return;
 356   }
 357
 358   wxLogMessage("Got \"%s\" from client.", wxString::FromUTF8(buf, len));
 359   wxLogMessage("Sending the data back");
 360
 361   // Write it back
 362   sock->WriteMsg(buf, len);
 363 }
 364
 365 void MyFrame::Test3(wxSocketBase *sock)
 366 {
 367   TestLogger logtest("Test 3");
 368
 369   // This test is similar to the first one, but the len is
 370   // expressed in kbytes - this tests large data transfers.
 371
 372   sock->SetFlags(wxSOCKET_WAITALL);
 373
 374   // Read the size
 375   unsigned char len;
 376   sock->Read(&len, 1);
 377   wxCharBuffer buf(len*1024);
 378
 379   // Read the data
 380   sock->Read(buf.data(), len * 1024);
 381   wxLogMessage("Got the data, sending it back");
 382
 383   // Write it back
 384   sock->Write(buf, len * 1024);
 385 }
 386
 387 void MyFrame::OnServerEvent(wxSocketEvent& event)
 388 {
 389   wxString s = _("OnServerEvent: ");
 390   wxSocketBase *sock;
 391
 392   switch(event.GetSocketEvent())
 393   {
 394     case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
 395     default                  : s.Append(_("Unexpected event !\n")); break;
 396   }
 397
 398   m_text->AppendText(s);
 399
 400   // Accept new connection if there is one in the pending
 401   // connections queue, else exit. We use Accept(false) for
 402   // non-blocking accept (although if we got here, there
 403   // should ALWAYS be a pending connection).
 404
 405   sock = m_server->Accept(false);
 406
 407   if (sock)
 408   {
 409     IPaddress addr;
 410     if ( !sock->GetPeer(addr) )
 411     {
 412       wxLogMessage("New connection from unknown client accepted.");
 413     }
 414     else
 415     {
 416       wxLogMessage("New client connection from %s:%u accepted",
 417                    addr.IPAddress(), addr.Service());
 418     }
 419   }
 420   else
 421   {
 422     wxLogMessage("Error: couldn't accept a new connection");
 423     return;
 424   }
 425
 426   sock->SetEventHandler(*this, SOCKET_ID);
 427   sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 428   sock->Notify(true);
 429
 430   m_numClients++;
 431   UpdateStatusBar();
 432 }
 433
 434 void MyFrame::OnSocketEvent(wxSocketEvent& event)
 435 {
 436   wxString s = _("OnSocketEvent: ");
 437   wxSocketBase *sock = event.GetSocket();
 438
 439   // First, print a message
 440   switch(event.GetSocketEvent())
 441   {
 442     case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
 443     case wxSOCKET_LOST  : s.Append(_("wxSOCKET_LOST\n")); break;
 444     default             : s.Append(_("Unexpected event !\n")); break;
 445   }
 446
 447   m_text->AppendText(s);
 448
 449   // Now we process the event
 450   switch(event.GetSocketEvent())
 451   {
 452     case wxSOCKET_INPUT:
 453     {
 454       // We disable input events, so that the test doesn't trigger
 455       // wxSocketEvent again.
 456       sock->SetNotify(wxSOCKET_LOST_FLAG);
 457
 458       // Which test are we going to run?
 459       unsigned char c;
 460       sock->Read(&c, 1);
 461
 462       switch (c)
 463       {
 464         case 0xBE: Test1(sock); break;
 465         case 0xCE: Test2(sock); break;
 466         case 0xDE: Test3(sock); break;
 467         default:
 468           wxLogMessage("Unknown test id received from client");
 469       }
 470
 471       // Enable input events again.
 472       sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
 473       break;
 474     }
 475     case wxSOCKET_LOST:
 476     {
 477       m_numClients--;
 478
 479       // Destroy() should be used instead of delete wherever possible,
 480       // due to the fact that wxSocket uses 'delayed events' (see the
 481       // documentation for wxPostEvent) and we don't want an event to
 482       // arrive to the event handler (the frame, here) after the socket
 483       // has been deleted. Also, we might be doing some other thing with
 484       // the socket at the same time; for example, we might be in the
 485       // middle of a test or something. Destroy() takes care of all
 486       // this for us.
 487
 488       wxLogMessage("Deleting socket.");
 489       sock->Destroy();
 490       break;
 491     }
 492     default: ;
 493   }
 494
 495   UpdateStatusBar();
 496 }
 497
 498 // convenience functions
 499
 500 void MyFrame::UpdateStatusBar()
 501 {
 502 #if wxUSE_STATUSBAR
 503   wxString s;
 504   s.Printf(_("%d clients connected"), m_numClients);
 505   SetStatusText(s, 1);
 506 #endif // wxUSE_STATUSBAR
 507 }