]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/socket.h
fixing overrelease and out-of-bounds write, fixes #13725
[wxWidgets.git] / include / wx / socket.h
index d069f2904f73f64493dcd00f616bfb4b9ab9b0b8..93b39325da264f0a3775170df780a1fd95e6e77c 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        socket.h
+// Name:        wx/socket.h
 // Purpose:     Socket handling classes
 // Authors:     Guilhem Lavaux, Guillermo Rodriguez Garcia
 // Modified by:
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifndef _WX_NETWORK_SOCKET_H
-#define _WX_NETWORK_SOCKET_H
-
-#ifdef __GNUG__
-#pragma interface "socket.h"
-#endif
+#ifndef _WX_SOCKET_H_
+#define _WX_SOCKET_H_
 
 #include "wx/defs.h"
 
 #if wxUSE_SOCKETS
 
 // ---------------------------------------------------------------------------
-// wxSocket headers (generic)
+// wxSocket headers
 // ---------------------------------------------------------------------------
 
-#ifdef WXPREC
-#  include "wx/wxprec.h"
-#else
-#  include "wx/event.h"
-#  include "wx/string.h"
-#endif
-
+#include "wx/event.h"
 #include "wx/sckaddr.h"
-#include "wx/gsocket.h"
+#include "wx/list.h"
+
+class wxSocketImpl;
 
 // ------------------------------------------------------------------------
-// GSocket type alias
+// Types and constants
 // ------------------------------------------------------------------------
 
-typedef enum {
-  wxSOCKET_INPUT = GSOCK_INPUT,
-  wxSOCKET_OUTPUT = GSOCK_OUTPUT,
-  wxSOCKET_CONNECTION = GSOCK_CONNECTION,
-  wxSOCKET_LOST = GSOCK_LOST
-} wxSocketNotify;
-
-enum {
-  wxSOCKET_INPUT_FLAG = GSOCK_INPUT_FLAG,
-  wxSOCKET_OUTPUT_FLAG = GSOCK_OUTPUT_FLAG,
-  wxSOCKET_CONNECTION_FLAG = GSOCK_CONNECTION_FLAG,
-  wxSOCKET_LOST_FLAG = GSOCK_LOST_FLAG
+// 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
 };
 
-typedef GSocketEventFlags wxSocketEventFlags;
-
-typedef enum {
-  wxSOCKET_NOERROR = GSOCK_NOERROR,
-  wxSOCKET_INPOP = GSOCK_INVOP,
-  wxSOCKET_IOERR = GSOCK_IOERR,
-  wxSOCKET_INVADDR = GSOCK_INVADDR,
-  wxSOCKET_INVSOCK = GSOCK_INVSOCK,
-  wxSOCKET_NOHOST = GSOCK_NOHOST,
-  wxSOCKET_INVPORT = GSOCK_INVPORT,
-  wxSOCKET_WOULDBLOCK = GSOCK_WOULDBLOCK,
-  wxSOCKET_TIMEDOUT = GSOCK_TIMEDOUT,
-  wxSOCKET_MEMERR = GSOCK_MEMERR,
-  wxSOCKET_BUSY
-} wxSocketError;
-
-enum {
-  wxSOCKET_NONE = 0,
-  wxSOCKET_NOWAIT = 1,
-  wxSOCKET_WAITALL = 2,
-  wxSOCKET_BLOCK = 4
+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
 };
 
-typedef int wxSockFlags;
-
-// ------------------------------------------------------------------------
-// wxSocket base
-// ------------------------------------------------------------------------
+// this is a combination of the bit masks defined above
+typedef int wxSocketEventFlags;
 
-class WXDLLEXPORT wxTimer;
-class WXDLLEXPORT wxSocketEvent;
-class WXDLLEXPORT wxSocketBase : public wxEvtHandler
+enum wxSocketError
 {
-  DECLARE_CLASS(wxSocketBase)
-public:
+    wxSOCKET_NOERROR = 0,
+    wxSOCKET_INVOP,
+    wxSOCKET_IOERR,
+    wxSOCKET_INVADDR,
+    wxSOCKET_INVSOCK,
+    wxSOCKET_NOHOST,
+    wxSOCKET_INVPORT,
+    wxSOCKET_WOULDBLOCK,
+    wxSOCKET_TIMEDOUT,
+    wxSOCKET_MEMERR,
+    wxSOCKET_OPTERR
+};
 
