src/common/sckipc.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        sckipc.cpp
// Purpose:     Interprocess communication implementation (wxSocket version)
// Author:      Julian Smart
// Modified by: Guilhem Lavaux (big rewrite) May 1997, 1998
//              Guillermo Rodriguez (updated for wxSocket v2) Jan 2000
//                                  (callbacks deprecated)    Mar 2000
// Created:     1993
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart 1993
//              (c) Guilhem Lavaux 1997, 1998
//              (c) 2000 Guillermo Rodriguez <guille@iies.es>
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// ==========================================================================
// declarations
// ==========================================================================

// --------------------------------------------------------------------------
// headers
// --------------------------------------------------------------------------

#ifdef __GNUG__
#pragma implementation "sckipc.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/defs.h"
#endif

#if wxUSE_SOCKETS && wxUSE_IPC && wxUSE_STREAMS

#include <stdlib.h>
#include <stdio.h>

#include "wx/socket.h"
#include "wx/sckipc.h"
#include "wx/module.h"
#include "wx/event.h"
#include "wx/log.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

// --------------------------------------------------------------------------
// macros and constants
// --------------------------------------------------------------------------

// It seems to be already defined somewhere in the Xt includes.
#ifndef __XT__
// Message codes
enum
{
  IPC_EXECUTE = 1,
  IPC_REQUEST,
  IPC_POKE,
  IPC_ADVISE_START,
  IPC_ADVISE_REQUEST,
  IPC_ADVISE,
  IPC_ADVISE_STOP,
  IPC_REQUEST_REPLY,
  IPC_FAIL,
  IPC_CONNECT,
  IPC_DISCONNECT
};
#endif


// All sockets will be created with the following flags
#define SCKIPC_FLAGS (wxSOCKET_WAITALL)

// --------------------------------------------------------------------------
// wxTCPEventHandler stuff (private class)
// --------------------------------------------------------------------------

class wxTCPEventHandler : public wxEvtHandler
{
public:
  wxTCPEventHandler() : wxEvtHandler() {};

  void Client_OnRequest(wxSocketEvent& event);
  void Server_OnRequest(wxSocketEvent& event);

  DECLARE_EVENT_TABLE()
};

enum
{
  _CLIENT_ONREQUEST_ID = 1000,
  _SERVER_ONREQUEST_ID
};

static wxTCPEventHandler *gs_handler = NULL;

// ==========================================================================
// implementation
// ==========================================================================

IMPLEMENT_DYNAMIC_CLASS(wxTCPServer, wxServerBase)
IMPLEMENT_DYNAMIC_CLASS(wxTCPClient, wxClientBase)
IMPLEMENT_CLASS(wxTCPConnection, wxConnectionBase)

// --------------------------------------------------------------------------
// wxTCPClient
// --------------------------------------------------------------------------

wxTCPClient::wxTCPClient () : wxClientBase()
{
}

wxTCPClient::~wxTCPClient ()
{
}

bool wxTCPClient::ValidHost(const wxString& host)
{
  wxIPV4address addr;

  return addr.Hostname(host);
}

wxConnectionBase *wxTCPClient::MakeConnection (const wxString& host,
                                               const wxString& server_name,
                                               const wxString& topic)
{
  wxSocketClient *client = new wxSocketClient(SCKIPC_FLAGS);
  wxSocketStream *stream = new wxSocketStream(*client);
  wxDataInputStream *data_is = new wxDataInputStream(*stream);
  wxDataOutputStream *data_os = new wxDataOutputStream(*stream);

  wxIPV4address addr;
  addr.Service(server_name);
  addr.Hostname(host);

  if (client->Connect(addr))
  {
    unsigned char msg;

    // Send topic name, and enquire whether this has succeeded
    data_os->Write8(IPC_CONNECT);
    data_os->WriteString(topic);

    msg = data_is->Read8();

    // OK! Confirmation.
    if (msg == IPC_CONNECT)
    {
      wxTCPConnection *connection = (wxTCPConnection *)OnMakeConnection ();

      if (connection)
      {
        if (connection->IsKindOf(CLASSINFO(wxTCPConnection)))
        {
          connection->m_topic = topic;
          connection->m_sock  = client;
          connection->m_sockstrm = stream;
          connection->m_codeci = data_is;
          connection->m_codeco = data_os;
          client->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
          client->SetClientData(connection);
          client->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
          client->Notify(TRUE);
          return connection;
        }
        else
        {
          delete connection;
          // and fall through to delete everything else
        }
      }
    }
  }

  // Something went wrong, delete everything
  delete data_is;
  delete data_os;
  delete stream;
  client->Destroy();

  return NULL;
}

wxConnectionBase *wxTCPClient::OnMakeConnection()
{
  return new wxTCPConnection();
}

