src/unix/gsocket.cpp

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