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       m_error = GSOCK_IOERR;
1088     else if (ret == -1)
1089     {
1090       if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1091         m_error = GSOCK_WOULDBLOCK;
1092       else
1093         m_error = GSOCK_IOERR;
1094     }
1095   }
1096
1097   /* Enable events again now that we are done processing */
1098   Enable(GSOCK_INPUT);
1099
1100   return ret;
1101 }
1102
1103 int GSocket::Write(const char *buffer, int size)
1104 {
1105   int ret;
1106
1107   assert(this);
1108
1109   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
1110
1111   if (m_fd == INVALID_SOCKET || m_server)
1112   {
1113     m_error = GSOCK_INVSOCK;
1114     return -1;
1115   }
1116
1117   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
1118
1119   /* If the socket is blocking, wait for writability (with a timeout) */
1120   if (Output_Timeout() == GSOCK_TIMEDOUT)
1121     return -1;
1122
1123   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
1124
1125   /* Write the data */
1126   if (m_stream)
1127     ret = Send_Stream(buffer, size);
1128   else
1129     ret = Send_Dgram(buffer, size);
1130
1131   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
1132
1133   if (ret == -1)
1134   {
1135     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1136     {
1137       m_error = GSOCK_WOULDBLOCK;
1138       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
1139     }
1140     else
1141     {
1142       m_error = GSOCK_IOERR;
1143       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
1144     }
1145
1146     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
1147      * in MSW). Once the first OUTPUT event is received, users can assume
1148      * that the socket is writable until a read operation fails. Only then
1149      * will further OUTPUT events be posted.
1150      */
1151     Enable(GSOCK_OUTPUT);
1152
1153     return -1;
1154   }
1155
1156   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
1157
1158   return ret;
1159 }
1160
1161 /* GSocket_Select:
1162  *  Polls the socket to determine its status. This function will
1163  *  check for the events specified in the 'flags' parameter, and
1164  *  it will return a mask indicating which operations can be
1165  *  performed. This function won't block, regardless of the
1166  *  mode (blocking | nonblocking) of the socket.
1167  */
1168 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
1169 {
1170   if (!gs_gui_functions->CanUseEventLoop())
1171   {
1172
1173     GSocketEventFlags result = 0;
1174     fd_set readfds;
1175     fd_set writefds;
1176     fd_set exceptfds;
1177     struct timeval tv;
1178
1179     assert(this);
1180
1181     if (m_fd == -1)
1182         return (GSOCK_LOST_FLAG & flags);
1183
1184     /* Do not use a static struct, Linux can garble it */
1185     tv.tv_sec = m_timeout / 1000;
1186     tv.tv_usec = (m_timeout % 1000) * 1000;
1187
1188     wxFD_ZERO(&readfds);
1189     wxFD_ZERO(&writefds);
1190     wxFD_ZERO(&exceptfds);
1191     wxFD_SET(m_fd, &readfds);
1192     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
1193       wxFD_SET(m_fd, &writefds);
1194     wxFD_SET(m_fd, &exceptfds);
1195
1196     /* Check 'sticky' CONNECTION flag first */
1197     result |= (GSOCK_CONNECTION_FLAG & m_detected);
1198
1199     /* If we have already detected a LOST event, then don't try
1200      * to do any further processing.
1201      */
1202     if ((m_detected & GSOCK_LOST_FLAG) != 0)
1203     {
1204       m_establishing = false;
1205
1206       return (GSOCK_LOST_FLAG & flags);
1207     }
1208
1209     /* Try select now */
1210     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
1211     {
1212       /* What to do here? */
1213       return (result & flags);
1214     }
1215
1216     /* Check for exceptions and errors */
1217     if (wxFD_ISSET(m_fd, &exceptfds))
1218     {
1219       m_establishing = false;
1220       m_detected = GSOCK_LOST_FLAG;
1221
1222       /* LOST event: Abort any further processing */
1223       return (GSOCK_LOST_FLAG & flags);
1224     }
1225
1226     /* Check for readability */
1227     if (wxFD_ISSET(m_fd, &readfds))
1228     {
1229       result |= GSOCK_INPUT_FLAG;
1230
1231       if (m_server && m_stream)
1232       {
1233         /* This is a TCP server socket that detected a connection.
1234           While the INPUT_FLAG is also set, it doesn't matter on
1235           this kind of  sockets, as we can only Accept() from them. */
1236         result |= GSOCK_CONNECTION_FLAG;
1237         m_detected |= GSOCK_CONNECTION_FLAG;
1238       }
1239     }
1240
1241     /* Check for writability */
1242     if (wxFD_ISSET(m_fd, &writefds))
1243     {
1244       if (m_establishing && !m_server)
1245       {
1246         int error;
1247         SOCKOPTLEN_T len = sizeof(error);
1248
1249         m_establishing = false;
1250
1251         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1252
1253         if (error)
1254         {
1255           m_detected = GSOCK_LOST_FLAG;
1256
1257           /* LOST event: Abort any further processing */
1258           return (GSOCK_LOST_FLAG & flags);
1259         }
1260         else
1261         {
1262           result |= GSOCK_CONNECTION_FLAG;
1263           m_detected |= GSOCK_CONNECTION_FLAG;
1264         }
1265       }
1266       else
1267       {
1268         result |= GSOCK_OUTPUT_FLAG;
1269       }
1270     }
1271
1272     return (result & flags);
1273
1274   }
1275   else
1276   {
1277     assert(this);
1278     return flags & m_detected;
1279   }
1280 }
1281
1282 /* Flags */
1283
1284 /* GSocket_SetNonBlocking:
1285  *  Sets the socket to non-blocking mode. All IO calls will return
1286  *  immediately.
1287  */
1288 void GSocket::SetNonBlocking(bool non_block)
1289 {
1290   assert(this);
1291
1292   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1293
1294   m_non_blocking = non_block;
1295 }
1296
1297 /* GSocket_SetTimeout:
1298  *  Sets the timeout for blocking calls. Time is expressed in
1299  *  milliseconds.
1300  */
1301 void GSocket::SetTimeout(unsigned long millisec)
1302 {
1303   assert(this);
1304
1305   m_timeout = millisec;
1306 }
1307
1308 /* GSocket_GetError:
1309  *  Returns the last error occurred for this socket. Note that successful
1310  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1311  *  after an error.
1312  */
1313 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1314 {
1315   assert(this);
1316
1317   return m_error;
1318 }
1319
1320 /* Callbacks */
1321
1322 /* GSOCK_INPUT:
1323  *   There is data to be read in the input buffer. If, after a read
1324  *   operation, there is still data available, the callback function will
1325  *   be called again.
1326  * GSOCK_OUTPUT:
1327  *   The socket is available for writing. That is, the next write call
1328  *   won't block. This event is generated only once, when the connection is
1329  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1330  *   when the output buffer empties again. This means that the app should
1331  *   assume that it can write since the first OUTPUT event, and no more
1332  *   OUTPUT events will be generated unless an error occurs.
1333  * GSOCK_CONNECTION:
1334  *   Connection successfully established, for client sockets, or incoming
1335  *   client connection, for server sockets. Wait for this event (also watch
1336  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1337  * GSOCK_LOST:
1338  *   The connection is lost (or a connection request failed); this could
1339  *   be due to a failure, or due to the peer closing it gracefully.
1340  */
1341
1342 /* GSocket_SetCallback:
1343  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1344  *  may be a combination of flags OR'ed toghether, so the same
1345  *  callback function can be made to accept different events.
1346  *  The callback function must have the following prototype:
1347  *
1348  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1349  */
1350 void GSocket::SetCallback(GSocketEventFlags flags,
1351                          GSocketCallback callback, char *cdata)
1352 {
1353   int count;
1354
1355   assert(this);
1356
1357   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1358   {
1359     if ((flags & (1 << count)) != 0)
1360     {
1361       m_cbacks[count] = callback;
1362       m_data[count] = cdata;
1363     }
1364   }
1365 }
1366
1367 /* GSocket_UnsetCallback:
1368  *  Disables all callbacks specified by 'flags', which may be a
1369  *  combination of flags OR'ed toghether.
1370  */
1371 void GSocket::UnsetCallback(GSocketEventFlags flags)
1372 {
1373   int count;
1374
1375   assert(this);
1376
1377   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1378   {
1379     if ((flags & (1 << count)) != 0)
1380     {
1381       m_cbacks[count] = NULL;
1382       m_data[count] = NULL;
1383     }
1384   }
1385 }
1386
1387 GSocketError GSocket::GetSockOpt(int level, int optname,
1388                                 void *optval, int *optlen)
1389 {
1390     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1391         return GSOCK_NOERROR;
1392
1393     return GSOCK_OPTERR;
1394 }
1395
1396 GSocketError GSocket::SetSockOpt(int level, int optname,
1397                                 const void *optval, int optlen)
1398 {
1399     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1400         return GSOCK_NOERROR;
1401
1402     return GSOCK_OPTERR;
1403 }
1404
1405 #define CALL_CALLBACK(socket, event) {                                  \
1406   socket->Disable(event);                                               \
1407   if (socket->m_cbacks[event])                                          \
1408     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1409 }
1410
1411
1412 void GSocket::Enable(GSocketEvent event)
1413 {
1414   m_detected &= ~(1 << event);
1415   gs_gui_functions->Install_Callback(this, event);
1416 }
1417
1418 void GSocket::Disable(GSocketEvent event)
1419 {
1420   m_detected |= (1 << event);
1421   gs_gui_functions->Uninstall_Callback(this, event);
1422 }
1423
1424 /* _GSocket_Input_Timeout:
1425  *  For blocking sockets, wait until data is available or
1426  *  until timeout ellapses.
1427  */
1428 GSocketError GSocket::Input_Timeout()
1429 {
1430   struct timeval tv;
1431   fd_set readfds;
1432   int ret;
1433
1434   /* Linux select() will overwrite the struct on return */
1435   tv.tv_sec  = (m_timeout / 1000);
1436   tv.tv_usec = (m_timeout % 1000) * 1000;
1437
1438   if (!m_non_blocking)
1439   {
1440     wxFD_ZERO(&readfds);
1441     wxFD_SET(m_fd, &readfds);
1442     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1443     if (ret == 0)
1444     {
1445       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1446       m_error = GSOCK_TIMEDOUT;
1447       return GSOCK_TIMEDOUT;
1448     }
1449
1450     if (ret == -1)
1451     {
1452       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1453       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1454       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1455       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1456       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1457       m_error = GSOCK_TIMEDOUT;
1458       return GSOCK_TIMEDOUT;
1459     }
1460   }
1461
1462   return GSOCK_NOERROR;
1463 }
1464
1465 /* _GSocket_Output_Timeout:
1466  *  For blocking sockets, wait until data can be sent without
1467  *  blocking or until timeout ellapses.
1468  */
1469 GSocketError GSocket::Output_Timeout()
1470 {
1471   struct timeval tv;
1472   fd_set writefds;
1473   int ret;
1474
1475   /* Linux select() will overwrite the struct on return */
1476   tv.tv_sec  = (m_timeout / 1000);
1477   tv.tv_usec = (m_timeout % 1000) * 1000;
1478
1479   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1480
1481   if (!m_non_blocking)
1482   {
1483     wxFD_ZERO(&writefds);
1484     wxFD_SET(m_fd, &writefds);
1485     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1486     if (ret == 0)
1487     {
1488       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1489       m_error = GSOCK_TIMEDOUT;
1490       return GSOCK_TIMEDOUT;
1491     }
1492
1493     if (ret == -1)
1494     {
1495       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1496       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1497       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1498       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1499       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1500       m_error = GSOCK_TIMEDOUT;
1501       return GSOCK_TIMEDOUT;
1502     }
1503
1504     if ( ! wxFD_ISSET(m_fd, &writefds) )
1505     {
1506         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1507     }
1508     else
1509     {
1510         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1511     }
1512   }
1513   else
1514   {
1515     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1516   }
1517
1518   return GSOCK_NOERROR;
1519 }
1520
1521 int GSocket::Recv_Stream(char *buffer, int size)
1522 {
1523   int ret;
1524   do
1525   {
1526     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1527   }
1528   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1529
1530   return ret;
1531 }
1532
1533 int GSocket::Recv_Dgram(char *buffer, int size)
1534 {
1535   struct sockaddr from;
1536   WX_SOCKLEN_T fromlen = sizeof(from);
1537   int ret;
1538   GSocketError err;
1539
1540   fromlen = sizeof(from);
1541
1542   do
1543   {
1544     ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
1545   }
1546   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1547
1548   if (ret == -1)
1549     return -1;
1550
1551   /* Translate a system address into a GSocket address */
1552   if (!m_peer)
1553   {
1554     m_peer = GAddress_new();
1555     if (!m_peer)
1556     {
1557       m_error = GSOCK_MEMERR;
1558       return -1;
1559     }
1560   }
1561
1562   err = _GAddress_translate_from(m_peer, &from, fromlen);
1563   if (err != GSOCK_NOERROR)
1564   {
1565     GAddress_destroy(m_peer);
1566     m_peer  = NULL;
1567     m_error = err;
1568     return -1;
1569   }
1570
1571   return ret;
1572 }
1573
1574 int GSocket::Send_Stream(const char *buffer, int size)
1575 {
1576   int ret;
1577
1578   MASK_SIGNAL();
1579
1580   do
1581   {
1582     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1583   }
1584   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1585
1586   UNMASK_SIGNAL();
1587
1588   return ret;
1589 }
1590
1591 int GSocket::Send_Dgram(const char *buffer, int size)
1592 {
1593   struct sockaddr *addr;
1594   int len, ret;
1595   GSocketError err;
1596
1597   if (!m_peer)
1598   {
1599     m_error = GSOCK_INVADDR;
1600     return -1;
1601   }
1602
1603   err = _GAddress_translate_to(m_peer, &addr, &len);
1604   if (err != GSOCK_NOERROR)
1605   {
1606     m_error = err;
1607     return -1;
1608   }
1609
1610   MASK_SIGNAL();
1611
1612   do
1613   {
1614     ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1615   }
1616   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1617
1618   UNMASK_SIGNAL();
1619
1620   /* Frees memory allocated from _GAddress_translate_to */
1621   free(addr);
1622
1623   return ret;
1624 }
1625
1626 void GSocket::Detected_Read()
1627 {
1628   char c;
1629
1630   /* Safeguard against straggling call to Detected_Read */
1631   if (m_fd == INVALID_SOCKET)
1632   {
1633     return;
1634   }
1635
1636   /* If we have already detected a LOST event, then don't try
1637    * to do any further processing.
1638    */
1639   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1640   {
1641     m_establishing = false;
1642
1643     CALL_CALLBACK(this, GSOCK_LOST);
1644     Shutdown();
1645     return;
1646   }
1647
1648   int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1649
1650   if (num > 0)
1651   {
1652     CALL_CALLBACK(this, GSOCK_INPUT);
1653   }
1654   else
1655   {
1656     if (m_server && m_stream)
1657     {
1658       CALL_CALLBACK(this, GSOCK_CONNECTION);
1659     }
1660     else
1661     {
1662       /* Do not throw a lost event in cases where the socket isn't really lost */
1663       if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1664       {
1665         CALL_CALLBACK(this, GSOCK_INPUT);
1666       }
1667       else
1668       {
1669         CALL_CALLBACK(this, GSOCK_LOST);
1670         Shutdown();
1671       }
1672     }
1673   }
1674 }
1675
1676 void GSocket::Detected_Write()
1677 {
1678   /* If we have already detected a LOST event, then don't try
1679    * to do any further processing.
1680    */
1681   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1682   {
1683     m_establishing = false;
1684
1685     CALL_CALLBACK(this, GSOCK_LOST);
1686     Shutdown();
1687     return;
1688   }
1689
1690   if (m_establishing && !m_server)
1691   {
1692     int error;
1693     SOCKOPTLEN_T len = sizeof(error);
1694
1695     m_establishing = false;
1696
1697     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1698
1699     if (error)
1700     {
1701       CALL_CALLBACK(this, GSOCK_LOST);
1702       Shutdown();
1703     }
1704     else
1705     {
1706       CALL_CALLBACK(this, GSOCK_CONNECTION);
1707       /* We have to fire this event by hand because CONNECTION (for clients)
1708        * and OUTPUT are internally the same and we just disabled CONNECTION
1709        * events with the above macro.
1710        */
1711       CALL_CALLBACK(this, GSOCK_OUTPUT);
1712     }
1713   }
1714   else
1715   {
1716     CALL_CALLBACK(this, GSOCK_OUTPUT);
1717   }
1718 }
1719
1720 /* Compatibility functions for GSocket */
1721 GSocket *GSocket_new(void)
1722 {
1723     GSocket *newsocket = new GSocket();
1724     if (newsocket->IsOk())
1725         return newsocket;
1726
1727     delete newsocket;
1728
1729     return NULL;
1730 }
1731
1732 /*
1733  * -------------------------------------------------------------------------
1734  * GAddress
1735  * -------------------------------------------------------------------------
1736  */
1737
1738 /* CHECK_ADDRESS verifies that the current address family is either
1739  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1740  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1741  * an appropiate error code.
1742  *
1743  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1744  */
1745 #define CHECK_ADDRESS(address, family)                              \
1746 {                                                                   \
1747   if (address->m_family == GSOCK_NOFAMILY)                          \
1748     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1749       return address->m_error;                                      \
1750   if (address->m_family != GSOCK_##family)                          \
1751   {                                                                 \
1752     address->m_error = GSOCK_INVADDR;                               \
1753     return GSOCK_INVADDR;                                           \
1754   }                                                                 \
1755 }
1756
1757 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1758 {                                                                   \
1759   if (address->m_family == GSOCK_NOFAMILY)                          \
1760     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1761       return retval;                                                \
1762   if (address->m_family != GSOCK_##family)                          \
1763   {                                                                 \
1764     address->m_error = GSOCK_INVADDR;                               \
1765     return retval;                                                  \
1766   }                                                                 \
1767 }
1768
1769
1770 GAddress *GAddress_new(void)
1771 {
1772   GAddress *address;
1773
1774   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1775     return NULL;
1776
1777   address->m_family  = GSOCK_NOFAMILY;
1778   address->m_addr    = NULL;
1779   address->m_len     = 0;
1780
1781   return address;
1782 }
1783
1784 GAddress *GAddress_copy(GAddress *address)
1785 {
1786   GAddress *addr2;
1787
1788   assert(address != NULL);
1789
1790   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1791     return NULL;
1792
1793   memcpy(addr2, address, sizeof(GAddress));
1794
1795   if (address->m_addr && address->m_len > 0)
1796   {
1797     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1798     if (addr2->m_addr == NULL)
1799     {
1800       free(addr2);
1801       return NULL;
1802     }
1803     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1804   }
1805
1806   return addr2;
1807 }
1808
1809 void GAddress_destroy(GAddress *address)
1810 {
1811   assert(address != NULL);
1812
1813   if (address->m_addr)
1814     free(address->m_addr);
1815
1816   free(address);
1817 }
1818
1819 void GAddress_SetFamily(GAddress *address, GAddressType type)
1820 {
1821   assert(address != NULL);
1822
1823   address->m_family = type;
1824 }
1825
1826 GAddressType GAddress_GetFamily(GAddress *address)
1827 {
1828   assert(address != NULL);
1829
1830   return address->m_family;
1831 }
1832
1833 GSocketError _GAddress_translate_from(GAddress *address,
1834                                       struct sockaddr *addr, int len)
1835 {
1836   address->m_realfamily = addr->sa_family;
1837   switch (addr->sa_family)
1838   {
1839     case AF_INET:
1840       address->m_family = GSOCK_INET;
1841       break;
1842     case AF_UNIX:
1843       address->m_family = GSOCK_UNIX;
1844       break;
1845 #ifdef AF_INET6
1846     case AF_INET6:
1847       address->m_family = GSOCK_INET6;
1848       break;
1849 #endif
1850     default:
1851     {
1852       address->m_error = GSOCK_INVOP;
1853       return GSOCK_INVOP;
1854     }
1855   }
1856
1857   if (address->m_addr)
1858     free(address->m_addr);
1859
1860   address->m_len  = len;
1861   address->m_addr = (struct sockaddr *)malloc(len);
1862
1863   if (address->m_addr == NULL)
1864   {
1865     address->m_error = GSOCK_MEMERR;
1866     return GSOCK_MEMERR;
1867   }
1868
1869   memcpy(address->m_addr, addr, len);
1870
1871   return GSOCK_NOERROR;
1872 }
1873
1874 GSocketError _GAddress_translate_to(GAddress *address,
1875                                     struct sockaddr **addr, int *len)
1876 {
1877   if (!address->m_addr)
1878   {
1879     address->m_error = GSOCK_INVADDR;
1880     return GSOCK_INVADDR;
1881   }
1882
1883   *len = address->m_len;
1884   *addr = (struct sockaddr *)malloc(address->m_len);
1885   if (*addr == NULL)
1886   {
1887     address->m_error = GSOCK_MEMERR;
1888     return GSOCK_MEMERR;
1889   }
1890
1891   memcpy(*addr, address->m_addr, address->m_len);
1892   return GSOCK_NOERROR;
1893 }
1894
1895 /*
1896  * -------------------------------------------------------------------------
1897  * Internet address family
1898  * -------------------------------------------------------------------------
1899  */
1900
1901 GSocketError _GAddress_Init_INET(GAddress *address)
1902 {
1903   address->m_len  = sizeof(struct sockaddr_in);
1904   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1905   if (address->m_addr == NULL)
1906   {
1907     address->m_error = GSOCK_MEMERR;
1908     return GSOCK_MEMERR;
1909   }
1910
1911   address->m_family = GSOCK_INET;
1912   address->m_realfamily = PF_INET;
1913   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1914   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1915
1916   return GSOCK_NOERROR;
1917 }
1918
1919 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1920 {
1921   struct hostent *he;
1922   struct in_addr *addr;
1923
1924   assert(address != NULL);
1925
1926   CHECK_ADDRESS(address, INET);
1927
1928   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1929
1930   /* If it is a numeric host name, convert it now */
1931 #if defined(HAVE_INET_ATON)
1932   if (inet_aton(hostname, addr) == 0)
1933   {
1934 #elif defined(HAVE_INET_ADDR)
1935   if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
1936   {
1937 #else
1938   /* Use gethostbyname by default */
1939 #ifndef __WXMAC__
1940   int val = 1;  /* VA doesn't like constants in conditional expressions */
1941   if (val)
1942 #endif
1943   {
1944 #endif
1945     struct in_addr *array_addr;
1946
1947     /* It is a real name, we solve it */
1948     struct hostent h;
1949 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
1950     struct hostent_data buffer;
1951 #else
1952     char buffer[1024];
1953 #endif
1954     int err;
1955     he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
1956     if (he == NULL)
1957     {
1958       /* Reset to invalid address */
1959       addr->s_addr = INADDR_NONE;
1960       address->m_error = GSOCK_NOHOST;
1961       return GSOCK_NOHOST;
1962     }
1963
1964     array_addr = (struct in_addr *) *(he->h_addr_list);
1965     addr->s_addr = array_addr[0].s_addr;
1966   }
1967
1968   return GSOCK_NOERROR;
1969 }
1970
1971 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1972 {
1973   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1974 }
1975
1976 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1977                                           unsigned long hostaddr)
1978 {
1979   struct in_addr *addr;
1980
1981   assert(address != NULL);
1982
1983   CHECK_ADDRESS(address, INET);
1984
1985   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1986   addr->s_addr = htonl(hostaddr);
1987
1988   return GSOCK_NOERROR;
1989 }
1990
1991 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1992                                        const char *protocol)
1993 {
1994   struct servent *se;
1995   struct sockaddr_in *addr;
1996
1997   assert(address != NULL);
1998   CHECK_ADDRESS(address, INET);
1999
2000   if (!port)
2001   {
2002     address->m_error = GSOCK_INVPORT;
2003     return GSOCK_INVPORT;
2004   }
2005
2006 #if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
2007     struct servent_data buffer;
2008 #else
2009   char buffer[1024];
2010 #endif
2011   struct servent serv;
2012   se = wxGetservbyname_r(port, protocol, &serv,
2013                          (void*)&buffer, sizeof(buffer));
2014   if (!se)
2015   {
2016     /* the cast to int suppresses compiler warnings about subscript having the
2017        type char */
2018     if (isdigit((int)port[0]))
2019     {
2020       int port_int;
2021
2022       port_int = atoi(port);
2023       addr = (struct sockaddr_in *)address->m_addr;
2024       addr->sin_port = htons(port_int);
2025       return GSOCK_NOERROR;
2026     }
2027
2028     address->m_error = GSOCK_INVPORT;
2029     return GSOCK_INVPORT;
2030   }
2031
2032   addr = (struct sockaddr_in *)address->m_addr;
2033   addr->sin_port = se->s_port;
2034
2035   return GSOCK_NOERROR;
2036 }
2037
2038 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
2039 {
2040   struct sockaddr_in *addr;
2041
2042   assert(address != NULL);
2043   CHECK_ADDRESS(address, INET);
2044
2045   addr = (struct sockaddr_in *)address->m_addr;
2046   addr->sin_port = htons(port);
2047
2048   return GSOCK_NOERROR;
2049 }
2050
2051 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
2052 {
2053   struct hostent *he;
2054   char *addr_buf;
2055   struct sockaddr_in *addr;
2056
2057   assert(address != NULL);
2058   CHECK_ADDRESS(address, INET);
2059
2060   addr = (struct sockaddr_in *)address->m_addr;
2061   addr_buf = (char *)&(addr->sin_addr);
2062
2063   struct hostent temphost;
2064 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2065   struct hostent_data buffer;
2066 #else
2067   char buffer[1024];
2068 #endif
2069   int err;
2070   he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
2071                          (void*)&buffer, sizeof(buffer), &err);
2072   if (he == NULL)
2073   {
2074     address->m_error = GSOCK_NOHOST;
2075     return GSOCK_NOHOST;
2076   }
2077
2078   strncpy(hostname, he->h_name, sbuf);
2079
2080   return GSOCK_NOERROR;
2081 }
2082
2083 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
2084 {
2085   struct sockaddr_in *addr;
2086
2087   assert(address != NULL);
2088   CHECK_ADDRESS_RETVAL(address, INET, 0);
2089
2090   addr = (struct sockaddr_in *)address->m_addr;
2091
2092   return ntohl(addr->sin_addr.s_addr);
2093 }
2094
2095 unsigned short GAddress_INET_GetPort(GAddress *address)
2096 {
2097   struct sockaddr_in *addr;
2098
2099   assert(address != NULL);
2100   CHECK_ADDRESS_RETVAL(address, INET, 0);
2101
2102   addr = (struct sockaddr_in *)address->m_addr;
2103   return ntohs(addr->sin_port);
2104 }
2105
2106 /*
2107  * -------------------------------------------------------------------------
2108  * Unix address family
2109  * -------------------------------------------------------------------------
2110  */
2111
2112 #ifndef __VISAGECPP__
2113 GSocketError _GAddress_Init_UNIX(GAddress *address)
2114 {
2115   address->m_len  = sizeof(struct sockaddr_un);
2116   address->m_addr = (struct sockaddr *)malloc(address->m_len);
2117   if (address->m_addr == NULL)
2118   {
2119     address->m_error = GSOCK_MEMERR;
2120     return GSOCK_MEMERR;
2121   }
2122
2123   address->m_family = GSOCK_UNIX;
2124   address->m_realfamily = PF_UNIX;
2125   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
2126   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
2127
2128   return GSOCK_NOERROR;
2129 }
2130
2131 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
2132
2133 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
2134 {
2135   struct sockaddr_un *addr;
2136
2137   assert(address != NULL);
2138
2139   CHECK_ADDRESS(address, UNIX);
2140
2141   addr = ((struct sockaddr_un *)address->m_addr);
2142   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
2143   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
2144
2145   return GSOCK_NOERROR;
2146 }
2147
2148 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
2149 {
2150   struct sockaddr_un *addr;
2151
2152   assert(address != NULL);
2153   CHECK_ADDRESS(address, UNIX);
2154
2155   addr = (struct sockaddr_un *)address->m_addr;
2156
2157   strncpy(path, addr->sun_path, sbuf);
2158
2159   return GSOCK_NOERROR;
2160 }
2161 #endif  /* !defined(__VISAGECPP__) */
2162 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */