Annotation of qemu/qemu-sockets.c, revision 1.1.1.3

1.1       root        1: /*
                      2:  *  inet and unix socket functions for qemu
                      3:  *
                      4:  *  (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
                      5:  *
                      6:  *  This program is free software; you can redistribute it and/or modify
                      7:  *  it under the terms of the GNU General Public License as published by
                      8:  *  the Free Software Foundation; under version 2 of the License.
                      9:  *
                     10:  *  This program is distributed in the hope that it will be useful,
                     11:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
                     12:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     13:  *  GNU General Public License for more details.
                     14:  */
                     15: #include <stdio.h>
                     16: #include <stdlib.h>
                     17: #include <string.h>
                     18: #include <ctype.h>
                     19: #include <errno.h>
                     20: #include <unistd.h>
                     21: 
                     22: #include "qemu_socket.h"
                     23: #include "qemu-common.h" /* for qemu_isdigit */
                     24: 
                     25: #ifndef AI_ADDRCONFIG
                     26: # define AI_ADDRCONFIG 0
                     27: #endif
                     28: 
                     29: static int sockets_debug = 0;
                     30: static const int on=1, off=0;
                     31: 
1.1.1.3 ! root       32: /* used temporarely until all users are converted to QemuOpts */
        !            33: static QemuOptsList dummy_opts = {
        !            34:     .name = "dummy",
        !            35:     .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
        !            36:     .desc = {
        !            37:         {
        !            38:             .name = "path",
        !            39:             .type = QEMU_OPT_STRING,
        !            40:         },{
        !            41:             .name = "host",
        !            42:             .type = QEMU_OPT_STRING,
        !            43:         },{
        !            44:             .name = "port",
        !            45:             .type = QEMU_OPT_STRING,
        !            46:         },{
        !            47:             .name = "to",
        !            48:             .type = QEMU_OPT_NUMBER,
        !            49:         },{
        !            50:             .name = "ipv4",
        !            51:             .type = QEMU_OPT_BOOL,
        !            52:         },{
        !            53:             .name = "ipv6",
        !            54:             .type = QEMU_OPT_BOOL,
        !            55:         },
        !            56:         { /* end if list */ }
        !            57:     },
        !            58: };
        !            59: 
1.1       root       60: static int inet_getport(struct addrinfo *e)
                     61: {
                     62:     struct sockaddr_in *i4;
                     63:     struct sockaddr_in6 *i6;
                     64: 
                     65:     switch (e->ai_family) {
                     66:     case PF_INET6:
                     67:         i6 = (void*)e->ai_addr;
                     68:         return ntohs(i6->sin6_port);
                     69:     case PF_INET:
                     70:         i4 = (void*)e->ai_addr;
                     71:         return ntohs(i4->sin_port);
                     72:     default:
                     73:         return 0;
                     74:     }
                     75: }
                     76: 
                     77: static void inet_setport(struct addrinfo *e, int port)
                     78: {
                     79:     struct sockaddr_in *i4;
                     80:     struct sockaddr_in6 *i6;
                     81: 
                     82:     switch (e->ai_family) {
                     83:     case PF_INET6:
                     84:         i6 = (void*)e->ai_addr;
                     85:         i6->sin6_port = htons(port);
                     86:         break;
                     87:     case PF_INET:
                     88:         i4 = (void*)e->ai_addr;
                     89:         i4->sin_port = htons(port);
                     90:         break;
                     91:     }
                     92: }
                     93: 
                     94: static const char *inet_strfamily(int family)
                     95: {
                     96:     switch (family) {
                     97:     case PF_INET6: return "ipv6";
                     98:     case PF_INET:  return "ipv4";
                     99:     case PF_UNIX:  return "unix";
                    100:     }
                    101:     return "????";
                    102: }
                    103: 
                    104: static void inet_print_addrinfo(const char *tag, struct addrinfo *res)
                    105: {
                    106:     struct addrinfo *e;
                    107:     char uaddr[INET6_ADDRSTRLEN+1];
                    108:     char uport[33];
                    109: 
                    110:     for (e = res; e != NULL; e = e->ai_next) {
                    111:         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
                    112:                     uaddr,INET6_ADDRSTRLEN,uport,32,
                    113:                     NI_NUMERICHOST | NI_NUMERICSERV);
                    114:         fprintf(stderr,"%s: getaddrinfo: family %s, host %s, port %s\n",
                    115:                 tag, inet_strfamily(e->ai_family), uaddr, uport);
                    116:     }
                    117: }
                    118: 
