new sample

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3773 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

samples/wxsocket/client.cpp

@@ -1,387 +1,445 @@
-/*
+/////////////////////////////////////////////////////////////////////////////
- * File:	client.cpp
+// Name:        client.cpp
- * Purpose:	wxSocket: client demo
+// Purpose:     Client for wxSocket demo
- * Author:	LAVAUX Guilhem
+// Author:      Guillermo Rodriguez Garcia <guille@iies.es>
- * Created:	June 1997
+// Modified by:
- * CVS ID:	$Id$
+// Created:     1999/09/19
- * Copyright:	(c) 1997, LAVAUX Guilhem
+// RCS-ID:      $Id$
- */
+// Copyright:   (c) 1999 Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ==========================================================================
+// declarations
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// headers
+// --------------------------------------------------------------------------
 
 #ifdef __GNUG__
-#pragma implementation
+#  pragma implementation "client.cpp"
-#pragma interface
+#  pragma interface "client.cpp"
 #endif
 
-// For compilers that support precompilation, includes "wx.h".
+// For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #  pragma hdrstop
 #endif
 
+// for all others, include the necessary headers 
 #ifndef WX_PRECOMP
 #  include "wx/wx.h"
-#endif
-
-#include "wx/wfstream.h"
 #  include "wx/socket.h"
 #  include "wx/url.h"
 #  include "wx/protocol/http.h"
-#include "wx/thread.h"
 #  include "wx/progdlg.h"
+#endif
 
-#if defined(__WXMOTIF__) || defined(__WXGTK__)
+// --------------------------------------------------------------------------
+// resources
+// --------------------------------------------------------------------------
+
+// the application icon
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
 #  include "mondrian.xpm"
 #endif
 
+// --------------------------------------------------------------------------
+// classes
+// --------------------------------------------------------------------------
+
 // Define a new application type
 class MyApp : public wxApp