// --------------------------------------------------------------------------
// wxTCPServer
// --------------------------------------------------------------------------

wxTCPServer::wxTCPServer () : wxServerBase()
{
  m_server = NULL;
}

bool wxTCPServer::Create(const wxString& serverName)
{
  // Destroy previous server, if any
  if (m_server)
  {
    m_server->SetClientData(NULL);
    m_server->Destroy();
    m_server = NULL;
  }

  // wxIPV4address defaults to INADDR_ANY:0
  wxIPV4address addr;
  addr.Service(serverName);

  // Create a socket listening on the specified port
  m_server = new wxSocketServer(addr, SCKIPC_FLAGS);

  if (!m_server->Ok())
  {
    m_server->Destroy();
    m_server = NULL;

    return FALSE;
  }

  m_server->SetEventHandler(*gs_handler, _SERVER_ONREQUEST_ID);
  m_server->SetClientData(this);
  m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
  m_server->Notify(TRUE);

  return TRUE;
}

wxTCPServer::~wxTCPServer()
{
  if (m_server)
  {
    m_server->SetClientData(NULL);
    m_server->Destroy();
  }
}

wxConnectionBase *wxTCPServer::OnAcceptConnection( const wxString& WXUNUSED(topic) )
{
  return new wxTCPConnection();
}

// --------------------------------------------------------------------------
// wxTCPConnection
// --------------------------------------------------------------------------

wxTCPConnection::wxTCPConnection () : wxConnectionBase()
{
  m_sock     = NULL;
  m_sockstrm = NULL;
  m_codeci   = NULL;
  m_codeco   = NULL;
}

wxTCPConnection::wxTCPConnection(char * WXUNUSED(buffer), int WXUNUSED(size))
{
}

wxTCPConnection::~wxTCPConnection ()
{
  wxDELETE(m_codeci);
  wxDELETE(m_codeco);
  wxDELETE(m_sockstrm);

  if (m_sock)
  {
    m_sock->SetClientData(NULL);
    m_sock->Destroy();
  }
}

void wxTCPConnection::Compress(bool WXUNUSED(on))
{
  // Use wxLZWStream
}

// Calls that CLIENT can make.
bool wxTCPConnection::Disconnect ()
{
  // Send the the disconnect message to the peer.
  m_codeco->Write8(IPC_DISCONNECT);
  m_sock->Notify(FALSE);
  m_sock->Close();

  return TRUE;
}

bool wxTCPConnection::Execute(const wxChar *data, int size, wxIPCFormat format)
{
  if (!m_sock->IsConnected())
    return FALSE;

  // Prepare EXECUTE message
  m_codeco->Write8(IPC_EXECUTE);
  m_codeco->Write8(format);

  if (size < 0)
    size = wxStrlen(data) + 1;    // includes final NUL

  m_codeco->Write32(size);
  m_sockstrm->Write(data, size);

  return TRUE;
}

char *wxTCPConnection::Request (const wxString& item, int *size, wxIPCFormat format)
{
  if (!m_sock->IsConnected())
    return NULL;

  m_codeco->Write8(IPC_REQUEST);
  m_codeco->WriteString(item);
  m_codeco->Write8(format);

  // If Unpack doesn't initialize it.
  int ret;

  ret = m_codeci->Read8();
  if (ret == IPC_FAIL)
    return NULL;
  else
  {
    size_t s;
    char *data = NULL;

    s = m_codeci->Read32();
    data = new char[s];
    m_sockstrm->Read(data, s);

    if (size)
      *size = s;
    return data;
  }
}

bool wxTCPConnection::Poke (const wxString& item, wxChar *data, int size, wxIPCFormat format)
{
  if (!m_sock->IsConnected())
    return FALSE;

  m_codeco->Write8(IPC_POKE);
  m_codeco->WriteString(item);
  m_codeco->Write8(format);

  if (size < 0)
    size = wxStrlen(data) + 1;    // includes final NUL

  m_codeco->Write32(size);
  m_sockstrm->Write(data, size);

  return TRUE;
}

bool wxTCPConnection::StartAdvise (const wxString& item)
{
  int ret;

  if (!m_sock->IsConnected())
    return FALSE;

  m_codeco->Write8(IPC_ADVISE_START);
  m_codeco->WriteString(item);

  ret = m_codeci->Read8();

  if (ret != IPC_FAIL)
    return TRUE;
  else
    return FALSE;
}

bool wxTCPConnection::StopAdvise (const wxString& item)
{
  int msg;

  if (!m_sock->IsConnected())
    return FALSE;

  m_codeco->Write8(IPC_ADVISE_STOP);
  m_codeco->WriteString(item);

  msg = m_codeci->Read8();

  if (msg != IPC_FAIL)
    return TRUE;
  else
    return FALSE;
}

