X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/17dff81c7141e142765b168ab225e5c61475669f..89b799cccff2a3cfa5d51dac5c6e9153d2fe2e82:/include/wx/socket.h?ds=sidebyside diff --git a/include/wx/socket.h b/include/wx/socket.h index 99422550b4..e978b5ca80 100644 --- a/include/wx/socket.h +++ b/include/wx/socket.h @@ -1,7 +1,7 @@ ///////////////////////////////////////////////////////////////////////////// // Name: socket.h // Purpose: Socket handling classes -// Author: Guilhem Lavaux +// Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia // Modified by: // Created: April 1997 // RCS-ID: $Id$ @@ -9,333 +9,405 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifndef _WX_NETWORK_SOCKET_H -#define _WX_NETWORK_SOCKET_H +#ifndef _WX_SOCKET_H_ +#define _WX_SOCKET_H_ -#ifdef __GNUG__ -#pragma interface "socket.h" -#endif +#include "wx/defs.h" + +#if wxUSE_SOCKETS // --------------------------------------------------------------------------- -// Windows(tm) specific +// wxSocket headers // --------------------------------------------------------------------------- -#if defined(__WINDOWS__) && defined(WXSOCK_INTERNAL) -#include -#include -struct wxSockInternal { - UINT my_msg; -}; +#include "wx/event.h" +#include "wx/sckaddr.h" +#include "wx/list.h" -struct wxSockHandlerInternal { - HWND sockWin; - UINT firstAvailableMsg; -}; -#endif // defined(__WINDOWS__) && defined(WXSOCK_INTERNAL) +class wxSocketImpl; -// --------------------------------------------------------------------------- -// Unix specific -// --------------------------------------------------------------------------- -#if defined(__UNIX__) && defined(WXSOCK_INTERNAL) -#include -#include -#include +// ------------------------------------------------------------------------ +// Types and constants +// ------------------------------------------------------------------------ -// --------------------------------------------------------------------------- -// Athena specific -// --------------------------------------------------------------------------- -#if defined(__WXXT__) || defined(__WXMOTIF__) -#include +// 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, + wxSOCKET_OUTPUT, + wxSOCKET_CONNECTION, + wxSOCKET_LOST +}; -struct wxSockInternal { - XtInputId sock_inputid, sock_outputid, sock_exceptid; +enum +{ + wxSOCKET_INPUT_FLAG = 1 << wxSOCKET_INPUT, + wxSOCKET_OUTPUT_FLAG = 1 << wxSOCKET_OUTPUT, + wxSOCKET_CONNECTION_FLAG = 1 << wxSOCKET_CONNECTION, + wxSOCKET_LOST_FLAG = 1 << wxSOCKET_LOST }; -#endif -// --------------------------------------------------------------------------- -// GTK specific -// --------------------------------------------------------------------------- -#if defined(__WXGTK__) -#include +// this is a combination of the bit masks defined above +typedef int wxSocketEventFlags; -struct wxSockInternal { - gint sock_inputid, sock_outputid, sock_exceptid; +enum wxSocketError +{ + wxSOCKET_NOERROR = 0, + wxSOCKET_INVOP, + wxSOCKET_IOERR, + wxSOCKET_INVADDR, + wxSOCKET_INVSOCK, + wxSOCKET_NOHOST, + wxSOCKET_INVPORT, + wxSOCKET_WOULDBLOCK, + wxSOCKET_TIMEDOUT, + wxSOCKET_MEMERR, + wxSOCKET_OPTERR }; -#endif -#endif // defined(__UNIX__) && defined(WXSOCK_INTERNAL) +// 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 headers (generic) -// --------------------------------------------------------------------------- -#ifdef WXPREC -#include -#else -#include -#endif -#include "wx/sckaddr.h" +typedef int wxSocketFlags; -class WXDLLEXPORT wxSocketEvent; -class WXDLLEXPORT wxSocketHandler; -class WXDLLEXPORT wxSocketBase : public wxEvtHandler +// socket kind values (badly defined, don't use) +enum wxSocketType { - DECLARE_CLASS(wxSocketBase) -#ifdef __WXMAC__ -friend void wxMacSocketOnRequestProc(void *refcon , short event) ; -#endif -public: + wxSOCKET_UNINIT, + wxSOCKET_CLIENT, + wxSOCKET_SERVER, + wxSOCKET_BASE, + wxSOCKET_DATAGRAM +}; + - enum wxSockFlags { NONE=0, NOWAIT=1, WAITALL=2, SPEED=4 }; - // Type of request - enum { REQ_READ=0x1, REQ_PEEK=0x2, REQ_WRITE=0x4, REQ_LOST=0x8, - REQ_ACCEPT=0x10, REQ_CONNECT=0x20}; - enum { EVT_READ=0, EVT_PEEK=1, EVT_WRITE=2, EVT_LOST=3, EVT_ACCEPT=4, - EVT_CONNECT=5 }; - - typedef int wxRequestNotify; - typedef int wxRequestEvent; - typedef void (*wxSockCbk)(wxSocketBase& sock,wxRequestEvent evt,char *cdata); - -protected: - wxList req_list[EVT_WRITE+1]; - - // Internal use for SaveState() and RestoreState() - class wxSockState : public wxObject { - public: - bool cbk_on; - wxSockCbk cbk; - char *cdata; - bool notif; - wxRequestNotify cbk_set; - wxSockFlags flags; - }; - typedef struct { - char sig[4]; - char len[4]; - } SockMsg; - enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT }; - - wxSockFlags m_flags; - wxSockType m_type; // wxSocket type - bool m_connected, m_connecting; // State of the socket - int m_fd; // Socket file descriptors - int m_waitflags; // Wait flags - wxList m_states; // States list - wxSockCbk m_cbk; // C callback - char *m_cdata; // C callback data - int m_id; // Socket id (for event handler) - wxSocketHandler *m_handler; // the current socket handler - wxRequestNotify m_neededreq; // Specify which requet signals we need - bool m_cbkon; - char *m_unread; // The unread buf - size_t m_unrd_size; // The size of the unread buf - bool m_processing; // To prevent some endless loop - unsigned long m_timeout; - int m_wantbuf; - size_t m_lcount; // Last IO request size - int m_error; // Last IO error - bool m_notifyme; - - struct wxSockInternal *m_internal; // System specific variables +// event +class WXDLLIMPEXP_FWD_NET wxSocketEvent; +wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent); +// -------------------------------------------------------------------------- +// wxSocketBase +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketBase : public wxObject +{ public: - wxSocketBase(); - virtual ~wxSocketBase(); - virtual bool Close(); - - // Base IO - wxSocketBase& Peek(char* buffer, size_t nbytes); - wxSocketBase& Read(char* buffer, size_t nbytes); - wxSocketBase& Write(const char *buffer, size_t nbytes); - wxSocketBase& WriteMsg(const char *buffer, size_t nbytes); - wxSocketBase& ReadMsg(char* buffer, size_t nbytes); - wxSocketBase& Unread(const char *buffer, size_t nbytes); - void Discard(); - - // Try not to use this two methods (they sould be protected) - void CreatePushbackAfter(const char *buffer, size_t size); - void CreatePushbackBefore(const char *buffer, size_t size); - - // Status - inline bool Ok() const { return (m_fd < 0 ? 0 : 1); }; - inline bool Error() const { return (m_error != 0); }; - inline bool IsConnected() const { return m_connected; }; - inline bool IsDisconnected() const { return !IsConnected(); }; - inline bool IsNoWait() const { return m_flags & NOWAIT; }; - bool IsData() const; - inline size_t LastCount() const { return m_lcount; } - inline int LastError() const { return m_error; } - - inline void SetFlags(wxSockFlags _flags); - inline void SetTimeout(unsigned long sec) { m_timeout = sec; } - - // seconds = -1 means infinite wait - // seconds = 0 means no wait - // seconds > 0 means specified wait - bool Wait(long seconds = -1, long microseconds = 0); - bool WaitForRead(long seconds = -1, long microseconds = 0); - bool WaitForWrite(long seconds = -1, long microseconds = 0); - bool WaitForLost(long seconds = -1, long microseconds = 0); - - // Save the current state of Socket - void SaveState(); - void RestoreState(); - - // Setup external callback - wxSockCbk Callback(wxSockCbk cbk_); - char *CallbackData(char *data); - - // Setup event handler - void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1); - - // Method called when it happens something on the socket - void SetNotify(wxRequestNotify flags); - virtual void OnRequest(wxRequestEvent req_evt); - - // Public internal callback - virtual void OldOnNotify(wxRequestEvent WXUNUSED(evt)); - - // Some info on the socket... - virtual bool GetPeer(wxSockAddress& addr_man) const; - virtual bool GetLocal(wxSockAddress& addr_man) const; - - // Install or uninstall callbacks - void Notify(bool notify); - - // So you can know what the socket driver is looking for ... - inline wxRequestNotify NeededReq() const { return m_neededreq; } - - static wxRequestNotify EventToNotify(wxRequestEvent evt); - -protected: - friend class wxSocketServer; - friend class wxSocketHandler; - - wxSocketBase(wxSockFlags flags, wxSockType type); - - bool _Wait(long seconds, long microseconds, int type); - - // Set "my" handler - inline virtual void SetHandler(wxSocketHandler *handler) - { m_handler = handler; } - - // Activate or disactivate callback - void SetupCallbacks(); - void DestroyCallbacks(); - - // Pushback library - size_t GetPushback(char *buffer, size_t size, bool peek); - - // To prevent many read or write on the same socket at the same time - // ==> cause strange things :-) - void WantSpeedBuffer(char *buffer, size_t size, wxRequestEvent req); - void WantBuffer(char *buffer, size_t size, wxRequestEvent req); - - virtual bool DoRequests(wxRequestEvent req); + // 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; } + 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; } + + // 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 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 + 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 + 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) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketServer : public wxSocketBase +// -------------------------------------------------------------------------- +// wxSocketServer +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase { - DECLARE_CLASS(wxSocketServer) public: + wxSocketServer(const wxSockAddress& addr, + wxSocketFlags flags = wxSOCKET_NONE); - // 'service' can be a name or a port-number + wxSocketBase* Accept(bool wait = true); + bool AcceptWith(wxSocketBase& socket, bool wait = true); - wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE); + bool WaitForAccept(long seconds = -1, long milliseconds = 0); - wxSocketBase* Accept(); - bool AcceptWith(wxSocketBase& sock); - virtual void OnRequest(wxRequestEvent flags); + wxDECLARE_NO_COPY_CLASS(wxSocketServer); + DECLARE_CLASS(wxSocketServer) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketClient : public wxSocketBase +// -------------------------------------------------------------------------- +// wxSocketClient +// -------------------------------------------------------------------------- + +class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase { - DECLARE_CLASS(wxSocketClient) public: + 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); + + 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; + + wxDECLARE_NO_COPY_CLASS(wxSocketClient); + DECLARE_CLASS(wxSocketClient) +}; - wxSocketClient(wxSockFlags flags = wxSocketBase::NONE); - virtual ~wxSocketClient(); - virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE); +// -------------------------------------------------------------------------- +// wxDatagramSocket +// -------------------------------------------------------------------------- - bool WaitOnConnect(long seconds = -1, long microseconds = 0); +// WARNING: still in alpha stage - virtual void OnRequest(wxRequestEvent flags); +class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase +{ +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); + */ + +private: + wxDECLARE_NO_COPY_CLASS(wxDatagramSocket); + DECLARE_CLASS(wxDatagramSocket) }; -//////////////////////////////////////////////////////////////////////// -class WXDLLEXPORT wxSocketHandler : public wxObject -{ - DECLARE_CLASS(wxSocketHandler) -protected: -#if defined(__WINDOWS__) - wxList *smsg_list; - struct wxSockHandlerInternal *internal; -#endif - wxList *socks; +// -------------------------------------------------------------------------- +// wxSocketEvent +// -------------------------------------------------------------------------- +class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent +{ public: - enum SockStatus { SOCK_NONE, SOCK_DATA, SOCK_CONNECT, SOCK_DISCONNECT, - SOCK_ERROR }; - static wxSocketHandler *master; - - wxSocketHandler(); - virtual ~wxSocketHandler(); - - void Register(wxSocketBase* sock); - void UnRegister(wxSocketBase* sock); - - unsigned long Count() const; - - // seconds = -1 means indefinite wait - // seconds = 0 means no wait - // seconds > 0 means specified wait - - int Wait(long seconds = -1, long microseconds = 0); - void YieldSock(); - - wxSocketServer *CreateServer - (wxSockAddress& addr, - wxSocketBase::wxSockFlags flags = wxSocketBase::NONE); - wxSocketClient *CreateClient - (wxSocketBase::wxSockFlags flags = wxSocketBase::NONE); - - // Create or reuse a socket handler - static wxSocketHandler& Master() { return *master; } - -#if defined(WXSOCK_INTERNAL) && defined(__WINDOWS__) - - friend LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, - UINT message, WPARAM wParam, LPARAM lParam); - - UINT NewMessage(wxSocketBase *sock); - void DestroyMessage(UINT msg); - - HWND GetHWND() const; -#endif -}; + wxSocketEvent(int id = 0) + : wxEvent(id, wxEVT_SOCKET) + { + } -class WXDLLEXPORT wxSocketEvent : public wxEvent { - DECLARE_DYNAMIC_CLASS(wxSocketEvent) -public: - wxSocketEvent(int id = 0); + 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 wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_SOCKET; } - wxSocketBase::wxRequestEvent SocketEvent() const { return m_skevt; } public: - wxSocketBase::wxRequestEvent m_skevt; + wxSocketNotify m_event; + void *m_clientData; + + DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent) }; + typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&); -#define wxEVT_SOCKET wxEVT_FIRST+301 +#define wxSocketEventHandler(func) \ + wxEVENT_HANDLER_CAST(wxSocketEventFunction, func) + +#define EVT_SOCKET(id, func) \ + wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func)) + +#endif // wxUSE_SOCKETS -#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, 0, \ - (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \ - (wxObject *) NULL }, +#endif // _WX_SOCKET_H_ -#endif