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