// Calls that SERVER can make
bool wxTCPConnection::Advise (const wxString& item,
                              wxChar *data, int size, wxIPCFormat format)
{
  if (!m_sock->IsConnected())
    return FALSE;

  m_codeco->Write8(IPC_ADVISE);
  m_codeco->WriteString(item);
  m_codeco->Write8(format);

  if (size < 0)
    size = wxStrlen(data) + 1;    // includes final NUL

  m_codeco->Write32(size);
  m_sockstrm->Write(data, size);

  return TRUE;
}

// --------------------------------------------------------------------------
// wxTCPEventHandler (private class)
// --------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxTCPEventHandler, wxEvtHandler)
  EVT_SOCKET(_CLIENT_ONREQUEST_ID, wxTCPEventHandler::Client_OnRequest)
  EVT_SOCKET(_SERVER_ONREQUEST_ID, wxTCPEventHandler::Server_OnRequest)
END_EVENT_TABLE()

void wxTCPEventHandler::Client_OnRequest(wxSocketEvent &event)
{
  wxSocketBase *sock = event.GetSocket();
  wxSocketNotify evt = event.GetSocketEvent();
  wxTCPConnection *connection = (wxTCPConnection *)(sock->GetClientData());

  // This socket is being deleted; skip this event
  if (!connection)
    return;

  int msg = 0;
  wxDataInputStream *codeci;
  wxDataOutputStream *codeco;
  wxSocketStream *sockstrm;
  wxString topic_name = connection->m_topic;
  wxString item;

  // We lost the connection: destroy everything
  if (evt == wxSOCKET_LOST)
  {
    sock->Notify(FALSE);
    sock->Close();
    connection->OnDisconnect();
    return;
  }

  // Receive message number.
  codeci = connection->m_codeci;
  codeco = connection->m_codeco;
  sockstrm = connection->m_sockstrm;
  msg = codeci->Read8();

  switch (msg)
  {
  case IPC_EXECUTE:
  {
    char *data;
    size_t size;
    wxIPCFormat format;

    format = (wxIPCFormat)codeci->Read8();
    size = codeci->Read32();
    data = new char[size];
    sockstrm->Read(data, size);

    connection->OnExecute (topic_name, data, size, format);

    delete [] data;
    break;
  }
  case IPC_ADVISE:
  {
    char *data;
    size_t size;
    wxIPCFormat format;

    item = codeci->ReadString();
    format = (wxIPCFormat)codeci->Read8();
    size = codeci->Read32();
    data = new char[size];
    sockstrm->Read(data, size);

    connection->OnAdvise (topic_name, item, data, size, format);

    delete [] data;
    break;
  }
  case IPC_ADVISE_START:
  {
    item = codeci->ReadString();

    bool ok = connection->OnStartAdvise (topic_name, item);
    if (ok)
      codeco->Write8(IPC_ADVISE_START);
    else
      codeco->Write8(IPC_FAIL);

    break;
  }
  case IPC_ADVISE_STOP:
  {
    item = codeci->ReadString();

    bool ok = connection->OnStopAdvise (topic_name, item);
    if (ok)
      codeco->Write8(IPC_ADVISE_STOP);
    else
      codeco->Write8(IPC_FAIL);

    break;
  }
  case IPC_POKE:
  {
    wxIPCFormat format;
    size_t size;
    wxChar *data;

    item = codeci->ReadString();
    format = (wxIPCFormat)codeci->Read8();
    size = codeci->Read32();
    data = new wxChar[size];
    sockstrm->Read(data, size);

    connection->OnPoke (topic_name, item, data, size, format);

    delete [] data;

    break;
  }
  case IPC_REQUEST:
  {
    wxIPCFormat format;

    item = codeci->ReadString();
    format = (wxIPCFormat)codeci->Read8();

    int user_size = -1;
    char *user_data = connection->OnRequest (topic_name, item, &user_size, format);

    if (user_data)
    {
      codeco->Write8(IPC_REQUEST_REPLY);

      if (user_size == -1)
        user_size = strlen(user_data) + 1;      // includes final NUL

      codeco->Write32(user_size);
      sockstrm->Write(user_data, user_size);
    }
    else
      codeco->Write8(IPC_FAIL);

    break;
  }
  case IPC_DISCONNECT:
  {
    sock->Notify(FALSE);
    sock->Close();
    connection->OnDisconnect();
    break;
  }
  default:
    codeco->Write8(IPC_FAIL);
    break;
  }
}

