X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9181a383828ed30cc1e2a1fe5c630a1fc4c8d273..f24f65791310a4e0d1690f244658b837036aa270:/include/wx/socket.h diff --git a/include/wx/socket.h b/include/wx/socket.h index d991e85afb..1b72a2cd56 100644 --- a/include/wx/socket.h +++ b/include/wx/socket.h @@ -9,315 +9,377 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifndef _WX_NETWORK_SOCKET_H -#define _WX_NETWORK_SOCKET_H - -#ifdef __GNUG__ -#pragma interface "socket.h" -#endif +#ifndef _WX_SOCKET_H_ +#define _WX_SOCKET_H_ #include "wx/defs.h" #if wxUSE_SOCKETS // --------------------------------------------------------------------------- -// wxSocket headers (generic) +// wxSocket headers // --------------------------------------------------------------------------- -#ifdef WXPREC -# include "wx/wxprec.h" -#else -# include "wx/event.h" -# include "wx/string.h" -#endif - +#include "wx/event.h" #include "wx/sckaddr.h" -#include "wx/gsocket.h" +#include "wx/list.h" + +class wxSocketImpl; // ------------------------------------------------------------------------ -// constants +// Types and constants // ------------------------------------------------------------------------ +// Types of different socket notifications or events. +// +// NB: the values here should be consecutive and start with 0 as they are +// used to construct the wxSOCKET_XXX_FLAG bit mask values below enum wxSocketNotify { - wxSOCKET_INPUT = GSOCK_INPUT, - wxSOCKET_OUTPUT = GSOCK_OUTPUT, - wxSOCKET_CONNECTION = GSOCK_CONNECTION, - wxSOCKET_LOST = GSOCK_LOST + wxSOCKET_INPUT, + wxSOCKET_OUTPUT, + wxSOCKET_CONNECTION, + wxSOCKET_LOST, + wxSOCKET_MAX_EVENT }; enum { - wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG, - wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG, - wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG, - wxSOCKET_LOST_FLAG = GSOCK_LOST_FLAG + wxSOCKET_INPUT_FLAG = 1 << wxSOCKET_INPUT, + wxSOCKET_OUTPUT_FLAG = 1 << wxSOCKET_OUTPUT, + wxSOCKET_CONNECTION_FLAG = 1 << wxSOCKET_CONNECTION, + wxSOCKET_LOST_FLAG = 1 << wxSOCKET_LOST }; -typedef GSocketEventFlags wxSocketEventFlags; +// this is a combination of the bit masks defined above +typedef int wxSocketEventFlags; enum wxSocketError { - wxSOCKET_NOERROR = GSOCK_NOERROR, - wxSOCKET_INPOP = GSOCK_INVOP, - wxSOCKET_IOERR = GSOCK_IOERR, - wxSOCKET_INVADDR = GSOCK_INVADDR, - wxSOCKET_INVSOCK = GSOCK_INVSOCK, - wxSOCKET_NOHOST = GSOCK_NOHOST, - wxSOCKET_INVPORT = GSOCK_INVPORT, - wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK, - wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT, - wxSOCKET_MEMERR = GSOCK_MEMERR, - wxSOCKET_BUSY + wxSOCKET_NOERROR = 0, + wxSOCKET_INVOP, + wxSOCKET_IOERR, + wxSOCKET_INVADDR, + wxSOCKET_INVSOCK, + wxSOCKET_NOHOST, + wxSOCKET_INVPORT, + wxSOCKET_WOULDBLOCK, + wxSOCKET_TIMEDOUT, + wxSOCKET_MEMERR, + wxSOCKET_OPTERR }; +// socket options/flags bit masks enum { - wxSOCKET_NONE = 0, - wxSOCKET_NOWAIT = 1, - wxSOCKET_WAITALL = 2, - wxSOCKET_BLOCK = 4 + wxSOCKET_NONE = 0, + wxSOCKET_NOWAIT = 1, + wxSOCKET_WAITALL = 2, + wxSOCKET_BLOCK = 4, + wxSOCKET_REUSEADDR = 8, + wxSOCKET_BROADCAST = 16, + wxSOCKET_NOBIND = 32 }; -// Type of socket -enum wxSockType +typedef int wxSocketFlags; + +// socket kind values (badly defined, don't use) +enum wxSocketType { - SOCK_CLIENT, - SOCK_SERVER, - SOCK_DATAGRAM, - SOCK_INTERNAL, - SOCK_UNINIT + wxSOCKET_UNINIT, + wxSOCKET_CLIENT, + wxSOCKET_SERVER, + wxSOCKET_BASE, + wxSOCKET_DATAGRAM }; -typedef int wxSockFlags; -// ------------------------------------------------------------------------ -// wxSocket base -// ------------------------------------------------------------------------ -class WXDLLEXPORT wxTimer; -class WXDLLEXPORT wxSocketEvent; +// -------------------------------------------------------------------------- +// wxSocketBase +// -------------------------------------------------------------------------- -class WXDLLEXPORT wxSocketBase : public wxEvtHandler +class WXDLLIMPEXP_NET wxSocketBase : public wxObject { DECLARE_CLASS(wxSocketBase) + public: - enum - { - NONE = wxSOCKET_NONE, - NOWAIT = wxSOCKET_NOWAIT, - WAITALL = wxSOCKET_WAITALL, - SPEED = wxSOCKET_BLOCK - }; - - typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); - -protected: - GSocket *m_socket; // GSocket - wxEvtHandler *m_evt_handler; // event handler - int m_id; // Socket id (for event handler) - - // Attributes - wxSockFlags m_flags; // wxSocket flags - wxSockType m_type; // wxSocket type - wxSocketEventFlags m_neededreq; // Event mask - bool m_notify_state; // Notify events to users? - - // State - bool m_connected; // Connected? - bool m_establishing; // Establishing connection? - bool m_reading; // Busy reading? - bool m_writing; // Busy writing? - bool m_error; // Did last IO call fail? - wxUint32 m_lcount; // Last IO transaction size - unsigned long m_timeout; // IO timeout value - wxList m_states; // Stack of states - bool m_interrupt; // Interrupt ongoing wait operations - bool m_beingDeleted; // Marked for delayed deletion - - // Pushback buffer - char *m_unread; // Pushback buffer - wxUint32 m_unrd_size; // Pushback buffer size - wxUint32 m_unrd_cur; // Pushback pointer (index into buffer) - - // Callback - wxSockCbk m_cbk; // C callback - char *m_cdata; // C callback data + // Public interface + // ---------------- -public: + // ctors and dtors wxSocketBase(); + wxSocketBase(wxSocketFlags flags, wxSocketType type); virtual ~wxSocketBase(); - virtual bool Destroy(); - - // Base IO - virtual bool Close(); - wxSocketBase& Peek(char* buffer, wxUint32 nbytes); - wxSocketBase& Read(char* buffer, wxUint32 nbytes); - wxSocketBase& Write(const char *buffer, wxUint32 nbytes); - wxSocketBase& Unread(const char *buffer, wxUint32 nbytes); - wxSocketBase& ReadMsg(char *buffer, wxUint32 nbytes); - wxSocketBase& WriteMsg(const char *buffer, wxUint32 nbytes); - wxSocketBase& Discard(); + void Init(); + bool Destroy(); + + // state + bool Ok() const { return IsOk(); } + bool IsOk() const { return m_impl != NULL; } + bool Error() const { return m_error; } + bool IsClosed() const { return m_closed; } + bool IsConnected() const { return m_connected; } + bool IsData() { return WaitForRead(0, 0); } + bool IsDisconnected() const { return !IsConnected(); } + wxUint32 LastCount() const { return m_lcount; } + wxSocketError LastError() const; + void SaveState(); + void RestoreState(); - // Status - inline bool Ok() const { return (m_socket != NULL); }; - inline bool Error() const { return m_error; }; - inline bool IsConnected() const { return m_connected; }; - inline bool IsDisconnected() const { return !IsConnected(); }; - inline bool IsNoWait() const { return ((m_flags & NOWAIT) != 0); }; - inline bool IsData() { return WaitForRead(0, 0); }; - inline wxUint32 LastCount() const { return m_lcount; } - inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); } - inline wxSockType GetType() const { return m_type; } - - // Addresses - virtual bool GetPeer(wxSockAddress& addr_man) const; + // addresses virtual bool GetLocal(wxSockAddress& addr_man) const; + virtual bool GetPeer(wxSockAddress& addr_man) const; + virtual bool SetLocal(const wxIPV4address& local); - // Set attributes and flags - void SetTimeout(long seconds); - void SetFlags(wxSockFlags flags); - inline wxSockFlags GetFlags() const { return m_flags; }; - - /* Wait functions - * seconds = -1 means default timeout (change with SetTimeout) - * seconds, milliseconds = 0 means no wait - * seconds, milliseconds > 0 means specified wait - */ + // base IO + virtual bool Close(); + wxSocketBase& Discard(); + wxSocketBase& Peek(void* buffer, wxUint32 nbytes); + wxSocketBase& Read(void* buffer, wxUint32 nbytes); + wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes); + wxSocketBase& Unread(const void *buffer, wxUint32 nbytes); + wxSocketBase& Write(const void *buffer, wxUint32 nbytes); + wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes); + + // all Wait() functions wait until their condition is satisfied or the + // timeout expires; if seconds == -1 (default) then m_timeout value is used + // + // it is also possible to call InterruptWait() to cancel any current Wait() + + // wait for anything at all to happen with this socket bool Wait(long seconds = -1, long milliseconds = 0); + + // wait until we can read from or write to the socket without blocking + // (notice that this does not mean that the operation will succeed but only + // that it will return immediately) bool WaitForRead(long seconds = -1, long milliseconds = 0); bool WaitForWrite(long seconds = -1, long milliseconds = 0); + + // wait until the connection is terminated bool WaitForLost(long seconds = -1, long milliseconds = 0); - /* This function interrupts all ongoing wait operations for this - * socket; use it only as an escape mechanism (for example to close - * an app or to abort an operation). Reception of LOST events and - * calls to Close() automatically call this. - */ - void InterruptAllWaits() { m_interrupt = TRUE; }; + void InterruptWait() { m_interrupt = true; } - // Save the current state of Socket - void SaveState(); - void RestoreState(); - // Setup event handler - void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1); + wxSocketFlags GetFlags() const { return m_flags; } + void SetFlags(wxSocketFlags flags); + void SetTimeout(long seconds); + long GetTimeout() const { return m_timeout; } + + bool GetOption(int level, int optname, void *optval, int *optlen); + bool SetOption(int level, int optname, const void *optval, int optlen); + wxUint32 GetLastIOSize() const { return m_lcount; } - // Tell wxSocket which events to notify + // event handling + void *GetClientData() const { return m_clientData; } + void SetClientData(void *data) { m_clientData = data; } + void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY); void SetNotify(wxSocketEventFlags flags); void Notify(bool notify); - static wxSocketEventFlags EventToNotify(wxSocketNotify evt); - inline wxSocketEventFlags NeededReq() const { return m_neededreq; } - - // External callback - wxSockCbk Callback(wxSockCbk cbk_); - char *CallbackData(char *data); - // Public internal callback - virtual void OldOnNotify(wxSocketNotify WXUNUSED(evt)); + // initialize/shutdown the sockets (usually called automatically) + static bool IsInitialized(); + static bool Initialize(); + static void Shutdown(); - // Do NOT use this function; it should be protected! - void OnRequest(wxSocketNotify req_evt); -protected: - friend class wxSocketServer; - friend class wxSocketClient; - friend class wxSocketHandler; + // Implementation from now on + // -------------------------- -#ifdef __SALFORDC__ -public: -#endif + // do not use, should be private (called from wxSocketImpl only) + void OnRequest(wxSocketNotify notify); - wxSocketBase(wxSockFlags flags, wxSockType type); + // do not use, not documented nor supported + bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); } + wxSocketType GetType() const { return m_type; } -#ifdef __SALFORDC__ -protected: -#endif - - // Low level IO - wxUint32 _Read(char* buffer, wxUint32 nbytes); - wxUint32 _Write(const char *buffer, wxUint32 nbytes); - bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags); - - // Pushbacks - void Pushback(const char *buffer, wxUint32 size); - wxUint32 GetPushback(char *buffer, wxUint32 size, bool peek); +private: + friend class wxSocketClient; + friend class wxSocketServer; + friend class wxDatagramSocket; + + // low level IO + wxUint32 DoRead(void* buffer, wxUint32 nbytes); + wxUint32 DoWrite(const void *buffer, wxUint32 nbytes); + + // wait until the given flags are set for this socket or the given timeout + // (or m_timeout) expires + // + // notice that wxSOCKET_LOST_FLAG is always taken into account but the return + // value depends on whether it is included in flags or not: if it is, and the + // connection is indeed lost, true is returned, but if it isn't then the + // function returns false in this case + // + // false is always returned if we returned because of the timeout expiration + bool DoWait(long seconds, long milliseconds, wxSocketEventFlags flags); + + // pushback buffer + void Pushback(const void *buffer, wxUint32 size); + wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek); + +private: + // socket + wxSocketImpl *m_impl; // port-specific implementation + wxSocketType m_type; // wxSocket type + + // state + wxSocketFlags m_flags; // wxSocket flags + bool m_connected; // connected? + bool m_establishing; // establishing connection? + bool m_reading; // busy reading? + bool m_writing; // busy writing? + bool m_error; // did last IO call fail? + bool m_closed; // was the other end closed? + // (notice that m_error is also set then) + wxUint32 m_lcount; // last IO transaction size + unsigned long m_timeout; // IO timeout value in seconds + wxList m_states; // stack of states + bool m_interrupt; // interrupt ongoing wait operations? + bool m_beingDeleted; // marked for delayed deletion? + wxIPV4address m_localAddress; // bind to local address? + + // pushback buffer + void *m_unread; // pushback buffer + wxUint32 m_unrd_size; // pushback buffer size + wxUint32 m_unrd_cur; // pushback pointer (index into buffer) + + // events + int m_id; // socket id + wxEvtHandler *m_handler; // event handler + void *m_clientData; // client data for events + bool m_notify; // notify events to users? + wxSocketEventFlags m_eventmask; // which events to notify? + + // the initialization count, GSocket is initialized if > 0 + static size_t m_countInit; + + DECLARE_NO_COPY_CLASS(wxSocketBase) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketServer : public wxSocketBase +// -------------------------------------------------------------------------- +// wxSocketServer +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase { DECLARE_CLASS(wxSocketServer) -public: - // 'service' can be a name or a port-number - wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSOCKET_NONE); +public: + wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); - wxSocketBase* Accept(bool wait = TRUE); - bool AcceptWith(wxSocketBase& sock, bool wait = TRUE); + wxSocketBase* Accept(bool wait = true); + bool AcceptWith(wxSocketBase& socket, bool wait = true); bool WaitForAccept(long seconds = -1, long milliseconds = 0); + + DECLARE_NO_COPY_CLASS(wxSocketServer) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketClient : public wxSocketBase +// -------------------------------------------------------------------------- +// wxSocketClient +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase { DECLARE_CLASS(wxSocketClient) -public: - wxSocketClient(wxSockFlags flags = wxSOCKET_NONE); +public: + wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); virtual ~wxSocketClient(); - virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE); + virtual bool Connect(const wxSockAddress& addr, bool wait = true); + bool Connect(const wxSockAddress& addr, const wxSockAddress& local, + bool wait = true); bool WaitOnConnect(long seconds = -1, long milliseconds = 0); + + // Sets initial socket buffer sizes using the SO_SNDBUF and SO_RCVBUF options + // before calling connect (either one can be -1 to leave it unchanged) + void SetInitialSocketBuffers(int recv, int send) + { + m_initialRecvBufferSize = recv; + m_initialSendBufferSize = send; + } + +private: + virtual bool DoConnect(const wxSockAddress& addr, + const wxSockAddress* local, + bool wait = true); + + // buffer sizes, -1 if unset and defaults should be used + int m_initialRecvBufferSize; + int m_initialSendBufferSize; + + DECLARE_NO_COPY_CLASS(wxSocketClient) }; -//////////////////////////////////////////////////////////////////////// -class wxDatagramSocket : public wxSocketBase +// -------------------------------------------------------------------------- +// wxDatagramSocket +// -------------------------------------------------------------------------- + +// WARNING: still in alpha stage + +class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase { DECLARE_CLASS(wxDatagramSocket) public: - wxDatagramSocket( wxSockAddress& addr, wxSockFlags flags = wxSOCKET_NONE ); + wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxDatagramSocket& RecvFrom( wxSockAddress& addr, - char* buf, + void* buf, wxUint32 nBytes ); - wxDatagramSocket& SendTo( wxSockAddress& addr, - const char* buf, + wxDatagramSocket& SendTo( const wxSockAddress& addr, + const void* buf, wxUint32 nBytes ); + +/* TODO: + bool Connect(wxSockAddress& addr); +*/ + DECLARE_NO_COPY_CLASS(wxDatagramSocket) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketEvent : public wxEvent { - DECLARE_DYNAMIC_CLASS(wxSocketEvent) +// -------------------------------------------------------------------------- +// wxSocketEvent +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent +{ public: - wxSocketEvent(int id = 0); + wxSocketEvent(int id = 0) + : wxEvent(id, wxEVT_SOCKET) + { + } - wxSocketNotify SocketEvent() const { return m_skevt; } - wxSocketBase *Socket() const { return m_socket; } + wxSocketNotify GetSocketEvent() const { return m_event; } + wxSocketBase *GetSocket() const { return (wxSocketBase *) GetEventObject(); } + void *GetClientData() const { return m_clientData; } - void CopyObject(wxObject& obj_d) const; + virtual wxEvent *Clone() const { return new wxSocketEvent(*this); } public: - wxSocketNotify m_skevt; - wxSocketBase *m_socket; + wxSocketNotify m_event; + void *m_clientData; + + DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent) }; + typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&); -#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \ - (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \ - (wxObject *) NULL }, +#define wxSocketEventHandler(func) \ + (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSocketEventFunction, &func) + +#define EVT_SOCKET(id, func) \ + wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func)) + +#endif // wxUSE_SOCKETS -#endif - // wxUSE_SOCKETS +#endif // _WX_SOCKET_H_ -#endif - // _WX_NETWORK_SOCKET_H