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   m_oriented = TRUE;
 460
 461   /* Create the socket */
 462   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 463
 464   if (m_fd == INVALID_SOCKET)
 465   {
 466     m_error = GSOCK_IOERR;
 467     return GSOCK_IOERR;
 468   }
 469 #if defined(__EMX__) || defined(__VISAGECPP__)
 470   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 471 #else
 472   ioctl(m_fd, FIONBIO, &arg);
 473 #endif
 474   EventLoop_Enable_Events();
 475
 476   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 477      state after being previously closed.
 478    */
 479   setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 480
 481   /* Bind to the local address,
 482    * retrieve the actual address bound,
 483    * and listen up to 5 connections.
 484    */
 485   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 486       (getsockname(m_fd,
 487                    m_local->m_addr,
 488                    (SOCKLEN_T *) &m_local->m_len) != 0) ||
 489       (listen(m_fd, 5) != 0))
 490   {
 491     Close();
 492     m_error = GSOCK_IOERR;
 493     return GSOCK_IOERR;
 494   }
 495
 496   return GSOCK_NOERROR;
 497 }
 498
 499 /* GSocket_WaitConnection:
 500  *  Waits for an incoming client connection. Returns a pointer to
 501  *  a GSocket object, or NULL if there was an error, in which case
 502  *  the last error field will be updated for the calling GSocket.
 503  *
 504  *  Error codes (set in the calling GSocket)
 505  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 506  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 507  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 508  *    GSOCK_MEMERR     - couldn't allocate memory.
 509  *    GSOCK_IOERR      - low-level error.
 510  */
 511 GSocket *GSocketBSD::WaitConnection()
 512 {
 513   struct sockaddr from;
 514   SOCKLEN_T fromlen = sizeof(from);
 515   GSocket *connection;
 516   GSocketError err;
 517   int arg = 1;
 518
 519   assert(this);
 520
 521   /* Reenable CONNECTION events */
 522   Enable(GSOCK_CONNECTION);
 523
 524   /* If the socket has already been created, we exit immediately */
 525   if (m_fd == INVALID_SOCKET || !m_server)
 526   {
 527     m_error = GSOCK_INVSOCK;
 528     return NULL;
 529   }
 530
 531   /* Create a GSocket object for the new connection */
 532   connection = GSocket_new();
 533
 534   if (!connection)
 535   {
 536     delete connection;
 537     m_error = GSOCK_MEMERR;
 538     return NULL;
 539   }
 540
 541   /* Wait for a connection (with timeout) */
 542   if (Input_Timeout() == GSOCK_TIMEDOUT)
 543   {
 544     delete connection;
 545     /* m_error set by _GSocket_Input_Timeout */
 546     return NULL;
 547   }
 548
 549   connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen);
 550
 551   if (connection->m_fd == INVALID_SOCKET)
 552   {
 553     if (errno == EWOULDBLOCK)
 554       m_error = GSOCK_WOULDBLOCK;
 555     else
 556       m_error = GSOCK_IOERR;
 557
 558     delete connection;
 559     return NULL;
 560   }
 561
 562   /* Initialize all fields */
 563   connection->m_server   = FALSE;
 564   connection->m_stream   = TRUE;
 565   connection->m_oriented = TRUE;
 566
 567   /* Setup the peer address field */
 568   connection->m_peer = GAddress_new();
 569   if (!connection->m_peer)
 570   {
 571     delete connection;
 572     m_error = GSOCK_MEMERR;
 573     return NULL;
 574   }
 575   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 576   if (err != GSOCK_NOERROR)
 577   {
 578     GAddress_destroy(connection->m_peer);
 579     delete connection;
 580     m_error = err;
 581     return NULL;
 582   }
 583 #if defined(__EMX__) || defined(__VISAGECPP__)
 584   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 585 #else
 586   ioctl(connection->m_fd, FIONBIO, &arg);
 587 #endif
 588   connection->EventLoop_Enable_Events();
 589
 590   return connection;
 591 }
 592
 593 /* Client specific parts */
 594
 595 /* GSocket_Connect:
 596  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 597  *  to establish a client connection to a server using the peer address
 598  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 599  *  connection has been succesfully established, or one of the error
 600  *  codes listed below. Note that for nonblocking sockets, a return
 601  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 602  *  request can be completed later; you should use GSocket_Select()
 603  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 604  *  corresponding asynchronous events.
 605  *
 606  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 607  *  just sets the peer address established with GSocket_SetPeer() as
 608  *  default destination.
 609  *
 610  *  Error codes:
 611  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 612  *    GSOCK_INVADDR    - the peer address has not been established.
 613  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 614  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 615  *    GSOCK_MEMERR     - couldn't allocate memory.
 616  *    GSOCK_IOERR      - low-level error.
 617  */
 618 GSocketError GSocketBSD::Connect(GSocketStream stream)
 619 {
 620   int err, ret;
 621   int arg = 1;
 622
 623   assert(this);
 624
 625   /* Enable CONNECTION events (needed for nonblocking connections) */
 626   Enable(GSOCK_CONNECTION);
 627
 628   if (m_fd != INVALID_SOCKET)
 629   {
 630     m_error = GSOCK_INVSOCK;
 631     return GSOCK_INVSOCK;
 632   }
 633
 634   if (!m_peer)
 635   {
 636     m_error = GSOCK_INVADDR;
 637     return GSOCK_INVADDR;
 638   }
 639
 640   /* Streamed or dgram socket? */
 641   m_stream   = (stream == GSOCK_STREAMED);
 642   m_oriented = TRUE;
 643   m_server   = FALSE;
 644   m_establishing = FALSE;
 645
 646   /* Create the socket */
 647   m_fd = socket(m_peer->m_realfamily,
 648                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 649
 650   if (m_fd == INVALID_SOCKET)
 651   {
 652     m_error = GSOCK_IOERR;
 653     return GSOCK_IOERR;
 654   }
 655 #if defined(__EMX__) || defined(__VISAGECPP__)
 656   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 657 #else
 658   ioctl(m_fd, FIONBIO, &arg);
 659 #endif
 660   EventLoop_Enable_Events();
 661
 662   /* Connect it to the peer address, with a timeout (see below) */
 663   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 664
 665   if (ret == -1)
 666   {
 667     err = errno;
 668
 669     /* If connect failed with EINPROGRESS and the GSocket object
 670      * is in blocking mode, we select() for the specified timeout
 671      * checking for writability to see if the connection request
 672      * completes.
 673      */
 674     if ((err == EINPROGRESS) && (!m_non_blocking))
 675     {
 676       if (Output_Timeout() == GSOCK_TIMEDOUT)
 677       {
 678         Close();
 679         /* m_error is set in _GSocket_Output_Timeout */
 680         return GSOCK_TIMEDOUT;
 681       }
 682       else
 683       {
 684         int error;
 685         SOCKLEN_T len = sizeof(error);
 686
 687         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
 688
 689         if (!error)
 690           return GSOCK_NOERROR;
 691       }
 692     }
 693
 694     /* If connect failed with EINPROGRESS and the GSocket object
 695      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 696      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 697      * this way if the connection completes, a GSOCK_CONNECTION
 698      * event will be generated, if enabled.
 699      */
 700     if ((err == EINPROGRESS) && (m_non_blocking))
 701     {
 702       m_establishing = TRUE;
 703       m_error = GSOCK_WOULDBLOCK;
 704       return GSOCK_WOULDBLOCK;
 705     }
 706
 707     /* If connect failed with an error other than EINPROGRESS,
 708      * then the call to GSocket_Connect has failed.
 709      */
 710     Close();
 711     m_error = GSOCK_IOERR;
 712     return GSOCK_IOERR;
 713   }
 714
 715   return GSOCK_NOERROR;
 716 }
 717
 718 /* Datagram sockets */
 719
 720 /* GSocket_SetNonOriented:
 721  *  Sets up this socket as a non-connection oriented (datagram) socket.
 722  *  Before using this function, the local address must have been set
 723  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 724  *  on success, or one of the following otherwise.
 725  *
 726  *  Error codes:
 727  *    GSOCK_INVSOCK - the socket is in use.
 728  *    GSOCK_INVADDR - the local address has not been set.
 729  *    GSOCK_IOERR   - low-level error.
 730  */
 731 GSocketError GSocketBSD::SetNonOriented()
 732 {
 733   int arg = 1;
 734
 735   assert(this);
 736
 737   if (m_fd != INVALID_SOCKET)
 738   {
 739     m_error = GSOCK_INVSOCK;
 740     return GSOCK_INVSOCK;
 741   }
 742
 743   if (!m_local)
 744   {
 745     m_error = GSOCK_INVADDR;
 746     return GSOCK_INVADDR;
 747   }
 748
 749   /* Initialize all fields */
 750   m_stream   = FALSE;
 751   m_server   = FALSE;
 752   m_oriented = FALSE;
 753
 754   /* Create the socket */
 755   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 756
 757   if (m_fd == INVALID_SOCKET)
 758   {
 759     m_error = GSOCK_IOERR;
 760     return GSOCK_IOERR;
 761   }
 762 #if defined(__EMX__) || defined(__VISAGECPP__)
 763   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 764 #else
 765   ioctl(m_fd, FIONBIO, &arg);
 766 #endif
 767   EventLoop_Enable_Events();
 768
 769   /* Bind to the local address,
 770    * and retrieve the actual address bound.
 771    */
 772   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 773       (getsockname(m_fd,
 774                    m_local->m_addr,
 775                    (SOCKLEN_T *) &m_local->m_len) != 0))
 776   {
 777     Close();
 778     m_error = GSOCK_IOERR;
 779     return GSOCK_IOERR;
 780   }
 781
 782   return GSOCK_NOERROR;
 783 }
 784
 785 /* Generic IO */
 786
 787 /* Like recv(), send(), ... */
 788 int GSocketBSD::Read(char *buffer, int size)
 789 {
 790   int ret;
 791
 792   assert(this);
 793
 794   /* When using CFSocket we MUST NOT reenable events until we finish reading */
 795 #ifndef __DARWIN__
 796   /* Reenable INPUT events */
 797   Enable(GSOCK_INPUT);
 798 #endif
 799
 800   if (m_fd == INVALID_SOCKET || m_server)
 801   {
 802     m_error = GSOCK_INVSOCK;
 803     return -1;
 804   }
 805
 806   /* If the socket is blocking, wait for data (with a timeout) */
 807   if (Input_Timeout() == GSOCK_TIMEDOUT)
 808     return -1;
 809
 810   /* Read the data */
 811   if (m_stream)
 812     ret = Recv_Stream(buffer, size);
 813   else
 814     ret = Recv_Dgram(buffer, size);
 815
 816   if (ret == -1)
 817   {
 818     if (errno == EWOULDBLOCK)
 819       m_error = GSOCK_WOULDBLOCK;
 820     else
 821       m_error = GSOCK_IOERR;
 822   }
 823
 824 #ifdef __DARWIN__
 825   /* Reenable INPUT events */
 826   Enable(GSOCK_INPUT);
 827 #endif
 828
 829   return ret;
 830 }
 831
 832 int GSocketBSD::Write(const char *buffer, int size)
 833 {
 834   int ret;
 835
 836   assert(this);
 837
 838   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
 839
 840   if (m_fd == INVALID_SOCKET || m_server)
 841   {
 842     m_error = GSOCK_INVSOCK;
 843     return -1;
 844   }
 845
 846   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
 847
 848   /* If the socket is blocking, wait for writability (with a timeout) */
 849   if (Output_Timeout() == GSOCK_TIMEDOUT)
 850     return -1;
 851
 852   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
 853
 854   /* Write the data */
 855   if (m_stream)
 856     ret = Send_Stream(buffer, size);
 857   else
 858     ret = Send_Dgram(buffer, size);
 859
 860   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
 861
 862   if (ret == -1)
 863   {
 864     if (errno == EWOULDBLOCK)
 865     {
 866       m_error = GSOCK_WOULDBLOCK;
 867       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
 868     }
 869     else
 870     {
 871       m_error = GSOCK_IOERR;
 872       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
 873     }
 874
 875     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 876      * in MSW). Once the first OUTPUT event is received, users can assume
 877      * that the socket is writable until a read operation fails. Only then
 878      * will further OUTPUT events be posted.
 879      */
 880     Enable(GSOCK_OUTPUT);
 881     return -1;
 882   }
 883
 884   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
 885
 886   return ret;
 887 }
 888
 889 /* GSocket_Select:
 890  *  Polls the socket to determine its status. This function will
 891  *  check for the events specified in the 'flags' parameter, and
 892  *  it will return a mask indicating which operations can be
 893  *  performed. This function won't block, regardless of the
 894  *  mode (blocking | nonblocking) of the socket.
 895  */
 896 GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags)
 897 {
 898   if (!GSocketBSDGUIShim::UseGUI())
 899   {
 900
 901     GSocketEventFlags result = 0;
 902     fd_set readfds;
 903     fd_set writefds;
 904     fd_set exceptfds;
 905     struct timeval tv;
 906
 907     /* Do not use a static struct, Linux can garble it */
 908     tv.tv_sec = m_timeout / 1000;
 909     tv.tv_usec = (m_timeout % 1000) / 1000;
 910
 911     assert(this);
 912
 913     FD_ZERO(&readfds);
 914     FD_ZERO(&writefds);
 915     FD_ZERO(&exceptfds);
 916     FD_SET(m_fd, &readfds);
 917     if (flags & GSOCK_OUTPUT_FLAG)
 918       FD_SET(m_fd, &writefds);
 919     FD_SET(m_fd, &exceptfds);
 920
 921     /* Check 'sticky' CONNECTION flag first */
 922     result |= (GSOCK_CONNECTION_FLAG & m_detected);
 923
 924     /* If we have already detected a LOST event, then don't try
 925      * to do any further processing.
 926      */
 927     if ((m_detected & GSOCK_LOST_FLAG) != 0)
 928     {
 929       m_establishing = FALSE;
 930
 931       return (GSOCK_LOST_FLAG & flags);
 932     }
 933
 934     /* Try select now */
 935     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
 936     {
 937       /* What to do here? */
 938       return (result & flags);
 939     }
 940
 941     /* Check for readability */
 942     if (FD_ISSET(m_fd, &readfds))
 943     {
 944       char c;
 945
 946       if (recv(m_fd, &c, 1, MSG_PEEK) > 0)
 947       {
 948         result |= GSOCK_INPUT_FLAG;
 949       }
 950       else
 951       {
 952         if (m_server && m_stream)
 953         {
 954           result |= GSOCK_CONNECTION_FLAG;
 955           m_detected |= GSOCK_CONNECTION_FLAG;
 956         }
 957         else
 958         {
 959           m_detected = GSOCK_LOST_FLAG;
 960           m_establishing = FALSE;
 961
 962           /* LOST event: Abort any further processing */
 963           return (GSOCK_LOST_FLAG & flags);
 964         }
 965       }
 966     }
 967
 968     /* Check for writability */
 969     if (FD_ISSET(m_fd, &writefds))
 970     {
 971       if (m_establishing && !m_server)
 972       {
 973         int error;
 974         SOCKLEN_T len = sizeof(error);
 975
 976         m_establishing = FALSE;
 977
 978         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
 979
 980         if (error)
 981         {
 982           m_detected = GSOCK_LOST_FLAG;
 983
 984           /* LOST event: Abort any further processing */
 985           return (GSOCK_LOST_FLAG & flags);
 986         }
 987         else
 988         {
 989           result |= GSOCK_CONNECTION_FLAG;
 990           m_detected |= GSOCK_CONNECTION_FLAG;
 991         }
 992       }
 993       else
 994       {
 995         result |= GSOCK_OUTPUT_FLAG;
 996       }
 997     }
 998
 999     /* Check for exceptions and errors (is this useful in Unices?) */
1000     if (FD_ISSET(m_fd, &exceptfds))
1001     {
1002       m_establishing = FALSE;
1003       m_detected = GSOCK_LOST_FLAG;
1004
1005       /* LOST event: Abort any further processing */
1006       return (GSOCK_LOST_FLAG & flags);
1007     }
1008
1009     return (result & flags);
1010
1011   }
1012   else
1013   {
1014
1015     assert(this);
1016     return flags & m_detected;
1017
1018   }
1019 }
1020
1021 /* Flags */
1022
1023 /* GSocket_SetNonBlocking:
1024  *  Sets the socket to non-blocking mode. All IO calls will return
1025  *  immediately.
1026  */
1027 void GSocketBSD::SetNonBlocking(int non_block)
1028 {
1029   assert(this);
1030
1031   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1032
1033   m_non_blocking = non_block;
1034 }
1035
1036 /* GSocket_SetTimeout:
1037  *  Sets the timeout for blocking calls. Time is expressed in
1038  *  milliseconds.
1039  */
1040 void GSocketBSD::SetTimeout(unsigned long millisec)
1041 {
1042   assert(this);
1043
1044   m_timeout = millisec;
1045 }
1046
1047 /* GSocket_GetError:
1048  *  Returns the last error occured for this socket. Note that successful
1049  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1050  *  after an error.
1051  */
1052 GSocketError GSocketBSD::GetError()
1053 {
1054   assert(this);
1055
1056   return m_error;
1057 }
1058
1059 /* Callbacks */
1060
1061 /* GSOCK_INPUT:
1062  *   There is data to be read in the input buffer. If, after a read
1063  *   operation, there is still data available, the callback function will
1064  *   be called again.
1065  * GSOCK_OUTPUT:
1066  *   The socket is available for writing. That is, the next write call
1067  *   won't block. This event is generated only once, when the connection is
1068  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1069  *   when the output buffer empties again. This means that the app should
1070  *   assume that it can write since the first OUTPUT event, and no more
1071  *   OUTPUT events will be generated unless an error occurs.
1072  * GSOCK_CONNECTION:
1073  *   Connection succesfully established, for client sockets, or incoming
1074  *   client connection, for server sockets. Wait for this event (also watch
1075  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1076  * GSOCK_LOST:
1077  *   The connection is lost (or a connection request failed); this could
1078  *   be due to a failure, or due to the peer closing it gracefully.
1079  */
1080
1081 /* GSocket_SetCallback:
1082  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1083  *  may be a combination of flags OR'ed toghether, so the same
1084  *  callback function can be made to accept different events.
1085  *  The callback function must have the following prototype:
1086  *
1087  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1088  */
1089 void GSocketBSD::SetCallback(GSocketEventFlags flags,
1090                          GSocketCallback callback, char *cdata)
1091 {
1092   int count;
1093
1094   assert(this);
1095
1096   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1097   {
1098     if ((flags & (1 << count)) != 0)
1099     {
1100       m_cbacks[count] = callback;
1101       m_data[count] = cdata;
1102     }
1103   }
1104 }
1105
1106 /* GSocket_UnsetCallback:
1107  *  Disables all callbacks specified by 'flags', which may be a
1108  *  combination of flags OR'ed toghether.
1109  */
1110 void GSocketBSD::UnsetCallback(GSocketEventFlags flags)
1111 {
1112   int count;
1113
1114   assert(this);
1115
1116   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1117   {
1118     if ((flags & (1 << count)) != 0)
1119     {
1120       m_cbacks[count] = NULL;
1121       m_data[count] = NULL;
1122     }
1123   }
1124 }
1125
1126
1127 #define CALL_CALLBACK(event) {                                  \
1128   Disable(event);                                      \
1129   if (m_cbacks[event])                                          \
1130     m_cbacks[event](this, event, m_data[event]);      \
1131 }
1132
1133
1134 void GSocketBSD::Enable(GSocketEvent event)
1135 {
1136   m_detected &= ~(1 << event);
1137   EventLoop_Install_Callback(event);
1138 }
1139
1140 void GSocketBSD::Disable(GSocketEvent event)
1141 {
1142   m_detected |= (1 << event);
1143   EventLoop_Uninstall_Callback(event);
1144 }
1145
1146 /* _GSocket_Input_Timeout:
1147  *  For blocking sockets, wait until data is available or
1148  *  until timeout ellapses.
1149  */
1150 GSocketError GSocketBSD::Input_Timeout()
1151 {
1152   struct timeval tv;
1153   fd_set readfds;
1154   int ret;
1155
1156   /* Linux select() will overwrite the struct on return */
1157   tv.tv_sec  = (m_timeout / 1000);
1158   tv.tv_usec = (m_timeout % 1000) * 1000;
1159
1160   if (!m_non_blocking)
1161   {
1162     FD_ZERO(&readfds);
1163     FD_SET(m_fd, &readfds);
1164     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1165     if (ret == 0)
1166     {
1167       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1168       m_error = GSOCK_TIMEDOUT;
1169       return GSOCK_TIMEDOUT;
1170     }
1171     if (ret == -1)
1172     {
1173       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1174       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1175       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1176       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1177       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1178       m_error = GSOCK_TIMEDOUT;
1179       return GSOCK_TIMEDOUT;
1180     }
1181   }
1182   return GSOCK_NOERROR;
1183 }
1184
1185 /* _GSocket_Output_Timeout:
1186  *  For blocking sockets, wait until data can be sent without
1187  *  blocking or until timeout ellapses.
1188  */
1189 GSocketError GSocketBSD::Output_Timeout()
1190 {
1191   struct timeval tv;
1192   fd_set writefds;
1193   int ret;
1194
1195   /* Linux select() will overwrite the struct on return */
1196   tv.tv_sec  = (m_timeout / 1000);
1197   tv.tv_usec = (m_timeout % 1000) * 1000;
1198
1199   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1200
1201   if (!m_non_blocking)
1202   {
1203     FD_ZERO(&writefds);
1204     FD_SET(m_fd, &writefds);
1205     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1206     if (ret == 0)
1207     {
1208       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1209       m_error = GSOCK_TIMEDOUT;
1210       return GSOCK_TIMEDOUT;
1211     }
1212     if (ret == -1)
1213     {
1214       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1215       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1216       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1217       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1218       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1219       m_error = GSOCK_TIMEDOUT;
1220       return GSOCK_TIMEDOUT;
1221     }
1222     if ( ! FD_ISSET(m_fd, &writefds) ) {
1223         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1224     }
1225     else {
1226         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1227     }
1228   }
1229   else
1230   {
1231     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1232   }
1233
1234   return GSOCK_NOERROR;
1235 }
1236
1237 int GSocketBSD::Recv_Stream(char *buffer, int size)
1238 {
1239   return recv(m_fd, buffer, size, 0);
1240 }
1241
1242 int GSocketBSD::Recv_Dgram(char *buffer, int size)
1243 {
1244   struct sockaddr from;
1245   SOCKLEN_T fromlen = sizeof(from);
1246   int ret;
1247   GSocketError err;
1248
1249   fromlen = sizeof(from);
1250
1251   ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
1252
1253   if (ret == -1)
1254     return -1;
1255
1256   /* Translate a system address into a GSocket address */
1257   if (!m_peer)
1258   {
1259     m_peer = GAddress_new();
1260     if (!m_peer)
1261     {
1262       m_error = GSOCK_MEMERR;
1263       return -1;
1264     }
1265   }
1266   err = _GAddress_translate_from(m_peer, &from, fromlen);
1267   if (err != GSOCK_NOERROR)
1268   {
1269     GAddress_destroy(m_peer);
1270     m_peer  = NULL;
1271     m_error = err;
1272     return -1;
1273   }
1274
1275   return ret;
1276 }
1277
1278 int GSocketBSD::Send_Stream(const char *buffer, int size)
1279 {
1280   int ret;
1281
1282 #ifndef __VISAGECPP__
1283   MASK_SIGNAL();
1284   ret = send(m_fd, buffer, size, 0);
1285   UNMASK_SIGNAL();
1286 #else
1287   ret = send(m_fd, (char *)buffer, size, 0);
1288 #endif
1289
1290   return ret;
1291 }
1292
1293 int GSocketBSD::Send_Dgram(const char *buffer, int size)
1294 {
1295   struct sockaddr *addr;
1296   int len, ret;
1297   GSocketError err;
1298
1299   if (!m_peer)
1300   {
1301     m_error = GSOCK_INVADDR;
1302     return -1;
1303   }
1304
1305   err = _GAddress_translate_to(m_peer, &addr, &len);
1306   if (err != GSOCK_NOERROR)
1307   {
1308     m_error = err;
1309     return -1;
1310   }
1311
1312 #ifndef __VISAGECPP__
1313   MASK_SIGNAL();
1314   ret = sendto(m_fd, buffer, size, 0, addr, len);
1315   UNMASK_SIGNAL();
1316 #else
1317   ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1318 #endif
1319
1320   /* Frees memory allocated from _GAddress_translate_to */
1321   free(addr);
1322
1323   return ret;
1324 }
1325
1326 void GSocketBSD::Detected_Read()
1327 {
1328   char c;
1329
1330   /* If we have already detected a LOST event, then don't try
1331    * to do any further processing.
1332    */
1333   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1334   {
1335     m_establishing = FALSE;
1336
1337     CALL_CALLBACK(GSOCK_LOST);
1338     Shutdown();
1339     return;
1340   }
1341
1342   if (recv(m_fd, &c, 1, MSG_PEEK) > 0)
1343   {
1344     CALL_CALLBACK(GSOCK_INPUT);
1345   }
1346   else
1347   {
1348     if (m_server && m_stream)
1349     {
1350       CALL_CALLBACK(GSOCK_CONNECTION);
1351     }
1352     else
1353     {
1354       CALL_CALLBACK(GSOCK_LOST);
1355       Shutdown();
1356     }
1357   }
1358 }
1359
1360 void GSocketBSD::Detected_Write()
1361 {
1362   /* If we have already detected a LOST event, then don't try
1363    * to do any further processing.
1364    */
1365   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1366   {
1367     m_establishing = FALSE;
1368
1369     CALL_CALLBACK(GSOCK_LOST);
1370     Shutdown();
1371     return;
1372   }
1373
1374   if (m_establishing && !m_server)
1375   {
1376     int error;
1377     SOCKLEN_T len = sizeof(error);
1378
1379     m_establishing = FALSE;
1380
1381     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
1382
1383     if (error)
1384     {
1385       CALL_CALLBACK(GSOCK_LOST);
1386       Shutdown();
1387     }
1388     else
1389     {
1390       CALL_CALLBACK(GSOCK_CONNECTION);
1391       /* We have to fire this event by hand because CONNECTION (for clients)
1392        * and OUTPUT are internally the same and we just disabled CONNECTION
1393        * events with the above macro.
1394        */
1395       CALL_CALLBACK(GSOCK_OUTPUT);
1396     }
1397   }
1398   else
1399   {
1400     CALL_CALLBACK(GSOCK_OUTPUT);
1401   }
1402 }
1403
1404 /* Compatibility functions for GSocket */
1405 GSocket *GSocket_new(void)
1406 {
1407     GSocket *newsocket = new GSocketBSDGUIShim();
1408     if(newsocket->IsOk())
1409         return newsocket;
1410     delete newsocket;
1411     return NULL;
1412 }
1413
1414 void GSocket_destroy(GSocket *socket)
1415 {
1416     assert(socket);
1417
1418     /* Check that the socket is really shutdowned */
1419     if (socket->m_fd != INVALID_SOCKET)
1420       socket->Shutdown();
1421
1422     delete socket;
1423 }
1424
1425 void GSocketBSD::_GSocket_Detected_Read(GSocket *socket)
1426 {   socket->Detected_Read(); }
1427
1428 void GSocketBSD::_GSocket_Detected_Write(GSocket *socket)
1429 {   socket->Detected_Write(); }
1430
1431 /*
1432  * -------------------------------------------------------------------------
1433  * GAddress
1434  * -------------------------------------------------------------------------
1435  */
1436
1437 /* CHECK_ADDRESS verifies that the current address family is either
1438  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1439  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1440  * an appropiate error code.
1441  *
1442  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1443  */
1444 #define CHECK_ADDRESS(address, family)                              \
1445 {                                                                   \
1446   if (address->m_family == GSOCK_NOFAMILY)                          \
1447     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1448       return address->m_error;                                      \
1449   if (address->m_family != GSOCK_##family)                          \
1450   {                                                                 \
1451     address->m_error = GSOCK_INVADDR;                               \
1452     return GSOCK_INVADDR;                                           \
1453   }                                                                 \
1454 }
1455
1456 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1457 {                                                                   \
1458   if (address->m_family == GSOCK_NOFAMILY)                          \
1459     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1460       return retval;                                                \
1461   if (address->m_family != GSOCK_##family)                          \
1462   {                                                                 \
1463     address->m_error = GSOCK_INVADDR;                               \
1464     return retval;                                                  \
1465   }                                                                 \
1466 }
1467
1468
1469 GAddress *GAddress_new(void)
1470 {
1471   GAddress *address;
1472
1473   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1474     return NULL;
1475
1476   address->m_family  = GSOCK_NOFAMILY;
1477   address->m_addr    = NULL;
1478   address->m_len     = 0;
1479
1480   return address;
1481 }
1482
1483 GAddress *GAddress_copy(GAddress *address)
1484 {
1485   GAddress *addr2;
1486
1487   assert(address != NULL);
1488
1489   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1490     return NULL;
1491
1492   memcpy(addr2, address, sizeof(GAddress));
1493
1494   if (address->m_addr && address->m_len > 0)
1495   {
1496     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1497     if (addr2->m_addr == NULL)
1498     {
1499       free(addr2);
1500       return NULL;
1501     }
1502     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1503   }
1504
1505   return addr2;
1506 }
1507
1508 void GAddress_destroy(GAddress *address)
1509 {
1510   assert(address != NULL);
1511
1512   if (address->m_addr)
1513     free(address->m_addr);
1514
1515   free(address);
1516 }
1517
1518 void GAddress_SetFamily(GAddress *address, GAddressType type)
1519 {
1520   assert(address != NULL);
1521
1522   address->m_family = type;
1523 }
1524
1525 GAddressType GAddress_GetFamily(GAddress *address)
1526 {
1527   assert(address != NULL);
1528
1529   return address->m_family;
1530 }
1531
1532 GSocketError _GAddress_translate_from(GAddress *address,
1533                                       struct sockaddr *addr, int len)
1534 {
1535   address->m_realfamily = addr->sa_family;
1536   switch (addr->sa_family)
1537   {
1538     case AF_INET:
1539       address->m_family = GSOCK_INET;
1540       break;
1541     case AF_UNIX:
1542       address->m_family = GSOCK_UNIX;
1543       break;
1544 #ifdef AF_INET6
1545     case AF_INET6:
1546       address->m_family = GSOCK_INET6;
1547       break;
1548 #endif
1549     default:
1550     {
1551       address->m_error = GSOCK_INVOP;
1552       return GSOCK_INVOP;
1553     }
1554   }
1555
1556   if (address->m_addr)
1557     free(address->m_addr);
1558
1559   address->m_len  = len;
1560   address->m_addr = (struct sockaddr *)malloc(len);
1561
1562   if (address->m_addr == NULL)
1563   {
1564     address->m_error = GSOCK_MEMERR;
1565     return GSOCK_MEMERR;
1566   }
1567   memcpy(address->m_addr, addr, len);
1568
1569   return GSOCK_NOERROR;
1570 }
1571
1572 GSocketError _GAddress_translate_to(GAddress *address,
1573                                     struct sockaddr **addr, int *len)
1574 {
1575   if (!address->m_addr)
1576   {
1577     address->m_error = GSOCK_INVADDR;
1578     return GSOCK_INVADDR;
1579   }
1580
1581   *len = address->m_len;
1582   *addr = (struct sockaddr *)malloc(address->m_len);
1583   if (*addr == NULL)
1584   {
1585     address->m_error = GSOCK_MEMERR;
1586     return GSOCK_MEMERR;
1587   }
1588
1589   memcpy(*addr, address->m_addr, address->m_len);
1590   return GSOCK_NOERROR;
1591 }
1592
1593 /*
1594  * -------------------------------------------------------------------------
1595  * Internet address family
1596  * -------------------------------------------------------------------------
1597  */
1598
1599 GSocketError _GAddress_Init_INET(GAddress *address)
1600 {
1601   address->m_len  = sizeof(struct sockaddr_in);
1602   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1603   if (address->m_addr == NULL)
1604   {
1605     address->m_error = GSOCK_MEMERR;
1606     return GSOCK_MEMERR;
1607   }
1608
1609   address->m_family = GSOCK_INET;
1610   address->m_realfamily = PF_INET;
1611   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1612   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1613
1614   return GSOCK_NOERROR;
1615 }
1616
1617 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1618 {
1619   struct hostent *he;
1620   struct in_addr *addr;
1621
1622   assert(address != NULL);
1623
1624   CHECK_ADDRESS(address, INET);
1625
1626   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1627
1628   /* If it is a numeric host name, convert it now */
1629 #if defined(HAVE_INET_ATON)
1630   if (inet_aton(hostname, addr) == 0)
1631   {
1632 #elif defined(HAVE_INET_ADDR)
1633   if ( (addr->s_addr = inet_addr(hostname)) == -1 )
1634   {
1635 #else
1636   /* Use gethostbyname by default */
1637   int val = 1;  //VA doesn't like constants in conditional expressions at all
1638   if (val)
1639   {
1640 #endif
1641     struct in_addr *array_addr;
1642
1643     /* It is a real name, we solve it */
1644     if ((he = gethostbyname(hostname)) == NULL)
1645     {
1646       /* Reset to invalid address */
1647       addr->s_addr = INADDR_NONE;
1648       address->m_error = GSOCK_NOHOST;
1649       return GSOCK_NOHOST;
1650     }
1651     array_addr = (struct in_addr *) *(he->h_addr_list);
1652     addr->s_addr = array_addr[0].s_addr;
1653   }
1654   return GSOCK_NOERROR;
1655 }
1656
1657 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1658 {
1659   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1660 }
1661
1662 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1663                                           unsigned long hostaddr)
1664 {
1665   struct in_addr *addr;
1666
1667   assert(address != NULL);
1668
1669   CHECK_ADDRESS(address, INET);
1670
1671   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1672   addr->s_addr = hostaddr;
1673
1674   return GSOCK_NOERROR;
1675 }
1676
1677 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1678                                        const char *protocol)
1679 {
1680   struct servent *se;
1681   struct sockaddr_in *addr;
1682
1683   assert(address != NULL);
1684   CHECK_ADDRESS(address, INET);
1685
1686   if (!port)
1687   {
1688     address->m_error = GSOCK_INVPORT;
1689     return GSOCK_INVPORT;
1690   }
1691
1692   se = getservbyname(port, protocol);
1693   if (!se)
1694   {
1695     /* the cast to int suppresses compiler warnings about subscript having the
1696        type char */
1697     if (isdigit((int)port[0]))
1698     {
1699       int port_int;
1700
1701       port_int = atoi(port);
1702       addr = (struct sockaddr_in *)address->m_addr;
1703       addr->sin_port = htons(port_int);
1704       return GSOCK_NOERROR;
1705     }
1706
1707     address->m_error = GSOCK_INVPORT;
1708     return GSOCK_INVPORT;
1709   }
1710
1711   addr = (struct sockaddr_in *)address->m_addr;
1712   addr->sin_port = se->s_port;
1713
1714   return GSOCK_NOERROR;
1715 }
1716
1717 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1718 {
1719   struct sockaddr_in *addr;
1720
1721   assert(address != NULL);
1722   CHECK_ADDRESS(address, INET);
1723
1724   addr = (struct sockaddr_in *)address->m_addr;
1725   addr->sin_port = htons(port);
1726
1727   return GSOCK_NOERROR;
1728 }
1729
1730 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1731 {
1732   struct hostent *he;
1733   char *addr_buf;
1734   struct sockaddr_in *addr;
1735
1736   assert(address != NULL);
1737   CHECK_ADDRESS(address, INET);
1738
1739   addr = (struct sockaddr_in *)address->m_addr;
1740   addr_buf = (char *)&(addr->sin_addr);
1741
1742   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1743   if (he == NULL)
1744   {
1745     address->m_error = GSOCK_NOHOST;
1746     return GSOCK_NOHOST;
1747   }
1748
1749   strncpy(hostname, he->h_name, sbuf);
1750
1751   return GSOCK_NOERROR;
1752 }
1753
1754 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1755 {
1756   struct sockaddr_in *addr;
1757
1758   assert(address != NULL);
1759   CHECK_ADDRESS_RETVAL(address, INET, 0);
1760
1761   addr = (struct sockaddr_in *)address->m_addr;
1762
1763   return addr->sin_addr.s_addr;
1764 }
1765
1766 unsigned short GAddress_INET_GetPort(GAddress *address)
1767 {
1768   struct sockaddr_in *addr;
1769
1770   assert(address != NULL);
1771   CHECK_ADDRESS_RETVAL(address, INET, 0);
1772
1773   addr = (struct sockaddr_in *)address->m_addr;
1774   return ntohs(addr->sin_port);
1775 }
1776
1777 /*
1778  * -------------------------------------------------------------------------
1779  * Unix address family
1780  * -------------------------------------------------------------------------
1781  */
1782
1783 #ifndef __VISAGECPP__
1784 GSocketError _GAddress_Init_UNIX(GAddress *address)
1785 {
1786   address->m_len  = sizeof(struct sockaddr_un);
1787   address->m_addr = (struct sockaddr *)malloc(address->m_len);
1788   if (address->m_addr == NULL)
1789   {
1790     address->m_error = GSOCK_MEMERR;
1791     return GSOCK_MEMERR;
1792   }
1793
1794   address->m_family = GSOCK_UNIX;
1795   address->m_realfamily = PF_UNIX;
1796   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1797   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1798
1799   return GSOCK_NOERROR;
1800 }
1801
1802 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1803
1804 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1805 {
1806   struct sockaddr_un *addr;
1807
1808   assert(address != NULL);
1809
1810   CHECK_ADDRESS(address, UNIX);
1811
1812   addr = ((struct sockaddr_un *)address->m_addr);
1813   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1814   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1815
1816   return GSOCK_NOERROR;
1817 }
1818
1819 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1820 {
1821   struct sockaddr_un *addr;
1822
1823   assert(address != NULL);
1824   CHECK_ADDRESS(address, UNIX);
1825
1826   addr = (struct sockaddr_un *)address->m_addr;
1827
1828   strncpy(path, addr->sun_path, sbuf);
1829
1830   return GSOCK_NOERROR;
1831 }
1832 #endif  /* !defined(__VISAGECPP__) */
1833 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
1834