1.1.1.3 ! root      119: int inet_listen_opts(QemuOpts *opts, int port_offset)
1.1       root      120: {
                    121:     struct addrinfo ai,*res,*e;
1.1.1.3 ! root      122:     const char *addr;
1.1       root      123:     char port[33];
                    124:     char uaddr[INET6_ADDRSTRLEN+1];
                    125:     char uport[33];
1.1.1.3 ! root      126:     int slisten,rc,to,try_next;
1.1       root      127: 
                    128:     memset(&ai,0, sizeof(ai));
                    129:     ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
                    130:     ai.ai_family = PF_UNSPEC;
1.1.1.3 ! root      131:     ai.ai_socktype = SOCK_STREAM;
1.1       root      132: 
1.1.1.3 ! root      133:     if (qemu_opt_get(opts, "port") == NULL) {
        !           134:         fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
        !           135:         return -1;
1.1       root      136:     }
1.1.1.3 ! root      137:     pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
        !           138:     addr = qemu_opt_get(opts, "host");
1.1       root      139: 
1.1.1.3 ! root      140:     to = qemu_opt_get_number(opts, "to", 0);
        !           141:     if (qemu_opt_get_bool(opts, "ipv4", 0))
1.1       root      142:         ai.ai_family = PF_INET;
1.1.1.3 ! root      143:     if (qemu_opt_get_bool(opts, "ipv6", 0))
1.1       root      144:         ai.ai_family = PF_INET6;
                    145: 
                    146:     /* lookup */
                    147:     if (port_offset)
                    148:         snprintf(port, sizeof(port), "%d", atoi(port) + port_offset);
                    149:     rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res);
                    150:     if (rc != 0) {
1.1.1.3 ! root      151:         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
        !           152:                 gai_strerror(rc));
1.1       root      153:         return -1;
                    154:     }
                    155:     if (sockets_debug)
                    156:         inet_print_addrinfo(__FUNCTION__, res);
                    157: 
                    158:     /* create socket + bind */
                    159:     for (e = res; e != NULL; e = e->ai_next) {
1.1.1.2   root      160:         getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
                    161:                        uaddr,INET6_ADDRSTRLEN,uport,32,
                    162:                        NI_NUMERICHOST | NI_NUMERICSERV);
1.1.1.3 ! root      163:         slisten = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
1.1.1.2   root      164:         if (slisten < 0) {
1.1       root      165:             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
                    166:                     inet_strfamily(e->ai_family), strerror(errno));
1.1.1.2   root      167:             continue;
                    168:         }
1.1       root      169: 
                    170:         setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
                    171: #ifdef IPV6_V6ONLY
                    172:         if (e->ai_family == PF_INET6) {
                    173:             /* listen on both ipv4 and ipv6 */
1.1.1.2   root      174:             setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off,
                    175:                 sizeof(off));
1.1       root      176:         }
                    177: #endif
                    178: 
                    179:         for (;;) {
                    180:             if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) {
                    181:                 if (sockets_debug)
                    182:                     fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
1.1.1.2   root      183:                         inet_strfamily(e->ai_family), uaddr, inet_getport(e));
1.1       root      184:                 goto listen;
                    185:             }
                    186:             try_next = to && (inet_getport(e) <= to + port_offset);
                    187:             if (!try_next || sockets_debug)
                    188:                 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__,
                    189:                         inet_strfamily(e->ai_family), uaddr, inet_getport(e),
                    190:                         strerror(errno));
                    191:             if (try_next) {
                    192:                 inet_setport(e, inet_getport(e) + 1);
                    193:                 continue;
                    194:             }
                    195:             break;
                    196:         }
                    197:         closesocket(slisten);
                    198:     }
                    199:     fprintf(stderr, "%s: FAILED\n", __FUNCTION__);
                    200:     freeaddrinfo(res);
                    201:     return -1;
                    202: 
                    203: listen:
                    204:     if (listen(slisten,1) != 0) {
                    205:         perror("listen");
                    206:         closesocket(slisten);
1.1.1.2   root      207:         freeaddrinfo(res);
1.1       root      208:         return -1;
                    209:     }
