include/wx/socket.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        socket.h
   3 // Purpose:     Socket handling classes
   4 // Author:      Guilhem Lavaux
   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 #ifdef __GNUG__
  16 #pragma interface "socket.h"
  17 #endif
  18
  19 // ---------------------------------------------------------------------------
  20 // Windows(tm) specific
  21 // ---------------------------------------------------------------------------
  22 #if defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
  23 #include <winsock.h>
  24 #include <wx/msw/private.h>
  25
  26 struct wxSockInternal {
  27   UINT my_msg;
  28 };
  29
  30 struct wxSockHandlerInternal {
  31   HWND sockWin;
  32   UINT firstAvailableMsg;
  33 };
  34 #endif // defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
  35
  36 // ---------------------------------------------------------------------------
  37 // Unix specific
  38 // ---------------------------------------------------------------------------
  39 #if defined(__UNIX__) && defined(WXSOCK_INTERNAL)
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <netinet/in.h>
  43
  44 // ---------------------------------------------------------------------------
  45 // Athena specific
  46 // ---------------------------------------------------------------------------
  47 #if defined(__WXXT__) || defined(__WXMOTIF__)
  48 #include <X11/Intrinsic.h>
  49
  50 struct wxSockInternal {
  51   XtInputId sock_inputid, sock_outputid, sock_exceptid;
  52 };
  53 #endif
  54
  55 // ---------------------------------------------------------------------------
  56 // GTK specific
  57 // ---------------------------------------------------------------------------
  58 #if defined(__WXGTK__)
  59 #include <gdk/gdk.h>
  60
  61 struct wxSockInternal {
  62   gint sock_inputid, sock_outputid, sock_exceptid;
  63 };
  64 #endif
  65
  66 #endif // defined(__UNIX__) && defined(WXSOCK_INTERNAL)
  67
  68 // ---------------------------------------------------------------------------
  69 // wxSocket headers (generic)
  70 // ---------------------------------------------------------------------------
  71 #ifdef WXPREC
  72 #include <wx/wxprec.h>
  73 #else
  74 #include <wx/wx.h>
  75 #endif
  76 #include "wx/sckaddr.h"
  77
  78 class WXDLLEXPORT wxSocketEvent;
  79 class WXDLLEXPORT wxSocketHandler;
  80 class WXDLLEXPORT wxSocketBase : public wxEvtHandler
  81 {
  82   DECLARE_CLASS(wxSocketBase)
  83 #ifdef __WXMAC__
  84 friend void wxMacSocketOnRequestProc(void *refcon , short event) ;
  85 #endif
  86 public:
  87
  88   enum wxSockFlags { NONE=0, NOWAIT=1, WAITALL=2, SPEED=4 };
  89   // Type of request
  90   enum { REQ_READ=0x1, REQ_PEEK=0x2, REQ_WRITE=0x4, REQ_LOST=0x8,
  91          REQ_ACCEPT=0x10, REQ_CONNECT=0x20};
  92   enum { EVT_READ=0, EVT_PEEK=1, EVT_WRITE=2, EVT_LOST=3, EVT_ACCEPT=4,
  93          EVT_CONNECT=5 };
  94
  95   typedef int wxRequestNotify;
  96   typedef int wxRequestEvent;
  97   typedef void (*wxSockCbk)(wxSocketBase& sock,wxRequestEvent evt,char *cdata);
  98
  99 protected:
 100   wxList req_list[EVT_WRITE+1];
 101
 102   // Internal use for SaveState() and RestoreState()
 103   class wxSockState : public wxObject {
 104   public:
 105     bool cbk_on;
 106     wxSockCbk cbk;
 107     char *cdata;
 108     bool notif;
 109     wxRequestNotify cbk_set;
 110     wxSockFlags flags;
 111   };
 112   typedef struct {
 113     char sig[4];
 114     char len[4];
 115   } SockMsg;
 116   enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT };
 117
 118   wxSockFlags m_flags;
 119   wxSockType m_type;                    // wxSocket type
 120   bool m_connected, m_connecting;       // State of the socket
 121   int m_fd;                             // Socket file descriptors
 122   int m_waitflags;                      // Wait flags
 123   wxList m_states;                      // States list
 124   wxSockCbk m_cbk;                      // C callback
 125   char *m_cdata;                        // C callback data
 126   int m_id;                             // Socket id (for event handler)
 127   wxSocketHandler *m_handler;           // the current socket handler
 128   wxRequestNotify m_neededreq;          // Specify which requet signals we need
 129   bool m_cbkon;
 130   char *m_unread;                       // The unread buf
 131   size_t m_unrd_size;                   // The size of the unread buf
 132   bool m_processing;                    // To prevent some endless loop
 133   unsigned long m_timeout;
 134   int m_wantbuf;
 135   size_t m_lcount;                      // Last IO request size
 136   int m_error;                          // Last IO error
 137   bool m_notifyme;
 138
 139   struct wxSockInternal *m_internal;    // System specific variables
 140
 141 public:
 142   wxSocketBase();
 143   virtual ~wxSocketBase();
 144   virtual bool Close();
 145
 146   // Base IO
 147   wxSocketBase& Peek(char* buffer, size_t nbytes);
 148   wxSocketBase& Read(char* buffer, size_t nbytes);
 149   wxSocketBase& Write(const char *buffer, size_t nbytes);
 150   wxSocketBase& WriteMsg(const char *buffer, size_t nbytes);
 151   wxSocketBase& ReadMsg(char* buffer, size_t nbytes);
 152   wxSocketBase& Unread(const char *buffer, size_t nbytes);
 153   void Discard();
 154
 155   // Try not to use this two methods (they sould be protected)
 156   void CreatePushbackAfter(const char *buffer, size_t size);
 157   void CreatePushbackBefore(const char *buffer, size_t size);
 158
 159   // Status
 160   inline bool Ok() const { return (m_fd < 0 ? 0 : 1); };
 161   inline bool Error() const { return (m_error != 0); };
 162   inline bool IsConnected() const { return m_connected; };
 163   inline bool IsDisconnected() const { return !IsConnected(); };
 164   inline bool IsNoWait() const { return m_flags & NOWAIT; };
 165   bool IsData() const;
 166   inline size_t LastCount() const { return m_lcount; }
 167   inline int LastError() const { return m_error; }
 168
 169   inline void SetFlags(wxSockFlags _flags);
 170   inline void SetTimeout(unsigned long sec) { m_timeout = sec; }
 171
 172   // seconds = -1 means infinite wait
 173   // seconds = 0 means no wait
 174   // seconds > 0 means specified wait
 175   bool Wait(long seconds = -1, long microseconds = 0);
 176   bool WaitForRead(long seconds = -1, long microseconds = 0);
 177   bool WaitForWrite(long seconds = -1, long microseconds = 0);
 178   bool WaitForLost(long seconds = -1, long microseconds = 0);
 179
 180   // Save the current state of Socket
 181   void SaveState();
 182   void RestoreState();
 183
 184   // Setup external callback
 185   wxSockCbk Callback(wxSockCbk cbk_);
 186   char *CallbackData(char *data);
 187
 188   // Setup event handler
 189   void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1);
 190
 191   // Method called when it happens something on the socket
 192   void SetNotify(wxRequestNotify flags);
 193   virtual void OnRequest(wxRequestEvent req_evt);
 194
 195   // Public internal callback
 196   virtual void OldOnNotify(wxRequestEvent WXUNUSED(evt));
 197
 198   // Some info on the socket...
 199   virtual bool GetPeer(wxSockAddress& addr_man) const;
 200   virtual bool GetLocal(wxSockAddress& addr_man) const;
 201
 202   // Install or uninstall callbacks
 203   void Notify(bool notify);
 204
 205   // So you can know what the socket driver is looking for ...
 206   inline wxRequestNotify NeededReq() const { return m_neededreq; }
 207
 208   static wxRequestNotify EventToNotify(wxRequestEvent evt);
 209
 210 protected:
 211   friend class wxSocketServer;
 212   friend class wxSocketHandler;
 213
 214   wxSocketBase(wxSockFlags flags, wxSockType type);
 215
 216   bool _Wait(long seconds, long microseconds, int type);
 217
 218   // Set "my" handler
 219   inline virtual void SetHandler(wxSocketHandler *handler)
 220          { m_handler = handler; }
 221
 222   // Activate or disactivate callback
 223   void SetupCallbacks();
 224   void DestroyCallbacks();
 225
 226   // Pushback library
 227   size_t GetPushback(char *buffer, size_t size, bool peek);
 228
 229   // To prevent many read or write on the same socket at the same time
 230   //   ==> cause strange things :-)
 231   void WantSpeedBuffer(char *buffer, size_t size, wxRequestEvent req);
 232   void WantBuffer(char *buffer, size_t size, wxRequestEvent req);
 233
 234   virtual bool DoRequests(wxRequestEvent req);
 235 };
 236
 237 ////////////////////////////////////////////////////////////////////////
 238
 239 class WXDLLEXPORT wxSocketServer : public wxSocketBase
 240 {
 241   DECLARE_CLASS(wxSocketServer)
 242 public:
 243
 244   // 'service' can be a name or a port-number
 245
 246   wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE);
 247
 248   wxSocketBase* Accept();
 249   bool AcceptWith(wxSocketBase& sock);
 250   virtual void OnRequest(wxRequestEvent flags);
 251 };
 252
 253 ////////////////////////////////////////////////////////////////////////
 254
 255 class WXDLLEXPORT wxSocketClient : public wxSocketBase
 256 {
 257   DECLARE_CLASS(wxSocketClient)
 258 public:
 259
 260   wxSocketClient(wxSockFlags flags = wxSocketBase::NONE);
 261   virtual ~wxSocketClient();
 262
 263   virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE);
 264
 265   bool WaitOnConnect(long seconds = -1, long microseconds = 0);
 266
 267   virtual void OnRequest(wxRequestEvent flags);
 268 };
 269
 270 ////////////////////////////////////////////////////////////////////////
 271
 272 class WXDLLEXPORT wxSocketHandler : public wxObject
 273 {
 274   DECLARE_CLASS(wxSocketHandler)
 275 protected:
 276 #if defined(__WINDOWS__)
 277   wxList *smsg_list;
 278   struct wxSockHandlerInternal *internal;
 279 #endif
 280   wxList *socks;
 281
 282 public:
 283   enum SockStatus { SOCK_NONE, SOCK_DATA, SOCK_CONNECT, SOCK_DISCONNECT,
 284                     SOCK_ERROR };
 285   static wxSocketHandler *master;
 286
 287   wxSocketHandler();
 288   virtual ~wxSocketHandler();
 289
 290   void Register(wxSocketBase* sock);
 291   void UnRegister(wxSocketBase* sock);
 292
 293   unsigned long Count() const;
 294
 295   // seconds = -1 means indefinite wait
 296   // seconds = 0 means no wait
 297   // seconds > 0 means specified wait
 298
 299   int Wait(long seconds = -1, long microseconds = 0);
 300   void YieldSock();
 301
 302   wxSocketServer *CreateServer
 303                        (wxSockAddress& addr,
 304                         wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
 305   wxSocketClient *CreateClient
 306                        (wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
 307
 308   // Create or reuse a socket handler
 309   static wxSocketHandler& Master() { return *master; }
 310
 311 #if defined(WXSOCK_INTERNAL) && defined(__WINDOWS__)
 312
 313   friend LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd,
 314                         UINT message, WPARAM wParam, LPARAM lParam);
 315
 316   UINT NewMessage(wxSocketBase *sock);
 317   void DestroyMessage(UINT msg);
 318
 319   HWND GetHWND() const;
 320 #endif
 321 };
 322
 323 class WXDLLEXPORT wxSocketEvent : public wxEvent {
 324   DECLARE_DYNAMIC_CLASS(wxSocketEvent)
 325 public:
 326   wxSocketEvent(int id = 0);
 327
 328   wxSocketBase::wxRequestEvent SocketEvent() const { return m_skevt; }
 329 public:
 330   wxSocketBase::wxRequestEvent m_skevt;
 331 };
 332
 333 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 334
 335 #define wxEVT_SOCKET wxEVT_FIRST+301
 336
 337 #define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, 0, \
 338   (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
 339   (wxObject *) NULL  },
 340
 341 #endif