src/common/sckipc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/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 //              Vadim Zeitlin (added support for Unix sockets) Apr 2002
   9 // Created:     1993
  10 // RCS-ID:      $Id$
  11 // Copyright:   (c) Julian Smart 1993
  12 //              (c) Guilhem Lavaux 1997, 1998
  13 //              (c) 2000 Guillermo Rodriguez <guille@iies.es>
  14 // Licence:     wxWindows licence
  15 /////////////////////////////////////////////////////////////////////////////
  16
  17 // ==========================================================================
  18 // declarations
  19 // ==========================================================================
  20
  21 // --------------------------------------------------------------------------
  22 // headers
  23 // --------------------------------------------------------------------------
  24
  25 // For compilers that support precompilation, includes "wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 #if wxUSE_SOCKETS && wxUSE_IPC && wxUSE_STREAMS
  33
  34 #include "wx/sckipc.h"
  35
  36 #ifndef WX_PRECOMP
  37     #include "wx/log.h"
  38     #include "wx/event.h"
  39     #include "wx/module.h"
  40 #endif
  41
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <errno.h>
  45
  46 #include "wx/socket.h"
  47
  48 // --------------------------------------------------------------------------
  49 // macros and constants
  50 // --------------------------------------------------------------------------
  51
  52 // It seems to be already defined somewhere in the Xt includes.
  53 #ifndef __XT__
  54 // Message codes
  55 enum
  56 {
  57   IPC_EXECUTE = 1,
  58   IPC_REQUEST,
  59   IPC_POKE,
  60   IPC_ADVISE_START,
  61   IPC_ADVISE_REQUEST,
  62   IPC_ADVISE,
  63   IPC_ADVISE_STOP,
  64   IPC_REQUEST_REPLY,
  65   IPC_FAIL,
  66   IPC_CONNECT,
  67   IPC_DISCONNECT
  68 };
  69 #endif
  70
  71 // All sockets will be created with the following flags
  72 #define SCKIPC_FLAGS (wxSOCKET_WAITALL)
  73
  74 // headers needed for umask()
  75 #ifdef __UNIX_LIKE__
  76     #include <sys/types.h>
  77     #include <sys/stat.h>
  78 #endif // __UNIX_LIKE__
  79
  80 // ----------------------------------------------------------------------------
  81 // private functions
  82 // ----------------------------------------------------------------------------
  83
  84 // get the address object for the given server name, the caller must delete it
  85 static wxSockAddress *
  86 GetAddressFromName(const wxString& serverName, const wxString& host = wxEmptyString)
  87 {
  88     // we always use INET sockets under non-Unix systems
  89 #if defined(__UNIX__) && !defined(__WINDOWS__) && !defined(__WINE__) && (!defined(__WXMAC__) || defined(__DARWIN__))
  90     // under Unix, if the server name looks like a path, create a AF_UNIX
  91     // socket instead of AF_INET one
  92     if ( serverName.Find(_T('/')) != wxNOT_FOUND )
  93     {
  94         wxUNIXaddress *addr = new wxUNIXaddress;
  95         addr->Filename(serverName);
  96
  97         return addr;
  98     }
  99 #endif // Unix/!Unix
 100     {
 101         wxIPV4address *addr = new wxIPV4address;
 102         addr->Service(serverName);
 103         if ( !host.empty() )
 104         {
 105             addr->Hostname(host);
 106         }
 107
 108         return addr;
 109     }
 110 }
 111
 112 // --------------------------------------------------------------------------
 113 // wxTCPEventHandler stuff (private class)
 114 // --------------------------------------------------------------------------
 115
 116 class wxTCPEventHandler : public wxEvtHandler
 117 {
 118 public:
 119   wxTCPEventHandler() : wxEvtHandler() {}
 120
 121   void Client_OnRequest(wxSocketEvent& event);
 122   void Server_OnRequest(wxSocketEvent& event);
 123
 124   DECLARE_EVENT_TABLE()
 125   DECLARE_NO_COPY_CLASS(wxTCPEventHandler)
 126 };
 127
 128 enum
 129 {
 130   _CLIENT_ONREQUEST_ID = 1000,
 131   _SERVER_ONREQUEST_ID
 132 };
 133
 134 static wxTCPEventHandler *gs_handler = NULL;
 135
 136 // ==========================================================================
 137 // implementation
 138 // ==========================================================================
 139
 140 IMPLEMENT_DYNAMIC_CLASS(wxTCPServer, wxServerBase)
 141 IMPLEMENT_DYNAMIC_CLASS(wxTCPClient, wxClientBase)
 142 IMPLEMENT_CLASS(wxTCPConnection, wxConnectionBase)
 143
 144 // --------------------------------------------------------------------------
 145 // wxTCPClient
 146 // --------------------------------------------------------------------------
 147
 148 wxTCPClient::wxTCPClient () : wxClientBase()
 149 {
 150 }
 151
 152 wxTCPClient::~wxTCPClient ()
 153 {
 154 }
 155
 156 bool wxTCPClient::ValidHost(const wxString& host)
 157 {
 158   wxIPV4address addr;
 159
 160   return addr.Hostname(host);
 161 }
 162
 163 wxConnectionBase *wxTCPClient::MakeConnection (const wxString& host,
 164                                                const wxString& serverName,
 165                                                const wxString& topic)
 166 {
 167   wxSockAddress *addr = GetAddressFromName(serverName, host);
 168   if ( !addr )
 169       return NULL;
 170
 171   wxSocketClient *client = new wxSocketClient(SCKIPC_FLAGS);
 172   wxSocketStream *stream = new wxSocketStream(*client);
 173   wxDataInputStream *data_is = new wxDataInputStream(*stream);
 174   wxDataOutputStream *data_os = new wxDataOutputStream(*stream);
 175
 176   bool ok = client->Connect(*addr);
 177   delete addr;
 178
 179   if ( ok )
 180   {
 181     unsigned char msg;
 182
 183     // Send topic name, and enquire whether this has succeeded
 184     data_os->Write8(IPC_CONNECT);
 185     data_os->WriteString(topic);
 186
 187     msg = data_is->Read8();
 188
 189     // OK! Confirmation.
 190     if (msg == IPC_CONNECT)
 191     {
 192       wxTCPConnection *connection = (wxTCPConnection *)OnMakeConnection ();
 193
 194       if (connection)
 195       {
 196         if (connection->IsKindOf(CLASSINFO(wxTCPConnection)))
 197         {
 198           connection->m_topic = topic;
 199           connection->m_sock  = client;
 200           connection->m_sockstrm = stream;
 201           connection->m_codeci = data_is;
 202           connection->m_codeco = data_os;
 203           client->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
 204           client->SetClientData(connection);
 205           client->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 206           client->Notify(true);
 207           return connection;
 208         }
 209         else
 210         {
 211           delete connection;
 212           // and fall through to delete everything else
 213         }
 214       }
 215     }
 216   }
 217
 218   // Something went wrong, delete everything
 219   delete data_is;
 220   delete data_os;
 221   delete stream;
 222   client->Destroy();
 223
 224   return NULL;
 225 }
 226
 227 wxConnectionBase *wxTCPClient::OnMakeConnection()
 228 {
 229   return new wxTCPConnection();
 230 }
 231
 232 // --------------------------------------------------------------------------
 233 // wxTCPServer
 234 // --------------------------------------------------------------------------
 235
 236 wxTCPServer::wxTCPServer () : wxServerBase()
 237 {
 238   m_server = NULL;
 239 }
 240
 241 bool wxTCPServer::Create(const wxString& serverName)
 242 {
 243   // Destroy previous server, if any
 244   if (m_server)
 245   {
 246     m_server->SetClientData(NULL);
 247     m_server->Destroy();
 248     m_server = NULL;
 249   }
 250
 251   wxSockAddress *addr = GetAddressFromName(serverName);
 252   if ( !addr )
 253       return false;
 254
 255 #ifdef __UNIX_LIKE__
 256   mode_t umaskOld;
 257   if ( addr->Type() == wxSockAddress::UNIX )
 258   {
 259       // ensure that the file doesn't exist as otherwise calling socket() would
 260       // fail
 261       int rc = remove(serverName.fn_str());
 262       if ( rc < 0 && errno != ENOENT )
 263       {
 264           delete addr;
 265
 266           return false;
 267       }
 268
 269       // also set the umask to prevent the others from reading our file
 270       umaskOld = umask(077);
 271   }
 272   else
 273   {
 274       // unused anyhow but shut down the compiler warnings
 275       umaskOld = 0;
 276   }
 277 #endif // __UNIX_LIKE__
 278
 279   // Create a socket listening on the specified port
 280   m_server = new wxSocketServer(*addr, SCKIPC_FLAGS);
 281
 282 #ifdef __UNIX_LIKE__
 283   if ( addr->Type() == wxSockAddress::UNIX )
 284   {
 285       // restore the umask
 286       umask(umaskOld);
 287
 288       // save the file name to remove it later
 289       m_filename = serverName;
 290   }
 291 #endif // __UNIX_LIKE__
 292
 293   delete addr;
 294
 295   if (!m_server->Ok())
 296   {
 297     m_server->Destroy();
 298     m_server = NULL;
 299
 300     return false;
 301   }
 302
 303   m_server->SetEventHandler(*gs_handler, _SERVER_ONREQUEST_ID);
 304   m_server->SetClientData(this);
 305   m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
 306   m_server->Notify(true);
 307
 308   return true;
 309 }
 310
 311 wxTCPServer::~wxTCPServer()
 312 {
 313     if (m_server)
 314     {
 315         m_server->SetClientData(NULL);
 316         m_server->Destroy();
 317     }
 318
 319 #ifdef __UNIX_LIKE__
 320     if ( !m_filename.empty() )
 321     {
 322         if ( remove(m_filename.fn_str()) != 0 )
 323         {
 324             wxLogDebug(_T("Stale AF_UNIX file '%s' left."), m_filename.c_str());
 325         }
 326     }
 327 #endif // __UNIX_LIKE__
 328 }
 329
 330 wxConnectionBase *wxTCPServer::OnAcceptConnection( const wxString& WXUNUSED(topic) )
 331 {
 332   return new wxTCPConnection();
 333 }
 334
 335 // --------------------------------------------------------------------------
 336 // wxTCPConnection
 337 // --------------------------------------------------------------------------
 338
 339 wxTCPConnection::wxTCPConnection () : wxConnectionBase()
 340 {
 341   m_sock     = NULL;
 342   m_sockstrm = NULL;
 343   m_codeci   = NULL;
 344   m_codeco   = NULL;
 345 }
 346
 347 wxTCPConnection::wxTCPConnection(wxChar *buffer, int size)
 348        : wxConnectionBase(buffer, size)
 349 {
 350   m_sock     = NULL;
 351   m_sockstrm = NULL;
 352   m_codeci   = NULL;
 353   m_codeco   = NULL;
 354 }
 355
 356 wxTCPConnection::~wxTCPConnection ()
 357 {
 358   Disconnect();
 359
 360   if (m_sock)
 361   {
 362     m_sock->SetClientData(NULL);
 363     m_sock->Destroy();
 364   }
 365
 366   /* Delete after destroy */
 367   wxDELETE(m_codeci);
 368   wxDELETE(m_codeco);
 369   wxDELETE(m_sockstrm);
 370 }
 371
 372 void wxTCPConnection::Compress(bool WXUNUSED(on))
 373 {
 374   // Use wxLZWStream
 375 }
 376
 377 // Calls that CLIENT can make.
 378 bool wxTCPConnection::Disconnect ()
 379 {
 380   if ( !GetConnected() )
 381       return true;
 382   // Send the the disconnect message to the peer.
 383   m_codeco->Write8(IPC_DISCONNECT);
 384
 385   if ( m_sock )
 386   {
 387       m_sock->Notify(false);
 388       m_sock->Close();
 389   }
 390
 391   SetConnected(false);
 392
 393   return true;
 394 }
 395
 396 bool wxTCPConnection::Execute(const wxChar *data, int size, wxIPCFormat format)
 397 {
 398   if (!m_sock->IsConnected())
 399     return false;
 400
 401   // Prepare EXECUTE message
 402   m_codeco->Write8(IPC_EXECUTE);
 403   m_codeco->Write8(format);
 404
 405   if (size < 0)
 406     size = (wxStrlen(data) + 1) * sizeof(wxChar);    // includes final NUL
 407
 408   m_codeco->Write32(size);
 409   m_sockstrm->Write(data, size);
 410
 411   return true;
 412 }
 413
 414 wxChar *wxTCPConnection::Request (const wxString& item, int *size, wxIPCFormat format)
 415 {
 416   if (!m_sock->IsConnected())
 417     return NULL;
 418
 419   m_codeco->Write8(IPC_REQUEST);
 420   m_codeco->WriteString(item);
 421   m_codeco->Write8(format);
 422
 423   // If Unpack doesn't initialize it.
 424   int ret;
 425
 426   ret = m_codeci->Read8();
 427   if (ret == IPC_FAIL)
 428     return NULL;
 429   else
 430   {
 431     size_t s;
 432
 433     s = m_codeci->Read32();
 434
 435     wxChar *data = GetBufferAtLeast( s );
 436     wxASSERT_MSG(data != NULL,
 437                  _T("Buffer too small in wxTCPConnection::Request") );
 438     m_sockstrm->Read(data, s);
 439
 440     if (size)
 441       *size = s;
 442     return data;
 443   }
 444 }
 445
 446 bool wxTCPConnection::Poke (const wxString& item, const wxChar *data, int size, wxIPCFormat format)
 447 {
 448   if (!m_sock->IsConnected())
 449     return false;
 450
 451   m_codeco->Write8(IPC_POKE);
 452   m_codeco->WriteString(item);
 453   m_codeco->Write8(format);
 454
 455   if (size < 0)
 456     size = (wxStrlen(data) + 1) * sizeof(wxChar);    // includes final NUL
 457
 458   m_codeco->Write32(size);
 459   m_sockstrm->Write(data, size);
 460
 461   return true;
 462 }
 463
 464 bool wxTCPConnection::StartAdvise (const wxString& item)
 465 {
 466   int ret;
 467
 468   if (!m_sock->IsConnected())
 469     return false;
 470
 471   m_codeco->Write8(IPC_ADVISE_START);
 472   m_codeco->WriteString(item);
 473
 474   ret = m_codeci->Read8();
 475
 476   if (ret != IPC_FAIL)
 477     return true;
 478   else
 479     return false;
 480 }
 481
 482 bool wxTCPConnection::StopAdvise (const wxString& item)
 483 {
 484   int msg;
 485
 486   if (!m_sock->IsConnected())
 487     return false;
 488
 489   m_codeco->Write8(IPC_ADVISE_STOP);
 490   m_codeco->WriteString(item);
 491
 492   msg = m_codeci->Read8();
 493
 494   if (msg != IPC_FAIL)
 495     return true;
 496   else
 497     return false;
 498 }
 499
 500 // Calls that SERVER can make
 501 bool wxTCPConnection::Advise (const wxString& item,
 502                               const wxChar *data, int size, wxIPCFormat format)
 503 {
 504   if (!m_sock->IsConnected())
 505     return false;
 506
 507   m_codeco->Write8(IPC_ADVISE);
 508   m_codeco->WriteString(item);
 509   m_codeco->Write8(format);
 510
 511   if (size < 0)
 512     size = (wxStrlen(data) + 1) * sizeof(wxChar);    // includes final NUL
 513
 514   m_codeco->Write32(size);
 515   m_sockstrm->Write(data, size);
 516
 517   return true;
 518 }
 519
 520 // --------------------------------------------------------------------------
 521 // wxTCPEventHandler (private class)
 522 // --------------------------------------------------------------------------
 523
 524 BEGIN_EVENT_TABLE(wxTCPEventHandler, wxEvtHandler)
 525   EVT_SOCKET(_CLIENT_ONREQUEST_ID, wxTCPEventHandler::Client_OnRequest)
 526   EVT_SOCKET(_SERVER_ONREQUEST_ID, wxTCPEventHandler::Server_OnRequest)
 527 END_EVENT_TABLE()
 528
 529 void wxTCPEventHandler::Client_OnRequest(wxSocketEvent &event)
 530 {
 531   wxSocketBase *sock = event.GetSocket();
 532   if (!sock) {          /* No socket, no glory */
 533     return ;
 534   }
 535   wxSocketNotify evt = event.GetSocketEvent();
 536   wxTCPConnection *connection = (wxTCPConnection *)(sock->GetClientData());
 537
 538   // This socket is being deleted; skip this event
 539   if (!connection)
 540     return;
 541
 542   wxDataInputStream *codeci;
 543   wxDataOutputStream *codeco;
 544   wxSocketStream *sockstrm;
 545   wxString topic_name = connection->m_topic;
 546   wxString item;
 547
 548   // We lost the connection: destroy everything
 549   if (evt == wxSOCKET_LOST)
 550   {
 551     sock->Notify(false);
 552     sock->Close();
 553     connection->OnDisconnect();
 554     return;
 555   }
 556
 557   // Receive message number.
 558   codeci = connection->m_codeci;
 559   codeco = connection->m_codeco;
 560   sockstrm = connection->m_sockstrm;
 561   int msg = codeci->Read8();
 562
 563   switch (msg)
 564   {
 565   case IPC_EXECUTE:
 566   {
 567     wxChar *data;
 568     size_t size;
 569     wxIPCFormat format;
 570
 571     format = (wxIPCFormat)codeci->Read8();
 572     size = codeci->Read32();
 573
 574     data = connection->GetBufferAtLeast( size );
 575     wxASSERT_MSG(data != NULL,
 576                  _T("Buffer too small in wxTCPEventHandler::Client_OnRequest") );
 577     sockstrm->Read(data, size);
 578
 579     connection->OnExecute (topic_name, data, size, format);
 580
 581     break;
 582   }
 583   case IPC_ADVISE:
 584   {
 585     wxChar *data;
 586     size_t size;
 587     wxIPCFormat format;
 588
 589     item = codeci->ReadString();
 590     format = (wxIPCFormat)codeci->Read8();
 591     size = codeci->Read32();
 592     data = connection->GetBufferAtLeast( size );
 593     wxASSERT_MSG(data != NULL,
 594                  _T("Buffer too small in wxTCPEventHandler::Client_OnRequest") );
 595     sockstrm->Read(data, size);
 596
 597     connection->OnAdvise (topic_name, item, data, size, format);
 598
 599     break;
 600   }
 601   case IPC_ADVISE_START:
 602   {
 603     item = codeci->ReadString();
 604
 605     bool ok = connection->OnStartAdvise (topic_name, item);
 606     if (ok)
 607       codeco->Write8(IPC_ADVISE_START);
 608     else
 609       codeco->Write8(IPC_FAIL);
 610
 611     break;
 612   }
 613   case IPC_ADVISE_STOP:
 614   {
 615     item = codeci->ReadString();
 616
 617     bool ok = connection->OnStopAdvise (topic_name, item);
 618     if (ok)
 619       codeco->Write8(IPC_ADVISE_STOP);
 620     else
 621       codeco->Write8(IPC_FAIL);
 622
 623     break;
 624   }
 625   case IPC_POKE:
 626   {
 627     wxIPCFormat format;
 628     size_t size;
 629     wxChar *data;
 630
 631     item = codeci->ReadString();
 632     format = (wxIPCFormat)codeci->Read8();
 633     size = codeci->Read32();
 634     data = connection->GetBufferAtLeast( size );
 635     wxASSERT_MSG(data != NULL,
 636                  _T("Buffer too small in wxTCPEventHandler::Client_OnRequest") );
 637     sockstrm->Read(data, size);
 638
 639     connection->OnPoke (topic_name, item, data, size, format);
 640
 641     break;
 642   }
 643   case IPC_REQUEST:
 644   {
 645     wxIPCFormat format;
 646
 647     item = codeci->ReadString();
 648     format = (wxIPCFormat)codeci->Read8();
 649
 650     int user_size = -1;
 651     const wxChar *user_data = connection->OnRequest (topic_name, item, &user_size, format);
 652
 653     if (user_data)
 654     {
 655       codeco->Write8(IPC_REQUEST_REPLY);
 656
 657       if (user_size == -1)
 658         user_size = (wxStrlen(user_data) + 1) * sizeof(wxChar);    // includes final NUL
 659
 660       codeco->Write32(user_size);
 661       sockstrm->Write(user_data, user_size);
 662     }
 663     else
 664       codeco->Write8(IPC_FAIL);
 665
 666     break;
 667   }
 668   case IPC_DISCONNECT:
 669   {
 670     sock->Notify(false);
 671     sock->Close();
 672     connection->SetConnected(false);
 673     connection->OnDisconnect();
 674     break;
 675   }
 676   default:
 677     codeco->Write8(IPC_FAIL);
 678     break;
 679   }
 680 }
 681
 682 void wxTCPEventHandler::Server_OnRequest(wxSocketEvent &event)
 683 {
 684   wxSocketServer *server = (wxSocketServer *) event.GetSocket();
 685   if (!server) {                /* No server, Then exit */
 686           return ;
 687   }
 688   wxTCPServer *ipcserv = (wxTCPServer *) server->GetClientData();
 689
 690   // This socket is being deleted; skip this event
 691   if (!ipcserv)
 692     return;
 693
 694   if (event.GetSocketEvent() != wxSOCKET_CONNECTION)
 695     return;
 696
 697   // Accept the connection, getting a new socket
 698   wxSocketBase *sock = server->Accept();
 699   if (!sock) {          /* No socket, no glory */
 700           return ;
 701   }
 702   if (!sock->Ok())
 703   {
 704     sock->Destroy();
 705     return;
 706   }
 707
 708   wxSocketStream *stream     = new wxSocketStream(*sock);
 709   wxDataInputStream *codeci  = new wxDataInputStream(*stream);
 710   wxDataOutputStream *codeco = new wxDataOutputStream(*stream);
 711
 712   int msg;
 713   msg = codeci->Read8();
 714
 715   if (msg == IPC_CONNECT)
 716   {
 717     wxString topic_name;
 718     topic_name = codeci->ReadString();
 719
 720     wxTCPConnection *new_connection =
 721          (wxTCPConnection *)ipcserv->OnAcceptConnection (topic_name);
 722
 723     if (new_connection)
 724     {
 725       if (new_connection->IsKindOf(CLASSINFO(wxTCPConnection)))
 726       {
 727         // Acknowledge success
 728         codeco->Write8(IPC_CONNECT);
 729         new_connection->m_topic = topic_name;
 730         new_connection->m_sock = sock;
 731         new_connection->m_sockstrm = stream;
 732         new_connection->m_codeci = codeci;
 733         new_connection->m_codeco = codeco;
 734         sock->SetEventHandler(*gs_handler, _CLIENT_ONREQUEST_ID);
 735         sock->SetClientData(new_connection);
 736         sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
 737         sock->Notify(true);
 738         return;
 739       }
 740       else
 741       {
 742         delete new_connection;
 743         // and fall through to delete everything else
 744       }
 745     }
 746   }
 747
 748   // Something went wrong, send failure message and delete everything
 749   codeco->Write8(IPC_FAIL);
 750
 751   delete codeco;
 752   delete codeci;
 753   delete stream;
 754   sock->Destroy();
 755 }
 756
 757 // --------------------------------------------------------------------------
 758 // wxTCPEventHandlerModule (private class)
 759 // --------------------------------------------------------------------------
 760
 761 class wxTCPEventHandlerModule: public wxModule
 762 {
 763   DECLARE_DYNAMIC_CLASS(wxTCPEventHandlerModule)
 764
 765 public:
 766   bool OnInit() { gs_handler = new wxTCPEventHandler(); return true; }
 767   void OnExit() { wxDELETE(gs_handler); }
 768 };
 769
 770 IMPLEMENT_DYNAMIC_CLASS(wxTCPEventHandlerModule, wxModule)
 771
 772
 773 #endif
 774    // wxUSE_SOCKETS && wxUSE_IPC && wxUSE_STREAMS