]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/socket.h
support SDK < 10.6, fixes #14902
[wxWidgets.git] / include / wx / socket.h
index 4374b9b1d1990e8553b390c91ea507404c25f922..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:
 // Purpose:     Socket handling classes
 // Authors:     Guilhem Lavaux, Guillermo Rodriguez Garcia
 // Modified by:
@@ -9,12 +9,8 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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"
 
 
 #include "wx/defs.h"
 
 // wxSocket headers
 // ---------------------------------------------------------------------------
 
 // 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/sckaddr.h"
-#include "wx/gsocket.h"
+#include "wx/list.h"
+
+class wxSocketImpl;
 
 // ------------------------------------------------------------------------
 // Types and constants
 // ------------------------------------------------------------------------
 
 
 // ------------------------------------------------------------------------
 // Types and constants
 // ------------------------------------------------------------------------
 
+// 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
 {
 enum wxSocketNotify
 {
-  wxSOCKET_INPUT = GSOCK_INPUT,
-  wxSOCKET_OUTPUT = GSOCK_OUTPUT,
-  wxSOCKET_CONNECTION = GSOCK_CONNECTION,
-  wxSOCKET_LOST = GSOCK_LOST
+    wxSOCKET_INPUT,
+    wxSOCKET_OUTPUT,
+    wxSOCKET_CONNECTION,
+    wxSOCKET_LOST
 };
 
 enum
 {
 };
 
 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
+    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 GSocketEventFlags wxSocketEventFlags;
+// this is a combination of the bit masks defined above
+typedef int wxSocketEventFlags;
 
 enum wxSocketError
 {
 
 enum wxSocketError
 {
-  // from GSocket
-  wxSOCKET_NOERROR = GSOCK_NOERROR,
-  wxSOCKET_INVOP = 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-specific (not yet implemented)
-  wxSOCKET_DUMMY
+    wxSOCKET_NOERROR = 0,
+    wxSOCKET_INVOP,
+    wxSOCKET_IOERR,
+    wxSOCKET_INVADDR,
+    wxSOCKET_INVSOCK,
+    wxSOCKET_NOHOST,
+    wxSOCKET_INVPORT,
+    wxSOCKET_WOULDBLOCK,
+    wxSOCKET_TIMEDOUT,
+    wxSOCKET_MEMERR,
+    wxSOCKET_OPTERR
 };
 
 };
 
+// socket options/flags bit masks
 enum
 {
 enum
 {
-  wxSOCKET_NONE = 0,
-  wxSOCKET_NOWAIT = 1,
-  wxSOCKET_WAITALL = 2,
-  wxSOCKET_BLOCK = 4
+    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
 };
 
 };
 
+typedef int wxSocketFlags;
+
+// socket kind values (badly defined, don't use)
 enum wxSocketType
 {
 enum wxSocketType
 {
-  wxSOCKET_UNINIT,
-  wxSOCKET_CLIENT,
-  wxSOCKET_SERVER,
-  wxSOCKET_BASE,
-  wxSOCKET_DATAGRAM
+    wxSOCKET_UNINIT,
+    wxSOCKET_CLIENT,
+    wxSOCKET_SERVER,
+    wxSOCKET_BASE,
+    wxSOCKET_DATAGRAM
 };
 
 };
 
-typedef int wxSocketFlags;
-
-
-#if WXWIN_COMPATIBILITY
-  typedef wxSocketType wxSockType;
-  typedef wxSocketFlags wxSockFlags;
-#endif // WXWIN_COMPATIBILITY
 
 
+// event
+class WXDLLIMPEXP_FWD_NET wxSocketEvent;
+wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_NET, wxEVT_SOCKET, wxSocketEvent);
 
 // --------------------------------------------------------------------------
 // wxSocketBase
 // --------------------------------------------------------------------------
 
 
 // --------------------------------------------------------------------------
 // wxSocketBase
 // --------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSocketBase : public wxObject