void wxTCPEventHandler::Server_OnRequest(wxSocketEvent &event)
{
  wxSocketServer *server = (wxSocketServer *) event.GetSocket();
  wxTCPServer *ipcserv = (wxTCPServer *) server->GetClientData();

  // This socket is being deleted; skip this event
  if (!ipcserv)
    return;

  if (event.GetSocketEvent() != wxSOCKET_CONNECTION)
    return;

  // Accept the connection, getting a new socket
  wxSocketBase *sock = server->Accept();
  if (!sock->Ok())
  {
    sock->Destroy();
    return;
  }

  wxSocketStream *stream     = new wxSocketStream(*sock);
  wxDataInputStream *codeci  = new wxDataInputStream(*stream);
  wxDataOutputStream *codeco = new wxDataOutputStream(*stream);

  int msg;
  msg = codeci->Read8();

  if (msg == IPC_CONNECT)
  {
    wxString topic_name;
    topic_name = codeci->ReadString();

    wxTCPConnection *new_connection =
         (wxTCPConnection *)ipcserv->OnAcceptConnection (topic_name);

    if (new_connection)
    {
      if (new_connection->IsKindOf(CLASSINFO(wxTCPConnection)))
      {
        // Acknowledge success
        codeco->Write8(IPC_CONNECT);
        new_connection->m_topic = topic_name;
        new_connection->m_sock = sock;
        new_connection->m_sockstrm = stream;
        new_connection->m_codeci = codeci;
        new_connection->m_codeco = codeco;
        sock->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
        sock->SetClientData(new_connection);
        sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
        sock->Notify(TRUE);
        return;
      }
      else
      {
        delete new_connection;
        // and fall through to delete everything else
      }
    }
  }

  // Something went wrong, send failure message and delete everything
  codeco->Write8(IPC_FAIL);

  delete codeco;
  delete codeci;
  delete stream;
  sock->Destroy();
}

// --------------------------------------------------------------------------
// wxTCPEventHandlerModule (private class)
// --------------------------------------------------------------------------

class WXDLLEXPORT wxTCPEventHandlerModule: public wxModule
{
  DECLARE_DYNAMIC_CLASS(wxTCPEventHandlerModule)

public:
  bool OnInit() { gs_handler = new wxTCPEventHandler(); return TRUE; }
  void OnExit() { wxDELETE(gs_handler); }
};

IMPLEMENT_DYNAMIC_CLASS(wxTCPEventHandlerModule, wxModule)


