X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/bc450ccdff0c65ac0ef7bbb76137981fcccf0fe6..f809133f9eb30d4746c71098bbc14c621b94ef0d:/include/wx/socket.h diff --git a/include/wx/socket.h b/include/wx/socket.h index 52bc77a66a..7b540329f8 100644 --- a/include/wx/socket.h +++ b/include/wx/socket.h @@ -13,7 +13,7 @@ #define _WX_NETWORK_SOCKET_H #ifdef __GNUG__ -#pragma interface "socket.h" + #pragma interface "socket.h" #endif #include "wx/defs.h" @@ -21,31 +21,33 @@ #if wxUSE_SOCKETS // --------------------------------------------------------------------------- -// wxSocket headers (generic) +// wxSocket headers // --------------------------------------------------------------------------- #ifdef WXPREC -# include "wx/wxprec.h" + #include "wx/wxprec.h" #else -# include "wx/event.h" -# include "wx/string.h" + #include "wx/event.h" + #include "wx/string.h" #endif #include "wx/sckaddr.h" #include "wx/gsocket.h" // ------------------------------------------------------------------------ -// GSocket type alias +// Types and constants // ------------------------------------------------------------------------ -typedef enum { +enum wxSocketNotify +{ wxSOCKET_INPUT = GSOCK_INPUT, wxSOCKET_OUTPUT = GSOCK_OUTPUT, wxSOCKET_CONNECTION = GSOCK_CONNECTION, wxSOCKET_LOST = GSOCK_LOST -} wxSocketNotify; +}; -enum { +enum +{ wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG, wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG, wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG, @@ -54,9 +56,11 @@ enum { typedef GSocketEventFlags wxSocketEventFlags; -typedef enum { +enum wxSocketError +{ + // from GSocket wxSOCKET_NOERROR = GSOCK_NOERROR, - wxSOCKET_INPOP = GSOCK_INVOP, + wxSOCKET_INVOP = GSOCK_INVOP, wxSOCKET_IOERR = GSOCK_IOERR, wxSOCKET_INVADDR = GSOCK_INVADDR, wxSOCKET_INVSOCK = GSOCK_INVSOCK, @@ -65,234 +69,303 @@ typedef enum { wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK, wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT, wxSOCKET_MEMERR = GSOCK_MEMERR, - wxSOCKET_BUSY -} wxSocketError; -enum { + // wxSocket-specific (not yet implemented) + wxSOCKET_DUMMY +}; + +enum +{ wxSOCKET_NONE = 0, wxSOCKET_NOWAIT = 1, wxSOCKET_WAITALL = 2, wxSOCKET_BLOCK = 4 }; -// this is ugly but necessary for backwards compatibility -#define wxSockFlags wxSocketBase::wxSockFlags +enum wxSocketType +{ + wxSOCKET_UNINIT, + wxSOCKET_CLIENT, + wxSOCKET_SERVER, + wxSOCKET_BASE, + wxSOCKET_DATAGRAM +}; -// ------------------------------------------------------------------------ -// wxSocket base -// ------------------------------------------------------------------------ +typedef int wxSocketFlags; + + +#if WXWIN_COMPATIBILITY + typedef wxSocketType wxSockType; + typedef wxSocketFlags wxSockFlags; +#endif // WXWIN_COMPATIBILITY + + +// -------------------------------------------------------------------------- +// wxSocketBase +// -------------------------------------------------------------------------- -class WXDLLEXPORT wxTimer; -class WXDLLEXPORT wxSocketEvent; -class WXDLLEXPORT wxSocketBase : public wxEvtHandler +class WXDLLEXPORT wxSocketBase : public wxObject { DECLARE_CLASS(wxSocketBase) + public: - enum { +#if WXWIN_COMPATIBILITY + enum + { NONE = wxSOCKET_NONE, NOWAIT = wxSOCKET_NOWAIT, WAITALL = wxSOCKET_WAITALL, SPEED = wxSOCKET_BLOCK }; - // Type of request - typedef int wxSockFlags; - - enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT }; - typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); - -protected: - GSocket *m_socket; // GSocket - 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? - 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 - - char *m_unread; // Pushback buffer - wxUint32 m_unrd_size; // Pushback buffer size - wxUint32 m_unrd_cur; // Pushback pointer (index into buffer) - - // Async IO variables enum { - NO_DEFER = 0, - DEFER_READ = 1, - DEFER_WRITE = 2 - } m_defering; // Defering state - char *m_defer_buffer; // Defering target buffer - wxUint32 m_defer_nbytes; // Defering buffer size - wxTimer *m_defer_timer; // Timer for defering mode - -/* - char *m_read_buffer; // Target buffer (read) - char *m_write_buffer; // Target buffer (write) - wxUint32 m_read_nbytes; // Buffer size (read) - wxUint32 m_write_nbytes; // Buffer size (write) - wxTimer *m_read_timer; // Timer (read) - wxTimer *m_write_timer; // Timer (write) -*/ + SOCK_UNINIT = wxSOCKET_UNINIT, + SOCK_CLIENT = wxSOCKET_CLIENT, + SOCK_SERVER = wxSOCKET_SERVER, + SOCK_INTERNAL = wxSOCKET_BASE, + SOCK_DATAGRAM = wxSOCKET_DATAGRAM + }; - wxSockCbk m_cbk; // C callback - char *m_cdata; // C callback data + typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata); +#endif // WXWIN_COMPATIBILITY public: + + // Public interface + // ---------------- + + // ctors and dtors wxSocketBase(); + wxSocketBase(wxSocketFlags flags, wxSocketType type); virtual ~wxSocketBase(); - virtual bool Close(); - - // Base IO - 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(); - // Status + // state 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 bool IsDisconnected() const { return !IsConnected(); }; inline wxUint32 LastCount() const { return m_lcount; } inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); } - inline wxSockType GetType() const { return m_type; } + void SaveState(); + void RestoreState(); - // Some info on the socket... - virtual bool GetPeer(wxSockAddress& addr_man) const; + // addresses virtual bool GetLocal(wxSockAddress& addr_man) const; + virtual bool GetPeer(wxSockAddress& addr_man) const; - // 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); + + void InterruptWait() { m_interrupt = TRUE; }; bool Wait(long seconds = -1, long milliseconds = 0); bool WaitForRead(long seconds = -1, long milliseconds = 0); bool WaitForWrite(long seconds = -1, long milliseconds = 0); bool WaitForLost(long seconds = -1, long milliseconds = 0); - // Save the current state of Socket - void SaveState(); - void RestoreState(); - - // Setup event handler - void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1); + inline wxSocketFlags GetFlags() const { return m_flags; } + void SetFlags(wxSocketFlags flags); + void SetTimeout(long seconds); - // 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 = -1); void SetNotify(wxSocketEventFlags flags); void Notify(bool notify); - static wxSocketEventFlags EventToNotify(wxSocketNotify evt); - inline wxSocketEventFlags NeededReq() const { return m_neededreq; } - // External callback + // initialize/shutdown the sockets (usually called automatically) + static bool IsInitialized(); + static bool Initialize(); + static void Shutdown(); + + // callbacks are deprecated, use events instead +#if WXWIN_COMPATIBILITY wxSockCbk Callback(wxSockCbk cbk_); char *CallbackData(char *data); +#endif // WXWIN_COMPATIBILITY - // Public internal callback - virtual void OldOnNotify(wxSocketNotify WXUNUSED(evt)); - - // Do NOT use this function; it should be protected! - void OnRequest(wxSocketNotify req_evt); - -protected: - friend class wxSocketServer; - friend class wxSocketClient; - friend class wxSocketHandler; - -#ifdef __SALFORDC__ -public: -#endif - - wxSocketBase(wxSockFlags flags, wxSockType type); -#ifdef __SALFORDC__ -protected: -#endif + // Implementation from now on + // -------------------------- - // Low level IO - wxUint32 _Read(char* buffer, wxUint32 nbytes); - wxUint32 _Write(const char *buffer, wxUint32 nbytes); - bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags); + // do not use, should be private (called from GSocket) + void OnRequest(wxSocketNotify notify); - wxUint32 DeferRead(char *buffer, wxUint32 nbytes); - wxUint32 DeferWrite(const char *buffer, wxUint32 nbytes); - void DoDefer(); + // do not use, not documented nor supported + inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); } + inline wxSocketType GetType() const { return m_type; } - // 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 _Read(void* buffer, wxUint32 nbytes); + wxUint32 _Write(const void *buffer, wxUint32 nbytes); + bool _Wait(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 + 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? + wxSocketError m_lasterror; // last error (not cleared on success) + 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 + 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; + + // callbacks are deprecated, use events instead +#if WXWIN_COMPATIBILITY + wxSockCbk m_cbk; // callback + char *m_cdata; // callback data +#endif // WXWIN_COMPATIBILITY }; -//////////////////////////////////////////////////////////////////////// + +// -------------------------------------------------------------------------- +// wxSocketServer +// -------------------------------------------------------------------------- class WXDLLEXPORT wxSocketServer : public wxSocketBase { DECLARE_CLASS(wxSocketServer) -public: - // 'service' can be a name or a port-number - wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE); +public: + wxSocketServer(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); wxSocketBase* Accept(bool wait = TRUE); - bool AcceptWith(wxSocketBase& sock, bool wait = TRUE); + bool AcceptWith(wxSocketBase& socket, bool wait = TRUE); bool WaitForAccept(long seconds = -1, long milliseconds = 0); }; -//////////////////////////////////////////////////////////////////////// + +// -------------------------------------------------------------------------- +// wxSocketClient +// -------------------------------------------------------------------------- class WXDLLEXPORT wxSocketClient : public wxSocketBase { DECLARE_CLASS(wxSocketClient) -public: - wxSocketClient(wxSockFlags flags = wxSocketBase::NONE); +public: + wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE); virtual ~wxSocketClient(); - virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE); + virtual bool Connect(wxSockAddress& addr, bool wait = TRUE); bool WaitOnConnect(long seconds = -1, long milliseconds = 0); }; -class WXDLLEXPORT wxSocketEvent : public wxEvent { - DECLARE_DYNAMIC_CLASS(wxSocketEvent) + +// -------------------------------------------------------------------------- +// wxDatagramSocket +// -------------------------------------------------------------------------- + +// WARNING: still in alpha stage + +class wxDatagramSocket : public wxSocketBase +{ + DECLARE_CLASS(wxDatagramSocket) + public: - wxSocketEvent(int id = 0); + wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE); - wxSocketNotify SocketEvent() const { return m_skevt; } - wxSocketBase *Socket() const { return m_socket; } + wxDatagramSocket& RecvFrom( wxSockAddress& addr, + void* buf, + wxUint32 nBytes ); + wxDatagramSocket& SendTo( wxSockAddress& addr, + const void* buf, + wxUint32 nBytes ); + +/* TODO: + bool Connect(wxSockAddress& addr); +*/ +}; - void CopyObject(wxObject& obj_d) const; +// -------------------------------------------------------------------------- +// wxSocketEvent +// -------------------------------------------------------------------------- + +class WXDLLEXPORT wxSocketEvent : public wxEvent +{ public: - wxSocketNotify m_skevt; - wxSocketBase *m_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; } + + // backwards compatibility +#if WXWIN_COMPATIBILITY_2 + wxSocketNotify SocketEvent() const { return m_event; } + wxSocketBase *Socket() const { return (wxSocketBase *) GetEventObject(); } +#endif // WXWIN_COMPATIBILITY_2 + + virtual wxEvent *Clone() const { return new wxSocketEvent(*this); } + +public: + wxSocketNotify m_event; + void *m_clientData; + + DECLARE_DYNAMIC_CLASS(wxSocketEvent) }; + typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&); -#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \ - (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \ - (wxObject *) NULL }, +#define EVT_SOCKET(id, func) \ + DECLARE_EVENT_TABLE_ENTRY( wxEVT_SOCKET, id, -1, \ + (wxObjectEventFunction) \ + (wxEventFunction) \ + (wxSocketEventFunction) & func, \ + (wxObject *) NULL ), + #endif // wxUSE_SOCKETS