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