src/common/sckipc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        sckipc.cpp
   3 // Purpose:     Interprocess communication implementation (wxSocket version)
   4 // Author:      Julian Smart, Guilhem Lavaux
   5 // Modified by: Guilhem Lavaux (big rewrite) May 1997, 1998
   6 // Created:     1993
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart 1993, Guilhem Lavaux 1997, 1998
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "sckipc.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_SOCKETS
  24
  25 #ifndef WX_PRECOMP
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30
  31 #include "wx/socket.h"
  32 #include "wx/sckipc.h"
  33
  34 #ifdef __BORLANDC__
  35 #pragma hdrstop
  36 #endif
  37
  38 #if !USE_SHARED_LIBRARY
  39 IMPLEMENT_DYNAMIC_CLASS(wxTCPServer, wxServerBase)
  40 IMPLEMENT_DYNAMIC_CLASS(wxTCPClient, wxClientBase)
  41 IMPLEMENT_DYNAMIC_CLASS(wxTCPConnection, wxConnectionBase)
  42 #endif
  43
  44 // It seems to be already defined somewhere in the Xt includes.
  45 #ifndef __XT__
  46 // Message codes
  47 enum {
  48   IPC_EXECUTE = 1,
  49   IPC_REQUEST,
  50   IPC_POKE,
  51   IPC_ADVISE_START,
  52   IPC_ADVISE_REQUEST,
  53   IPC_ADVISE,
  54   IPC_ADVISE_STOP,
  55   IPC_REQUEST_REPLY,
  56   IPC_FAIL,
  57   IPC_CONNECT,
  58   IPC_DISCONNECT
  59 };
  60 #endif
  61
  62 void Server_OnRequest(wxSocketServer& server,
  63                       wxSocketNotify evt,
  64                       char *cdata);
  65 void Client_OnRequest(wxSocketBase& sock,
  66                       wxSocketNotify evt,
  67                       char *cdata);
  68
  69 // ---------------------------------------------------------------------------
  70 // wxTCPClient
  71 // ---------------------------------------------------------------------------
  72
  73 wxTCPClient::wxTCPClient (void)
  74   : wxClientBase()
  75 {
  76 }
  77
  78 wxTCPClient::~wxTCPClient (void)
  79 {
  80 }
  81
  82 bool wxTCPClient::ValidHost(const wxString& host)
  83 {
  84   wxIPV4address addr;
  85
  86   return addr.Hostname(host);
  87 }
  88
  89 wxConnectionBase *wxTCPClient::MakeConnection (const wxString& host,
  90                                                const wxString& server_name,
  91                                                const wxString& topic)
  92 {
  93   wxIPV4address addr;
  94   wxSocketClient *client = new wxSocketClient();
  95   wxSocketStream *stream = new wxSocketStream(*client);
  96   wxDataInputStream data_is(*stream);
  97   wxDataOutputStream data_os(*stream);
  98
  99   client->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 100   addr.Service(server_name);
 101   addr.Hostname(host);
 102
 103   if (!client->Connect(addr)) {
 104     delete client;
 105     return NULL;
 106   }
 107   client->Notify(FALSE);
 108
 109   // Send topic name, and enquire whether this has succeeded
 110   unsigned char msg;
 111
 112   data_os.Write8(IPC_CONNECT);
 113   data_os.WriteString(topic);
 114
 115   msg = data_is.Read8();
 116
 117   // OK! Confirmation.
 118   if (msg == IPC_CONNECT) {
 119     wxTCPConnection *connection = (wxTCPConnection *)OnMakeConnection ();
 120     if (connection) {
 121       if (!connection->IsKindOf(CLASSINFO(wxTCPConnection))) {
 122         delete connection;
 123         return NULL;
 124       }
 125       connection->m_topic = topic;
 126       client->Callback(Client_OnRequest);
 127       client->CallbackData((char *)connection);
 128       client->Notify(TRUE);
 129       return connection;
 130     } else {
 131       delete client;
 132       return NULL;
 133     }
 134   } else {
 135     delete client;
 136     return NULL;
 137   }
 138   return NULL;
 139 }
 140
 141 wxConnectionBase *wxTCPClient::OnMakeConnection()
 142 {
 143   return new wxTCPConnection;
 144 }
 145
 146 // ---------------------------------------------------------------------------
 147 // wxTCPServer
 148 // ---------------------------------------------------------------------------
 149
 150 wxTCPServer::wxTCPServer (void)
 151   : wxServerBase()
 152 {
 153 }
 154
 155 bool wxTCPServer::Create(const wxString& server_name)
 156 {
 157   wxIPV4address addr;
 158   wxSocketServer *server;
 159
 160   addr.Service(server_name);
 161
 162   // Create a socket listening on specified port
 163   server = new wxSocketServer(addr);
 164   server->Callback((wxSocketBase::wxSockCbk)Server_OnRequest);
 165   server->SetNotify(wxSOCKET_CONNECTION_FLAG);
 166
 167   server->CallbackData((char *)this);
 168
 169   return TRUE;
 170 }
 171
 172 wxTCPServer::~wxTCPServer(void)
 173 {
 174 }
 175
 176 wxConnectionBase *wxTCPServer::OnAcceptConnection( const wxString& WXUNUSED(topic) )
 177 {
 178   return new wxTCPConnection();
 179 }
 180
 181 // ---------------------------------------------------------------------------
 182 // wxTCPConnection
 183 // ---------------------------------------------------------------------------
 184
 185 wxTCPConnection::wxTCPConnection (void)
 186   : wxConnectionBase(),
 187     m_sock(NULL), m_sockstrm(NULL), m_codeci(NULL), m_codeco(NULL)
 188 {
 189 }
 190
 191 wxTCPConnection::wxTCPConnection(char *buffer, int size)
 192 {
 193 }
 194
 195 wxTCPConnection::~wxTCPConnection (void)
 196 {
 197   wxDELETE(m_sock);
 198   wxDELETE(m_codeci);
 199   wxDELETE(m_codeco);
 200   wxDELETE(m_sockstrm);
 201 }
 202
 203 void wxTCPConnection::Compress(bool WXUNUSED(on))
 204 {
 205   // Use wxLZWStream
 206 }
 207
 208 // Calls that CLIENT can make.
 209 bool wxTCPConnection::Disconnect (void)
 210 {
 211   // Send the the disconnect message to the peer.
 212   m_codeco->Write8(IPC_DISCONNECT);
 213   m_sock->Close();
 214
 215   return TRUE;
 216 }
 217
 218 bool wxTCPConnection::Execute (wxChar *data, int size, wxIPCFormat format)
 219 {
 220   if (!m_sock->IsConnected())
 221     return FALSE;
 222
 223   // Prepare EXECUTE message
 224   m_codeco->Write8(IPC_EXECUTE);
 225   m_codeco->Write8(format);
 226   if (size < 0)
 227     m_codeco->WriteString(data);
 228   else {
 229     m_codeco->Write32(size);
 230     m_sockstrm->Write(data, size);
 231   }
 232
 233   return TRUE;
 234 }
 235
 236 char *wxTCPConnection::Request (const wxString& item, int *size, wxIPCFormat format)
 237 {
 238   if (!m_sock->IsConnected())
 239     return NULL;
 240
 241   m_codeco->Write8(IPC_REQUEST);
 242   m_codeco->WriteString(item);
 243   m_codeco->Write8(format);
 244
 245   // If Unpack doesn't initialize it.
 246   int ret;
 247
 248   ret = m_codeci->Read8();
 249   if (ret == IPC_FAIL)
 250     return NULL;
 251   else {
 252     size_t s;
 253     char *data = NULL;
 254
 255     s = m_codeci->Read32();
 256     data = new char[s];
 257     m_sockstrm->Read(data, s);
 258
 259     if (size)
 260       *size = s;
 261     return data;
 262   }
 263 }
 264
 265 bool wxTCPConnection::Poke (const wxString& item, wxChar *data, int size, wxIPCFormat format)
 266 {
 267   if (!m_sock->IsConnected())
 268     return FALSE;
 269
 270   m_codeco->Write8(IPC_POKE);
 271   m_codeco->WriteString(item);
 272   m_codeco->Write8(format);
 273   if (size < 0)
 274     m_codeco->WriteString(data);
 275   else {
 276     m_codeco->Write32(size);
 277     m_sockstrm->Write(data, size);
 278   }
 279
 280   return TRUE;
 281 }
 282
 283 bool wxTCPConnection::StartAdvise (const wxString& item)
 284 {
 285   int ret;
 286
 287   if (!m_sock->IsConnected())
 288     return FALSE;
 289
 290   m_codeco->Write8(IPC_ADVISE_START);
 291   m_codeco->WriteString(item);
 292
 293   ret = m_codeci->Read8();
 294
 295   if (ret != IPC_FAIL)
 296     return TRUE;
 297   else
 298     return FALSE;
 299 }
 300
 301 bool wxTCPConnection::StopAdvise (const wxString& item)
 302 {
 303   int msg;
 304
 305   if (!m_sock->IsConnected())
 306     return FALSE;
 307
 308   m_codeco->Write8(IPC_ADVISE_STOP);
 309   m_codeco->WriteString(item);
 310
 311   msg = m_codeci->Read8();
 312
 313   if (msg != IPC_FAIL)
 314     return TRUE;
 315   else
 316     return FALSE;
 317 }
 318
 319 // Calls that SERVER can make
 320 bool wxTCPConnection::Advise (const wxString& item,
 321                               wxChar *data, int size, wxIPCFormat format)
 322 {
 323   if (!m_sock->IsConnected())
 324     return FALSE;
 325
 326   m_codeco->Write8(IPC_ADVISE);
 327   m_codeco->WriteString(item);
 328   m_codeco->Write8(format);
 329   if (size < 0)
 330     m_codeco->WriteString(data);
 331   else {
 332     m_codeco->Write32(size);
 333     m_sockstrm->Write(data, size);
 334   }
 335
 336   return TRUE;
 337 }
 338
 339 void Client_OnRequest(wxSocketBase& sock, wxSocketNotify evt,
 340                       char *cdata)
 341 {
 342   int msg = 0;
 343   wxTCPConnection *connection = (wxTCPConnection *)cdata;
 344   wxDataInputStream *codeci;
 345   wxDataOutputStream *codeco;
 346   wxSocketStream *sockstrm;
 347   wxString topic_name = connection->m_topic;
 348   wxString item;
 349
 350   // The socket handler signals us that we lost the connection: destroy all.
 351   if (evt == wxSOCKET_LOST) {
 352     sock.Close();
 353     connection->OnDisconnect();
 354     return;
 355   }
 356
 357   // Receive message number.
 358   codeci = connection->m_codeci;
 359   codeco = connection->m_codeco;
 360   sockstrm = connection->m_sockstrm;
 361   msg = codeci->Read8();
 362
 363   switch (msg) {
 364   case IPC_EXECUTE: {
 365     char *data;
 366     size_t size;
 367     wxIPCFormat format;
 368
 369     format = (wxIPCFormat)codeci->Read8();
 370     size = codeci->Read32();
 371     data = new char[size];
 372     sockstrm->Read(data, size);
 373
 374     connection->OnExecute (topic_name, data, size, format);
 375
 376     delete [] data;
 377     break;
 378   }
 379   case IPC_ADVISE: {
 380     char *data;
 381     size_t size;
 382     wxIPCFormat format;
 383
 384     item = codeci->ReadString();
 385     format = (wxIPCFormat)codeci->Read8();
 386     size = codeci->Read32();
 387     data = new char[size];
 388     sockstrm->Read(data, size);
 389
 390     connection->OnAdvise (topic_name, item, data, size, format);
 391
 392     delete [] data;
 393     break;
 394   }
 395   case IPC_ADVISE_START: {
 396     item = codeci->ReadString();
 397
 398     bool ok = connection->OnStartAdvise (topic_name, item);
 399     if (ok)
 400       codeco->Write8(IPC_ADVISE_START);
 401     else
 402       codeco->Write8(IPC_FAIL);
 403
 404     break;
 405   }
 406   case IPC_ADVISE_STOP: {
 407     item = codeci->ReadString();
 408
 409     bool ok = connection->OnStopAdvise (topic_name, item);
 410     if (ok)
 411       codeco->Write8(IPC_ADVISE_STOP);
 412     else
 413       codeco->Write8(IPC_FAIL);
 414
 415     break;
 416   }
 417   case IPC_POKE: {
 418     wxIPCFormat format;
 419     size_t size;
 420     wxChar *data;
 421
 422     item = codeci->ReadString();
 423     format = (wxIPCFormat)codeci->Read8();
 424     size = codeci->Read32();
 425     data = new wxChar[size];
 426     sockstrm->Read(data, size);
 427
 428     connection->OnPoke (topic_name, item, data, size, format);
 429
 430     delete [] data;
 431
 432     break;
 433   }
 434   case IPC_REQUEST: {
 435     wxIPCFormat format;
 436
 437     item = codeci->ReadString();
 438     format = (wxIPCFormat)codeci->Read8();
 439
 440     int user_size = -1;
 441     char *user_data = connection->OnRequest (topic_name, item, &user_size, format);
 442
 443     if (user_data) {
 444       codeco->Write8(IPC_REQUEST_REPLY);
 445       if (user_size != -1) {
 446         codeco->Write32(user_size);
 447         sockstrm->Write(user_data, user_size);
 448       } else
 449         codeco->WriteString(user_data);
 450     } else
 451       codeco->Write8(IPC_FAIL);
 452
 453     break;
 454   }
 455   case IPC_DISCONNECT: {
 456     sock.Close();
 457     connection->OnDisconnect();
 458     break;
 459   }
 460   default:
 461     codeco->Write8(IPC_FAIL);
 462     break;
 463   }
 464 }
 465
 466 void Server_OnRequest(wxSocketServer& server,
 467                       wxSocketNotify evt, char *cdata)
 468 {
 469   wxTCPServer *ipcserv = (wxTCPServer *)cdata;
 470   wxSocketStream *stream;
 471   wxDataInputStream *codeci;
 472   wxDataOutputStream *codeco;
 473
 474   if (evt != wxSOCKET_CONNECTION)
 475     return;
 476
 477   /* Accept the connection, getting a new socket */
 478   wxSocketBase *sock = server.Accept();
 479   sock->Notify(FALSE);
 480   sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 481
 482   stream = new wxSocketStream(*sock);
 483   codeci = new wxDataInputStream(*stream);
 484   codeco = new wxDataOutputStream(*stream);
 485
 486   if (!sock->Ok())
 487     return;
 488
 489   int msg;
 490   msg = codeci->Read8();
 491
 492   if (msg == IPC_CONNECT) {
 493     wxString topic_name;
 494     topic_name = codeci->ReadString();
 495
 496     /* Register new socket with the notifier */
 497     wxTCPConnection *new_connection =
 498          (wxTCPConnection *)ipcserv->OnAcceptConnection (topic_name);
 499     if (new_connection) {
 500       if (!new_connection->IsKindOf(CLASSINFO(wxTCPConnection))) {
 501         delete new_connection;
 502         codeco->Write8(IPC_FAIL);
 503         return;
 504       }
 505       // Acknowledge success
 506       codeco->Write8(IPC_CONNECT);
 507
 508       new_connection->m_topic = topic_name;
 509       new_connection->m_sockstrm = stream;
 510       new_connection->m_codeci = codeci;
 511       new_connection->m_codeco = codeco;
 512       sock->Callback(Client_OnRequest);
 513       sock->CallbackData((char *)new_connection);
 514       sock->Notify(TRUE);
 515     } else {
 516       // Send failure message
 517       codeco->Write8(IPC_FAIL);
 518     }
 519   }
 520 }
 521
 522 #endif
 523   // wxUSE_SOCKETS