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