interface/wx/socket.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        socket.h
   3 // Purpose:     interface of wxIP*address, wxSocket* classes
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9
  10 /**
  11     @class wxIPaddress
  12
  13     wxIPaddress is an abstract base class for all internet protocol address
  14     objects. Currently, only wxIPV4address is implemented. An experimental
  15     implementation for IPV6, wxIPV6address, is being developed.
  16
  17     @library{wxnet}
  18     @category{net}
  19 */
  20 class wxIPaddress : public wxSockAddress
  21 {
  22 public:
  23     /**
  24         Internally, this is the same as setting the IP address to @b INADDR_ANY.
  25
  26         On IPV4 implementations, 0.0.0.0
  27
  28         On IPV6 implementations, ::
  29
  30         @return @true on success, @false if something went wrong.
  31     */
  32     bool AnyAddress();
  33
  34     /**
  35         Internally, this is the same as setting the IP address to @b INADDR_BROADCAST.
  36
  37         On IPV4 implementations, 255.255.255.255
  38
  39         @return @true on success, @false if something went wrong.
  40     */
  41     virtual bool BroadcastAddress() = 0;
  42
  43     /**
  44         Set the address to hostname, which can be a host name or an IP-style address
  45         in a format dependent on implementation.
  46
  47         @return @true on success, @false if something goes wrong (invalid
  48                 hostname or invalid IP address).
  49     */
  50     bool Hostname(const wxString& hostname);
  51
  52     /**
  53         Returns the hostname which matches the IP address.
  54     */
  55     wxString Hostname() const;
  56
  57     /**
  58         Returns a wxString containing the IP address.
  59     */
  60     virtual wxString IPAddress() const = 0;
  61
  62     /**
  63         Determines if current address is set to localhost.
  64
  65         @return @true if address is localhost, @false if internet address.
  66     */
  67     virtual bool IsLocalHost() const = 0;
  68
  69     /**
  70         Set address to localhost.
  71
  72         On IPV4 implementations, 127.0.0.1
  73
  74         On IPV6 implementations, ::1
  75
  76         @return @true on success, @false if something went wrong.
  77     */
  78     bool LocalHost();
  79
  80     /**
  81         Set the port to that corresponding to the specified service.
  82
  83         @return @true on success, @false if something goes wrong (invalid @a service).
  84     */
  85     bool Service(const wxString& service);
  86
  87     /**
  88         Set the port to that corresponding to the specified service.
  89
  90         @return @true on success, @false if something goes wrong (invalid @a service).
  91     */
  92     bool Service(unsigned short service);
  93
  94     /**
  95         Returns the current service.
  96     */
  97     unsigned short Service() const;
  98 };
  99
 100
 101 /**
 102     @class wxIPV4address
 103
 104     A class for working with IPv4 network addresses.
 105
 106     @library{wxnet}
 107     @category{net}
 108 */
 109 class wxIPV4address : public wxIPaddress
 110 {
 111 public:
 112     /**
 113         Set address to any of the addresses of the current machine.
 114
 115         Whenever possible, use this function instead of LocalHost(),
 116         as this correctly handles multi-homed hosts and avoids other small
 117         problems. Internally, this is the same as setting the IP address
 118         to @b INADDR_ANY.
 119
 120         @return @true on success, @false if something went wrong.
 121     */
 122     bool AnyAddress();
 123
 124     /**
 125         Set the address to hostname, which can be a host name or an IP-style address
 126         in dot notation(<tt>a.b.c.d</tt>).
 127
 128         @return @true on success, @false if something goes wrong (invalid
 129                 hostname or invalid IP address).
 130     */
 131     bool Hostname(const wxString& hostname);
 132
 133     /**
 134         Returns the hostname which matches the IP address.
 135     */
 136     virtual wxString Hostname() const;
 137
 138     /**
 139         Returns a wxString containing the IP address in dot quad (127.0.0.1) format.
 140     */
 141     virtual wxString IPAddress() const;
 142
 143     /**
 144         Set address to localhost (127.0.0.1).
 145
 146         Whenever possible, use AnyAddress() instead of this one, as that one will
 147         correctly handle multi-homed hosts and avoid other small problems.
 148
 149         @return @true on success, @false if something went wrong.
 150     */
 151     bool LocalHost();
 152
 153     /**
 154         Set the port to that corresponding to the specified @a service.
 155
 156         @return @true on success, @false if something goes wrong (invalid @a service).
 157     */
 158     bool Service(const wxString& service);
 159
 160     /**
 161         Set the port to that corresponding to the specified @a service.
 162
 163         @return @true on success, @false if something goes wrong (invalid @a service).
 164     */
 165     bool Service(unsigned short service);
 166
 167     /**
 168         Returns the current service.
 169     */
 170     unsigned short Service() const;
 171 };
 172
 173
 174
 175 /**
 176     @class wxSocketServer
 177
 178     @todo describe me.
 179
 180     @library{wxnet}
 181     @category{net}
 182 */
 183 class wxSocketServer : public wxSocketBase
 184 {
 185 public:
 186     /**
 187         Constructs a new server and tries to bind to the specified @e address.
 188
 189         Before trying to accept new connections, remember to test whether it succeeded
 190         with wxSocketBase:IsOk().
 191
 192         @param address
 193             Specifies the local address for the server (e.g. port number).
 194         @param flags
 195             Socket flags (See wxSocketBase::SetFlags()).
 196     */
 197     wxSocketServer(const wxSockAddress& address,
 198                    wxSocketFlags flags = wxSOCKET_NONE);
 199
 200     /**
 201         Destructor (it doesn't close the accepted connections).
 202     */
 203     virtual ~wxSocketServer();
 204
 205     /**
 206         Accepts an incoming connection request, and creates a new wxSocketBase
 207         object which represents the server-side of the connection.
 208
 209         If @a wait is @true and there are no pending connections to be
 210         accepted, it will wait for the next incoming connection to
 211         arrive.
 212
 213         @warning This method will block the GUI.
 214
 215         If @a wait is @false, it will try to accept a pending connection
 216         if there is one, but it will always return immediately without blocking
 217         the GUI. If you want to use Accept() in this way, you can either check for
 218         incoming connections with WaitForAccept() or catch @b wxSOCKET_CONNECTION events,
 219         then call Accept() once you know that there is an incoming connection waiting
 220         to be accepted.
 221
 222         @return Returns an opened socket connection, or @NULL if an error
 223                 occurred or if the wait parameter was @false and there
 224                 were no pending connections.
 225
 226         @see WaitForAccept(), wxSocketBase::SetNotify(),
 227              wxSocketBase::Notify(), AcceptWith()
 228     */
 229     wxSocketBase* Accept(bool wait = true);
 230
 231     /**
 232         Accept an incoming connection using the specified socket object.
 233
 234         @param socket
 235             Socket to be initialized
 236         @param wait
 237             See Accept() for more info.
 238
 239         @return Returns @true on success, or @false if an error occurred or
 240                 if the wait parameter was @false and there were no pending
 241                 connections.
 242
 243         @see WaitForAccept(), wxSocketBase::SetNotify(),
 244              wxSocketBase::Notify(), Accept()
 245     */
 246     bool AcceptWith(wxSocketBase& socket, bool wait = true);
 247
 248     /**
 249         Wait for an incoming connection.
 250
 251         Use it if you want to call Accept() or AcceptWith() with @e wait set
 252         to @false, to detect when an incoming connection is waiting to be accepted.
 253
 254         @param seconds
 255             Number of seconds to wait. If -1, it will wait for the default
 256             timeout, as set with wxSocketBase::SetTimeout().
 257         @param millisecond
 258             Number of milliseconds to wait.
 259
 260         @return @true if an incoming connection arrived, @false if the timeout
 261                 elapsed.
 262
 263         @see Accept(), AcceptWith(), wxSocketBase::InterruptWait()
 264     */
 265     bool WaitForAccept(long seconds = -1, long millisecond = 0);
 266 };
 267
 268
 269 /**
 270     @class wxSocketClient
 271
 272     @todo describe me.
 273
 274     @library{wxnet}
 275     @category{net}
 276 */
 277 class wxSocketClient : public wxSocketBase
 278 {
 279 public:
 280     /**
 281         Constructor.
 282
 283         @param flags
 284             Socket flags (See wxSocketBase::SetFlags())
 285     */
 286     wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE);
 287
 288     /**
 289         Destructor. Please see wxSocketBase::Destroy().
 290     */
 291     virtual ~wxSocketClient();
 292
 293     /**
 294         Connects to a server using the specified address.
 295
 296         If @a wait is @true, Connect() will wait until the connection
 297         completes.
 298
 299         @warning This method will block the GUI.
 300
 301         If @a wait is @false, Connect() will try to establish the connection
 302         and return immediately, without blocking the GUI. When used this way,
 303         even if Connect() returns @false, the connection request can be
 304         completed later. To detect this, use WaitOnConnect(), or catch
 305         @b wxSOCKET_CONNECTION events (for successful establishment) and
 306         @b wxSOCKET_LOST events (for connection failure).
 307
 308         @param address
 309             Address of the server.
 310         @param wait
 311             If @true, waits for the connection to complete.
 312
 313         @return @true if the connection is established and no error occurs.
 314                 If @a wait was true, and Connect() returns @false, an error
 315                 occurred and the connection failed.
 316                 If @a wait was @false, and Connect() returns @false, you should
 317                 still be prepared to handle the completion of this connection request,
 318                 either with WaitOnConnect() or by watching wxSOCKET_CONNECTION
 319                 and wxSOCKET_LOST events.
 320
 321         @see WaitOnConnect(), wxSocketBase::SetNotify(), wxSocketBase::Notify()
 322     */
 323     virtual bool Connect(const wxSockAddress& address, bool wait = true);
 324
 325     /**
 326         Connects to a server using the specified address.
 327
 328         If @a wait is @true, Connect() will wait until the connection
 329         completes. @b Warning: This will block the GUI.
 330
 331         If @a wait is @false, Connect() will try to establish the connection
 332         and return immediately, without blocking the GUI. When used this way,
 333         even if Connect() returns @false, the connection request can be
 334         completed later. To detect this, use WaitOnConnect(), or catch
 335         @b wxSOCKET_CONNECTION events (for successful establishment) and
 336         @b wxSOCKET_LOST events (for connection failure).
 337
 338         @param address
 339             Address of the server.
 340         @param local
 341             Bind to the specified local address and port before connecting.
 342             The local address and port can also be set using SetLocal(),
 343             and then using the 2-parameter Connect() method.
 344         @param wait
 345             If @true, waits for the connection to complete.
 346
 347         @return @true if the connection is established and no error occurs.
 348                 If @a wait was true, and Connect() returns @false, an error
 349                 occurred and the connection failed.
 350                 If @a wait was @false, and Connect() returns @false, you should
 351                 still be prepared to handle the completion of this connection request,
 352                 either with WaitOnConnect() or by watching wxSOCKET_CONNECTION
 353                 and wxSOCKET_LOST events.
 354
 355         @see WaitOnConnect(), wxSocketBase::SetNotify(), wxSocketBase::Notify()
 356     */
 357     bool Connect(const wxSockAddress& address, const wxSockAddress& local,
 358                  bool wait = true);
 359
 360     /**
 361         Wait until a connection request completes, or until the specified timeout
 362         elapses. Use this function after issuing a call to Connect() with
 363         @e wait set to @false.
 364
 365         @param seconds
 366             Number of seconds to wait.
 367             If -1, it will wait for the default timeout, as set with wxSocketBase::SetTimeout().
 368         @param milliseconds
 369             Number of milliseconds to wait.
 370
 371         @return
 372             WaitOnConnect() returns @true if the connection request completes.
 373             This does not necessarily mean that the connection was
 374             successfully established; it might also happen that the
 375             connection was refused by the peer. Use wxSocketBase::IsConnected()
 376             to distinguish between these two situations.
 377             @n @n If the timeout elapses, WaitOnConnect() returns @false.
 378             @n @n These semantics allow code like this:
 379             @code
 380             // Issue the connection request
 381             client->Connect(addr, false);
 382
 383             // Wait until the request completes or until we decide to give up
 384             bool waitmore = true;
 385             while ( !client->WaitOnConnect(seconds, millis) && waitmore )
 386             {
 387                 // possibly give some feedback to the user,
 388                 // and update waitmore as needed.
 389             }
 390             bool success = client->IsConnected();
 391             @endcode
 392     */
 393     bool WaitOnConnect(long seconds = -1, long milliseconds = 0);
 394 };
 395
 396
 397
 398 /**
 399     @class wxSockAddress
 400
 401     You are unlikely to need to use this class: only wxSocketBase uses it.
 402
 403     @library{wxnet}
 404     @category{net}
 405
 406     @see wxSocketBase, wxIPaddress, wxIPV4address
 407 */
 408 class wxSockAddress : public wxObject
 409 {
 410 public:
 411     /**
 412         Default constructor.
 413     */
 414     wxSockAddress();
 415
 416     /**
 417         Default destructor.
 418     */
 419     virtual ~wxSockAddress();
 420
 421     /**
 422         Delete all informations about the address.
 423     */
 424     virtual void Clear();
 425
 426     /**
 427         Returns the length of the socket address.
 428     */
 429     int SockAddrLen();
 430
 431     /**
 432         Returns the pointer to the low-level representation of the address.
 433
 434         This can be used to pass socket address information to a 3rd party
 435         library.
 436
 437         @return
 438             Pointer to a sockaddr-derived struct.
 439     */
 440     const sockaddr *GetAddressData() const;
 441
 442     /**
 443         Returns the length of the buffer retrieved by GetAddressData().
 444
 445         @return
 446             The size of the sockaddr-derived struct corresponding to this
 447             address.
 448     */
 449     int GetAddressDataLen() const;
 450 };
 451
 452
 453
 454 /**
 455     @class wxSocketEvent
 456
 457     This event class contains information about socket events.
 458     This kind of events are sent to the event handler specified with
 459     wxSocketBase::SetEventHandler.
 460
 461     @beginEventTable{wxSocketEvent}
 462     @event{EVT_SOCKET(id, func)}
 463         Process a socket event, supplying the member function.
 464     @endEventTable
 465
 466     @library{wxnet}
 467     @category{net}
 468
 469     @see wxSocketBase, wxSocketClient, wxSocketServer
 470 */
 471 class wxSocketEvent : public wxEvent
 472 {
 473 public:
 474     /**
 475         Constructor.
 476     */
 477     wxSocketEvent(int id = 0);
 478
 479     /**
 480         Gets the client data of the socket which generated this event, as
 481         set with wxSocketBase::SetClientData().
 482     */
 483     void* GetClientData() const;
 484
 485     /**
 486         Returns the socket object to which this event refers to.
 487         This makes it possible to use the same event handler for different sockets.
 488     */
 489     wxSocketBase* GetSocket() const;
 490
 491     /**
 492         Returns the socket event type.
 493     */
 494     wxSocketNotify GetSocketEvent() const;
 495 };
 496
 497
 498 /**
 499     wxSocket error return values.
 500 */
 501 enum wxSocketError
 502 {
 503     wxSOCKET_NOERROR,       ///< No error happened.
 504     wxSOCKET_INVOP,         ///< Invalid operation.
 505     wxSOCKET_IOERR,         ///< Input/Output error.
 506     wxSOCKET_INVADDR,       ///< Invalid address passed to wxSocket.
 507     wxSOCKET_INVSOCK,       ///< Invalid socket (uninitialized).
 508     wxSOCKET_NOHOST,        ///< No corresponding host.
 509     wxSOCKET_INVPORT,       ///< Invalid port.
 510     wxSOCKET_WOULDBLOCK,    ///< The socket is non-blocking and the operation would block.
 511     wxSOCKET_TIMEDOUT,      ///< The timeout for this operation expired.
 512     wxSOCKET_MEMERR         ///< Memory exhausted.
 513 };
 514
 515
 516 /**
 517     @anchor wxSocketEventFlags
 518
 519     wxSocket Event Flags.
 520
 521     A brief note on how to use these events:
 522
 523     The @b wxSOCKET_INPUT event will be issued whenever there is data available
 524     for reading. This will be the case if the input queue was empty and new data
 525     arrives, or if the application has read some data yet there is still more data
 526     available. This means that the application does not need to read all available
 527     data in response to a @b wxSOCKET_INPUT event, as more events will be produced
 528     as necessary.
 529
 530     The @b wxSOCKET_OUTPUT event is issued when a socket is first connected with
 531     Connect() or accepted with Accept(). After that, new events will be generated
 532     only after an output operation fails with @b wxSOCKET_WOULDBLOCK and buffer space
 533     becomes available again. This means that the application should assume that it can
 534     write data to the socket until an @b wxSOCKET_WOULDBLOCK error occurs; after this,
 535     whenever the socket becomes writable again the application will be notified with
 536     another @b wxSOCKET_OUTPUT event.
 537
 538     The @b wxSOCKET_CONNECTION event is issued when a delayed connection request completes
 539     successfully (client) or when a new connection arrives at the incoming queue (server).
 540
 541     The @b wxSOCKET_LOST event is issued when a close indication is received for the socket.
 542     This means that the connection broke down or that it was closed by the peer. Also, this
 543     event will be issued if a connection request fails.
 544 */
 545 enum wxSocketEventFlags
 546 {
 547     wxSOCKET_INPUT,         ///< There is data available for reading.
 548     wxSOCKET_OUTPUT,        ///< The socket is ready to be written to.
 549     wxSOCKET_CONNECTION,    ///< Incoming connection request (server), or
 550                             ///< successful connection establishment (client).
 551     wxSOCKET_LOST           ///< The connection has been closed.
 552 };
 553
 554
 555 /**
 556     @anchor wxSocketFlags
 557
 558     wxSocket Flags.
 559
 560     A brief overview on how to use these flags follows.
 561
 562     If no flag is specified (this is the same as @b wxSOCKET_NONE),
 563     IO calls will return after some data has been read or written, even
 564     when the transfer might not be complete. This is the same as issuing
 565     exactly one blocking low-level call to @b recv() or @b send(). Note
 566     that @e blocking here refers to when the function returns, not
 567     to whether the GUI blocks during this time.
 568
 569     If @b wxSOCKET_NOWAIT is specified, IO calls will return immediately.
 570     Read operations will retrieve only available data. Write operations will
 571     write as much data as possible, depending on how much space is available
 572     in the output buffer. This is the same as issuing exactly one nonblocking
 573     low-level call to @b recv() or @b send(). Note that @e nonblocking here
 574     refers to when the function returns, not to whether the GUI blocks during
 575     this time.  Also note that this flag impacts both Read and Write
 576     operations.  If it is desired to control Read independently of Write, for
 577     example you want no wait on Read(), but you do want to wait on Write(), then
 578     use wxSOCKET_NOWAIT_READ and wxSOCKET_NOWAIT_WRITE.
 579
 580     If @b wxSOCKET_NOWAIT_READ (this flag is new since wxWidgets 2.9.5) is
 581     specified, Read operations will return immediately. Read operations will
 582     retrieve only available data. This is the same as issuing exactly one
 583     nonblocking low-level call to @b recv(). Note that @e nonblocking here
 584     refers to when the function returns, not to whether the GUI blocks during
 585     this time.  This flag should not be enabled if ReadMsg() is going to be
 586     used (it will be ignored), if you do then thread-safety may be at risk.
 587     Note that wxSOCKET_NOWAIT_READ impacts only Read operations and does not
 588     impact Write operations, allowing Read and Write operations to be set
 589     differently.
 590
 591     If @b wxSOCKET_NOWAIT_WRITE (this flag is new since wxWidgets 2.9.5) is
 592     specified, Write operations will return immediately. Write operations will
 593     write as much data as possible, depending on how much space is available in
 594     the output buffer. This is the same as issuing exactly one nonblocking
 595     low-level call to @b send(). Note that @e nonblocking here refers to when
 596     the function returns, not to whether the GUI blocks during this time.  This
 597     flag should not be enabled if WriteMsg() is going to be used (it will be
 598     ignored), if you use it then thread safety may be at risk. Note that
 599     wxSOCKET_NOWAIT_WRITE impacts only Write operations and does not impact
 600     Write operations, allowing Read and Write operations to be set differently.
 601
 602     If @b wxSOCKET_WAITALL is specified, IO calls won't return until ALL
 603     the data has been read or written (or until an error occurs), blocking if
 604     necessary, and issuing several low level calls if necessary. This is the
 605     same as having a loop which makes as many blocking low-level calls to
 606     @b recv() or @b send() as needed so as to transfer all the data. Note
 607     that @e blocking here refers to when the function returns, not
 608     to whether the GUI blocks during this time.  Note that wxSOCKET_WAITALL
 609     impacts both Read and Write operations.  If you desire to wait
 610     for all on just Read operations, but not on Write operations, (or vice versa),
 611     use wxSOCKET_WAITALL_READ or wxSOCKET_WAITALL_WRITE.
 612
 613     If @b wxSOCKET_WAITALL_READ (this flag is new since wxWidgets 2.9.5) is
 614     specified, Read operations won't return until ALL the data has been read
 615     (or until an error occurs), blocking if necessary, and issuing several low
 616     level calls if necessary. This is the same as having a loop which makes as
 617     many blocking low-level calls to @b recv() as needed so as to transfer all
 618     the data. Note that @e blocking here refers to when the function returns,
 619     not to whether the GUI blocks during this time.  Note that
 620     wxSOCKET_WAITALL_READ only has an impact on Read operations, and has no
 621     impact on Write operations, allowing Read and Write operations to have
 622     different settings.
 623
 624     If @b wxSOCKET_WAITALL_WRITE (this flag is new since wxWidgets 2.9.5) is
 625     specified, Write() and WriteMsg() calls won't return until ALL the data has
 626     been written (or until an error occurs), blocking if necessary, and issuing
 627     several low level calls if necessary. This is the same as having a loop
 628     which makes as many blocking low-level calls to @b send() as needed so as
 629     to transfer all the data. Note that @e blocking here refers to when the
 630     function returns, not to whether the GUI blocks during this time.  Note
 631     that wxSOCKET_WAITALL_WRITE only has an impact on Write operations, and has
 632     no impact on Read operations, allowing Read and Write operations to have
 633     different settings.
 634
 635     The @b wxSOCKET_BLOCK flag controls whether the GUI blocks during
 636     IO operations. If this flag is specified, the socket will not yield
 637     during IO calls, so the GUI will remain blocked until the operation
 638     completes. If it is not used, then the application must take extra
 639     care to avoid unwanted reentrance.
 640
 641     The @b wxSOCKET_REUSEADDR flag controls the use of the @b SO_REUSEADDR standard
 642     @b setsockopt() flag. This flag allows the socket to bind to a port that is
 643     already in use. This is mostly used on UNIX-based systems to allow rapid starting
 644     and stopping of a server, otherwise you may have to wait several minutes for the
 645     port to become available.
 646
 647     @b wxSOCKET_REUSEADDR can also be used with socket clients to (re)bind to a
 648     particular local port for an outgoing connection.
 649     This option can have surprising platform dependent behaviour, so check the
 650     documentation for your platform's implementation of setsockopt().
 651
 652     Note that on BSD-based systems(e.g. Mac OS X), use of
 653     @b wxSOCKET_REUSEADDR implies @b SO_REUSEPORT in addition to
 654     @b SO_REUSEADDR to be consistent with Windows.
 655
 656     The @b wxSOCKET_BROADCAST flag controls the use of the @b SO_BROADCAST standard
 657     @b setsockopt() flag. This flag allows the socket to use the broadcast address,
 658     and is generally used in conjunction with @b wxSOCKET_NOBIND and
 659     wxIPaddress::BroadcastAddress().
 660
 661     So:
 662     - @b wxSOCKET_NONE will try to read at least SOME data, no matter how much.
 663     - @b wxSOCKET_NOWAIT will always return immediately, even if it cannot
 664       read or write ANY data.
 665     - @b wxSOCKET_WAITALL will only return when it has read or written ALL
 666       the data.
 667     - @b wxSOCKET_BLOCK has nothing to do with the previous flags and
 668       it controls whether the GUI blocks.
 669     - @b wxSOCKET_REUSEADDR controls special platform-specific behaviour for
 670       reusing local addresses/ports.
 671 */
 672 enum
 673 {
 674     wxSOCKET_NONE = 0,      ///< Normal functionality.
 675     wxSOCKET_NOWAIT = 1,    ///< Read/write as much data as possible and return immediately.
 676     wxSOCKET_WAITALL = 2,   ///< Wait for all required data to be read/written unless an error occurs.
 677     wxSOCKET_BLOCK = 4,     ///< Block the GUI (do not yield) while reading/writing data.
 678     wxSOCKET_REUSEADDR = 8, ///< Allows the use of an in-use port.
 679     wxSOCKET_BROADCAST = 16, ///< Switches the socket to broadcast mode
 680     wxSOCKET_NOBIND = 32,   ///< Stops the socket from being bound to a specific
 681                             ///< adapter (normally used in conjunction with
 682                             ///< @b wxSOCKET_BROADCAST)
 683     wxSOCKET_NOWAIT_READ = 64,    ///< Read as much data as possible and return immediately
 684     wxSOCKET_WAITALL_READ = 128,  ///< Wait for all required data to be read unless an error occurs.
 685     wxSOCKET_NOWAIT_WRITE = 256,   ///< Write as much data as possible and return immediately
 686     wxSOCKET_WAITALL_WRITE = 512   ///< Wait for all required data to be written unless an error occurs.
 687 };
 688
 689
 690 /**
 691     @class wxSocketBase
 692
 693     wxSocketBase is the base class for all socket-related objects, and it
 694     defines all basic IO functionality.
 695
 696     @note
 697     When using wxSocket from multiple threads, even implicitly (e.g. by using
 698     wxFTP or wxHTTP in another thread) you must initialize the sockets from the
 699     main thread by calling Initialize() before creating the other ones.
 700
 701     @beginEventEmissionTable{wxSocketEvent}
 702     @event{EVT_SOCKET(id, func)}
 703         Process a @c wxEVT_SOCKET event.
 704         See @ref wxSocketEventFlags and @ref wxSocketFlags for more info.
 705     @endEventTable
 706
 707     @library{wxnet}
 708     @category{net}
 709
 710     @see wxSocketEvent, wxSocketClient, wxSocketServer, @sample{sockets},
 711          @ref wxSocketFlags, ::wxSocketEventFlags, ::wxSocketError
 712 */
 713 class wxSocketBase : public wxObject
 714 {
 715 public:
 716
 717     /**
 718         @name Construction and Destruction
 719     */
 720     //@{
 721
 722     /**
 723         Default constructor.
 724
 725         Don't use it directly; instead, use wxSocketClient to construct a socket client,
 726         or wxSocketServer to construct a socket server.
 727     */
 728     wxSocketBase();
 729
 730     /**
 731         Destructor.
 732
 733         Do not destroy a socket using the delete operator directly;
 734         use Destroy() instead. Also, do not create socket objects in the stack.
 735     */
 736     virtual ~wxSocketBase();
 737
 738     /**
 739         Destroys the socket safely.
 740
 741         Use this function instead of the delete operator, since otherwise socket events
 742         could reach the application even after the socket has been destroyed. To prevent
 743         this problem, this function appends the wxSocket to a list of object to be deleted
 744         on idle time, after all events have been processed. For the same reason, you should
 745         avoid creating socket objects in the stack.
 746
 747         Destroy() calls Close() automatically.
 748
 749         @return Always @true.
 750     */
 751     bool Destroy();
 752
 753     /**
 754         Perform the initialization needed in order to use the sockets.
 755
 756         This function is called from wxSocket constructor implicitly and so
 757         normally doesn't need to be called explicitly. There is however one
 758         important exception: as this function must be called from the main
 759         (UI) thread, if you use wxSocket from multiple threads you must call
 760         Initialize() from the main thread before creating wxSocket objects in
 761         the other ones.
 762
 763         It is safe to call this function multiple times (only the first call
 764         does anything) but you must call Shutdown() exactly once for every call
 765         to Initialize().
 766
 767         This function should only be called from the main thread.
 768
 769         @return
 770             @true if the sockets can be used, @false if the initialization
 771             failed and sockets are not available at all.
 772      */
 773     static bool Initialize();
 774
 775     /**
 776         Shut down the sockets.
 777
 778         This function undoes the call to Initialize() and must be called after
 779         every successful call to Initialize().
 780
 781         This function should only be called from the main thread, just as
 782         Initialize().
 783      */
 784     static void Shutdown();
 785
 786     //@}
 787
 788
 789     /**
 790         @name Socket State
 791     */
 792     //@{
 793
 794     /**
 795         Returns @true if an error occurred in the last IO operation.
 796
 797         Use this function to check for an error condition after one of the
 798         following calls: Discard(), Peek(), Read(), ReadMsg(), Unread(), Write(), WriteMsg().
 799     */
 800     bool Error() const;
 801
 802     /**
 803         Return the local address of the socket.
 804
 805         @return @true if no error happened, @false otherwise.
 806     */
 807     virtual bool GetLocal(wxSockAddress& addr) const;
 808
 809     /**
 810         Return the peer address field of the socket.
 811
 812         @return @true if no error happened, @false otherwise.
 813     */
 814     virtual bool GetPeer(wxSockAddress& addr) const;
 815
 816     /**
 817         Return the socket timeout in seconds.
 818
 819         The timeout can be set using SetTimeout() and is 10 minutes by default.
 820      */
 821     long GetTimeout() const;
 822
 823     /**
 824         Returns @true if the socket is connected.
 825     */
 826     bool IsConnected() const;
 827
 828     /**
 829         Check if the socket can be currently read or written.
 830
 831         This might mean that queued data is available for reading or, for streamed
 832         sockets, that the connection has been closed, so that a read operation will
 833         complete immediately without blocking (unless the @b wxSOCKET_WAITALL flag
 834         is set, in which case the operation might still block).
 835     */
 836     bool IsData();
 837
 838     /**
 839         Returns @true if the socket is not connected.
 840     */
 841     bool IsDisconnected() const;
 842
 843     /**
 844         Returns @true if the socket is initialized and ready and @false in other
 845         cases.
 846
 847         @remarks
 848         For wxSocketClient, IsOk() won't return @true unless the client is connected to a server.
 849         For wxSocketServer, IsOk() will return @true if the server could bind to the specified address
 850         and is already listening for new connections.
 851         IsOk() does not check for IO errors; use Error() instead for that purpose.
 852     */
 853     bool IsOk() const;
 854
 855     /**
 856         Returns the number of bytes read or written by the last IO call.
 857
 858         Use this function to get the number of bytes actually transferred
 859         after using one of the following IO calls: Discard(), Peek(), Read(),
 860         ReadMsg(), Unread(), Write(), WriteMsg().
 861
 862         @deprecated
 863         This function is kept mostly for backwards compatibility.  Use
 864         LastReadCount() or LastWriteCount() instead.  LastCount() is still
 865         needed for use with less commonly used functions: Discard(),
 866         Peek(), and Unread().
 867     */
 868     wxUint32 LastCount() const;
 869
 870     /**
 871         Returns the number of bytes read by the last Read() or ReadMsg()
 872         call (receive direction only).
 873
 874         This function is thread-safe, in case Read() is executed in a
 875         different thread than Write().  Use LastReadCount() instead of
 876         LastCount() for this reason.
 877
 878         Unlike LastCount(), the functions Discard(), Peek(), and Unread()
 879         are currently not supported by LastReadCount().
 880
 881         @since 2.9.5
 882     */
 883     wxUint32 LastReadCount() const;
 884
 885     /**
 886         Returns the number of bytes written by the last Write() or WriteMsg()
 887         call (transmit direction only).
 888
 889         This function is thread-safe, in case Write() is executed in a
 890         different thread than Read().  Use LastWriteCount() instead of
 891         LastCount() for this reason.
 892
 893         @since 2.9.5
 894     */
 895     wxUint32 LastWriteCount() const;
 896
 897     /**
 898         Returns the last wxSocket error. See @ref wxSocketError .
 899
 900         @note
 901         This function merely returns the last error code,
 902         but it should not be used to determine if an error has occurred (this
 903         is because successful operations do not change the LastError value).
 904         Use Error() first, in order to determine if the last IO call failed.
 905         If this returns @true, use LastError() to discover the cause of the error.
 906     */
 907     wxSocketError LastError() const;
 908
 909     /**
 910         Restore the previous state of the socket, as saved with SaveState().
 911
 912         Calls to SaveState() and RestoreState() can be nested.
 913
 914         @see SaveState()
 915     */
 916     void RestoreState();
 917
 918     /**
 919         Save the current state of the socket in a stack.
 920
 921         Socket state includes flags, as set with SetFlags(), event mask, as set
 922         with SetNotify() and Notify(), user data, as set with SetClientData().
 923         Calls to SaveState and RestoreState can be nested.
 924
 925         @see RestoreState()
 926     */
 927     void SaveState();
 928
 929     //@}
 930
 931
 932     /**
 933         @name Basic I/O
 934
 935         See also: wxSocketServer::WaitForAccept(), wxSocketClient::WaitOnConnect()
 936     */
 937     //@{
 938
 939     /**
 940         Shut down the socket, disabling further transmission and reception of
 941         data and disable events for the socket and frees the associated system
 942         resources.
 943
 944         Upon socket destruction, Close() is automatically called, so in most cases
 945         you won't need to do it yourself, unless you explicitly want to shut down
 946         the socket, typically to notify the peer that you are closing the connection.
 947
 948         @remarks
 949         Although Close() immediately disables events for the socket, it is possible
 950         that event messages may be waiting in the application's event queue.
 951         The application must therefore be prepared to handle socket event messages even
 952         after calling Close().
 953     */
 954     virtual bool Close();
 955
 956     /**
 957         Shuts down the writing end of the socket.
 958
 959         This function simply calls the standard shutdown() function on the
 960         underlying socket, indicating that nothing will be written to this
 961         socket any more.
 962      */
 963     void ShutdownOutput();
 964
 965     /**
 966         Delete all bytes in the incoming queue.
 967
 968         This function always returns immediately and its operation is not
 969         affected by IO flags.
 970
 971         Use LastCount() to verify the number of bytes actually discarded.
 972
 973         If you use Error(), it will always return @false.
 974     */
 975     wxSocketBase& Discard();
 976
 977     /**
 978         Returns current IO flags, as set with SetFlags()
 979     */
 980     wxSocketFlags GetFlags() const;
 981
 982     /**
 983         Use this function to interrupt any wait operation currently in progress.
 984
 985         Note that this is not intended as a regular way to interrupt a Wait call,
 986         but only as an escape mechanism for exceptional situations where it is
 987         absolutely necessary to use it, for example to abort an operation due to
 988         some exception or abnormal problem. InterruptWait is automatically called
 989         when you Close() a socket (and thus also upon
 990         socket destruction), so you don't need to use it in these cases.
 991
 992         @see  Wait(), WaitForLost(), WaitForRead(), WaitForWrite(),
 993               wxSocketServer::WaitForAccept(), wxSocketClient::WaitOnConnect()
 994     */
 995     void InterruptWait();
 996
 997     /**
 998         Peek into the socket by copying the next bytes which would be read by
 999         Read() into the provided buffer.
1000
1001         Peeking a buffer doesn't delete it from the socket input queue, i.e.
1002         calling Read() will return the same data.
1003
1004         Use LastCount() to verify the number of bytes actually peeked.
1005
1006         Use Error() to determine if the operation succeeded.
1007
1008         @param buffer
1009             Buffer where to put peeked data.
1010         @param nbytes
1011             Number of bytes.
1012
1013         @return Returns a reference to the current object.
1014
1015         @remarks
1016             The exact behaviour of Peek() depends on the combination of flags being used.
1017             For a detailed explanation, see SetFlags()
1018
1019         @see Error(), LastError(), LastCount(), SetFlags()
1020     */
1021     wxSocketBase& Peek(void* buffer, wxUint32 nbytes);
1022
1023     /**
1024         Read up to the given number of bytes from the socket.
1025
1026         Use LastReadCount() to verify the number of bytes actually read.
1027         Use Error() to determine if the operation succeeded.
1028
1029         @param buffer
1030             Buffer where to put read data.
1031         @param nbytes
1032             Number of bytes.
1033
1034         @return Returns a reference to the current object.
1035
1036         @remarks
1037             The exact behaviour of Read() depends on the combination of flags being used.
1038             For a detailed explanation, see SetFlags()
1039
1040         @see Error(), LastError(), LastReadCount(),
1041              SetFlags()
1042     */
1043     wxSocketBase& Read(void* buffer, wxUint32 nbytes);
1044
1045     /**
1046         Receive a message sent by WriteMsg().
1047
1048         If the buffer passed to the function isn't big enough, the remaining
1049         bytes will be discarded. This function always waits for the buffer to
1050         be entirely filled, unless an error occurs.
1051
1052         Use LastReadCount() to verify the number of bytes actually read.
1053
1054         Use Error() to determine if the operation succeeded.
1055
1056         @param buffer
1057             Buffer where to put read data.
1058         @param nbytes
1059             Size of the buffer.
1060
1061         @return Returns a reference to the current object.
1062
1063         @remarks
1064             ReadMsg() will behave as if the @b wxSOCKET_WAITALL flag was always set
1065             and it will always ignore the @b wxSOCKET_NOWAIT flag.
1066             The exact behaviour of ReadMsg() depends on the @b wxSOCKET_BLOCK flag.
1067             For a detailed explanation, see SetFlags().
1068             For thread safety, in case ReadMsg() and WriteMsg() are called in
1069             different threads, it is a good idea to call
1070             SetFlags(wxSOCKET_WAITALL|wx_SOCKET_BLOCK) before the first calls
1071             to ReadMsg() and WriteMsg() in different threads, as each of these
1072             functions will call SetFlags() which performs read/modify/write.  By
1073             setting these flags before the multi-threading, it will ensure that
1074             they don't get reset by thread race conditions.
1075
1076         @see Error(), LastError(), LastReadCount(), SetFlags(), WriteMsg()
1077     */
1078     wxSocketBase& ReadMsg(void* buffer, wxUint32 nbytes);
1079
1080     /**
1081         Use SetFlags to customize IO operation for this socket.
1082
1083         The @a flags parameter may be a combination of flags ORed together.
1084         Notice that not all combinations of flags affecting the IO calls
1085         (Read() and Write()) make sense, e.g. @b wxSOCKET_NOWAIT can't be
1086         combined with @b wxSOCKET_WAITALL nor with @b wxSOCKET_BLOCK.
1087
1088         The following flags can be used:
1089         @beginFlagTable
1090         @flag{wxSOCKET_NONE}
1091             Default mode: the socket will read some data in the IO calls and
1092             will process events to avoid blocking UI while waiting for the data
1093             to become available.
1094         @flag{wxSOCKET_NOWAIT}
1095             Don't wait for the socket to become ready in IO calls, read as much
1096             data as is available -- potentially 0 bytes -- and return
1097             immediately.
1098         @flag{wxSOCKET_WAITALL}
1099             Don't return before the entire amount of data specified in IO calls
1100             is read or written unless an error occurs. If this flag is not
1101             specified, the IO calls return as soon as any amount of data, even
1102             less than the total number of bytes, is processed.
1103         @flag{wxSOCKET_BLOCK}
1104             Don't process the UI events while waiting for the socket to become
1105             ready. This means that UI will be unresponsive during socket IO.
1106         @flag{wxSOCKET_REUSEADDR}
1107             Allows the use of an in-use port (wxServerSocket only).
1108         @flag{wxSOCKET_BROADCAST}
1109             Switches the socket to broadcast mode.
1110         @flag{wxSOCKET_NOBIND}
1111             Stops the socket from being bound to a specific adapter (normally
1112             used in conjunction with @b wxSOCKET_BROADCAST).
1113         @endFlagTable
1114
1115         For more information on socket events see @ref wxSocketFlags .
1116     */
1117     void SetFlags(wxSocketFlags flags);
1118
1119     /**
1120         Set the local address and port to use.
1121
1122         This function must always be called for the server sockets but may also
1123         be called for client sockets, if it is, @b bind() is called before @b
1124         connect().
1125     */
1126     virtual bool SetLocal(const wxIPV4address& local);
1127
1128     /**
1129         Set the default socket timeout in seconds.
1130
1131         This timeout applies to all IO calls, and also to the Wait() family of
1132         functions if you don't specify a wait interval. Initially, the default
1133         timeout is 10 minutes.
1134     */
1135     void SetTimeout(long seconds);
1136
1137     /**
1138         Put the specified data into the input queue.
1139
1140         The data in the buffer will be returned by the next call to Read().
1141
1142         This function is not affected by wxSocket flags.
1143
1144         If you use LastCount(), it will always return @a nbytes.
1145
1146         If you use Error(), it will always return @false.
1147
1148         @param buffer
1149             Buffer to be unread.
1150         @param nbytes
1151             Number of bytes.
1152
1153         @return Returns a reference to the current object.
1154
1155         @see Error(), LastCount(), LastError()
1156     */
1157     wxSocketBase& Unread(const void* buffer, wxUint32 nbytes);
1158
1159     /**
1160         Wait for any socket event.
1161
1162         Possible socket events are:
1163         @li The socket becomes readable.
1164         @li The socket becomes writable.
1165         @li An ongoing connection request has completed (wxSocketClient only)
1166         @li An incoming connection request has arrived (wxSocketServer only)
1167         @li The connection has been closed.
1168
1169         Note that it is recommended to use the individual @b WaitForXXX()
1170         functions to wait for the required condition, instead of this one.
1171
1172         @param seconds
1173             Number of seconds to wait.
1174             If -1, it will wait for the default timeout,
1175             as set with SetTimeout().
1176         @param millisecond
1177             Number of milliseconds to wait.
1178
1179         @return
1180            @true when any of the above conditions is satisfied or @false if the
1181            timeout was reached.
1182
1183         @see InterruptWait(), wxSocketServer::WaitForAccept(),
1184              WaitForLost(), WaitForRead(),
1185              WaitForWrite(), wxSocketClient::WaitOnConnect()
1186     */
1187     bool Wait(long seconds = -1, long millisecond = 0);
1188
1189     /**
1190         Wait until the connection is lost.
1191
1192         This may happen if the peer gracefully closes the connection or if the
1193         connection breaks.
1194
1195         @param seconds
1196             Number of seconds to wait.
1197             If -1, it will wait for the default timeout,
1198             as set with SetTimeout().
1199         @param millisecond
1200             Number of milliseconds to wait.
1201
1202         @return Returns @true if the connection was lost, @false if the timeout
1203                 was reached.
1204
1205         @see InterruptWait(), Wait()
1206     */
1207     bool WaitForLost(long seconds = -1, long millisecond = 0);
1208
1209     /**
1210         Wait until the socket is readable.
1211
1212         This might mean that queued data is available for reading or, for streamed
1213         sockets, that the connection has been closed, so that a read operation will
1214         complete immediately without blocking (unless the @b wxSOCKET_WAITALL flag
1215         is set, in which case the operation might still block).
1216
1217         Notice that this function should not be called if there is already data
1218         available for reading on the socket.
1219
1220         @param seconds
1221             Number of seconds to wait.
1222             If -1, it will wait for the default timeout,
1223             as set with SetTimeout().
1224         @param millisecond
1225             Number of milliseconds to wait.
1226
1227         @return Returns @true if the socket becomes readable, @false on timeout.
1228
1229         @see InterruptWait(), Wait()
1230     */
1231     bool WaitForRead(long seconds = -1, long millisecond = 0);
1232
1233     /**
1234         Wait until the socket becomes writable.
1235
1236         This might mean that the socket is ready to send new data, or for streamed
1237         sockets, that the connection has been closed, so that a write operation is
1238         guaranteed to complete immediately (unless the @b wxSOCKET_WAITALL flag is set,
1239         in which case the operation might still block).
1240
1241         Notice that this function should not be called if the socket is already
1242         writable.
1243
1244         @param seconds
1245             Number of seconds to wait.
1246             If -1, it will wait for the default timeout,
1247             as set with SetTimeout().
1248         @param millisecond
1249             Number of milliseconds to wait.
1250
1251         @return Returns @true if the socket becomes writable, @false on timeout.
1252
1253         @see InterruptWait(), Wait()
1254     */
1255     bool WaitForWrite(long seconds = -1, long millisecond = 0);
1256
1257     /**
1258         Write up to the given number of bytes to the socket.
1259
1260         Use LastWriteCount() to verify the number of bytes actually written.
1261
1262         Use Error() to determine if the operation succeeded.
1263
1264         @param buffer
1265             Buffer with the data to be sent.
1266         @param nbytes
1267             Number of bytes.
1268
1269         @return Returns a reference to the current object.
1270
1271         @remarks
1272
1273         The exact behaviour of Write() depends on the combination of flags being used.
1274         For a detailed explanation, see SetFlags().
1275
1276         @see Error(), LastError(), LastWriteCount(), SetFlags()
1277     */
1278     wxSocketBase& Write(const void* buffer, wxUint32 nbytes);
1279
1280     /**
1281         Sends a buffer which can be read using ReadMsg().
1282
1283         WriteMsg() sends a short header before the data so that ReadMsg()
1284         knows how much data should be actually read.
1285
1286         This function always waits for the entire buffer to be sent, unless an
1287         error occurs.
1288
1289         Use LastWriteCount() to verify the number of bytes actually written.
1290
1291         Use Error() to determine if the operation succeeded.
1292
1293         @param buffer
1294             Buffer with the data to be sent.
1295         @param nbytes
1296             Number of bytes to send.
1297
1298         @return Returns a reference to the current object.
1299
1300         @remarks
1301
1302         WriteMsg() will behave as if the @b wxSOCKET_WAITALL flag was always set and
1303         it will always ignore the @b wxSOCKET_NOWAIT flag. The exact behaviour of
1304         WriteMsg() depends on the @b wxSOCKET_BLOCK flag. For a detailed explanation,
1305         see SetFlags().
1306         For thread safety, in case ReadMsg() and WriteMsg() are called in
1307         different threads, it is a good idea to call
1308         @code SetFlags(wxSOCKET_WAITALL|wx_SOCKET_BLOCK) @endcode before the
1309         first calls to ReadMsg() and WriteMsg() in different threads, as each
1310         of these functions calls SetFlags() which performs read/modify/write.
1311         By setting these flags before the multi-threading, it will ensure that
1312         they don't get reset by thread race conditions.
1313
1314         @see  Error(), LastError(), LastWriteCount(), SetFlags(), ReadMsg()
1315
1316     */
1317     wxSocketBase& WriteMsg(const void* buffer, wxUint32 nbytes);
1318
1319     //@}
1320
1321
1322     /**
1323         @name Handling Socket Events
1324     */
1325     //@{
1326
1327     /**
1328         Returns a pointer of the client data for this socket, as set with
1329         SetClientData()
1330     */
1331     void* GetClientData() const;
1332
1333     /**
1334         According to the @a notify value, this function enables
1335         or disables socket events. If @a notify is @true, the events
1336         configured with SetNotify() will
1337         be sent to the application. If @a notify is @false; no events
1338         will be sent.
1339     */
1340     void Notify(bool notify);
1341
1342     /**
1343         Sets user-supplied client data for this socket. All socket events will
1344         contain a pointer to this data, which can be retrieved with
1345         the wxSocketEvent::GetClientData() function.
1346     */
1347     void SetClientData(void* data);
1348
1349     /**
1350         Sets an event handler to be called when a socket event occurs. The
1351         handler will be called for those events for which notification is
1352         enabled with SetNotify() and
1353         Notify().
1354
1355         @param handler
1356             Specifies the event handler you want to use.
1357         @param id
1358             The id of socket event.
1359
1360         @see SetNotify(), Notify(), wxSocketEvent, wxEvtHandler
1361     */
1362     void SetEventHandler(wxEvtHandler& handler, int id = -1);
1363
1364     /**
1365         Specifies which socket events are to be sent to the event handler.
1366         The @a flags parameter may be combination of flags ORed together. The
1367         following flags can be used:
1368
1369         @beginFlagTable
1370         @flag{wxSOCKET_INPUT_FLAG} to receive @b wxSOCKET_INPUT.
1371         @flag{wxSOCKET_OUTPUT_FLAG} to receive @b wxSOCKET_OUTPUT.
1372         @flag{wxSOCKET_CONNECTION_FLAG} to receive @b wxSOCKET_CONNECTION.
1373         @flag{wxSOCKET_LOST_FLAG} to receive @b wxSOCKET_LOST.
1374         @endFlagTable
1375
1376         For example:
1377
1378         @code
1379         sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
1380         sock.Notify(true);
1381         @endcode
1382
1383         In this example, the user will be notified about incoming socket data and
1384         whenever the connection is closed.
1385
1386         For more information on socket events see @ref wxSocketEventFlags .
1387     */
1388     void SetNotify(wxSocketEventFlags flags);
1389
1390     //@}
1391 };
1392
1393
1394
1395 /**
1396     @class wxDatagramSocket
1397
1398     @todo docme
1399
1400     @library{wxnet}
1401     @category{net}
1402 */
1403 class wxDatagramSocket : public wxSocketBase
1404 {
1405 public:
1406     /**
1407         Constructor.
1408
1409         @param addr
1410             The socket address.
1411         @param flags
1412             Socket flags (See wxSocketBase::SetFlags()).
1413     */
1414     wxDatagramSocket(const wxSockAddress& addr,
1415                      wxSocketFlags flags = wxSOCKET_NONE);
1416
1417     /**
1418         Destructor. Please see wxSocketBase::Destroy().
1419     */
1420     virtual ~wxDatagramSocket();
1421
1422     /**
1423         Write a buffer of @a nbytes bytes to the socket.
1424
1425         Use wxSocketBase::LastWriteCount() to verify the number of bytes actually wrote.
1426         Use wxSocketBase::Error() to determine if the operation succeeded.
1427
1428         @param address
1429             The address of the destination peer for this data.
1430         @param buffer
1431             Buffer where read data is.
1432         @param nbytes
1433             Number of bytes.
1434
1435         @return Returns a reference to the current object.
1436
1437         @see wxSocketBase::LastError(), wxSocketBase::SetFlags()
1438     */
1439     wxDatagramSocket& SendTo(const wxSockAddress& address,
1440                              const void* buffer, wxUint32 nbytes);
1441 };
1442