+class WXDLLIMPEXP_NET wxSocketBase : public wxObject
 {
 {
-  DECLARE_CLASS(wxSocketBase)
-
-public:
-
-#if WXWIN_COMPATIBILITY
-  enum
-  {
-    NONE = wxSOCKET_NONE,
-    NOWAIT = wxSOCKET_NOWAIT,
-    WAITALL = wxSOCKET_WAITALL,
-    SPEED = wxSOCKET_BLOCK
-  };
-
-  enum
-  {
-    SOCK_UNINIT = wxSOCKET_UNINIT,
-    SOCK_CLIENT = wxSOCKET_CLIENT,
-    SOCK_SERVER = wxSOCKET_SERVER,
-    SOCK_INTERNAL = wxSOCKET_BASE,
-    SOCK_DATAGRAM = wxSOCKET_DATAGRAM
-  };
-
-  typedef void (*wxSockCbk)(wxSocketBase& sock, wxSocketNotify evt, char *cdata);
-#endif // WXWIN_COMPATIBILITY
-
 public:
 public:
-
-  // Public interface
-  // ----------------
-
-  // ctors and dtors
-  wxSocketBase();
-  wxSocketBase(wxSocketFlags flags, wxSocketType type);
-  virtual ~wxSocketBase();
-  void Init();
-  bool Destroy();
-
-  // state
-  inline bool Ok() const { return (m_socket != NULL); };
-  inline bool Error() const { return m_error; };
-  inline bool IsConnected() const { return m_connected; };
-  inline bool IsData() { return WaitForRead(0, 0); };
-  inline bool IsDisconnected() const { return !IsConnected(); };
-  inline wxUint32 LastCount() const { return m_lcount; }
-  inline wxSocketError LastError() const { return (wxSocketError)GSocket_GetError(m_socket); }
-  void SaveState();
-  void RestoreState();
-
-  // addresses
-  virtual bool GetLocal(wxSockAddress& addr_man) const;
-  virtual bool GetPeer(wxSockAddress& addr_man) const;
-
-  // base IO
-  virtual bool  Close();
-  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);
-
-  void InterruptWait() { m_interrupt = TRUE; };
-  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);
-
-  inline wxSocketFlags GetFlags() const { return m_flags; }
-  void SetFlags(wxSocketFlags flags);
-  void SetTimeout(long seconds);
-
-  // event handling
-  void *GetClientData() const { return m_clientData; }
-  void SetClientData(void *data) { m_clientData = data; }
-  void SetEventHandler(wxEvtHandler& handler, int id = -1);
-  void SetNotify(wxSocketEventFlags flags);
-  void Notify(bool notify);
-
-  // callbacks are deprecated, use events instead
-#if WXWIN_COMPATIBILITY
-  wxSockCbk Callback(wxSockCbk cbk_);
-  char *CallbackData(char *data);
-#endif // WXWIN_COMPATIBILITY
-
-
-  // Implementation from now on
-  // --------------------------
-
-  // do not use, should be private (called from GSocket)
-  void OnRequest(wxSocketNotify notify);
-
-  // do not use, not documented nor supported
-  inline bool IsNoWait() const { return ((m_flags & wxSOCKET_NOWAIT) != 0); }
-  inline wxSocketType GetType() const { return m_type; }
+    // 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:
 
 private:
-  friend class wxSocketClient;
-  friend class wxSocketServer;
-  friend class wxDatagramSocket;
-
-  // low level IO
-  wxUint32 _Read(void* buffer, wxUint32 nbytes);
-  wxUint32 _Write(const void *buffer, wxUint32 nbytes);
-  bool     _Wait(long seconds, long milliseconds, wxSocketEventFlags flags);
-
-  // pushback buffer
-  void     Pushback(const void *buffer, wxUint32 size);
-  wxUint32 GetPushback(void *buffer, wxUint32 size, bool peek);
+    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:
 
 private:
-  // socket
-  GSocket      *m_socket;           // GSocket
-  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_error;            // did last IO call fail?
-  wxSocketError m_lasterror;        // last error (not cleared on success)
-  wxUint32      m_lcount;           // last IO transaction size
-  unsigned long m_timeout;          // IO timeout value
-  wxList        m_states;           // stack of states
-  bool          m_interrupt;        // interrupt ongoing wait operations?
-  bool          m_beingDeleted;     // marked for delayed deletion?
-
-  // 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?
-
-  // callbacks are deprecated, use events instead
-#if WXWIN_COMPATIBILITY
-  wxSockCbk     m_cbk;              // callback
-  char         *m_cdata;            // callback data
-#endif // WXWIN_COMPATIBILITY
+    // 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)
 };
 
 
 };
 
 
@@ -259,17 +297,19 @@ private:
 // wxSocketServer
 // --------------------------------------------------------------------------
 
 // wxSocketServer
 // --------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSocketServer : public wxSocketBase
