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