1.1.1.3 ! root      210:     snprintf(uport, sizeof(uport), "%d", inet_getport(e) - port_offset);
        !           211:     qemu_opt_set(opts, "host", uaddr);
        !           212:     qemu_opt_set(opts, "port", uport);
        !           213:     qemu_opt_set(opts, "ipv6", (e->ai_family == PF_INET6) ? "on" : "off");
        !           214:     qemu_opt_set(opts, "ipv4", (e->ai_family != PF_INET6) ? "on" : "off");
1.1       root      215:     freeaddrinfo(res);
                    216:     return slisten;
                    217: }
                    218: 
1.1.1.3 ! root      219: int inet_connect_opts(QemuOpts *opts)
1.1       root      220: {
                    221:     struct addrinfo ai,*res,*e;
1.1.1.3 ! root      222:     const char *addr;
        !           223:     const char *port;
1.1       root      224:     char uaddr[INET6_ADDRSTRLEN+1];
                    225:     char uport[33];
                    226:     int sock,rc;
                    227: 
                    228:     memset(&ai,0, sizeof(ai));
                    229:     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
                    230:     ai.ai_family = PF_UNSPEC;
1.1.1.3 ! root      231:     ai.ai_socktype = SOCK_STREAM;
1.1       root      232: 
1.1.1.3 ! root      233:     addr = qemu_opt_get(opts, "host");
        !           234:     port = qemu_opt_get(opts, "port");
        !           235:     if (addr == NULL || port == NULL) {
        !           236:         fprintf(stderr, "inet_connect: host and/or port not specified\n");
        !           237:         return -1;
1.1       root      238:     }
                    239: 
1.1.1.3 ! root      240:     if (qemu_opt_get_bool(opts, "ipv4", 0))
1.1       root      241:         ai.ai_family = PF_INET;
1.1.1.3 ! root      242:     if (qemu_opt_get_bool(opts, "ipv6", 0))
1.1       root      243:         ai.ai_family = PF_INET6;
                    244: 
                    245:     /* lookup */
                    246:     if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) {
1.1.1.3 ! root      247:         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
        !           248:                 gai_strerror(rc));
1.1       root      249:        return -1;
                    250:     }
                    251:     if (sockets_debug)
                    252:         inet_print_addrinfo(__FUNCTION__, res);
                    253: 
                    254:     for (e = res; e != NULL; e = e->ai_next) {
1.1.1.2   root      255:         if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen,
                    256:                             uaddr,INET6_ADDRSTRLEN,uport,32,
                    257:                             NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
1.1       root      258:             fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__);
1.1.1.2   root      259:             continue;
                    260:         }
1.1.1.3 ! root      261:         sock = qemu_socket(e->ai_family, e->ai_socktype, e->ai_protocol);
1.1.1.2   root      262:         if (sock < 0) {
1.1       root      263:             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
1.1.1.2   root      264:             inet_strfamily(e->ai_family), strerror(errno));
                    265:             continue;
                    266:         }
1.1       root      267:         setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
                    268: 
1.1.1.2   root      269:         /* connect to peer */
                    270:         if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) {
1.1       root      271:             if (sockets_debug || NULL == e->ai_next)
                    272:                 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
                    273:                         inet_strfamily(e->ai_family),
                    274:                         e->ai_canonname, uaddr, uport, strerror(errno));
                    275:             closesocket(sock);
