samples/sockets/server.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        server.cpp
   3 // Purpose:     Server 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 "server.cpp"
  22 #  pragma interface "server.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
  39 // --------------------------------------------------------------------------
  40 // resources
  41 // --------------------------------------------------------------------------
  42
  43 // the application icon
  44 #if defined(__WXGTK__) || defined(__WXMOTIF__)
  45 #  include "mondrian.xpm"
  46 #endif
  47
  48 // --------------------------------------------------------------------------
  49 // classes
  50 // --------------------------------------------------------------------------
  51
  52 // Define a new application type
  53 class MyApp : public wxApp
  54 {
  55 public:
  56   virtual bool OnInit();
  57 };
  58
  59 // Define a new frame type: this is going to be our main frame
  60 class MyFrame : public wxFrame
  61 {
  62 public:
  63   MyFrame();
  64   ~MyFrame();
  65
  66   // event handlers (these functions should _not_ be virtual)
  67   void OnQuit(wxCommandEvent& event);
  68   void OnAbout(wxCommandEvent& event);
  69   void OnServerEvent(wxSocketEvent& event);
  70   void OnSocketEvent(wxSocketEvent& event);
  71
  72   void Test1(wxSocketBase *sock);
  73   void Test2(wxSocketBase *sock);
  74   void Test3(wxSocketBase *sock);
  75
  76   // convenience functions
  77   void UpdateStatusBar();
  78
  79 private:
  80   wxSocketServer *m_server;
  81   wxTextCtrl     *m_text;
  82   wxMenu         *m_menuFile;
  83   wxMenuBar      *m_menuBar;
  84   bool            m_busy;
  85   int             m_numClients;
  86
  87   // any class wishing to process wxWindows events must use this macro
  88   DECLARE_EVENT_TABLE()
  89 };
  90
  91 // --------------------------------------------------------------------------
  92 // constants
  93 // --------------------------------------------------------------------------
  94
  95 // IDs for the controls and the menu commands
  96 enum
  97 {
  98   // menu items
  99   SERVER_QUIT = 1000,
 100   SERVER_ABOUT,
 101
 102   // id for sockets
 103   SERVER_ID,
 104   SOCKET_ID
 105 };
 106
 107 // --------------------------------------------------------------------------
 108 // event tables and other macros for wxWindows
 109 // --------------------------------------------------------------------------
 110
 111 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 112   EVT_MENU(SERVER_QUIT,  MyFrame::OnQuit)
 113   EVT_MENU(SERVER_ABOUT, MyFrame::OnAbout)
 114   EVT_SOCKET(SERVER_ID,  MyFrame::OnServerEvent)
 115   EVT_SOCKET(SOCKET_ID,  MyFrame::OnSocketEvent)
 116 END_EVENT_TABLE()
 117
 118 IMPLEMENT_APP(MyApp)
 119
 120
 121 // ==========================================================================
 122 // implementation
 123 // ==========================================================================
 124
 125 // --------------------------------------------------------------------------
 126 // the application class
 127 // --------------------------------------------------------------------------
 128
 129 bool MyApp::OnInit()
 130 {
 131   // Create the main application window
 132   MyFrame *frame = new MyFrame();
 133
 134   // Show it and tell the application that it's our main window
 135   frame->Show(TRUE);
 136   SetTopWindow(frame);
 137
 138   // Success
 139   return TRUE;
 140 }
 141
 142 // --------------------------------------------------------------------------
 143 // main frame
 144 // --------------------------------------------------------------------------
 145
 146 // frame constructor
 147
 148 MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, -1,
 149                              _("wxSocket demo: Server"),
 150                              wxDefaultPosition, wxSize(300, 200))
 151 {
 152   // Give the frame an icon
 153   SetIcon(wxICON(mondrian));
 154
 155   // Make menus
 156   m_menuFile = new wxMenu();
 157   m_menuFile->Append(SERVER_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
 158   m_menuFile->AppendSeparator();
 159   m_menuFile->Append(SERVER_QUIT, _("E&xit\tAlt-X"), _("Quit server"));
 160
 161   // Append menus to the menubar
 162   m_menuBar = new wxMenuBar();
 163   m_menuBar->Append(m_menuFile, _("&File"));
 164   SetMenuBar(m_menuBar);
 165
 166   // Status bar
 167   CreateStatusBar(2);
 168
 169   // Make a textctrl for logging
 170   m_text  = new wxTextCtrl(this, -1,
 171                            _("Welcome to wxSocket demo: Server\n"),
 172                            wxDefaultPosition, wxDefaultSize,
 173                            wxTE_MULTILINE | wxTE_READONLY);
 174
 175   // Create the address - defaults to localhost:0 initially
 176   wxIPV4address addr;
 177   addr.Service(3000);
 178
 179   // Create the socket
 180   m_server = new wxSocketServer(addr);
 181
 182   // We use Ok() here to see if the server is really listening
 183   if (! m_server->Ok())
 184   {
 185     m_text->AppendText(_("Could not listen at the specified port !\n\n"));
 186     return;
 187   }
 188   else
 189   {
 190     m_text->AppendText(_("Server listening.\n\n"));
 191   }
 192
 193   // Setup the event handler and subscribe to connection events
 194   m_server->SetEventHandler(*this, SERVER_ID);
 195   m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
 196   m_server->Notify(TRUE);
 197
 198   m_busy = FALSE;
 199   m_numClients = 0;
 200   UpdateStatusBar();
 201 }
 202
 203 MyFrame::~MyFrame()
 204 {
 205   // No delayed deletion here, as the frame is dying anyway
 206   delete m_server;
 207 }
 208
 209 // event handlers
 210
 211 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 212 {
 213   // TRUE is to force the frame to close
 214   Close(TRUE);
 215 }
 216
 217 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 218 {
 219   wxMessageBox(_("wxSocket demo: Server\n"
 220                  "(c) 1999 Guillermo Rodriguez Garcia\n"),
 221                _("About Server"),
 222                wxOK | wxICON_INFORMATION, this);
 223 }
 224
 225 void MyFrame::Test1(wxSocketBase *sock)
 226 {
 227   unsigned char len;
 228   char *buf;
 229
 230   m_text->AppendText(_("Test 1 begins\n"));
 231
 232   // Receive data from socket and send it back. We will first
 233   // get a byte with the buffer size, so we can specify the
 234   // exact size and use the wxSOCKET_WAITALL flag. Also, we
 235   // disabled input events so we won't have unwanted reentrance.
 236   // This way we can avoid the infamous wxSOCKET_BLOCK flag.
 237
 238   sock->SetFlags(wxSOCKET_WAITALL);
 239
 240   // Read the size
 241   sock->Read(&len, 1);
 242   buf = new char[len];
 243
 244   // Read the data
 245   sock->Read(buf, len);
 246   m_text->AppendText(_("Got the data, sending it back\n"));
 247
 248   // Write it back
 249   sock->Write(buf, len);
 250   delete[] buf;
 251
 252   m_text->AppendText(_("Test 1 ends\n\n"));
 253 }
 254
 255 void MyFrame::Test2(wxSocketBase *sock)
 256 {
 257 #define MAX_MSG_SIZE 10000
 258
 259   wxString s;
 260   char *buf = new char[MAX_MSG_SIZE];
 261   wxUint32 len;
 262
 263   m_text->AppendText(_("Test 2 begins\n"));
 264
 265   // We don't need to set flags because ReadMsg and WriteMsg
 266   // are not affected by them anyway.
 267
 268   // Read the message
 269   len = sock->ReadMsg(buf, MAX_MSG_SIZE).LastCount();
 270   s.Printf(_("Client says: %s\n"), buf);
 271   m_text->AppendText(s);
 272   m_text->AppendText(_("Sending the data back\n"));
 273
 274   // Write it back
 275   sock->WriteMsg(buf, len);
 276   delete[] buf;
 277
 278   m_text->AppendText(_("Test 2 ends\n\n"));
 279
 280 #undef MAX_MSG_SIZE
 281 }
 282
 283 void MyFrame::Test3(wxSocketBase *sock)
 284 {
 285   unsigned char len;
 286   char *buf;
 287
 288   m_text->AppendText(_("Test 3 begins\n"));
 289
 290   // This test is similar to the first one, but the len is
 291   // expressed in kbytes - this tests large data transfers.
 292
 293   sock->SetFlags(wxSOCKET_WAITALL);
 294
 295   // Read the size
 296   sock->Read(&len, 1);
 297   buf = new char[len * 1024];
 298
 299   // Read the data
 300   sock->Read(buf, len * 1024);
 301   m_text->AppendText(_("Got the data, sending it back\n"));
 302
 303   // Write it back
 304   sock->Write(buf, len * 1024);
 305   delete[] buf;
 306
 307   m_text->AppendText(_("Test 3 ends\n\n"));
 308 }
 309
 310 void MyFrame::OnServerEvent(wxSocketEvent& event)
 311 {
 312   wxString s = _("OnServerEvent: ");
 313   wxSocketBase *sock;
 314
 315   switch(event.GetSocketEvent())
 316   {
 317     case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
 318     default                  : s.Append(_("Unexpected event !\n")); break;
 319   }
 320
 321   m_text->AppendText(s);
 322
 323   // Accept new connection if there is one in the pending
 324   // connections queue, else exit. We use Accept(FALSE) for
 325   // non-blocking accept (although if we got here, there
 326   // should ALWAYS be a pending connection).
 327
 328   sock = m_server->Accept(FALSE);
 329
 330   if (sock)
 331   {
 332     m_text->AppendText(_("New client connection accepted\n\n"));
 333   }
 334   else
 335   {
 336     m_text->AppendText(_("Error: couldn't accept a new connection\n\n"));
 337     sock->Destroy();
 338     return;
 339   }
 340
 341   sock->SetEventHandler(*this, SOCKET_ID);
 342   sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 343   sock->Notify(TRUE);
 344
 345   m_numClients++;
 346   UpdateStatusBar();
 347 }
 348
 349 void MyFrame::OnSocketEvent(wxSocketEvent& event)
 350 {
 351   wxString s = _("OnSocketEvent: ");
 352   wxSocketBase *sock = event.GetSocket();
 353
 354   // First, print a message
 355   switch(event.GetSocketEvent())
 356   {
 357     case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
 358     case wxSOCKET_LOST  : s.Append(_("wxSOCKET_LOST\n")); break;
 359     default             : s.Append(_("Unexpected event !\n")); break;
 360   }
 361
 362   m_text->AppendText(s);
 363
 364   // Now we process the event
 365   switch(event.GetSocketEvent())
 366   {
 367     case wxSOCKET_INPUT:
 368     {
 369       // We disable input events, so that the test doesn't trigger
 370       // wxSocketEvent again.
 371       sock->SetNotify(wxSOCKET_LOST_FLAG);
 372
 373       m_text->AppendText();
 374
 375       // Which test are we going to run?
 376       unsigned char c;
 377       sock->Read(&c, 1);
 378
 379       switch (c)
 380       {
 381         case 0xBE: Test1(sock); break;
 382         case 0xCE: Test2(sock); break;
 383         case 0xDE: Test3(sock); break;
 384         default:
 385           m_text->AppendText(_("Unknown test id received from client\n\n"));
 386       }
 387
 388       // Enable input events again.
 389       sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
 390       break;
 391     }
 392     case wxSOCKET_LOST:
 393     {
 394       m_numClients--;
 395
 396       // Destroy() should be used instead of delete wherever possible,
 397       // due to the fact that wxSocket uses 'delayed events' (see the
 398       // documentation for wxPostEvent) and we don't want an event to
 399       // arrive to the event handler (the frame, here) after the socket
 400       // has been deleted. Also, we might be doing some other thing with
 401       // the socket at the same time; for example, we might be in the
 402       // middle of a test or something. Destroy() takes care of all
 403       // this for us.
 404
 405       m_text->AppendText(_("Deleting socket.\n\n"));
 406       sock->Destroy();
 407       break;
 408     }
 409     default: ;
 410   }
 411
 412   UpdateStatusBar();
 413 }
 414
 415 // convenience functions
 416
 417 void MyFrame::UpdateStatusBar()
 418 {
 419   wxString s;
 420   s.Printf(_("%d clients connected"), m_numClients);
 421   SetStatusText(s, 1);
 422 }