1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/private/socket.h
3 // Purpose: wxSocketImpl nd related declarations
4 // Authors: Guilhem Lavaux, Vadim Zeitlin
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"
45 #include "wx/private/sckaddr.h"
50 Including sys/types.h under Cygwin results in the warnings about "fd_set
51 having been defined in sys/types.h" when winsock.h is included later and
52 doesn't seem to be necessary anyhow. It's not needed under Mac neither.
54 #if !defined(__WXMAC__) && !defined(__CYGWIN__) && !defined(__WXWINCE__)
55 #include <sys/types.h>
62 // include the header defining timeval: under Windows this struct is used only
63 // with sockets so we need to include winsock.h which we do via windows.h
65 #include "wx/msw/wrapwin.h"
67 #include <sys/time.h> // for timeval
70 // these definitions are for MSW when we don't use configure, otherwise these
71 // symbols are defined by configure
73 #define WX_SOCKLEN_T int
77 #define SOCKOPTLEN_T int
80 // define some symbols which winsock.h defines but traditional BSD headers
86 #ifndef INVALID_SOCKET
87 #define INVALID_SOCKET (-1)
91 #define SOCKET_ERROR (-1)
94 typedef int wxSocketEventFlags
;
99 Class providing hooks abstracting the differences between console and GUI
100 applications for socket code.
102 We also have different implementations of this class for different platforms
103 allowing us to keep more things in the common code but the main reason for
104 its existence is that we want the same socket code work differently
105 depending on whether it's used from a console or a GUI program. This is
106 achieved by implementing the virtual methods of this class differently in
107 the objects returned by wxConsoleAppTraits::GetSocketManager() and the same
108 method in wxGUIAppTraits.
110 class wxSocketManager
113 // set the manager to use, we don't take ownership of it
115 // this should be called before creating the first wxSocket object,
116 // otherwise the manager returned by wxAppTraits::GetSocketManager() will
118 static void Set(wxSocketManager
*manager
);
120 // return the manager to use
122 // this initializes the manager at first use
123 static wxSocketManager
*Get()
131 // called before the first wxSocket is created and should do the
132 // initializations needed in order to use the network
134 // return true if initialized successfully; if this returns false sockets
135 // can't be used at all
136 virtual bool OnInit() = 0;
138 // undo the initializations of OnInit()
139 virtual void OnExit() = 0;
142 // these functions enable or disable monitoring of the given socket for the
143 // specified events inside the currently running event loop (but notice
144 // that both BSD and Winsock implementations actually use socket->m_server
145 // value to determine what exactly should be monitored so it needs to be
146 // set before calling these functions)
147 virtual void Install_Callback(wxSocketImpl
*socket
,
148 wxSocketNotify event
= wxSOCKET_MAX_EVENT
) = 0;
149 virtual void Uninstall_Callback(wxSocketImpl
*socket
,
150 wxSocketNotify event
= wxSOCKET_MAX_EVENT
) = 0;
152 virtual ~wxSocketManager() { }
155 // get the manager to use if we don't have it yet
158 static wxSocketManager
*ms_manager
;
162 Base class for all socket implementations providing functionality common to
163 BSD and Winsock sockets.
165 Objects of this class are not created directly but only via its static
166 Create() method which is implemented in port-specific code.
171 // static factory function: creates the low-level socket associated with
172 // the given wxSocket (and inherits its attributes such as timeout)
173 static wxSocketImpl
*Create(wxSocketBase
& wxsocket
);
175 virtual ~wxSocketImpl();
177 // set various socket properties: all of those can only be called before
178 // creating the socket
179 void SetTimeout(unsigned long millisec
);
180 void SetReusable() { m_reusable
= true; }
181 void SetBroadcast() { m_broadcast
= true; }
182 void DontDoBind() { m_dobind
= false; }
183 void SetInitialSocketBuffers(int recv
, int send
)
185 m_initialRecvBufferSize
= recv
;
186 m_initialSendBufferSize
= send
;
189 wxSocketError
SetLocal(const wxSockAddressImpl
& address
);
190 wxSocketError
SetPeer(const wxSockAddressImpl
& address
);
195 bool IsServer() const { return m_server
; }
197 const wxSockAddressImpl
& GetLocal(); // non const as may update m_local
198 const wxSockAddressImpl
& GetPeer() const { return m_peer
; }
200 wxSocketError
GetError() const { return m_error
; }
201 bool IsOk() const { return m_error
== wxSOCKET_NOERROR
; }
203 // get the error code corresponding to the last operation
204 virtual wxSocketError
GetLastError() const = 0;
207 // creating/closing the socket
208 // --------------------------
210 // notice that SetLocal() must be called before creating the socket using
211 // any of the functions below
213 // all of Create() functions return wxSOCKET_NOERROR if the operation
214 // completed successfully or one of:
215 // wxSOCKET_INVSOCK - the socket is in use.
216 // wxSOCKET_INVADDR - the local (server) or peer (client) address has not
218 // wxSOCKET_IOERR - any other error.
220 // create a socket listening on the local address specified by SetLocal()
221 // (notice that DontDoBind() is ignored by this function)
222 wxSocketError
CreateServer();
224 // create a socket connected to the peer address specified by SetPeer()
225 // (notice that DontDoBind() is ignored by this function)
227 // this function may return wxSOCKET_WOULDBLOCK in addition to the return
228 // values listed above if wait is false
229 wxSocketError
CreateClient(bool wait
);
231 // create (and bind unless DontDoBind() had been called) an UDP socket
232 // associated with the given local address
233 wxSocketError
CreateUDP();
235 // may be called whether the socket was created or not, calls DoClose() if
236 // it was indeed created
239 // shuts down the writing end of the socket and closes it, this is a more
240 // graceful way to close
242 // does nothing if the socket wasn't created
249 // basic IO, work for both TCP and UDP sockets
251 // return the number of bytes read/written (possibly 0) or -1 on error
252 int Read(void *buffer
, int size
);
253 int Write(const void *buffer
, int size
);
255 // basically a wrapper for select(): returns the condition of the socket,
256 // blocking for not longer than timeout if it is specified (otherwise just
257 // poll without blocking at all)
259 // flags defines what kind of conditions we're interested in, the return
260 // value is composed of a (possibly empty) subset of the bits set in flags
261 wxSocketEventFlags
Select(wxSocketEventFlags flags
,
262 const timeval
*timeout
= NULL
);
264 // convenient wrapper calling Select() with our default timeout
265 wxSocketEventFlags
SelectWithTimeout(wxSocketEventFlags flags
)
267 return Select(flags
, &m_timeout
);
270 // just a wrapper for accept(): it is called to create a new wxSocketImpl
271 // corresponding to a new server connection represented by the given
272 // wxSocketBase, returns NULL on error (including immediately if there are
273 // no pending connections as our sockets are non-blocking)
274 wxSocketImpl
*Accept(wxSocketBase
& wxsocket
);
280 // notify m_wxsocket about the given socket event by calling its (inaptly
281 // named) OnRequest() method
282 void NotifyOnStateChange(wxSocketNotify event
);
284 // TODO: make these fields protected and provide accessors for those of
285 // them that wxSocketBase really needs
289 int m_initialRecvBufferSize
;
290 int m_initialSendBufferSize
;
292 wxSockAddressImpl m_local
,
294 wxSocketError m_error
;
302 struct timeval m_timeout
;
305 wxSocketImpl(wxSocketBase
& wxsocket
);
307 // true if we're a listening stream socket
311 // called by Close() if we have a valid m_fd
312 virtual void DoClose() = 0;
314 // put this socket into non-blocking mode and enable monitoring this socket
315 // as part of the event loop
316 virtual void UnblockAndRegisterWithEventLoop() = 0;
318 // check that the socket wasn't created yet and that the given address
319 // (either m_local or m_peer depending on the socket kind) is valid and
320 // set m_error and return false if this is not the case
321 bool PreCreateCheck(const wxSockAddressImpl
& addr
);
323 // set the given socket option: this just wraps setsockopt(SOL_SOCKET)
324 int SetSocketOption(int optname
, int optval
)
326 // although modern Unix systems use "const void *" for the 4th
327 // parameter here, old systems and Winsock still use "const char *"
328 return setsockopt(m_fd
, SOL_SOCKET
, optname
,
329 reinterpret_cast<const char *>(&optval
),
333 // set the given socket option to true value: this is an even simpler
334 // wrapper for setsockopt(SOL_SOCKET) for boolean options
335 int EnableSocketOption(int optname
)
337 return SetSocketOption(optname
, 1);
340 // apply the options to the (just created) socket and register it with the
341 // event loop by calling UnblockAndRegisterWithEventLoop()
344 // update local address after binding/connecting
345 wxSocketError
UpdateLocalAddress();
347 // functions used to implement Read/Write()
348 int RecvStream(void *buffer
, int size
);
349 int RecvDgram(void *buffer
, int size
);
350 int SendStream(const void *buffer
, int size
);
351 int SendDgram(const void *buffer
, int size
);
354 // set in ctor and never changed except that it's reset to NULL when the
355 // socket is shut down
356 wxSocketBase
*m_wxsocket
;
358 DECLARE_NO_COPY_CLASS(wxSocketImpl
)
361 #if defined(__WXMSW__)
362 #include "wx/msw/private/sockmsw.h"
364 #include "wx/unix/private/sockunix.h"
367 #endif /* wxUSE_SOCKETS */
369 #endif /* _WX_PRIVATE_SOCKET_H_ */