-{ public:
+{
-    virtual bool OnInit(void);
+public:
+  virtual bool OnInit();
 };
 
-class MyClient;
+// Define a new frame type: this is going to be our main frame
-
-// Define a new frame type
 class MyFrame : public wxFrame
 {
-  DECLARE_CLASS(MyFrame)
 public:
-  MyClient *sock;
+  MyFrame();
-  int m_good;
+  ~MyFrame();
 
-  MyFrame(void);
+  // event handlers (these functions should _not_ be virtual)
-  virtual ~MyFrame();
+  void OnQuit(wxCommandEvent& event);
-  void OnCloseTest(wxCommandEvent& evt);
+  void OnAbout(wxCommandEvent& event);
-  void OnExecTest1(wxCommandEvent& evt);
+  void OnOpenConnection(wxCommandEvent& event);
-  void OnExecUrlTest(wxCommandEvent& evt);
+  void OnTest1(wxCommandEvent& event);
-  void OnQuitApp(wxCommandEvent& evt);
+  void OnTest2(wxCommandEvent& event);
-  void OnExecOpenConnection(wxCommandEvent& evt);
+  void OnTest3(wxCommandEvent& event);
-  void OnExecCloseConnection(wxCommandEvent& evt);
+  void OnCloseConnection(wxCommandEvent& event);
-  void OnSocketEvent(wxSocketEvent& evt);
+  void OnSocketEvent(wxSocketEvent& event);
-  void UpdateStatus();
 
-  void Download(wxInputStream *input);
+  // convenience functions
+  void UpdateStatusBar();
 
+private:
+  wxSocketClient *m_sock;
+  wxPanel        *m_panel;
+  wxTextCtrl     *m_text;
+  wxMenu         *m_menuFile;
+  wxMenu         *m_menuSocket;
+  wxMenuBar      *m_menuBar;
+  bool            m_busy;
+
+  // any class wishing to process wxWindows events must use this macro
   DECLARE_EVENT_TABLE()
 };
 
+// --------------------------------------------------------------------------
+// constants
+// --------------------------------------------------------------------------
 
-IMPLEMENT_CLASS(MyFrame, wxFrame)
+// IDs for the controls and the menu commands
-
+enum
-/*
- * Define a new derived SocketClient
- */
-class MyClient: public wxSocketClient
 {
-public:
+  // menu items
-  MyFrame *frame;
+  CLIENT_QUIT = 1000,
+  CLIENT_ABOUT,
+  CLIENT_OPEN,
+  CLIENT_TEST1,
+  CLIENT_TEST2,
+  CLIENT_TEST3,
+  CLIENT_CLOSE,
 
-  void OnNotify(GSocketEventFlags WXUNUSED(flags)) { frame->UpdateStatus(); }
+  // id for socket
+  SOCKET_ID
 };
 
-// ID for the menu quit command
+// --------------------------------------------------------------------------
-const int SKDEMO_QUIT    = 101;
+// event tables and other macros for wxWindows
-const int SKDEMO_CONNECT = 102;
+// --------------------------------------------------------------------------
-const int SKDEMO_TEST1   = 103;
+
-const int SKDEMO_TEST2   = 104;
+BEGIN_EVENT_TABLE(MyFrame, wxFrame)
-const int SKDEMO_CLOSE   = 105;
+  EVT_MENU(CLIENT_QUIT,  MyFrame::OnQuit)
-const int SKDEMO_TEST3   = 106;
+  EVT_MENU(CLIENT_ABOUT, MyFrame::OnAbout)
-const int ID_TEST_CLOSE  = 107;
+  EVT_MENU(CLIENT_OPEN,  MyFrame::OnOpenConnection)
-const int SKDEMO_SCK     = 108;
+  EVT_MENU(CLIENT_TEST1, MyFrame::OnTest1)
+  EVT_MENU(CLIENT_TEST2, MyFrame::OnTest2)
+  EVT_MENU(CLIENT_TEST3, MyFrame::OnTest3)
+  EVT_MENU(CLIENT_CLOSE, MyFrame::OnCloseConnection)
+  EVT_SOCKET(SOCKET_ID,  MyFrame::OnSocketEvent)
+END_EVENT_TABLE()
 
 IMPLEMENT_APP(MyApp)
 
-/*
+// ==========================================================================
- * `Main program' equivalent, creating windows and returning main app frame
+// implementation
- */
+// ==========================================================================
-bool MyApp::OnInit(void)
+
+// --------------------------------------------------------------------------
+// the application class
+// --------------------------------------------------------------------------
+
+bool MyApp::OnInit()
 {
-  // Create the main frame window
+  // Create the main application window
   MyFrame *frame = new MyFrame();
 
-  // Give it an icon
+  // Show it and tell the application that it's our main window
-  frame->SetIcon(wxICON(mondrian));
-
-  // Make a menubar
-  wxMenu *file_menu = new wxMenu();
-
-  file_menu->Append(SKDEMO_QUIT, "Exit");
-  wxMenuBar *menu_bar = new wxMenuBar;
-  menu_bar->Append(file_menu, "File");
-
-  wxMenu *socket_menu = new wxMenu();
-  socket_menu->Append(SKDEMO_CONNECT, "Open session");
-  socket_menu->AppendSeparator();
-  socket_menu->Append(SKDEMO_TEST1, "Start test 1");
-  socket_menu->AppendSeparator();
-  socket_menu->Append(SKDEMO_CLOSE, "Close session");
-  socket_menu->AppendSeparator();
-  socket_menu->Append(SKDEMO_TEST3, "Start URL test");
-
-  menu_bar->Append(socket_menu, "Socket");
-
-  frame->SetMenuBar(menu_bar);
-
-  // Make a panel with a message
-  (void)new wxPanel(frame, -1, wxPoint(0, 0), wxSize(300, 100));
-
-  // Show the frame
   frame->Show(TRUE);
+  SetTopWindow(frame);
 
-  // Return the main frame window
+  // success
   return TRUE;
 }
 
-/*
+// --------------------------------------------------------------------------
- * MyFrame Constructor
+// main frame
- */
+// --------------------------------------------------------------------------
-MyFrame::MyFrame():
+
-  wxFrame(NULL, -1, "wxSocket client demo",
+// frame constructor
-          wxDefaultPosition, wxSize(300, 200), wxDEFAULT_FRAME_STYLE)
+MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, -1,
+                             _T("wxSocket demo: Client"),
+                             wxDefaultPosition, wxSize(300, 200))
 {
-  sock = new MyClient();
+  // Give the frame an icon
-  sock->SetFlags((wxSocketBase::wxSockFlags) (wxSocketBase::WAITALL | wxSocketBase::SPEED));
+  SetIcon(wxICON(mondrian));
-  sock->frame = this;
+
-  sock->SetNotify(wxSOCKET_LOST_FLAG);
+  // Make menus
+  m_menuFile = new wxMenu();
+  m_menuFile->Append(CLIENT_ABOUT, _T("&About...\tCtrl-A"), _T("Show about dialog"));
+  m_menuFile->AppendSeparator();
+  m_menuFile->Append(CLIENT_QUIT, _T("E&xit\tAlt-X"), _T("Quit client"));
+
+  m_menuSocket = new wxMenu();
+  m_menuSocket->Append(CLIENT_OPEN, _T("&Open session"), _T("Connect to server"));
+  m_menuSocket->AppendSeparator();
+  m_menuSocket->Append(CLIENT_TEST1, _T("Test &1"), _T("Test basic functionality"));
+  m_menuSocket->Append(CLIENT_TEST2, _T("Test &2"), _T("Test ReadMsg and WriteMsg"));
+  m_menuSocket->Append(CLIENT_TEST3, _T("Test &3"), _T("Test large data transfer"));
+  m_menuSocket->AppendSeparator();
+  m_menuSocket->Append(CLIENT_CLOSE, _T("&Close session"), _T("Close connection"));
+
+  // Append menus to the menubar
+  m_menuBar = new wxMenuBar();
+  m_menuBar->Append(m_menuFile, _T("&File"));
+  m_menuBar->Append(m_menuSocket, _T("&Socket"));
+  SetMenuBar(m_menuBar);
+
+  // Status bar
   CreateStatusBar(2);
-  UpdateStatus();
+
+  // Make a panel with a textctrl in it
+  m_panel = new wxPanel(this, -1, wxPoint(0, 0), GetClientSize());
+  m_text  = new wxTextCtrl(m_panel, -1,
+                           _T("Welcome to wxSocket demo: Client\n")
+                           _T("Client ready\n\n"),
+                           wxPoint(0, 0), m_panel->GetClientSize(),
+                           wxTE_MULTILINE | wxTE_READONLY);
+
+  // Create the socket
+  m_sock = new wxSocketClient();
+  m_sock->SetEventHandler(*this, SOCKET_ID);
+  m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG |
+                    wxSOCKET_INPUT_FLAG |
+                    wxSOCKET_LOST_FLAG);
+  m_sock->Notify(TRUE);
+
+  m_busy = FALSE;
+  UpdateStatusBar();
 }
 
 MyFrame::~MyFrame()
 {
-  delete sock;
+  delete m_sock;
 }
 
