upstream: qemu-sockets changes.

1 files changed, 250 insertions, 110 deletions

diff --git a/qemu-sockets-android.c b/qemu-sockets-android.c
index c22f352..dc64775 100644
--- a/qemu-sockets-android.c
+++ b/qemu-sockets-android.c
@@ -29,6 +29,35 @@
 static int sockets_debug = 0;
 static const int on=1, off=0;
 
+/* used temporarely until all users are converted to QemuOpts */
+static QemuOptsList dummy_opts = {
+    .name = "dummy",
+    .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
+    .desc = {
+        {
+            .name = "path",
+            .type = QEMU_OPT_STRING,
+        },{
+            .name = "host",
+            .type = QEMU_OPT_STRING,
+        },{
+            .name = "port",
+            .type = QEMU_OPT_STRING,
+        },{
+            .name = "to",
+            .type = QEMU_OPT_NUMBER,
+        },{
+            .name = "ipv4",
+            .type = QEMU_OPT_BOOL,
+        },{
+            .name = "ipv6",
+            .type = QEMU_OPT_BOOL,
+        },
+        { /* end if list */ }
+    },
+};
+
+
 static const char *sock_address_strfamily(SockAddress *s)
 {
     switch (sock_address_get_family(s)) {
@@ -39,64 +68,30 @@ static const char *sock_address_strfamily(SockAddress *s)
     }
 }
 
