X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/70d26c3f4ffb24d50457d405c9595fd23f9e5b7c..e1efca652844273c3e8d32c7e5f442b87e455ca7:/samples/sockets/client.cpp

diff --git a/samples/sockets/client.cpp b/samples/sockets/client.cpp
index 2dba5c91b3..7b67c98dd8 100644
--- a/samples/sockets/client.cpp
+++ b/samples/sockets/client.cpp
@@ -17,11 +17,6 @@
 // headers
 // --------------------------------------------------------------------------
 
-#ifdef __GNUG__
-#  pragma implementation "client.cpp"
-#  pragma interface "client.cpp"
-#endif
-
 // For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
@@ -29,23 +24,23 @@
 #  pragma hdrstop
 #endif
 
-// for all others, include the necessary headers 
+// for all others, include the necessary headers
 #ifndef WX_PRECOMP
 #  include "wx/wx.h"
 #endif
 
-#  include "wx/socket.h"
-#  include "wx/url.h"
-#  include "wx/protocol/http.h"
-#  include "wx/progdlg.h"
+#include "wx/socket.h"
+#include "wx/url.h"
+#include "wx/sstream.h"
+#include <memory>
 
 // --------------------------------------------------------------------------
 // resources
 // --------------------------------------------------------------------------
 
 // the application icon
-#if defined(__WXGTK__) || defined(__WXMOTIF__)
-#  include "mondrian.xpm"
+#if !defined(__WXMSW__) && !defined(__WXPM__)
+    #include "../sample.xpm"
 #endif
 
 // --------------------------------------------------------------------------
@@ -66,14 +61,31 @@ public:
   MyFrame();
   ~MyFrame();
 
-  // event handlers (these functions should _not_ be virtual)
+  // event handlers for File menu
   void OnQuit(wxCommandEvent& event);
   void OnAbout(wxCommandEvent& event);
+
+  // event handlers for Socket menu
   void OnOpenConnection(wxCommandEvent& event);
   void OnTest1(wxCommandEvent& event);
   void OnTest2(wxCommandEvent& event);
   void OnTest3(wxCommandEvent& event);
   void OnCloseConnection(wxCommandEvent& event);
+
+#if wxUSE_URL
+  // event handlers for Protocols menu
+  void OnTestURL(wxCommandEvent& event);
+#endif
+#if wxUSE_IPV6
+  void OnOpenConnectionIPv6(wxCommandEvent& event);
+#endif
+
+  void OpenConnection(wxSockAddress::Family family);
+
+  // event handlers for DatagramSocket menu (stub)
+  void OnDatagram(wxCommandEvent& event);
+
+  // socket event handler
   void OnSocketEvent(wxSocketEvent& event);
 
   // convenience functions
@@ -81,17 +93,36 @@ public:
 
 private:
   wxSocketClient *m_sock;
-  wxPanel        *m_panel;
   wxTextCtrl     *m_text;
   wxMenu         *m_menuFile;
   wxMenu         *m_menuSocket;
+  wxMenu         *m_menuDatagramSocket;
+  wxMenu         *m_menuProtocols;
   wxMenuBar      *m_menuBar;
   bool            m_busy;
 
-  // any class wishing to process wxWindows events must use this macro
+  // any class wishing to process wxWidgets events must use this macro
   DECLARE_EVENT_TABLE()
 };
 
+// simple helper class to log start and end of each test
+class TestLogger
+{
+public:
+    TestLogger(const wxString& name) : m_name(name)
+    {
+        wxLogMessage("=== %s test begins ===", m_name);
+    }
+
+    ~TestLogger()
+    {
+        wxLogMessage("=== %s test ends ===", m_name);
+    }
+
+private:
+    const wxString m_name;
+};
+
 // --------------------------------------------------------------------------
 // constants
 // --------------------------------------------------------------------------
@@ -100,31 +131,45 @@ private:
 enum
 {
   // menu items
-  CLIENT_QUIT = 1000,
-  CLIENT_ABOUT,
-  CLIENT_OPEN,
+  CLIENT_QUIT = wxID_EXIT,
+  CLIENT_ABOUT = wxID_ABOUT,
+  CLIENT_OPEN = 100,
+#if wxUSE_IPV6
+  CLIENT_OPENIPV6,
+#endif
   CLIENT_TEST1,
   CLIENT_TEST2,
   CLIENT_TEST3,
   CLIENT_CLOSE,
+#if wxUSE_URL
+  CLIENT_TESTURL,
+#endif
+  CLIENT_DGRAM,
 
   // id for socket
   SOCKET_ID
 };
 
 // --------------------------------------------------------------------------