+class WXDLLIMPEXP_NET wxSocketServer : public wxSocketBase
 {
 {
-  DECLARE_CLASS(wxSocketServer)
-
 public:
 public:
-  wxSocketServer(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
+    wxSocketServer(const wxSockAddress& addr,
+                   wxSocketFlags flags = wxSOCKET_NONE);
 
 
-  wxSocketBase* Accept(bool wait = TRUE);
-  bool AcceptWith(wxSocketBase& socket, bool wait = TRUE);
+    wxSocketBase* Accept(bool wait = true);
+    bool AcceptWith(wxSocketBase& socket, 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)
 };
 
 
 };
 
 
@@ -277,17 +317,38 @@ public:
 // wxSocketClient
 // --------------------------------------------------------------------------
 
 // wxSocketClient
 // --------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSocketClient : public wxSocketBase
+class WXDLLIMPEXP_NET wxSocketClient : public wxSocketBase
 {
 {
-  DECLARE_CLASS(wxSocketClient)
-
 public:
 public:
-  wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
-  virtual ~wxSocketClient();
+    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);
 
 
-  virtual bool Connect(wxSockAddress& addr, bool wait = TRUE);
+    // 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;
+    }
 
 
-  bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
+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)
 };
 
 
 };
 
 
@@ -297,23 +358,26 @@ public:
 
 // WARNING: still in alpha stage
 
 
 // WARNING: still in alpha stage
 
-class wxDatagramSocket : public wxSocketBase
+class WXDLLIMPEXP_NET wxDatagramSocket : public wxSocketBase
 {
 {
-  DECLARE_CLASS(wxDatagramSocket)
-
 public:
 public:
-  wxDatagramSocket(wxSockAddress& addr, wxSocketFlags flags = wxSOCKET_NONE);
-
-  wxDatagramSocket& RecvFrom( wxSockAddress& addr,
-                              void* buf,
-                              wxUint32 nBytes );
-  wxDatagramSocket& SendTo( wxSockAddress& addr,
-                            const void* buf,
-                            wxUint32 nBytes );
-
-/* TODO:
-  bool Connect(wxSockAddress& addr);
-*/
+    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)
 };
 
 
 };
 
 
@@ -321,43 +385,39 @@ public:
 // wxSocketEvent
 // --------------------------------------------------------------------------
 
 // wxSocketEvent
 // --------------------------------------------------------------------------
 
-class WXDLLEXPORT wxSocketEvent : public wxEvent
+class WXDLLIMPEXP_NET wxSocketEvent : public wxEvent
 {
 {
-  DECLARE_DYNAMIC_CLASS(wxSocketEvent)
-
 public:
 public:
-  wxSocketEvent(int id = 0);
-
-  wxSocketNotify  GetSocketEvent() const { return m_event; }
-  wxSocketBase   *GetSocket() const      { return (wxSocketBase *) GetEventObject(); }
-  void           *GetClientData() const  { return m_clientData; }
+    wxSocketEvent(int id = 0)
+        : wxEvent(id, wxEVT_SOCKET)
+    {
+    }
 
 
-  // backwards compatibility
-#if WXWIN_COMPATIBILITY_2
-  wxSocketNotify  SocketEvent() const    { return m_event; }
-  wxSocketBase   *Socket() const         { return (wxSocketBase *) GetEventObject(); }
-#endif // WXWIN_COMPATIBILITY_2
+    wxSocketNotify GetSocketEvent() const { return m_event; }
+    wxSocketBase *GetSocket() const
+        { return (wxSocketBase *) GetEventObject(); }
+    void *GetClientData() const { return m_clientData; }
 
 
-  void CopyObject(wxObject& object_dest) const;
+    virtual wxEvent *Clone() const { return new wxSocketEvent(*this); }
+    virtual wxEventCategory GetEventCategory() const { return wxEVT_CATEGORY_SOCKET; }
 
 public:
 
 public:
-  wxSocketNotify  m_event;
-  void           *m_clientData;
+    wxSocketNotify  m_event;
+    void           *m_clientData;
+
+    DECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxSocketEvent)
 };
 
 
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 
 };
 
 
 typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
 
+#define wxSocketEventHandler(func) \
+    wxEVENT_HANDLER_CAST(wxSocketEventFunction, func)
+
 #define EVT_SOCKET(id, func) \
 #define EVT_SOCKET(id, func) \
-    DECLARE_EVENT_TABLE_ENTRY( wxEVT_SOCKET, id, -1, \
-                              (wxObjectEventFunction) \
-                              (wxEventFunction) \
-                              (wxSocketEventFunction) & func, \
-                              (wxObject *) NULL ),
+    wx__DECLARE_EVT1(wxEVT_SOCKET, id, wxSocketEventHandler(func))
 
 
+#endif // wxUSE_SOCKETS
 
 
-#endif
-  // wxUSE_SOCKETS
+#endif // _WX_SOCKET_H_
 
 
-#endif
-  // _WX_NETWORK_SOCKET_H