]> git.saurik.com Git - wxWidgets.git/blob - include/wx/socket.h
no message
[wxWidgets.git] / include / wx / socket.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: socket.h
3 // Purpose: Socket handling classes
4 // Author: Guilhem Lavaux
5 // Modified by:
6 // Created: April 1997
7 // RCS-ID: $Id$
8 // Copyright: (c) Guilhem Lavaux
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_NETWORK_SOCKET_H
13 #define _WX_NETWORK_SOCKET_H
14
15 #ifdef __GNUG__
16 #pragma interface "socket.h"
17 #endif
18
19 // ---------------------------------------------------------------------------
20 // Windows(tm) specific
21 // ---------------------------------------------------------------------------
22 #if defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
23 #include <winsock.h>
24 #include <wx/msw/private.h>
25
26 struct wxSockInternal {
27 UINT my_msg;
28 };
29
30 struct wxSockHandlerInternal {
31 HWND sockWin;
32 UINT firstAvailableMsg;
33 };
34 #endif // defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
35
36 // ---------------------------------------------------------------------------
37 // Unix specific
38 // ---------------------------------------------------------------------------
39 #if defined(__UNIX__) && defined(WXSOCK_INTERNAL)
40 #include <sys/types.h>
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43
44 // ---------------------------------------------------------------------------
45 // Athena specific
46 // ---------------------------------------------------------------------------
47 #if defined(__WXXT__) || defined(__WXMOTIF__)
48 #include <X11/Intrinsic.h>
49
50 struct wxSockInternal {
51 XtInputId sock_inputid, sock_outputid, sock_exceptid;
52 };
53 #endif
54
55 // ---------------------------------------------------------------------------
56 // GTK specific
57 // ---------------------------------------------------------------------------
58 #if defined(__WXGTK__)
59 #include <gdk/gdk.h>
60
61 struct wxSockInternal {
62 gint sock_inputid, sock_outputid, sock_exceptid;
63 };
64 #endif
65
66 #endif // defined(__UNIX__) && defined(WXSOCK_INTERNAL)
67
68 // ---------------------------------------------------------------------------
69 // wxSocket headers (generic)
70 // ---------------------------------------------------------------------------
71 #ifdef WXPREC
72 #include <wx/wxprec.h>
73 #else
74 #include <wx/wx.h>
75 #endif
76 #include "wx/sckaddr.h"
77
78 class WXDLLEXPORT wxSocketEvent;
79 class WXDLLEXPORT wxSocketHandler;
80 class WXDLLEXPORT wxSocketBase : public wxEvtHandler
81 {
82 DECLARE_CLASS(wxSocketBase)
83 #ifdef __WXMAC__
84 friend void wxMacSocketOnRequestProc(void *refcon , short event) ;
85 #endif
86 public:
87
88 enum wxSockFlags { NONE=0, NOWAIT=1, WAITALL=2, SPEED=4 };
89 // Type of request
90 enum { REQ_READ=0x1, REQ_PEEK=0x2, REQ_WRITE=0x4, REQ_LOST=0x8,
91 REQ_ACCEPT=0x10, REQ_CONNECT=0x20};
92 enum { EVT_READ=0, EVT_PEEK=1, EVT_WRITE=2, EVT_LOST=3, EVT_ACCEPT=4,
93 EVT_CONNECT=5 };
94
95 typedef int wxRequestNotify;
96 typedef int wxRequestEvent;
97 typedef void (*wxSockCbk)(wxSocketBase& sock,wxRequestEvent evt,char *cdata);
98
99 protected:
100 wxList req_list[EVT_WRITE+1];
101
102 // Internal use for SaveState() and RestoreState()
103 class wxSockState : public wxObject {
104 public:
105 bool cbk_on;
106 wxSockCbk cbk;
107 char *cdata;
108 bool notif;
109 wxRequestNotify cbk_set;
110 wxSockFlags flags;
111 };
112 typedef struct {
113 char sig[4];
114 char len[4];
115 } SockMsg;
116 enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT };
117
118 wxSockFlags m_flags;
119 wxSockType m_type; // wxSocket type
120 bool m_connected, m_connecting; // State of the socket
121 int m_fd; // Socket file descriptors
122 int m_waitflags; // Wait flags
123 wxList m_states; // States list
124 wxSockCbk m_cbk; // C callback
125 char *m_cdata; // C callback data
126 int m_id; // Socket id (for event handler)
127 wxSocketHandler *m_handler; // the current socket handler
128 wxRequestNotify m_neededreq; // Specify which requet signals we need
129 bool m_cbkon;
130 char *m_unread; // The unread buf
131 size_t m_unrd_size; // The size of the unread buf
132 bool m_processing; // To prevent some endless loop
133 unsigned long m_timeout;
134 int m_wantbuf;
135 size_t m_lcount; // Last IO request size
136 int m_error; // Last IO error
137 bool m_notifyme;
138
139 struct wxSockInternal *m_internal; // System specific variables
140
141 public:
142 wxSocketBase();
143 virtual ~wxSocketBase();
144 virtual bool Close();
145
146 // Base IO
147 wxSocketBase& Peek(char* buffer, size_t nbytes);
148 wxSocketBase& Read(char* buffer, size_t nbytes);
149 wxSocketBase& Write(const char *buffer, size_t nbytes);
150 wxSocketBase& WriteMsg(const char *buffer, size_t nbytes);
151 wxSocketBase& ReadMsg(char* buffer, size_t nbytes);
152 wxSocketBase& Unread(const char *buffer, size_t nbytes);
153 void Discard();
154
155 // Try not to use this two methods (they sould be protected)
156 void CreatePushbackAfter(const char *buffer, size_t size);
157 void CreatePushbackBefore(const char *buffer, size_t size);
158
159 // Status
160 inline bool Ok() const { return (m_fd < 0 ? 0 : 1); };
161 inline bool Error() const { return (m_error != 0); };
162 inline bool IsConnected() const { return m_connected; };
163 inline bool IsDisconnected() const { return !IsConnected(); };
164 inline bool IsNoWait() const { return m_flags & NOWAIT; };
165 bool IsData() const;
166 inline size_t LastCount() const { return m_lcount; }
167 inline int LastError() const { return m_error; }
168
169 inline void SetFlags(wxSockFlags _flags);
170 inline void SetTimeout(unsigned long sec) { m_timeout = sec; }
171
172 // seconds = -1 means infinite wait
173 // seconds = 0 means no wait
174 // seconds > 0 means specified wait
175 bool Wait(long seconds = -1, long microseconds = 0);
176 bool WaitForRead(long seconds = -1, long microseconds = 0);
177 bool WaitForWrite(long seconds = -1, long microseconds = 0);
178 bool WaitForLost(long seconds = -1, long microseconds = 0);
179
180 // Save the current state of Socket
181 void SaveState();
182 void RestoreState();
183
184 // Setup external callback
185 wxSockCbk Callback(wxSockCbk cbk_);
186 char *CallbackData(char *data);
187
188 // Setup event handler
189 void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1);
190
191 // Method called when it happens something on the socket
192 void SetNotify(wxRequestNotify flags);
193 virtual void OnRequest(wxRequestEvent req_evt);
194
195 // Public internal callback
196 virtual void OldOnNotify(wxRequestEvent WXUNUSED(evt));
197
198 // Some info on the socket...
199 virtual bool GetPeer(wxSockAddress& addr_man) const;
200 virtual bool GetLocal(wxSockAddress& addr_man) const;
201
202 // Install or uninstall callbacks
203 void Notify(bool notify);
204
205 // So you can know what the socket driver is looking for ...
206 inline wxRequestNotify NeededReq() const { return m_neededreq; }
207
208 static wxRequestNotify EventToNotify(wxRequestEvent evt);
209
210 protected:
211 friend class wxSocketServer;
212 friend class wxSocketHandler;
213
214 wxSocketBase(wxSockFlags flags, wxSockType type);
215
216 bool _Wait(long seconds, long microseconds, int type);
217
218 // Set "my" handler
219 inline virtual void SetHandler(wxSocketHandler *handler)
220 { m_handler = handler; }
221
222 // Activate or disactivate callback
223 void SetupCallbacks();
224 void DestroyCallbacks();
225
226 // Pushback library
227 size_t GetPushback(char *buffer, size_t size, bool peek);
228
229 // To prevent many read or write on the same socket at the same time
230 // ==> cause strange things :-)
231 void WantSpeedBuffer(char *buffer, size_t size, wxRequestEvent req);
232 void WantBuffer(char *buffer, size_t size, wxRequestEvent req);
233
234 virtual bool DoRequests(wxRequestEvent req);
235 };
236
237 ////////////////////////////////////////////////////////////////////////
238
239 class WXDLLEXPORT wxSocketServer : public wxSocketBase
240 {
241 DECLARE_CLASS(wxSocketServer)
242 public:
243
244 // 'service' can be a name or a port-number
245
246 wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE);
247
248 wxSocketBase* Accept();
249 bool AcceptWith(wxSocketBase& sock);
250 virtual void OnRequest(wxRequestEvent flags);
251 };
252
253 ////////////////////////////////////////////////////////////////////////
254
255 class WXDLLEXPORT wxSocketClient : public wxSocketBase
256 {
257 DECLARE_CLASS(wxSocketClient)
258 public:
259
260 wxSocketClient(wxSockFlags flags = wxSocketBase::NONE);
261 virtual ~wxSocketClient();
262
263 virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE);
264
265 bool WaitOnConnect(long seconds = -1, long microseconds = 0);
266
267 virtual void OnRequest(wxRequestEvent flags);
268 };
269
270 ////////////////////////////////////////////////////////////////////////
271
272 class WXDLLEXPORT wxSocketHandler : public wxObject
273 {
274 DECLARE_CLASS(wxSocketHandler)
275 protected:
276 #if defined(__WINDOWS__)
277 wxList *smsg_list;
278 struct wxSockHandlerInternal *internal;
279 #endif
280 wxList *socks;
281
282 public:
283 enum SockStatus { SOCK_NONE, SOCK_DATA, SOCK_CONNECT, SOCK_DISCONNECT,
284 SOCK_ERROR };
285 static wxSocketHandler *master;
286
287 wxSocketHandler();
288 virtual ~wxSocketHandler();
289
290 void Register(wxSocketBase* sock);
291 void UnRegister(wxSocketBase* sock);
292
293 unsigned long Count() const;
294
295 // seconds = -1 means indefinite wait
296 // seconds = 0 means no wait
297 // seconds > 0 means specified wait
298
299 int Wait(long seconds = -1, long microseconds = 0);
300 void YieldSock();
301
302 wxSocketServer *CreateServer
303 (wxSockAddress& addr,
304 wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
305 wxSocketClient *CreateClient
306 (wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
307
308 // Create or reuse a socket handler
309 static wxSocketHandler& Master() { return *master; }
310
311 #if defined(WXSOCK_INTERNAL) && defined(__WINDOWS__)
312
313 friend LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd,
314 UINT message, WPARAM wParam, LPARAM lParam);
315
316 UINT NewMessage(wxSocketBase *sock);
317 void DestroyMessage(UINT msg);
318
319 HWND GetHWND() const;
320 #endif
321 };
322
323 class WXDLLEXPORT wxSocketEvent : public wxEvent {
324 DECLARE_DYNAMIC_CLASS(wxSocketEvent)
325 public:
326 wxSocketEvent(int id = 0);
327
328 wxSocketBase::wxRequestEvent SocketEvent() const { return m_skevt; }
329 public:
330 wxSocketBase::wxRequestEvent m_skevt;
331 };
332
333 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
334
335 #define wxEVT_SOCKET wxEVT_FIRST+301
336
337 #define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, 0, \
338 (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
339 (wxObject *) NULL },
340
341 #endif