]> git.saurik.com Git - wxWidgets.git/blob - src/common/sckipc.cpp
warning in Unicode compilation fixed
[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 // 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