1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/private/socket.h
3 // Purpose: wxSocketImpl nd related declarations
4 // Authors: Guilhem Lavaux, Vadim Zeitlin
6 // RCS-ID: $Id: socket.h 56994 2008-11-28 12:47:07Z VZ $
7 // Copyright: (c) 1997 Guilhem Lavaux
8 // (c) 2008 Vadim Zeitlin
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
13 Brief overview of different socket classes:
15 - wxSocketBase is the public class representing a socket ("Base" here
16 refers to the fact that wxSocketClient and wxSocketServer are derived
17 from it and predates the convention of using "Base" for common base
18 classes for platform-specific classes in wxWidgets) with implementation
19 common to all platforms and forwarding methods whose implementation
20 differs between platforms to wxSocketImpl which it contains.
22 - wxSocketImpl is actually just an abstract base class having only code
23 common to all platforms, the concrete implementation classes derive from
24 it and are created by wxSocketImpl::Create().
26 - Some socket operations have different implementations in console-mode and
27 GUI applications. wxSocketManager class exists to abstract this in such
28 way that console applications (using wxBase) don't depend on wxNet. An
29 object of this class is made available via wxApp and GUI applications set
30 up a different kind of global socket manager from console ones.
32 TODO: it looks like wxSocketManager could be eliminated by providing
33 methods for registering/unregistering sockets directly in
37 #ifndef _WX_PRIVATE_SOCKET_H_
38 #define _WX_PRIVATE_SOCKET_H_
44 #include "wx/socket.h"
49 Including sys/types.h under Cygwin results in the warnings about "fd_set
50 having been defined in sys/types.h" when winsock.h is included later and
51 doesn't seem to be necessary anyhow. It's not needed under Mac neither.
53 #if !defined(__WXMAC__) && !defined(__CYGWIN__) && !defined(__WXWINCE__)
54 #include <sys/types.h>
61 // include the header defining timeval: under Windows this struct is used only
62 // with sockets so we need to include winsock.h which we do via windows.h
64 #include "wx/msw/wrapwin.h"
66 #include <sys/time.h> // for timeval
69 // these definitions are for MSW when we don't use configure, otherwise these
70 // symbols are defined by configure
72 #define WX_SOCKLEN_T int
76 #define SOCKOPTLEN_T int
79 // define some symbols which winsock.h defines but traditional BSD headers
85 #ifndef INVALID_SOCKET
86 #define INVALID_SOCKET (-1)
90 #define SOCKET_ERROR (-1)
94 typedef struct sockaddr_storage wxSockAddr
;
96 typedef struct sockaddr wxSockAddr
;
101 wxSOCKET_NOFAMILY
= 0,
107 typedef int wxSocketEventFlags
;
113 Class providing hooks abstracting the differences between console and GUI
114 applications for socket code.
116 We also have different implementations of this class for different platforms
117 allowing us to keep more things in the common code but the main reason for
118 its existence is that we want the same socket code work differently
119 depending on whether it's used from a console or a GUI program. This is
120 achieved by implementing the virtual methods of this class differently in
121 the objects returned by wxConsoleAppTraits::GetSocketManager() and the same
122 method in wxGUIAppTraits.
124 class wxSocketManager
127 // set the manager to use, we don't take ownership of it
129 // this should be called before creating the first wxSocket object,
130 // otherwise the manager returned by wxAppTraits::GetSocketManager() will
132 static void Set(wxSocketManager
*manager
);
134 // return the manager to use
136 // this initializes the manager at first use
137 static wxSocketManager
*Get()
145 // called before the first wxSocket is created and should do the
146 // initializations needed in order to use the network
148 // return true if initialized successfully; if this returns false sockets
149 // can't be used at all
150 virtual bool OnInit() = 0;
152 // undo the initializations of OnInit()
153 virtual void OnExit() = 0;
156 // these functions enable or disable monitoring of the given socket for the
157 // specified events inside the currently running event loop (but notice
158 // that both BSD and Winsock implementations actually use socket->m_server
159 // value to determine what exactly should be monitored so it needs to be
160 // set before calling these functions)
161 virtual void Install_Callback(wxSocketImpl
*socket
,
162 wxSocketNotify event
= wxSOCKET_MAX_EVENT
) = 0;
163 virtual void Uninstall_Callback(wxSocketImpl
*socket
,
164 wxSocketNotify event
= wxSOCKET_MAX_EVENT
) = 0;
166 virtual ~wxSocketManager() { }
169 // get the manager to use if we don't have it yet
172 static wxSocketManager
*ms_manager
;
176 Base class for all socket implementations providing functionality common to
177 BSD and Winsock sockets.
179 Objects of this class are not created directly but only via its static
180 Create() method which is implemented in port-specific code.
185 // static factory function: creates the low-level socket associated with
186 // the given wxSocket (and inherits its attributes such as timeout)
187 static wxSocketImpl
*Create(wxSocketBase
& wxsocket
);
189 virtual ~wxSocketImpl();
191 // set various socket properties: all of those can only be called before
192 // creating the socket
193 void SetTimeout(unsigned long millisec
);
194 void SetNonBlocking(bool non_blocking
) { m_non_blocking
= non_blocking
; }
195 void SetReusable() { m_reusable
= true; }
196 void SetBroadcast() { m_broadcast
= true; }
197 void DontDoBind() { m_dobind
= false; }
198 void SetInitialSocketBuffers(int recv
, int send
)
200 m_initialRecvBufferSize
= recv
;
201 m_initialSendBufferSize
= send
;
204 wxSocketError
SetLocal(GAddress
*address
);
205 wxSocketError
SetPeer(GAddress
*address
);
210 GAddress
*GetLocal();
213 wxSocketError
GetError() const { return m_error
; }
214 bool IsOk() const { return m_error
== wxSOCKET_NOERROR
; }
217 // creating/closing the socket
218 // --------------------------
220 // notice that SetLocal() must be called before creating the socket using
221 // any of the functions below
223 // all of Create() functions return wxSOCKET_NOERROR if the operation
224 // completed successfully or one of:
225 // wxSOCKET_INVSOCK - the socket is in use.
226 // wxSOCKET_INVADDR - the local (server) or peer (client) address has not
228 // wxSOCKET_IOERR - any other error.
230 // create a socket listening on the local address specified by SetLocal()
231 // (notice that DontDoBind() is ignored by this function)
232 wxSocketError
CreateServer();
234 // create a socket connected to the peer address specified by SetPeer()
235 // (notice that DontDoBind() is ignored by this function)
237 // this function may return wxSOCKET_WOULDBLOCK in addition to the return
238 // values listed above
239 wxSocketError
CreateClient();
241 // create (and bind unless DontDoBind() had been called) an UDP socket
242 // associated with the given local address
243 wxSocketError
CreateUDP();
245 // may be called whether the socket was created or not, calls DoClose() if
246 // it was indeed created
249 virtual void Shutdown();
255 virtual int Read(void *buffer
, int size
) = 0;
256 virtual int Write(const void *buffer
, int size
) = 0;
258 wxSocketEventFlags
Select(wxSocketEventFlags flags
);
260 virtual wxSocketImpl
*WaitConnection(wxSocketBase
& wxsocket
) = 0;
266 // notify m_wxsocket about the given socket event by calling its (inaptly
267 // named) OnRequest() method
268 void NotifyOnStateChange(wxSocketNotify event
);
270 // FIXME: this one probably isn't needed here at all
271 virtual void Notify(bool WXUNUSED(notify
)) { }
273 // TODO: make these fields protected and provide accessors for those of
274 // them that wxSocketBase really needs
278 int m_initialRecvBufferSize
;
279 int m_initialSendBufferSize
;
283 wxSocketError m_error
;
293 struct timeval m_timeout
;
295 wxSocketEventFlags m_detected
;
298 wxSocketImpl(wxSocketBase
& wxsocket
);
301 // handle the given connect() return value (which may be 0 or EWOULDBLOCK
302 // or something else)
303 virtual wxSocketError
DoHandleConnect(int ret
) = 0;
305 // called by Close() if we have a valid m_fd
306 virtual void DoClose() = 0;
308 // put this socket into non-blocking mode and enable monitoring this socket
309 // as part of the event loop
310 virtual void UnblockAndRegisterWithEventLoop() = 0;
312 // check that the socket wasn't created yet and that the given address
313 // (either m_local or m_peer depending on the socket kind) is valid and
314 // set m_error and return false if this is not the case
315 bool PreCreateCheck(GAddress
*addr
);
317 // set the given socket option: this just wraps setsockopt(SOL_SOCKET)
318 int SetSocketOption(int optname
, int optval
)
320 // although modern Unix systems use "const void *" for the 4th
321 // parameter here, old systems and Winsock still use "const char *"
322 return setsockopt(m_fd
, SOL_SOCKET
, optname
,
323 reinterpret_cast<const char *>(&optval
),
327 // set the given socket option to true value: this is an even simpler
328 // wrapper for setsockopt(SOL_SOCKET) for boolean options
329 int EnableSocketOption(int optname
)
331 return SetSocketOption(optname
, 1);
334 // apply the options to the (just created) socket and register it with the
335 // event loop by calling UnblockAndRegisterWithEventLoop()
338 // update local address after binding/connecting
339 wxSocketError
UpdateLocalAddress();
342 // set in ctor and never changed except that it's reset to NULL when the
343 // socket is shut down
344 wxSocketBase
*m_wxsocket
;
346 DECLARE_NO_COPY_CLASS(wxSocketImpl
)
349 #if defined(__WXMSW__)
350 #include "wx/msw/gsockmsw.h"
352 #include "wx/unix/private/sockunix.h"
358 // TODO: make GAddress a real class instead of this mix of C and C++
360 // Represents a socket endpoint, i.e. -- in spite of its name -- not an address
361 // but an (address, port) pair
364 struct sockaddr
*m_addr
;
367 GAddressType m_family
;
370 wxSocketError m_error
;
373 GAddress
*GAddress_new();
374 GAddress
*GAddress_copy(GAddress
*address
);
375 void GAddress_destroy(GAddress
*address
);
377 void GAddress_SetFamily(GAddress
*address
, GAddressType type
);
378 GAddressType
GAddress_GetFamily(GAddress
*address
);
380 /* The use of any of the next functions will set the address family to
381 * the specific one. For example if you use GAddress_INET_SetHostName,
382 * address family will be implicitly set to AF_INET.
385 wxSocketError
GAddress_INET_SetHostName(GAddress
*address
, const char *hostname
);
386 wxSocketError
GAddress_INET_SetBroadcastAddress(GAddress
*address
);
387 wxSocketError
GAddress_INET_SetAnyAddress(GAddress
*address
);
388 wxSocketError
GAddress_INET_SetHostAddress(GAddress
*address
,
389 unsigned long hostaddr
);
390 wxSocketError
GAddress_INET_SetPortName(GAddress
*address
, const char *port
,
391 const char *protocol
);
392 wxSocketError
GAddress_INET_SetPort(GAddress
*address
, unsigned short port
);
394 wxSocketError
GAddress_INET_GetHostName(GAddress
*address
, char *hostname
,
396 unsigned long GAddress_INET_GetHostAddress(GAddress
*address
);
397 unsigned short GAddress_INET_GetPort(GAddress
*address
);
399 wxSocketError
_GAddress_translate_from(GAddress
*address
,
400 struct sockaddr
*addr
, int len
);
401 wxSocketError
_GAddress_translate_to (GAddress
*address
,
402 struct sockaddr
**addr
, int *len
);
403 wxSocketError
_GAddress_Init_INET(GAddress
*address
);
407 wxSocketError
GAddress_INET6_SetHostName(GAddress
*address
, const char *hostname
);
408 wxSocketError
GAddress_INET6_SetAnyAddress(GAddress
*address
);
409 wxSocketError
GAddress_INET6_SetHostAddress(GAddress
*address
,
410 struct in6_addr hostaddr
);
411 wxSocketError
GAddress_INET6_SetPortName(GAddress
*address
, const char *port
,
412 const char *protocol
);
413 wxSocketError
GAddress_INET6_SetPort(GAddress
*address
, unsigned short port
);
415 wxSocketError
GAddress_INET6_GetHostName(GAddress
*address
, char *hostname
,
417 wxSocketError
GAddress_INET6_GetHostAddress(GAddress
*address
,struct in6_addr
*hostaddr
);
418 unsigned short GAddress_INET6_GetPort(GAddress
*address
);
422 // these functions are available under all platforms but only implemented under
423 // Unix ones, elsewhere they just return wxSOCKET_INVADDR
424 wxSocketError
_GAddress_Init_UNIX(GAddress
*address
);
425 wxSocketError
GAddress_UNIX_SetPath(GAddress
*address
, const char *path
);
426 wxSocketError
GAddress_UNIX_GetPath(GAddress
*address
, char *path
, size_t sbuf
);
428 #endif /* wxUSE_SOCKETS */
430 #endif /* _WX_PRIVATE_SOCKET_H_ */