-void MyFrame::OnQuitApp(wxCommandEvent& WXUNUSED(evt))
+// event handlers
+
+void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 {
+  // TRUE is to force the frame to close
   Close(TRUE);
 }
 
-void MyFrame::OnExecOpenConnection(wxCommandEvent& WXUNUSED(evt))
+void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
+{
+  wxMessageBox(_T("wxSocket demo: Client\n")
+               _T("(c) 1999 Guillermo Rodriguez Garcia\n"),
+               _T("About Client"),
+               wxOK | wxICON_INFORMATION, this);
+}
+
+void MyFrame::OnOpenConnection(wxCommandEvent& WXUNUSED(event))
 {
   wxIPV4address addr;
 
-  if (sock->IsConnected())
+  m_menuSocket->Enable(CLIENT_OPEN, FALSE);
-    sock->Close();
+  m_menuSocket->Enable(CLIENT_CLOSE, FALSE);
 
-  wxString hname = wxGetTextFromUser("Enter the address of the wxSocket Sample Server", 
+  // Ask server address
-                                  "Connect ...", "localhost");
+  wxString hostname = wxGetTextFromUser(
-  addr.Hostname(hname);
+    _T("Enter the address of the wxSocket demo server:"),
+    _T("Connect ..."),
+    _T("localhost"));
+
+  addr.Hostname(hostname);
   addr.Service(3000);
-  sock->Connect(addr, FALSE);
-  sock->WaitOnConnect(10);
-  sock->SetFlags(wxSocketBase::NONE);
-  if (!sock->IsConnected())
-    wxMessageBox("Can't connect to the specified host", "Alert !");
 
-  UpdateStatus();
+  // Non-blocking connect
-}
+  m_text->AppendText(_T("Trying to connect (timeout = 10 sec) ...\n"));
+  m_sock->Connect(addr, FALSE);
+  m_sock->WaitOnConnect(10);
 
