Home | History | Annotate | Download | only in qemu
      1 /* Copyright (C) 2007-2008 The Android Open Source Project
      2 **
      3 ** This software is licensed under the terms of the GNU General Public
      4 ** License version 2, as published by the Free Software Foundation, and
      5 ** may be copied, distributed, and modified under those terms.
      6 **
      7 ** This program is distributed in the hope that it will be useful,
      8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
      9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     10 ** GNU General Public License for more details.
     11 */
     12 #ifdef __linux__ /* Recent versions of glibc only define EAI_NODATA, which is an
     13                     extension to the POSIX standard, if _GNU_SOURCE is defined. */
     14 #  define _GNU_SOURCE 1
     15 #endif
     16 
     17 #include "sockets.h"
     18 #include <fcntl.h>
     19 #include <stddef.h>
     20 #include "qemu_debug.h"
     21 #include "qemu-char.h"
     22 #include <stdlib.h>
     23 #include <string.h>
     24 #include "android/utils/path.h"
     25 #include "android/utils/debug.h"
     26 #include "android/utils/misc.h"
     27 #include "android/utils/system.h"
     28 
     29 #define  D(...) VERBOSE_PRINT(socket,__VA_ARGS__)
     30 
     31 #ifdef _WIN32
     32 #  define xxWIN32_LEAN_AND_MEAN
     33 #  include <windows.h>
     34 #  include <winsock2.h>
     35 #  include <ws2tcpip.h>
     36 #else /* !_WIN32 */
     37 #  include <sys/ioctl.h>
     38 #  include <sys/socket.h>
     39 #  include <netinet/in.h>
     40 #  include <netinet/tcp.h>
     41 #  include <netdb.h>
     42 #  if HAVE_UNIX_SOCKETS
     43 #    include <sys/un.h>
     44 #    ifndef UNIX_PATH_MAX
     45 #      define  UNIX_PATH_MAX  (sizeof(((struct sockaddr_un*)0)->sun_path)-1)
     46 #    endif
     47 #  endif
     48 #endif /* !_WIN32 */
     49 
     50 
     51 
     52 /* QSOCKET_CALL is used to deal with the fact that EINTR happens pretty
     53  * easily in QEMU since we use SIGALRM to implement periodic timers
     54  */
     55 #ifdef _WIN32
     56 #  define  QSOCKET_CALL(_ret,_cmd)   \
     57     do { _ret = (_cmd); } while ( _ret < 0 && WSAGetLastError() == WSAEINTR )
     58 #else
     59 #  define  QSOCKET_CALL(_ret,_cmd)   \
     60     do { \
     61         errno = 0; \
     62         do { _ret = (_cmd); } while ( _ret < 0 && errno == EINTR ); \
     63     } while (0);
     64 #endif
     65 
     66 #ifdef _WIN32
     67 
     68 #include <errno.h>
     69 
     70 static int  winsock_error;
     71 
     72 #define  WINSOCK_ERRORS_LIST \
     73     EE(WSA_INVALID_HANDLE,EINVAL,"invalid handle") \
     74     EE(WSA_NOT_ENOUGH_MEMORY,ENOMEM,"not enough memory") \
     75     EE(WSA_INVALID_PARAMETER,EINVAL,"invalid parameter") \
     76     EE(WSAEINTR,EINTR,"interrupted function call") \
     77     EE(WSAEALREADY,EALREADY,"operation already in progress") \
     78     EE(WSAEBADF,EBADF,"bad file descriptor") \
     79     EE(WSAEACCES,EACCES,"permission denied") \
     80     EE(WSAEFAULT,EFAULT,"bad address") \
     81     EE(WSAEINVAL,EINVAL,"invalid argument") \
     82     EE(WSAEMFILE,EMFILE,"too many opened files") \
     83     EE(WSAEWOULDBLOCK,EWOULDBLOCK,"resource temporarily unavailable") \
     84     EE(WSAEINPROGRESS,EINPROGRESS,"operation now in progress") \
     85     EE(WSAEALREADY,EAGAIN,"operation already in progress") \
     86     EE(WSAENOTSOCK,EBADF,"socket operation not on socket") \
     87     EE(WSAEDESTADDRREQ,EDESTADDRREQ,"destination address required") \
     88     EE(WSAEMSGSIZE,EMSGSIZE,"message too long") \
     89     EE(WSAEPROTOTYPE,EPROTOTYPE,"wrong protocol type for socket") \
     90     EE(WSAENOPROTOOPT,ENOPROTOOPT,"bad protocol option") \
     91     EE(WSAEADDRINUSE,EADDRINUSE,"address already in use") \
     92     EE(WSAEADDRNOTAVAIL,EADDRNOTAVAIL,"cannot assign requested address") \
     93     EE(WSAENETDOWN,ENETDOWN,"network is down") \
     94     EE(WSAENETUNREACH,ENETUNREACH,"network unreachable") \
     95     EE(WSAENETRESET,ENETRESET,"network dropped connection on reset") \
     96     EE(WSAECONNABORTED,ECONNABORTED,"software caused connection abort") \
     97     EE(WSAECONNRESET,ECONNRESET,"connection reset by peer") \
     98     EE(WSAENOBUFS,ENOBUFS,"no buffer space available") \
     99     EE(WSAEISCONN,EISCONN,"socket is already connected") \
    100     EE(WSAENOTCONN,ENOTCONN,"socket is not connected") \
    101     EE(WSAESHUTDOWN,ESHUTDOWN,"cannot send after socket shutdown") \
    102     EE(WSAETOOMANYREFS,ETOOMANYREFS,"too many references") \
    103     EE(WSAETIMEDOUT,ETIMEDOUT,"connection timed out") \
    104     EE(WSAECONNREFUSED,ECONNREFUSED,"connection refused") \
    105     EE(WSAELOOP,ELOOP,"cannot translate name") \
    106     EE(WSAENAMETOOLONG,ENAMETOOLONG,"name too long") \
    107     EE(WSAEHOSTDOWN,EHOSTDOWN,"host is down") \
    108     EE(WSAEHOSTUNREACH,EHOSTUNREACH,"no route to host") \
    109 
    110 typedef struct {
    111     int          winsock;
    112     int          unix;
    113     const char*  string;
    114 } WinsockError;
    115 
    116 static const WinsockError  _winsock_errors[] = {
    117 #define  EE(w,u,s)   { w, u, s },
    118     WINSOCK_ERRORS_LIST
    119 #undef   EE
    120     { -1, -1, NULL }
    121 };
    122 
    123 /* this function reads the latest winsock error code and updates
    124  * errno to a matching value. It also returns the new value of
    125  * errno.
    126  */
    127 static int
    128 fix_errno( void )
    129 {
    130     const WinsockError*  werr = _winsock_errors;
    131     int                  unix = EINVAL;  /* generic error code */
    132 
    133     winsock_error = WSAGetLastError();
    134 
    135     for ( ; werr->string != NULL; werr++ ) {
    136         if (werr->winsock == winsock_error) {
    137             unix = werr->unix;
    138             break;
    139         }
    140     }
    141     errno = unix;
    142     return -1;
    143 }
    144 
    145 static int
    146 set_errno( int  code )
    147 {
    148     winsock_error = -1;
    149     errno         = code;
    150     return -1;
    151 }
    152 
    153 /* this function returns a string describing the latest Winsock error */
    154 const char*
    155 _errno_str(void)
    156 {
    157     const WinsockError*  werr   = _winsock_errors;
    158     const char*          result = NULL;
    159 
    160     for ( ; werr->string; werr++ ) {
    161         if (werr->winsock == winsock_error) {
    162             result = werr->string;
    163             break;
    164         }
    165     }
    166 
    167     if (result == NULL) {
    168         result = tempstr_format(
    169                     "Unkown socket error (Winsock=0x%08x) errno=%d: %s",
    170                     winsock_error, errno, strerror(errno));
    171     }
    172     return result;
    173 }
    174 #else
    175 static int
    176 fix_errno( void )
    177 {
    178     return -1;
    179 }
    180 
    181 static int
    182 set_errno( int  code )
    183 {
    184     errno = code;
    185     return -1;
    186 }
    187 #endif
    188 
    189 /* socket types */
    190 
    191 static int
    192 socket_family_to_bsd( SocketFamily  family )
    193 {
    194     switch (family) {
    195     case SOCKET_INET: return AF_INET;
    196     case SOCKET_IN6:  return AF_INET6;
    197 #if HAVE_UNIX_SOCKETS
    198     case SOCKET_UNIX: return AF_LOCAL;
    199 #endif
    200     default: return -1;
    201     }
    202 }
    203 
    204 static int
    205 socket_type_to_bsd( SocketType  type )
    206 {
    207     switch (type) {
    208         case SOCKET_DGRAM:  return SOCK_DGRAM;
    209         case SOCKET_STREAM: return SOCK_STREAM;
    210         default: return 0;
    211     }
    212 }
    213 
    214 static SocketType
    215 socket_type_from_bsd( int  type )
    216 {
    217     switch (type) {
    218         case SOCK_DGRAM:  return SOCKET_DGRAM;
    219         case SOCK_STREAM: return SOCKET_STREAM;
    220         default:          return (SocketType) SOCKET_UNSPEC;
    221     }
    222 }
    223 
    224 #if 0
    225 static int
    226 socket_type_check( SocketType  type )
    227 {
    228     return (type == SOCKET_DGRAM || type == SOCKET_STREAM);
    229 }
    230 #endif
    231 
    232 typedef union {
    233     struct sockaddr     sa[1];
    234     struct sockaddr_in  in[1];
    235 #if HAVE_IN6_SOCKETS
    236     struct sockaddr_in6 in6[1];
    237 #endif
    238 #if HAVE_UNIX_SOCKETS
    239     struct sockaddr_un  un[1];
    240 #endif
    241 } sockaddr_storage;
    242 
    243 /* socket addresses */
    244 
    245 void
    246 sock_address_init_inet( SockAddress*  a, uint32_t  ip, uint16_t  port )
    247 {
    248     a->family         = SOCKET_INET;
    249     a->u.inet.port    = port;
    250     a->u.inet.address = ip;
    251 }
    252 
    253 void
    254 sock_address_init_in6 ( SockAddress*  a, const uint8_t*  ip6[16], uint16_t  port )
    255 {
    256     a->family = SOCKET_IN6;
    257     a->u.in6.port = port;
    258     memcpy( a->u.in6.address, ip6, sizeof(a->u.in6.address) );
    259 }
    260 
    261 void
    262 sock_address_init_unix( SockAddress*  a, const char*  path )
    263 {
    264     a->family       = SOCKET_UNIX;
    265     a->u._unix.path  = strdup(path ? path : "");
    266     a->u._unix.owner = 1;
    267 }
    268 
    269 void  sock_address_done( SockAddress*  a )
    270 {
    271     if (a->family == SOCKET_UNIX && a->u._unix.owner) {
    272         a->u._unix.owner = 0;
    273         free((char*)a->u._unix.path);
    274     }
    275 }
    276 
    277 static char*
    278 format_char( char*  buf, char*  end, int  c )
    279 {
    280     if (buf < end) {
    281         if (buf+1 == end) {
    282             *buf++ = 0;
    283         } else {
    284             *buf++ = (char) c;
    285             *buf    = 0;
    286         }
    287     }
    288     return buf;
    289 }
    290 
    291 static char*
    292 format_str( char*  buf, char*  end, const char*  str )
    293 {
    294     int  len   = strlen(str);
    295     int  avail = end - buf;
    296 
    297     if (len > avail)
    298         len = avail;
    299 
    300     memcpy( buf, str, len );
    301     buf += len;
    302 
    303     if (buf == end)
    304         buf[-1] = 0;
    305     else
    306         buf[0] = 0;
    307 
    308     return buf;
    309 }
    310 
    311 static char*
    312 format_unsigned( char*  buf, char*  end, unsigned  val )
    313 {
    314     char  temp[16];
    315     int   nn;
    316 
    317     for ( nn = 0; val != 0; nn++ ) {
    318         int  rem = val % 10;
    319         temp[nn] = '0'+rem;
    320         val /= 10;
    321     }
    322 
    323     if (nn == 0)
    324         temp[nn++] = '0';
    325 
    326     while (nn > 0)
    327         buf = format_char(buf, end, temp[--nn]);
    328 
    329     return buf;
    330 }
    331 
    332 static char*
    333 format_hex( char*  buf, char*  end, unsigned  val, int  ndigits )
    334 {
    335     int   shift = 4*ndigits;
    336     static const char   hex[16] = "0123456789abcdef";
    337 
    338     while (shift >= 0) {
    339         buf = format_char(buf, end, hex[(val >> shift) & 15]);
    340         shift -= 4;
    341     }
    342     return buf;
    343 }
    344 
    345 static char*
    346 format_ip4( char*  buf, char*  end, uint32_t  ip )
    347 {
    348     buf = format_unsigned( buf, end, (unsigned)(ip >> 24) );
    349     buf = format_char( buf, end, '.');
    350     buf = format_unsigned( buf, end, (unsigned)((ip >> 16) & 255));
    351     buf = format_char( buf, end, '.');
    352     buf = format_unsigned( buf, end, (unsigned)((ip >> 8) & 255));
    353     buf = format_char( buf, end, '.');
    354     buf = format_unsigned( buf, end, (unsigned)(ip & 255));
    355     return buf;
    356 }
    357 
    358 static char*
    359 format_ip6( char*  buf, char*  end, const uint8_t*  ip6 )
    360 {
    361     int  nn;
    362     for (nn = 0; nn < 8; nn++) {
    363         int  val = (ip6[0] << 16) | ip6[1];
    364         ip6 += 2;
    365         if (nn > 0)
    366             buf = format_char(buf, end, ':');
    367         if (val == 0)
    368             continue;
    369         buf  = format_hex(buf, end, val, 4);
    370     }
    371     return buf;
    372 }
    373 
    374 const char*
    375 sock_address_to_string( const SockAddress*  a )
    376 {
    377     static char buf0[MAX_PATH];
    378     char *buf = buf0, *end = buf + sizeof(buf0);
    379 
    380     switch (a->family) {
    381     case SOCKET_INET:
    382         buf = format_ip4( buf, end, a->u.inet.address );
    383         buf = format_char( buf, end, ':' );
    384         buf = format_unsigned( buf, end, (unsigned) a->u.inet.port );
    385         break;
    386 
    387     case SOCKET_IN6:
    388         buf = format_ip6( buf, end, a->u.in6.address );
    389         buf = format_char( buf, end, ':' );
    390         buf = format_unsigned( buf, end, (unsigned) a->u.in6.port );
    391         break;
    392 
    393     case SOCKET_UNIX:
    394         buf = format_str( buf, end, a->u._unix.path );
    395         break;
    396 
    397     default:
    398         return NULL;
    399     }
    400 
    401     return buf0;
    402 }
    403 
    404 int
    405 sock_address_equal( const SockAddress*  a, const SockAddress*  b )
    406 {
    407     if (a->family != b->family)
    408         return 0;
    409 
    410     switch (a->family) {
    411     case SOCKET_INET:
    412         return (a->u.inet.address == b->u.inet.address &&
    413                 a->u.inet.port    == b->u.inet.port);
    414 
    415     case SOCKET_IN6:
    416         return (!memcmp(a->u.in6.address, b->u.in6.address, 16) &&
    417                 a->u.in6.port == b->u.in6.port);
    418 
    419     case SOCKET_UNIX:
    420         return (!strcmp(a->u._unix.path, b->u._unix.path));
    421 
    422     default:
    423         return 0;
    424     }
    425 }
    426 
    427 int
    428 sock_address_get_port( const SockAddress*  a )
    429 {
    430     switch (a->family) {
    431     case SOCKET_INET:
    432         return a->u.inet.port;
    433     case SOCKET_IN6:
    434         return a->u.in6.port;
    435     default:
    436         return -1;
    437     }
    438 }
    439 
    440 void
    441 sock_address_set_port( SockAddress*  a, uint16_t  port )
    442 {
    443     switch (a->family) {
    444     case SOCKET_INET:
    445         a->u.inet.port = port;
    446         break;
    447     case SOCKET_IN6:
    448         a->u.in6.port = port;
    449         break;
    450     default:
    451         ;
    452     }
    453 }
    454 
    455 const char*
    456 sock_address_get_path( const SockAddress*  a )
    457 {
    458     if (a->family == SOCKET_UNIX)
    459         return a->u._unix.path;
    460     else
    461         return NULL;
    462 }
    463 
    464 int
    465 sock_address_get_ip( const SockAddress*  a )
    466 {
    467     if (a->family == SOCKET_INET)
    468         return a->u.inet.address;
    469 
    470     return -1;
    471 }
    472 
    473 #if 0
    474 char*
    475 bufprint_sock_address( char*  p, char*  end, const SockAddress*  a )
    476 {
    477     switch (a->family) {
    478     case SOCKET_INET:
    479         {
    480             uint32_t  ip = a->u.inet.address;
    481 
    482             return bufprint( p, end, "%d.%d.%d.%d:%d",
    483                          (ip >> 24) & 255, (ip >> 16) & 255,
    484                          (ip >> 8) & 255, ip & 255,
    485                          a->u.inet.port );
    486         }
    487     case SOCKET_IN6:
    488         {
    489             int             nn     = 0;
    490             const char*     column = "";
    491             const uint8_t*  tab    = a->u.in6.address;
    492             for (nn = 0; nn < 16; nn += 2) {
    493                 p = bufprint(p, end, "%s%04x", column, (tab[n] << 8) | tab[n+1]);
    494                 column = ":";
    495             }
    496             return bufprint(p, end, ":%d", a->u.in6.port);
    497         }
    498     case SOCKET_UNIX:
    499         {
    500             return bufprint(p, end, "%s", a->u._unix.path);
    501         }
    502     default:
    503         return p;
    504     }
    505 }
    506 #endif
    507 
    508 static int
    509 sock_address_to_bsd( const SockAddress*  a, sockaddr_storage*  paddress, socklen_t  *psize )
    510 {
    511     switch (a->family) {
    512     case SOCKET_INET:
    513         {
    514             struct sockaddr_in*  dst = paddress->in;
    515 
    516             *psize = sizeof(*dst);
    517 
    518             memset( paddress, 0, *psize );
    519 
    520             dst->sin_family      = AF_INET;
    521             dst->sin_port        = htons(a->u.inet.port);
    522             dst->sin_addr.s_addr = htonl(a->u.inet.address);
    523         }
    524         break;
    525 
    526 #if HAVE_IN6_SOCKETS
    527     case SOCKET_IN6:
    528         {
    529             struct sockaddr_in6*  dst = paddress->in6;
    530 
    531             *psize = sizeof(*dst);
    532 
    533             memset( paddress, 0, *psize );
    534 
    535             dst->sin6_family = AF_INET6;
    536             dst->sin6_port   = htons(a->u.in6.port);
    537             memcpy( dst->sin6_addr.s6_addr, a->u.in6.address, 16 );
    538         }
    539         break;
    540 #endif /* HAVE_IN6_SOCKETS */
    541 
    542 #if HAVE_UNIX_SOCKETS
    543     case SOCKET_UNIX:
    544         {
    545             int                  slen = strlen(a->u._unix.path);
    546             struct sockaddr_un*  dst = paddress->un;
    547 
    548             if (slen >= UNIX_PATH_MAX)
    549                 return -1;
    550 
    551             memset( dst, 0, sizeof(*dst) );
    552 
    553             dst->sun_family = AF_LOCAL;
    554             memcpy( dst->sun_path, a->u._unix.path, slen );
    555             dst->sun_path[slen] = 0;
    556 
    557             *psize = (char*)&dst->sun_path[slen+1] - (char*)dst;
    558         }
    559         break;
    560 #endif /* HAVE_UNIX_SOCKETS */
    561 
    562     default:
    563         return set_errno(EINVAL);
    564     }
    565 
    566     return 0;
    567 }
    568 
    569 static int
    570 sock_address_from_bsd( SockAddress*  a, const void*  from, size_t  fromlen )
    571 {
    572     switch (((struct sockaddr *)from)->sa_family) {
    573     case AF_INET:
    574         {
    575            const struct sockaddr_in*  src = from;
    576 
    577             if (fromlen < sizeof(*src))
    578                 return set_errno(EINVAL);
    579 
    580             a->family         = SOCKET_INET;
    581             a->u.inet.port    = ntohs(src->sin_port);
    582             a->u.inet.address = ntohl(src->sin_addr.s_addr);
    583         }
    584         break;
    585 
    586 #ifdef HAVE_IN6_SOCKETS
    587     case AF_INET6:
    588         {
    589             const struct sockaddr_in6*  src = from;
    590 
    591             if (fromlen < sizeof(*src))
    592                 return set_errno(EINVAL);
    593 
    594             a->family     = SOCKET_IN6;
    595             a->u.in6.port = ntohs(src->sin6_port);
    596             memcpy(a->u.in6.address, src->sin6_addr.s6_addr, 16);
    597         }
    598         break;
    599 #endif
    600 
    601 #ifdef HAVE_UNIX_SOCKETS
    602     case AF_LOCAL:
    603         {
    604             const struct sockaddr_un*  src = from;
    605             char*                end;
    606 
    607             if (fromlen < sizeof(*src))
    608                 return set_errno(EINVAL);
    609 
    610             /* check that the path is zero-terminated */
    611             end = memchr(src->sun_path, 0, UNIX_PATH_MAX);
    612             if (end == NULL)
    613                 return set_errno(EINVAL);
    614 
    615             a->family = SOCKET_UNIX;
    616             a->u._unix.owner = 1;
    617             a->u._unix.path  = strdup(src->sun_path);
    618         }
    619         break;
    620 #endif
    621 
    622     default:
    623         return set_errno(EINVAL);
    624     }
    625     return 0;
    626 }
    627 
    628 
    629 int
    630 sock_address_init_resolve( SockAddress*  a, const char*  hostname, uint16_t  port, int  preferIn6 )
    631 {
    632     struct addrinfo   hints[1];
    633     struct addrinfo*  res;
    634     int                ret;
    635 
    636     memset(hints, 0, sizeof(hints));
    637     hints->ai_family   = preferIn6 ? AF_INET6 : AF_UNSPEC;
    638 
    639     ret = getaddrinfo(hostname, NULL, hints, &res);
    640     if (ret != 0) {
    641         int  err;
    642 
    643         switch (ret) {
    644         case EAI_AGAIN:  /* server is down */
    645         case EAI_FAIL:   /* server is sick */
    646             err = EHOSTDOWN;
    647             break;
    648 
    649 /* NOTE that in x86_64-w64-mingw32 both EAI_NODATA and EAI_NONAME are the same */
    650 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
    651         case EAI_NODATA:
    652 #endif
    653         case EAI_NONAME:
    654             err = ENOENT;
    655             break;
    656 
    657         case EAI_MEMORY:
    658             err = ENOMEM;
    659             break;
    660 
    661         default:
    662             err = EINVAL;
    663         }
    664         return set_errno(err);
    665     }
    666 
    667     /* Parse the returned list of addresses. */
    668     {
    669         struct addrinfo*  res_ipv4 = NULL;
    670         struct addrinfo*  res_ipv6 = NULL;
    671         struct addrinfo*  r;
    672 
    673        /* If preferIn6 is false, we stop on the first IPv4 address,
    674         * otherwise, we stop on the first IPv6 one
    675         */
    676         for (r = res; r != NULL; r = r->ai_next) {
    677             if (r->ai_family == AF_INET && res_ipv4 == NULL) {
    678                 res_ipv4 = r;
    679                 if (!preferIn6)
    680                     break;
    681             }
    682             else if (r->ai_family == AF_INET6 && res_ipv6 == NULL) {
    683                 res_ipv6 = r;
    684                 if (preferIn6)
    685                     break;
    686             }
    687         }
    688 
    689         /* Select the best address in 'r', which will be NULL
    690          * if there is no corresponding address.
    691          */
    692         if (preferIn6) {
    693             r = res_ipv6;
    694             if (r == NULL)
    695                 r = res_ipv4;
    696         } else {
    697             r = res_ipv4;
    698             if (r == NULL)
    699                 r = res_ipv6;
    700         }
    701 
    702         if (r == NULL) {
    703             ret = set_errno(ENOENT);
    704             goto Exit;
    705         }
    706 
    707         /* Convert to a SockAddress */
    708         ret = sock_address_from_bsd( a, r->ai_addr, r->ai_addrlen );
    709         if (ret < 0)
    710             goto Exit;
    711     }
    712 
    713     /* need to set the port */
    714     switch (a->family) {
    715     case SOCKET_INET: a->u.inet.port = port; break;
    716     case SOCKET_IN6:  a->u.in6.port  = port; break;
    717     default: ;
    718     }
    719 
    720 Exit:
    721     freeaddrinfo(res);
    722     return ret;
    723 }
    724 
    725 /* The Winsock headers for mingw lack some definitions */
    726 #ifndef AI_ADDRCONFIG
    727 #  define  AI_ADDRCONFIG  0
    728 #endif
    729 
    730 SockAddress**
    731 sock_address_list_create( const char*  hostname,
    732                           const char*  port,
    733                           unsigned     flags )
    734 {
    735     SockAddress**    list = NULL;
    736     SockAddress*     addr;
    737     int              nn, count, ret;
    738     struct addrinfo  ai, *res, *e;
    739 
    740     memset(&ai, 0, sizeof(ai));
    741     ai.ai_flags   |= AI_ADDRCONFIG;
    742     ai.ai_family   = PF_UNSPEC;
    743 
    744     if (flags & SOCKET_LIST_FORCE_INET)
    745         ai.ai_family = PF_INET;
    746     else if (flags & SOCKET_LIST_FORCE_IN6)
    747         ai.ai_family = PF_INET6;
    748 
    749     if (flags & SOCKET_LIST_PASSIVE)
    750         ai.ai_flags |= AI_PASSIVE;
    751     else
    752         ai.ai_flags |= AI_CANONNAME;
    753 
    754     if (flags & SOCKET_LIST_DGRAM)
    755         ai.ai_socktype = SOCK_DGRAM;
    756 
    757     while (1) {
    758         struct addrinfo  hints = ai;
    759 
    760         ret = getaddrinfo(hostname, port, &hints, &res);
    761         if (ret == 0)
    762             break;
    763 
    764         switch (ret) {
    765 #ifdef EAI_ADDRFAMILY
    766         case EAI_ADDRFAMILY:
    767 #endif
    768         case EAI_NODATA:
    769             set_errno(ENOENT);
    770             break;
    771         case EAI_FAMILY:
    772             set_errno(EAFNOSUPPORT);
    773             break;
    774         case EAI_AGAIN:
    775             set_errno(EAGAIN);
    776             break;
    777 #ifdef EAI_SYSTEM
    778         case EAI_SYSTEM:
    779             if (errno == EINTR)
    780                 continue;
    781             break;
    782 #endif
    783         default:
    784             set_errno(EINVAL);
    785         }
    786         return NULL;
    787     }
    788 
    789     /* allocate result list */
    790     for (count = 0, e = res; e != NULL; e = e->ai_next)
    791         count += 1;
    792 
    793     AARRAY_NEW(list, count+1);
    794     AARRAY_NEW(addr, count);
    795 
    796     for (nn = 0, e = res; e != NULL; e = e->ai_next) {
    797 
    798         ret = sock_address_from_bsd(addr, e->ai_addr, e->ai_addrlen);
    799         if (ret < 0)
    800             continue;
    801 
    802         list[nn++] = addr++;
    803     }
    804     list[nn] = NULL;
    805     freeaddrinfo(res);
    806     return list;
    807 }
    808 
    809 SockAddress**
    810 sock_address_list_create2(const char* host_and_port, unsigned flags )
    811 {
    812     char host_name[512];
    813     const char* actual_host_name = "localhost";
    814     // Parse host and port name.
    815     const char* port_name = strchr(host_and_port, ':');
    816     if (port_name != NULL) {
    817         int to_copy = MIN(sizeof(host_name)-1, port_name - host_and_port);
    818         if (to_copy != 0) {
    819             memcpy(host_name, host_and_port, to_copy);
    820             host_name[to_copy] = '\0';
    821             actual_host_name = host_name;
    822             port_name++;
    823         } else {
    824             return NULL;
    825         }
    826     } else {
    827         port_name = host_and_port;
    828     }
    829     // Make sure that port_name is not empty.
    830     if (port_name[0] == '\0') {
    831         return NULL;
    832     }
    833     return sock_address_list_create(actual_host_name, port_name, flags);
    834 }
    835 
    836 void
    837 sock_address_list_free( SockAddress**  list )
    838 {
    839     int  nn;
    840     SockAddress*  addr;
    841 
    842     if (list == NULL)
    843         return;
    844 
    845     addr = list[0];
    846     for (nn = 0; list[nn] != NULL; nn++) {
    847         sock_address_done(list[nn]);
    848         list[nn] = NULL;
    849     }
    850     AFREE(addr);
    851     AFREE(list);
    852 }
    853 
    854 int
    855 sock_address_get_numeric_info( SockAddress*  a,
    856                                char*         host,
    857                                size_t        hostlen,
    858                                char*         serv,
    859                                size_t        servlen )
    860 {
    861     struct sockaddr*  saddr;
    862     socklen_t         slen;
    863     int               ret;
    864 
    865     switch (a->family) {
    866     case SOCKET_INET:
    867         saddr = (struct sockaddr*) &a->u.inet.address;
    868         slen  = sizeof(a->u.inet.address);
    869         break;
    870 
    871 #if HAVE_IN6_SOCKET
    872     case SOCKET_IN6:
    873         saddr = (struct sockaddr*) &a->u.in6.address;
    874         slen  = sizeof(a->u.in6.address);
    875         break;
    876 #endif
    877     default:
    878         return set_errno(EINVAL);
    879     }
    880 
    881     ret = getnameinfo( saddr, slen, host, hostlen, serv, servlen,
    882                        NI_NUMERICHOST | NI_NUMERICSERV );
    883 
    884     switch (ret) {
    885     case 0:
    886         break;
    887     case EAI_AGAIN:
    888         ret = EAGAIN;
    889         break;
    890     default:
    891         ret = EINVAL;
    892     }
    893     return ret;
    894 }
    895 
    896 int
    897 socket_create( SocketFamily  family, SocketType  type )
    898 {
    899     int   ret;
    900     int   sfamily = socket_family_to_bsd(family);
    901     int   stype   = socket_type_to_bsd(type);
    902 
    903     if (sfamily < 0 || stype < 0) {
    904         return set_errno(EINVAL);
    905     }
    906 
    907     QSOCKET_CALL(ret, socket(sfamily, stype, 0));
    908     if (ret < 0)
    909         return fix_errno();
    910 
    911     return ret;
    912 }
    913 
    914 
    915 int
    916 socket_create_inet( SocketType  type )
    917 {
    918     return socket_create( SOCKET_INET, type );
    919 }
    920 
    921 #if HAVE_IN6_SOCKETS
    922 int
    923 socket_create_in6 ( SocketType  type )
    924 {
    925     return socket_create( SOCKET_IN6, type );
    926 }
    927 #endif
    928 
    929 #if HAVE_UNIX_SOCKETS
    930 int
    931 socket_create_unix( SocketType  type )
    932 {
    933     return socket_create( SOCKET_UNIX, type );
    934 }
    935 #endif
    936 
    937 int  socket_can_read(int  fd)
    938 {
    939 #ifdef _WIN32
    940     unsigned long  opt;
    941 
    942     if (ioctlsocket(fd, FIONREAD, &opt) < 0)
    943         return 0;
    944 
    945     return opt;
    946 #else
    947     int  opt;
    948 
    949     if (ioctl(fd, FIONREAD, &opt) < 0)
    950         return 0;
    951 
    952     return opt;
    953 #endif
    954 }
    955 
    956 #define   SOCKET_CALL(cmd)  \
    957     int  ret; \
    958     QSOCKET_CALL(ret, (cmd)); \
    959     if (ret < 0) \
    960         return fix_errno(); \
    961     return ret; \
    962 
    963 int
    964 socket_send(int  fd, const void*  buf, int  buflen)
    965 {
    966     SOCKET_CALL(send(fd, buf, buflen, 0))
    967 }
    968 
    969 int
    970 socket_send_oob( int  fd, const void*  buf, int  buflen )
    971 {
    972     SOCKET_CALL(send(fd, buf, buflen, MSG_OOB));
    973 }
    974 
    975 int
    976 socket_sendto(int  fd, const void*  buf, int  buflen, const SockAddress*  to)
    977 {
    978     sockaddr_storage  sa;
    979     socklen_t         salen;
    980 
    981     if (sock_address_to_bsd(to, &sa, &salen) < 0)
    982         return -1;
    983 
    984     SOCKET_CALL(sendto(fd, buf, buflen, 0, sa.sa, salen));
    985 }
    986 
    987 int
    988 socket_recv(int  fd, void*  buf, int  len)
    989 {
    990     SOCKET_CALL(recv(fd, buf, len, 0));
    991 }
    992 
    993 int
    994 socket_recvfrom(int  fd, void*  buf, int  len, SockAddress*  from)
    995 {
    996     sockaddr_storage  sa;
    997     socklen_t         salen = sizeof(sa);
    998     int               ret;
    999 
   1000     QSOCKET_CALL(ret,recvfrom(fd,buf,len,0,sa.sa,&salen));
   1001     if (ret < 0)
   1002         return fix_errno();
   1003 
   1004     if (sock_address_from_bsd(from, &sa, salen) < 0)
   1005         return -1;
   1006 
   1007     return ret;
   1008 }
   1009 
   1010 int
   1011 socket_connect( int  fd, const SockAddress*  address )
   1012 {
   1013     sockaddr_storage  addr;
   1014     socklen_t         addrlen;
   1015 
   1016     if (sock_address_to_bsd(address, &addr, &addrlen) < 0)
   1017         return -1;
   1018 
   1019     SOCKET_CALL(connect(fd,addr.sa,addrlen));
   1020 }
   1021 
   1022 int
   1023 socket_bind( int  fd, const SockAddress*  address )
   1024 {
   1025     sockaddr_storage  addr;
   1026     socklen_t         addrlen;
   1027 
   1028     if (sock_address_to_bsd(address, &addr, &addrlen) < 0)
   1029         return -1;
   1030 
   1031     SOCKET_CALL(bind(fd, addr.sa, addrlen));
   1032 }
   1033 
   1034 int
   1035 socket_get_address( int  fd, SockAddress*  address )
   1036 {
   1037     sockaddr_storage  addr;
   1038     socklen_t         addrlen = sizeof(addr);
   1039     int               ret;
   1040 
   1041     QSOCKET_CALL(ret, getsockname(fd, addr.sa, &addrlen));
   1042     if (ret < 0)
   1043         return fix_errno();
   1044 
   1045     return sock_address_from_bsd(address, &addr, addrlen);
   1046 }
   1047 
   1048 int
   1049 socket_get_peer_address( int  fd, SockAddress*  address )
   1050 {
   1051     sockaddr_storage  addr;
   1052     socklen_t         addrlen = sizeof(addr);
   1053     int               ret;
   1054 
   1055     QSOCKET_CALL(ret, getpeername(fd, addr.sa, &addrlen));
   1056     if (ret < 0)
   1057         return fix_errno();
   1058 
   1059     return sock_address_from_bsd(address, &addr, addrlen);
   1060 }
   1061 
   1062 int
   1063 socket_listen( int  fd, int  backlog )
   1064 {
   1065     SOCKET_CALL(listen(fd, backlog));
   1066 }
   1067 
   1068 int
   1069 socket_accept( int  fd, SockAddress*  address )
   1070 {
   1071     sockaddr_storage  addr;
   1072     socklen_t         addrlen = sizeof(addr);
   1073     int               ret;
   1074 
   1075     QSOCKET_CALL(ret, accept(fd, addr.sa, &addrlen));
   1076     if (ret < 0)
   1077         return fix_errno();
   1078 
   1079     if (address) {
   1080         if (sock_address_from_bsd(address, &addr, addrlen) < 0) {
   1081             socket_close(ret);
   1082             return -1;
   1083         }
   1084     }
   1085     return ret;
   1086 }
   1087 
   1088 static int
   1089 socket_getoption(int  fd, int  domain, int  option, int  defaut)
   1090 {
   1091     int  ret;
   1092     while (1) {
   1093 #ifdef _WIN32
   1094         DWORD opt = (DWORD)-1;
   1095 #else
   1096         int  opt  = -1;
   1097 #endif
   1098         socklen_t  optlen = sizeof(opt);
   1099         ret = getsockopt(fd, domain, option, (char*)&opt, &optlen);
   1100         if (ret == 0)
   1101             return (int)opt;
   1102         if (errno != EINTR)
   1103             return defaut;
   1104     }
   1105 #undef OPT_CAST
   1106 }
   1107 
   1108 
   1109 SocketType socket_get_type(int fd)
   1110 {
   1111     int   so_type = socket_getoption(fd, SOL_SOCKET, SO_TYPE, -1);
   1112     return socket_type_from_bsd(so_type);
   1113 }
   1114 
   1115 int socket_set_nonblock(int fd)
   1116 {
   1117 #ifdef _WIN32
   1118     unsigned long opt = 1;
   1119     return ioctlsocket(fd, FIONBIO, &opt);
   1120 #else
   1121     int   flags = fcntl(fd, F_GETFL);
   1122     return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
   1123 #endif
   1124 }
   1125 
   1126 int socket_set_blocking(int fd)
   1127 {
   1128 #ifdef _WIN32
   1129     unsigned long opt = 0;
   1130     return ioctlsocket(fd, FIONBIO, &opt);
   1131 #else
   1132     int   flags = fcntl(fd, F_GETFL);
   1133     return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
   1134 #endif
   1135 }
   1136 
   1137 static int
   1138 socket_setoption(int  fd, int  domain, int  option, int  _flag)
   1139 {
   1140 #ifdef _WIN32
   1141     DWORD  flag = (DWORD) _flag;
   1142 #else
   1143     int    flag = _flag;
   1144 #endif
   1145     return setsockopt( fd, domain, option, (const char*)&flag, sizeof(flag) );
   1146 }
   1147 
   1148 int socket_set_xreuseaddr(int  fd)
   1149 {
   1150 #ifdef _WIN32
   1151    /* on Windows, SO_REUSEADDR is used to indicate that several programs can
   1152     * bind to the same port. this is completely different from the Unix
   1153     * semantics. instead of SO_EXCLUSIVEADDR to ensure that explicitely prevent
   1154     * this.
   1155     */
   1156     return socket_setoption(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, 1);
   1157 #else
   1158     return socket_setoption(fd, SOL_SOCKET, SO_REUSEADDR, 1);
   1159 #endif
   1160 }
   1161 
   1162 
   1163 int socket_set_oobinline(int  fd)
   1164 {
   1165     return socket_setoption(fd, SOL_SOCKET, SO_OOBINLINE, 1);
   1166 }
   1167 
   1168 
   1169 int  socket_set_nodelay(int  fd)
   1170 {
   1171     return socket_setoption(fd, IPPROTO_TCP, TCP_NODELAY, 1);
   1172 }
   1173 
   1174 int socket_set_ipv6only(int  fd)
   1175 {
   1176 /* IPV6_ONLY is only supported since Vista on Windows,
   1177  * and the Mingw headers lack its definition anyway.
   1178  */
   1179 #if defined(_WIN32) && !defined(IPV6_V6ONLY)
   1180 	return 0;
   1181 #else
   1182     return socket_setoption(fd, IPPROTO_IPV6, IPV6_V6ONLY, 1);
   1183 #endif
   1184 }
   1185 
   1186 
   1187 int socket_get_error(int fd)
   1188 {
   1189     return socket_getoption(fd, SOL_SOCKET, SO_ERROR, -1);
   1190 }
   1191 
   1192 #ifdef _WIN32
   1193 #include <stdlib.h>
   1194 
   1195 static void socket_cleanup(void)
   1196 {
   1197     WSACleanup();
   1198 }
   1199 
   1200 int socket_init(void)
   1201 {
   1202     WSADATA Data;
   1203     int ret, err;
   1204 
   1205     ret = WSAStartup(MAKEWORD(2,2), &Data);
   1206     if (ret != 0) {
   1207         err = WSAGetLastError();
   1208         return -1;
   1209     }
   1210     atexit(socket_cleanup);
   1211     return 0;
   1212 }
   1213 
   1214 #else /* !_WIN32 */
   1215 
   1216 int socket_init(void)
   1217 {
   1218    return 0;   /* nothing to do on Unix */
   1219 }
   1220 
   1221 #endif /* !_WIN32 */
   1222 
   1223 #ifdef _WIN32
   1224 
   1225 static void
   1226 socket_close_handler( void*  _fd )
   1227 {
   1228     int   fd = (int)_fd;
   1229     int   ret;
   1230     char  buff[64];
   1231 
   1232     /* we want to drain the read side of the socket before closing it */
   1233     do {
   1234         ret = recv( fd, buff, sizeof(buff), 0 );
   1235     } while (ret < 0 && WSAGetLastError() == WSAEINTR);
   1236 
   1237     if (ret < 0 && WSAGetLastError() == EWOULDBLOCK)
   1238         return;
   1239 
   1240     qemu_set_fd_handler( fd, NULL, NULL, NULL );
   1241     closesocket( fd );
   1242 }
   1243 
   1244 void
   1245 socket_close( int  fd )
   1246 {
   1247     int  old_errno = errno;
   1248 
   1249     shutdown( fd, SD_BOTH );
   1250     /* we want to drain the socket before closing it */
   1251     qemu_set_fd_handler( fd, socket_close_handler, NULL, (void*)fd );
   1252 
   1253     errno = old_errno;
   1254 }
   1255 
   1256 #else /* !_WIN32 */
   1257 
   1258 #include <unistd.h>
   1259 
   1260 void
   1261 socket_close( int  fd )
   1262 {
   1263     int  old_errno = errno;
   1264 
   1265     shutdown( fd, SHUT_RDWR );
   1266     close( fd );
   1267 
   1268     errno = old_errno;
   1269 }
   1270 
   1271 #endif /* !_WIN32 */
   1272 
   1273 
   1274 static int
   1275 socket_bind_server( int  s, const SockAddress*  to, SocketType  type )
   1276 {
   1277     socket_set_xreuseaddr(s);
   1278 
   1279     if (socket_bind(s, to) < 0) {
   1280         D("could not bind server socket address %s: %s",
   1281           sock_address_to_string(to), errno_str);
   1282         goto FAIL;
   1283     }
   1284 
   1285     if (type == SOCKET_STREAM) {
   1286         if (socket_listen(s, 4) < 0) {
   1287             D("could not listen server socket %s: %s",
   1288               sock_address_to_string(to), errno_str);
   1289             goto FAIL;
   1290         }
   1291     }
   1292     return  s;
   1293 
   1294 FAIL:
   1295     socket_close(s);
   1296     return -1;
   1297 }
   1298 
   1299 
   1300 static int
   1301 socket_connect_client( int  s, const SockAddress*  to )
   1302 {
   1303     if (socket_connect(s, to) < 0) {
   1304         D( "could not connect client socket to %s: %s\n",
   1305            sock_address_to_string(to), errno_str );
   1306         socket_close(s);
   1307         return -1;
   1308     }
   1309 
   1310     socket_set_nonblock( s );
   1311     return s;
   1312 }
   1313 
   1314 
   1315 static int
   1316 socket_in_server( int  address, int  port, SocketType  type )
   1317 {
   1318     SockAddress  addr;
   1319     int          s;
   1320 
   1321     sock_address_init_inet( &addr, address, port );
   1322     s = socket_create_inet( type );
   1323     if (s < 0)
   1324         return -1;
   1325 
   1326     return socket_bind_server( s, &addr, type );
   1327 }
   1328 
   1329 
   1330 static int
   1331 socket_in_client( SockAddress*  to, SocketType  type )
   1332 {
   1333     int  s;
   1334 
   1335     s = socket_create_inet( type );
   1336     if (s < 0) return -1;
   1337 
   1338     return socket_connect_client( s, to );
   1339 }
   1340 
   1341 
   1342 int
   1343 socket_loopback_server( int  port, SocketType  type )
   1344 {
   1345     return socket_in_server( SOCK_ADDRESS_INET_LOOPBACK, port, type );
   1346 }
   1347 
   1348 int
   1349 socket_loopback_client( int  port, SocketType  type )
   1350 {
   1351     SockAddress  addr;
   1352 
   1353     sock_address_init_inet( &addr, SOCK_ADDRESS_INET_LOOPBACK, port );
   1354     return socket_in_client( &addr, type );
   1355 }
   1356 
   1357 
   1358 int
   1359 socket_network_client( const char*  host, int  port, SocketType  type )
   1360 {
   1361     SockAddress  addr;
   1362 
   1363     if (sock_address_init_resolve( &addr, host, port, 0) < 0)
   1364         return -1;
   1365 
   1366     return socket_in_client( &addr, type );
   1367 }
   1368 
   1369 
   1370 int
   1371 socket_anyaddr_server( int  port, SocketType  type )
   1372 {
   1373     return socket_in_server( SOCK_ADDRESS_INET_ANY, port, type );
   1374 }
   1375 
   1376 int
   1377 socket_accept_any( int  server_fd )
   1378 {
   1379     int  fd;
   1380 
   1381     QSOCKET_CALL(fd, accept( server_fd, NULL, 0 ));
   1382     if (fd < 0) {
   1383         D( "could not accept client connection from fd %d: %s",
   1384            server_fd, errno_str );
   1385         return -1;
   1386     }
   1387 
   1388     /* set to non-blocking */
   1389     socket_set_nonblock( fd );
   1390     return fd;
   1391 }
   1392 
   1393 
   1394 #if HAVE_UNIX_SOCKETS
   1395 
   1396 int
   1397 socket_unix_server( const char*  name, SocketType  type )
   1398 {
   1399     SockAddress   addr;
   1400     int           s, ret;
   1401 
   1402     s = socket_create_unix( type );
   1403     if (s < 0)
   1404         return -1;
   1405 
   1406     sock_address_init_unix( &addr, name );
   1407 
   1408     do {
   1409         ret = unlink( name );
   1410     } while (ret < 0 && errno == EINTR);
   1411 
   1412     ret = socket_bind_server( s, &addr, type );
   1413 
   1414     sock_address_done( &addr );
   1415     return ret;
   1416 }
   1417 
   1418 int
   1419 socket_unix_client( const char*  name, SocketType  type )
   1420 {
   1421     SockAddress   addr;
   1422     int           s, ret;
   1423 
   1424     s = socket_create_unix(type);
   1425     if (s < 0)
   1426         return -1;
   1427 
   1428     sock_address_init_unix( &addr, name );
   1429 
   1430     ret =  socket_connect_client( s, &addr );
   1431 
   1432     sock_address_done( &addr );
   1433     return ret;
   1434 }
   1435 
   1436 #endif /* HAVE_UNIX_SOCKETS */
   1437 
   1438 
   1439 
   1440 int
   1441 socket_pair(int *fd1, int *fd2)
   1442 {
   1443 #ifndef _WIN32
   1444     int   fds[2];
   1445     int   ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
   1446 
   1447     if (!ret) {
   1448         socket_set_nonblock(fds[0]);
   1449         socket_set_nonblock(fds[1]);
   1450         *fd1 = fds[0];
   1451         *fd2 = fds[1];
   1452     }
   1453     return ret;
   1454 #else /* _WIN32 */
   1455     /* on Windows, select() only works with network sockets, which
   1456      * means we absolutely cannot use Win32 PIPEs to implement
   1457      * socket pairs with the current event loop implementation.
   1458      * We're going to do like Cygwin: create a random pair
   1459      * of localhost TCP sockets and connect them together
   1460      */
   1461     int                 s0, s1, s2, port;
   1462     struct sockaddr_in  sockin;
   1463     socklen_t           len;
   1464 
   1465     /* first, create the 'server' socket.
   1466      * a port number of 0 means 'any port between 1024 and 5000.
   1467      * see Winsock bind() documentation for details */
   1468     s0 = socket_loopback_server( 0, SOCK_STREAM );
   1469     if (s0 < 0)
   1470         return -1;
   1471 
   1472     /* now connect a client socket to it, we first need to
   1473      * extract the server socket's port number */
   1474     len = sizeof sockin;
   1475     if (getsockname(s0, (struct sockaddr*) &sockin, &len) < 0) {
   1476         closesocket (s0);
   1477         return -1;
   1478     }
   1479 
   1480     port = ntohs(sockin.sin_port);
   1481     s2   = socket_loopback_client( port, SOCK_STREAM );
   1482     if (s2 < 0) {
   1483         closesocket(s0);
   1484         return -1;
   1485     }
   1486 
   1487     /* we need to accept the connection on the server socket
   1488      * this will create the second socket for the pair
   1489      */
   1490     len = sizeof sockin;
   1491     s1  = accept(s0, (struct sockaddr*) &sockin, &len);
   1492     if (s1 == INVALID_SOCKET) {
   1493         closesocket (s0);
   1494         closesocket (s2);
   1495         return -1;
   1496     }
   1497     socket_set_nonblock(s1);
   1498 
   1499     /* close server socket */
   1500     closesocket(s0);
   1501     *fd1 = s1;
   1502     *fd2 = s2;
   1503     return 0;
   1504 #endif /* _WIN32 */
   1505 }
   1506 
   1507 
   1508 
   1509 int
   1510 socket_mcast_inet_add_membership( int  s, uint32_t  ip )
   1511 {
   1512     struct ip_mreq imr;
   1513 
   1514     imr.imr_multiaddr.s_addr = htonl(ip);
   1515     imr.imr_interface.s_addr = htonl(INADDR_ANY);
   1516 
   1517     if ( setsockopt( s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
   1518                      (const char *)&imr,
   1519                      sizeof(struct ip_mreq)) < 0 )
   1520     {
   1521         return fix_errno();
   1522     }
   1523     return 0;
   1524 }
   1525 
   1526 int
   1527 socket_mcast_inet_drop_membership( int  s, uint32_t  ip )
   1528 {
   1529     struct ip_mreq imr;
   1530 
   1531     imr.imr_multiaddr.s_addr = htonl(ip);
   1532     imr.imr_interface.s_addr = htonl(INADDR_ANY);
   1533 
   1534     if ( setsockopt( s, IPPROTO_IP, IP_DROP_MEMBERSHIP,
   1535                      (const char *)&imr,
   1536                      sizeof(struct ip_mreq)) < 0 )
   1537     {
   1538         return fix_errno();
   1539     }
   1540     return 0;
   1541 }
   1542 
   1543 int
   1544 socket_mcast_inet_set_loop( int  s, int  enabled )
   1545 {
   1546     return socket_setoption( s, IPPROTO_IP, IP_MULTICAST_LOOP, !!enabled );
   1547 }
   1548 
   1549 int
   1550 socket_mcast_inet_set_ttl( int  s, int  ttl )
   1551 {
   1552     return socket_setoption( s, IPPROTO_IP, IP_MULTICAST_TTL, ttl );
   1553 }
   1554 
   1555 
   1556 char*
   1557 host_name( void )
   1558 {
   1559     static char buf[256];  /* 255 is the max host name length supported by DNS */
   1560     int         ret;
   1561 
   1562     QSOCKET_CALL(ret, gethostname(buf, sizeof(buf)));
   1563 
   1564     if (ret < 0)
   1565         return "localhost";
   1566     else
   1567         return buf;
   1568 }
   1569