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 /* Table of GUI-related functions. We must call them indirectly because
 454  * of wxBase and GUI separation: */
 455
 456 static GSocketGUIFunctionsTable *gs_gui_functions;
 457
 458 class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
 459 {
 460 public:
 461     virtual bool OnInit();
 462     virtual void OnExit();
 463     virtual bool CanUseEventLoop();
 464     virtual bool Init_Socket(GSocket *socket);
 465     virtual void Destroy_Socket(GSocket *socket);
 466     virtual void Install_Callback(GSocket *socket, GSocketEvent event);
 467     virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event);
 468     virtual void Enable_Events(GSocket *socket);
 469     virtual void Disable_Events(GSocket *socket);
 470 };
 471
 472 bool GSocketGUIFunctionsTableNull::OnInit()
 473 {   return true; }
 474 void GSocketGUIFunctionsTableNull::OnExit()
 475 {}
 476 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 477 {   return false; }
 478 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
 479 {   return true; }
 480 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
 481 {}
 482 void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 483 {}
 484 void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 485 {}
 486 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
 487 {}
 488 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
 489 {}
 490 /* Global initialisers */
 491
 492 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
 493 {
 494   gs_gui_functions = guifunc;
 495 }
 496
 497 int GSocket_Init(void)
 498 {
 499   if (!gs_gui_functions)
 500   {
 501     static GSocketGUIFunctionsTableNull table;
 502     gs_gui_functions = &table;
 503   }
 504   if ( !gs_gui_functions->OnInit() )
 505     return 0;
 506   return 1;
 507 }
 508
 509 void GSocket_Cleanup(void)
 510 {
 511   if (gs_gui_functions)
 512   {
 513       gs_gui_functions->OnExit();
 514   }
 515 }
 516
 517 /* Constructors / Destructors for GSocket */
 518
 519 GSocket::GSocket()
 520 {
 521   int i;
 522
 523   m_fd                  = INVALID_SOCKET;
 524   m_handler             = NULL;
 525
 526   for (i=0;i<GSOCK_MAX_EVENT;i++)
 527   {
 528     m_cbacks[i]         = NULL;
 529   }
 530   m_detected            = 0;
 531   m_local               = NULL;
 532   m_peer                = NULL;
 533   m_error               = GSOCK_NOERROR;
 534   m_server              = false;
 535   m_stream              = true;
 536   m_gui_dependent       = NULL;
 537   m_non_blocking        = false;
 538   m_reusable            = false;
 539   m_broadcast           = false;
 540   m_dobind              = true;
 541   m_timeout             = 10*60*1000;
 542                                 /* 10 minutes * 60 sec * 1000 millisec */
 543   m_establishing        = false;
 544
 545   assert(gs_gui_functions);
 546   /* Per-socket GUI-specific initialization */
 547   m_ok = gs_gui_functions->Init_Socket(this);
 548 }
 549
 550 void GSocket::Close()
 551 {
 552     gs_gui_functions->Disable_Events(this);
 553
 554     /*  When running on OS X, the gsockosx implementation of GSocketGUIFunctionsTable
 555         will close the socket during Disable_Events.  However, it will only do this
 556         if it is being used.  That is, it won't do it in a console program.  To
 557         ensure we get the right behavior, we have gsockosx set m_fd = INVALID_SOCKET
 558         if it has closed the socket which indicates to us (at runtime, instead of
 559         at compile time as this had been before) that the socket has already
 560         been closed.
 561      */
 562     if(m_fd != INVALID_SOCKET)
 563         close(m_fd);
 564     m_fd = INVALID_SOCKET;
 565 }
 566
 567 GSocket::~GSocket()
 568 {
 569   assert(this);
 570
 571   /* Check that the socket is really shutdowned */
 572   if (m_fd != INVALID_SOCKET)
 573     Shutdown();
 574
 575   /* Per-socket GUI-specific cleanup */
 576   gs_gui_functions->Destroy_Socket(this);
 577
 578   delete m_handler;
 579
 580   /* Destroy private addresses */
 581   if (m_local)
 582     GAddress_destroy(m_local);
 583
 584   if (m_peer)
 585     GAddress_destroy(m_peer);
 586 }
 587
 588 /* GSocket_Shutdown:
 589  *  Disallow further read/write operations on this socket, close
 590  *  the fd and disable all callbacks.
 591  */
 592 void GSocket::Shutdown()
 593 {
 594   int evt;
 595
 596   assert(this);
 597
 598   /* Don't allow events to fire after socket has been closed */
 599   gs_gui_functions->Disable_Events(this);
 600
 601   /* If socket has been created, shutdown it */
 602   if (m_fd != INVALID_SOCKET)
 603   {
 604     shutdown(m_fd, 1);
 605     Close();
 606   }
 607
 608   /* Disable GUI callbacks */
 609   for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
 610     m_cbacks[evt] = NULL;
 611
 612   m_detected = GSOCK_LOST_FLAG;
 613 }
 614
 615 /* Address handling */
 616
 617 /* GSocket_SetLocal:
 618  * GSocket_GetLocal:
 619  * GSocket_SetPeer:
 620  * GSocket_GetPeer:
 621  *  Set or get the local or peer address for this socket. The 'set'
 622  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 623  *  The 'get' functions return a pointer to a GAddress object on success,
 624  *  or NULL otherwise, in which case they set the error code of the
 625  *  corresponding GSocket.
 626  *
 627  *  Error codes:
 628  *    GSOCK_INVSOCK - the socket is not valid.
 629  *    GSOCK_INVADDR - the address is not valid.
 630  */
 631 GSocketError GSocket::SetLocal(GAddress *address)
 632 {
 633   assert(this);
 634
 635   /* the socket must be initialized, or it must be a server */
 636   if ((m_fd != INVALID_SOCKET && !m_server))
 637   {
 638     m_error = GSOCK_INVSOCK;
 639     return GSOCK_INVSOCK;
 640   }
 641
 642   /* check address */
 643   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 644   {
 645     m_error = GSOCK_INVADDR;
 646     return GSOCK_INVADDR;
 647   }
 648
 649   if (m_local)
 650     GAddress_destroy(m_local);
 651
 652   m_local = GAddress_copy(address);
 653
 654   return GSOCK_NOERROR;
 655 }
 656
 657 GSocketError GSocket::SetPeer(GAddress *address)
 658 {
 659   assert(this);
 660
 661   /* check address */
 662   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 663   {
 664     m_error = GSOCK_INVADDR;
 665     return GSOCK_INVADDR;
 666   }
 667
 668   if (m_peer)
 669     GAddress_destroy(m_peer);
 670
 671   m_peer = GAddress_copy(address);
 672
 673   return GSOCK_NOERROR;
 674 }
 675
 676 GAddress *GSocket::GetLocal()
 677 {
 678   GAddress *address;
 679   struct sockaddr addr;
 680   WX_SOCKLEN_T size = sizeof(addr);
 681   GSocketError err;
 682
 683   assert(this);
 684
 685   /* try to get it from the m_local var first */
 686   if (m_local)
 687     return GAddress_copy(m_local);
 688
 689   /* else, if the socket is initialized, try getsockname */
 690   if (m_fd == INVALID_SOCKET)
 691   {
 692     m_error = GSOCK_INVSOCK;
 693     return NULL;
 694   }
 695
 696   if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0)
 697   {
 698     m_error = GSOCK_IOERR;
 699     return NULL;
 700   }
 701
 702   /* got a valid address from getsockname, create a GAddress object */
 703   address = GAddress_new();
 704   if (address == NULL)
 705   {
 706     m_error = GSOCK_MEMERR;
 707     return NULL;
 708   }
 709
 710   err = _GAddress_translate_from(address, &addr, size);
 711   if (err != GSOCK_NOERROR)
 712   {
 713     GAddress_destroy(address);
 714     m_error = err;
 715     return NULL;
 716   }
 717
 718   return address;
 719 }
 720
 721 GAddress *GSocket::GetPeer()
 722 {
 723   assert(this);
 724
 725   /* try to get it from the m_peer var */
 726   if (m_peer)
 727     return GAddress_copy(m_peer);
 728
 729   return NULL;
 730 }
 731
 732 /* Server specific parts */
 733
 734 /* GSocket_SetServer:
 735  *  Sets up this socket as a server. The local address must have been
 736  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 737  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 738  *
 739  *  Error codes:
 740  *    GSOCK_INVSOCK - the socket is in use.
 741  *    GSOCK_INVADDR - the local address has not been set.
 742  *    GSOCK_IOERR   - low-level error.
 743  */
 744 GSocketError GSocket::SetServer()
 745 {
 746   int arg = 1;
 747
 748   assert(this);
 749
 750   /* must not be in use */
 751   if (m_fd != INVALID_SOCKET)
 752   {
 753     m_error = GSOCK_INVSOCK;
 754     return GSOCK_INVSOCK;
 755   }
 756
 757   /* the local addr must have been set */
 758   if (!m_local)
 759   {
 760     m_error = GSOCK_INVADDR;
 761     return GSOCK_INVADDR;
 762   }
 763
 764   /* Initialize all fields */
 765   m_stream   = true;
 766   m_server   = true;
 767
 768   /* Create the socket */
 769   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 770
 771   if (m_fd == INVALID_SOCKET)
 772   {
 773     m_error = GSOCK_IOERR;
 774     return GSOCK_IOERR;
 775   }
 776
 777   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 778 #ifdef SO_NOSIGPIPE
 779   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
 780 #endif
 781
 782   ioctl(m_fd, FIONBIO, &arg);
 783   gs_gui_functions->Enable_Events(this);
 784
 785   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 786      state after being previously closed.
 787    */
 788   if (m_reusable)
 789   {
 790     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
 791 #ifdef SO_REUSEPORT
 792     setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
 793 #endif
 794   }
 795
 796   /* Bind to the local address,
 797    * retrieve the actual address bound,
 798    * and listen up to 5 connections.
 799    */
 800   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 801       (getsockname(m_fd,
 802                    m_local->m_addr,
 803                    (WX_SOCKLEN_T *) &m_local->m_len) != 0) ||
 804       (listen(m_fd, 5) != 0))
 805   {
 806     Close();
 807     m_error = GSOCK_IOERR;
 808     return GSOCK_IOERR;
 809   }
 810
 811   return GSOCK_NOERROR;
 812 }
 813
 814 /* GSocket_WaitConnection:
 815  *  Waits for an incoming client connection. Returns a pointer to
 816  *  a GSocket object, or NULL if there was an error, in which case
 817  *  the last error field will be updated for the calling GSocket.
 818  *
 819  *  Error codes (set in the calling GSocket)
 820  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 821  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 822  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 823  *    GSOCK_MEMERR     - couldn't allocate memory.
 824  *    GSOCK_IOERR      - low-level error.
 825  */
 826 GSocket *GSocket::WaitConnection()
 827 {
 828   struct sockaddr from;
 829   WX_SOCKLEN_T fromlen = sizeof(from);
 830   GSocket *connection;
 831   GSocketError err;
 832   int arg = 1;
 833
 834   assert(this);
 835
 836   /* If the socket has already been created, we exit immediately */
 837   if (m_fd == INVALID_SOCKET || !m_server)
 838   {
 839     m_error = GSOCK_INVSOCK;
 840     return NULL;
 841   }
 842
 843   /* Create a GSocket object for the new connection */
 844   connection = GSocket_new();
 845
 846   if (!connection)
 847   {
 848     m_error = GSOCK_MEMERR;
 849     return NULL;
 850   }
 851
 852   /* Wait for a connection (with timeout) */
 853   if (Input_Timeout() == GSOCK_TIMEDOUT)
 854   {
 855     delete connection;
 856     /* m_error set by _GSocket_Input_Timeout */
 857     return NULL;
 858   }
 859
 860   connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen);
 861
 862   /* Reenable CONNECTION events */
 863   Enable(GSOCK_CONNECTION);
 864
 865   if (connection->m_fd == INVALID_SOCKET)
 866   {
 867     if (errno == EWOULDBLOCK)
 868       m_error = GSOCK_WOULDBLOCK;
 869     else
 870       m_error = GSOCK_IOERR;
 871
 872     delete connection;
 873     return NULL;
 874   }
 875
 876   /* Initialize all fields */
 877   connection->m_server   = false;
 878   connection->m_stream   = true;
 879
 880   /* Setup the peer address field */
 881   connection->m_peer = GAddress_new();
 882   if (!connection->m_peer)
 883   {
 884     delete connection;
 885     m_error = GSOCK_MEMERR;
 886     return NULL;
 887   }
 888
 889   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 890   if (err != GSOCK_NOERROR)
 891   {
 892     delete connection;
 893     m_error = err;
 894     return NULL;
 895   }
 896
 897 #if defined(__EMX__) || defined(__VISAGECPP__)
 898   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 899 #else
 900   ioctl(connection->m_fd, FIONBIO, &arg);
 901 #endif
 902   gs_gui_functions->Enable_Events(connection);
 903
 904   return connection;
 905 }
 906
 907 bool GSocket::SetReusable()
 908 {
 909     /* socket must not be null, and must not be in use/already bound */
 910     if (this && m_fd == INVALID_SOCKET)
 911     {
 912         m_reusable = true;
 913
 914         return true;
 915     }
 916
 917     return false;
 918 }
 919
 920 bool GSocket::SetBroadcast()
 921 {
 922     /* socket must not be in use/already bound */
 923     if (m_fd == INVALID_SOCKET) {
 924         m_broadcast = true;
 925         return true;
 926     }
 927     return false;
 928 }
 929
 930 bool GSocket::DontDoBind()
 931 {
 932     /* socket must not be in use/already bound */
 933     if (m_fd == INVALID_SOCKET) {
 934         m_dobind = false;
 935         return true;
 936     }
 937     return false;
 938 }
 939
 940 /* Client specific parts */
 941
 942 /* GSocket_Connect:
 943  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 944  *  to establish a client connection to a server using the peer address
 945  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 946  *  connection has been successfully established, or one of the error
 947  *  codes listed below. Note that for nonblocking sockets, a return
 948  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 949  *  request can be completed later; you should use GSocket_Select()
 950  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 951  *  corresponding asynchronous events.
 952  *
 953  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 954  *  just sets the peer address established with GSocket_SetPeer() as
 955  *  default destination.
 956  *
 957  *  Error codes:
 958  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 959  *    GSOCK_INVADDR    - the peer address has not been established.
 960  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 961  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 962  *    GSOCK_MEMERR     - couldn't allocate memory.
 963  *    GSOCK_IOERR      - low-level error.
 964  */
 965 GSocketError GSocket::Connect(GSocketStream stream)
 966 {
 967   int err, ret;
 968   int arg = 1;
 969
 970   assert(this);
 971
 972   /* Enable CONNECTION events (needed for nonblocking connections) */
 973   Enable(GSOCK_CONNECTION);
 974
 975   if (m_fd != INVALID_SOCKET)
 976   {
 977     m_error = GSOCK_INVSOCK;
 978     return GSOCK_INVSOCK;
 979   }
 980
 981   if (!m_peer)
 982   {
 983     m_error = GSOCK_INVADDR;
 984     return GSOCK_INVADDR;
 985   }
 986
 987   /* Streamed or dgram socket? */
 988   m_stream   = (stream == GSOCK_STREAMED);
 989   m_server   = false;
 990   m_establishing = false;
 991
 992   /* Create the socket */
 993   m_fd = socket(m_peer->m_realfamily,
 994                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 995
 996   if (m_fd == INVALID_SOCKET)
 997   {
 998     m_error = GSOCK_IOERR;
 999     return GSOCK_IOERR;
1000   }
1001
1002   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
1003 #ifdef SO_NOSIGPIPE
1004   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
1005 #endif
1006
1007 #if defined(__EMX__) || defined(__VISAGECPP__)
1008   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
1009 #else
1010   ioctl(m_fd, FIONBIO, &arg);
1011 #endif
1012
1013   // If the reuse flag is set, use the applicable socket reuse flags(s)
1014   if (m_reusable)
1015   {
1016     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
1017 #ifdef SO_REUSEPORT
1018     setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
1019 #endif
1020   }
1021
1022   // If a local address has been set, then we need to bind to it before calling connect
1023   if (m_local && m_local->m_addr)
1024   {
1025      bind(m_fd, m_local->m_addr, m_local->m_len);
1026   }
1027
1028   /* Connect it to the peer address, with a timeout (see below) */
1029   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
1030
1031   /* We only call Enable_Events if we know we aren't shutting down the socket.
1032    * NB: Enable_Events needs to be called whether the socket is blocking or
1033    * non-blocking, it just shouldn't be called prior to knowing there is a
1034    * connection _if_ blocking sockets are being used.
1035    * If connect above returns 0, we are already connected and need to make the
1036    * call to Enable_Events now.
1037    */
1038
1039   if (m_non_blocking || ret == 0)
1040     gs_gui_functions->Enable_Events(this);
1041
1042   if (ret == -1)
1043   {
1044     err = errno;
1045
1046     /* If connect failed with EINPROGRESS and the GSocket object
1047      * is in blocking mode, we select() for the specified timeout
1048      * checking for writability to see if the connection request
1049      * completes.
1050      */
1051     if ((err == EINPROGRESS) && (!m_non_blocking))
1052     {
1053       if (Output_Timeout() == GSOCK_TIMEDOUT)
1054       {
1055         Close();
1056         /* m_error is set in _GSocket_Output_Timeout */
1057         return GSOCK_TIMEDOUT;
1058       }
1059       else
1060       {
1061         int error;
1062         SOCKOPTLEN_T len = sizeof(error);
1063
1064         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
1065
1066         gs_gui_functions->Enable_Events(this);
1067
1068         if (!error)
1069           return GSOCK_NOERROR;
1070       }
1071     }
1072
1073     /* If connect failed with EINPROGRESS and the GSocket object
1074      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
1075      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
1076      * this way if the connection completes, a GSOCK_CONNECTION
1077      * event will be generated, if enabled.
1078      */
1079     if ((err == EINPROGRESS) && (m_non_blocking))
1080     {
1081       m_establishing = true;
1082       m_error = GSOCK_WOULDBLOCK;
1083       return GSOCK_WOULDBLOCK;
1084     }
1085
1086     /* If connect failed with an error other than EINPROGRESS,
1087      * then the call to GSocket_Connect has failed.
1088      */
1089     Close();
1090     m_error = GSOCK_IOERR;
1091
1092     return GSOCK_IOERR;
1093   }
1094
1095   return GSOCK_NOERROR;
1096 }
1097
1098 /* Datagram sockets */
1099
1100 /* GSocket_SetNonOriented:
1101  *  Sets up this socket as a non-connection oriented (datagram) socket.
1102  *  Before using this function, the local address must have been set
1103  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
1104  *  on success, or one of the following otherwise.
1105  *
1106  *  Error codes:
1107  *    GSOCK_INVSOCK - the socket is in use.
1108  *    GSOCK_INVADDR - the local address has not been set.
1109  *    GSOCK_IOERR   - low-level error.
1110  */
1111 GSocketError GSocket::SetNonOriented()
1112 {
1113   int arg = 1;
1114
1115   assert(this);
1116
1117   if (m_fd != INVALID_SOCKET)
1118   {
1119     m_error = GSOCK_INVSOCK;
1120     return GSOCK_INVSOCK;
1121   }
1122
1123   if (!m_local)
1124   {
1125     m_error = GSOCK_INVADDR;
1126     return GSOCK_INVADDR;
1127   }
1128
1129   /* Initialize all fields */
1130   m_stream   = false;
1131   m_server   = false;
1132
1133   /* Create the socket */
1134   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
1135
1136   if (m_fd == INVALID_SOCKET)
1137   {
1138     m_error = GSOCK_IOERR;
1139     return GSOCK_IOERR;
1140   }
1141 #if defined(__EMX__) || defined(__VISAGECPP__)
1142   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
1143 #else
1144   ioctl(m_fd, FIONBIO, &arg);
1145 #endif
1146   gs_gui_functions->Enable_Events(this);
1147
1148   if (m_reusable)
1149   {
1150     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
1151 #ifdef SO_REUSEPORT
1152     setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
1153 #endif
1154   }
1155
1156   if (m_broadcast)
1157   {
1158     setsockopt(m_fd, SOL_SOCKET, SO_BROADCAST, (const char*)&arg, sizeof(arg));
1159   }
1160   if (m_dobind)
1161   {
1162       /* Bind to the local address,
1163        * and retrieve the actual address bound.
1164        */
1165       if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
1166           (getsockname(m_fd,
1167                        m_local->m_addr,
1168                        (WX_SOCKLEN_T *) &m_local->m_len) != 0))
1169       {
1170         Close();
1171         m_error = GSOCK_IOERR;
1172         return GSOCK_IOERR;
1173       }
1174   }
1175   return GSOCK_NOERROR;
1176 }
1177
1178 /* Generic IO */
1179
1180 /* Like recv(), send(), ... */
1181 int GSocket::Read(char *buffer, int size)
1182 {
1183   int ret;
1184
1185   assert(this);
1186
1187   if (m_fd == INVALID_SOCKET || m_server)
1188   {
1189     m_error = GSOCK_INVSOCK;
1190     return -1;
1191   }
1192
1193   /* Disable events during query of socket status */
1194   Disable(GSOCK_INPUT);
1195
1196   /* If the socket is blocking, wait for data (with a timeout) */
1197   if (Input_Timeout() == GSOCK_TIMEDOUT) {
1198     m_error = GSOCK_TIMEDOUT;
1199     /* Don't return here immediately, otherwise socket events would not be
1200      * re-enabled! */
1201     ret = -1;
1202   }
1203   else
1204   {
1205     /* Read the data */
1206     if (m_stream)
1207       ret = Recv_Stream(buffer, size);
1208     else
1209       ret = Recv_Dgram(buffer, size);
1210
1211     /* If recv returned zero, then the connection has been gracefully closed.
1212      * Otherwise, recv has returned an error (-1), in which case we have lost the
1213      * socket only if errno does _not_ indicate that there may be more data to read.
1214      */
1215     if (ret == 0)
1216     {
1217       /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
1218       m_detected = GSOCK_LOST_FLAG;
1219       Detected_Read();
1220       return 0;
1221     }
1222     else if (ret == -1)
1223     {
1224       if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1225         m_error = GSOCK_WOULDBLOCK;
1226       else
1227         m_error = GSOCK_IOERR;
1228     }
1229   }
1230
1231   /* Enable events again now that we are done processing */
1232   Enable(GSOCK_INPUT);
1233
1234   return ret;
1235 }
1236
1237 int GSocket::Write(const char *buffer, int size)
1238 {
1239   int ret;
1240
1241   assert(this);
1242
1243   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
1244
1245   if (m_fd == INVALID_SOCKET || m_server)
1246   {
1247     m_error = GSOCK_INVSOCK;
1248     return -1;
1249   }
1250
1251   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
1252
1253   /* If the socket is blocking, wait for writability (with a timeout) */
1254   if (Output_Timeout() == GSOCK_TIMEDOUT)
1255     return -1;
1256
1257   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
1258
1259   /* Write the data */
1260   if (m_stream)
1261     ret = Send_Stream(buffer, size);
1262   else
1263     ret = Send_Dgram(buffer, size);
1264
1265   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
1266
1267   if (ret == -1)
1268   {
1269     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1270     {
1271       m_error = GSOCK_WOULDBLOCK;
1272       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
1273     }
1274     else
1275     {
1276       m_error = GSOCK_IOERR;
1277       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
1278     }
1279
1280     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
1281      * in MSW). Once the first OUTPUT event is received, users can assume
1282      * that the socket is writable until a read operation fails. Only then
1283      * will further OUTPUT events be posted.
1284      */
1285     Enable(GSOCK_OUTPUT);
1286
1287     return -1;
1288   }
1289
1290   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
1291
1292   return ret;
1293 }
1294
1295 /* GSocket_Select:
1296  *  Polls the socket to determine its status. This function will
1297  *  check for the events specified in the 'flags' parameter, and
1298  *  it will return a mask indicating which operations can be
1299  *  performed. This function won't block, regardless of the
1300  *  mode (blocking | nonblocking) of the socket.
1301  */
1302 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
1303 {
1304   if (!gs_gui_functions->CanUseEventLoop())
1305   {
1306
1307     GSocketEventFlags result = 0;
1308     fd_set readfds;
1309     fd_set writefds;
1310     fd_set exceptfds;
1311     struct timeval tv;
1312
1313     assert(this);
1314
1315     if (m_fd == -1)
1316         return (GSOCK_LOST_FLAG & flags);
1317
1318     /* Do not use a static struct, Linux can garble it */
1319     tv.tv_sec = m_timeout / 1000;
1320     tv.tv_usec = (m_timeout % 1000) * 1000;
1321
1322     wxFD_ZERO(&readfds);
1323     wxFD_ZERO(&writefds);
1324     wxFD_ZERO(&exceptfds);
1325     wxFD_SET(m_fd, &readfds);
1326     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
1327       wxFD_SET(m_fd, &writefds);
1328     wxFD_SET(m_fd, &exceptfds);
1329
1330     /* Check 'sticky' CONNECTION flag first */
1331     result |= (GSOCK_CONNECTION_FLAG & m_detected);
1332
1333     /* If we have already detected a LOST event, then don't try
1334      * to do any further processing.
1335      */
1336     if ((m_detected & GSOCK_LOST_FLAG) != 0)
1337     {
1338       m_establishing = false;
1339
1340       return (GSOCK_LOST_FLAG & flags);
1341     }
1342
1343     /* Try select now */
1344     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
1345     {
1346       /* What to do here? */
1347       return (result & flags);
1348     }
1349
1350     /* Check for exceptions and errors */
1351     if (wxFD_ISSET(m_fd, &exceptfds))
1352     {
1353       m_establishing = false;
1354       m_detected = GSOCK_LOST_FLAG;
1355
1356       /* LOST event: Abort any further processing */
1357       return (GSOCK_LOST_FLAG & flags);
1358     }
1359
1360     /* Check for readability */
1361     if (wxFD_ISSET(m_fd, &readfds))
1362     {
1363       result |= GSOCK_INPUT_FLAG;
1364
1365       if (m_server && m_stream)
1366       {
1367         /* This is a TCP server socket that detected a connection.
1368           While the INPUT_FLAG is also set, it doesn't matter on
1369           this kind of  sockets, as we can only Accept() from them. */
1370         result |= GSOCK_CONNECTION_FLAG;
1371         m_detected |= GSOCK_CONNECTION_FLAG;
1372       }
1373     }
1374
1375     /* Check for writability */
1376     if (wxFD_ISSET(m_fd, &writefds))
1377     {
1378       if (m_establishing && !m_server)
1379       {
1380         int error;
1381         SOCKOPTLEN_T len = sizeof(error);
1382
1383         m_establishing = false;
1384
1385         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1386
1387         if (error)
1388         {
1389           m_detected = GSOCK_LOST_FLAG;
1390
1391           /* LOST event: Abort any further processing */
1392           return (GSOCK_LOST_FLAG & flags);
1393         }
1394         else
1395         {
1396           result |= GSOCK_CONNECTION_FLAG;
1397           m_detected |= GSOCK_CONNECTION_FLAG;
1398         }
1399       }
1400       else
1401       {
1402         result |= GSOCK_OUTPUT_FLAG;
1403       }
1404     }
1405
1406     return (result & flags);
1407
1408   }
1409   else
1410   {
1411     assert(this);
1412     return flags & m_detected;
1413   }
1414 }
1415
1416 /* Flags */
1417
1418 /* GSocket_SetNonBlocking:
1419  *  Sets the socket to non-blocking mode. All IO calls will return
1420  *  immediately.
1421  */
1422 void GSocket::SetNonBlocking(bool non_block)
1423 {
1424   assert(this);
1425
1426   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1427
1428   m_non_blocking = non_block;
1429 }
1430
1431 /* GSocket_SetTimeout:
1432  *  Sets the timeout for blocking calls. Time is expressed in
1433  *  milliseconds.
1434  */
1435 void GSocket::SetTimeout(unsigned long millisec)
1436 {
1437   assert(this);
1438
1439   m_timeout = millisec;
1440 }
1441
1442 /* GSocket_GetError:
1443  *  Returns the last error occurred for this socket. Note that successful
1444  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1445  *  after an error.
1446  */
1447 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1448 {
1449   assert(this);
1450
1451   return m_error;
1452 }
1453
1454 /* Callbacks */
1455
1456 /* GSOCK_INPUT:
1457  *   There is data to be read in the input buffer. If, after a read
1458  *   operation, there is still data available, the callback function will
1459  *   be called again.
1460  * GSOCK_OUTPUT:
1461  *   The socket is available for writing. That is, the next write call
1462  *   won't block. This event is generated only once, when the connection is
1463  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1464  *   when the output buffer empties again. This means that the app should
1465  *   assume that it can write since the first OUTPUT event, and no more
1466  *   OUTPUT events will be generated unless an error occurs.
1467  * GSOCK_CONNECTION:
1468  *   Connection successfully established, for client sockets, or incoming
1469  *   client connection, for server sockets. Wait for this event (also watch
1470  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1471  * GSOCK_LOST:
1472  *   The connection is lost (or a connection request failed); this could
1473  *   be due to a failure, or due to the peer closing it gracefully.
1474  */
1475
1476 /* GSocket_SetCallback:
1477  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1478  *  may be a combination of flags OR'ed toghether, so the same
1479  *  callback function can be made to accept different events.
1480  *  The callback function must have the following prototype:
1481  *
1482  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1483  */
1484 void GSocket::SetCallback(GSocketEventFlags flags,
1485                          GSocketCallback callback, char *cdata)
1486 {
1487   int count;
1488
1489   assert(this);
1490
1491   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1492   {
1493     if ((flags & (1 << count)) != 0)
1494     {
1495       m_cbacks[count] = callback;
1496       m_data[count] = cdata;
1497     }
1498   }
1499 }
1500
1501 /* GSocket_UnsetCallback:
1502  *  Disables all callbacks specified by 'flags', which may be a
1503  *  combination of flags OR'ed toghether.
1504  */
1505 void GSocket::UnsetCallback(GSocketEventFlags flags)
1506 {
1507   int count;
1508
1509   assert(this);
1510
1511   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1512   {
1513     if ((flags & (1 << count)) != 0)
1514     {
1515       m_cbacks[count] = NULL;
1516       m_data[count] = NULL;
1517     }
1518   }
1519 }
1520
1521 GSocketError GSocket::GetSockOpt(int level, int optname,
1522                                 void *optval, int *optlen)
1523 {
1524     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1525         return GSOCK_NOERROR;
1526
1527     return GSOCK_OPTERR;
1528 }
1529
1530 GSocketError GSocket::SetSockOpt(int level, int optname,
1531                                 const void *optval, int optlen)
1532 {
1533     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1534         return GSOCK_NOERROR;
1535
1536     return GSOCK_OPTERR;
1537 }
1538
1539 #define CALL_CALLBACK(socket, event) {                                  \
1540   socket->Disable(event);                                               \
1541   if (socket->m_cbacks[event])                                          \
1542     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1543 }
1544
1545
1546 void GSocket::Enable(GSocketEvent event)
1547 {
1548   m_detected &= ~(1 << event);
1549   gs_gui_functions->Install_Callback(this, event);
1550 }
1551
1552 void GSocket::Disable(GSocketEvent event)
1553 {
1554   m_detected |= (1 << event);
1555   gs_gui_functions->Uninstall_Callback(this, event);
1556 }
1557
1558 /* _GSocket_Input_Timeout:
1559  *  For blocking sockets, wait until data is available or
1560  *  until timeout ellapses.
1561  */
1562 GSocketError GSocket::Input_Timeout()
1563 {
1564   struct timeval tv;
1565   fd_set readfds;
1566   int ret;
1567
1568   /* Linux select() will overwrite the struct on return */
1569   tv.tv_sec  = (m_timeout / 1000);
1570   tv.tv_usec = (m_timeout % 1000) * 1000;
1571
1572   if (!m_non_blocking)
1573   {
1574     wxFD_ZERO(&readfds);
1575     wxFD_SET(m_fd, &readfds);
1576     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1577     if (ret == 0)
1578     {
1579       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1580       m_error = GSOCK_TIMEDOUT;
1581       return GSOCK_TIMEDOUT;
1582     }
1583
1584     if (ret == -1)
1585     {
1586       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1587       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1588       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1589       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1590       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1591       m_error = GSOCK_TIMEDOUT;
1592       return GSOCK_TIMEDOUT;
1593     }
1594   }
1595
1596   return GSOCK_NOERROR;
1597 }
1598
1599 /* _GSocket_Output_Timeout:
1600  *  For blocking sockets, wait until data can be sent without
1601  *  blocking or until timeout ellapses.
1602  */
1603 GSocketError GSocket::Output_Timeout()
1604 {
1605   struct timeval tv;
1606   fd_set writefds;
1607   int ret;
1608
1609   /* Linux select() will overwrite the struct on return */
1610   tv.tv_sec  = (m_timeout / 1000);
1611   tv.tv_usec = (m_timeout % 1000) * 1000;
1612
1613   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1614
1615   if (!m_non_blocking)
1616   {
1617     wxFD_ZERO(&writefds);
1618     wxFD_SET(m_fd, &writefds);
1619     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1620     if (ret == 0)
1621     {
1622       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1623       m_error = GSOCK_TIMEDOUT;
1624       return GSOCK_TIMEDOUT;
1625     }
1626
1627     if (ret == -1)
1628     {
1629       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1630       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1631       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1632       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1633       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1634       m_error = GSOCK_TIMEDOUT;
1635       return GSOCK_TIMEDOUT;
1636     }
1637
1638     if ( ! wxFD_ISSET(m_fd, &writefds) )
1639     {
1640         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1641     }
1642     else
1643     {
1644         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1645     }
1646   }
1647   else
1648   {
1649     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1650   }
1651
1652   return GSOCK_NOERROR;
1653 }
1654
1655 int GSocket::Recv_Stream(char *buffer, int size)
1656 {
1657   int ret;
1658   do
1659   {
1660     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1661   }
1662   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1663
1664   return ret;
1665 }
1666
1667 int GSocket::Recv_Dgram(char *buffer, int size)
1668 {
1669   struct sockaddr from;
1670   WX_SOCKLEN_T fromlen = sizeof(from);
1671   int ret;
1672   GSocketError err;
1673
1674   fromlen = sizeof(from);
1675
1676   do
1677   {
1678     ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
1679   }
1680   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1681
1682   if (ret == -1)
1683     return -1;
1684
1685   /* Translate a system address into a GSocket address */
1686   if (!m_peer)
1687   {
1688     m_peer = GAddress_new();
1689     if (!m_peer)
1690     {
1691       m_error = GSOCK_MEMERR;
1692       return -1;
1693     }
1694   }
1695
1696   err = _GAddress_translate_from(m_peer, &from, fromlen);
1697   if (err != GSOCK_NOERROR)
1698   {
1699     GAddress_destroy(m_peer);
1700     m_peer  = NULL;
1701     m_error = err;
1702     return -1;
1703   }
1704
1705   return ret;
1706 }
1707
1708 int GSocket::Send_Stream(const char *buffer, int size)
1709 {
1710   int ret;
1711
1712   MASK_SIGNAL();
1713
1714   do
1715   {
1716     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1717   }
1718   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1719
1720   UNMASK_SIGNAL();
1721
1722   return ret;
1723 }
1724
1725 int GSocket::Send_Dgram(const char *buffer, int size)
1726 {
1727   struct sockaddr *addr;
1728   int len, ret;
1729   GSocketError err;
1730
1731   if (!m_peer)
1732   {
1733     m_error = GSOCK_INVADDR;
1734     return -1;
1735   }
1736
1737   err = _GAddress_translate_to(m_peer, &addr, &len);
1738   if (err != GSOCK_NOERROR)
1739   {
1740     m_error = err;
1741     return -1;
1742   }
1743
1744   MASK_SIGNAL();
1745
1746   do
1747   {
1748     ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1749   }
1750   while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1751
1752   UNMASK_SIGNAL();
1753
1754   /* Frees memory allocated from _GAddress_translate_to */
1755   free(addr);
1756
1757   return ret;
1758 }
1759
1760 void GSocket::Detected_Read()
1761 {
1762   char c;
1763
1764   /* Safeguard against straggling call to Detected_Read */
1765   if (m_fd == INVALID_SOCKET)
1766   {
1767     return;
1768   }
1769
1770   /* If we have already detected a LOST event, then don't try
1771    * to do any further processing.
1772    */
1773   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1774   {
1775     m_establishing = false;
1776
1777     CALL_CALLBACK(this, GSOCK_LOST);
1778     Shutdown();
1779     return;
1780   }
1781
1782   int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1783
1784   if (num > 0)
1785   {
1786     CALL_CALLBACK(this, GSOCK_INPUT);
1787   }
1788   else
1789   {
1790     if (m_server && m_stream)
1791     {
1792       CALL_CALLBACK(this, GSOCK_CONNECTION);
1793     }
1794     else if (num == 0)
1795     {
1796       /* graceful shutdown */
1797       CALL_CALLBACK(this, GSOCK_LOST);
1798       Shutdown();
1799     }
1800     else
1801     {
1802       /* Do not throw a lost event in cases where the socket isn't really lost */
1803       if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1804       {
1805         CALL_CALLBACK(this, GSOCK_INPUT);
1806       }
1807       else
1808       {
1809         CALL_CALLBACK(this, GSOCK_LOST);
1810         Shutdown();
1811       }
1812     }
1813   }
1814 }
1815
1816 void GSocket::Detected_Write()
1817 {
1818   /* If we have already detected a LOST event, then don't try
1819    * to do any further processing.
1820    */
1821   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1822   {
1823     m_establishing = false;
1824
1825     CALL_CALLBACK(this, GSOCK_LOST);
1826     Shutdown();
1827     return;
1828   }
1829
1830   if (m_establishing && !m_server)
1831   {
1832     int error;
1833     SOCKOPTLEN_T len = sizeof(error);
1834
1835     m_establishing = false;
1836
1837     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1838
1839     if (error)
1840     {
1841       CALL_CALLBACK(this, GSOCK_LOST);
1842       Shutdown();
1843     }
1844     else
1845     {
1846       CALL_CALLBACK(this, GSOCK_CONNECTION);
1847       /* We have to fire this event by hand because CONNECTION (for clients)
1848        * and OUTPUT are internally the same and we just disabled CONNECTION
1849        * events with the above macro.
1850        */
1851       CALL_CALLBACK(this, GSOCK_OUTPUT);
1852     }
1853   }
1854   else
1855   {
1856     CALL_CALLBACK(this, GSOCK_OUTPUT);
1857   }
1858 }
1859
1860 /* Compatibility functions for GSocket */
1861 GSocket *GSocket_new(void)
1862 {
1863     GSocket *newsocket = new GSocket();
1864     if (newsocket->IsOk())
1865         return newsocket;
1866
1867     delete newsocket;
1868
1869     return NULL;
1870 }
1871
1872 /*
1873  * -------------------------------------------------------------------------
1874  * GAddress
1875  * -------------------------------------------------------------------------
1876  */
1877
1878 /* CHECK_ADDRESS verifies that the current address family is either
1879  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1880  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1881  * an appropiate error code.
1882  *
1883  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1884  */
1885 #define CHECK_ADDRESS(address, family)                              \
1886 {                                                                   \
1887   if (address->m_family == GSOCK_NOFAMILY)                          \
1888     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1889       return address->m_error;                                      \
1890   if (address->m_family != GSOCK_##family)                          \
1891   {                                                                 \
1892     address->m_error = GSOCK_INVADDR;                               \
1893     return GSOCK_INVADDR;                                           \
1894   }                                                                 \
1895 }
1896
1897 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1898 {                                                                   \
1899   if (address->m_family == GSOCK_NOFAMILY)                          \
1900     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1901       return retval;                                                \
1902   if (address->m_family != GSOCK_##family)                          \
1903   {                                                                 \
1904     address->m_error = GSOCK_INVADDR;                               \
1905     return retval;                                                  \
1906   }                                                                 \
1907 }
1908
1909
1910 GAddress *GAddress_new(void)
1911 {
1912   GAddress *address;
1913
1914   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1915     return NULL;
1916
1917   address->m_family  = GSOCK_NOFAMILY;
1918   address->m_addr    = NULL;
1919   address->m_len     = 0;
1920
1921   return address;
1922 }
1923
1924 GAddress *GAddress_copy(GAddress *address)
1925 {
1926   GAddress *addr2;
1927
1928   assert(address != NULL);
1929
1930   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1931     return NULL;
1932
1933   memcpy(addr2, address, sizeof(GAddress));
1934
1935   if (address->m_addr && address->m_len > 0)
1936   {
1937     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1938     if (addr2->m_addr == NULL)
1939     {
1940       free(addr2);
1941       return NULL;
1942     }
1943     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1944   }
1945
1946   return addr2;
1947 }
1948
1949 void GAddress_destroy(GAddress *address)
1950 {
1951   assert(address != NULL);
1952
1953   if (address->m_addr)
1954     free(address->m_addr);
1955
1956   free(address);
1957 }
1958
1959 void GAddress_SetFamily(GAddress *address, GAddressType type)
1960 {
1961   assert(address != NULL);
1962
1963   address->m_family = type;
1964 }
1965
1966 GAddressType GAddress_GetFamily(GAddress *address)
1967 {
1968   assert(address != NULL);
1969
1970   return address->m_family;
1971 }
1972
1973 GSocketError _GAddress_translate_from(GAddress *address,
1974                                       struct sockaddr *addr, int len)
1975 {
1976   address->m_realfamily = addr->sa_family;
1977   switch (addr->sa_family)
1978   {
1979     case AF_INET:
1980       address->m_family = GSOCK_INET;
1981       break;
1982     case AF_UNIX:
1983       address->m_family = GSOCK_UNIX;
1984       break;
1985 #ifdef AF_INET6
1986     case AF_INET6:
1987       address->m_family = GSOCK_INET6;
1988       break;
1989 #endif
1990     default:
1991     {
1992       address->m_error = GSOCK_INVOP;
1993       return GSOCK_INVOP;
1994     }
1995   }
1996
1997   if (address->m_addr)
1998     free(address->m_addr);
1999
2000   address->m_len  = len;
2001   address->m_addr = (struct sockaddr *)malloc(len);
2002
2003   if (address->m_addr == NULL)
2004   {
2005     address->m_error = GSOCK_MEMERR;
2006     return GSOCK_MEMERR;
2007   }
2008
2009   memcpy(address->m_addr, addr, len);
2010
2011   return GSOCK_NOERROR;
2012 }
2013
2014 GSocketError _GAddress_translate_to(GAddress *address,
2015                                     struct sockaddr **addr, int *len)
2016 {
2017   if (!address->m_addr)
2018   {
2019     address->m_error = GSOCK_INVADDR;
2020     return GSOCK_INVADDR;
2021   }
2022
2023   *len = address->m_len;
2024   *addr = (struct sockaddr *)malloc(address->m_len);
2025   if (*addr == NULL)
2026   {
2027     address->m_error = GSOCK_MEMERR;
2028     return GSOCK_MEMERR;
2029   }
2030
2031   memcpy(*addr, address->m_addr, address->m_len);
2032   return GSOCK_NOERROR;
2033 }
2034
2035 /*
2036  * -------------------------------------------------------------------------
2037  * Internet address family
2038  * -------------------------------------------------------------------------
2039  */
2040
2041 GSocketError _GAddress_Init_INET(GAddress *address)
2042 {
2043   address->m_len  = sizeof(struct sockaddr_in);
2044   address->m_addr = (struct sockaddr *) malloc(address->m_len);
2045   if (address->m_addr == NULL)
2046   {
2047     address->m_error = GSOCK_MEMERR;
2048     return GSOCK_MEMERR;
2049   }
2050
2051   address->m_family = GSOCK_INET;
2052   address->m_realfamily = PF_INET;
2053   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
2054   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
2055
2056   return GSOCK_NOERROR;
2057 }
2058
2059 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
2060 {
2061   struct hostent *he;
2062   struct in_addr *addr;
2063
2064   assert(address != NULL);
2065
2066   CHECK_ADDRESS(address, INET);
2067
2068   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
2069
2070   /* If it is a numeric host name, convert it now */
2071 #if defined(HAVE_INET_ATON)
2072   if (inet_aton(hostname, addr) == 0)
2073   {
2074 #elif defined(HAVE_INET_ADDR)
2075   if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
2076   {
2077 #else
2078   /* Use gethostbyname by default */
2079 #ifndef __WXMAC__
2080   int val = 1;  /* VA doesn't like constants in conditional expressions */
2081   if (val)
2082 #endif
2083   {
2084 #endif
2085     struct in_addr *array_addr;
2086
2087     /* It is a real name, we solve it */
2088     struct hostent h;
2089 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2090     struct hostent_data buffer;
2091 #else
2092     char buffer[1024];
2093 #endif
2094     int err;
2095     he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
2096     if (he == NULL)
2097     {
2098       /* Reset to invalid address */
2099       addr->s_addr = INADDR_NONE;
2100       address->m_error = GSOCK_NOHOST;
2101       return GSOCK_NOHOST;
2102     }
2103
2104     array_addr = (struct in_addr *) *(he->h_addr_list);
2105     addr->s_addr = array_addr[0].s_addr;
2106   }
2107
2108   return GSOCK_NOERROR;
2109 }
2110
2111
2112 GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
2113 {
2114   return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
2115 }
2116
2117 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
2118 {
2119   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
2120 }
2121
2122 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
2123                                           unsigned long hostaddr)
2124 {
2125   struct in_addr *addr;
2126
2127   assert(address != NULL);
2128
2129   CHECK_ADDRESS(address, INET);
2130
2131   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
2132   addr->s_addr = htonl(hostaddr);
2133
2134   return GSOCK_NOERROR;
2135 }
2136
2137 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
2138                                        const char *protocol)
2139 {
2140   struct servent *se;
2141   struct sockaddr_in *addr;
2142
2143   assert(address != NULL);
2144   CHECK_ADDRESS(address, INET);
2145
2146   if (!port)
2147   {
2148     address->m_error = GSOCK_INVPORT;
2149     return GSOCK_INVPORT;
2150   }
2151
2152 #if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
2153     struct servent_data buffer;
2154 #else
2155   char buffer[1024];
2156 #endif
2157   struct servent serv;
2158   se = wxGetservbyname_r(port, protocol, &serv,
2159                          (void*)&buffer, sizeof(buffer));
2160   if (!se)
2161   {
2162     /* the cast to int suppresses compiler warnings about subscript having the
2163        type char */
2164     if (isdigit((int)port[0]))
2165     {
2166       int port_int;
2167
2168       port_int = atoi(port);
2169       addr = (struct sockaddr_in *)address->m_addr;
2170       addr->sin_port = htons(port_int);
2171       return GSOCK_NOERROR;
2172     }
2173
2174     address->m_error = GSOCK_INVPORT;
2175     return GSOCK_INVPORT;
2176   }
2177
2178   addr = (struct sockaddr_in *)address->m_addr;
2179   addr->sin_port = se->s_port;
2180
2181   return GSOCK_NOERROR;
2182 }
2183
2184 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
2185 {
2186   struct sockaddr_in *addr;
2187
2188   assert(address != NULL);
2189   CHECK_ADDRESS(address, INET);
2190
2191   addr = (struct sockaddr_in *)address->m_addr;
2192   addr->sin_port = htons(port);
2193
2194   return GSOCK_NOERROR;
2195 }
2196
2197 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
2198 {
2199   struct hostent *he;
2200   char *addr_buf;
2201   struct sockaddr_in *addr;
2202
2203   assert(address != NULL);
2204   CHECK_ADDRESS(address, INET);
2205
2206   addr = (struct sockaddr_in *)address->m_addr;
2207   addr_buf = (char *)&(addr->sin_addr);
2208
2209   struct hostent temphost;
2210 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2211   struct hostent_data buffer;
2212 #else
2213   char buffer[1024];
2214 #endif
2215   int err;
2216   he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
2217                          (void*)&buffer, sizeof(buffer), &err);
2218   if (he == NULL)
2219   {
2220     address->m_error = GSOCK_NOHOST;
2221     return GSOCK_NOHOST;
2222   }
2223
2224   strncpy(hostname, he->h_name, sbuf);
2225
2226   return GSOCK_NOERROR;
2227 }
2228
2229 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
2230 {
2231   struct sockaddr_in *addr;
2232
2233   assert(address != NULL);
2234   CHECK_ADDRESS_RETVAL(address, INET, 0);
2235
2236   addr = (struct sockaddr_in *)address->m_addr;
2237
2238   return ntohl(addr->sin_addr.s_addr);
2239 }
2240
2241 unsigned short GAddress_INET_GetPort(GAddress *address)
2242 {
2243   struct sockaddr_in *addr;
2244
2245   assert(address != NULL);
2246   CHECK_ADDRESS_RETVAL(address, INET, 0);
2247
2248   addr = (struct sockaddr_in *)address->m_addr;
2249   return ntohs(addr->sin_port);
2250 }
2251
2252 /*
2253  * -------------------------------------------------------------------------
2254  * Unix address family
2255  * -------------------------------------------------------------------------
2256  */
2257
2258 #ifndef __VISAGECPP__
2259 GSocketError _GAddress_Init_UNIX(GAddress *address)
2260 {
2261   address->m_len  = sizeof(struct sockaddr_un);
2262   address->m_addr = (struct sockaddr *)malloc(address->m_len);
2263   if (address->m_addr == NULL)
2264   {
2265     address->m_error = GSOCK_MEMERR;
2266     return GSOCK_MEMERR;
2267   }
2268
2269   address->m_family = GSOCK_UNIX;
2270   address->m_realfamily = PF_UNIX;
2271   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
2272   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
2273
2274   return GSOCK_NOERROR;
2275 }
2276
2277 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
2278
2279 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
2280 {
2281   struct sockaddr_un *addr;
2282
2283   assert(address != NULL);
2284
2285   CHECK_ADDRESS(address, UNIX);
2286
2287   addr = ((struct sockaddr_un *)address->m_addr);
2288   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
2289   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
2290
2291   return GSOCK_NOERROR;
2292 }
2293
2294 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
2295 {
2296   struct sockaddr_un *addr;
2297
2298   assert(address != NULL);
2299   CHECK_ADDRESS(address, UNIX);
2300
2301   addr = (struct sockaddr_un *)address->m_addr;
2302
2303   strncpy(path, addr->sun_path, sbuf);
2304
2305   return GSOCK_NOERROR;
2306 }
2307 #endif  /* !defined(__VISAGECPP__) */
2308 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */