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