include/wx/socket.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        socket.h
   3 // Purpose:     Socket handling classes
   4 // Authors:     Guilhem Lavaux, Guillermo Rodriguez Garcia
   5 // Modified by:
   6 // Created:     April 1997
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Guilhem Lavaux
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_SOCKET_H_
  13 #define _WX_SOCKET_H_
  14
  15 #include "wx/defs.h"
  16
  17 #if wxUSE_SOCKETS
  18
  19 // ---------------------------------------------------------------------------
  20 // wxSocket headers
  21 // ---------------------------------------------------------------------------
  22
  23 #include "wx/event.h"
  24 #include "wx/sckaddr.h"
  25 #include "wx/gsocket.h"
  26 #include "wx/list.h"
  27
  28 // ------------------------------------------------------------------------
  29 // Types and constants
  30 // ------------------------------------------------------------------------
  31
  32 enum wxSocketNotify
  33 {
  34   wxSOCKET_INPUT = GSOCK_INPUT,
  35   wxSOCKET_OUTPUT = GSOCK_OUTPUT,
  36   wxSOCKET_CONNECTION = GSOCK_CONNECTION,
  37   wxSOCKET_LOST = GSOCK_LOST
  38 };
  39
  40 enum
  41 {
  42   wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG,
  43   wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG,
  44   wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG,
  45   wxSOCKET_LOST_FLAG = GSOCK_LOST_FLAG
  46 };
  47
  48 typedef GSocketEventFlags wxSocketEventFlags;
  49
  50 enum wxSocketError
  51 {
  52   // from GSocket
  53   wxSOCKET_NOERROR = GSOCK_NOERROR,
  54   wxSOCKET_INVOP = GSOCK_INVOP,
  55   wxSOCKET_IOERR = GSOCK_IOERR,
  56   wxSOCKET_INVADDR = GSOCK_INVADDR,
  57   wxSOCKET_INVSOCK = GSOCK_INVSOCK,
  58   wxSOCKET_NOHOST = GSOCK_NOHOST,
  59   wxSOCKET_INVPORT = GSOCK_INVPORT,
  60   wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK,
  61   wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT,
  62   wxSOCKET_MEMERR = GSOCK_MEMERR,
  63
  64   // wxSocket-specific (not yet implemented)
  65   wxSOCKET_DUMMY
  66 };
  67
  68 enum
  69 {
  70   wxSOCKET_NONE = 0,
  71   wxSOCKET_NOWAIT = 1,
  72   wxSOCKET_WAITALL = 2,
  73   wxSOCKET_BLOCK = 4,
  74   wxSOCKET_REUSEADDR = 8
  75 };
  76
  77 enum wxSocketType
  78 {
  79   wxSOCKET_UNINIT,
  80   wxSOCKET_CLIENT,
  81   wxSOCKET_SERVER,
  82   wxSOCKET_BASE,
  83   wxSOCKET_DATAGRAM
  84 };
  85
  86 typedef int wxSocketFlags;
  87
  88
  89
  90 // --------------------------------------------------------------------------
  91 // wxSocketBase
  92 // --------------------------------------------------------------------------
  93
  94 class WXDLLIMPEXP_NET wxSocketBase : public wxObject
  95 {
  96   DECLARE_CLASS(wxSocketBase)
  97
  98 public:
  99
 100   // Public interface
 101   // ----------------
 102
 103   // ctors and dtors
 104   wxSocketBase();
 105   wxSocketBase(wxSocketFlags flags, wxSocketType type);
 106   virtual ~wxSocketBase();
 107   void Init();
 108   bool Destroy();
 109
 110   // state
 111   inline bool Ok() const { return (m_socket != NULL); };
 112   inline bool Error() const { return m_error; };
 113   inline bool IsConnected() const { return m_connected; };
 114   inline bool IsData() { return WaitForRead(0, 0); };
 115   inline bool IsDisconnected() const { return !IsConnected(); };
 116   inline wxUint32 LastCount() const { return m_lcount; }
 117   inline wxSocketError LastError() const { return (wxSocketError)m_socket->GetError(); }
 118   void SaveState();
 119   void RestoreState();
 120
 121   // addresses
 122   virtual bool GetLocal(wxSockAddress& addr_man) const;
 123   virtual bool GetPeer(wxSockAddress& addr_man) const;
 124   virtual bool SetLocal(wxSockAddress& local);
 125
 126   // base IO
 127   virtual bool  Close();
 128   wxSocketBase& Discard();
 129   wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
 130   wxSocketBase& Read(void* buffer, wxUint32 nbytes);
 131   wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
 132   wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
 133   wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
 134   wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
 135
 136   void InterruptWait() { m_interrupt = true; };
 137   bool Wait(long seconds = -1, long milliseconds = 0);
 138   bool WaitForRead(long seconds = -1, long milliseconds = 0);
 139   bool WaitForWrite(long seconds = -1, long milliseconds = 0);
 140   bool WaitForLost(long seconds = -1, long milliseconds = 0);
 141
 142   inline wxSocketFlags GetFlags() const { return m_flags; }
 143   void SetFlags(wxSocketFlags flags);
 144   void SetTimeout(long seconds);
 145
 146   bool GetOption(int level, int optname, void *optval, int *optlen);
 147   bool SetOption(int level, int optname, const void *optval, int optlen);
 148   inline wxUint32 GetLastIOSize() const { return m_lcount; };
 149
 150   // event handling
 151   void *GetClientData() const { return m_clientData; }
 152   void SetClientData(void *data) { m_clientData = data; }
 153   void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY);
 154   void SetNotify(wxSocketEventFlags flags);
 155   void Notify(bool notify);
 156
 157   // initialize/shutdown the sockets (usually called automatically)
 158   static bool IsInitialized();
 159   static bool Initialize();
 160   static void Shutdown();
 161
 162
 163   // Implementation from now on
 164   // --------------------------
 165
 166   // do not use, should be private (called from GSocket)
 167   void OnRequest(wxSocketNotify notify);
 168
 169   // do not use, not documented nor supported
 170   inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
 171   inline wxSocketType GetType() const { return m_type; }
 172
 173 private:
 174   friend class wxSocketClient;
 175   friend class wxSocketServer;
 176   friend class wxDatagramSocket;
 177
 178   // low level IO
 179   wxUint32 _Read(void* buffer, wxUint32 nbytes);
 180   wxUint32 _Write(const void *buffer, wxUint32 nbytes);
 181   bool     _Wait(long seconds, long milliseconds, wxSocketEventFlags flags);
 182
 183   // pushback buffer
 184   void     Pushback(const void *buffer, wxUint32 size);
 185   wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
 186
 187 private:
 188   // socket
 189   GSocket      *m_socket;           // GSocket
 190   wxSocketType  m_type;             // wxSocket type
 191
 192   // state
 193   wxSocketFlags m_flags;            // wxSocket flags
 194   bool          m_connected;        // connected?
 195   bool          m_establishing;     // establishing connection?
 196   bool          m_reading;          // busy reading?
 197   bool          m_writing;          // busy writing?
 198   bool          m_error;            // did last IO call fail?
 199   wxSocketError m_lasterror;        // last error (not cleared on success)
 200   wxUint32      m_lcount;           // last IO transaction size
 201   unsigned long m_timeout;          // IO timeout value
 202   wxList        m_states;           // stack of states
 203   bool          m_interrupt;        // interrupt ongoing wait operations?
 204   bool          m_beingDeleted;     // marked for delayed deletion?
 205
 206   // pushback buffer
 207   void         *m_unread;           // pushback buffer
 208   wxUint32      m_unrd_size;        // pushback buffer size
 209   wxUint32      m_unrd_cur;         // pushback pointer (index into buffer)
 210
 211   // events
 212   int           m_id;               // socket id
 213   wxEvtHandler *m_handler;          // event handler
 214   void         *m_clientData;       // client data for events
 215   bool          m_notify;           // notify events to users?
 216   wxSocketEventFlags  m_eventmask;  // which events to notify?
 217
 218   // the initialization count, GSocket is initialized if > 0
 219   static size_t m_countInit;
 220
 221   DECLARE_NO_COPY_CLASS(wxSocketBase)
 222 };
 223
 224
 225 // --------------------------------------------------------------------------
 226 // wxSocketServer
 227 // --------------------------------------------------------------------------
 228
 229 class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
 230 {
 231   DECLARE_CLASS(wxSocketServer)
 232
 233 public:
 234   wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
 235
 236   wxSocketBase* Accept(bool wait = true);
 237   bool AcceptWith(wxSocketBase& socket, bool wait = true);
 238
 239   bool WaitForAccept(long seconds = -1, long milliseconds = 0);
 240
 241   DECLARE_NO_COPY_CLASS(wxSocketServer)
 242 };
 243
 244
 245 // --------------------------------------------------------------------------
 246 // wxSocketClient
 247 // --------------------------------------------------------------------------
 248
 249 class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
 250 {
 251   DECLARE_CLASS(wxSocketClient)
 252
 253 public:
 254   wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
 255   virtual ~wxSocketClient();
 256
 257   virtual bool Connect(wxSockAddress& addr, bool wait = true);
 258   virtual bool Connect(wxSockAddress& addr, wxSockAddress& local, bool wait = true);
 259
 260   bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
 261
 262 private:
 263   virtual bool DoConnect(wxSockAddress& addr, wxSockAddress* local, bool wait = true);
 264
 265   DECLARE_NO_COPY_CLASS(wxSocketClient)
 266 };
 267
 268
 269 // --------------------------------------------------------------------------
 270 // wxDatagramSocket
 271 // --------------------------------------------------------------------------
 272
 273 // WARNING: still in alpha stage
 274
 275 class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase
 276 {
 277   DECLARE_CLASS(wxDatagramSocket)
 278
 279 public:
 280   wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
 281
 282   wxDatagramSocket& RecvFrom( wxSockAddress& addr,
 283                               void* buf,
 284                               wxUint32 nBytes );
 285   wxDatagramSocket& SendTo( const wxSockAddress& addr,
 286                             const void* buf,
 287                             wxUint32 nBytes );
 288
 289 /* TODO:
 290   bool Connect(wxSockAddress& addr);
 291 */
 292   DECLARE_NO_COPY_CLASS(wxDatagramSocket)
 293 };
 294
 295
 296 // --------------------------------------------------------------------------
 297 // wxSocketEvent
 298 // --------------------------------------------------------------------------
 299
 300 class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
 301 {
 302 public:
 303   wxSocketEvent(int id = 0)
 304       : wxEvent(id, wxEVT_SOCKET)
 305       {
 306       }
 307
 308   wxSocketNotify  GetSocketEvent() const { return m_event; }
 309   wxSocketBase   *GetSocket() const      { return (wxSocketBase *) GetEventObject(); }
 310   void           *GetClientData() const  { return m_clientData; }
 311
 312   virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
 313
 314 public:
 315   wxSocketNotify  m_event;
 316   void           *m_clientData;
 317
 318   DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
 319 };
 320
 321
 322 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 323
 324 #define wxSocketEventHandler(func) \
 325     (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSocketEventFunction, &func)
 326
 327 #define EVT_SOCKET(id, func) \
 328     wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))
 329
 330 #endif // wxUSE_SOCKETS
 331
 332 #endif // _WX_SOCKET_H_
 333