// Name: server.cpp
// Purpose: Server for wxSocket demo
// Author: Guillermo Rodriguez Garcia <guille@iies.es>
-// Modified by:
// Created: 1999/09/19
// RCS-ID: $Id$
// Copyright: (c) 1999 Guillermo Rodriguez Garcia
+// (c) 2009 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// headers
// --------------------------------------------------------------------------
-#ifdef __GNUG__
-# pragma implementation "server.cpp"
-# pragma interface "server.cpp"
-#endif
-
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
# 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/busyinfo.h"
#include "wx/socket.h"
+// this example is currently written to use only IP or only IPv6 sockets, it
+// should be extended to allow using either in the future
+#if wxUSE_IPV6
+ typedef wxIPV6address IPaddress;
+#else
+ typedef wxIPV4address IPaddress;
+#endif
+
// --------------------------------------------------------------------------
// resources
// --------------------------------------------------------------------------
// the application icon
-#if defined(__WXGTK__) || defined(__WXMOTIF__)
-# include "mondrian.xpm"
+#if !defined(__WXMSW__) && !defined(__WXPM__)
+ #include "../sample.xpm"
#endif
// --------------------------------------------------------------------------
~MyFrame();
// event handlers (these functions should _not_ be virtual)
+ void OnUDPTest(wxCommandEvent& event);
+ void OnWaitForAccept(wxCommandEvent& event);
void OnQuit(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
void OnServerEvent(wxSocketEvent& event);
bool m_busy;
int m_numClients;
- // 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 begins ===", m_name);
+ }
+
+ ~TestLogger()
+ {
+ wxLogMessage("=== %s ends ===", m_name);
+ }
+
+private:
+ const wxString m_name;
+};
+
// --------------------------------------------------------------------------
// constants
// --------------------------------------------------------------------------
enum
{
// menu items
- SERVER_QUIT = 1000,
- SERVER_ABOUT,
+ SERVER_UDPTEST = 10,
+ SERVER_WAITFORACCEPT,
+ SERVER_QUIT = wxID_EXIT,
+ SERVER_ABOUT = wxID_ABOUT,
// id for sockets
- SERVER_ID,
+ SERVER_ID = 100,
SOCKET_ID
};
// --------------------------------------------------------------------------
-// event tables and other macros for wxWindows
+// event tables and other macros for wxWidgets
// --------------------------------------------------------------------------
BEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(SERVER_QUIT, MyFrame::OnQuit)
EVT_MENU(SERVER_ABOUT, MyFrame::OnAbout)
+ EVT_MENU(SERVER_UDPTEST, MyFrame::OnUDPTest)
+ EVT_MENU(SERVER_WAITFORACCEPT, MyFrame::OnWaitForAccept)
EVT_SOCKET(SERVER_ID, MyFrame::OnServerEvent)
EVT_SOCKET(SOCKET_ID, MyFrame::OnSocketEvent)
END_EVENT_TABLE()
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;
}
// --------------------------------------------------------------------------
// frame constructor
-MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, -1,
+MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
_("wxSocket demo: Server"),
wxDefaultPosition, wxSize(300, 200))
{
// Give the frame an icon
- SetIcon(wxICON(mondrian));
+ SetIcon(wxICON(sample));
// Make menus
m_menuFile = new wxMenu();
+ m_menuFile->Append(SERVER_WAITFORACCEPT, "&Wait for connection\tCtrl-W");
+ m_menuFile->Append(SERVER_UDPTEST, "&UDP test\tCtrl-U");
+ m_menuFile->AppendSeparator();
m_menuFile->Append(SERVER_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
m_menuFile->AppendSeparator();
m_menuFile->Append(SERVER_QUIT, _("E&xit\tAlt-X"), _("Quit server"));
m_menuBar->Append(m_menuFile, _("&File"));
SetMenuBar(m_menuBar);
+#if wxUSE_STATUSBAR
// Status bar
CreateStatusBar(2);
+#endif // wxUSE_STATUSBAR
// Make a textctrl for logging
- m_text = new wxTextCtrl(this, -1,
+ m_text = new wxTextCtrl(this, wxID_ANY,
_("Welcome to wxSocket demo: Server\n"),
wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE | wxTE_READONLY);
+ delete wxLog::SetActiveTarget(new wxLogTextCtrl(m_text));
// Create the address - defaults to localhost:0 initially
- wxIPV4address addr;
+ IPaddress addr;
addr.Service(3000);
+ wxLogMessage("Creating server at %s:%u", addr.IPAddress(), addr.Service());
+
// Create the socket
m_server = new wxSocketServer(addr);
// We use Ok() here to see if the server is really listening
if (! m_server->Ok())
{
- m_text->AppendText(_("Could not listen at the specified port !\n\n"));
+ wxLogMessage("Could not listen at the specified port !");
return;
}
+
+ IPaddress addrReal;
+ if ( !m_server->GetLocal(addrReal) )
+ {
+ wxLogMessage("ERROR: couldn't get the address we bound to");
+ }
else
{
- m_text->AppendText(_("Server listening.\n\n"));
+ wxLogMessage("Server listening at %s:%u",
+ addrReal.IPAddress(), addrReal.Service());
}
// Setup the event handler and subscribe to connection events
m_server->SetEventHandler(*this, SERVER_ID);
m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
- m_server->Notify(TRUE);
+ m_server->Notify(true);
- m_busy = FALSE;
+ m_busy = false;
m_numClients = 0;
UpdateStatusBar();
}
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(_("wxSocket demo: Server\n"
- "(c) 1999 Guillermo Rodriguez Garcia\n"),
+ wxMessageBox(_("wxSocket demo: Server\n(c) 1999 Guillermo Rodriguez Garcia\n"),
_("About Server"),
wxOK | wxICON_INFORMATION, this);
}
-void MyFrame::Test1(wxSocketBase *sock)
+void MyFrame::OnUDPTest(wxCommandEvent& WXUNUSED(event))
{
- unsigned char len;
- char *buf;
+ TestLogger logtest("UDP test");
- m_text->AppendText(_("Test 1 begins\n"));
+ IPaddress addr;
+ addr.Service(3000);
+ wxDatagramSocket sock(addr);
+
+ char buf[1024];
+ size_t n = sock.RecvFrom(addr, buf, sizeof(buf)).LastCount();
+ if ( !n )
+ {
+ wxLogMessage("ERROR: failed to receive data");
+ return;
+ }
+
+ wxLogMessage("Received \"%s\" from %s:%u.",
+ wxString::From8BitData(buf, n),
+ addr.IPAddress(), addr.Service());
+
+ for ( size_t i = 0; i < n; i++ )
+ {
+ char& c = buf[i];
+ if ( (c >= 'A' && c <= 'M') || (c >= 'a' && c <= 'm') )
+ c += 13;
+ else if ( (c >= 'N' && c <= 'Z') || (c >= 'n' && c <= 'z') )
+ c -= 13;
+ }
+
+ if ( sock.SendTo(addr, buf, n).LastCount() != n )
+ {
+ wxLogMessage("ERROR: failed to send data");
+ return;
+ }
+}
+
+void MyFrame::OnWaitForAccept(wxCommandEvent& WXUNUSED(event))
+{
+ TestLogger logtest("WaitForAccept() test");
+
+ wxBusyInfo("Waiting for connection for 10 seconds...", this);
+ if ( m_server->WaitForAccept(10) )
+ wxLogMessage("Accepted client connection.");
+ else
+ wxLogMessage("Connection error or timeout expired.");
+}
+
+void MyFrame::Test1(wxSocketBase *sock)
+{
+ TestLogger logtest("Test 1");
// Receive data from socket and send it back. We will first
// get a byte with the buffer size, so we can specify the
sock->SetFlags(wxSOCKET_WAITALL);
+ // Read the size
+ unsigned char len;
sock->Read(&len, 1);
+ wxCharBuffer buf(len);
- buf = new char[len];
- sock->Read(buf, len);
- sock->Write(buf, len);
- delete[] buf;
+ // Read the data
+ sock->Read(buf.data(), len);
+ wxLogMessage("Got the data, sending it back");
- m_text->AppendText(_("Test 1 ends\n"));
+ // Write it back
+ sock->Write(buf, len);
}
void MyFrame::Test2(wxSocketBase *sock)
{
-#define MAX_MSG_SIZE 10000
-
- wxString s;
- char *buf = new char[MAX_MSG_SIZE];
- wxUint32 len;
+ char buf[4096];
- m_text->AppendText(_("Test 2 begins\n"));
+ TestLogger logtest("Test 2");
// 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();
+ // Read the message
+ wxUint32 len = sock->ReadMsg(buf, sizeof(buf)).LastCount();
+ if ( !len )
+ {
+ wxLogError("Failed to read message.");
+ return;
+ }
- s.Printf(_("Client says: %s\n"), buf);
- m_text->AppendText(s);
- m_text->AppendText(_("Sending the data back\n"));
+ wxLogMessage("Got \"%s\" from client.", wxString::FromUTF8(buf, len));
+ wxLogMessage("Sending the data back");
+ // Write it back
sock->WriteMsg(buf, len);
- delete[] buf;
-
- m_text->AppendText(_("Test 2 ends\n"));
-
-#undef MAX_MSG_SIZE
}
void MyFrame::Test3(wxSocketBase *sock)
{
- unsigned char len;
- char *buf;
+ TestLogger logtest("Test 3");
- m_text->AppendText(_("Test 3 begins\n"));
-
- // This test is similar to the first one, but the len is
+ // This test is similar to the first one, but the len is
// expressed in kbytes - this tests large data transfers.
sock->SetFlags(wxSOCKET_WAITALL);
+ // Read the size
+ unsigned char len;
sock->Read(&len, 1);
- buf = new char[len * 1024];
- sock->Read(buf, len * 1024);
- sock->Write(buf, len * 1024);
- delete[] buf;
+ wxCharBuffer buf(len*1024);
+
+ // Read the data
+ sock->Read(buf.data(), len * 1024);
+ wxLogMessage("Got the data, sending it back");
- m_text->AppendText(_("Test 3 ends\n"));
+ // Write it back
+ sock->Write(buf, len * 1024);
}
void MyFrame::OnServerEvent(wxSocketEvent& event)
wxString s = _("OnServerEvent: ");
wxSocketBase *sock;
- switch(event.SocketEvent())
+ switch(event.GetSocketEvent())
{
case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
default : s.Append(_("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
+ // 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);
+ sock = m_server->Accept(false);
if (sock)
{
- m_text->AppendText(_("New client connection accepted\n"));
+ IPaddress addr;
+ if ( !sock->GetPeer(addr) )
+ {
+ wxLogMessage("New connection from unknown client accepted.");
+ }
+ else
+ {
+ wxLogMessage("New client connection from %s:%u accepted",
+ addr.IPAddress(), addr.Service());
+ }
}
else
{
- m_text->AppendText(_("Error: couldn't accept a new connection"));
+ wxLogMessage("Error: couldn't accept a new connection");
return;
}
sock->SetEventHandler(*this, SOCKET_ID);
sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
- sock->Notify(TRUE);
+ sock->Notify(true);
m_numClients++;
UpdateStatusBar();
void MyFrame::OnSocketEvent(wxSocketEvent& event)
{
- wxSocketBase *sock = event.Socket();
wxString s = _("OnSocketEvent: ");
+ wxSocketBase *sock = event.GetSocket();
- // We first print a msg
- switch(event.SocketEvent())
+ // First, print a message
+ switch(event.GetSocketEvent())
{
- case wxSOCKET_INPUT: s.Append(_("wxSOCKET_INPUT\n")); break;
- case wxSOCKET_LOST: s.Append(_("wxSOCKET_LOST\n")); break;
- default: s.Append(_("unexpected event !\n"));
+ case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
+ case wxSOCKET_LOST : s.Append(_("wxSOCKET_LOST\n")); break;
+ default : s.Append(_("Unexpected event !\n")); break;
}
m_text->AppendText(s);
// Now we process the event
- switch(event.SocketEvent())
+ switch(event.GetSocketEvent())
{
case wxSOCKET_INPUT:
{
// Which test are we going to run?
unsigned char c;
- sock->Read(&c ,1);
+ sock->Read(&c, 1);
switch (c)
{
case 0xBE: Test1(sock); break;
case 0xCE: Test2(sock); break;
case 0xDE: Test3(sock); break;
- default: s.Append(_("Unknown test id received from client\n"));
+ default:
+ wxLogMessage("Unknown test id received from client");
}
// Enable input events again.
// has been deleted. Also, we might be doing some other thing with
// the socket at the same time; for example, we might be in the
// middle of a test or something. Destroy() takes care of all
- // this for us. The only case where delete should be used instead
- // is when the event handler itself is also being destroyed; for
- // example, see the frame dtor above.
+ // this for us.
- m_text->AppendText(_("Deleting socket.\n"));
+ wxLogMessage("Deleting socket.");
sock->Destroy();
break;
}
void MyFrame::UpdateStatusBar()
{
+#if wxUSE_STATUSBAR
wxString s;
s.Printf(_("%d clients connected"), m_numClients);
SetStatusText(s, 1);
+#endif // wxUSE_STATUSBAR
}
projects / wxWidgets.git / blobdiff