]> git.proxmox.com Git - qemu.git/blame - net.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move network redirection code out of vl.c and into net.c
[qemu.git] / net.c
CommitLineData
63a01ef8
AL		 1/*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24#include "hw/hw.h"
25#include "hw/boards.h"
26#include "hw/usb.h"
27#include "hw/pcmcia.h"
28#include "hw/pc.h"
29#include "hw/audiodev.h"
30#include "hw/isa.h"
31#include "hw/baum.h"
32#include "hw/bt.h"
33#include "net.h"
34#include "console.h"
35#include "sysemu.h"
36#include "gdbstub.h"
37#include "qemu-timer.h"
38#include "qemu-char.h"
39#include "block.h"
40#include "audio/audio.h"
41#include "migration.h"
42
43#include <unistd.h>
44#include <fcntl.h>
45#include <signal.h>
46#include <time.h>
47#include <errno.h>
48#include <sys/time.h>
49#include <zlib.h>
50
51#ifndef _WIN32
52#include <sys/times.h>
53#include <sys/wait.h>
54#include <termios.h>
55#include <sys/mman.h>
56#include <sys/ioctl.h>
57#include <sys/socket.h>
58#include <netinet/in.h>
59#include <dirent.h>
60#include <netdb.h>
61#include <sys/select.h>
62#include <arpa/inet.h>
63#ifdef _BSD
64#include <sys/stat.h>
65#if !defined(__APPLE__) && !defined(__OpenBSD__)
66#include <libutil.h>
67#endif
68#ifdef __OpenBSD__
69#include <net/if.h>
70#endif
71#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72#include <freebsd/stdlib.h>
73#else
74#ifdef __linux__
75#include <linux/if.h>
76#include <linux/if_tun.h>
77#include <pty.h>
78#include <malloc.h>
79#include <linux/rtc.h>
80
81/* For the benefit of older linux systems which don't supply it,
82 we use a local copy of hpet.h. */
83/* #include <linux/hpet.h> */
84#include "hpet.h"
85
86#include <linux/ppdev.h>
87#include <linux/parport.h>
88#endif
89#ifdef __sun__
90#include <sys/stat.h>
91#include <sys/ethernet.h>
92#include <sys/sockio.h>
93#include <netinet/arp.h>
94#include <netinet/in.h>
95#include <netinet/in_systm.h>
96#include <netinet/ip.h>
97#include <netinet/ip_icmp.h> // must come after ip.h
98#include <netinet/udp.h>
99#include <netinet/tcp.h>
100#include <net/if.h>
101#include <syslog.h>
102#include <stropts.h>
103#endif
104#endif
105#endif
106
107#include "qemu_socket.h"
108
109#if defined(CONFIG_SLIRP)
110#include "libslirp.h"
111#endif
112
113#if defined(__OpenBSD__)
114#include <util.h>
115#endif
116
117#if defined(CONFIG_VDE)
118#include <libvdeplug.h>
119#endif
120
121#ifdef _WIN32
122#include <malloc.h>
123#include <sys/timeb.h>
124#include <mmsystem.h>
125#define getopt_long_only getopt_long
126#define memalign(align, size) malloc(size)
127#endif
128
129#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
130#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
131#ifdef __sun__
132#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
133#else
134#define SMBD_COMMAND "/usr/sbin/smbd"
135#endif
136
137static VLANState *first_vlan;
138
139/***********************************************************/
140/* network device redirectors */
141
142#if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
143static void hex_dump(FILE *f, const uint8_t *buf, int size)
144{
145 int len, i, j, c;
146
147 for(i=0;i<size;i+=16) {
148 len = size - i;
149 if (len > 16)
150 len = 16;
151 fprintf(f, "%08x ", i);
152 for(j=0;j<16;j++) {
153 if (j < len)
154 fprintf(f, " %02x", buf[i+j]);
155 else
156 fprintf(f, " ");
157 }
158 fprintf(f, " ");
159 for(j=0;j<len;j++) {
160 c = buf[i+j];
161 if (c < ' ' || c > '~')
162 c = '.';
163 fprintf(f, "%c", c);
164 }
165 fprintf(f, "\n");
166 }
167}
168#endif
169
170static int parse_macaddr(uint8_t *macaddr, const char *p)
171{
172 int i;
173 char *last_char;
174 long int offset;
175
176 errno = 0;
177 offset = strtol(p, &last_char, 0);
178 if (0 == errno && '\0' == *last_char &&
179 offset >= 0 && offset <= 0xFFFFFF) {
180 macaddr[3] = (offset & 0xFF0000) >> 16;
181 macaddr[4] = (offset & 0xFF00) >> 8;
182 macaddr[5] = offset & 0xFF;
183 return 0;
184 } else {
185 for(i = 0; i < 6; i++) {
186 macaddr[i] = strtol(p, (char **)&p, 16);
187 if (i == 5) {
188 if (*p != '\0')
189 return -1;
190 } else {
191 if (*p != ':' && *p != '-')
192 return -1;
193 p++;
194 }
195 }
196 return 0;
197 }
198
199 return -1;
200}
201
202static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
203{
204 const char *p, *p1;
205 int len;
206 p = *pp;
207 p1 = strchr(p, sep);
208 if (!p1)
209 return -1;
210 len = p1 - p;
211 p1++;
212 if (buf_size > 0) {
213 if (len > buf_size - 1)
214 len = buf_size - 1;
215 memcpy(buf, p, len);
216 buf[len] = '\0';
217 }
218 *pp = p1;
219 return 0;
220}
221
222int parse_host_src_port(struct sockaddr_in *haddr,
223 struct sockaddr_in *saddr,
224 const char *input_str)
225{
226 char *str = strdup(input_str);
227 char *host_str = str;
228 char *src_str;
229 const char *src_str2;
230 char *ptr;
231
232 /*
233 * Chop off any extra arguments at the end of the string which
234 * would start with a comma, then fill in the src port information
235 * if it was provided else use the "any address" and "any port".
236 */
237 if ((ptr = strchr(str,',')))
238 *ptr = '\0';
239
240 if ((src_str = strchr(input_str,'@'))) {
241 *src_str = '\0';
242 src_str++;
243 }
244
245 if (parse_host_port(haddr, host_str) < 0)
246 goto fail;
247
248 src_str2 = src_str;
249 if (!src_str || *src_str == '\0')
250 src_str2 = ":0";
251
252 if (parse_host_port(saddr, src_str2) < 0)
253 goto fail;
254
255 free(str);
256 return(0);
257
258fail:
259 free(str);
260 return -1;
261}
262
263int parse_host_port(struct sockaddr_in *saddr, const char *str)
264{
265 char buf[512];
266 struct hostent *he;
267 const char *p, *r;
268 int port;
269
270 p = str;
271 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
272 return -1;
273 saddr->sin_family = AF_INET;
274 if (buf[0] == '\0') {
275 saddr->sin_addr.s_addr = 0;
276 } else {
277 if (isdigit(buf[0])) {
278 if (!inet_aton(buf, &saddr->sin_addr))
279 return -1;
280 } else {
281 if ((he = gethostbyname(buf)) == NULL)
282 return - 1;
283 saddr->sin_addr = *(struct in_addr *)he->h_addr;
284 }
285 }
286 port = strtol(p, (char **)&r, 0);
287 if (r == p)
288 return -1;
289 saddr->sin_port = htons(port);
290 return 0;
291}
292
293#ifndef _WIN32
294int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
295{
296 const char *p;
297 int len;
298
299 len = MIN(108, strlen(str));
300 p = strchr(str, ',');
301 if (p)
302 len = MIN(len, p - str);
303
304 memset(uaddr, 0, sizeof(*uaddr));
305
306 uaddr->sun_family = AF_UNIX;
307 memcpy(uaddr->sun_path, str, len);
308
309 return 0;
310}
311#endif
312
313VLANClientState *qemu_new_vlan_client(VLANState *vlan,
314 IOReadHandler *fd_read,
315 IOCanRWHandler *fd_can_read,
316 void *opaque)
317{
318 VLANClientState *vc, **pvc;
319 vc = qemu_mallocz(sizeof(VLANClientState));
320 if (!vc)
321 return NULL;
322 vc->fd_read = fd_read;
323 vc->fd_can_read = fd_can_read;
324 vc->opaque = opaque;
325 vc->vlan = vlan;
326
327 vc->next = NULL;
328 pvc = &vlan->first_client;
329 while (*pvc != NULL)
330 pvc = &(*pvc)->next;
331 *pvc = vc;
332 return vc;
333}
334
335void qemu_del_vlan_client(VLANClientState *vc)
336{
337 VLANClientState **pvc = &vc->vlan->first_client;
338
339 while (*pvc != NULL)
340 if (*pvc == vc) {
341 *pvc = vc->next;
342 free(vc);
343 break;
344 } else
345 pvc = &(*pvc)->next;
346}
347
348int qemu_can_send_packet(VLANClientState *vc1)
349{
350 VLANState *vlan = vc1->vlan;
351 VLANClientState *vc;
352
353 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
354 if (vc != vc1) {
355 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
356 return 1;
357 }
358 }
359 return 0;
360}
361
362void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
363{
364 VLANState *vlan = vc1->vlan;
365 VLANClientState *vc;
366
367#ifdef DEBUG_NET
368 printf("vlan %d send:\n", vlan->id);
369 hex_dump(stdout, buf, size);
370#endif
371 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
372 if (vc != vc1) {
373 vc->fd_read(vc->opaque, buf, size);
374 }
375 }
376}
377
378#if defined(CONFIG_SLIRP)
379
380/* slirp network adapter */
381
382static int slirp_inited;
383static VLANClientState *slirp_vc;
384
385int slirp_can_output(void)
386{
387 return !slirp_vc || qemu_can_send_packet(slirp_vc);
388}
389
390void slirp_output(const uint8_t *pkt, int pkt_len)
391{
392#ifdef DEBUG_SLIRP
393 printf("slirp output:\n");
394 hex_dump(stdout, pkt, pkt_len);
395#endif
396 if (!slirp_vc)
397 return;
398 qemu_send_packet(slirp_vc, pkt, pkt_len);
399}
400
401int slirp_is_inited(void)
402{
403 return slirp_inited;
404}
405
406static void slirp_receive(void *opaque, const uint8_t *buf, int size)
407{
408#ifdef DEBUG_SLIRP
409 printf("slirp input:\n");
410 hex_dump(stdout, buf, size);
411#endif
412 slirp_input(buf, size);
413}
414
415static int net_slirp_init(VLANState *vlan)
416{
417 if (!slirp_inited) {
418 slirp_inited = 1;
419 slirp_init();
420 }
421 slirp_vc = qemu_new_vlan_client(vlan,
422 slirp_receive, NULL, NULL);
423 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
424 return 0;
425}
426
427void net_slirp_redir(const char *redir_str)
428{
429 int is_udp;
430 char buf[256], *r;
431 const char *p;
432 struct in_addr guest_addr;
433 int host_port, guest_port;
434
435 if (!slirp_inited) {
436 slirp_inited = 1;
437 slirp_init();
438 }
439
440 p = redir_str;
441 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
442 goto fail;
443 if (!strcmp(buf, "tcp")) {
444 is_udp = 0;
445 } else if (!strcmp(buf, "udp")) {
446 is_udp = 1;
447 } else {
448 goto fail;
449 }
450
451 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
452 goto fail;
453 host_port = strtol(buf, &r, 0);
454 if (r == buf)
455 goto fail;
456
457 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
458 goto fail;
459 if (buf[0] == '\0') {
460 pstrcpy(buf, sizeof(buf), "10.0.2.15");
461 }
462 if (!inet_aton(buf, &guest_addr))
463 goto fail;
464
465 guest_port = strtol(p, &r, 0);
466 if (r == p)
467 goto fail;
468
469 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
470 fprintf(stderr, "qemu: could not set up redirection\n");
471 exit(1);
472 }
473 return;
474 fail:
475 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
476 exit(1);
477}
478
479#ifndef _WIN32
480
481static char smb_dir[1024];
482
483static void erase_dir(char *dir_name)
484{
485 DIR *d;
486 struct dirent *de;
487 char filename[1024];
488
489 /* erase all the files in the directory */
490 if ((d = opendir(dir_name)) != 0) {
491 for(;;) {
492 de = readdir(d);
493 if (!de)
494 break;
495 if (strcmp(de->d_name, ".") != 0 &&
496 strcmp(de->d_name, "..") != 0) {
497 snprintf(filename, sizeof(filename), "%s/%s",
498 smb_dir, de->d_name);
499 if (unlink(filename) != 0) /* is it a directory? */
500 erase_dir(filename);
501 }
502 }
503 closedir(d);
504 rmdir(dir_name);
505 }
506}
507
508/* automatic user mode samba server configuration */
509static void smb_exit(void)
510{
511 erase_dir(smb_dir);
512}
513
514/* automatic user mode samba server configuration */
515void net_slirp_smb(const char *exported_dir)
516{
517 char smb_conf[1024];
518 char smb_cmdline[1024];
519 FILE *f;
520
521 if (!slirp_inited) {
522 slirp_inited = 1;
523 slirp_init();
524 }
525
526 /* XXX: better tmp dir construction */
527 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
528 if (mkdir(smb_dir, 0700) < 0) {
529 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
530 exit(1);
531 }
532 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
533
534 f = fopen(smb_conf, "w");
535 if (!f) {
536 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
537 exit(1);
538 }
539 fprintf(f,
540 "[global]\n"
541 "private dir=%s\n"
542 "smb ports=0\n"
543 "socket address=127.0.0.1\n"
544 "pid directory=%s\n"
545 "lock directory=%s\n"
546 "log file=%s/log.smbd\n"
547 "smb passwd file=%s/smbpasswd\n"
548 "security = share\n"
549 "[qemu]\n"
550 "path=%s\n"
551 "read only=no\n"
552 "guest ok=yes\n",
553 smb_dir,
554 smb_dir,
555 smb_dir,
556 smb_dir,
557 smb_dir,
558 exported_dir
559 );
560 fclose(f);
561 atexit(smb_exit);
562
563 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
564 SMBD_COMMAND, smb_conf);
565
566 slirp_add_exec(0, smb_cmdline, 4, 139);
567}
568
569#endif /* !defined(_WIN32) */
570void do_info_slirp(void)
571{
572 slirp_stats();
573}
574
575#endif /* CONFIG_SLIRP */
576
577#if !defined(_WIN32)
578
579typedef struct TAPState {
580 VLANClientState *vc;
581 int fd;
582 char down_script[1024];
583} TAPState;
584
585static void tap_receive(void *opaque, const uint8_t *buf, int size)
586{
587 TAPState *s = opaque;
588 int ret;
589 for(;;) {
590 ret = write(s->fd, buf, size);
591 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
592 } else {
593 break;
594 }
595 }
596}
597
598static void tap_send(void *opaque)
599{
600 TAPState *s = opaque;
601 uint8_t buf[4096];
602 int size;
603
604#ifdef __sun__
605 struct strbuf sbuf;
606 int f = 0;
607 sbuf.maxlen = sizeof(buf);
608 sbuf.buf = buf;
609 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
610#else
611 size = read(s->fd, buf, sizeof(buf));
612#endif
613 if (size > 0) {
614 qemu_send_packet(s->vc, buf, size);
615 }
616}
617
618/* fd support */
619
620static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
621{
622 TAPState *s;
623
624 s = qemu_mallocz(sizeof(TAPState));
625 if (!s)
626 return NULL;
627 s->fd = fd;
628 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
629 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
630 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
631 return s;
632}
633
634#if defined (_BSD) || defined (__FreeBSD_kernel__)
635static int tap_open(char *ifname, int ifname_size)
636{
637 int fd;
638 char *dev;
639 struct stat s;
640
641 TFR(fd = open("/dev/tap", O_RDWR));
642 if (fd < 0) {
643 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
644 return -1;
645 }
646
647 fstat(fd, &s);
648 dev = devname(s.st_rdev, S_IFCHR);
649 pstrcpy(ifname, ifname_size, dev);
650
651 fcntl(fd, F_SETFL, O_NONBLOCK);
652 return fd;
653}
654#elif defined(__sun__)
655#define TUNNEWPPA (('T'<<16) | 0x0001)
656/*
657 * Allocate TAP device, returns opened fd.
658 * Stores dev name in the first arg(must be large enough).
659 */
660int tap_alloc(char *dev, size_t dev_size)
661{
662 int tap_fd, if_fd, ppa = -1;
663 static int ip_fd = 0;
664 char *ptr;
665
666 static int arp_fd = 0;
667 int ip_muxid, arp_muxid;
668 struct strioctl strioc_if, strioc_ppa;
669 int link_type = I_PLINK;;
670 struct lifreq ifr;
671 char actual_name[32] = "";
672
673 memset(&ifr, 0x0, sizeof(ifr));
674
675 if( *dev ){
676 ptr = dev;
677 while( *ptr && !isdigit((int)*ptr) ) ptr++;
678 ppa = atoi(ptr);
679 }
680
681 /* Check if IP device was opened */
682 if( ip_fd )
683 close(ip_fd);
684
685 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
686 if (ip_fd < 0) {
687 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
688 return -1;
689 }
690
691 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
692 if (tap_fd < 0) {
693 syslog(LOG_ERR, "Can't open /dev/tap");
694 return -1;
695 }
696
697 /* Assign a new PPA and get its unit number. */
698 strioc_ppa.ic_cmd = TUNNEWPPA;
699 strioc_ppa.ic_timout = 0;
700 strioc_ppa.ic_len = sizeof(ppa);
701 strioc_ppa.ic_dp = (char *)&ppa;
702 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
703 syslog (LOG_ERR, "Can't assign new interface");
704
705 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
706 if (if_fd < 0) {
707 syslog(LOG_ERR, "Can't open /dev/tap (2)");
708 return -1;
709 }
710 if(ioctl(if_fd, I_PUSH, "ip") < 0){
711 syslog(LOG_ERR, "Can't push IP module");
712 return -1;
713 }
714
715 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
716 syslog(LOG_ERR, "Can't get flags\n");
717
718 snprintf (actual_name, 32, "tap%d", ppa);
719 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
720
721 ifr.lifr_ppa = ppa;
722 /* Assign ppa according to the unit number returned by tun device */
723
724 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
725 syslog (LOG_ERR, "Can't set PPA %d", ppa);
726 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
727 syslog (LOG_ERR, "Can't get flags\n");
728 /* Push arp module to if_fd */
729 if (ioctl (if_fd, I_PUSH, "arp") < 0)
730 syslog (LOG_ERR, "Can't push ARP module (2)");
731
732 /* Push arp module to ip_fd */
733 if (ioctl (ip_fd, I_POP, NULL) < 0)
734 syslog (LOG_ERR, "I_POP failed\n");
735 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
736 syslog (LOG_ERR, "Can't push ARP module (3)\n");
737 /* Open arp_fd */
738 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
739 if (arp_fd < 0)
740 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
741
742 /* Set ifname to arp */
743 strioc_if.ic_cmd = SIOCSLIFNAME;
744 strioc_if.ic_timout = 0;
745 strioc_if.ic_len = sizeof(ifr);
746 strioc_if.ic_dp = (char *)&ifr;
747 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
748 syslog (LOG_ERR, "Can't set ifname to arp\n");
749 }
750
751 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
752 syslog(LOG_ERR, "Can't link TAP device to IP");
753 return -1;
754 }
755
756 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
757 syslog (LOG_ERR, "Can't link TAP device to ARP");
758
759 close (if_fd);
760
761 memset(&ifr, 0x0, sizeof(ifr));
762 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
763 ifr.lifr_ip_muxid = ip_muxid;
764 ifr.lifr_arp_muxid = arp_muxid;
765
766 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
767 {
768 ioctl (ip_fd, I_PUNLINK , arp_muxid);
769 ioctl (ip_fd, I_PUNLINK, ip_muxid);
770 syslog (LOG_ERR, "Can't set multiplexor id");
771 }
772
773 snprintf(dev, dev_size, "tap%d", ppa);
774 return tap_fd;
775}
776
777static int tap_open(char *ifname, int ifname_size)
778{
779 char dev[10]="";
780 int fd;
781 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
782 fprintf(stderr, "Cannot allocate TAP device\n");
783 return -1;
784 }
785 pstrcpy(ifname, ifname_size, dev);
786 fcntl(fd, F_SETFL, O_NONBLOCK);
787 return fd;
788}
789#else
790static int tap_open(char *ifname, int ifname_size)
791{
792 struct ifreq ifr;
793 int fd, ret;
794
795 TFR(fd = open("/dev/net/tun", O_RDWR));
796 if (fd < 0) {
797 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
798 return -1;
799 }
800 memset(&ifr, 0, sizeof(ifr));
801 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
802 if (ifname[0] != '\0')
803 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
804 else
805 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
806 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
807 if (ret != 0) {
808 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
809 close(fd);
810 return -1;
811 }
812 pstrcpy(ifname, ifname_size, ifr.ifr_name);
813 fcntl(fd, F_SETFL, O_NONBLOCK);
814 return fd;
815}
816#endif
817
818static int launch_script(const char *setup_script, const char *ifname, int fd)
819{
820 int pid, status;
821 char *args[3];
822 char **parg;
823
824 /* try to launch network script */
825 pid = fork();
826 if (pid >= 0) {
827 if (pid == 0) {
828 int open_max = sysconf (_SC_OPEN_MAX), i;
829 for (i = 0; i < open_max; i++)
830 if (i != STDIN_FILENO &&
831 i != STDOUT_FILENO &&
832 i != STDERR_FILENO &&
833 i != fd)
834 close(i);
835
836 parg = args;
837 *parg++ = (char *)setup_script;
838 *parg++ = (char *)ifname;
839 *parg++ = NULL;
840 execv(setup_script, args);
841 _exit(1);
842 }
843 while (waitpid(pid, &status, 0) != pid);
844 if (!WIFEXITED(status) ||
845 WEXITSTATUS(status) != 0) {
846 fprintf(stderr, "%s: could not launch network script\n",
847 setup_script);
848 return -1;
849 }
850 }
851 return 0;
852}
853
854static int net_tap_init(VLANState *vlan, const char *ifname1,
855 const char *setup_script, const char *down_script)
856{
857 TAPState *s;
858 int fd;
859 char ifname[128];
860
861 if (ifname1 != NULL)
862 pstrcpy(ifname, sizeof(ifname), ifname1);
863 else
864 ifname[0] = '\0';
865 TFR(fd = tap_open(ifname, sizeof(ifname)));
866 if (fd < 0)
867 return -1;
868
869 if (!setup_script || !strcmp(setup_script, "no"))
870 setup_script = "";
871 if (setup_script[0] != '\0') {
872 if (launch_script(setup_script, ifname, fd))
873 return -1;
874 }
875 s = net_tap_fd_init(vlan, fd);
876 if (!s)
877 return -1;
878 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
879 "tap: ifname=%s setup_script=%s", ifname, setup_script);
880 if (down_script && strcmp(down_script, "no"))
881 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
882 return 0;
883}
884
885#endif /* !_WIN32 */
886
887#if defined(CONFIG_VDE)
888typedef struct VDEState {
889 VLANClientState *vc;
890 VDECONN *vde;
891} VDEState;
892
893static void vde_to_qemu(void *opaque)
894{
895 VDEState *s = opaque;
896 uint8_t buf[4096];
897 int size;
898
899 size = vde_recv(s->vde, buf, sizeof(buf), 0);
900 if (size > 0) {
901 qemu_send_packet(s->vc, buf, size);
902 }
903}
904
905static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
906{
907 VDEState *s = opaque;
908 int ret;
909 for(;;) {
910 ret = vde_send(s->vde, buf, size, 0);
911 if (ret < 0 && errno == EINTR) {
912 } else {
913 break;
914 }
915 }
916}
917
918static int net_vde_init(VLANState *vlan, const char *sock, int port,
919 const char *group, int mode)
920{
921 VDEState *s;
922 char *init_group = strlen(group) ? (char *)group : NULL;
923 char *init_sock = strlen(sock) ? (char *)sock : NULL;
924
925 struct vde_open_args args = {
926 .port = port,
927 .group = init_group,
928 .mode = mode,
929 };
930
931 s = qemu_mallocz(sizeof(VDEState));
932 if (!s)
933 return -1;
934 s->vde = vde_open(init_sock, "QEMU", &args);
935 if (!s->vde){
936 free(s);
937 return -1;
938 }
939 s->vc = qemu_new_vlan_client(vlan, vde_from_qemu, NULL, s);
940 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
941 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "vde: sock=%s fd=%d",
942 sock, vde_datafd(s->vde));
943 return 0;
944}
945#endif
946
947/* network connection */
948typedef struct NetSocketState {
949 VLANClientState *vc;
950 int fd;
951 int state; /* 0 = getting length, 1 = getting data */
952 int index;
953 int packet_len;
954 uint8_t buf[4096];
955 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
956} NetSocketState;
957
958typedef struct NetSocketListenState {
959 VLANState *vlan;
960 int fd;
961} NetSocketListenState;
962
963/* XXX: we consider we can send the whole packet without blocking */
964static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
965{
966 NetSocketState *s = opaque;
967 uint32_t len;
968 len = htonl(size);
969
970 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
971 send_all(s->fd, buf, size);
972}
973
974static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
975{
976 NetSocketState *s = opaque;
977 sendto(s->fd, buf, size, 0,
978 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
979}
980
981static void net_socket_send(void *opaque)
982{
983 NetSocketState *s = opaque;
984 int l, size, err;
985 uint8_t buf1[4096];
986 const uint8_t *buf;
987
988 size = recv(s->fd, buf1, sizeof(buf1), 0);
989 if (size < 0) {
990 err = socket_error();
991 if (err != EWOULDBLOCK)
992 goto eoc;
993 } else if (size == 0) {
994 /* end of connection */
995 eoc:
996 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
997 closesocket(s->fd);
998 return;
999 }
1000 buf = buf1;
1001 while (size > 0) {
1002 /* reassemble a packet from the network */
1003 switch(s->state) {
1004 case 0:
1005 l = 4 - s->index;
1006 if (l > size)
1007 l = size;
1008 memcpy(s->buf + s->index, buf, l);
1009 buf += l;
1010 size -= l;
1011 s->index += l;
1012 if (s->index == 4) {
1013 /* got length */
1014 s->packet_len = ntohl(*(uint32_t *)s->buf);
1015 s->index = 0;
1016 s->state = 1;
1017 }
1018 break;
1019 case 1:
1020 l = s->packet_len - s->index;
1021 if (l > size)
1022 l = size;
1023 memcpy(s->buf + s->index, buf, l);
1024 s->index += l;
1025 buf += l;
1026 size -= l;
1027 if (s->index >= s->packet_len) {
1028 qemu_send_packet(s->vc, s->buf, s->packet_len);
1029 s->index = 0;
1030 s->state = 0;
1031 }
1032 break;
1033 }
1034 }
1035}
1036
1037static void net_socket_send_dgram(void *opaque)
1038{
1039 NetSocketState *s = opaque;
1040 int size;
1041
1042 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
1043 if (size < 0)
1044 return;
1045 if (size == 0) {
1046 /* end of connection */
1047 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1048 return;
1049 }
1050 qemu_send_packet(s->vc, s->buf, size);
1051}
1052
1053static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1054{
1055 struct ip_mreq imr;
1056 int fd;
1057 int val, ret;
1058 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1059 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1060 inet_ntoa(mcastaddr->sin_addr),
1061 (int)ntohl(mcastaddr->sin_addr.s_addr));
1062 return -1;
1063
1064 }
1065 fd = socket(PF_INET, SOCK_DGRAM, 0);
1066 if (fd < 0) {
1067 perror("socket(PF_INET, SOCK_DGRAM)");
1068 return -1;
1069 }
1070
1071 val = 1;
1072 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1073 (const char *)&val, sizeof(val));
1074 if (ret < 0) {
1075 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1076 goto fail;
1077 }
1078
1079 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1080 if (ret < 0) {
1081 perror("bind");
1082 goto fail;
1083 }
1084
1085 /* Add host to multicast group */
1086 imr.imr_multiaddr = mcastaddr->sin_addr;
1087 imr.imr_interface.s_addr = htonl(INADDR_ANY);
1088
1089 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1090 (const char *)&imr, sizeof(struct ip_mreq));
1091 if (ret < 0) {
1092 perror("setsockopt(IP_ADD_MEMBERSHIP)");
1093 goto fail;
1094 }
1095
1096 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1097 val = 1;
1098 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1099 (const char *)&val, sizeof(val));
1100 if (ret < 0) {
1101 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1102 goto fail;
1103 }
1104
1105 socket_set_nonblock(fd);
1106 return fd;
1107fail:
1108 if (fd >= 0)
1109 closesocket(fd);
1110 return -1;
1111}
1112
1113static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
1114 int is_connected)
1115{
1116 struct sockaddr_in saddr;
1117 int newfd;
1118 socklen_t saddr_len;
1119 NetSocketState *s;
1120
1121 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1122 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1123 * by ONLY ONE process: we must "clone" this dgram socket --jjo
1124 */
1125
1126 if (is_connected) {
1127 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1128 /* must be bound */
1129 if (saddr.sin_addr.s_addr==0) {
1130 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1131 fd);
1132 return NULL;
1133 }
1134 /* clone dgram socket */
1135 newfd = net_socket_mcast_create(&saddr);
1136 if (newfd < 0) {
1137 /* error already reported by net_socket_mcast_create() */
1138 close(fd);
1139 return NULL;
1140 }
1141 /* clone newfd to fd, close newfd */
1142 dup2(newfd, fd);
1143 close(newfd);
1144
1145 } else {
1146 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1147 fd, strerror(errno));
1148 return NULL;
1149 }
1150 }
1151
1152 s = qemu_mallocz(sizeof(NetSocketState));
1153 if (!s)
1154 return NULL;
1155 s->fd = fd;
1156
1157 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
1158 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
1159
1160 /* mcast: save bound address as dst */
1161 if (is_connected) s->dgram_dst=saddr;
1162
1163 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1164 "socket: fd=%d (%s mcast=%s:%d)",
1165 fd, is_connected? "cloned" : "",
1166 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1167 return s;
1168}
1169
1170static void net_socket_connect(void *opaque)
1171{
1172 NetSocketState *s = opaque;
1173 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
1174}
1175
1176static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
1177 int is_connected)
1178{
1179 NetSocketState *s;
1180 s = qemu_mallocz(sizeof(NetSocketState));
1181 if (!s)
1182 return NULL;
1183 s->fd = fd;
1184 s->vc = qemu_new_vlan_client(vlan,
1185 net_socket_receive, NULL, s);
1186 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1187 "socket: fd=%d", fd);
1188 if (is_connected) {
1189 net_socket_connect(s);
1190 } else {
1191 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
1192 }
1193 return s;
1194}
1195
1196static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
1197 int is_connected)
1198{
1199 int so_type=-1, optlen=sizeof(so_type);
1200
1201 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
1202 (socklen_t *)&optlen)< 0) {
1203 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
1204 return NULL;
1205 }
1206 switch(so_type) {
1207 case SOCK_DGRAM:
1208 return net_socket_fd_init_dgram(vlan, fd, is_connected);
1209 case SOCK_STREAM:
1210 return net_socket_fd_init_stream(vlan, fd, is_connected);
1211 default:
1212 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
1213 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
1214 return net_socket_fd_init_stream(vlan, fd, is_connected);
1215 }
1216 return NULL;
1217}
1218
1219static void net_socket_accept(void *opaque)
1220{
1221 NetSocketListenState *s = opaque;
1222 NetSocketState *s1;
1223 struct sockaddr_in saddr;
1224 socklen_t len;
1225 int fd;
1226
1227 for(;;) {
1228 len = sizeof(saddr);
1229 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
1230 if (fd < 0 && errno != EINTR) {
1231 return;
1232 } else if (fd >= 0) {
1233 break;
1234 }
1235 }
1236 s1 = net_socket_fd_init(s->vlan, fd, 1);
1237 if (!s1) {
1238 closesocket(fd);
1239 } else {
1240 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
1241 "socket: connection from %s:%d",
1242 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1243 }
1244}
1245
1246static int net_socket_listen_init(VLANState *vlan, const char *host_str)
1247{
1248 NetSocketListenState *s;
1249 int fd, val, ret;
1250 struct sockaddr_in saddr;
1251
1252 if (parse_host_port(&saddr, host_str) < 0)
1253 return -1;
1254
1255 s = qemu_mallocz(sizeof(NetSocketListenState));
1256 if (!s)
1257 return -1;
1258
1259 fd = socket(PF_INET, SOCK_STREAM, 0);
1260 if (fd < 0) {
1261 perror("socket");
1262 return -1;
1263 }
1264 socket_set_nonblock(fd);
1265
1266 /* allow fast reuse */
1267 val = 1;
1268 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
1269
1270 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1271 if (ret < 0) {
1272 perror("bind");
1273 return -1;
1274 }
1275 ret = listen(fd, 0);
1276 if (ret < 0) {
1277 perror("listen");
1278 return -1;
1279 }
1280 s->vlan = vlan;
1281 s->fd = fd;
1282 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
1283 return 0;
1284}
1285
1286static int net_socket_connect_init(VLANState *vlan, const char *host_str)
1287{
1288 NetSocketState *s;
1289 int fd, connected, ret, err;
1290 struct sockaddr_in saddr;
1291
1292 if (parse_host_port(&saddr, host_str) < 0)
1293 return -1;
1294
1295 fd = socket(PF_INET, SOCK_STREAM, 0);
1296 if (fd < 0) {
1297 perror("socket");
1298 return -1;
1299 }
1300 socket_set_nonblock(fd);
1301
1302 connected = 0;
1303 for(;;) {
1304 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1305 if (ret < 0) {
1306 err = socket_error();
1307 if (err == EINTR || err == EWOULDBLOCK) {
1308 } else if (err == EINPROGRESS) {
1309 break;
1310#ifdef _WIN32
1311 } else if (err == WSAEALREADY) {
1312 break;
1313#endif
1314 } else {
1315 perror("connect");
1316 closesocket(fd);
1317 return -1;
1318 }
1319 } else {
1320 connected = 1;
1321 break;
1322 }
1323 }
1324 s = net_socket_fd_init(vlan, fd, connected);
1325 if (!s)
1326 return -1;
1327 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1328 "socket: connect to %s:%d",
1329 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1330 return 0;
1331}
1332
1333static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
1334{
1335 NetSocketState *s;
1336 int fd;
1337 struct sockaddr_in saddr;
1338
1339 if (parse_host_port(&saddr, host_str) < 0)
1340 return -1;
1341
1342
1343 fd = net_socket_mcast_create(&saddr);
1344 if (fd < 0)
1345 return -1;
1346
1347 s = net_socket_fd_init(vlan, fd, 0);
1348 if (!s)
1349 return -1;
1350
1351 s->dgram_dst = saddr;
1352
1353 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1354 "socket: mcast=%s:%d",
1355 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1356 return 0;
1357
1358}
1359
1360/* find or alloc a new VLAN */
1361VLANState *qemu_find_vlan(int id)
1362{
1363 VLANState **pvlan, *vlan;
1364 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1365 if (vlan->id == id)
1366 return vlan;
1367 }
1368 vlan = qemu_mallocz(sizeof(VLANState));
1369 if (!vlan)
1370 return NULL;
1371 vlan->id = id;
1372 vlan->next = NULL;
1373 pvlan = &first_vlan;
1374 while (*pvlan != NULL)
1375 pvlan = &(*pvlan)->next;
1376 *pvlan = vlan;
1377 return vlan;
1378}
1379
1380int net_client_init(const char *device, const char *p)
1381{
1382 char buf[1024];
1383 int vlan_id, ret;
1384 VLANState *vlan;
1385
1386 vlan_id = 0;
1387 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
1388 vlan_id = strtol(buf, NULL, 0);
1389 }
1390 vlan = qemu_find_vlan(vlan_id);
1391 if (!vlan) {
1392 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
1393 return -1;
1394 }
1395 if (!strcmp(device, "nic")) {
1396 NICInfo *nd;
1397 uint8_t *macaddr;
1398
1399 if (nb_nics >= MAX_NICS) {
1400 fprintf(stderr, "Too Many NICs\n");
1401 return -1;
1402 }
1403 nd = &nd_table[nb_nics];
1404 macaddr = nd->macaddr;
1405 macaddr[0] = 0x52;
1406 macaddr[1] = 0x54;
1407 macaddr[2] = 0x00;
1408 macaddr[3] = 0x12;
1409 macaddr[4] = 0x34;
1410 macaddr[5] = 0x56 + nb_nics;
1411
1412 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
1413 if (parse_macaddr(macaddr, buf) < 0) {
1414 fprintf(stderr, "invalid syntax for ethernet address\n");
1415 return -1;
1416 }
1417 }
1418 if (get_param_value(buf, sizeof(buf), "model", p)) {
1419 nd->model = strdup(buf);
1420 }
1421 nd->vlan = vlan;
1422 nb_nics++;
1423 vlan->nb_guest_devs++;
1424 ret = 0;
1425 } else
1426 if (!strcmp(device, "none")) {
1427 /* does nothing. It is needed to signal that no network cards
1428 are wanted */
1429 ret = 0;
1430 } else
1431#ifdef CONFIG_SLIRP
1432 if (!strcmp(device, "user")) {
1433 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
1434 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
1435 }
1436 vlan->nb_host_devs++;
1437 ret = net_slirp_init(vlan);
1438 } else
1439#endif
1440#ifdef _WIN32
1441 if (!strcmp(device, "tap")) {
1442 char ifname[64];
1443 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1444 fprintf(stderr, "tap: no interface name\n");
1445 return -1;
1446 }
1447 vlan->nb_host_devs++;
1448 ret = tap_win32_init(vlan, ifname);
1449 } else
1450#else
1451 if (!strcmp(device, "tap")) {
1452 char ifname[64];
1453 char setup_script[1024], down_script[1024];
1454 int fd;
1455 vlan->nb_host_devs++;
1456 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1457 fd = strtol(buf, NULL, 0);
1458 fcntl(fd, F_SETFL, O_NONBLOCK);
1459 ret = -1;
1460 if (net_tap_fd_init(vlan, fd))
1461 ret = 0;
1462 } else {
1463 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1464 ifname[0] = '\0';
1465 }
1466 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
1467 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
1468 }
1469 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
1470 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
1471 }
1472 ret = net_tap_init(vlan, ifname, setup_script, down_script);
1473 }
1474 } else
1475#endif
1476 if (!strcmp(device, "socket")) {
1477 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1478 int fd;
1479 fd = strtol(buf, NULL, 0);
1480 ret = -1;
1481 if (net_socket_fd_init(vlan, fd, 1))
1482 ret = 0;
1483 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
1484 ret = net_socket_listen_init(vlan, buf);
1485 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
1486 ret = net_socket_connect_init(vlan, buf);
1487 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
1488 ret = net_socket_mcast_init(vlan, buf);
1489 } else {
1490 fprintf(stderr, "Unknown socket options: %s\n", p);
1491 return -1;
1492 }
1493 vlan->nb_host_devs++;
1494 } else
1495#ifdef CONFIG_VDE
1496 if (!strcmp(device, "vde")) {
1497 char vde_sock[1024], vde_group[512];
1498 int vde_port, vde_mode;
1499 vlan->nb_host_devs++;
1500 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
1501 vde_sock[0] = '\0';
1502 }
1503 if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
1504 vde_port = strtol(buf, NULL, 10);
1505 } else {
1506 vde_port = 0;
1507 }
1508 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
1509 vde_group[0] = '\0';
1510 }
1511 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
1512 vde_mode = strtol(buf, NULL, 8);
1513 } else {
1514 vde_mode = 0700;
1515 }
1516 ret = net_vde_init(vlan, vde_sock, vde_port, vde_group, vde_mode);
1517 } else
1518#endif
1519 {
1520 fprintf(stderr, "Unknown network device: %s\n", device);
1521 return -1;
1522 }
1523 if (ret < 0) {
1524 fprintf(stderr, "Could not initialize device '%s'\n", device);
1525 }
1526
1527 return ret;
1528}
1529
1530int net_client_parse(const char *str)
1531{
1532 const char *p;
1533 char *q;
1534 char device[64];
1535
1536 p = str;
1537 q = device;
1538 while (*p != '\0' && *p != ',') {
1539 if ((q - device) < sizeof(device) - 1)
1540 *q++ = *p;
1541 p++;
1542 }
1543 *q = '\0';
1544 if (*p == ',')
1545 p++;
1546
1547 return net_client_init(device, p);
1548}
1549
1550void do_info_network(void)
1551{
1552 VLANState *vlan;
1553 VLANClientState *vc;
1554
1555 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1556 term_printf("VLAN %d devices:\n", vlan->id);
1557 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
1558 term_printf(" %s\n", vc->info_str);
1559 }
1560}
1561
1562void net_cleanup(void)
1563{
1564 VLANState *vlan;
1565
1566#if !defined(_WIN32)
1567 /* close network clients */
1568 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1569 VLANClientState *vc;
1570
1571 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1572 if (vc->fd_read == tap_receive) {
1573 char ifname[64];
1574 TAPState *s = vc->opaque;
1575
1576 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
1577 s->down_script[0])
1578 launch_script(s->down_script, ifname, s->fd);
1579 }
1580#if defined(CONFIG_VDE)
1581 if (vc->fd_read == vde_from_qemu) {
1582 VDEState *s = vc->opaque;
1583 vde_close(s->vde);
1584 }
1585#endif
1586 }
1587 }
1588#endif
1589}
1590
1591void net_client_check(void)
1592{
1593 VLANState *vlan;
1594
1595 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1596 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
1597 continue;
1598 if (vlan->nb_guest_devs == 0)
1599 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1600 if (vlan->nb_host_devs == 0)
1601 fprintf(stderr,
1602 "Warning: vlan %d is not connected to host network\n",
1603 vlan->id);
1604 }
1605}
Qemu copy for testing