-// event tables and other macros for wxWindows
+// event tables and other macros for wxWidgets
 // --------------------------------------------------------------------------
 
 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
-  EVT_MENU(CLIENT_QUIT,  MyFrame::OnQuit)
-  EVT_MENU(CLIENT_ABOUT, MyFrame::OnAbout)
-  EVT_MENU(CLIENT_OPEN,  MyFrame::OnOpenConnection)
-  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)
+  EVT_MENU(CLIENT_QUIT,     MyFrame::OnQuit)
+  EVT_MENU(CLIENT_ABOUT,    MyFrame::OnAbout)
+  EVT_MENU(CLIENT_OPEN,     MyFrame::OnOpenConnection)
+#if wxUSE_IPV6
+  EVT_MENU(CLIENT_OPENIPV6, MyFrame::OnOpenConnectionIPv6)
+#endif
+  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_MENU(CLIENT_DGRAM,    MyFrame::OnDatagram)
+#if wxUSE_URL
+  EVT_MENU(CLIENT_TESTURL,  MyFrame::OnTestURL)
+#endif
+  EVT_SOCKET(SOCKET_ID,     MyFrame::OnSocketEvent)
 END_EVENT_TABLE()
 
 IMPLEMENT_APP(MyApp)
@@ -139,15 +184,17 @@ IMPLEMENT_APP(MyApp)
 
 bool MyApp::OnInit()
 {
+  if ( !wxApp::OnInit() )
+      return false;
+
   // Create the main application window
   MyFrame *frame = new MyFrame();
 
-  // Show it and tell the application that it's our main window
-  frame->Show(TRUE);
-  SetTopWindow(frame);
+  // Show it
+  frame->Show(true);
 
   // success
-  return TRUE;
+  return true;
 }
 
 // --------------------------------------------------------------------------
@@ -155,59 +202,79 @@ bool MyApp::OnInit()
 // --------------------------------------------------------------------------
 
 // frame constructor
-MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, -1,
-                             _T("wxSocket demo: Client"),
+MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
+                             _("wxSocket demo: Client"),
                              wxDefaultPosition, wxSize(300, 200))
 {
   // Give the frame an icon
-  SetIcon(wxICON(mondrian));
+  SetIcon(wxICON(sample));
 
   // Make menus
   m_menuFile = new wxMenu();
-  m_menuFile->Append(CLIENT_ABOUT, _T("&About...\tCtrl-A"), _T("Show about dialog"));
+  m_menuFile->Append(CLIENT_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
   m_menuFile->AppendSeparator();
-  m_menuFile->Append(CLIENT_QUIT, _T("E&xit\tAlt-X"), _T("Quit client"));
+  m_menuFile->Append(CLIENT_QUIT, _("E&xit\tAlt-X"), _("Quit client"));
 
   m_menuSocket = new wxMenu();
-  m_menuSocket->Append(CLIENT_OPEN, _T("&Open session"), _T("Connect to server"));
+  m_menuSocket->Append(CLIENT_OPEN, _("&Open session\tCtrl-O"), _("Connect to server"));
+#if wxUSE_IPV6
+  m_menuSocket->Append(CLIENT_OPENIPV6, _("&Open session(IPv6)\tShift-Ctrl-O"), _("Connect to server(IPv6)"));
+#endif
   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->Append(CLIENT_TEST1, _("Test &1\tCtrl-F1"), _("Test basic functionality"));
+  m_menuSocket->Append(CLIENT_TEST2, _("Test &2\tCtrl-F2"), _("Test ReadMsg and WriteMsg"));
+  m_menuSocket->Append(CLIENT_TEST3, _("Test &3\tCtrl-F3"), _("Test large data transfer"));
   m_menuSocket->AppendSeparator();
-  m_menuSocket->Append(CLIENT_CLOSE, _T("&Close session"), _T("Close connection"));
+  m_menuSocket->Append(CLIENT_CLOSE, _("&Close session\tCtrl-Q"), _("Close connection"));
+
+  m_menuDatagramSocket = new wxMenu();
+  m_menuDatagramSocket->Append(CLIENT_DGRAM, _("&Datagram test\tCtrl-D"), _("Test UDP sockets"));
+
+#if wxUSE_URL
+  m_menuProtocols = new wxMenu();
+  m_menuProtocols->Append(CLIENT_TESTURL, _("Test URL\tCtrl-U"),
+                          _("Get data from the specified URL"));
+#endif
 
   // Append menus to the menubar
   m_menuBar = new wxMenuBar();
-  m_menuBar->Append(m_menuFile, _T("&File"));
-  m_menuBar->Append(m_menuSocket, _T("&Socket"));
+  m_menuBar->Append(m_menuFile, _("&File"));
+  m_menuBar->Append(m_menuSocket, _("&TCP"));
+  m_menuBar->Append(m_menuDatagramSocket, _("&UDP"));
+#if wxUSE_URL
+  m_menuBar->Append(m_menuProtocols, _("&Protocols"));
+#endif
   SetMenuBar(m_menuBar);
 
+#if wxUSE_STATUSBAR
   // Status bar
   CreateStatusBar(2);
+#endif // wxUSE_STATUSBAR
 
-  // 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(),
+  // Make a textctrl for logging
+  m_text  = new wxTextCtrl(this, wxID_ANY,
+                           _("Welcome to wxSocket demo: Client\nClient ready\n"),
+                           wxDefaultPosition, wxDefaultSize,
                            wxTE_MULTILINE | wxTE_READONLY);
+  delete wxLog::SetActiveTarget(new wxLogTextCtrl(m_text));
 
   // Create the socket
   m_sock = new wxSocketClient();
+
+  // Setup the event handler and subscribe to most events
   m_sock->SetEventHandler(*this, SOCKET_ID);
   m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG |
                     wxSOCKET_INPUT_FLAG |
                     wxSOCKET_LOST_FLAG);
-  m_sock->Notify(TRUE);
+  m_sock->Notify(true);
 
-  m_busy = FALSE;
+  m_busy = false;
   UpdateStatusBar();
 }
 
 MyFrame::~MyFrame()
 {
+  // No delayed deletion here, as the frame is dying anyway
   delete m_sock;
 }
 