-int inet_listen(const char *str, char *ostr, int olen,
-                SocketType socktype, int port_offset)
+int inet_listen_opts(QemuOpts *opts, int port_offset)
 {
     SockAddress**  list;
     SockAddress*   e;
     unsigned       flags = SOCKET_LIST_PASSIVE;
-    char addr[64];
+    const char *addr;
     char port[33];
     char uaddr[256+1];
-    const char *opts, *h;
-    int slisten,pos,to,try_next,nn;
+    char uport[33];
+    int slisten,to,try_next,nn;
 
-    /* parse address */
-    if (str[0] == ':') {
-        /* no host given */
-        addr[0] = '\0';
-        if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
-            fprintf(stderr, "%s: portonly parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
-    } else if (str[0] == '[') {
-        /* IPv6 addr */
-        if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
-            fprintf(stderr, "%s: ipv6 parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
-        flags |= SOCKET_LIST_FORCE_IN6;
-    } else if (qemu_isdigit(str[0])) {
-        /* IPv4 addr */
-        if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
-            fprintf(stderr, "%s: ipv4 parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
-        flags |= SOCKET_LIST_FORCE_INET;
-    } else {
-        /* hostname */
-        if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
-            fprintf(stderr, "%s: hostname parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
+    if ((qemu_opt_get(opts, "host") == NULL) ||
+        (qemu_opt_get(opts, "port") == NULL)) {
+        fprintf(stderr, "%s: host and/or port not specified\n", __FUNCTION__);
+        return -1;
     }
+    pstrcpy(port, sizeof(port), qemu_opt_get(opts, "port"));
+    addr = qemu_opt_get(opts, "host");
 
-    /* parse options */
-    opts = str + pos;
-    h = strstr(opts, ",to=");
-    to = h ? atoi(h+4) : 0;
-    if (strstr(opts, ",ipv4")) {
-        flags &= ~SOCKET_LIST_FORCE_IN6;
+    to = qemu_opt_get_number(opts, "to", 0);
+    if (qemu_opt_get_bool(opts, "ipv4", 0))
         flags |= SOCKET_LIST_FORCE_INET;
-    }
-    if (strstr(opts, ",ipv6")) {
-        flags &= SOCKET_LIST_FORCE_INET;
+    if (qemu_opt_get_bool(opts, "ipv6", 0))
         flags |= SOCKET_LIST_FORCE_IN6;
-    }
 
     /* lookup */
     if (port_offset)
@@ -117,7 +112,9 @@ int inet_listen(const char *str, char *ostr, int olen,
 
         e      = list[nn];
         family = sock_address_get_family(e);
-        slisten = socket_create(family, socktype);
+
+        sock_address_get_numeric_info(e, uaddr, sizeof uaddr, uport, sizeof uport);
+        slisten = socket_create(family, SOCKET_STREAM);
         if (slisten < 0) {
             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
                     sock_address_strfamily(e), errno_str);
@@ -127,7 +124,7 @@ int inet_listen(const char *str, char *ostr, int olen,
         socket_set_xreuseaddr(slisten);
 #ifdef IPV6_V6ONLY
         /* listen on both ipv4 and ipv6 */
-        if (family == PF_INET6) {
+        if (family == SOCKET_IN6) {
             socket_set_ipv6only(slisten);
         }
 #endif
@@ -162,60 +159,36 @@ listen:
         socket_close(slisten);
         return -1;
     }
-    if (ostr) {
-        if (flags & SOCKET_LIST_FORCE_IN6) {
-            snprintf(ostr, olen, "[%s]:%d%s", uaddr,
-                     sock_address_get_port(e) - port_offset, opts);
-        } else {
-            snprintf(ostr, olen, "%s:%d%s", uaddr,
-                     sock_address_get_port(e) - port_offset, opts);
-        }
-    }
+    snprintf(uport, sizeof(uport), "%d", sock_address_get_port(e) - port_offset);
+    qemu_opt_set(opts, "host", uaddr);
+    qemu_opt_set(opts, "port", uport);
+    qemu_opt_set(opts, "ipv6", (e->family == SOCKET_IN6) ? "on" : "off");
+    qemu_opt_set(opts, "ipv4", (e->family != SOCKET_IN6) ? "on" : "off");
     sock_address_list_free(list);
     return slisten;
 }
 
-int inet_connect(const char *str, SocketType socktype)
+int inet_connect_opts(QemuOpts *opts)
 {
     SockAddress**  list;
     SockAddress*   e;
     unsigned       flags = 0;
-    char addr[64];
-    char port[33];
+    const char *addr;
+    const char *port;
     int sock, nn;
 
-    /* parse address */
-    if (str[0] == '[') {
-        /* IPv6 addr */
-        if (2 != sscanf(str,"[%64[^]]]:%32[^,]",addr,port)) {
-            fprintf(stderr, "%s: ipv6 parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
-        flags |= SOCKET_LIST_FORCE_IN6;
-    } else if (qemu_isdigit(str[0])) {
-        /* IPv4 addr */
-        if (2 != sscanf(str,"%64[0-9.]:%32[^,]",addr,port)) {
-            fprintf(stderr, "%s: ipv4 parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
-        flags |= SOCKET_LIST_FORCE_INET;
-    } else {
-        /* hostname */
-        if (2 != sscanf(str,"%64[^:]:%32[^,]",addr,port)) {
-            fprintf(stderr, "%s: hostname parse error (%s)\n",
-                    __FUNCTION__, str);
-            return -1;
-        }
+    addr = qemu_opt_get(opts, "host");
+    port = qemu_opt_get(opts, "port");
+    if (addr == NULL || port == NULL) {
+        fprintf(stderr, "inet_connect: host and/or port not specified\n");
+        return -1;
     }
 
-    /* parse options */
-    if (strstr(str, ",ipv4")) {
+    if (qemu_opt_get_bool(opts, "ipv4", 0)) {
         flags &= SOCKET_LIST_FORCE_IN6;
         flags |= SOCKET_LIST_FORCE_INET;
     }
-    if (strstr(str, ",ipv6")) {
+    if (qemu_opt_get_bool(opts, "ipv6", 0)) {
         flags &= SOCKET_LIST_FORCE_INET;
         flags |= SOCKET_LIST_FORCE_IN6;
     }
@@ -230,7 +203,7 @@ int inet_connect(const char *str, SocketType socktype)
 
     for (nn = 0; list[nn] != NULL; nn++) {
         e     = list[nn];
-        sock = socket_create(sock_address_get_family(e), socktype);
+        sock = socket_create(sock_address_get_family(e), SOCKET_STREAM);
         if (sock < 0) {
             fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__,
             sock_address_strfamily(e), errno_str);
@@ -260,29 +233,119 @@ EXIT:
     return sock;
 }
 
+/* compatibility wrapper */
+static int inet_parse(QemuOpts *opts, const char *str)
+{
+    const char *optstr, *h;
+    char addr[64];
+    char port[33];
+    int pos;
+
+    /* parse address */
+    if (str[0] == ':') {
+        /* no host given */
+        addr[0] = '\0';
+        if (1 != sscanf(str,":%32[^,]%n",port,&pos)) {
+            fprintf(stderr, "%s: portonly parse error (%s)\n",
+                    __FUNCTION__, str);
+            return -1;
+        }
+    } else if (str[0] == '[') {
+        /* IPv6 addr */
+        if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) {
+            fprintf(stderr, "%s: ipv6 parse error (%s)\n",
+                    __FUNCTION__, str);
+            return -1;
+        }
+        qemu_opt_set(opts, "ipv6", "on");
+    } else if (qemu_isdigit(str[0])) {
+        /* IPv4 addr */
+        if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) {
+            fprintf(stderr, "%s: ipv4 parse error (%s)\n",
+                    __FUNCTION__, str);
+            return -1;
+        }
+        qemu_opt_set(opts, "ipv4", "on");
+    } else {
+        /* hostname */
+        if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) {
+            fprintf(stderr, "%s: hostname parse error (%s)\n",
+                    __FUNCTION__, str);
+            return -1;
+        }
+    }
+    qemu_opt_set(opts, "host", addr);
+    qemu_opt_set(opts, "port", port);
+
+    /* parse options */
+    optstr = str + pos;
+    h = strstr(optstr, ",to=");
+    if (h)
+        qemu_opt_set(opts, "to", h+4);
+    if (strstr(optstr, ",ipv4"))
+        qemu_opt_set(opts, "ipv4", "on");
+    if (strstr(optstr, ",ipv6"))
+        qemu_opt_set(opts, "ipv6", "on");
+    return 0;
+}
+
+int inet_listen(const char *str, char *ostr, int olen,
+                int socktype, int port_offset)
+{
+    QemuOpts *opts;
+    char *optstr;
+    int sock = -1;
+
+    opts = qemu_opts_create(&dummy_opts, NULL, 0);
+    if (inet_parse(opts, str) == 0) {
+        sock = inet_listen_opts(opts, port_offset);
+        if (sock != -1 && ostr) {
+            optstr = strchr(str, ',');
+            if (qemu_opt_get_bool(opts, "ipv6", 0)) {
+                snprintf(ostr, olen, "[%s]:%s%s",
+                         qemu_opt_get(opts, "host"),
+                         qemu_opt_get(opts, "port"),
+                         optstr ? optstr : "");
+            } else {
+                snprintf(ostr, olen, "%s:%s%s",
+                         qemu_opt_get(opts, "host"),
+                         qemu_opt_get(opts, "port"),
+                         optstr ? optstr : "");
+            }
+        }
+    }
+    qemu_opts_del(opts);
+    return sock;
+}
+
+int inet_connect(const char *str, int socktype)
+{
+    QemuOpts *opts;
+    int sock = -1;
+
+    opts = qemu_opts_create(&dummy_opts, NULL, 0);
+    if (inet_parse(opts, str) == 0)
+        sock = inet_connect_opts(opts);
+    qemu_opts_del(opts);
+    return sock;
+}
+
 #ifndef _WIN32
 
-int unix_listen(const char *str, char *ostr, int olen)
+int unix_listen_opts(QemuOpts *opts)
 {
-    SockAddress  un;
-    char         unpath[PATH_MAX];
-    char *path, *upath, *opts;
-    int sock, fd, len;
-
-    opts = strchr(str, ',');
-    if (opts) {
-        len = opts - str;
-        path = qemu_malloc(len+1);
-        snprintf(path, len+1, "%.*s", len, str);
-    } else
-        path = qemu_strdup(str);
-
-    if (path || strlen(path) > 0) {
+    const char *path = qemu_opt_get(opts, "path");
+    char        unpath[PATH_MAX];
+    const char *upath;
+    int sock, fd;
+
+    if (path && strlen(path)) {
         upath = path;
     } else {
         char *tmpdir = getenv("TMPDIR");
         snprintf(unpath, sizeof(unpath), "%s/qemu-socket-XXXXXX",
                  tmpdir ? tmpdir : "/tmp");
+        upath = unpath;
         /*
          * This dummy fd usage silences the mktemp() unsecure warning.
          * Using mkstemp() doesn't make things more secure here
@@ -291,12 +354,10 @@ int unix_listen(const char *str, char *ostr, int olen)
          * worst case possible is bind() failing, i.e. a DoS attack.
          */
         fd = mkstemp(unpath); close(fd);
-        upath = unpath;
+        qemu_opt_set(opts, "path", unpath);
     }
-    snprintf(ostr, olen, "%s%s", path, opts ? opts : "");
 
     sock = socket_unix_server(upath, SOCKET_STREAM);
-    sock_address_done(&un);
 
     if (sock < 0) {
         fprintf(stderr, "bind(unix:%s): %s\n", upath, errno_str);
@@ -306,18 +367,17 @@ int unix_listen(const char *str, char *ostr, int olen)
     if (sockets_debug)
         fprintf(stderr, "bind(unix:%s): OK\n", upath);
 
-    qemu_free(path);
     return sock;
 
 err:
-    qemu_free(path);
     socket_close(sock);
     return -1;
 }
 
-int unix_connect(const char *path)
+int unix_connect_opts(QemuOpts *opts)
 {
     SockAddress  un;
+    const char *path = qemu_opt_get(opts, "path");
     int ret, sock;
 
     sock = socket_create_unix(SOCKET_STREAM);
@@ -340,8 +400,62 @@ int unix_connect(const char *path)
     return sock;
 }
 
+/* compatibility wrapper */
+int unix_listen(const char *str, char *ostr, int olen)
+{
+    QemuOpts *opts;
+    char *path, *optstr;
+    int sock, len;
+
+    opts = qemu_opts_create(&dummy_opts, NULL, 0);
+
+    optstr = strchr(str, ',');
+    if (optstr) {
+        len = optstr - str;
+        if (len) {
+            path = qemu_malloc(len+1);
+            snprintf(path, len+1, "%.*s", len, str);
+            qemu_opt_set(opts, "path", path);
+            qemu_free(path);
+        }
+    } else {
+        qemu_opt_set(opts, "path", str);
+    }
+
+    sock = unix_listen_opts(opts);
+
+    if (sock != -1 && ostr)
+        snprintf(ostr, olen, "%s%s", qemu_opt_get(opts, "path"), optstr ? optstr : "");
+    qemu_opts_del(opts);
+    return sock;
+}
+
+int unix_connect(const char *path)
+{
+    QemuOpts *opts;
+    int sock;
+
+    opts = qemu_opts_create(&dummy_opts, NULL, 0);
+    qemu_opt_set(opts, "path", path);
+    sock = unix_connect_opts(opts);
+    qemu_opts_del(opts);
+    return sock;
+}
+
 #else
 
+int unix_listen_opts(QemuOpts *opts)
+{
+    fprintf(stderr, "unix sockets are not available on windows\n");
+    return -1;
+}
+
+int unix_connect_opts(QemuOpts *opts)
+{
+    fprintf(stderr, "unix sockets are not available on windows\n");
+    return -1;
+}
+
 int unix_listen(const char *path, char *ostr, int olen)
 {
     fprintf(stderr, "unix sockets are not available on windows\n");
@@ -355,3 +469,29 @@ int unix_connect(const char *path)
 }
 
 #endif
+
+#ifndef CONFIG_ANDROID /* see sockets.c */
+#ifdef _WIN32
+static void socket_cleanup(void)
+{
+    WSACleanup();
+}
+#endif
+
+int socket_init(void)
+{
+#ifdef _WIN32
+    WSADATA Data;
+    int ret, err;
+
+    ret = WSAStartup(MAKEWORD(2,2), &Data);
+    if (ret != 0) {
+        err = WSAGetLastError();
+        fprintf(stderr, "WSAStartup: %d\n", err);
+        return -1;
+    }
+    atexit(socket_cleanup);
+#endif
+    return 0;
+}
+#endif /* !CONFIG_ANDROID */