1 /* 2 * inet and unix socket functions for qemu 3 * 4 * (c) 2008 Gerd Hoffmann <kraxel (at) 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 32 static int inet_getport(struct addrinfo *e) 33 { 34 struct sockaddr_in *i4; 35 struct sockaddr_in6 *i6; 36 37 switch (e->ai_family) { 38 case PF_INET6: 39 i6 = (void*)e->ai_addr; 40 return ntohs(i6->sin6_port); 41 case PF_INET: 42 i4 = (void*)e->ai_addr; 43 return ntohs(i4->sin_port); 44 default: 45 return 0; 46 } 47 } 48 49 static void inet_setport(struct addrinfo *e, int port) 50 { 51 struct sockaddr_in *i4; 52 struct sockaddr_in6 *i6; 53 54 switch (e->ai_family) { 55 case PF_INET6: 56 i6 = (void*)e->ai_addr; 57 i6->sin6_port = htons(port); 58 break; 59 case PF_INET: 60 i4 = (void*)e->ai_addr; 61 i4->sin_port = htons(port); 62 break; 63 } 64 } 65 66 static const char *inet_strfamily(int family) 67 { 68 switch (family) { 69 case PF_INET6: return "ipv6"; 70 case PF_INET: return "ipv4"; 71 case PF_UNIX: return "unix"; 72 } 73 return "????"; 74 } 75 76 static void inet_print_addrinfo(const char *tag, struct addrinfo *res) 77 { 78 struct addrinfo *e; 79 char uaddr[INET6_ADDRSTRLEN+1]; 80 char uport[33]; 81 82 for (e = res; e != NULL; e = e->ai_next) { 83 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 84 uaddr,INET6_ADDRSTRLEN,uport,32, 85 NI_NUMERICHOST | NI_NUMERICSERV); 86 fprintf(stderr,"%s: getaddrinfo: family %s, host %s, port %s\n", 87 tag, inet_strfamily(e->ai_family), uaddr, uport); 88 } 89 } 90 91 int inet_listen(const char *str, char *ostr, int olen, 92 int socktype, int port_offset) 93 { 94 struct addrinfo ai,*res,*e; 95 char addr[64]; 96 char port[33]; 97 char uaddr[INET6_ADDRSTRLEN+1]; 98 char uport[33]; 99 const char *opts, *h; 100 int slisten,rc,pos,to,try_next; 101 102 memset(&ai,0, sizeof(ai)); 103 ai.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; 104 ai.ai_family = PF_UNSPEC; 105 ai.ai_socktype = socktype; 106 107 /* parse address */ 108 if (str[0] == ':') { 109 /* no host given */ 110 addr[0] = '\0'; 111 if (1 != sscanf(str,":%32[^,]%n",port,&pos)) { 112 fprintf(stderr, "%s: portonly parse error (%s)\n", 113 __FUNCTION__, str); 114 return -1; 115 } 116 } else if (str[0] == '[') { 117 /* IPv6 addr */ 118 if (2 != sscanf(str,"[%64[^]]]:%32[^,]%n",addr,port,&pos)) { 119 fprintf(stderr, "%s: ipv6 parse error (%s)\n", 120 __FUNCTION__, str); 121 return -1; 122 } 123 ai.ai_family = PF_INET6; 124 } else if (qemu_isdigit(str[0])) { 125 /* IPv4 addr */ 126 if (2 != sscanf(str,"%64[0-9.]:%32[^,]%n",addr,port,&pos)) { 127 fprintf(stderr, "%s: ipv4 parse error (%s)\n", 128 __FUNCTION__, str); 129 return -1; 130 } 131 ai.ai_family = PF_INET; 132 } else { 133 /* hostname */ 134 if (2 != sscanf(str,"%64[^:]:%32[^,]%n",addr,port,&pos)) { 135 fprintf(stderr, "%s: hostname parse error (%s)\n", 136 __FUNCTION__, str); 137 return -1; 138 } 139 } 140 141 /* parse options */ 142 opts = str + pos; 143 h = strstr(opts, ",to="); 144 to = h ? atoi(h+4) : 0; 145 if (strstr(opts, ",ipv4")) 146 ai.ai_family = PF_INET; 147 if (strstr(opts, ",ipv6")) 148 ai.ai_family = PF_INET6; 149 150 /* lookup */ 151 if (port_offset) 152 snprintf(port, sizeof(port), "%d", atoi(port) + port_offset); 153 rc = getaddrinfo(strlen(addr) ? addr : NULL, port, &ai, &res); 154 if (rc != 0) { 155 fprintf(stderr,"%s: getaddrinfo(%s,%s): %s\n", __FUNCTION__, 156 addr, port, gai_strerror(rc)); 157 return -1; 158 } 159 if (sockets_debug) 160 inet_print_addrinfo(__FUNCTION__, res); 161 162 /* create socket + bind */ 163 for (e = res; e != NULL; e = e->ai_next) { 164 getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 165 uaddr,INET6_ADDRSTRLEN,uport,32, 166 NI_NUMERICHOST | NI_NUMERICSERV); 167 slisten = socket(e->ai_family, e->ai_socktype, e->ai_protocol); 168 if (slisten < 0) { 169 fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__, 170 inet_strfamily(e->ai_family), strerror(errno)); 171 continue; 172 } 173 174 setsockopt(slisten,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on)); 175 #ifdef IPV6_V6ONLY 176 if (e->ai_family == PF_INET6) { 177 /* listen on both ipv4 and ipv6 */ 178 setsockopt(slisten,IPPROTO_IPV6,IPV6_V6ONLY,(void*)&off, 179 sizeof(off)); 180 } 181 #endif 182 183 for (;;) { 184 if (bind(slisten, e->ai_addr, e->ai_addrlen) == 0) { 185 if (sockets_debug) 186 fprintf(stderr,"%s: bind(%s,%s,%d): OK\n", __FUNCTION__, 187 inet_strfamily(e->ai_family), uaddr, inet_getport(e)); 188 goto listen; 189 } 190 try_next = to && (inet_getport(e) <= to + port_offset); 191 if (!try_next || sockets_debug) 192 fprintf(stderr,"%s: bind(%s,%s,%d): %s\n", __FUNCTION__, 193 inet_strfamily(e->ai_family), uaddr, inet_getport(e), 194 strerror(errno)); 195 if (try_next) { 196 inet_setport(e, inet_getport(e) + 1); 197 continue; 198 } 199 break; 200 } 201 closesocket(slisten); 202 } 203 fprintf(stderr, "%s: FAILED\n", __FUNCTION__); 204 freeaddrinfo(res); 205 return -1; 206 207 listen: 208 if (listen(slisten,1) != 0) { 209 perror("listen"); 210 closesocket(slisten); 211 freeaddrinfo(res); 212 return -1; 213 } 214 if (ostr) { 215 if (e->ai_family == PF_INET6) { 216 snprintf(ostr, olen, "[%s]:%d%s", uaddr, 217 inet_getport(e) - port_offset, opts); 218 } else { 219 snprintf(ostr, olen, "%s:%d%s", uaddr, 220 inet_getport(e) - port_offset, opts); 221 } 222 } 223 freeaddrinfo(res); 224 return slisten; 225 } 226 227 int inet_connect(const char *str, int socktype) 228 { 229 struct addrinfo ai,*res,*e; 230 char addr[64]; 231 char port[33]; 232 char uaddr[INET6_ADDRSTRLEN+1]; 233 char uport[33]; 234 int sock,rc; 235 236 memset(&ai,0, sizeof(ai)); 237 ai.ai_flags = AI_CANONNAME | AI_ADDRCONFIG; 238 ai.ai_family = PF_UNSPEC; 239 ai.ai_socktype = socktype; 240 241 /* parse address */ 242 if (str[0] == '[') { 243 /* IPv6 addr */ 244 if (2 != sscanf(str,"[%64[^]]]:%32[^,]",addr,port)) { 245 fprintf(stderr, "%s: ipv6 parse error (%s)\n", 246 __FUNCTION__, str); 247 return -1; 248 } 249 ai.ai_family = PF_INET6; 250 } else if (qemu_isdigit(str[0])) { 251 /* IPv4 addr */ 252 if (2 != sscanf(str,"%64[0-9.]:%32[^,]",addr,port)) { 253 fprintf(stderr, "%s: ipv4 parse error (%s)\n", 254 __FUNCTION__, str); 255 return -1; 256 } 257 ai.ai_family = PF_INET; 258 } else { 259 /* hostname */ 260 if (2 != sscanf(str,"%64[^:]:%32[^,]",addr,port)) { 261 fprintf(stderr, "%s: hostname parse error (%s)\n", 262 __FUNCTION__, str); 263 return -1; 264 } 265 } 266 267 /* parse options */ 268 if (strstr(str, ",ipv4")) 269 ai.ai_family = PF_INET; 270 if (strstr(str, ",ipv6")) 271 ai.ai_family = PF_INET6; 272 273 /* lookup */ 274 if (0 != (rc = getaddrinfo(addr, port, &ai, &res))) { 275 fprintf(stderr,"getaddrinfo(%s,%s): %s\n", gai_strerror(rc), 276 addr, port); 277 return -1; 278 } 279 if (sockets_debug) 280 inet_print_addrinfo(__FUNCTION__, res); 281 282 for (e = res; e != NULL; e = e->ai_next) { 283 if (getnameinfo((struct sockaddr*)e->ai_addr,e->ai_addrlen, 284 uaddr,INET6_ADDRSTRLEN,uport,32, 285 NI_NUMERICHOST | NI_NUMERICSERV) != 0) { 286 fprintf(stderr,"%s: getnameinfo: oops\n", __FUNCTION__); 287 continue; 288 } 289 sock = socket(e->ai_family, e->ai_socktype, e->ai_protocol); 290 if (sock < 0) { 291 fprintf(stderr,"%s: socket(%s): %s\n", __FUNCTION__, 292 inet_strfamily(e->ai_family), strerror(errno)); 293 continue; 294 } 295 setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on)); 296 297 /* connect to peer */ 298 if (connect(sock,e->ai_addr,e->ai_addrlen) < 0) { 299 if (sockets_debug || NULL == e->ai_next) 300 fprintf(stderr, "%s: connect(%s,%s,%s,%s): %s\n", __FUNCTION__, 301 inet_strfamily(e->ai_family), 302 e->ai_canonname, uaddr, uport, strerror(errno)); 303 closesocket(sock); 304 continue; 305 } 306 if (sockets_debug) 307 fprintf(stderr, "%s: connect(%s,%s,%s,%s): OK\n", __FUNCTION__, 308 inet_strfamily(e->ai_family), 309 e->ai_canonname, uaddr, uport); 310 freeaddrinfo(res); 311 return sock; 312 } 313 freeaddrinfo(res); 314 return -1; 315 } 316 317 #ifndef _WIN32 318 319 int unix_listen(const char *str, char *ostr, int olen) 320 { 321 struct sockaddr_un un; 322 char *path, *opts; 323 int sock, fd, len; 324 325 sock = socket(PF_UNIX, SOCK_STREAM, 0); 326 if (sock < 0) { 327 perror("socket(unix)"); 328 return -1; 329 } 330 331 opts = strchr(str, ','); 332 if (opts) { 333 len = opts - str; 334 path = qemu_malloc(len+1); 335 snprintf(path, len+1, "%.*s", len, str); 336 } else 337 path = qemu_strdup(str); 338 339 memset(&un, 0, sizeof(un)); 340 un.sun_family = AF_UNIX; 341 if (path && strlen(path)) { 342 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 343 } else { 344 char *tmpdir = getenv("TMPDIR"); 345 snprintf(un.sun_path, sizeof(un.sun_path), "%s/qemu-socket-XXXXXX", 346 tmpdir ? tmpdir : "/tmp"); 347 /* 348 * This dummy fd usage silences the mktemp() unsecure warning. 349 * Using mkstemp() doesn't make things more secure here 350 * though. bind() complains about existing files, so we have 351 * to unlink first and thus re-open the race window. The 352 * worst case possible is bind() failing, i.e. a DoS attack. 353 */ 354 fd = mkstemp(un.sun_path); close(fd); 355 } 356 snprintf(ostr, olen, "%s%s", un.sun_path, opts ? opts : ""); 357 358 unlink(un.sun_path); 359 if (bind(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 360 fprintf(stderr, "bind(unix:%s): %s\n", un.sun_path, strerror(errno)); 361 goto err; 362 } 363 if (listen(sock, 1) < 0) { 364 fprintf(stderr, "listen(unix:%s): %s\n", un.sun_path, strerror(errno)); 365 goto err; 366 } 367 368 if (sockets_debug) 369 fprintf(stderr, "bind(unix:%s): OK\n", un.sun_path); 370 qemu_free(path); 371 return sock; 372 373 err: 374 qemu_free(path); 375 closesocket(sock); 376 return -1; 377 } 378 379 int unix_connect(const char *path) 380 { 381 struct sockaddr_un un; 382 int sock; 383 384 sock = socket(PF_UNIX, SOCK_STREAM, 0); 385 if (sock < 0) { 386 perror("socket(unix)"); 387 return -1; 388 } 389 390 memset(&un, 0, sizeof(un)); 391 un.sun_family = AF_UNIX; 392 snprintf(un.sun_path, sizeof(un.sun_path), "%s", path); 393 if (connect(sock, (struct sockaddr*) &un, sizeof(un)) < 0) { 394 fprintf(stderr, "connect(unix:%s): %s\n", path, strerror(errno)); 395 return -1; 396 } 397 398 if (sockets_debug) 399 fprintf(stderr, "connect(unix:%s): OK\n", path); 400 return sock; 401 } 402 403 #else 404 405 int unix_listen(const char *path, char *ostr, int olen) 406 { 407 fprintf(stderr, "unix sockets are not available on windows\n"); 408 return -1; 409 } 410 411 int unix_connect(const char *path) 412 { 413 fprintf(stderr, "unix sockets are not available on windows\n"); 414 return -1; 415 } 416 417 #endif 418