@@ -215,125 +282,135 @@ MyFrame::~MyFrame()
 
 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
 {
-  // TRUE is to force the frame to close
-  Close(TRUE);
+  // true is to force the frame to close
+  Close(true);
 }
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
 {
-  wxMessageBox(_T("wxSocket demo: Client\n")
-               _T("(c) 1999 Guillermo Rodriguez Garcia\n"),
-               _T("About Client"),
+  wxMessageBox(_("wxSocket demo: Client\n(c) 1999 Guillermo Rodriguez Garcia\n"),
+               _("About Client"),
                wxOK | wxICON_INFORMATION, this);
 }
 
 void MyFrame::OnOpenConnection(wxCommandEvent& WXUNUSED(event))
 {
-  wxIPV4address addr;
+    OpenConnection(wxSockAddress::IPV4);
+}
+#if wxUSE_IPV6
+void MyFrame::OnOpenConnectionIPv6(wxCommandEvent& WXUNUSED(event))
+{
+    OpenConnection(wxSockAddress::IPV6);
+}
+#endif // wxUSE_IPV6
+
+void MyFrame::OpenConnection(wxSockAddress::Family family)
+{
+    wxUnusedVar(family); // unused in !wxUSE_IPV6 case
+
+  wxIPaddress * addr;
+  wxIPV4address addr4;
+#if wxUSE_IPV6
+  wxIPV6address addr6;
+  if ( family == wxSockAddress::IPV6 )
+    addr = &addr6;
+  else
+#endif
+    addr = &addr4;
 
-  m_menuSocket->Enable(CLIENT_OPEN, FALSE);
-  m_menuSocket->Enable(CLIENT_CLOSE, FALSE);
+  m_menuSocket->Enable(CLIENT_OPEN, false);
+#if wxUSE_IPV6
+  m_menuSocket->Enable(CLIENT_OPENIPV6, false);
+#endif
+  m_menuSocket->Enable(CLIENT_CLOSE, false);
 
-  // Ask server address
+  // Ask user for server address
   wxString hostname = wxGetTextFromUser(
-    _T("Enter the address of the wxSocket demo server:"),
-    _T("Connect ..."),
-    _T("localhost"));
+    _("Enter the address of the wxSocket demo server:"),
+    _("Connect ..."),
+    _("localhost"));
+  if ( hostname.empty() )
+    return;
 
-  addr.Hostname(hostname);
-  addr.Service(3000);
+  addr->Hostname(hostname);
+  addr->Service(3000);
 
-  // Non-blocking connect
-  m_text->AppendText(_T("Trying to connect (timeout = 10 sec) ...\n"));
-  m_sock->Connect(addr, FALSE);
-  m_sock->WaitOnConnect(10);
+  // we connect asynchronously and will get a wxSOCKET_CONNECTION event when
+  // the connection is really established
+  //
+  // if you want to make sure that connection is established right here you
+  // could call WaitOnConnect(timeout) instead
+  wxLogMessage("Trying to connect to %s:%d", hostname, addr->Service());
 
-  if (m_sock->IsConnected())
-    m_text->AppendText(_T("Succeeded ! Connection established\n"));
-  else
-  {
-    m_sock->Close();
-    m_text->AppendText(_T("Failed ! Unable to connect\n"));
-    wxMessageBox(_T("Can't connect to the specified host"), _T("Alert !"));
-  }
-  
-  UpdateStatusBar();
+  m_sock->Connect(*addr, false);
 }
 
 void MyFrame::OnTest1(wxCommandEvent& WXUNUSED(event))
 {
-  char *buf1, *buf2;
-  char len;
-
   // Disable socket menu entries (exception: Close Session)
-  m_busy = TRUE;
+  m_busy = true;
   UpdateStatusBar();
 
-  m_text->AppendText(_T("\n=== Test 1 begins ===\n"));
+  m_text->AppendText(_("\n=== Test 1 begins ===\n"));
 
   // Tell the server which test we are running
-  char c = 0xBE;
+  unsigned 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.
+  // sent or received and use the wxSOCKET_WAITALL flag. Also,
+  // we have disabled menu entries which could interfere with
+  // the test, so we can safely avoid the wxSOCKET_BLOCK 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
+  // value larger than a byte "as is" across 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];
+  const char *buf1 = "Test string (less than 256 chars!)";
+  unsigned char len  = (unsigned char)(wxStrlen(buf1) + 1);
+  wxCharBuffer buf2(wxStrlen(buf1));
 
-  m_text->AppendText(_T("Sending a test buffer to the server ..."));
+  m_text->AppendText(_("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(m_sock->Error() ? _("failed !\n") : _("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(_("Receiving the buffer back from server ..."));
+  m_sock->Read(buf2.data(), len);
+  m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
 
-  m_text->AppendText(_T("Comparing the two buffers ..."));
+  m_text->AppendText(_("Comparing the two buffers ..."));
   if (memcmp(buf1, buf2, len) != 0)
   {
-    m_text->AppendText(_T("failed!\n"));
-    m_text->AppendText(_T("Test 1 failed !\n"));
+    m_text->AppendText(_("failed!\n"));
+    m_text->AppendText(_("Test 1 failed !\n"));
   }
   else
   {
-    m_text->AppendText(_T("done\n"));
-    m_text->AppendText(_T("Test 1 passed !\n"));
+    m_text->AppendText(_("done\n"));
+    m_text->AppendText(_("Test 1 passed !\n"));
   }
-  m_text->AppendText(_T("=== Test 1 ends ===\n"));
+  m_text->AppendText(_("=== Test 1 ends ===\n"));
 
-  delete[] buf2;
-  m_busy = FALSE;
+  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;
+  m_busy = true;
   UpdateStatusBar();
 
-  m_text->AppendText(_T("\n=== Test 2 begins ===\n"));
+  m_text->AppendText(_("\n=== Test 2 begins ===\n"));
 
   // Tell the server which test we are running
-  char c = 0xCE;
+  unsigned char c = 0xCE;
   m_sock->Write(&c, 1);
 
   // Here we use ReadMsg and WriteMsg to send messages with
@@ -342,58 +419,103 @@ void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
   //
   // 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!"));
+    _("Enter an arbitrary string to send to the server:"),
+    _("Test 2 ..."),
+    _("Yes I like wxWidgets!"));
 
-  msg1 = (char *)s.c_str();
-  len  = wxStrlen(msg1) + 1;
-  msg2 = (char *)malloc(len);
+  const wxScopedCharBuffer msg1(s.utf8_str());
+  size_t len  = wxStrlen(msg1) + 1;
+  wxCharBuffer msg2(wxStrlen(msg1));
 
-  m_text->AppendText(_T("Sending the string with WriteMsg ..."));
+  m_text->AppendText(_("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"));
+  m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
+  m_text->AppendText(_("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 ..."));
+    m_text->AppendText(_("Reading the string back with ReadMsg ..."));
+    m_sock->ReadMsg(msg2.data(), len);
+    m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
+    m_text->AppendText(_("Comparing the two buffers ..."));
     if (memcmp(msg1, msg2, len) != 0)
     {
-      m_text->AppendText(_T("failed!\n"));  
-      m_text->AppendText(_T("Test 2 failed !\n"));
+      m_text->AppendText(_("failed!\n"));
+      m_text->AppendText(_("Test 2 failed !\n"));
     }
     else
     {
-      m_text->AppendText(_T("done\n"));
-      m_text->AppendText(_T("Test 2 passed !\n"));
+      m_text->AppendText(_("done\n"));
+      m_text->AppendText(_("Test 2 passed !\n"));
     }
   }
   else
-    m_text->AppendText(_T("Timeout ! Test 2 failed.\n"));
+    m_text->AppendText(_("Timeout ! Test 2 failed.\n"));
 
-  m_text->AppendText(_T("=== Test 2 ends ===\n"));
+  m_text->AppendText(_("=== Test 2 ends ===\n"));
 
-  free(msg2);
-  m_busy = FALSE;
+  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"));
+  // Disable socket menu entries (exception: Close Session)
+  m_busy = true;
+  UpdateStatusBar();
+
+  m_text->AppendText(_("\n=== Test 3 begins ===\n"));
+
+  // Tell the server which test we are running
+  unsigned char c = 0xDE;
+  m_sock->Write(&c, 1);
+
+  // This test also is similar to the first one but it sends a
+  // large buffer so that wxSocket is actually forced to split
+  // it into pieces and take care of sending everything before
+  // returning.
+
+  m_sock->SetFlags(wxSOCKET_WAITALL);
+
+  // Note that len is in kbytes here!
+  const unsigned char len  = 32;
+  wxCharBuffer buf1(len * 1024),
+               buf2(len * 1024);
+
+  for (size_t i = 0; i < len * 1024; i ++)
+    buf1.data()[i] = (char)(i % 256);
+
+  m_text->AppendText(_("Sending a large buffer (32K) to the server ..."));
+  m_sock->Write(&len, 1);
+  m_sock->Write(buf1, len * 1024);
+  m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
+
+  m_text->AppendText(_("Receiving the buffer back from server ..."));
+  m_sock->Read(buf2.data(), len * 1024);
+  m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
+
+  m_text->AppendText(_("Comparing the two buffers ..."));
+  if (memcmp(buf1, buf2, len) != 0)
+  {
+    m_text->AppendText(_("failed!\n"));
+    m_text->AppendText(_("Test 3 failed !\n"));
+  }
+  else
+  {
+    m_text->AppendText(_("done\n"));
+    m_text->AppendText(_("Test 3 passed !\n"));
+  }
+  m_text->AppendText(_("=== Test 3 ends ===\n"));
+
+  m_busy = false;
+  UpdateStatusBar();
 }
 
 void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
