X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/60ee01727442e8b364825cd965a3e06c21f07833..ca77701441e39245dcbfce903049e76f166979e5:/include/wx/socket.h diff --git a/include/wx/socket.h b/include/wx/socket.h index f04e4b2f1e..93b39325da 100644 --- a/include/wx/socket.h +++ b/include/wx/socket.h @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: socket.h +// Name: wx/socket.h // Purpose: Socket handling classes // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia // Modified by: @@ -22,72 +22,84 @@ #include "wx/event.h" #include "wx/sckaddr.h" -#include "wx/gsocket.h" #include "wx/list.h" +class wxSocketImpl; + // ------------------------------------------------------------------------ // 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 }; 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 { - // from GSocket - wxSOCKET_NOERROR = GSOCK_NOERROR, - wxSOCKET_INVOP = 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-specific (not yet implemented) - wxSOCKET_DUMMY + 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_REUSEADDR = 8, - wxSOCKET_BROADCAST = 16, - wxSOCKET_NOBIND = 32 + wxSOCKET_NONE = 0x0000, + wxSOCKET_NOWAIT_READ = 0x0001, + wxSOCKET_NOWAIT_WRITE = 0x0002, + wxSOCKET_NOWAIT = wxSOCKET_NOWAIT_READ | wxSOCKET_NOWAIT_WRITE, + wxSOCKET_WAITALL_READ = 0x0004, + wxSOCKET_WAITALL_WRITE = 0x0008, + wxSOCKET_WAITALL = wxSOCKET_WAITALL_READ | wxSOCKET_WAITALL_WRITE, + wxSOCKET_BLOCK = 0x0010, + wxSOCKET_REUSEADDR = 0x0020, + wxSOCKET_BROADCAST = 0x0040, + wxSOCKET_NOBIND = 0x0080 }; +typedef int wxSocketFlags; + +// socket kind values (badly defined, don't use) enum wxSocketType { - wxSOCKET_UNINIT, - wxSOCKET_CLIENT, - wxSOCKET_SERVER, - wxSOCKET_BASE, - wxSOCKET_DATAGRAM + wxSOCKET_UNINIT, + wxSOCKET_CLIENT, + wxSOCKET_SERVER, + wxSOCKET_BASE, + wxSOCKET_DATAGRAM }; -typedef int wxSocketFlags; - +// event +class WXDLLIMPEXP_FWD_NET wxSocketEvent; +wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent); // -------------------------------------------------------------------------- // wxSocketBase @@ -95,160 +107,189 @@ typedef int wxSocketFlags; class WXDLLIMPEXP_NET wxSocketBase : public wxObject { - DECLARE_CLASS(wxSocketBase) - public: - - // Public interface - // ---------------- - - // ctors and dtors - wxSocketBase(); - wxSocketBase(wxSocketFlags flags, wxSocketType type); - virtual ~wxSocketBase(); - void Init(); - bool Destroy(); - - // state - bool Ok() const { return IsOk(); } - bool IsOk() const { return (m_socket != 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 { return (wxSocketError)m_socket->GetError(); } - void SaveState(); - void RestoreState(); - - // addresses - virtual bool GetLocal(wxSockAddress& addr_man) const; - virtual bool GetPeer(wxSockAddress& addr_man) const; - virtual bool SetLocal(const wxIPV4address& local); - - // 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); - - void InterruptWait() { m_interrupt = true; } - - - wxSocketFlags GetFlags() const { return m_flags; } - void SetFlags(wxSocketFlags flags); - void SetTimeout(long seconds); - - 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; } - - // 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); - - // initialize/shutdown the sockets (usually called automatically) - static bool IsInitialized(); - static bool Initialize(); - static void Shutdown(); - - - // Implementation from now on - // -------------------------- - - // do not use, should be private (called from GSocket) - void OnRequest(wxSocketNotify notify); - - // do not use, not documented nor supported - bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); } - wxSocketType GetType() const { return m_type; } + // Public interface + // ---------------- + + // ctors and dtors + wxSocketBase(); + wxSocketBase(wxSocketFlags flags, wxSocketType type); + virtual ~wxSocketBase(); + void Init(); + bool Destroy(); + + // state + bool Ok() const { return IsOk(); } + bool IsOk() const { return m_impl != NULL; } + bool Error() const { return LastError() != wxSOCKET_NOERROR; } + 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; } + wxUint32 LastReadCount() const { return m_lcount_read; } + wxUint32 LastWriteCount() const { return m_lcount_write; } + wxSocketError LastError() const; + void SaveState(); + void RestoreState(); + + // addresses + virtual bool GetLocal(wxSockAddress& addr_man) const; + virtual bool GetPeer(wxSockAddress& addr_man) const; + virtual bool SetLocal(const wxIPV4address& local); + + // base IO + virtual bool Close(); + void ShutdownOutput(); + 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); + + void InterruptWait() { m_interrupt = true; } + + + wxSocketFlags GetFlags() const { return m_flags; } + void SetFlags(wxSocketFlags flags); + virtual 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; } + wxUint32 GetLastIOReadSize() const { return m_lcount_read; } + wxUint32 GetLastIOWriteSize() const { return m_lcount_write; } + + // 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); + + // initialize/shutdown the sockets (done automatically so there is no need + // to call these functions usually) + // + // should always be called from the main thread only so one of the cases + // where they should indeed be called explicitly is when the first wxSocket + // object in the application is created in a different thread + static bool Initialize(); + static void Shutdown(); + + // check if wxSocket had been already initialized + // + // notice that this function should be only called from the main thread as + // otherwise it is inherently unsafe because Initialize/Shutdown() may be + // called concurrently with it in the main thread + static bool IsInitialized(); + + // Implementation from now on + // -------------------------- + + // do not use, should be private (called from wxSocketImpl only) + void OnRequest(wxSocketNotify notify); + + // do not use, not documented nor supported + bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); } + wxSocketType GetType() const { return m_type; } private: - friend class wxSocketClient; - friend class wxSocketServer; - friend class wxDatagramSocket; - - // low level IO - wxUint32 _Read(void* buffer, wxUint32 nbytes); - wxUint32 _Write(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 GSOCK_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); + 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 and the + // function returns -1 if the connection was lost; otherwise it returns + // true if any of the events specified by flags argument happened or false + // if the timeout expired + int DoWait(long timeout, wxSocketEventFlags flags); + + // a helper calling DoWait() using the same convention as the public + // WaitForXXX() functions use, i.e. use our timeout if seconds == -1 or the + // specified timeout otherwise + int DoWait(long seconds, long milliseconds, wxSocketEventFlags flags); + + // another helper calling DoWait() using our m_timeout + int DoWaitWithTimeout(wxSocketEventFlags flags) + { + return DoWait(m_timeout*1000, flags); + } + + // pushback buffer + void Pushback(const void *buffer, wxUint32 size); + wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek); + + // store the given error as the LastError() + void SetError(wxSocketError error); private: - // socket - GSocket *m_socket; // GSocket - 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) + // 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_closed; // was the other end closed? + wxUint32 m_lcount; // last IO transaction size + wxUint32 m_lcount_read; // last IO transaction size of Read() direction. + wxUint32 m_lcount_write; // last IO transaction size of Write() direction. + unsigned long m_timeout; // IO timeout value in seconds + // (TODO: remove, wxSocketImpl has it too) + wxList m_states; // stack of states (TODO: remove!) + 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? + wxSocketEventFlags m_eventsgot; // collects events received in OnRequest() + + + friend class wxSocketReadGuard; + friend class wxSocketWriteGuard; + + wxDECLARE_NO_COPY_CLASS(wxSocketBase); + DECLARE_CLASS(wxSocketBase) }; @@ -258,17 +299,17 @@ private: class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase { - DECLARE_CLASS(wxSocketServer) - public: - wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); + wxSocketServer(const wxSockAddress& addr, + wxSocketFlags flags = wxSOCKET_NONE); - wxSocketBase* Accept(bool wait = true); - bool AcceptWith(wxSocketBase& socket, bool wait = true); + wxSocketBase* Accept(bool wait = true); + bool AcceptWith(wxSocketBase& socket, bool wait = true); - bool WaitForAccept(long seconds = -1, long milliseconds = 0); + bool WaitForAccept(long seconds = -1, long milliseconds = 0); - DECLARE_NO_COPY_CLASS(wxSocketServer) + wxDECLARE_NO_COPY_CLASS(wxSocketServer); + DECLARE_CLASS(wxSocketServer) }; @@ -278,36 +319,36 @@ public: class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase { - DECLARE_CLASS(wxSocketClient) - public: - wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); - virtual ~wxSocketClient(); + wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); - virtual bool Connect(const wxSockAddress& addr, bool wait = true); - bool Connect(const wxSockAddress& addr, const wxSockAddress& local, - 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); + 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; - } + // 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); + 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; + // buffer sizes, -1 if unset and defaults should be used + int m_initialRecvBufferSize; + int m_initialSendBufferSize; - DECLARE_NO_COPY_CLASS(wxSocketClient) + wxDECLARE_NO_COPY_CLASS(wxSocketClient); + DECLARE_CLASS(wxSocketClient) }; @@ -319,22 +360,24 @@ private: class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase { - DECLARE_CLASS(wxDatagramSocket) - public: - wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); - - wxDatagramSocket& RecvFrom( wxSockAddress& addr, - void* buf, - wxUint32 nBytes ); - wxDatagramSocket& SendTo( const wxSockAddress& addr, - const void* buf, - wxUint32 nBytes ); - -/* TODO: - bool Connect(wxSockAddress& addr); -*/ - DECLARE_NO_COPY_CLASS(wxDatagramSocket) + wxDatagramSocket(const wxSockAddress& addr, + wxSocketFlags flags = wxSOCKET_NONE); + + wxDatagramSocket& RecvFrom(wxSockAddress& addr, + void *buf, + wxUint32 nBytes); + wxDatagramSocket& SendTo(const wxSockAddress& addr, + const void* buf, + wxUint32 nBytes); + + /* TODO: + bool Connect(wxSockAddress& addr); + */ + +private: + wxDECLARE_NO_COPY_CLASS(wxDatagramSocket); + DECLARE_CLASS(wxDatagramSocket) }; @@ -345,29 +388,31 @@ public: class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent { public: - wxSocketEvent(int id = 0) - : wxEvent(id, wxEVT_SOCKET) - { - } + wxSocketEvent(int id = 0) + : wxEvent(id, wxEVT_SOCKET) + { + } - wxSocketNotify GetSocketEvent() const { return m_event; } - wxSocketBase *GetSocket() const { return (wxSocketBase *) GetEventObject(); } - void *GetClientData() const { return m_clientData; } + wxSocketNotify GetSocketEvent() const { return m_event; } + wxSocketBase *GetSocket() const + { return (wxSocketBase *) GetEventObject(); } + void *GetClientData() const { return m_clientData; } - virtual wxEvent *Clone() const { return new wxSocketEvent(*this); } + virtual wxEvent *Clone() const { return new wxSocketEvent(*this); } + virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_SOCKET; } public: - wxSocketNotify m_event; - void *m_clientData; + wxSocketNotify m_event; + void *m_clientData; - DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent) + DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent) }; typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&); #define wxSocketEventHandler(func) \ - (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSocketEventFunction, &func) + wxEVENT_HANDLER_CAST(wxSocketEventFunction, func) #define EVT_SOCKET(id, func) \ wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))