1.1.1.2   root      276:             continue;
                    277:         }
1.1       root      278:         if (sockets_debug)
                    279:             fprintf(stderr, "%s: connect(%s,%s,%s,%s): OK\n", __FUNCTION__,
                    280:                     inet_strfamily(e->ai_family),
                    281:                     e->ai_canonname, uaddr, uport);
                    282:         freeaddrinfo(res);
1.1.1.2   root      283:         return sock;
1.1       root      284:     }
                    285:     freeaddrinfo(res);
                    286:     return -1;
                    287: }
                    288: 
1.1.1.3 ! root      289: int inet_dgram_opts(QemuOpts *opts)
        !           290: {
        !           291:     struct addrinfo ai, *peer = NULL, *local = NULL;
        !           292:     const char *addr;
        !           293:     const char *port;
        !           294:     char uaddr[INET6_ADDRSTRLEN+1];
        !           295:     char uport[33];
        !           296:     int sock = -1, rc;
        !           297: 
        !           298:     /* lookup peer addr */
        !           299:     memset(&ai,0, sizeof(ai));
        !           300:     ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG;
        !           301:     ai.ai_family = PF_UNSPEC;
        !           302:     ai.ai_socktype = SOCK_DGRAM;
        !           303: 
        !           304:     addr = qemu_opt_get(opts, "host");
        !           305:     port = qemu_opt_get(opts, "port");
        !           306:     if (addr == NULL || strlen(addr) == 0) {
        !           307:         addr = "localhost";
        !           308:     }
        !           309:     if (port == NULL || strlen(port) == 0) {
        !           310:         fprintf(stderr, "inet_dgram: port not specified\n");
        !           311:         return -1;
        !           312:     }
        !           313: 
        !           314:     if (qemu_opt_get_bool(opts, "ipv4", 0))
        !           315:         ai.ai_family = PF_INET;
        !           316:     if (qemu_opt_get_bool(opts, "ipv6", 0))
        !           317:         ai.ai_family = PF_INET6;
        !           318: 
        !           319:     if (0 != (rc = getaddrinfo(addr, port, &ai, &peer))) {
        !           320:         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
        !           321:                 gai_strerror(rc));
        !           322:        return -1;
        !           323:     }
        !           324:     if (sockets_debug) {
        !           325:         fprintf(stderr, "%s: peer (%s:%s)\n", __FUNCTION__, addr, port);
        !           326:         inet_print_addrinfo(__FUNCTION__, peer);
        !           327:     }
        !           328: 
        !           329:     /* lookup local addr */
        !           330:     memset(&ai,0, sizeof(ai));
        !           331:     ai.ai_flags = AI_PASSIVE;
        !           332:     ai.ai_family = peer->ai_family;
        !           333:     ai.ai_socktype = SOCK_DGRAM;
        !           334: 
        !           335:     addr = qemu_opt_get(opts, "localaddr");
        !           336:     port = qemu_opt_get(opts, "localport");
        !           337:     if (addr == NULL || strlen(addr) == 0) {
        !           338:         addr = NULL;
        !           339:     }
        !           340:     if (!port || strlen(port) == 0)
        !           341:         port = "0";
        !           342: 
        !           343:     if (0 != (rc = getaddrinfo(addr, port, &ai, &local))) {
        !           344:         fprintf(stderr,"getaddrinfo(%s,%s): %s\n", addr, port,
        !           345:                 gai_strerror(rc));
        !           346:         return -1;
        !           347:     }
        !           348:     if (sockets_debug) {
        !           349:         fprintf(stderr, "%s: local (%s:%s)\n", __FUNCTION__, addr, port);
        !           350:         inet_print_addrinfo(__FUNCTION__, local);
        !           351:     }
        !           352: 
        !           353:     /* create socket */
        !           354:     sock = qemu_socket(peer->ai_family, peer->ai_socktype, peer->ai_protocol);
        !           355:     if (sock < 0) {
        !           356:         fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
        !           357:                 inet_strfamily(peer->ai_family), strerror(errno));
        !           358:         goto err;
        !           359:     }
        !           360:     setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
        !           361: 
        !           362:     /* bind socket */
        !           363:     if (getnameinfo((struct sockaddr*)local->ai_addr,local->ai_addrlen,
        !           364:                     uaddr,INET6_ADDRSTRLEN,uport,32,
        !           365:                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
        !           366:         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
        !           367:         goto err;
        !           368:     }
        !           369:     if (bind(sock, local->ai_addr, local->ai_addrlen) < 0) {
        !           370:         fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__,
        !           371:                 inet_strfamily(local->ai_family), uaddr, inet_getport(local));
        !           372:         goto err;
        !           373:     }
        !           374: 
        !           375:     /* connect to peer */
        !           376:     if (getnameinfo((struct sockaddr*)peer->ai_addr, peer->ai_addrlen,
        !           377:                     uaddr, INET6_ADDRSTRLEN, uport, 32,
        !           378:                     NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
        !           379:         fprintf(stderr, "%s: getnameinfo: oops\n", __FUNCTION__);
        !           380:         goto err;
        !           381:     }
        !           382:     if (connect(sock,peer->ai_addr,peer->ai_addrlen) < 0) {
        !           383:         fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__,
        !           384:                 inet_strfamily(peer->ai_family),
        !           385:                 peer->ai_canonname, uaddr, uport, strerror(errno));
        !           386:         goto err;
        !           387:     }
        !           388: 
        !           389:     freeaddrinfo(local);
        !           390:     freeaddrinfo(peer);
        !           391:     return sock;
        !           392: 
        !           393: err:
        !           394:     if (-1 != sock)
        !           395:         closesocket(sock);
        !           396:     if (local)
        !           397:         freeaddrinfo(local);
        !           398:     if (peer)
        !           399:         freeaddrinfo(peer);
        !           400:     return -1;
        !           401: }
        !           402: 
        !           403: /* compatibility wrapper */
        !           404: static int inet_parse(QemuOpts *opts, const char *str)
        !           405: {
        !           406:     const char *optstr, *h;
        !           407:     char addr[64];
        !           408:     char port[33];
        !           409:     int pos;
        !           410: 
        !           411:     /* parse address */
        !           412:     if (str[0] == ':') {
        !           413:         /* no host given */
        !           414:         addr[0] = '\0';
        !           415:         if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
        !           416:             fprintf(stderr, "%s: portonly parse error (%s)\n",
        !           417:                     __FUNCTION__, str);
        !           418:             return -1;
        !           419:         }
        !           420:     } else if (str[0] == '[') {
        !           421:         /* IPv6 addr */
        !           422:         if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
        !           423:             fprintf(stderr, "%s: ipv6 parse error (%s)\n",
        !           424:                     __FUNCTION__, str);
        !           425:             return -1;
        !           426:         }
        !           427:         qemu_opt_set(opts, "ipv6", "yes");
        !           428:     } else if (qemu_isdigit(str[0])) {
        !           429:         /* IPv4 addr */
        !           430:         if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
        !           431:             fprintf(stderr, "%s: ipv4 parse error (%s)\n",
        !           432:                     __FUNCTION__, str);
        !           433:             return -1;
        !           434:         }
        !           435:         qemu_opt_set(opts, "ipv4", "yes");
        !           436:     } else {
        !           437:         /* hostname */
        !           438:         if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
        !           439:             fprintf(stderr, "%s: hostname parse error (%s)\n",
        !           440:                     __FUNCTION__, str);
        !           441:             return -1;
        !           442:         }
        !           443:     }
        !           444:     qemu_opt_set(opts, "host", addr);
        !           445:     qemu_opt_set(opts, "port", port);
        !           446: 
        !           447:     /* parse options */
        !           448:     optstr = str + pos;
        !           449:     h = strstr(optstr, ",to=");
        !           450:     if (h)
        !           451:         qemu_opt_set(opts, "to", h+4);
        !           452:     if (strstr(optstr, ",ipv4"))
        !           453:         qemu_opt_set(opts, "ipv4", "yes");
        !           454:     if (strstr(optstr, ",ipv6"))
        !           455:         qemu_opt_set(opts, "ipv6", "yes");
        !           456:     return 0;
        !           457: }
        !           458: 
        !           459: int inet_listen(const char *str, char *ostr, int olen,
        !           460:                 int socktype, int port_offset)
        !           461: {
        !           462:     QemuOpts *opts;
        !           463:     char *optstr;
        !           464:     int sock = -1;
        !           465: 
        !           466:     opts = qemu_opts_create(&dummy_opts, NULL, 0);
        !           467:     if (inet_parse(opts, str) == 0) {
        !           468:         sock = inet_listen_opts(opts, port_offset);
        !           469:         if (sock != -1 && ostr) {
        !           470:             optstr = strchr(str, ',');
        !           471:             if (qemu_opt_get_bool(opts, "ipv6", 0)) {
        !           472:                 snprintf(ostr, olen, "[%s]:%s%s",
        !           473:                          qemu_opt_get(opts, "host"),
        !           474:                          qemu_opt_get(opts, "port"),
        !           475:                          optstr ? optstr : "");
        !           476:             } else {
        !           477:                 snprintf(ostr, olen, "%s:%s%s",
        !           478:                          qemu_opt_get(opts, "host"),
        !           479:                          qemu_opt_get(opts, "port"),
        !           480:                          optstr ? optstr : "");
        !           481:             }
        !           482:         }
        !           483:     }
        !           484:     qemu_opts_del(opts);
        !           485:     return sock;
        !           486: }
        !           487: 
        !           488: int inet_connect(const char *str, int socktype)
        !           489: {
        !           490:     QemuOpts *opts;
        !           491:     int sock = -1;
        !           492: 
        !           493:     opts = qemu_opts_create(&dummy_opts, NULL, 0);
        !           494:     if (inet_parse(opts, str) == 0)
        !           495:         sock = inet_connect_opts(opts);
        !           496:     qemu_opts_del(opts);
        !           497:     return sock;
        !           498: }
        !           499: 
