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/private/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   wxSOCKET_BROADCAST = 16,
  76   wxSOCKET_NOBIND = 32
  77 };
  78
  79 enum wxSocketType
  80 {
  81   wxSOCKET_UNINIT,
  82   wxSOCKET_CLIENT,
  83   wxSOCKET_SERVER,
  84   wxSOCKET_BASE,
  85   wxSOCKET_DATAGRAM
  86 };
  87
  88 typedef int wxSocketFlags;
  89
  90
  91
  92 // --------------------------------------------------------------------------
  93 // wxSocketBase
  94 // --------------------------------------------------------------------------
  95
  96 class WXDLLIMPEXP_NET wxSocketBase : public wxObject
  97 {
  98   DECLARE_CLASS(wxSocketBase)
  99
 100 public:
 101
 102   // Public interface
 103   // ----------------
 104
 105   // ctors and dtors
 106   wxSocketBase();
 107   wxSocketBase(wxSocketFlags flags, wxSocketType type);
 108   virtual ~wxSocketBase();
 109   void Init();
 110   bool Destroy();
 111
 112   // state
 113   bool Ok() const { return IsOk(); }
 114   bool IsOk() const { return (m_socket != NULL); }
 115   bool Error() const { return m_error; }
 116   bool IsClosed() const { return m_closed; }
 117   bool IsConnected() const { return m_connected; }
 118   bool IsData() { return WaitForRead(0, 0); }
 119   bool IsDisconnected() const { return !IsConnected(); }
 120   wxUint32 LastCount() const { return m_lcount; }
 121   wxSocketError LastError() const { return (wxSocketError)m_socket->GetError(); }
 122   void SaveState();
 123   void RestoreState();
 124
 125   // addresses
 126   virtual bool GetLocal(wxSockAddress& addr_man) const;
 127   virtual bool GetPeer(wxSockAddress& addr_man) const;
 128   virtual bool SetLocal(const wxIPV4address& local);
 129
 130   // base IO
 131   virtual bool  Close();
 132   wxSocketBase& Discard();
 133   wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
 134   wxSocketBase& Read(void* buffer, wxUint32 nbytes);
 135   wxSocketBase& ReadMsg(void *buffer, wxUint32 nbytes);
 136   wxSocketBase& Unread(const void *buffer, wxUint32 nbytes);
 137   wxSocketBase& Write(const void *buffer, wxUint32 nbytes);
 138   wxSocketBase& WriteMsg(const void *buffer, wxUint32 nbytes);
 139
 140   // all Wait() functions wait until their condition is satisfied or the
 141   // timeout expires; if seconds == -1 (default) then m_timeout value is used
 142   //
 143   // it is also possible to call InterruptWait() to cancel any current Wait()
 144
 145   // wait for anything at all to happen with this socket
 146   bool Wait(long seconds = -1, long milliseconds = 0);
 147
 148   // wait until we can read from or write to the socket without blocking
 149   // (notice that this does not mean that the operation will succeed but only
 150   // that it will return immediately)
 151   bool WaitForRead(long seconds = -1, long milliseconds = 0);
 152   bool WaitForWrite(long seconds = -1, long milliseconds = 0);
 153
 154   // wait until the connection is terminated
 155   bool WaitForLost(long seconds = -1, long milliseconds = 0);
 156
 157   void InterruptWait() { m_interrupt = true; }
 158
 159
 160   wxSocketFlags GetFlags() const { return m_flags; }
 161   void SetFlags(wxSocketFlags flags);
 162   void SetTimeout(long seconds);
 163   long GetTimeout() const { return m_timeout; }
 164
 165   bool GetOption(int level, int optname, void *optval, int *optlen);
 166   bool SetOption(int level, int optname, const void *optval, int optlen);
 167   wxUint32 GetLastIOSize() const { return m_lcount; }
 168
 169   // event handling
 170   void *GetClientData() const { return m_clientData; }
 171   void SetClientData(void *data) { m_clientData = data; }
 172   void SetEventHandler(wxEvtHandler& handler, int id = wxID_ANY);
 173   void SetNotify(wxSocketEventFlags flags);
 174   void Notify(bool notify);
 175
 176   // initialize/shutdown the sockets (usually called automatically)
 177   static bool IsInitialized();
 178   static bool Initialize();
 179   static void Shutdown();
 180
 181
 182   // Implementation from now on
 183   // --------------------------
 184
 185   // do not use, should be private (called from GSocket)
 186   void OnRequest(wxSocketNotify notify);
 187
 188   // do not use, not documented nor supported
 189   bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
 190   wxSocketType GetType() const { return m_type; }
 191
 192 private:
 193   friend class wxSocketClient;
 194   friend class wxSocketServer;
 195   friend class wxDatagramSocket;
 196
 197   // low level IO
 198   wxUint32 DoRead(void* buffer, wxUint32 nbytes);
 199   wxUint32 DoWrite(const void *buffer, wxUint32 nbytes);
 200
 201   // wait until the given flags are set for this socket or the given timeout
 202   // (or m_timeout) expires
 203   //
 204   // notice that GSOCK_LOST_FLAG is always taken into account but the return
 205   // value depends on whether it is included in flags or not: if it is, and the
 206   // connection is indeed lost, true is returned, but if it isn't then the
 207   // function returns false in this case
 208   //
 209   // false is always returned if we returned because of the timeout expiration
 210   bool DoWait(long seconds, long milliseconds, wxSocketEventFlags flags);
 211
 212   // pushback buffer
 213   void     Pushback(const void *buffer, wxUint32 size);
 214   wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
 215
 216 private:
 217   // socket
 218   GSocket      *m_socket;           // GSocket
 219   wxSocketType  m_type;             // wxSocket type
 220
 221   // state
 222   wxSocketFlags m_flags;            // wxSocket flags
 223   bool          m_connected;        // connected?
 224   bool          m_establishing;     // establishing connection?
 225   bool          m_reading;          // busy reading?
 226   bool          m_writing;          // busy writing?
 227   bool          m_error;            // did last IO call fail?
 228   bool          m_closed;           // was the other end closed?
 229                                     // (notice that m_error is also set then)
 230   wxUint32      m_lcount;           // last IO transaction size
 231   unsigned long m_timeout;          // IO timeout value in seconds
 232   wxList        m_states;           // stack of states
 233   bool          m_interrupt;        // interrupt ongoing wait operations?
 234   bool          m_beingDeleted;     // marked for delayed deletion?
 235   wxIPV4address m_localAddress;     // bind to local address?
 236
 237   // pushback buffer
 238   void         *m_unread;           // pushback buffer
 239   wxUint32      m_unrd_size;        // pushback buffer size
 240   wxUint32      m_unrd_cur;         // pushback pointer (index into buffer)
 241
 242   // events
 243   int           m_id;               // socket id
 244   wxEvtHandler *m_handler;          // event handler
 245   void         *m_clientData;       // client data for events
 246   bool          m_notify;           // notify events to users?
 247   wxSocketEventFlags  m_eventmask;  // which events to notify?
 248
 249   // the initialization count, GSocket is initialized if > 0
 250   static size_t m_countInit;
 251
 252   DECLARE_NO_COPY_CLASS(wxSocketBase)
 253 };
 254
 255
 256 // --------------------------------------------------------------------------
 257 // wxSocketServer
 258 // --------------------------------------------------------------------------
 259
 260 class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
 261 {
 262   DECLARE_CLASS(wxSocketServer)
 263
 264 public:
 265   wxSocketServer(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
 266
 267   wxSocketBase* Accept(bool wait = true);
 268   bool AcceptWith(wxSocketBase& socket, bool wait = true);
 269
 270   bool WaitForAccept(long seconds = -1, long milliseconds = 0);
 271
 272   DECLARE_NO_COPY_CLASS(wxSocketServer)
 273 };
 274
 275
 276 // --------------------------------------------------------------------------
 277 // wxSocketClient
 278 // --------------------------------------------------------------------------
 279
 280 class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
 281 {
 282   DECLARE_CLASS(wxSocketClient)
 283
 284 public:
 285   wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
 286   virtual ~wxSocketClient();
 287
 288   virtual bool Connect(const wxSockAddress& addr, bool wait = true);
 289   bool Connect(const wxSockAddress& addr, const wxSockAddress& local,
 290                bool wait = true);
 291
 292   bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
 293
 294   // Sets initial socket buffer sizes using the SO_SNDBUF and SO_RCVBUF options
 295   // before calling connect (either one can be -1 to leave it unchanged)
 296   void SetInitialSocketBuffers(int recv, int send)
 297   {
 298       m_initialRecvBufferSize = recv;
 299       m_initialSendBufferSize = send;
 300   }
 301
 302 private:
 303   virtual bool DoConnect(const wxSockAddress& addr,
 304                          const wxSockAddress* local,
 305                          bool wait = true);
 306
 307   // buffer sizes, -1 if unset and defaults should be used
 308   int m_initialRecvBufferSize;
 309   int m_initialSendBufferSize;
 310
 311   DECLARE_NO_COPY_CLASS(wxSocketClient)
 312 };
 313
 314
 315 // --------------------------------------------------------------------------
 316 // wxDatagramSocket
 317 // --------------------------------------------------------------------------
 318
 319 // WARNING: still in alpha stage
 320
 321 class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase
 322 {
 323   DECLARE_CLASS(wxDatagramSocket)
 324
 325 public:
 326   wxDatagramSocket(const wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
 327
 328   wxDatagramSocket& RecvFrom( wxSockAddress& addr,
 329                               void* buf,
 330                               wxUint32 nBytes );
 331   wxDatagramSocket& SendTo( const wxSockAddress& addr,
 332                             const void* buf,
 333                             wxUint32 nBytes );
 334
 335 /* TODO:
 336   bool Connect(wxSockAddress& addr);
 337 */
 338   DECLARE_NO_COPY_CLASS(wxDatagramSocket)
 339 };
 340
 341
 342 // --------------------------------------------------------------------------
 343 // wxSocketEvent
 344 // --------------------------------------------------------------------------
 345
 346 class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
 347 {
 348 public:
 349   wxSocketEvent(int id = 0)
 350       : wxEvent(id, wxEVT_SOCKET)
 351       {
 352       }
 353
 354   wxSocketNotify  GetSocketEvent() const { return m_event; }
 355   wxSocketBase   *GetSocket() const      { return (wxSocketBase *) GetEventObject(); }
 356   void           *GetClientData() const  { return m_clientData; }
 357
 358   virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
 359
 360 public:
 361   wxSocketNotify  m_event;
 362   void           *m_clientData;
 363
 364   DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
 365 };
 366
 367
 368 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 369
 370 #define wxSocketEventHandler(func) \
 371     (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxSocketEventFunction, &func)
 372
 373 #define EVT_SOCKET(id, func) \
 374     wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))
 375
 376 #endif // wxUSE_SOCKETS
 377
 378 #endif // _WX_SOCKET_H_
 379