/include/wx/socket.h
C Header | 435 lines | 246 code | 89 blank | 100 comment | 3 complexity | 46027f42d45f3b5b63547cb7a5caebe1 MD5 | raw file
Possible License(s): LGPL-3.0, AGPL-3.0, GPL-2.0, LGPL-2.0
- /////////////////////////////////////////////////////////////////////////////
- // Name: wx/socket.h
- // Purpose: Socket handling classes
- // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia
- // Modified by:
- // Created: April 1997
- // Copyright: (c) Guilhem Lavaux
- // Licence: wxWindows licence
- /////////////////////////////////////////////////////////////////////////////
- #ifndef _WX_SOCKET_H_
- #define _WX_SOCKET_H_
- #include "wx/defs.h"
- #if wxUSE_SOCKETS
- // ---------------------------------------------------------------------------
- // wxSocket headers
- // ---------------------------------------------------------------------------
- #include "wx/event.h"
- #include "wx/sckaddr.h"
- #include "wx/list.h"
- class wxSocketImpl;
- // ------------------------------------------------------------------------
- // Types and constants
- // ------------------------------------------------------------------------
- // Define the type of native sockets.
- #if defined(__WINDOWS__)
- // Although socket descriptors are still 32 bit values, even under Win64,
- // the socket type is 64 bit there.
- typedef wxUIntPtr wxSOCKET_T;
- #else
- typedef int wxSOCKET_T;
- #endif
- // 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
- };
- 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
- };
- // this is a combination of the bit masks defined above
- typedef int wxSocketEventFlags;
- 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
- };
- // socket options/flags bit masks
- enum
- {
- 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
- };
- // event
- class WXDLLIMPEXP_FWD_NET wxSocketEvent;
- wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent);
- // --------------------------------------------------------------------------
- // wxSocketBase
- // --------------------------------------------------------------------------
- class WXDLLIMPEXP_NET wxSocketBase : public wxObject
- {
- 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_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);
- // Get the underlying socket descriptor.
- wxSOCKET_T GetSocket() const;
- // 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
- 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)
- };
- // --------------------------------------------------------------------------
- // wxSocketServer
- // --------------------------------------------------------------------------
- class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
- {
- public:
- wxSocketServer(const wxSockAddress& addr,
- wxSocketFlags flags = wxSOCKET_NONE);
- wxSocketBase* Accept(bool wait = true);
- bool AcceptWith(wxSocketBase& socket, bool wait = true);
- bool WaitForAccept(long seconds = -1, long milliseconds = 0);
- wxDECLARE_NO_COPY_CLASS(wxSocketServer);
- DECLARE_CLASS(wxSocketServer)
- };
- // --------------------------------------------------------------------------
- // wxSocketClient
- // --------------------------------------------------------------------------
- class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
- {
- 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)
- };
- // --------------------------------------------------------------------------
- // wxDatagramSocket
- // --------------------------------------------------------------------------
- // WARNING: still in alpha stage
- 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)
- };
- // --------------------------------------------------------------------------
- // wxSocketEvent
- // --------------------------------------------------------------------------
- class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
- {
- public:
- 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; }
- virtual wxEvent *Clone() const wxOVERRIDE { return new wxSocketEvent(*this); }
- virtual wxEventCategory GetEventCategory() const wxOVERRIDE { return wxEVT_CATEGORY_SOCKET; }
- public:
- wxSocketNotify m_event;
- void *m_clientData;
- DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
- };
- typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
- #define wxSocketEventHandler(func) \
- wxEVENT_HANDLER_CAST(wxSocketEventFunction, func)
- #define EVT_SOCKET(id, func) \
- wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))
- #endif // wxUSE_SOCKETS
- #endif // _WX_SOCKET_H_