-void MyFrame::OnExecCloseConnection(wxCommandEvent& WXUNUSED(evt))
+  if (m_sock->IsConnected())
-{
+    m_text->AppendText(_T("Succeeded ! Connection established\n"));
-  sock->Close();
-  UpdateStatus();
-}
-
-BEGIN_EVENT_TABLE(MyFrame, wxFrame)
-  EVT_BUTTON(ID_TEST_CLOSE, MyFrame::OnCloseTest)
-  EVT_MENU(SKDEMO_TEST1, MyFrame::OnExecTest1)
-  EVT_MENU(SKDEMO_TEST3, MyFrame::OnExecUrlTest)
-  EVT_MENU(SKDEMO_QUIT, MyFrame::OnQuitApp)
-  EVT_MENU(SKDEMO_CONNECT, MyFrame::OnExecOpenConnection)
-  EVT_MENU(SKDEMO_CLOSE, MyFrame::OnExecCloseConnection)
-  EVT_SOCKET(SKDEMO_SCK, MyFrame::OnSocketEvent)
-END_EVENT_TABLE()
-
-class MyFrameSocketTimer: public wxTimer {
- public:
-  void Notify() {
-    *m_var = 0;
-  }
-
-  int *m_var;
-};
-
-void MyFrame::OnSocketEvent(wxSocketEvent& evt)
-{
-  m_good = 1;
-}
-
-void MyFrame::OnCloseTest(wxCommandEvent& evt)
-{
-  wxButton *button = (wxButton *)evt.GetEventObject();
-  wxDialog *dlg = (wxDialog *)button->GetParent();
-
-  dlg->EndModal(0);
-}
-
-void MyFrame::UpdateStatus()
-{
-  if (!sock->IsConnected()) {
-    SetStatusText("Not connected", 0);
-    SetStatusText("", 1);
-  } else {
-    wxIPV4address addr;
-    wxChar s[100];
-
-    sock->GetPeer(addr);
-    wxSprintf(s, _T("Connected to %s"), WXSTRINGCAST addr.Hostname());
-    SetStatusText(s, 0);
-    wxSprintf(s, _T("Service: %d"), addr.Service());
-    SetStatusText(s, 1);
-  } 
-}
-
-void MyFrame::OnExecTest1(wxCommandEvent& WXUNUSED(evt))
-{
-  if (!sock->IsConnected())
-    return;
-
-  wxDialog *dlgbox = new wxDialog(this, -1, "Test 1", wxDefaultPosition, wxSize(414, 280));
-  wxTextCtrl *text_win = new wxTextCtrl(dlgbox, -1, "",
-                                        wxPoint(0, 0), wxSize(400, 200),
-					wxTE_MULTILINE);
-  (void)new wxButton(dlgbox, ID_TEST_CLOSE, "Close",
-                     wxPoint(100, 210), wxSize(100, -1));
-  wxChar *buf, *buf2;
-
-  dlgbox->Layout();
-  dlgbox->Show(TRUE);
-
-  text_win->WriteText("Initializing test 1 ...\n");
-  
-  wxYield();
-  
-  /* Init */
-  buf = copystring(_T("Hi ! Hi ! Hi !\n"));
-  buf2 = new wxChar[wxStrlen(buf)+1];
-  char c = 0xbe;
-  sock->Write(&c, 1);
-
-  /* No 1 */
-  text_win->WriteText("Sending some byte to the server ...");
-  wxYield();
-  sock->Write((char *)buf, wxStrlen(buf)+1);
-  text_win->WriteText("done\n");
-  wxYield();
-  text_win->WriteText("Receiving some byte from the server ...");
-  wxYield();
-  sock->Read((char *)buf2, wxStrlen(buf)+1);
-  text_win->WriteText("done\n");
-  wxYield();
-  
-  text_win->WriteText("Comparing the two buffers ...");
-  if (memcmp(buf, buf2, wxStrlen(buf)+1) != 0) {
-    text_win->WriteText("Fail\n");
-    sock->Close();
-    UpdateStatus();
-  } else
-    text_win->WriteText("done\nTest 1A passed !\n");
-
-  /* No 2 */
-  sock->SetEventHandler(*this, SKDEMO_SCK);
-  sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
-  sock->Notify(TRUE);
-  text_win->WriteText("Test 1B: sending bytes to the server\n");
-  if (!sock->IsData())
-    text_win->WriteText("No data to read yet (this is OK)\n");
-
-  wxYield();
-  sock->Write((char *)buf, wxStrlen(buf)+1);
-  text_win->WriteText("Waiting for incoming bytes (timeout = 2 sec) ...");
-  wxYield();
-  
-  m_good = 2;
-
-  MyFrameSocketTimer timer;
-
-  timer.m_var = &m_good; 
-  timer.Start(2000, TRUE);
-
-  while (m_good == 2)
-   wxYield();
-
-  if (!m_good) {
-    text_win->WriteText("timeout ! Failed.\n");
-    sock->Close();
-    UpdateStatus();
-  } else
-    text_win->WriteText("event ! (no timeout).\n");
-
-  if (sock->IsData())
-    text_win->WriteText("Data is available, as expected...\n");
-
-  sock->Read((char *)buf2, wxStrlen(buf)+1);
-
-  text_win->WriteText("Success!\n");
-
-  dlgbox->Layout();
-  dlgbox->ShowModal();
-
-  delete [] buf;
-  delete [] buf2;
-  delete text_win;
-  delete dlgbox;
-}
-
-
-void MyFrame::Download(wxInputStream *input)
-{
-  wxProgressDialog progress("Downloading ...", "0% downloaded");
-  wxFileOutputStream f_out("test.url");
-  size_t downloaded;
-  int BUFSIZE, bytes_read;
-  size_t file_size;
-  wxString message;
-  int percents;
-
-  char *buf;
-
-  if (input->GetSize() == (size_t)-1) {
-    file_size = (size_t)-1;
-    bytes_read = BUFSIZE = 10240;
-  } else {
-    file_size = input->GetSize();
-    if (file_size > 10240)
-      bytes_read = BUFSIZE = file_size / 1024;
   else
-      bytes_read = BUFSIZE = 1024;
-  }
-  buf = new char[BUFSIZE];
-
-  downloaded = 0;
-  bytes_read = BUFSIZE;
-  while (downloaded < file_size && bytes_read != 0) {
-    bytes_read = input->Read(buf, BUFSIZE).LastRead();
-    f_out.Write(buf, bytes_read);
-    downloaded += bytes_read;
-
-    percents = downloaded * 100 / file_size;
-
-    message = _T("");
-    message << percents << _T("% downloaded");
-    progress.Update(percents, message);
-  }
-
-  delete[] buf;   
-}
-
-void MyFrame::OnExecUrlTest(wxCommandEvent& WXUNUSED(evt))
   {
-  wxString urlname = wxGetTextFromUser("Enter an URL to get",
+    m_sock->Close();
-                                     "URL:", "http://localhost");
+    m_text->AppendText(_T("Failed ! Unable to connect\n"));
+    wxMessageBox(_T("Can't connect to the specified host"), _T("Alert !"));
+  }
   
-  wxURL url(urlname);
+  UpdateStatusBar();
-  wxInputStream *datas = url.GetInputStream();
+}
 