-  enum {
-    NONE = wxSOCKET_NONE,
-    NOWAIT = wxSOCKET_NOWAIT,
-    WAITALL = wxSOCKET_WAITALL,
-    SPEED = wxSOCKET_BLOCK
-  };
-
-  typedef ::wxSockFlags wxSockFlags;
-
-  // Type of request
-
-  enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT };
-  typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata);
-
-protected:
-  GSocket *m_socket;            // GSocket
-  int m_id;                     // Socket id (for event handler)
-
-  // Attributes
-  wxSockFlags m_flags;                 // wxSocket flags
-  wxSockType m_type;                   // wxSocket type
-  wxSocketEventFlags m_neededreq;   // Event mask
-  bool m_notify_state;          // Notify events to users?
-  bool m_connected;             // Connected ?
-  bool m_establishing;          // Establishing connection ?
-  bool m_reading;               // Busy reading?
-  bool m_writing;               // Busy writing?
-  bool m_error;                 // Did last IO call fail ?
-  wxUint32 m_lcount;            // Last IO transaction size
-  unsigned long m_timeout;             // IO timeout value
-  wxList m_states;              // Stack of states
-
-  char *m_unread;               // Pushback buffer
-  wxUint32 m_unrd_size;                        // Pushback buffer size
-  wxUint32 m_unrd_cur;          // Pushback pointer (index into buffer)
-
-  // Async IO variables
-  enum
-  {
-    NO_DEFER = 0,
-    DEFER_READ = 1,
-    DEFER_WRITE = 2
-  } m_defering;                 // Defering state
-  char *m_defer_buffer;         // Defering target buffer
-  wxUint32 m_defer_nbytes;      // Defering buffer size
-  wxTimer *m_defer_timer;       // Timer for defering mode
-
-/*
-  char *m_read_buffer;          // Target buffer (read)
-  char *m_write_buffer;         // Target buffer (write)
-  wxUint32 m_read_nbytes;       // Buffer size (read)
-  wxUint32 m_write_nbytes;      // Buffer size (write)
-  wxTimer *m_read_timer;        // Timer (read)
-  wxTimer *m_write_timer;       // Timer (write)
-*/
-
-  wxSockCbk m_cbk;              // C callback
-  char *m_cdata;                // C callback data
+// 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
+};
 
-public:
-  wxSocketBase();
-  virtual ~wxSocketBase();
-  virtual bool Close();
-
-  // Base IO
-  wxSocketBase& Peek(char* buffer, wxUint32 nbytes);
-  wxSocketBase& Read(char* buffer, wxUint32 nbytes);
-  wxSocketBase& Write(const char *buffer, wxUint32 nbytes);
-  wxSocketBase& Unread(const char *buffer, wxUint32 nbytes);
-  wxSocketBase& ReadMsg(char *buffer, wxUint32 nbytes);
-  wxSocketBase& WriteMsg(const char *buffer, wxUint32 nbytes);
-  wxSocketBase& Discard();
-
-  // Status
-  inline bool Ok() const { return (m_socket != NULL); };
-  inline bool Error() const { return m_error; };
-  inline bool IsConnected() const { return m_connected; };
-  inline bool IsDisconnected() const { return !IsConnected(); };
-  inline bool IsNoWait() const { return ((m_flags & NOWAIT) != 0); };
-  inline bool IsData() { return WaitForRead(0, 0); };
-  inline wxUint32 LastCount() const { return m_lcount; }
-  inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); }
-  inline wxSockType GetType() const { return m_type; }
-
-  // Some info on the socket...
-  virtual bool GetPeer(wxSockAddress& addr_man) const;
-  virtual bool GetLocal(wxSockAddress& addr_man) const;
-
-  // Set attributes and flags
-  void SetTimeout(long seconds);
-  void SetFlags(wxSockFlags flags);
-  inline wxSockFlags GetFlags() const { return m_flags; };
-
-  // Wait functions
-  //   seconds = -1 means default timeout (change with SetTimeout)
-  //   seconds, milliseconds = 0 means no wait
-  //   seconds, milliseconds > 0 means specified wait
-  bool Wait(long seconds = -1, long milliseconds = 0);
-  bool WaitForRead(long seconds = -1, long milliseconds = 0);
-  bool WaitForWrite(long seconds = -1, long milliseconds = 0);
-  bool WaitForLost(long seconds = -1, long milliseconds = 0);
-
-  // Save the current state of Socket
-  void SaveState();
-  void RestoreState();
-
-  // Setup event handler
-  void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1);
-
-  // Tell wxSocket which events to notify
-  void SetNotify(wxSocketEventFlags flags);
-  void Notify(bool notify);
-  static wxSocketEventFlags EventToNotify(wxSocketNotify evt);
-  inline wxSocketEventFlags NeededReq() const { return m_neededreq; }
-
-  // External callback
-  wxSockCbk Callback(wxSockCbk cbk_);
-  char *CallbackData(char *data);
-
-  // Public internal callback
-  virtual void OldOnNotify(wxSocketNotify WXUNUSED(evt));
-
-  // Do NOT use this function; it should be protected!
-  void OnRequest(wxSocketNotify req_evt);
-
-protected:
-  friend class wxSocketServer;
-  friend class wxSocketClient;
-  friend class wxSocketHandler;
-
-#ifdef __SALFORDC__
-public:
-#endif
+typedef int wxSocketFlags;
 
