From 315ceb8a16eb7a2102fee4946898e7b8a202e86a Mon Sep 17 00:00:00 2001 From: David Turner Date: Fri, 10 Sep 2010 14:15:17 +0200 Subject: upstream: qemu-sockets changes. --- qemu-sockets-android.c | 360 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 250 insertions(+), 110 deletions(-) (limited to 'qemu-sockets-android.c') 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 */ -- cgit v1.1