@@ -402,43 +524,165 @@ void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
   UpdateStatusBar();
 }
 
-void MyFrame::OnSocketEvent(wxSocketEvent& event)
+void MyFrame::OnDatagram(wxCommandEvent& WXUNUSED(event))
 {
-  wxString s = _T("OnSocketEvent: ");
+    wxString hostname = wxGetTextFromUser
+                        (
+                         "Enter the address of the wxSocket demo server:",
+                         "UDP peer",
+                         "localhost"
+                        );
+    if ( hostname.empty() )
+        return;
+
+    TestLogger logtest("UDP");
+
+    wxIPV4address addrLocal;
+    addrLocal.Hostname();
+    wxDatagramSocket sock(addrLocal);
+    if ( !sock.IsOk() )
+    {
+        wxLogMessage("ERROR: failed to create UDP socket");
+        return;
+    }
 
-  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;
-  }
+    wxLogMessage("Created UDP socket at %s:%u",
+                 addrLocal.IPAddress(), addrLocal.Service());
 
-  m_text->AppendText(s);
-  UpdateStatusBar();
+    wxIPV4address addrPeer;
+    addrPeer.Hostname(hostname);
+    addrPeer.Service(3000);
+
+    wxLogMessage("Testing UDP with peer at %s:%u",
+                 addrPeer.IPAddress(), addrPeer.Service());
+
+    char buf[] = "Uryyb sebz pyvrag!";
+    if ( sock.SendTo(addrPeer, buf, sizeof(buf)).LastCount() != sizeof(buf) )
+    {
+        wxLogMessage("ERROR: failed to send data");
+        return;
+    }
+
+    if ( sock.RecvFrom(addrPeer, buf, sizeof(buf)).LastCount() != sizeof(buf) )
+    {
+        wxLogMessage("ERROR: failed to receive data");
+        return;
+    }
+
+    wxLogMessage("Received \"%s\" from %s:%u.",
+                 wxString::From8BitData(buf, sock.LastCount()),
+                 addrPeer.IPAddress(), addrPeer.Service());
+}
+
+#if wxUSE_URL
+
+void MyFrame::OnTestURL(wxCommandEvent& WXUNUSED(event))
+{
+    // Ask for the URL
+    static wxString s_urlname("http://www.google.com/");
+    wxString urlname = wxGetTextFromUser
+                       (
+                        _("Enter an URL to get"),
+                        _("URL:"),
+                        s_urlname
+                       );
+    if ( urlname.empty() )
+        return; // cancelled by user
+
+    s_urlname = urlname;
+
+
+    TestLogger logtest("URL");
+
+    // Parse the URL
+    wxURL url(urlname);
+    if ( url.GetError() != wxURL_NOERR )
+    {
+        wxLogError("Failed to parse URL \"%s\"", urlname);
+        return;
+    }
+
+    // Try to get the input stream (connects to the given URL)
+    wxLogMessage("Establishing connection to \"%s\"...", urlname);
+    const std::auto_ptr<wxInputStream> data(url.GetInputStream());
+    if ( !data.get() )
+    {
+        wxLogError("Failed to retrieve URL \"%s\"", urlname);
+        return;
+    }
+
+    // Print the contents type and file size
+    wxLogMessage("Contents type: %s\nFile size: %i\nStarting to download...",
+                 url.GetProtocol().GetContentType(),
+                 data->GetSize());
+
+    // Get the data
+    wxStringOutputStream sout;
+    if ( data->Read(sout).GetLastError() != wxSTREAM_EOF )
+    {
+        wxLogError("Error reading the input stream.");
+    }
+
+    wxLogMessage("Text retrieved from URL \"%s\" follows:\n%s",
+                 urlname, sout.GetString());
+}
+
+#endif // wxUSE_URL
+
+void MyFrame::OnSocketEvent(wxSocketEvent& event)
+{
+    switch ( event.GetSocketEvent() )
+    {
+        case wxSOCKET_INPUT:
+            wxLogMessage("Input available on the socket");
+            break;
+
+        case wxSOCKET_LOST:
+            wxLogMessage("Socket connection was unexpectedly lost.");
+            UpdateStatusBar();
+            break;
+
+        case wxSOCKET_CONNECTION:
+            wxLogMessage("... socket is now connected.");
+            UpdateStatusBar();
+            break;
+
+        default:
+            wxLogMessage("Unknown socket event!!!");
+            break;
+    }
 }
 
 // convenience functions
 
 void MyFrame::UpdateStatusBar()
 {
+#if wxUSE_STATUSBAR
   wxString s;
 
   if (!m_sock->IsConnected())
   {
-    s.Printf(_T("Not connected"));
+    s = "Not connected";
   }
   else
   {
+#if wxUSE_IPV6
+    wxIPV6address addr;
+#else
     wxIPV4address addr;
+#endif
 
     m_sock->GetPeer(addr);
-    s.Printf(_T("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
+    s.Printf("%s : %d", addr.Hostname(), addr.Service());
   }
 
   SetStatusText(s, 1);
+#endif // wxUSE_STATUSBAR
 
   m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
+#if wxUSE_IPV6
+  m_menuSocket->Enable(CLIENT_OPENIPV6, !m_sock->IsConnected() && !m_busy);
+#endif
   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);