src/unix/gsocket.cpp

   1 /* -------------------------------------------------------------------------
   2  * Project:     GSocket (Generic Socket) for WX
   3  * Name:        gsocket.c
   4  * Copyright:   (c) Guilhem Lavaux
   5  * Licence:     wxWindows Licence
   6  * Authors:     David Elliott (C++ conversion, maintainer)
   7  *              Guilhem Lavaux,
   8  *              Guillermo Rodriguez Garcia <guille@iies.es>
   9  * Purpose:     GSocket main Unix and OS/2 file
  10  * Licence:     The wxWindows licence
  11  * CVSID:       $Id$
  12  * -------------------------------------------------------------------------
  13  */
  14
  15 #if defined(__WATCOMC__)
  16 #include "wx/wxprec.h"
  17 #include <errno.h>
  18 #include <nerrno.h>
  19 #endif
  20
  21 #ifndef __GSOCKET_STANDALONE__
  22 #include "wx/defs.h"
  23 #endif
  24
  25 #if defined(__VISAGECPP__)
  26 #define BSD_SELECT /* use Berkeley Sockets select */
  27 #endif
  28
  29 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
  30
  31 #include <assert.h>
  32 #include <sys/types.h>
  33 #ifdef __VISAGECPP__
  34 #include <string.h>
  35 #include <sys/time.h>
  36 #include <types.h>
  37 #include <netinet/in.h>
  38 #endif
  39 #include <netdb.h>
  40 #include <sys/ioctl.h>
  41
  42 #ifdef __VMS__
  43 #include <socket.h>
  44 struct sockaddr_un
  45 {
  46     u_char  sun_len;        /* sockaddr len including null */
  47     u_char  sun_family;     /* AF_UNIX */
  48     char    sun_path[108];  /* path name (gag) */
  49 };
  50 #else
  51 #include <sys/socket.h>
  52 #include <sys/un.h>
  53 #endif
  54
  55 #ifndef __VISAGECPP__
  56 #include <sys/time.h>
  57 #include <netinet/in.h>
  58 #include <arpa/inet.h>
  59 #include <errno.h>
  60 #include <string.h>
  61 #include <unistd.h>
  62 #else
  63 #include <nerrno.h>
  64 #  if __IBMCPP__ < 400
  65 #include <machine/endian.h>
  66 #include <socket.h>
  67 #include <ioctl.h>
  68 #include <select.h>
  69 #include <unistd.h>
  70
  71 #define EBADF   SOCEBADF
  72
  73 #    ifdef min
  74 #    undef min
  75 #    endif
  76 #  else
  77 #include <sys/socket.h>
  78 #include <sys/ioctl.h>
  79 #include <sys/select.h>
  80
  81 #define close(a) soclose(a)
  82 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
  83 int _System bsdselect(int,
  84                       struct fd_set *,
  85                       struct fd_set *,
  86                       struct fd_set *,
  87                       struct timeval *);
  88 int _System soclose(int);
  89 #  endif
  90 #endif
  91 #ifdef __EMX__
  92 #include <sys/select.h>
  93 #endif
  94
  95 #include <stdio.h>
  96 #include <stdlib.h>
  97 #include <stddef.h>
  98 #include <ctype.h>
  99 #ifdef sun
 100 #  include <sys/filio.h>
 101 #endif
 102 #ifdef sgi
 103 #  include <bstring.h>
 104 #endif
 105 #ifdef _AIX
 106 #  include <strings.h>
 107 #endif
 108 #include <signal.h>
 109
 110 #ifndef WX_SOCKLEN_T
 111
 112 #ifdef VMS
 113 #  define WX_SOCKLEN_T unsigned int
 114 #else
 115 #  ifdef __GLIBC__
 116 #    if __GLIBC__ == 2
 117 #      define WX_SOCKLEN_T socklen_t
 118 #    endif
 119 #  elif defined(__WXMAC__)
 120 #    define WX_SOCKLEN_T socklen_t
 121 #  else
 122 #    define WX_SOCKLEN_T int
 123 #  endif
 124 #endif
 125
 126 #endif /* SOCKLEN_T */
 127
 128 #ifndef SOCKOPTLEN_T
 129 #define SOCKOPTLEN_T WX_SOCKLEN_T
 130 #endif
 131
 132 /*
 133  * MSW defines this, Unices don't.
 134  */
 135 #ifndef INVALID_SOCKET
 136 #define INVALID_SOCKET -1
 137 #endif
 138
 139 /* UnixWare reportedly needs this for FIONBIO definition */
 140 #ifdef __UNIXWARE__
 141 #include <sys/filio.h>
 142 #endif
 143
 144 /*
 145  * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
 146  * on all systems. INADDR_BROADCAST should be fine to indicate an error.
 147  */
 148 #ifndef INADDR_NONE
 149 #define INADDR_NONE INADDR_BROADCAST
 150 #endif
 151
 152 #if defined(__VISAGECPP__) || defined(__WATCOMC__)
 153
 154     #define MASK_SIGNAL() {
 155     #define UNMASK_SIGNAL() }
 156
 157 #else
 158     extern "C" { typedef void (*wxSigHandler)(int); }
 159
 160     #define MASK_SIGNAL()                       \
 161     {                                           \
 162         wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN);
 163
 164     #define UNMASK_SIGNAL()                     \
 165         signal(SIGPIPE, old_handler);           \
 166     }
 167
 168 #endif
 169
 170 /* If a SIGPIPE is issued by a socket call on a remotely closed socket,
 171    the program will "crash" unless it explicitly handles the SIGPIPE.
 172    By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will
 173    use SO_NOSIGPIPE (if available), the BSD equivalent. */
 174 #ifdef MSG_NOSIGNAL
 175 #  define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
 176 #else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */
 177 #  define GSOCKET_MSG_NOSIGNAL 0
 178 #endif /* MSG_NOSIGNAL */
 179
 180 #ifndef __GSOCKET_STANDALONE__
 181 #  include "wx/unix/gsockunx.h"
 182 #  include "wx/unix/private.h"
 183 #  include "wx/gsocket.h"
 184 #if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
 185 #  include "wx/thread.h"
 186 #endif
 187 #else
 188 #  include "gsockunx.h"
 189 #  include "gsocket.h"
 190 #  ifndef WXUNUSED
 191 #    define WXUNUSED(x)
 192 #  endif
 193 #endif /* __GSOCKET_STANDALONE__ */
 194
 195 #if defined(HAVE_GETHOSTBYNAME)
 196 static struct hostent * deepCopyHostent(struct hostent *h,
 197                                         const struct hostent *he,
 198                                         char *buffer, int size, int *err)
 199 {
 200   memcpy(h, he, sizeof(struct hostent));
 201   int len = strlen(h->h_name);
 202   if (len > size)
 203     len = size - 1;
 204   memcpy(buffer, h->h_name, len);
 205   buffer[len] = '\0';
 206   h->h_name = buffer;
 207   buffer += len + 1;
 208   size -= len + 1;
 209   len = h->h_length;
 210   for (char **p = h->h_addr_list; *p != 0; p++) {
 211     if (size < len){
 212       *err = ENOMEM;
 213       return NULL;
 214     }
 215     memcpy(buffer, *p, len);
 216     *p = buffer;
 217     buffer += len;
 218     size -= len;
 219   }
 220   for (char **q = h->h_aliases; size > 0 && *q != 0; q++){
 221     len = strlen(*q);
 222     if (len > size)
 223       len = size - 1;
 224     memcpy(buffer, *q, len);
 225     buffer[len] = '\0';
 226     *q = buffer;
 227     buffer += len + 1;
 228     size -= len + 1;
 229   }
 230   return h;
 231 }
 232 #endif
 233
 234 struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h,
 235                                    void *buffer, int size, int *err)
 236
 237 {
 238   struct hostent *he = NULL;
 239   *err = 0;
 240 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
 241   if (gethostbyname_r(hostname, h, (char*)buffer, size, &he, err))
 242     he = NULL;
 243 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
 244   he = gethostbyname_r(hostname, h, (char*)buffer, size, err);
 245 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
 246   if (gethostbyname_r(hostname, h, (struct hostent_data*) buffer))
 247   {
 248     he = NULL;
 249     *err = h_errno;
 250   }
 251   else
 252     he = h;
 253 #elif defined(HAVE_GETHOSTBYNAME)
 254 #if wxUSE_THREADS
 255   static wxMutex nameLock;
 256   wxMutexLocker locker(nameLock);
 257 #endif
 258   he = gethostbyname(hostname);
 259   if (!he)
 260     *err = h_errno;
 261   else
 262     he = deepCopyHostent(h, he, (char*)buffer, size, err);
 263 #endif
 264   return he;
 265 }
 266
 267 struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
 268                                    int proto, struct hostent *h,
 269                                    void *buffer, int size, int *err)
 270 {
 271   struct hostent *he = NULL;
 272   *err = 0;
 273 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
 274   if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
 275                       (char*)buffer, size, &he, err))
 276     he = NULL;
 277 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
 278   he = gethostbyaddr_r(addr_buf, buf_size, proto, h, (char*)buffer, size, err);
 279 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
 280   if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
 281                         (struct hostent_data*) buffer))
 282   {
 283     he = NULL;
 284     *err = h_errno;
 285   }
 286   else
 287     he = h;
 288 #elif defined(HAVE_GETHOSTBYNAME)
 289 #if wxUSE_THREADS
 290   static wxMutex addrLock;
 291   wxMutexLocker locker(addrLock);
 292 #endif
 293   he = gethostbyaddr(addr_buf, buf_size, proto);
 294   if (!he)
 295     *err = h_errno;
 296   else
 297     he = deepCopyHostent(h, he, (char*)buffer, size, err);
 298 #endif
 299   return he;
 300 }
 301
 302 #if defined(HAVE_GETSERVBYNAME)
 303 static struct servent * deepCopyServent(struct servent *s,
 304                                         const struct servent *se,
 305                                         char *buffer, int size)
 306 {
 307   memcpy(s, se, sizeof(struct servent));
 308   int len = strlen(s->s_name);
 309   if (len > size)
 310     len = size - 1;
 311   memcpy(buffer, s->s_name, len);
 312   buffer[len] = '\0';
 313   s->s_name = buffer;
 314   buffer += len + 1;
 315   size -= len + 1;
 316   len = strlen(s->s_proto);
 317   if (len > size)
 318     len = size - 1;
 319   memcpy(buffer, s->s_proto, len);
 320   buffer[len] = '\0';
 321   s->s_proto = buffer;
 322   buffer += len + 1;
 323   size -= len + 1;
 324   for (char **q = s->s_aliases; size > 0 && *q != 0; q++){
 325     len = strlen(*q);
 326     if (len > size)
 327       len = size - 1;
 328     memcpy(buffer, *q, len);
 329     buffer[len] = '\0';
 330     *q = buffer;
 331     buffer += len + 1;
 332     size -= len + 1;
 333   }
 334   return s;
 335 }
 336 #endif
 337
 338 struct servent *wxGetservbyname_r(const char *port, const char *protocol,
 339                                   struct servent *serv, void *buffer, int size)
 340 {
 341   struct servent *se = NULL;
 342 #if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
 343   if (getservbyname_r(port, protocol, serv, (char*)buffer, size, &se))
 344     se = NULL;
 345 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
 346   se = getservbyname_r(port, protocol, serv, (char*)buffer, size);
 347 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
 348   if (getservbyname_r(port, protocol, serv, (struct servent_data*) buffer))
 349     se = NULL;
 350   else
 351     se = serv;
 352 #elif defined(HAVE_GETSERVBYNAME)
 353 #if wxUSE_THREADS
 354   static wxMutex servLock;
 355   wxMutexLocker locker(servLock);
 356 #endif
 357   se = getservbyname(port, protocol);
 358   if (se)
 359     se = deepCopyServent(serv, se, (char*)buffer, size);
 360 #endif
 361   return se;
 362 }
 363
 364 /* debugging helpers */
 365 #ifdef __GSOCKET_DEBUG__
 366 #  define GSocket_Debug(args) printf args
 367 #else
 368 #  define GSocket_Debug(args)
 369 #endif /* __GSOCKET_DEBUG__ */
 370
 371 /* Table of GUI-related functions. We must call them indirectly because
 372  * of wxBase and GUI separation: */
 373
 374 static GSocketGUIFunctionsTable *gs_gui_functions;
 375
 376 class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
 377 {
 378 public:
 379     virtual bool OnInit();
 380     virtual void OnExit();
 381     virtual bool CanUseEventLoop();
 382     virtual bool Init_Socket(GSocket *socket);
 383     virtual void Destroy_Socket(GSocket *socket);
 384     virtual void Install_Callback(GSocket *socket, GSocketEvent event);
 385     virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event);
 386     virtual void Enable_Events(GSocket *socket);
 387     virtual void Disable_Events(GSocket *socket);
 388 };
 389
 390 bool GSocketGUIFunctionsTableNull::OnInit()
 391 {   return true; }
 392 void GSocketGUIFunctionsTableNull::OnExit()
 393 {}
 394 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 395 {   return false; }
 396 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
 397 {   return true; }
 398 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
 399 {}
 400 void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 401 {}
 402 void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 403 {}
 404 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
 405 {}
 406 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
 407 {}
 408 /* Global initialisers */
 409
 410 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
 411 {
 412   gs_gui_functions = guifunc;
 413 }
 414
 415 int GSocket_Init(void)
 416 {
 417   if (!gs_gui_functions)
 418   {
 419     static GSocketGUIFunctionsTableNull table;
 420     gs_gui_functions = &table;
 421   }
 422   if ( !gs_gui_functions->OnInit() )
 423     return 0;
 424   return 1;
 425 }
 426
 427 void GSocket_Cleanup(void)
 428 {
 429   if (gs_gui_functions)
 430   {
 431       gs_gui_functions->OnExit();
 432   }
 433 }
 434
 435 /* Constructors / Destructors for GSocket */
 436
 437 GSocket::GSocket()
 438 {
 439   int i;
 440
 441   m_fd                  = INVALID_SOCKET;
 442   for (i=0;i<GSOCK_MAX_EVENT;i++)
 443   {
 444     m_cbacks[i]         = NULL;
 445   }
 446   m_detected            = 0;
 447   m_local               = NULL;
 448   m_peer                = NULL;
 449   m_error               = GSOCK_NOERROR;
 450   m_server              = false;
 451   m_stream              = true;
 452   m_gui_dependent       = NULL;
 453   m_non_blocking        = false;
 454   m_reusable            = false;
 455   m_timeout             = 10*60*1000;
 456                                 /* 10 minutes * 60 sec * 1000 millisec */
 457   m_establishing        = false;
 458
 459   assert(gs_gui_functions);
 460   /* Per-socket GUI-specific initialization */
 461   m_ok = gs_gui_functions->Init_Socket(this);
 462 }
 463
 464 void GSocket::Close()
 465 {
 466     gs_gui_functions->Disable_Events(this);
 467     /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */
 468 #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
 469     close(m_fd);
 470 #endif
 471     m_fd = INVALID_SOCKET;
 472 }
 473
 474 GSocket::~GSocket()
 475 {
 476   assert(this);
 477
 478   /* Check that the socket is really shutdowned */
 479   if (m_fd != INVALID_SOCKET)
 480     Shutdown();
 481
 482   /* Per-socket GUI-specific cleanup */
 483   gs_gui_functions->Destroy_Socket(this);
 484
 485   /* Destroy private addresses */
 486   if (m_local)
 487     GAddress_destroy(m_local);
 488
 489   if (m_peer)
 490     GAddress_destroy(m_peer);
 491 }
 492
 493 /* GSocket_Shutdown:
 494  *  Disallow further read/write operations on this socket, close
 495  *  the fd and disable all callbacks.
 496  */
 497 void GSocket::Shutdown()
 498 {
 499   int evt;
 500
 501   assert(this);
 502
 503   /* Don't allow events to fire after socket has been closed */
 504   gs_gui_functions->Disable_Events(this);
 505
 506   /* If socket has been created, shutdown it */
 507   if (m_fd != INVALID_SOCKET)
 508   {
 509     shutdown(m_fd, 2);
 510     Close();
 511   }
 512
 513   /* Disable GUI callbacks */
 514   for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
 515     m_cbacks[evt] = NULL;
 516
 517   m_detected = GSOCK_LOST_FLAG;
 518 }
 519
 520 /* Address handling */
 521
 522 /* GSocket_SetLocal:
 523  * GSocket_GetLocal:
 524  * GSocket_SetPeer:
 525  * GSocket_GetPeer:
 526  *  Set or get the local or peer address for this socket. The 'set'
 527  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 528  *  The 'get' functions return a pointer to a GAddress object on success,
 529  *  or NULL otherwise, in which case they set the error code of the
 530  *  corresponding GSocket.
 531  *
 532  *  Error codes:
 533  *    GSOCK_INVSOCK - the socket is not valid.
 534  *    GSOCK_INVADDR - the address is not valid.
 535  */
 536 GSocketError GSocket::SetLocal(GAddress *address)
 537 {
 538   assert(this);
 539
 540   /* the socket must be initialized, or it must be a server */
 541   if ((m_fd != INVALID_SOCKET && !m_server))
 542   {
 543     m_error = GSOCK_INVSOCK;
 544     return GSOCK_INVSOCK;
 545   }
 546
 547   /* check address */
 548   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 549   {
 550     m_error = GSOCK_INVADDR;
 551     return GSOCK_INVADDR;
 552   }
 553
 554   if (m_local)
 555     GAddress_destroy(m_local);
 556
 557   m_local = GAddress_copy(address);
 558
 559   return GSOCK_NOERROR;
 560 }
 561
 562 GSocketError GSocket::SetPeer(GAddress *address)
 563 {
 564   assert(this);
 565
 566   /* check address */
 567   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 568   {
 569     m_error = GSOCK_INVADDR;
 570     return GSOCK_INVADDR;
 571   }
 572
 573   if (m_peer)
 574     GAddress_destroy(m_peer);
 575
 576   m_peer = GAddress_copy(address);
 577
 578   return GSOCK_NOERROR;
 579 }
 580
 581 GAddress *GSocket::GetLocal()
 582 {
 583   GAddress *address;
 584   struct sockaddr addr;
 585   WX_SOCKLEN_T size = sizeof(addr);
 586   GSocketError err;
 587
 588   assert(this);
 589
 590   /* try to get it from the m_local var first */
 591   if (m_local)
 592     return GAddress_copy(m_local);
 593
 594   /* else, if the socket is initialized, try getsockname */
 595   if (m_fd == INVALID_SOCKET)
 596   {
 597     m_error = GSOCK_INVSOCK;
 598     return NULL;
 599   }
 600
 601   if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0)
 602   {
 603     m_error = GSOCK_IOERR;
 604     return NULL;
 605   }
 606
 607   /* got a valid address from getsockname, create a GAddress object */
 608   address = GAddress_new();
 609   if (address == NULL)
 610   {
 611     m_error = GSOCK_MEMERR;
 612     return NULL;
 613   }
 614
 615   err = _GAddress_translate_from(address, &addr, size);
 616   if (err != GSOCK_NOERROR)
 617   {
 618     GAddress_destroy(address);
 619     m_error = err;
 620     return NULL;
 621   }
 622
 623   return address;
 624 }
 625
 626 GAddress *GSocket::GetPeer()
 627 {
 628   assert(this);
 629
 630   /* try to get it from the m_peer var */
 631   if (m_peer)
 632     return GAddress_copy(m_peer);
 633
 634   return NULL;
 635 }
 636
 637 /* Server specific parts */
 638
 639 /* GSocket_SetServer:
 640  *  Sets up this socket as a server. The local address must have been
 641  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 642  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 643  *
 644  *  Error codes:
 645  *    GSOCK_INVSOCK - the socket is in use.
 646  *    GSOCK_INVADDR - the local address has not been set.
 647  *    GSOCK_IOERR   - low-level error.
 648  */
 649 GSocketError GSocket::SetServer()
 650 {
 651   int arg = 1;
 652
 653   assert(this);
 654
 655   /* must not be in use */
 656   if (m_fd != INVALID_SOCKET)
 657   {
 658     m_error = GSOCK_INVSOCK;
 659     return GSOCK_INVSOCK;
 660   }
 661
 662   /* the local addr must have been set */
 663   if (!m_local)
 664   {
 665     m_error = GSOCK_INVADDR;
 666     return GSOCK_INVADDR;
 667   }
 668
 669   /* Initialize all fields */
 670   m_stream   = true;
 671   m_server   = true;
 672
 673   /* Create the socket */
 674   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 675
 676   if (m_fd == INVALID_SOCKET)
 677   {
 678     m_error = GSOCK_IOERR;
 679     return GSOCK_IOERR;
 680   }
 681
 682   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 683 #ifdef SO_NOSIGPIPE
 684   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long));
 685 #endif
 686
 687   ioctl(m_fd, FIONBIO, &arg);
 688   gs_gui_functions->Enable_Events(this);
 689
 690   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 691      state after being previously closed.
 692    */
 693   if (m_reusable)
 694   {
 695     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 696 #ifdef SO_REUSEPORT
 697     setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(u_long));
 698 #endif
 699   }
 700
 701   /* Bind to the local address,
 702    * retrieve the actual address bound,
 703    * and listen up to 5 connections.
 704    */
 705   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 706       (getsockname(m_fd,
 707                    m_local->m_addr,
 708                    (WX_SOCKLEN_T *) &m_local->m_len) != 0) ||
 709       (listen(m_fd, 5) != 0))
 710   {
 711     Close();
 712     m_error = GSOCK_IOERR;
 713     return GSOCK_IOERR;
 714   }
 715
 716   return GSOCK_NOERROR;
 717 }
 718
 719 /* GSocket_WaitConnection:
 720  *  Waits for an incoming client connection. Returns a pointer to
 721  *  a GSocket object, or NULL if there was an error, in which case
 722  *  the last error field will be updated for the calling GSocket.
 723  *
 724  *  Error codes (set in the calling GSocket)
 725  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 726  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 727  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 728  *    GSOCK_MEMERR     - couldn't allocate memory.
 729  *    GSOCK_IOERR      - low-level error.
 730  */
 731 GSocket *GSocket::WaitConnection()
 732 {
 733   struct sockaddr from;
 734   WX_SOCKLEN_T fromlen = sizeof(from);
 735   GSocket *connection;
 736   GSocketError err;
 737   int arg = 1;
 738
 739   assert(this);
 740
 741   /* If the socket has already been created, we exit immediately */
 742   if (m_fd == INVALID_SOCKET || !m_server)
 743   {
 744     m_error = GSOCK_INVSOCK;
 745     return NULL;
 746   }
 747
 748   /* Create a GSocket object for the new connection */
 749   connection = GSocket_new();
 750
 751   if (!connection)
 752   {
 753     m_error = GSOCK_MEMERR;
 754     return NULL;
 755   }
 756
 757   /* Wait for a connection (with timeout) */
 758   if (Input_Timeout() == GSOCK_TIMEDOUT)
 759   {
 760     delete connection;
 761     /* m_error set by _GSocket_Input_Timeout */
 762     return NULL;
 763   }
 764
 765   connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen);
 766
 767   /* Reenable CONNECTION events */
 768   Enable(GSOCK_CONNECTION);
 769
 770   if (connection->m_fd == INVALID_SOCKET)
 771   {
 772     if (errno == EWOULDBLOCK)
 773       m_error = GSOCK_WOULDBLOCK;
 774     else
 775       m_error = GSOCK_IOERR;
 776
 777     delete connection;
 778     return NULL;
 779   }
 780
 781   /* Initialize all fields */
 782   connection->m_server   = false;
 783   connection->m_stream   = true;
 784
 785   /* Setup the peer address field */
 786   connection->m_peer = GAddress_new();
 787   if (!connection->m_peer)
 788   {
 789     delete connection;
 790     m_error = GSOCK_MEMERR;
 791     return NULL;
 792   }
 793
 794   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 795   if (err != GSOCK_NOERROR)
 796   {
 797     delete connection;
 798     m_error = err;
 799     return NULL;
 800   }
 801
 802 #if defined(__EMX__) || defined(__VISAGECPP__)
 803   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 804 #else
 805   ioctl(connection->m_fd, FIONBIO, &arg);
 806 #endif
 807   gs_gui_functions->Enable_Events(connection);
 808
 809   return connection;
 810 }
 811
 812 bool GSocket::SetReusable()
 813 {
 814     /* socket must not be null, and must not be in use/already bound */
 815     if (this && m_fd == INVALID_SOCKET)
 816     {
 817         m_reusable = true;
 818
 819         return true;
 820     }
 821
 822     return false;
 823 }
 824
 825 /* Client specific parts */
 826
 827 /* GSocket_Connect:
 828  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 829  *  to establish a client connection to a server using the peer address
 830  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 831  *  connection has been successfully established, or one of the error
 832  *  codes listed below. Note that for nonblocking sockets, a return
 833  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 834  *  request can be completed later; you should use GSocket_Select()
 835  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 836  *  corresponding asynchronous events.
 837  *
 838  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 839  *  just sets the peer address established with GSocket_SetPeer() as
 840  *  default destination.
 841  *
 842  *  Error codes:
 843  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 844  *    GSOCK_INVADDR    - the peer address has not been established.
 845  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 846  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 847  *    GSOCK_MEMERR     - couldn't allocate memory.
 848  *    GSOCK_IOERR      - low-level error.
 849  */
 850 GSocketError GSocket::Connect(GSocketStream stream)
 851 {
 852   int err, ret;
 853   int arg = 1;
 854
 855   assert(this);
 856
 857   /* Enable CONNECTION events (needed for nonblocking connections) */
 858   Enable(GSOCK_CONNECTION);
 859
 860   if (m_fd != INVALID_SOCKET)
 861   {
 862     m_error = GSOCK_INVSOCK;
 863     return GSOCK_INVSOCK;
 864   }
 865
 866   if (!m_peer)
 867   {
 868     m_error = GSOCK_INVADDR;
 869     return GSOCK_INVADDR;
 870   }
 871
 872   /* Streamed or dgram socket? */
 873   m_stream   = (stream == GSOCK_STREAMED);
 874   m_server   = false;
 875   m_establishing = false;
 876
 877   /* Create the socket */
 878   m_fd = socket(m_peer->m_realfamily,
 879                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 880
 881   if (m_fd == INVALID_SOCKET)
 882   {
 883     m_error = GSOCK_IOERR;
 884     return GSOCK_IOERR;
 885   }
 886
 887   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 888 #ifdef SO_NOSIGPIPE
 889   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long));
 890 #endif
 891
 892 #if defined(__EMX__) || defined(__VISAGECPP__)
 893   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 894 #else
 895   ioctl(m_fd, FIONBIO, &arg);
 896 #endif
 897
 898   // If the reuse flag is set, use the applicable socket reuse flags(s)
 899   if (m_reusable)
 900   {
 901     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 902 #ifdef SO_REUSEPORT
 903     setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(u_long));
 904 #endif
 905   }
 906
 907   // If a local address has been set, then we need to bind to it before calling connect
 908   if (m_local && m_local->m_addr)
 909   {
 910      bind(m_fd, m_local->m_addr, m_local->m_len);
 911   }
 912
 913   /* Connect it to the peer address, with a timeout (see below) */
 914   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 915
 916   /* We only call Enable_Events if we know we aren't shutting down the socket.
 917    * NB: Enable_Events needs to be called whether the socket is blocking or
 918    * non-blocking, it just shouldn't be called prior to knowing there is a
 919    * connection _if_ blocking sockets are being used.
 920    * If connect above returns 0, we are already connected and need to make the
 921    * call to Enable_Events now.
 922    */
 923
 924   if (m_non_blocking || ret == 0)
 925     gs_gui_functions->Enable_Events(this);
 926
 927   if (ret == -1)
 928   {
 929     err = errno;
 930
 931     /* If connect failed with EINPROGRESS and the GSocket object
 932      * is in blocking mode, we select() for the specified timeout
 933      * checking for writability to see if the connection request
 934      * completes.
 935      */
 936     if ((err == EINPROGRESS) && (!m_non_blocking))
 937     {
 938       if (Output_Timeout() == GSOCK_TIMEDOUT)
 939       {
 940         Close();
 941         /* m_error is set in _GSocket_Output_Timeout */
 942         return GSOCK_TIMEDOUT;
 943       }
 944       else
 945       {
 946         int error;
 947         SOCKOPTLEN_T len = sizeof(error);
 948
 949         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
 950
 951         gs_gui_functions->Enable_Events(this);
 952
 953         if (!error)
 954           return GSOCK_NOERROR;
 955       }
 956     }
 957
 958     /* If connect failed with EINPROGRESS and the GSocket object
 959      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 960      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 961      * this way if the connection completes, a GSOCK_CONNECTION
 962      * event will be generated, if enabled.
 963      */
 964     if ((err == EINPROGRESS) && (m_non_blocking))
 965     {
 966       m_establishing = true;
 967       m_error = GSOCK_WOULDBLOCK;
 968       return GSOCK_WOULDBLOCK;
 969     }
 970
 971     /* If connect failed with an error other than EINPROGRESS,
 972      * then the call to GSocket_Connect has failed.
 973      */
 974     Close();
 975     m_error = GSOCK_IOERR;
 976
 977     return GSOCK_IOERR;
 978   }
 979
 980   return GSOCK_NOERROR;
 981 }
 982
 983 /* Datagram sockets */
 984
 985 /* GSocket_SetNonOriented:
 986  *  Sets up this socket as a non-connection oriented (datagram) socket.
 987  *  Before using this function, the local address must have been set
 988  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 989  *  on success, or one of the following otherwise.
 990  *
 991  *  Error codes:
 992  *    GSOCK_INVSOCK - the socket is in use.
 993  *    GSOCK_INVADDR - the local address has not been set.
 994  *    GSOCK_IOERR   - low-level error.
 995  */
 996 GSocketError GSocket::SetNonOriented()
 997 {
 998   int arg = 1;
 999
1000   assert(this);
1001
1002   if (m_fd != INVALID_SOCKET)
1003   {
1004     m_error = GSOCK_INVSOCK;
1005     return GSOCK_INVSOCK;
1006   }
1007
1008   if (!m_local)
1009   {
1010     m_error = GSOCK_INVADDR;
1011     return GSOCK_INVADDR;
1012   }
1013
1014   /* Initialize all fields */
1015   m_stream   = false;
1016   m_server   = false;
1017
1018   /* Create the socket */
1019   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
1020
1021   if (m_fd == INVALID_SOCKET)
1022   {
1023     m_error = GSOCK_IOERR;
1024     return GSOCK_IOERR;
1025   }
1026 #if defined(__EMX__) || defined(__VISAGECPP__)
1027   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
1028 #else
1029   ioctl(m_fd, FIONBIO, &arg);
1030 #endif
1031   gs_gui_functions->Enable_Events(this);
1032
1033   /* Bind to the local address,
1034    * and retrieve the actual address bound.
1035    */
1036   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
1037       (getsockname(m_fd,
1038                    m_local->m_addr,
1039                    (WX_SOCKLEN_T *) &m_local->m_len) != 0))
1040   {
1041     Close();
1042     m_error = GSOCK_IOERR;
1043     return GSOCK_IOERR;
1044   }
1045
1046   return GSOCK_NOERROR;
1047 }
1048
1049 /* Generic IO */
1050
1051 /* Like recv(), send(), ... */
1052 int GSocket::Read(char *buffer, int size)
1053 {
1054   int ret;
1055
1056   assert(this);
1057
1058   if (m_fd == INVALID_SOCKET || m_server)
1059   {
1060     m_error = GSOCK_INVSOCK;
1061     return -1;
1062   }
1063
1064   /* Disable events during query of socket status */
1065   Disable(GSOCK_INPUT);
1066
1067   /* If the socket is blocking, wait for data (with a timeout) */
1068   if (Input_Timeout() == GSOCK_TIMEDOUT) {
1069     m_error = GSOCK_TIMEDOUT;
1070     /* Don't return here immediately, otherwise socket events would not be
1071      * re-enabled! */
1072     ret = -1;
1073   }
1074   else
1075   {
1076     /* Read the data */
1077     if (m_stream)
1078       ret = Recv_Stream(buffer, size);
1079     else
1080       ret = Recv_Dgram(buffer, size);
1081
1082     /* If recv returned zero, then the connection is lost, and errno is not set.
1083      * Otherwise, recv has returned an error (-1), in which case we have lost the
1084      * socket only if errno does _not_ indicate that there may be more data to read.
1085      */
1086     if (ret == 0)
1087     {
1088       m_error = GSOCK_IOERR;
1089       m_detected = GSOCK_LOST_FLAG;
1090       Close();
1091       // Signal an error for return
1092       return -1;
1093     }
1094     else if (ret == -1)
1095     {
1096       if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1097         m_error = GSOCK_WOULDBLOCK;
1098       else
1099         m_error = GSOCK_IOERR;
1100     }
1101   }
1102
1103   /* Enable events again now that we are done processing */
1104   Enable(GSOCK_INPUT);
1105
1106   return ret;
1107 }
1108
1109 int GSocket::Write(const char *buffer, int size)
1110 {
1111   int ret;
1112
1113   assert(this);
1114
1115   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
1116
1117   if (m_fd == INVALID_SOCKET || m_server)
1118   {
1119     m_error = GSOCK_INVSOCK;
1120     return -1;
1121   }
1122
1123   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
1124
1125   /* If the socket is blocking, wait for writability (with a timeout) */
1126   if (Output_Timeout() == GSOCK_TIMEDOUT)
1127     return -1;
1128
1129   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
1130
1131   /* Write the data */
1132   if (m_stream)
1133     ret = Send_Stream(buffer, size);
1134   else
1135     ret = Send_Dgram(buffer, size);
1136
1137   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
1138
1139   if (ret == -1)
1140   {
1141     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1142     {
1143       m_error = GSOCK_WOULDBLOCK;
1144       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
1145     }
1146     else
1147     {
1148       m_error = GSOCK_IOERR;
1149       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
1150     }
1151
1152     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
1153      * in MSW). Once the first OUTPUT event is received, users can assume
1154      * that the socket is writable until a read operation fails. Only then
1155      * will further OUTPUT events be posted.
1156      */
1157     Enable(GSOCK_OUTPUT);
1158
1159     return -1;
1160   }
1161
1162   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
1163
1164   return ret;
1165 }
1166
1167 /* GSocket_Select:
1168  *  Polls the socket to determine its status. This function will
1169  *  check for the events specified in the 'flags' parameter, and
1170  *  it will return a mask indicating which operations can be
1171  *  performed. This function won't block, regardless of the
1172  *  mode (blocking | nonblocking) of the socket.
1173  */
1174 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
1175 {
1176   if (!gs_gui_functions->CanUseEventLoop())
1177   {
1178
1179     GSocketEventFlags result = 0;
1180     fd_set readfds;
1181     fd_set writefds;
1182     fd_set exceptfds;
1183     struct timeval tv;
1184
1185     assert(this);
1186
1187     if (m_fd == -1)
1188         return (GSOCK_LOST_FLAG & flags);
1189
1190     /* Do not use a static struct, Linux can garble it */
1191     tv.tv_sec = m_timeout / 1000;
1192     tv.tv_usec = (m_timeout % 1000) * 1000;
1193
1194     wxFD_ZERO(&readfds);
1195     wxFD_ZERO(&writefds);
1196     wxFD_ZERO(&exceptfds);
1197     wxFD_SET(m_fd, &readfds);
1198     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
1199       wxFD_SET(m_fd, &writefds);
1200     wxFD_SET(m_fd, &exceptfds);
1201
1202     /* Check 'sticky' CONNECTION flag first */
1203     result |= (GSOCK_CONNECTION_FLAG & m_detected);
1204
1205     /* If we have already detected a LOST event, then don't try
1206      * to do any further processing.
1207      */
1208     if ((m_detected & GSOCK_LOST_FLAG) != 0)
1209     {
1210       m_establishing = false;
1211
1212       return (GSOCK_LOST_FLAG & flags);
1213     }
1214
1215     /* Try select now */
1216     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
1217     {
1218       /* What to do here? */
1219       return (result & flags);
1220     }
1221
1222     /* Check for exceptions and errors */
1223     if (wxFD_ISSET(m_fd, &exceptfds))
1224     {
1225       m_establishing = false;
1226       m_detected = GSOCK_LOST_FLAG;
1227
1228       /* LOST event: Abort any further processing */
1229       return (GSOCK_LOST_FLAG & flags);
1230     }
1231
1232     /* Check for readability */
1233     if (wxFD_ISSET(m_fd, &readfds))
1234     {
1235       result |= GSOCK_INPUT_FLAG;
1236
1237       if (m_server && m_stream)
1238       {
1239         /* This is a TCP server socket that detected a connection.
1240           While the INPUT_FLAG is also set, it doesn't matter on
1241           this kind of  sockets, as we can only Accept() from them. */
1242         result |= GSOCK_CONNECTION_FLAG;
1243         m_detected |= GSOCK_CONNECTION_FLAG;
1244       }
1245     }
1246
1247     /* Check for writability */
1248     if (wxFD_ISSET(m_fd, &writefds))
1249     {
1250       if (m_establishing && !m_server)
1251       {
1252         int error;
1253         SOCKOPTLEN_T len = sizeof(error);
1254
1255         m_establishing = false;
1256
1257         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1258
1259         if (error)
1260         {
1261           m_detected = GSOCK_LOST_FLAG;
1262
1263           /* LOST event: Abort any further processing */
1264           return (GSOCK_LOST_FLAG & flags);
1265         }
1266         else
1267         {
1268           result |= GSOCK_CONNECTION_FLAG;
1269           m_detected |= GSOCK_CONNECTION_FLAG;
1270         }
1271       }
1272       else
1273       {
1274         result |= GSOCK_OUTPUT_FLAG;
1275       }
1276     }
1277
1278     return (result & flags);
1279
1280   }
1281   else
1282   {
1283     assert(this);
1284     return flags & m_detected;
1285   }
1286 }
1287
1288 /* Flags */
1289
1290 /* GSocket_SetNonBlocking:
1291  *  Sets the socket to non-blocking mode. All IO calls will return
1292  *  immediately.
1293  */
1294 void GSocket::SetNonBlocking(bool non_block)
1295 {
1296   assert(this);
1297
1298   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1299
1300   m_non_blocking = non_block;
1301 }
1302
1303 /* GSocket_SetTimeout:
1304  *  Sets the timeout for blocking calls. Time is expressed in
1305  *  milliseconds.
1306  */
1307 void GSocket::SetTimeout(unsigned long millisec)
1308 {
1309   assert(this);
1310
1311   m_timeout = millisec;
1312 }
1313
1314 /* GSocket_GetError:
1315  *  Returns the last error occurred for this socket. Note that successful
1316  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1317  *  after an error.
1318  */
1319 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1320 {
1321   assert(this);
1322
1323   return m_error;
1324 }
1325
1326 /* Callbacks */
1327
1328 /* GSOCK_INPUT:
1329  *   There is data to be read in the input buffer. If, after a read
1330  *   operation, there is still data available, the callback function will
1331  *   be called again.
1332  * GSOCK_OUTPUT:
1333  *   The socket is available for writing. That is, the next write call
1334  *   won't block. This event is generated only once, when the connection is
1335  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1336  *   when the output buffer empties again. This means that the app should
1337  *   assume that it can write since the first OUTPUT event, and no more
1338  *   OUTPUT events will be generated unless an error occurs.
1339  * GSOCK_CONNECTION:
1340  *   Connection successfully established, for client sockets, or incoming
1341  *   client connection, for server sockets. Wait for this event (also watch
1342  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1343  * GSOCK_LOST:
1344  *   The connection is lost (or a connection request failed); this could
1345  *   be due to a failure, or due to the peer closing it gracefully.
1346  */
1347
1348 /* GSocket_SetCallback:
1349  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1350  *  may be a combination of flags OR'ed toghether, so the same
1351  *  callback function can be made to accept different events.
1352  *  The callback function must have the following prototype:
1353  *
1354  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1355  */
1356 void GSocket::SetCallback(GSocketEventFlags flags,
1357                          GSocketCallback callback, char *cdata)
1358 {
1359   int count;
1360
1361   assert(this);
1362
1363   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1364   {
1365     if ((flags & (1 << count)) != 0)
1366     {
1367       m_cbacks[count] = callback;
1368       m_data[count] = cdata;
1369     }
1370   }
1371 }
1372
1373 /* GSocket_UnsetCallback:
1374  *  Disables all callbacks specified by 'flags', which may be a
1375  *  combination of flags OR'ed toghether.
1376  */
1377 void GSocket::UnsetCallback(GSocketEventFlags flags)
1378 {
1379   int count;
1380
1381   assert(this);
1382
1383   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1384   {
1385     if ((flags & (1 << count)) != 0)
1386     {
1387       m_cbacks[count] = NULL;
1388       m_data[count] = NULL;
1389     }
1390   }
1391 }
1392
1393 GSocketError GSocket::GetSockOpt(int level, int optname,
1394                                 void *optval, int *optlen)
1395 {
1396     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1397         return GSOCK_NOERROR;
1398
1399     return GSOCK_OPTERR;
1400 }
1401
1402 GSocketError GSocket::SetSockOpt(int level, int optname,
1403                                 const void *optval, int optlen)
1404 {
1405     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1406         return GSOCK_NOERROR;
1407
1408     return GSOCK_OPTERR;
1409 }
1410
1411 #define CALL_CALLBACK(socket, event) {                                  \
1412   socket->Disable(event);                                               \
1413   if (socket->m_cbacks[event])                                          \
1414     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1415 }
1416
1417
1418 void GSocket::Enable(GSocketEvent event)
1419 {
1420   m_detected &= ~(1 << event);
1421   gs_gui_functions->Install_Callback(this, event);
1422 }
1423
1424 void GSocket::Disable(GSocketEvent event)
1425 {
1426   m_detected |= (1 << event);
1427   gs_gui_functions->Uninstall_Callback(this, event);
1428 }
1429
1430 /* _GSocket_Input_Timeout:
1431  *  For blocking sockets, wait until data is available or
1432  *  until timeout ellapses.
1433  */
1434 GSocketError GSocket::Input_Timeout()
1435 {
1436   struct timeval tv;
1437   fd_set readfds;
1438   int ret;
1439
1440   /* Linux select() will overwrite the struct on return */
1441   tv.tv_sec  = (m_timeout / 1000);
1442   tv.tv_usec = (m_timeout % 1000) * 1000;
1443
1444   if (!m_non_blocking)
1445   {
1446     wxFD_ZERO(&readfds);
1447     wxFD_SET(m_fd, &readfds);
1448     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1449     if (ret == 0)
1450     {
1451       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1452       m_error = GSOCK_TIMEDOUT;
1453       return GSOCK_TIMEDOUT;
1454     }
1455
1456     if (ret == -1)
1457     {
1458       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1459       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1460       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1461       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1462       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1463       m_error = GSOCK_TIMEDOUT;
1464       return GSOCK_TIMEDOUT;
1465     }
1466   }
1467
1468   return GSOCK_NOERROR;
1469 }
1470
1471 /* _GSocket_Output_Timeout:
1472  *  For blocking sockets, wait until data can be sent without
1473  *  blocking or until timeout ellapses.
1474  */
1475 GSocketError GSocket::Output_Timeout()
1476 {
1477   struct timeval tv;
1478   fd_set writefds;
1479   int ret;
1480
1481   /* Linux select() will overwrite the struct on return */
1482   tv.tv_sec  = (m_timeout / 1000);
1483   tv.tv_usec = (m_timeout % 1000) * 1000;
1484
1485   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1486
1487   if (!m_non_blocking)
1488   {
1489     wxFD_ZERO(&writefds);
1490     wxFD_SET(m_fd, &writefds);
1491     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1492     if (ret == 0)
1493     {
1494       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1495       m_error = GSOCK_TIMEDOUT;
1496       return GSOCK_TIMEDOUT;
1497     }
1498
1499     if (ret == -1)
1500     {
1501       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1502       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1503       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1504       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1505       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1506       m_error = GSOCK_TIMEDOUT;
1507       return GSOCK_TIMEDOUT;
1508     }
1509
1510     if ( ! wxFD_ISSET(m_fd, &writefds) )
1511     {
1512         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1513     }
1514     else
1515     {
1516         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1517     }
1518   }
1519   else
1520   {
1521     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1522   }
1523
1524   return GSOCK_NOERROR;
1525 }
1526
1527 int GSocket::Recv_Stream(char *buffer, int size)
1528 {
1529   int ret;
1530   do
1531   {
1532     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1533   }
1534   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1535
1536   return ret;
1537 }
1538
1539 int GSocket::Recv_Dgram(char *buffer, int size)
1540 {
1541   struct sockaddr from;
1542   WX_SOCKLEN_T fromlen = sizeof(from);
1543   int ret;
1544   GSocketError err;
1545
1546   fromlen = sizeof(from);
1547
1548   do
1549   {
1550     ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
1551   }
1552   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1553
1554   if (ret == -1)
1555     return -1;
1556
1557   /* Translate a system address into a GSocket address */
1558   if (!m_peer)
1559   {
1560     m_peer = GAddress_new();
1561     if (!m_peer)
1562     {
1563       m_error = GSOCK_MEMERR;
1564       return -1;
1565     }
1566   }
1567
1568   err = _GAddress_translate_from(m_peer, &from, fromlen);
1569   if (err != GSOCK_NOERROR)
1570   {
1571     GAddress_destroy(m_peer);
1572     m_peer  = NULL;
1573     m_error = err;
1574     return -1;
1575   }
1576
1577   return ret;
1578 }
1579
1580 int GSocket::Send_Stream(const char *buffer, int size)
1581 {
1582   int ret;
1583
1584   MASK_SIGNAL();
1585
1586   do
1587   {
1588     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1589   }
1590   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1591
1592   UNMASK_SIGNAL();
1593
1594   return ret;
1595 }
1596
1597 int GSocket::Send_Dgram(const char *buffer, int size)
1598 {
1599   struct sockaddr *addr;
1600   int len, ret;
1601   GSocketError err;
1602
1603   if (!m_peer)
1604   {
1605     m_error = GSOCK_INVADDR;
1606     return -1;
1607   }
1608
1609   err = _GAddress_translate_to(m_peer, &addr, &len);
1610   if (err != GSOCK_NOERROR)
1611   {
1612     m_error = err;
1613     return -1;
1614   }
1615
1616   MASK_SIGNAL();
1617
1618   do
1619   {
1620     ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1621   }
1622   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1623
1624   UNMASK_SIGNAL();
1625
1626   /* Frees memory allocated from _GAddress_translate_to */
1627   free(addr);
1628
1629   return ret;
1630 }
1631
1632 void GSocket::Detected_Read()
1633 {
1634   char c;
1635
1636   /* Safeguard against straggling call to Detected_Read */
1637   if (m_fd == INVALID_SOCKET)
1638   {
1639     return;
1640   }
1641
1642   /* If we have already detected a LOST event, then don't try
1643    * to do any further processing.
1644    */
1645   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1646   {
1647     m_establishing = false;
1648
1649     CALL_CALLBACK(this, GSOCK_LOST);
1650     Shutdown();
1651     return;
1652   }
1653
1654   int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1655
1656   if (num > 0)
1657   {
1658     CALL_CALLBACK(this, GSOCK_INPUT);
1659   }
1660   else
1661   {
1662     if (m_server && m_stream)
1663     {
1664       CALL_CALLBACK(this, GSOCK_CONNECTION);
1665     }
1666     else
1667     {
1668       /* Do not throw a lost event in cases where the socket isn't really lost */
1669       if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1670       {
1671         CALL_CALLBACK(this, GSOCK_INPUT);
1672       }
1673       else
1674       {
1675         CALL_CALLBACK(this, GSOCK_LOST);
1676         Shutdown();
1677       }
1678     }
1679   }
1680 }
1681
1682 void GSocket::Detected_Write()
1683 {
1684   /* If we have already detected a LOST event, then don't try
1685    * to do any further processing.
1686    */
1687   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1688   {
1689     m_establishing = false;
1690
1691     CALL_CALLBACK(this, GSOCK_LOST);
1692     Shutdown();
1693     return;
1694   }
1695
1696   if (m_establishing && !m_server)
1697   {
1698     int error;
1699     SOCKOPTLEN_T len = sizeof(error);
1700
1701     m_establishing = false;
1702
1703     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1704
1705     if (error)
1706     {
1707       CALL_CALLBACK(this, GSOCK_LOST);
1708       Shutdown();
1709     }
1710     else
1711     {
1712       CALL_CALLBACK(this, GSOCK_CONNECTION);
1713       /* We have to fire this event by hand because CONNECTION (for clients)
1714        * and OUTPUT are internally the same and we just disabled CONNECTION
1715        * events with the above macro.
1716        */
1717       CALL_CALLBACK(this, GSOCK_OUTPUT);
1718     }
1719   }
1720   else
1721   {
1722     CALL_CALLBACK(this, GSOCK_OUTPUT);
1723   }
1724 }
1725
1726 /* Compatibility functions for GSocket */
1727 GSocket *GSocket_new(void)
1728 {
1729     GSocket *newsocket = new GSocket();
1730     if (newsocket->IsOk())
1731         return newsocket;
1732
1733     delete newsocket;
1734
1735     return NULL;
1736 }
1737
1738 /*
1739  * -------------------------------------------------------------------------
1740  * GAddress
1741  * -------------------------------------------------------------------------
1742  */
1743
1744 /* CHECK_ADDRESS verifies that the current address family is either
1745  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1746  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1747  * an appropiate error code.
1748  *
1749  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1750  */
1751 #define CHECK_ADDRESS(address, family)                              \
1752 {                                                                   \
1753   if (address->m_family == GSOCK_NOFAMILY)                          \
1754     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1755       return address->m_error;                                      \
1756   if (address->m_family != GSOCK_##family)                          \
1757   {                                                                 \
1758     address->m_error = GSOCK_INVADDR;                               \
1759     return GSOCK_INVADDR;                                           \
1760   }                                                                 \
1761 }
1762
1763 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1764 {                                                                   \
1765   if (address->m_family == GSOCK_NOFAMILY)                          \
1766     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1767       return retval;                                                \
1768   if (address->m_family != GSOCK_##family)                          \
1769   {                                                                 \
1770     address->m_error = GSOCK_INVADDR;                               \
1771     return retval;                                                  \
1772   }                                                                 \
1773 }
1774
1775
1776 GAddress *GAddress_new(void)
1777 {
1778   GAddress *address;
1779
1780   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1781     return NULL;
1782
1783   address->m_family  = GSOCK_NOFAMILY;
1784   address->m_addr    = NULL;
1785   address->m_len     = 0;
1786
1787   return address;
1788 }
1789
1790 GAddress *GAddress_copy(GAddress *address)
1791 {
1792   GAddress *addr2;
1793
1794   assert(address != NULL);
1795
1796   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1797     return NULL;
1798
1799   memcpy(addr2, address, sizeof(GAddress));
1800
1801   if (address->m_addr && address->m_len > 0)
1802   {
1803     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1804     if (addr2->m_addr == NULL)
1805     {
1806       free(addr2);
1807       return NULL;
1808     }
1809     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1810   }
1811
1812   return addr2;
1813 }
1814
1815 void GAddress_destroy(GAddress *address)
1816 {
1817   assert(address != NULL);
1818
1819   if (address->m_addr)
1820     free(address->m_addr);
1821
1822   free(address);
1823 }
1824
1825 void GAddress_SetFamily(GAddress *address, GAddressType type)
1826 {
1827   assert(address != NULL);
1828
1829   address->m_family = type;
1830 }
1831
1832 GAddressType GAddress_GetFamily(GAddress *address)
1833 {
1834   assert(address != NULL);
1835
1836   return address->m_family;
1837 }
1838
1839 GSocketError _GAddress_translate_from(GAddress *address,
1840                                       struct sockaddr *addr, int len)
1841 {
1842   address->m_realfamily = addr->sa_family;
1843   switch (addr->sa_family)
1844   {
1845     case AF_INET:
1846       address->m_family = GSOCK_INET;
1847       break;
1848     case AF_UNIX:
1849       address->m_family = GSOCK_UNIX;
1850       break;
1851 #ifdef AF_INET6
1852     case AF_INET6:
1853       address->m_family = GSOCK_INET6;
1854       break;
1855 #endif
1856     default:
1857     {
1858       address->m_error = GSOCK_INVOP;
1859       return GSOCK_INVOP;
1860     }
1861   }
1862
1863   if (address->m_addr)
1864     free(address->m_addr);
1865
1866   address->m_len  = len;
1867   address->m_addr = (struct sockaddr *)malloc(len);
1868
1869   if (address->m_addr == NULL)
1870   {
1871     address->m_error = GSOCK_MEMERR;
1872     return GSOCK_MEMERR;
1873   }
1874
1875   memcpy(address->m_addr, addr, len);
1876
1877   return GSOCK_NOERROR;
1878 }
1879
1880 GSocketError _GAddress_translate_to(GAddress *address,
1881                                     struct sockaddr **addr, int *len)
1882 {
1883   if (!address->m_addr)
1884   {
1885     address->m_error = GSOCK_INVADDR;
1886     return GSOCK_INVADDR;
1887   }
1888
1889   *len = address->m_len;
1890   *addr = (struct sockaddr *)malloc(address->m_len);
1891   if (*addr == NULL)
1892   {
1893     address->m_error = GSOCK_MEMERR;
1894     return GSOCK_MEMERR;
1895   }
1896
1897   memcpy(*addr, address->m_addr, address->m_len);
1898   return GSOCK_NOERROR;
1899 }
1900
1901 /*
1902  * -------------------------------------------------------------------------
1903  * Internet address family
1904  * -------------------------------------------------------------------------
1905  */
1906
1907 GSocketError _GAddress_Init_INET(GAddress *address)
1908 {
1909   address->m_len  = sizeof(struct sockaddr_in);
1910   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1911   if (address->m_addr == NULL)
1912   {
1913     address->m_error = GSOCK_MEMERR;
1914     return GSOCK_MEMERR;
1915   }
1916
1917   address->m_family = GSOCK_INET;
1918   address->m_realfamily = PF_INET;
1919   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1920   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1921
1922   return GSOCK_NOERROR;
1923 }
1924
1925 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1926 {
1927   struct hostent *he;
1928   struct in_addr *addr;
1929
1930   assert(address != NULL);
1931
1932   CHECK_ADDRESS(address, INET);
1933
1934   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1935
1936   /* If it is a numeric host name, convert it now */
1937 #if defined(HAVE_INET_ATON)
1938   if (inet_aton(hostname, addr) == 0)
1939   {
1940 #elif defined(HAVE_INET_ADDR)
1941   if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
1942   {
1943 #else
1944   /* Use gethostbyname by default */
1945 #ifndef __WXMAC__
1946   int val = 1;  /* VA doesn't like constants in conditional expressions */
1947   if (val)
1948 #endif
1949   {
1950 #endif
1951     struct in_addr *array_addr;
1952
1953     /* It is a real name, we solve it */
1954     struct hostent h;
1955 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
1956     struct hostent_data buffer;
1957 #else
1958     char buffer[1024];
1959 #endif
1960     int err;
1961     he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
1962     if (he == NULL)
1963     {
1964       /* Reset to invalid address */
1965       addr->s_addr = INADDR_NONE;
1966       address->m_error = GSOCK_NOHOST;
1967       return GSOCK_NOHOST;
1968     }
1969
1970     array_addr = (struct in_addr *) *(he->h_addr_list);
1971     addr->s_addr = array_addr[0].s_addr;
1972   }
1973
1974   return GSOCK_NOERROR;
1975 }
1976
1977 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1978 {
1979   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1980 }
1981
1982 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1983                                           unsigned long hostaddr)
1984 {
1985   struct in_addr *addr;
1986
1987   assert(address != NULL);
1988
1989   CHECK_ADDRESS(address, INET);
1990
1991   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1992   addr->s_addr = htonl(hostaddr);
1993
1994   return GSOCK_NOERROR;
1995 }
1996
1997 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1998                                        const char *protocol)
1999 {
2000   struct servent *se;
2001   struct sockaddr_in *addr;
2002
2003   assert(address != NULL);
2004   CHECK_ADDRESS(address, INET);
2005
2006   if (!port)
2007   {
2008     address->m_error = GSOCK_INVPORT;
2009     return GSOCK_INVPORT;
2010   }
2011
2012 #if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
2013     struct servent_data buffer;
2014 #else
2015   char buffer[1024];
2016 #endif
2017   struct servent serv;
2018   se = wxGetservbyname_r(port, protocol, &serv,
2019                          (void*)&buffer, sizeof(buffer));
2020   if (!se)
2021   {
2022     /* the cast to int suppresses compiler warnings about subscript having the
2023        type char */
2024     if (isdigit((int)port[0]))
2025     {
2026       int port_int;
2027
2028       port_int = atoi(port);
2029       addr = (struct sockaddr_in *)address->m_addr;
2030       addr->sin_port = htons(port_int);
2031       return GSOCK_NOERROR;
2032     }
2033
2034     address->m_error = GSOCK_INVPORT;
2035     return GSOCK_INVPORT;
2036   }
2037
2038   addr = (struct sockaddr_in *)address->m_addr;
2039   addr->sin_port = se->s_port;
2040
2041   return GSOCK_NOERROR;
2042 }
2043
2044 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
2045 {
2046   struct sockaddr_in *addr;
2047
2048   assert(address != NULL);
2049   CHECK_ADDRESS(address, INET);
2050
2051   addr = (struct sockaddr_in *)address->m_addr;
2052   addr->sin_port = htons(port);
2053
2054   return GSOCK_NOERROR;
2055 }
2056
2057 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
2058 {
2059   struct hostent *he;
2060   char *addr_buf;
2061   struct sockaddr_in *addr;
2062
2063   assert(address != NULL);
2064   CHECK_ADDRESS(address, INET);
2065
2066   addr = (struct sockaddr_in *)address->m_addr;
2067   addr_buf = (char *)&(addr->sin_addr);
2068
2069   struct hostent temphost;
2070 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2071   struct hostent_data buffer;
2072 #else
2073   char buffer[1024];
2074 #endif
2075   int err;
2076   he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
2077                          (void*)&buffer, sizeof(buffer), &err);
2078   if (he == NULL)
2079   {
2080     address->m_error = GSOCK_NOHOST;
2081     return GSOCK_NOHOST;
2082   }
2083
2084   strncpy(hostname, he->h_name, sbuf);
2085
2086   return GSOCK_NOERROR;
2087 }
2088
2089 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
2090 {
2091   struct sockaddr_in *addr;
2092
2093   assert(address != NULL);
2094   CHECK_ADDRESS_RETVAL(address, INET, 0);
2095
2096   addr = (struct sockaddr_in *)address->m_addr;
2097
2098   return ntohl(addr->sin_addr.s_addr);
2099 }
2100
2101 unsigned short GAddress_INET_GetPort(GAddress *address)
2102 {
2103   struct sockaddr_in *addr;
2104
2105   assert(address != NULL);
2106   CHECK_ADDRESS_RETVAL(address, INET, 0);
2107
2108   addr = (struct sockaddr_in *)address->m_addr;
2109   return ntohs(addr->sin_port);
2110 }
2111
2112 /*
2113  * -------------------------------------------------------------------------
2114  * Unix address family
2115  * -------------------------------------------------------------------------
2116  */
2117
2118 #ifndef __VISAGECPP__
2119 GSocketError _GAddress_Init_UNIX(GAddress *address)
2120 {
2121   address->m_len  = sizeof(struct sockaddr_un);
2122   address->m_addr = (struct sockaddr *)malloc(address->m_len);
2123   if (address->m_addr == NULL)
2124   {
2125     address->m_error = GSOCK_MEMERR;
2126     return GSOCK_MEMERR;
2127   }
2128
2129   address->m_family = GSOCK_UNIX;
2130   address->m_realfamily = PF_UNIX;
2131   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
2132   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
2133
2134   return GSOCK_NOERROR;
2135 }
2136
2137 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
2138
2139 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
2140 {
2141   struct sockaddr_un *addr;
2142
2143   assert(address != NULL);
2144
2145   CHECK_ADDRESS(address, UNIX);
2146
2147   addr = ((struct sockaddr_un *)address->m_addr);
2148   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
2149   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
2150
2151   return GSOCK_NOERROR;
2152 }
2153
2154 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
2155 {
2156   struct sockaddr_un *addr;
2157
2158   assert(address != NULL);
2159   CHECK_ADDRESS(address, UNIX);
2160
2161   addr = (struct sockaddr_un *)address->m_addr;
2162
2163   strncpy(path, addr->sun_path, sbuf);
2164
2165   return GSOCK_NOERROR;
2166 }
2167 #endif  /* !defined(__VISAGECPP__) */
2168 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */