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