1.1       root      500: #ifndef _WIN32
                    501: 
1.1.1.3 ! root      502: int unix_listen_opts(QemuOpts *opts)
1.1       root      503: {
                    504:     struct sockaddr_un un;
1.1.1.3 ! root      505:     const char *path = qemu_opt_get(opts, "path");
        !           506:     int sock, fd;
1.1       root      507: 
1.1.1.3 ! root      508:     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
1.1       root      509:     if (sock < 0) {
1.1.1.2   root      510:         perror("socket(unix)");
                    511:         return -1;
1.1       root      512:     }
                    513: 
                    514:     memset(&un, 0, sizeof(un));
                    515:     un.sun_family = AF_UNIX;
                    516:     if (path && strlen(path)) {
                    517:         snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
                    518:     } else {
                    519:         char *tmpdir = getenv("TMPDIR");
                    520:         snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX",
                    521:                  tmpdir ? tmpdir : "/tmp");
                    522:         /*
                    523:          * This dummy fd usage silences the mktemp() unsecure warning.
                    524:          * Using mkstemp() doesn't make things more secure here
                    525:          * though.  bind() complains about existing files, so we have
                    526:          * to unlink first and thus re-open the race window.  The
                    527:          * worst case possible is bind() failing, i.e. a DoS attack.
                    528:          */
                    529:         fd = mkstemp(un.sun_path); close(fd);
1.1.1.3 ! root      530:         qemu_opt_set(opts, "path", un.sun_path);
1.1       root      531:     }
                    532: 
                    533:     unlink(un.sun_path);
                    534:     if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
                    535:         fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno));
                    536:         goto err;
                    537:     }
                    538:     if (listen(sock, 1) < 0) {
                    539:         fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno));
                    540:         goto err;
                    541:     }
                    542: 
                    543:     if (sockets_debug)
                    544:         fprintf(stderr, "bind(unix:%s): OK\n", un.sun_path);
                    545:     return sock;
                    546: 
                    547: err:
                    548:     closesocket(sock);
                    549:     return -1;
                    550: }
                    551: 