-  wxSocketBase(wxSockFlags flags, wxSockType type);
+// socket kind values (badly defined, don't use)
+enum wxSocketType
+{
+    wxSOCKET_UNINIT,
+    wxSOCKET_CLIENT,
+    wxSOCKET_SERVER,
+    wxSOCKET_BASE,
+    wxSOCKET_DATAGRAM
+};
 
-#ifdef __SALFORDC__
-protected:
-#endif
 
-  // Low level IO
-  wxUint32 _Read(char* buffer, wxUint32 nbytes);
-  wxUint32 _Write(const char *buffer, wxUint32 nbytes);
-  bool _Wait(long seconds, long milliseconds, wxSocketEventFlags flags);
+// event
+class WXDLLIMPEXP_FWD_NET wxSocketEvent;
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent);
 
-  wxUint32 DeferRead(char *buffer, wxUint32 nbytes);
-  wxUint32 DeferWrite(const char *buffer, wxUint32 nbytes);
-  void DoDefer();
+// --------------------------------------------------------------------------
+// wxSocketBase
+// --------------------------------------------------------------------------
 
-  // Pushbacks
-  void Pushback(const char *buffer, wxUint32 size);
-  wxUint32 GetPushback(char *buffer, wxUint32 size, bool peek);
+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);
+
+    // 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)
 };
 
-////////////////////////////////////////////////////////////////////////
 
-class WXDLLEXPORT wxSocketServer : public wxSocketBase
+// --------------------------------------------------------------------------
+// wxSocketServer
+// --------------------------------------------------------------------------
+
+class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
 {
-  DECLARE_CLASS(wxSocketServer)
 public:
-  // 'service' can be a name or a port-number
+    wxSocketServer(const wxSockAddress& addr,
+                   wxSocketFlags flags = wxSOCKET_NONE);
 
-  wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE);
+    wxSocketBase* Accept(bool wait = true);
+    bool AcceptWith(wxSocketBase& socket, bool wait = true);
 
-  wxSocketBase* Accept(bool wait = TRUE);
-  bool AcceptWith(wxSocketBase& sock, bool wait = TRUE);
+    bool WaitForAccept(long seconds = -1, long milliseconds = 0);
 
-  bool WaitForAccept(long seconds = -1, long milliseconds = 0);
+    wxDECLARE_NO_COPY_CLASS(wxSocketServer);
+    DECLARE_CLASS(wxSocketServer)
 };
 
-////////////////////////////////////////////////////////////////////////
 
-class WXDLLEXPORT wxSocketClient : public wxSocketBase
+// --------------------------------------------------------------------------
+// wxSocketClient
+// --------------------------------------------------------------------------
+
+class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
 {
-  DECLARE_CLASS(wxSocketClient)
 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)
+};
+
 
-  wxSocketClient(wxSockFlags flags = wxSocketBase::NONE);
-  virtual ~wxSocketClient();
+// --------------------------------------------------------------------------
+// wxDatagramSocket
+// --------------------------------------------------------------------------
 
-  virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE);
+// WARNING: still in alpha stage
 
-  bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
+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)
 };
 
-class WXDLLEXPORT wxSocketEvent : public wxEvent {
-  DECLARE_DYNAMIC_CLASS(wxSocketEvent)
+
+// --------------------------------------------------------------------------
+// wxSocketEvent
+// --------------------------------------------------------------------------
+
+class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
+{
 public:
-  wxSocketEvent(int id = 0);
+    wxSocketEvent(int id = 0)
+        : wxEvent(id, wxEVT_SOCKET)
+    {
+    }
 
-  wxSocketNotify SocketEvent() const { return m_skevt; }
-  wxSocketBase *Socket() const { return m_socket; }
+    wxSocketNotify GetSocketEvent() const { return m_event; }
+    wxSocketBase *GetSocket() const
+        { return (wxSocketBase *) GetEventObject(); }
+    void *GetClientData() const { return m_clientData; }
 
-  void CopyObject(wxObject& obj_d) const;
+    virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
+    virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_SOCKET; }
 
 public:
-  wxSocketNotify m_skevt;
-  wxSocketBase *m_socket;
+    wxSocketNotify  m_event;
+    void           *m_clientData;
+
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
 };
 
+
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 
-#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \
-  (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
-  (wxObject *) NULL  },
+#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
-  // wxUSE_SOCKETS
+#endif // _WX_SOCKET_H_
 
-#endif
-  // _WX_NETWORK_SOCKET_H