#endif
    // wxUSE_SOCKETS && wxUSE_IPC
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: sckipc.cpp
	3	// Purpose: Interprocess communication implementation (wxSocket version)
	4	// Author: Julian Smart
	5	// Modified by: Guilhem Lavaux (big rewrite) May 1997, 1998
	6	// Guillermo Rodriguez (updated for wxSocket v2) Jan 2000
	7	// (callbacks deprecated) Mar 2000
	8	// Created: 1993
	9	// RCS-ID: $Id$
	10	// Copyright: (c) Julian Smart 1993
	11	// (c) Guilhem Lavaux 1997, 1998
	12	// (c) 2000 Guillermo Rodriguez <guille@iies.es>
	13	// Licence: wxWindows license
	14	/////////////////////////////////////////////////////////////////////////////
	15
	16	// ==========================================================================
	17	// declarations
	18	// ==========================================================================
	19
	20	// --------------------------------------------------------------------------
	21	// headers
	22	// --------------------------------------------------------------------------
	23
	24	#ifdef __GNUG__
	25	#pragma implementation "sckipc.h"
	26	#endif
	27
	28	// For compilers that support precompilation, includes "wx.h".
	29	#include "wx/wxprec.h"
	30
	31	#ifdef __BORLANDC__
	32	#pragma hdrstop
	33	#endif
	34
	35	#ifndef WX_PRECOMP
	36	#include "wx/defs.h"
	37	#endif
	38
	39	#if wxUSE_SOCKETS && wxUSE_IPC && wxUSE_STREAMS
	40
	41	#include <stdlib.h>
	42	#include <stdio.h>
	43
	44	#include "wx/socket.h"
	45	#include "wx/sckipc.h"
	46	#include "wx/module.h"
	47	#include "wx/event.h"
	48	#include "wx/log.h"
	49
	50	#ifdef __BORLANDC__
	51	#pragma hdrstop
	52	#endif
	53
	54	// --------------------------------------------------------------------------
	55	// macros and constants
	56	// --------------------------------------------------------------------------
	57
	58	// It seems to be already defined somewhere in the Xt includes.
	59	#ifndef __XT__
	60	// Message codes
	61	enum
	62	{
	63	IPC_EXECUTE = 1,
	64	IPC_REQUEST,
	65	IPC_POKE,
	66	IPC_ADVISE_START,
	67	IPC_ADVISE_REQUEST,
	68	IPC_ADVISE,
	69	IPC_ADVISE_STOP,
	70	IPC_REQUEST_REPLY,
	71	IPC_FAIL,
	72	IPC_CONNECT,
	73	IPC_DISCONNECT
	74	};
	75	#endif
	76
	77
	78	// All sockets will be created with the following flags
	79	#define SCKIPC_FLAGS (wxSOCKET_WAITALL)
	80
	81	// --------------------------------------------------------------------------
	82	// wxTCPEventHandler stuff (private class)
	83	// --------------------------------------------------------------------------
	84
	85	class wxTCPEventHandler : public wxEvtHandler
	86	{
	87	public:
	88	wxTCPEventHandler() : wxEvtHandler() {};
	89
	90	void Client_OnRequest(wxSocketEvent& event);
	91	void Server_OnRequest(wxSocketEvent& event);
	92
	93	DECLARE_EVENT_TABLE()
	94	};
	95
	96	enum
	97	{
	98	_CLIENT_ONREQUEST_ID = 1000,
	99	_SERVER_ONREQUEST_ID
	100	};
	101
	102	static wxTCPEventHandler *gs_handler = NULL;
	103
	104	// ==========================================================================
	105	// implementation
	106	// ==========================================================================
	107
	108	IMPLEMENT_DYNAMIC_CLASS(wxTCPServer, wxServerBase)
	109	IMPLEMENT_DYNAMIC_CLASS(wxTCPClient, wxClientBase)
	110	IMPLEMENT_CLASS(wxTCPConnection, wxConnectionBase)
	111
	112	// --------------------------------------------------------------------------
	113	// wxTCPClient
	114	// --------------------------------------------------------------------------
	115
	116	wxTCPClient::wxTCPClient () : wxClientBase()
	117	{
	118	}
	119
	120	wxTCPClient::~wxTCPClient ()
	121	{
	122	}
	123
	124	bool wxTCPClient::ValidHost(const wxString& host)
	125	{
	126	wxIPV4address addr;
	127
	128	return addr.Hostname(host);
	129	}
	130
	131	wxConnectionBase *wxTCPClient::MakeConnection (const wxString& host,
	132	const wxString& server_name,
	133	const wxString& topic)
	134	{
	135	wxSocketClient *client = new wxSocketClient(SCKIPC_FLAGS);
	136	wxSocketStream stream = new wxSocketStream(client);
	137	wxDataInputStream data_is = new wxDataInputStream(stream);
	138	wxDataOutputStream data_os = new wxDataOutputStream(stream);
	139
	140	wxIPV4address addr;
	141	addr.Service(server_name);
	142	addr.Hostname(host);
	143
	144	if (client->Connect(addr))
	145	{
	146	unsigned char msg;
	147
	148	// Send topic name, and enquire whether this has succeeded
	149	data_os->Write8(IPC_CONNECT);
	150	data_os->WriteString(topic);
	151
	152	msg = data_is->Read8();
	153
	154	// OK! Confirmation.
	155	if (msg == IPC_CONNECT)
	156	{
	157	wxTCPConnection connection = (wxTCPConnection )OnMakeConnection ();
	158
	159	if (connection)
	160	{
	161	if (connection->IsKindOf(CLASSINFO(wxTCPConnection)))
	162	{
	163	connection->m_topic = topic;
	164	connection->m_sock = client;
	165	connection->m_sockstrm = stream;
	166	connection->m_codeci = data_is;
	167	connection->m_codeco = data_os;
	168	client->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
	169	client->SetClientData(connection);
	170	client->SetNotify(wxSOCKET_INPUT_FLAG \| wxSOCKET_LOST_FLAG);
	171	client->Notify(TRUE);
	172	return connection;
	173	}
	174	else
	175	{
	176	delete connection;
	177	// and fall through to delete everything else
	178	}
	179	}
	180	}
	181	}
	182
	183	// Something went wrong, delete everything
	184	delete data_is;
	185	delete data_os;
	186	delete stream;
	187	client->Destroy();
	188
	189	return NULL;
	190	}
	191
	192	wxConnectionBase *wxTCPClient::OnMakeConnection()
	193	{
	194	return new wxTCPConnection();
	195	}
	196
	197	// --------------------------------------------------------------------------
	198	// wxTCPServer
	199	// --------------------------------------------------------------------------
	200
	201	wxTCPServer::wxTCPServer () : wxServerBase()
	202	{
	203	m_server = NULL;
	204	}
	205
	206	bool wxTCPServer::Create(const wxString& serverName)
	207	{
	208	// Destroy previous server, if any
	209	if (m_server)
	210	{
	211	m_server->SetClientData(NULL);
	212	m_server->Destroy();
	213	m_server = NULL;
	214	}
	215
	216	// wxIPV4address defaults to INADDR_ANY:0
	217	wxIPV4address addr;
	218	addr.Service(serverName);
	219
	220	// Create a socket listening on the specified port
	221	m_server = new wxSocketServer(addr, SCKIPC_FLAGS);
	222
	223	if (!m_server->Ok())
	224	{
	225	m_server->Destroy();
	226	m_server = NULL;
	227
	228	return FALSE;
	229	}
	230
	231	m_server->SetEventHandler(*gs_handler, _SERVER_ONREQUEST_ID);
	232	m_server->SetClientData(this);
	233	m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
	234	m_server->Notify(TRUE);
	235
	236	return TRUE;
	237	}
	238
	239	wxTCPServer::~wxTCPServer()
	240	{
	241	if (m_server)
	242	{
	243	m_server->SetClientData(NULL);
	244	m_server->Destroy();
	245	}
	246	}
	247
	248	wxConnectionBase *wxTCPServer::OnAcceptConnection( const wxString& WXUNUSED(topic) )
	249	{
	250	return new wxTCPConnection();
	251	}
	252
	253	// --------------------------------------------------------------------------
	254	// wxTCPConnection
	255	// --------------------------------------------------------------------------
	256
	257	wxTCPConnection::wxTCPConnection () : wxConnectionBase()
	258	{
	259	m_sock = NULL;
	260	m_sockstrm = NULL;
	261	m_codeci = NULL;
	262	m_codeco = NULL;
	263	}
	264
	265	wxTCPConnection::wxTCPConnection(char * WXUNUSED(buffer), int WXUNUSED(size))
	266	{
	267	}
	268
	269	wxTCPConnection::~wxTCPConnection ()
	270	{
	271	wxDELETE(m_codeci);
	272	wxDELETE(m_codeco);
	273	wxDELETE(m_sockstrm);
	274
	275	if (m_sock)
	276	{
	277	m_sock->SetClientData(NULL);
	278	m_sock->Destroy();
	279	}
	280	}
	281
	282	void wxTCPConnection::Compress(bool WXUNUSED(on))
	283	{
	284	// Use wxLZWStream
	285	}
	286
	287	// Calls that CLIENT can make.
	288	bool wxTCPConnection::Disconnect ()
	289	{
	290	// Send the the disconnect message to the peer.
	291	m_codeco->Write8(IPC_DISCONNECT);
	292	m_sock->Notify(FALSE);
	293	m_sock->Close();
	294
	295	return TRUE;
	296	}
	297
	298	bool wxTCPConnection::Execute(const wxChar *data, int size, wxIPCFormat format)
	299	{
	300	if (!m_sock->IsConnected())
	301	return FALSE;
	302
	303	// Prepare EXECUTE message
	304	m_codeco->Write8(IPC_EXECUTE);
	305	m_codeco->Write8(format);
	306
	307	if (size < 0)
	308	size = wxStrlen(data) + 1; // includes final NUL
	309
	310	m_codeco->Write32(size);
	311	m_sockstrm->Write(data, size);
	312
	313	return TRUE;
	314	}
	315
	316	char wxTCPConnection::Request (const wxString& item, int size, wxIPCFormat format)
	317	{
	318	if (!m_sock->IsConnected())
	319	return NULL;
	320
	321	m_codeco->Write8(IPC_REQUEST);
	322	m_codeco->WriteString(item);
	323	m_codeco->Write8(format);
	324
	325	// If Unpack doesn't initialize it.
	326	int ret;
	327
	328	ret = m_codeci->Read8();
	329	if (ret == IPC_FAIL)
	330	return NULL;
	331	else
	332	{
	333	size_t s;
	334	char *data = NULL;
	335
	336	s = m_codeci->Read32();
	337	data = new char[s];
	338	m_sockstrm->Read(data, s);
	339
	340	if (size)
	341	*size = s;
	342	return data;
	343	}
	344	}
	345
	346	bool wxTCPConnection::Poke (const wxString& item, wxChar *data, int size, wxIPCFormat format)
	347	{
	348	if (!m_sock->IsConnected())
	349	return FALSE;
	350
	351	m_codeco->Write8(IPC_POKE);
	352	m_codeco->WriteString(item);
	353	m_codeco->Write8(format);
	354
	355	if (size < 0)
	356	size = wxStrlen(data) + 1; // includes final NUL
	357
	358	m_codeco->Write32(size);
	359	m_sockstrm->Write(data, size);
	360
	361	return TRUE;
	362	}
	363
	364	bool wxTCPConnection::StartAdvise (const wxString& item)
	365	{
	366	int ret;
	367
	368	if (!m_sock->IsConnected())
	369	return FALSE;
	370
	371	m_codeco->Write8(IPC_ADVISE_START);
	372	m_codeco->WriteString(item);
	373
	374	ret = m_codeci->Read8();
	375
	376	if (ret != IPC_FAIL)
	377	return TRUE;
	378	else
	379	return FALSE;
	380	}
	381
	382	bool wxTCPConnection::StopAdvise (const wxString& item)
	383	{
	384	int msg;
	385
	386	if (!m_sock->IsConnected())
	387	return FALSE;
	388
	389	m_codeco->Write8(IPC_ADVISE_STOP);
	390	m_codeco->WriteString(item);
	391
	392	msg = m_codeci->Read8();
	393
	394	if (msg != IPC_FAIL)
	395	return TRUE;
	396	else
	397	return FALSE;
	398	}
	399
	400	// Calls that SERVER can make
	401	bool wxTCPConnection::Advise (const wxString& item,
	402	wxChar *data, int size, wxIPCFormat format)
	403	{
	404	if (!m_sock->IsConnected())
	405	return FALSE;
	406
	407	m_codeco->Write8(IPC_ADVISE);
	408	m_codeco->WriteString(item);
	409	m_codeco->Write8(format);
	410
	411	if (size < 0)
	412	size = wxStrlen(data) + 1; // includes final NUL
	413
	414	m_codeco->Write32(size);
	415	m_sockstrm->Write(data, size);
	416
	417	return TRUE;
	418	}
	419
	420	// --------------------------------------------------------------------------
	421	// wxTCPEventHandler (private class)
	422	// --------------------------------------------------------------------------
	423
	424	BEGIN_EVENT_TABLE(wxTCPEventHandler, wxEvtHandler)
	425	EVT_SOCKET(_CLIENT_ONREQUEST_ID, wxTCPEventHandler::Client_OnRequest)
	426	EVT_SOCKET(_SERVER_ONREQUEST_ID, wxTCPEventHandler::Server_OnRequest)
	427	END_EVENT_TABLE()
	428
	429	void wxTCPEventHandler::Client_OnRequest(wxSocketEvent &event)
	430	{
	431	wxSocketBase *sock = event.GetSocket();
	432	wxSocketNotify evt = event.GetSocketEvent();
	433	wxTCPConnection connection = (wxTCPConnection )(sock->GetClientData());
	434
	435	// This socket is being deleted; skip this event
	436	if (!connection)
	437	return;
	438
	439	int msg = 0;
	440	wxDataInputStream *codeci;
	441	wxDataOutputStream *codeco;
	442	wxSocketStream *sockstrm;
	443	wxString topic_name = connection->m_topic;
	444	wxString item;
	445
	446	// We lost the connection: destroy everything
	447	if (evt == wxSOCKET_LOST)
	448	{
	449	sock->Notify(FALSE);
	450	sock->Close();
	451	connection->OnDisconnect();
	452	return;
	453	}
	454
	455	// Receive message number.
	456	codeci = connection->m_codeci;
	457	codeco = connection->m_codeco;
	458	sockstrm = connection->m_sockstrm;
	459	msg = codeci->Read8();
	460
	461	switch (msg)
	462	{
	463	case IPC_EXECUTE:
	464	{
	465	char *data;
	466	size_t size;
	467	wxIPCFormat format;
	468
	469	format = (wxIPCFormat)codeci->Read8();
	470	size = codeci->Read32();
	471	data = new char[size];
	472	sockstrm->Read(data, size);
	473
	474	connection->OnExecute (topic_name, data, size, format);
	475
	476	delete [] data;
	477	break;
	478	}
	479	case IPC_ADVISE:
	480	{
	481	char *data;
	482	size_t size;
	483	wxIPCFormat format;
	484
	485	item = codeci->ReadString();
	486	format = (wxIPCFormat)codeci->Read8();
	487	size = codeci->Read32();
	488	data = new char[size];
	489	sockstrm->Read(data, size);
	490
	491	connection->OnAdvise (topic_name, item, data, size, format);
	492
	493	delete [] data;
	494	break;
	495	}
	496	case IPC_ADVISE_START:
	497	{
	498	item = codeci->ReadString();
	499
	500	bool ok = connection->OnStartAdvise (topic_name, item);
	501	if (ok)
	502	codeco->Write8(IPC_ADVISE_START);
	503	else
	504	codeco->Write8(IPC_FAIL);
	505
	506	break;
	507	}
	508	case IPC_ADVISE_STOP:
	509	{
	510	item = codeci->ReadString();
	511
	512	bool ok = connection->OnStopAdvise (topic_name, item);
	513	if (ok)
	514	codeco->Write8(IPC_ADVISE_STOP);
	515	else
	516	codeco->Write8(IPC_FAIL);
	517
	518	break;
	519	}
	520	case IPC_POKE:
	521	{
	522	wxIPCFormat format;
	523	size_t size;
	524	wxChar *data;
	525
	526	item = codeci->ReadString();
	527	format = (wxIPCFormat)codeci->Read8();
	528	size = codeci->Read32();
	529	data = new wxChar[size];
	530	sockstrm->Read(data, size);
	531
	532	connection->OnPoke (topic_name, item, data, size, format);
	533
	534	delete [] data;
	535
	536	break;
	537	}
	538	case IPC_REQUEST:
	539	{
	540	wxIPCFormat format;
	541
	542	item = codeci->ReadString();
	543	format = (wxIPCFormat)codeci->Read8();
	544
	545	int user_size = -1;
	546	char *user_data = connection->OnRequest (topic_name, item, &user_size, format);
	547
	548	if (user_data)
	549	{
	550	codeco->Write8(IPC_REQUEST_REPLY);
	551
	552	if (user_size == -1)
	553	user_size = strlen(user_data) + 1; // includes final NUL
	554
	555	codeco->Write32(user_size);
	556	sockstrm->Write(user_data, user_size);
	557	}
	558	else
	559	codeco->Write8(IPC_FAIL);
	560
	561	break;
	562	}
	563	case IPC_DISCONNECT:
	564	{
	565	sock->Notify(FALSE);
	566	sock->Close();
	567	connection->OnDisconnect();
	568	break;
	569	}
	570	default:
	571	codeco->Write8(IPC_FAIL);
	572	break;
	573	}
	574	}
	575
	576	void wxTCPEventHandler::Server_OnRequest(wxSocketEvent &event)
	577	{
	578	wxSocketServer server = (wxSocketServer ) event.GetSocket();
	579	wxTCPServer ipcserv = (wxTCPServer ) server->GetClientData();
	580
	581	// This socket is being deleted; skip this event
	582	if (!ipcserv)
	583	return;
	584
	585	if (event.GetSocketEvent() != wxSOCKET_CONNECTION)
	586	return;
	587
	588	// Accept the connection, getting a new socket
	589	wxSocketBase *sock = server->Accept();
	590	if (!sock->Ok())
	591	{
	592	sock->Destroy();
	593	return;
	594	}
	595
	596	wxSocketStream stream = new wxSocketStream(sock);
	597	wxDataInputStream codeci = new wxDataInputStream(stream);
	598	wxDataOutputStream codeco = new wxDataOutputStream(stream);
	599
	600	int msg;
	601	msg = codeci->Read8();
	602
	603	if (msg == IPC_CONNECT)
	604	{
	605	wxString topic_name;
	606	topic_name = codeci->ReadString();
	607
	608	wxTCPConnection *new_connection =
	609	(wxTCPConnection *)ipcserv->OnAcceptConnection (topic_name);
	610
	611	if (new_connection)
	612	{
	613	if (new_connection->IsKindOf(CLASSINFO(wxTCPConnection)))
	614	{
	615	// Acknowledge success
	616	codeco->Write8(IPC_CONNECT);
	617	new_connection->m_topic = topic_name;
	618	new_connection->m_sock = sock;
	619	new_connection->m_sockstrm = stream;
	620	new_connection->m_codeci = codeci;
	621	new_connection->m_codeco = codeco;
	622	sock->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
	623	sock->SetClientData(new_connection);
	624	sock->SetNotify(wxSOCKET_INPUT_FLAG \| wxSOCKET_LOST_FLAG);
	625	sock->Notify(TRUE);
	626	return;
	627	}
	628	else
	629	{
	630	delete new_connection;
	631	// and fall through to delete everything else
	632	}
	633	}
	634	}
	635
	636	// Something went wrong, send failure message and delete everything
	637	codeco->Write8(IPC_FAIL);
	638
	639	delete codeco;
	640	delete codeci;
	641	delete stream;
	642	sock->Destroy();
	643	}
	644
	645	// --------------------------------------------------------------------------
	646	// wxTCPEventHandlerModule (private class)
	647	// --------------------------------------------------------------------------
	648
	649	class WXDLLEXPORT wxTCPEventHandlerModule: public wxModule
	650	{
	651	DECLARE_DYNAMIC_CLASS(wxTCPEventHandlerModule)
	652
	653	public:
	654	bool OnInit() { gs_handler = new wxTCPEventHandler(); return TRUE; }
	655	void OnExit() { wxDELETE(gs_handler); }
	656	};
	657
	658	IMPLEMENT_DYNAMIC_CLASS(wxTCPEventHandlerModule, wxModule)
	659
	660
	661	#endif
	662	// wxUSE_SOCKETS && wxUSE_IPC