1.1.1.3 ! root      552: int unix_connect_opts(QemuOpts *opts)
1.1       root      553: {
                    554:     struct sockaddr_un un;
1.1.1.3 ! root      555:     const char *path = qemu_opt_get(opts, "path");
1.1       root      556:     int sock;
                    557: 
1.1.1.3 ! root      558:     if (NULL == path) {
        !           559:         fprintf(stderr, "unix connect: no path specified\n");
        !           560:         return -1;
        !           561:     }
        !           562: 
        !           563:     sock = qemu_socket(PF_UNIX, SOCK_STREAM, 0);
1.1       root      564:     if (sock < 0) {
1.1.1.2   root      565:         perror("socket(unix)");
                    566:         return -1;
1.1       root      567:     }
                    568: 
                    569:     memset(&un, 0, sizeof(un));
                    570:     un.sun_family = AF_UNIX;
                    571:     snprintf(un.sun_path, sizeof(un.sun_path), "%s", path);
                    572:     if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) {
                    573:         fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno));
                    574:        return -1;
                    575:     }
                    576: 
                    577:     if (sockets_debug)
                    578:         fprintf(stderr, "connect(unix:%s): OK\n", path);
                    579:     return sock;
                    580: }
                    581: 
1.1.1.3 ! root      582: /* compatibility wrapper */
        !           583: int unix_listen(const char *str, char *ostr, int olen)
        !           584: {
        !           585:     QemuOpts *opts;
        !           586:     char *path, *optstr;
        !           587:     int sock, len;
        !           588: 
        !           589:     opts = qemu_opts_create(&dummy_opts, NULL, 0);
        !           590: 
        !           591:     optstr = strchr(str, ',');
        !           592:     if (optstr) {
        !           593:         len = optstr - str;
        !           594:         if (len) {
        !           595:             path = qemu_malloc(len+1);
        !           596:             snprintf(path, len+1, "%.*s", len, str);
        !           597:             qemu_opt_set(opts, "path", path);
        !           598:             qemu_free(path);
        !           599:         }
        !           600:     } else {
        !           601:         qemu_opt_set(opts, "path", str);
        !           602:     }
        !           603: 
        !           604:     sock = unix_listen_opts(opts);
        !           605: 
        !           606:     if (sock != -1 && ostr)
        !           607:         snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
        !           608:     qemu_opts_del(opts);
        !           609:     return sock;
        !           610: }
        !           611: 
        !           612: int unix_connect(const char *path)
        !           613: {
        !           614:     QemuOpts *opts;
        !           615:     int sock;
        !           616: 
        !           617:     opts = qemu_opts_create(&dummy_opts, NULL, 0);
        !           618:     qemu_opt_set(opts, "path", path);
        !           619:     sock = unix_connect_opts(opts);
        !           620:     qemu_opts_del(opts);
        !           621:     return sock;
        !           622: }
        !           623: 
1.1       root      624: #else
                    625: 
1.1.1.3 ! root      626: int unix_listen_opts(QemuOpts *opts)
        !           627: {
        !           628:     fprintf(stderr, "unix sockets are not available on windows\n");
        !           629:     return -1;
        !           630: }
        !           631: 
        !           632: int unix_connect_opts(QemuOpts *opts)
        !           633: {
        !           634:     fprintf(stderr, "unix sockets are not available on windows\n");
        !           635:     return -1;
        !           636: }
        !           637: 
1.1       root      638: int unix_listen(const char *path, char *ostr, int olen)
                    639: {
                    640:     fprintf(stderr, "unix sockets are not available on windows\n");
                    641:     return -1;
                    642: }
                    643: 
                    644: int unix_connect(const char *path)
                    645: {
                    646:     fprintf(stderr, "unix sockets are not available on windows\n");
                    647:     return -1;
                    648: }
                    649: 
                    650: #endif

unix.superglobalmegacorp.com