-  if (!datas) {
+void MyFrame::OnTest1(wxCommandEvent& WXUNUSED(event))
-    wxString error;
+{
-    error.Printf(_T("Error in getting data from the URL. (error = %d)"), url.GetError());
+  char *buf1, *buf2;
-    wxMessageBox(error, "Alert !");
+  char len;
-  } else {
-    Download(datas);
 
-    delete datas;
+  // Disable socket menu entries (exception: Close Session)
+  m_busy = TRUE;
+  UpdateStatusBar();
+
+  m_text->AppendText(_T("\n=== Test 1 begins ===\n"));
+
+  // Tell the server which test we are running
+  char c = 0xBE;
+  m_sock->Write(&c, 1);
+
+  // Send some data and read it back. We know the size of the
+  // buffer, so we can specify the exact number of bytes to be
+  // sent or received and use the WAITALL flag. Also, we have
+  // disabled menu entries which could interfere with the test,
+  // so we can safely avoid the BLOCK (formerly SPEED) flag.
+  //
+  // First we send a byte with the length of the string, then
+  // we send the string itself (do NOT try to send any integral
+  // value larger than a byte "as is" acrosss the network, or
+  // you might be in trouble! Ever heard about big and little
+  // endian computers?)
+  //
+  m_sock->SetFlags(wxSOCKET_WAITALL);
+
+  buf1 = _T("Test string (less than 127 chars!)");
+  len  = wxStrlen(buf1) + 1;
+  buf2 = new char[len];
+
+  m_text->AppendText(_T("Sending a test buffer to the server ..."));
+  m_sock->Write(&len, 1);
+  m_sock->Write(buf1, len);
+  m_text->AppendText(m_sock->Error() ? _T("failed !\n") : _T("done\n"));
+
+  m_text->AppendText(_T("Receiving the buffer back from server ..."));
+  m_sock->Read(buf2, len);
+  m_text->AppendText(m_sock->Error() ? _T("failed !\n") : _T("done\n"));
+
+  m_text->AppendText(_T("Comparing the two buffers ..."));
+  if (memcmp(buf1, buf2, len) != 0)
+  {
+    m_text->AppendText(_T("failed!\n"));
+    m_text->AppendText(_T("Test 1 failed !\n"));
+  }
+  else
+  {
+    m_text->AppendText(_T("done\n"));
+    m_text->AppendText(_T("Test 1 passed !\n"));
+  }
+  m_text->AppendText(_T("=== Test 1 ends ===\n"));
+
+  delete[] buf2;
+  m_busy = FALSE;
+  UpdateStatusBar();
+}
+
+void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
+{
+  char *msg1;
+  char *msg2;
+  size_t len;
+
+  // Disable socket menu entries (exception: Close Session)
+  m_busy = TRUE;
+  UpdateStatusBar();
+
+  m_text->AppendText(_T("\n=== Test 2 begins ===\n"));
+
+  // Tell the server which test we are running
+  char c = 0xCE;
+  m_sock->Write(&c, 1);
+
+  // Here we use ReadMsg and WriteMsg to send messages with
+  // a header with size information. Also, the reception is
+  // event triggered, so we test input events as well.
+  //
+  // We need to set no flags here (ReadMsg and WriteMsg are
+  // not affected by flags)
+  //
+  m_sock->SetFlags(wxSOCKET_WAITALL);
+
+  wxString s = wxGetTextFromUser(
+    _T("Enter an arbitrary string to send to the server:"),
+    _T("Test 2 ..."),
+    _T("Yes I like wxWindows!"));
+
+  msg1 = (char *)s.c_str();
+  len  = wxStrlen(msg1) + 1;
+  msg2 = (char *)malloc(len);
+
+  m_text->AppendText(_T("Sending the string with WriteMsg ..."));
+  m_sock->WriteMsg(msg1, len);
+  m_text->AppendText(m_sock->Error() ? _T("failed !\n") : _T("done\n"));
+  m_text->AppendText(_T("Waiting for an event (timeout = 2 sec)\n"));
+
+  // Wait until data available (will also return if the connection is lost)
+  m_sock->WaitForRead(2);
+
+  if (m_sock->IsData())
+  {
+    m_text->AppendText(_T("Reading the string back with ReadMsg ..."));
+    m_sock->ReadMsg(msg2, len);
+    m_text->AppendText(m_sock->Error() ? _T("failed !\n") : _T("done\n"));
+    m_text->AppendText(_T("Comparing the two buffers ..."));
+    if (memcmp(msg1, msg2, len) != 0)
+    {
+      m_text->AppendText(_T("failed!\n"));  
+      m_text->AppendText(_T("Test 2 failed !\n"));
+    }
+    else
+    {
+      m_text->AppendText(_T("done\n"));
+      m_text->AppendText(_T("Test 2 passed !\n"));
     }
   }
+  else
+    m_text->AppendText(_T("Timeout ! Test 2 failed.\n"));
+
+  m_text->AppendText(_T("=== Test 2 ends ===\n"));
+
+  free(msg2);
+  m_busy = FALSE;
+  UpdateStatusBar();
+}
+
+void MyFrame::OnTest3(wxCommandEvent& WXUNUSED(event))
+{
+  m_text->AppendText(_T("\n=== Test 3 begins ===\n"));
+  m_text->AppendText(_T("Test 3 not implemented\n"));
+  m_text->AppendText(_T("=== Test 3 ends ===\n"));
+}
+
+void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
+{
+  m_sock->Close();
+  UpdateStatusBar();
+}
+
+void MyFrame::OnSocketEvent(wxSocketEvent& event)
+{
+  wxString s = _T("OnSocketEvent: ");
+
+  switch(event.SocketEvent())
+  {
+    case wxSOCKET_INPUT      : s.Append(_T("wxSOCKET_INPUT\n")); break;
+    case wxSOCKET_LOST       : s.Append(_T("wxSOCKET_LOST\n")); break;
+    case wxSOCKET_CONNECTION : s.Append(_T("wxSOCKET_CONNECTION\n")); break;
+    default                  : s.Append(_T("Unexpected event !\n")); break;
+  }
+
+  m_text->AppendText(s);
+  UpdateStatusBar();
+}
+
+// convenience functions
+
+void MyFrame::UpdateStatusBar()
+{
+  wxString s;
+
+  if (!m_sock->IsConnected())
+  {
+    s.Printf(_T("Not connected"));
+  }
+  else
+  {
+    wxIPV4address addr;
+
+    m_sock->GetPeer(addr);
+    s.Printf(_T("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
+  }
+
+  SetStatusText(s, 1);
+
+  m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
+  m_menuSocket->Enable(CLIENT_TEST1, m_sock->IsConnected() && !m_busy);
+  m_menuSocket->Enable(CLIENT_TEST2, m_sock->IsConnected() && !m_busy);
+  m_menuSocket->Enable(CLIENT_TEST3, m_sock->IsConnected() && !m_busy);
+  m_menuSocket->Enable(CLIENT_CLOSE, m_sock->IsConnected());
+}

samples/wxsocket/server.cpp

@@ -1,194 +1,380 @@
-/*
+/////////////////////////////////////////////////////////////////////////////
- * File:	server.cpp
+// Name:        server.cpp
- * Purpose:	wxSocket: server demo
+// Purpose:     Server for wxSocket demo
- * Author:	LAVAUX Guilhem
+// Author:      Guillermo Rodriguez Garcia <guille@iies.es>
- * Created:	June 1997
+// Modified by:
- * CVS Id:	$Id$
+// Created:     1999/09/19
- * Copyright: (C) 1997, LAVAUX Guilhem
+// RCS-ID:      $Id$
- */
+// Copyright:   (c) 1999 Guillermo Rodriguez Garcia
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ==========================================================================
+// declarations
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// headers
+// --------------------------------------------------------------------------
 
 #ifdef __GNUG__
-#pragma implementation
+#  pragma implementation "server.cpp"
-#pragma interface
+#  pragma interface "server.cpp"
 #endif
 
-// For compilers that support precompilation, includes "wx.h".
+// For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #  pragma hdrstop
 #endif
 
+// for all others, include the necessary headers 
 #ifndef WX_PRECOMP
 #  include "wx/wx.h"
+#  include "wx/socket.h"
 #endif
 
-#include "wx/socket.h"
+// --------------------------------------------------------------------------
+// resources
+// --------------------------------------------------------------------------
 
-#if defined(__WXMOTIF__) || defined(__WXGTK__)
+// the application icon
+#if defined(__WXGTK__) || defined(__WXMOTIF__)
 #  include "mondrian.xpm"
 #endif
 
+// --------------------------------------------------------------------------
+// classes
+// --------------------------------------------------------------------------
+
 // Define a new application type
 class MyApp : public wxApp
-{ public:
+{
-    bool OnInit(void);
+public:
+  virtual bool OnInit();
 };
 
-class MyServer;
+// Define a new frame type: this is going to be our main frame
-
-// Define a new frame type
 class MyFrame : public wxFrame
 {
-  DECLARE_EVENT_TABLE()
 public:
-  wxSocketServer *sock;
+  MyFrame();
-  int nb_clients;
+  ~MyFrame();
 
-  MyFrame(wxFrame *frame);
+  // event handlers (these functions should _not_ be virtual)
-  virtual ~MyFrame();
+  void OnQuit(wxCommandEvent& event);
-  void Menu_Exit(wxCommandEvent& evt);
+  void OnAbout(wxCommandEvent& event);
-  void OnSockRequest(wxSocketEvent& evt);
+  void OnServerEvent(wxSocketEvent& event);
-  void OnSockRequestServer(wxSocketEvent& evt);
+  void OnSocketEvent(wxSocketEvent& event);
-  void ExecTest1(wxSocketBase *sock_o);
+
-  void UpdateStatus(int incr);
+  void Test1(wxSocketBase *sock);
+  void Test2(wxSocketBase *sock);
+  void Test3(wxSocketBase *sock);
+
+  // convenience functions
+  void UpdateStatusBar();
+
+private:
+  wxSocketServer *m_server;
+  wxPanel        *m_panel;
+  wxTextCtrl     *m_text;
+  wxMenu         *m_menuFile;
+  wxMenuBar      *m_menuBar;
+  bool            m_busy;
+  int             m_numClients;
+
+  // any class wishing to process wxWindows events must use this macro
+  DECLARE_EVENT_TABLE()
 };
 
-#define SKDEMO_QUIT 101
+// --------------------------------------------------------------------------
-#define SKDEMO_SOCKET_SERV 102
+// constants
-#define SKDEMO_SOCKET 103
+// --------------------------------------------------------------------------
+
+// IDs for the controls and the menu commands
+enum
+{
+  // menu items
+  SERVER_QUIT = 1000,
+  SERVER_ABOUT,
+
+  // id for sockets
+  SERVER_ID,
+  SOCKET_ID
+};
+
+// --------------------------------------------------------------------------
+// event tables and other macros for wxWindows
+// --------------------------------------------------------------------------
 
 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
-  EVT_MENU(SKDEMO_QUIT, MyFrame::Menu_Exit)
+  EVT_MENU(SERVER_QUIT,  MyFrame::OnQuit)
-  EVT_SOCKET(SKDEMO_SOCKET_SERV, MyFrame::OnSockRequestServer)
+  EVT_MENU(SERVER_ABOUT, MyFrame::OnAbout)
-  EVT_SOCKET(SKDEMO_SOCKET, MyFrame::OnSockRequest)
+  EVT_SOCKET(SERVER_ID,  MyFrame::OnServerEvent)
+  EVT_SOCKET(SOCKET_ID,  MyFrame::OnSocketEvent)
 END_EVENT_TABLE()
 
 IMPLEMENT_APP(MyApp)
 
-// `Main program' equivalent, creating windows and returning main app frame
+
-bool MyApp::OnInit(void)
+// To append sockets for delayed deletion
+extern wxList wxPendingDelete;
+
+
+// ==========================================================================
+// implementation
+// ==========================================================================
+
+// --------------------------------------------------------------------------
+// the application class
+// --------------------------------------------------------------------------
+
+bool MyApp::OnInit()
 {
-  // Create the main frame window
+  // Create the main application window
-  MyFrame *frame = new MyFrame(NULL);
+  MyFrame *frame = new MyFrame();
 
-  // Give it an icon
+  // Show it and tell the application that it's our main window
-  frame->SetIcon(wxICON(mondrian));
-
-  // Make a menubar
-  wxMenu *file_menu = new wxMenu;
-
-  file_menu->Append(SKDEMO_QUIT, "E&xit");
-  wxMenuBar *menu_bar = new wxMenuBar;
-  menu_bar->Append(file_menu, "File");
-  frame->SetMenuBar(menu_bar);
-
-  // Make a panel with a message
-  (void)new wxPanel(frame, 0, 0, 300, 100);
-
-  // Show the frame
   frame->Show(TRUE);
+  SetTopWindow(frame);
 
-  // Return the main frame window
+  // success
   return TRUE;
 }
 
-extern wxList wxPendingDelete;
+// --------------------------------------------------------------------------
+// main frame
+// --------------------------------------------------------------------------
 
-void MyFrame::OnSockRequest(wxSocketEvent& evt)
+// frame constructor
+MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, -1,
+                             _T("wxSocket demo: Server"),
+                             wxDefaultPosition, wxSize(300, 200))
 {
-  wxSocketBase *sock = evt.Socket();
+  // Give the frame an icon
+  SetIcon(wxICON(mondrian));
 
-  wxPrintf(_T("OnSockRequest OK\n"));
+  // Make menus
-  wxPrintf(_T("OnSockRequest (event = %d)\n"),evt.SocketEvent());
+  m_menuFile = new wxMenu();
-  switch (evt.SocketEvent()) {
+  m_menuFile->Append(SERVER_ABOUT, _T("&About...\tCtrl-A"), _T("Show about dialog"));
-  case wxSOCKET_INPUT:
+  m_menuFile->AppendSeparator();
-    unsigned char c;
+  m_menuFile->Append(SERVER_QUIT, _T("E&xit\tAlt-X"), _T("Quit server"));
 
-    sock->Read((char *)&c, 1);
+  // Append menus to the menubar
-    if (c == 0xbe)
+  m_menuBar = new wxMenuBar();
-      ExecTest1(sock);
+  m_menuBar->Append(m_menuFile, _T("&File"));
+  SetMenuBar(m_menuBar);
 
-    break;
+  // Status bar
-  case wxSOCKET_LOST:
+  CreateStatusBar(2);
-    wxPrintf(_T("Destroying socket\n"));
-    wxPendingDelete.Append(sock);
-    UpdateStatus(-1);
-    return;
-    break;
-  default:
-    wxPrintf(_T("Invalid event !\n"));
-  }
-  wxPrintf(_T("OnSockRequest Exiting\n"));
-}
 
-void MyFrame::OnSockRequestServer(wxSocketEvent& evt)
+  // Make a panel with a textctrl in it
-{
+  m_panel = new wxPanel(this, -1, wxPoint(0, 0), GetClientSize());
-  wxSocketBase *sock2;
+  m_text  = new wxTextCtrl(m_panel, -1,
-  wxSocketServer *server = (wxSocketServer *) evt.Socket();
+                           _T("Welcome to wxSocket demo: Server\n"),
+                           wxPoint(0, 0), m_panel->GetClientSize(),
+                           wxTE_MULTILINE | wxTE_READONLY);
 
-  wxPrintf(_T("OnSockRequestServer OK\n"));
+  // Create the socket
-  wxPrintf(_T("OnSockRequest (event = %d)\n"), evt.SocketEvent());
-
-  sock2 = server->Accept(FALSE);
-  if (sock2 == NULL)
-    return;
-
-  UpdateStatus(1);
-  sock2->SetFlags(wxSocketBase::NONE);
-  sock2->Notify(TRUE);
-  sock2->SetEventHandler(*this, SKDEMO_SOCKET);
-  sock2->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
-}
-
-// My frame Constructor
-MyFrame::MyFrame(wxFrame *frame):
-  wxFrame(frame, -1, "wxSocket sample (server)", wxDefaultPosition,
-          wxSize(300, 200))
-{
   wxIPV4address addr;
   addr.Service(3000);
 
-  // Init all
+  m_server = new wxSocketServer(addr);
+  m_server->SetEventHandler(*this, SERVER_ID);
+  m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
+  m_server->Notify(TRUE);
 
-  sock = new wxSocketServer(addr);
+  // We use Ok() here to see if the server is really listening
-  sock->SetNotify(wxSOCKET_CONNECTION_FLAG);
+  if (m_server->Ok())
-  sock->SetEventHandler(*this, SKDEMO_SOCKET_SERV);
+    m_text->AppendText(_T("Server listening.\n\n"));
-  sock->SetFlags(wxSocketBase::SPEED);
+  else
-  sock->Notify(TRUE);
+    m_text->AppendText(_T("Could not listen at the specified port !\n\n"));
-  nb_clients = 0;
+
-  CreateStatusBar(1);
+  m_busy = FALSE;
-  UpdateStatus(0);
+  m_numClients = 0;
+  UpdateStatusBar();
 }
 
 MyFrame::~MyFrame()
 {
-  delete sock;
+  delete m_server;
 }
 
-// Intercept menu commands
+// event handlers
-void MyFrame::Menu_Exit(wxCommandEvent& WXUNUSED(event))
+
+void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 {
+  // TRUE is to force the frame to close
   Close(TRUE);
 }
 
-void MyFrame::ExecTest1(wxSocketBase *sock_o)
+void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 {
-  char *buf = new char[50];
+  wxMessageBox(_T("wxSocket demo: Server\n")
-  size_t l;
+               _T("(c) 1999 Guillermo Rodriguez Garcia\n"),
-
+               _T("About Server"),
-  l = sock_o->Read(buf, 50).LastCount();
+               wxOK | wxICON_INFORMATION, this);
-  sock_o->Write(buf, l);
-  l = sock_o->Read(buf, 50).LastCount();
-  sock_o->Write(buf, l);
-
-  delete[] buf;
 }
 
-void MyFrame::UpdateStatus(int incr)
+void MyFrame::Test1(wxSocketBase *sock)
 {
-  wxChar s[30];
+  unsigned char len;
-  nb_clients += incr;
+  char *buf;
-  wxSprintf(s, _T("%d clients connected"), nb_clients);
+
-  SetStatusText(s);
+  m_text->AppendText(_T("Test 1 begins\n"));
+
+  // Receive data from socket and send it back. We will first
+  // get a byte with the buffer size, so we can specify the
+  // exact size and use the WAITALL flag. Also, we disabled
+  // input events so we won't have unwanted reentrance. This
+  // way we can avoid the infamous BLOCK (formerly SPEED) flag.
+  //
+  sock->SetFlags(wxSOCKET_WAITALL);
+
+  sock->Read((char *)&len, 1);
+
+  buf = (char *)malloc(len);
+  sock->Read(buf, len);
+  sock->Write(buf, len);
+  free(buf);
+
+  m_text->AppendText(_T("Test 1 ends\n"));
+}
+
+void MyFrame::Test2(wxSocketBase *sock)
+{
+#define MAX_MSG_SIZE 10000
+
+  wxString s;
+  char *buf = (char *)malloc(MAX_MSG_SIZE);
+  wxUint32 len;
+
+  m_text->AppendText(_T("Test 2 begins\n"));
+
+  // We don't need to set flags because ReadMsg and WriteMsg
+  // are not affected by them anyway.
+  //
+  len = sock->ReadMsg(buf, MAX_MSG_SIZE).LastCount();
+
+  s.Printf(_T("Client says: %s\n"), buf);
+  m_text->AppendText(s);
+
+  sock->WriteMsg(buf, len);
+  free(buf);
+
+  m_text->AppendText(_T("Test 2 ends\n"));
+
+#undef MAX_MSG_SIZE
+}
+
+void MyFrame::Test3(wxSocketBase *sock)
+{
+  m_text->AppendText(_T("Test 3 begins\n"));
+  m_text->AppendText(_T("(not implemented)\n"));
+  m_text->AppendText(_T("Test 3 ends\n"));
+}
+
+void MyFrame::OnServerEvent(wxSocketEvent& event)
+{
+  wxString s = _T("OnServerEvent: ");
+  wxSocketBase *sock;
+
+  switch(event.SocketEvent())
+  {
+    case wxSOCKET_CONNECTION : s.Append(_T("wxSOCKET_CONNECTION\n")); break;
+    default                  : s.Append(_T("Unexpected event !\n")); break;
+  }
+
+  m_text->AppendText(s);
+
+  // Accept new connection if there is one in the pending
+  // connections queue, else exit. We use Accept(FALSE) for
+  // non-blocking accept (although if we got here, there
+  // should ALWAYS be a pending connection).
+  //
+  sock = m_server->Accept(FALSE);
+
+  if (sock)
+  {
+    m_text->AppendText(_T("New client connection accepted\n"));
+  }
+  else
+  {
+    m_text->AppendText(_T("Error: couldn't accept a new connection"));
+    return;
+  }
+
+  sock->SetEventHandler(*this, SOCKET_ID);
+  sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
+  sock->Notify(TRUE);
+
+  m_numClients++;
+  UpdateStatusBar();
+}
+
+void MyFrame::OnSocketEvent(wxSocketEvent& event)
+{
+  wxSocketBase *sock = event.Socket();
+  wxString s = _T("OnSocketEvent: ");
+
+  // We first print a msg
+  switch(event.SocketEvent())
+  {
+    case wxSOCKET_INPUT: s.Append(_T("wxSOCKET_INPUT\n")); break;
+    case wxSOCKET_LOST:  s.Append(_T("wxSOCKET_LOST\n")); break;
+    default:             s.Append(_T("unexpected event !\n"));
+  }
+
+  m_text->AppendText(s);
+
+  // Now we process the event
+  switch(event.SocketEvent())
+  {
+    case wxSOCKET_INPUT:
+    {
+      // We disable input events, so that the test doesn't trigger
+      // wxSocketEvent again.
+      sock->SetNotify(wxSOCKET_LOST_FLAG);
+
+      // Which test are we going to run?
+      unsigned char c;
+      sock->Read((char *)&c ,1);
+
+      switch (c)
+      {
+        case 0xBE: Test1(sock); break;
+        case 0xCE: Test2(sock); break;
+        case 0xDE: Test3(sock); break;
+        default: s.Append(_T("Unknown test id received from client\n"));
+      }
+
+      // Enable input events again.
+      sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
+      break;
+    }
+    case wxSOCKET_LOST:
+    {
+      m_numClients--;
+
+      // We cannot delete the socket right now because we can
+      // be in the middle of a test or something. So we append
+      // it to the list of objects to be deleted.
+      m_text->AppendText(_T("Deleting socket.\n"));
+      wxPendingDelete.Append(sock);
+      break;
+    }
+    default: ;
+  }
+
+  UpdateStatusBar();
+}
+
+// convenience functions
+
+void MyFrame::UpdateStatusBar()
+{
+  wxString s;
+  s.Printf(_T("%d clients connected"), m_numClients);
+  SetStatusText(s, 1);
 }