src/unix/gsocket.cpp

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