Remove noisy printf when KVM masks CPU features
[qemu-kvm/fedora.git] / net.c
blobae54421801e39186ae8bba1b86aeec02fd34b1ea
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include "qemu-common.h"
25 #include "net.h"
26 #include "console.h"
27 #include "sysemu.h"
28 #include "qemu-timer.h"
29 #include "qemu-char.h"
30 #include "audio/audio.h"
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <signal.h>
35 #include <time.h>
36 #include <errno.h>
37 #include <sys/time.h>
38 #include <zlib.h>
40 #ifndef _WIN32
41 #include <sys/times.h>
42 #include <sys/wait.h>
43 #include <termios.h>
44 #include <sys/mman.h>
45 #include <sys/ioctl.h>
46 #include <sys/resource.h>
47 #include <sys/socket.h>
48 #include <netinet/in.h>
49 #include <net/if.h>
50 #ifdef __NetBSD__
51 #include <net/if_tap.h>
52 #endif
53 #ifdef __linux__
54 #include <linux/if_tun.h>
55 #endif
56 #include <arpa/inet.h>
57 #include <dirent.h>
58 #include <netdb.h>
59 #include <sys/select.h>
60 #ifdef _BSD
61 #include <sys/stat.h>
62 #ifdef __FreeBSD__
63 #include <libutil.h>
64 #else
65 #include <util.h>
66 #endif
67 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68 #include <freebsd/stdlib.h>
69 #else
70 #ifdef __linux__
71 #include <pty.h>
72 #include <malloc.h>
73 #include <linux/rtc.h>
75 /* For the benefit of older linux systems which don't supply it,
76 we use a local copy of hpet.h. */
77 /* #include <linux/hpet.h> */
78 #include "hpet.h"
80 #include <linux/ppdev.h>
81 #include <linux/parport.h>
82 #endif
83 #ifdef __sun__
84 #include <sys/stat.h>
85 #include <sys/ethernet.h>
86 #include <sys/sockio.h>
87 #include <netinet/arp.h>
88 #include <netinet/in.h>
89 #include <netinet/in_systm.h>
90 #include <netinet/ip.h>
91 #include <netinet/ip_icmp.h> // must come after ip.h
92 #include <netinet/udp.h>
93 #include <netinet/tcp.h>
94 #include <net/if.h>
95 #include <syslog.h>
96 #include <stropts.h>
97 #endif
98 #endif
99 #endif
101 #include "qemu_socket.h"
103 #if defined(CONFIG_SLIRP)
104 #include "libslirp.h"
105 #endif
107 #if defined(__OpenBSD__)
108 #include <util.h>
109 #endif
111 #if defined(CONFIG_VDE)
112 #include <libvdeplug.h>
113 #endif
115 #ifdef _WIN32
116 #include <malloc.h>
117 #include <sys/timeb.h>
118 #include <mmsystem.h>
119 #define getopt_long_only getopt_long
120 #define memalign(align, size) malloc(size)
121 #endif
123 static VLANState *first_vlan;
125 /***********************************************************/
126 /* network device redirectors */
128 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
129 static void hex_dump(FILE *f, const uint8_t *buf, int size)
131 int len, i, j, c;
133 for(i=0;i<size;i+=16) {
134 len = size - i;
135 if (len > 16)
136 len = 16;
137 fprintf(f, "%08x ", i);
138 for(j=0;j<16;j++) {
139 if (j < len)
140 fprintf(f, " %02x", buf[i+j]);
141 else
142 fprintf(f, " ");
144 fprintf(f, " ");
145 for(j=0;j<len;j++) {
146 c = buf[i+j];
147 if (c < ' ' || c > '~')
148 c = '.';
149 fprintf(f, "%c", c);
151 fprintf(f, "\n");
154 #endif
156 static int parse_macaddr(uint8_t *macaddr, const char *p)
158 int i;
159 char *last_char;
160 long int offset;
162 errno = 0;
163 offset = strtol(p, &last_char, 0);
164 if (0 == errno && '\0' == *last_char &&
165 offset >= 0 && offset <= 0xFFFFFF) {
166 macaddr[3] = (offset & 0xFF0000) >> 16;
167 macaddr[4] = (offset & 0xFF00) >> 8;
168 macaddr[5] = offset & 0xFF;
169 return 0;
170 } else {
171 for(i = 0; i < 6; i++) {
172 macaddr[i] = strtol(p, (char **)&p, 16);
173 if (i == 5) {
174 if (*p != '\0')
175 return -1;
176 } else {
177 if (*p != ':' && *p != '-')
178 return -1;
179 p++;
182 return 0;
185 return -1;
188 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
190 const char *p, *p1;
191 int len;
192 p = *pp;
193 p1 = strchr(p, sep);
194 if (!p1)
195 return -1;
196 len = p1 - p;
197 p1++;
198 if (buf_size > 0) {
199 if (len > buf_size - 1)
200 len = buf_size - 1;
201 memcpy(buf, p, len);
202 buf[len] = '\0';
204 *pp = p1;
205 return 0;
208 int parse_host_src_port(struct sockaddr_in *haddr,
209 struct sockaddr_in *saddr,
210 const char *input_str)
212 char *str = strdup(input_str);
213 char *host_str = str;
214 char *src_str;
215 const char *src_str2;
216 char *ptr;
219 * Chop off any extra arguments at the end of the string which
220 * would start with a comma, then fill in the src port information
221 * if it was provided else use the "any address" and "any port".
223 if ((ptr = strchr(str,',')))
224 *ptr = '\0';
226 if ((src_str = strchr(input_str,'@'))) {
227 *src_str = '\0';
228 src_str++;
231 if (parse_host_port(haddr, host_str) < 0)
232 goto fail;
234 src_str2 = src_str;
235 if (!src_str || *src_str == '\0')
236 src_str2 = ":0";
238 if (parse_host_port(saddr, src_str2) < 0)
239 goto fail;
241 free(str);
242 return(0);
244 fail:
245 free(str);
246 return -1;
249 int parse_host_port(struct sockaddr_in *saddr, const char *str)
251 char buf[512];
252 struct hostent *he;
253 const char *p, *r;
254 int port;
256 p = str;
257 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
258 return -1;
259 saddr->sin_family = AF_INET;
260 if (buf[0] == '\0') {
261 saddr->sin_addr.s_addr = 0;
262 } else {
263 if (qemu_isdigit(buf[0])) {
264 if (!inet_aton(buf, &saddr->sin_addr))
265 return -1;
266 } else {
267 if ((he = gethostbyname(buf)) == NULL)
268 return - 1;
269 saddr->sin_addr = *(struct in_addr *)he->h_addr;
272 port = strtol(p, (char **)&r, 0);
273 if (r == p)
274 return -1;
275 saddr->sin_port = htons(port);
276 return 0;
279 #if !defined(_WIN32) && 0
280 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
282 const char *p;
283 int len;
285 len = MIN(108, strlen(str));
286 p = strchr(str, ',');
287 if (p)
288 len = MIN(len, p - str);
290 memset(uaddr, 0, sizeof(*uaddr));
292 uaddr->sun_family = AF_UNIX;
293 memcpy(uaddr->sun_path, str, len);
295 return 0;
297 #endif
299 void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
301 snprintf(vc->info_str, sizeof(vc->info_str),
302 "model=%s,macaddr=%02x:%02x:%02x:%02x:%02x:%02x",
303 vc->model,
304 macaddr[0], macaddr[1], macaddr[2],
305 macaddr[3], macaddr[4], macaddr[5]);
308 static char *assign_name(VLANClientState *vc1, const char *model)
310 VLANState *vlan;
311 char buf[256];
312 int id = 0;
314 for (vlan = first_vlan; vlan; vlan = vlan->next) {
315 VLANClientState *vc;
317 for (vc = vlan->first_client; vc; vc = vc->next)
318 if (vc != vc1 && strcmp(vc->model, model) == 0)
319 id++;
322 snprintf(buf, sizeof(buf), "%s.%d", model, id);
324 return strdup(buf);
327 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
328 const char *model,
329 const char *name,
330 IOReadHandler *fd_read,
331 IOCanRWHandler *fd_can_read,
332 NetCleanup *cleanup,
333 void *opaque)
335 VLANClientState *vc, **pvc;
336 vc = qemu_mallocz(sizeof(VLANClientState));
337 vc->model = strdup(model);
338 if (name)
339 vc->name = strdup(name);
340 else
341 vc->name = assign_name(vc, model);
342 vc->fd_read = fd_read;
343 vc->fd_can_read = fd_can_read;
344 vc->cleanup = cleanup;
345 vc->opaque = opaque;
346 vc->vlan = vlan;
348 vc->next = NULL;
349 pvc = &vlan->first_client;
350 while (*pvc != NULL)
351 pvc = &(*pvc)->next;
352 *pvc = vc;
353 return vc;
356 void qemu_del_vlan_client(VLANClientState *vc)
358 VLANClientState **pvc = &vc->vlan->first_client;
360 while (*pvc != NULL)
361 if (*pvc == vc) {
362 *pvc = vc->next;
363 if (vc->cleanup) {
364 vc->cleanup(vc);
366 free(vc->name);
367 free(vc->model);
368 qemu_free(vc);
369 break;
370 } else
371 pvc = &(*pvc)->next;
374 VLANClientState *qemu_find_vlan_client(VLANState *vlan, void *opaque)
376 VLANClientState **pvc = &vlan->first_client;
378 while (*pvc != NULL)
379 if ((*pvc)->opaque == opaque)
380 return *pvc;
381 else
382 pvc = &(*pvc)->next;
384 return NULL;
387 int qemu_can_send_packet(VLANClientState *vc1)
389 VLANState *vlan = vc1->vlan;
390 VLANClientState *vc;
392 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
393 if (vc != vc1) {
394 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
395 return 1;
398 return 0;
401 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
403 VLANState *vlan = vc1->vlan;
404 VLANClientState *vc;
406 if (vc1->link_down)
407 return;
409 #ifdef DEBUG_NET
410 printf("vlan %d send:\n", vlan->id);
411 hex_dump(stdout, buf, size);
412 #endif
413 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
414 if (vc != vc1 && !vc->link_down) {
415 vc->fd_read(vc->opaque, buf, size);
420 static ssize_t vc_sendv_compat(VLANClientState *vc, const struct iovec *iov,
421 int iovcnt)
423 uint8_t buffer[4096];
424 size_t offset = 0;
425 int i;
427 for (i = 0; i < iovcnt; i++) {
428 size_t len;
430 len = MIN(sizeof(buffer) - offset, iov[i].iov_len);
431 memcpy(buffer + offset, iov[i].iov_base, len);
432 offset += len;
435 vc->fd_read(vc->opaque, buffer, offset);
437 return offset;
440 static ssize_t calc_iov_length(const struct iovec *iov, int iovcnt)
442 size_t offset = 0;
443 int i;
445 for (i = 0; i < iovcnt; i++)
446 offset += iov[i].iov_len;
447 return offset;
450 ssize_t qemu_sendv_packet(VLANClientState *vc1, const struct iovec *iov,
451 int iovcnt)
453 VLANState *vlan = vc1->vlan;
454 VLANClientState *vc;
455 ssize_t max_len = 0;
457 if (vc1->link_down)
458 return calc_iov_length(iov, iovcnt);
460 for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
461 ssize_t len = 0;
463 if (vc == vc1)
464 continue;
466 if (vc->link_down)
467 len = calc_iov_length(iov, iovcnt);
468 if (vc->fd_readv)
469 len = vc->fd_readv(vc->opaque, iov, iovcnt);
470 else if (vc->fd_read)
471 len = vc_sendv_compat(vc, iov, iovcnt);
473 max_len = MAX(max_len, len);
476 return max_len;
479 #if defined(CONFIG_SLIRP)
481 /* slirp network adapter */
483 static int slirp_inited;
484 static int slirp_restrict;
485 static char *slirp_ip;
486 static VLANClientState *slirp_vc;
488 int slirp_can_output(void)
490 return !slirp_vc || qemu_can_send_packet(slirp_vc);
493 void slirp_output(const uint8_t *pkt, int pkt_len)
495 #ifdef DEBUG_SLIRP
496 printf("slirp output:\n");
497 hex_dump(stdout, pkt, pkt_len);
498 #endif
499 if (!slirp_vc)
500 return;
501 qemu_send_packet(slirp_vc, pkt, pkt_len);
504 int slirp_is_inited(void)
506 return slirp_inited;
509 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
511 #ifdef DEBUG_SLIRP
512 printf("slirp input:\n");
513 hex_dump(stdout, buf, size);
514 #endif
515 slirp_input(buf, size);
518 static int net_slirp_init(VLANState *vlan, const char *model, const char *name)
520 if (!slirp_inited) {
521 slirp_inited = 1;
522 slirp_init(slirp_restrict, slirp_ip);
524 slirp_vc = qemu_new_vlan_client(vlan, model, name,
525 slirp_receive, NULL, NULL, NULL);
526 slirp_vc->info_str[0] = '\0';
527 return 0;
530 void net_slirp_redir(const char *redir_str)
532 int is_udp;
533 char buf[256], *r;
534 const char *p;
535 struct in_addr guest_addr;
536 int host_port, guest_port;
538 if (!slirp_inited) {
539 slirp_inited = 1;
540 slirp_init(slirp_restrict, slirp_ip);
543 p = redir_str;
544 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
545 goto fail;
546 if (!strcmp(buf, "tcp")) {
547 is_udp = 0;
548 } else if (!strcmp(buf, "udp")) {
549 is_udp = 1;
550 } else {
551 goto fail;
554 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
555 goto fail;
556 host_port = strtol(buf, &r, 0);
557 if (r == buf)
558 goto fail;
560 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
561 goto fail;
562 if (buf[0] == '\0') {
563 pstrcpy(buf, sizeof(buf), "10.0.2.15");
565 if (!inet_aton(buf, &guest_addr))
566 goto fail;
568 guest_port = strtol(p, &r, 0);
569 if (r == p)
570 goto fail;
572 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
573 fprintf(stderr, "qemu: could not set up redirection\n");
574 exit(1);
576 return;
577 fail:
578 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
579 exit(1);
582 #ifndef _WIN32
584 static char smb_dir[1024];
586 static void erase_dir(char *dir_name)
588 DIR *d;
589 struct dirent *de;
590 char filename[1024];
592 /* erase all the files in the directory */
593 if ((d = opendir(dir_name)) != 0) {
594 for(;;) {
595 de = readdir(d);
596 if (!de)
597 break;
598 if (strcmp(de->d_name, ".") != 0 &&
599 strcmp(de->d_name, "..") != 0) {
600 snprintf(filename, sizeof(filename), "%s/%s",
601 smb_dir, de->d_name);
602 if (unlink(filename) != 0) /* is it a directory? */
603 erase_dir(filename);
606 closedir(d);
607 rmdir(dir_name);
611 /* automatic user mode samba server configuration */
612 static void smb_exit(void)
614 erase_dir(smb_dir);
617 /* automatic user mode samba server configuration */
618 void net_slirp_smb(const char *exported_dir)
620 char smb_conf[1024];
621 char smb_cmdline[1024];
622 FILE *f;
624 if (!slirp_inited) {
625 slirp_inited = 1;
626 slirp_init(slirp_restrict, slirp_ip);
629 /* XXX: better tmp dir construction */
630 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
631 if (mkdir(smb_dir, 0700) < 0) {
632 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
633 exit(1);
635 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
637 f = fopen(smb_conf, "w");
638 if (!f) {
639 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
640 exit(1);
642 fprintf(f,
643 "[global]\n"
644 "private dir=%s\n"
645 "smb ports=0\n"
646 "socket address=127.0.0.1\n"
647 "pid directory=%s\n"
648 "lock directory=%s\n"
649 "log file=%s/log.smbd\n"
650 "smb passwd file=%s/smbpasswd\n"
651 "security = share\n"
652 "[qemu]\n"
653 "path=%s\n"
654 "read only=no\n"
655 "guest ok=yes\n",
656 smb_dir,
657 smb_dir,
658 smb_dir,
659 smb_dir,
660 smb_dir,
661 exported_dir
663 fclose(f);
664 atexit(smb_exit);
666 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
667 SMBD_COMMAND, smb_conf);
669 slirp_add_exec(0, smb_cmdline, 4, 139);
672 #endif /* !defined(_WIN32) */
673 void do_info_slirp(void)
675 slirp_stats();
678 struct VMChannel {
679 CharDriverState *hd;
680 int port;
681 } *vmchannels;
683 static int vmchannel_can_read(void *opaque)
685 struct VMChannel *vmc = (struct VMChannel*)opaque;
686 return slirp_socket_can_recv(4, vmc->port);
689 static void vmchannel_read(void *opaque, const uint8_t *buf, int size)
691 struct VMChannel *vmc = (struct VMChannel*)opaque;
692 slirp_socket_recv(4, vmc->port, buf, size);
695 #endif /* CONFIG_SLIRP */
697 #if !defined(_WIN32)
699 typedef struct TAPState {
700 VLANClientState *vc;
701 int fd;
702 char down_script[1024];
703 char down_script_arg[128];
704 } TAPState;
706 static int launch_script(const char *setup_script, const char *ifname, int fd);
708 static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov,
709 int iovcnt)
711 TAPState *s = opaque;
712 ssize_t len;
714 do {
715 len = writev(s->fd, iov, iovcnt);
716 } while (len == -1 && (errno == EINTR || errno == EAGAIN));
718 return len;
721 static void tap_receive(void *opaque, const uint8_t *buf, int size)
723 TAPState *s = opaque;
724 int ret;
725 for(;;) {
726 ret = write(s->fd, buf, size);
727 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
728 } else {
729 break;
734 static void tap_send(void *opaque)
736 TAPState *s = opaque;
737 uint8_t buf[4096];
738 int size;
740 #ifdef __sun__
741 struct strbuf sbuf;
742 int f = 0;
743 sbuf.maxlen = sizeof(buf);
744 sbuf.buf = buf;
745 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
746 #else
747 size = read(s->fd, buf, sizeof(buf));
748 #endif
749 if (size > 0) {
750 qemu_send_packet(s->vc, buf, size);
754 static void tap_cleanup(VLANClientState *vc)
756 TAPState *s = vc->opaque;
758 if (s->down_script[0])
759 launch_script(s->down_script, s->down_script_arg, s->fd);
761 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
762 close(s->fd);
763 qemu_free(s);
766 /* fd support */
768 static TAPState *net_tap_fd_init(VLANState *vlan,
769 const char *model,
770 const char *name,
771 int fd)
773 TAPState *s;
775 s = qemu_mallocz(sizeof(TAPState));
776 s->fd = fd;
777 s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive,
778 NULL, tap_cleanup, s);
779 s->vc->fd_readv = tap_receive_iov;
780 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
781 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd);
782 return s;
785 #if defined (_BSD) || defined (__FreeBSD_kernel__)
786 static int tap_open(char *ifname, int ifname_size)
788 int fd;
789 char *dev;
790 struct stat s;
792 TFR(fd = open("/dev/tap", O_RDWR));
793 if (fd < 0) {
794 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
795 return -1;
798 fstat(fd, &s);
799 dev = devname(s.st_rdev, S_IFCHR);
800 pstrcpy(ifname, ifname_size, dev);
802 fcntl(fd, F_SETFL, O_NONBLOCK);
803 return fd;
805 #elif defined(__sun__)
806 #define TUNNEWPPA (('T'<<16) | 0x0001)
808 * Allocate TAP device, returns opened fd.
809 * Stores dev name in the first arg(must be large enough).
811 int tap_alloc(char *dev, size_t dev_size)
813 int tap_fd, if_fd, ppa = -1;
814 static int ip_fd = 0;
815 char *ptr;
817 static int arp_fd = 0;
818 int ip_muxid, arp_muxid;
819 struct strioctl strioc_if, strioc_ppa;
820 int link_type = I_PLINK;;
821 struct lifreq ifr;
822 char actual_name[32] = "";
824 memset(&ifr, 0x0, sizeof(ifr));
826 if( *dev ){
827 ptr = dev;
828 while( *ptr && !qemu_isdigit((int)*ptr) ) ptr++;
829 ppa = atoi(ptr);
832 /* Check if IP device was opened */
833 if( ip_fd )
834 close(ip_fd);
836 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
837 if (ip_fd < 0) {
838 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
839 return -1;
842 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
843 if (tap_fd < 0) {
844 syslog(LOG_ERR, "Can't open /dev/tap");
845 return -1;
848 /* Assign a new PPA and get its unit number. */
849 strioc_ppa.ic_cmd = TUNNEWPPA;
850 strioc_ppa.ic_timout = 0;
851 strioc_ppa.ic_len = sizeof(ppa);
852 strioc_ppa.ic_dp = (char *)&ppa;
853 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
854 syslog (LOG_ERR, "Can't assign new interface");
856 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
857 if (if_fd < 0) {
858 syslog(LOG_ERR, "Can't open /dev/tap (2)");
859 return -1;
861 if(ioctl(if_fd, I_PUSH, "ip") < 0){
862 syslog(LOG_ERR, "Can't push IP module");
863 return -1;
866 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
867 syslog(LOG_ERR, "Can't get flags\n");
869 snprintf (actual_name, 32, "tap%d", ppa);
870 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
872 ifr.lifr_ppa = ppa;
873 /* Assign ppa according to the unit number returned by tun device */
875 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
876 syslog (LOG_ERR, "Can't set PPA %d", ppa);
877 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
878 syslog (LOG_ERR, "Can't get flags\n");
879 /* Push arp module to if_fd */
880 if (ioctl (if_fd, I_PUSH, "arp") < 0)
881 syslog (LOG_ERR, "Can't push ARP module (2)");
883 /* Push arp module to ip_fd */
884 if (ioctl (ip_fd, I_POP, NULL) < 0)
885 syslog (LOG_ERR, "I_POP failed\n");
886 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
887 syslog (LOG_ERR, "Can't push ARP module (3)\n");
888 /* Open arp_fd */
889 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
890 if (arp_fd < 0)
891 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
893 /* Set ifname to arp */
894 strioc_if.ic_cmd = SIOCSLIFNAME;
895 strioc_if.ic_timout = 0;
896 strioc_if.ic_len = sizeof(ifr);
897 strioc_if.ic_dp = (char *)&ifr;
898 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
899 syslog (LOG_ERR, "Can't set ifname to arp\n");
902 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
903 syslog(LOG_ERR, "Can't link TAP device to IP");
904 return -1;
907 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
908 syslog (LOG_ERR, "Can't link TAP device to ARP");
910 close (if_fd);
912 memset(&ifr, 0x0, sizeof(ifr));
913 pstrcpy(ifr.lifr_name, sizeof(ifr.lifr_name), actual_name);
914 ifr.lifr_ip_muxid = ip_muxid;
915 ifr.lifr_arp_muxid = arp_muxid;
917 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
919 ioctl (ip_fd, I_PUNLINK , arp_muxid);
920 ioctl (ip_fd, I_PUNLINK, ip_muxid);
921 syslog (LOG_ERR, "Can't set multiplexor id");
924 snprintf(dev, dev_size, "tap%d", ppa);
925 return tap_fd;
928 static int tap_open(char *ifname, int ifname_size)
930 char dev[10]="";
931 int fd;
932 if( (fd = tap_alloc(dev, sizeof(dev))) < 0 ){
933 fprintf(stderr, "Cannot allocate TAP device\n");
934 return -1;
936 pstrcpy(ifname, ifname_size, dev);
937 fcntl(fd, F_SETFL, O_NONBLOCK);
938 return fd;
940 #elif defined (_AIX)
941 static int tap_open(char *ifname, int ifname_size)
943 fprintf (stderr, "no tap on AIX\n");
944 return -1;
946 #else
947 static int tap_open(char *ifname, int ifname_size)
949 struct ifreq ifr;
950 int fd, ret;
952 TFR(fd = open("/dev/net/tun", O_RDWR));
953 if (fd < 0) {
954 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
955 return -1;
957 memset(&ifr, 0, sizeof(ifr));
958 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
959 if (ifname[0] != '\0')
960 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
961 else
962 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
963 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
964 if (ret != 0) {
965 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
966 close(fd);
967 return -1;
969 pstrcpy(ifname, ifname_size, ifr.ifr_name);
970 fcntl(fd, F_SETFL, O_NONBLOCK);
971 return fd;
973 #endif
975 static int launch_script(const char *setup_script, const char *ifname, int fd)
977 int pid, status;
978 char *args[3];
979 char **parg;
981 /* try to launch network script */
982 pid = fork();
983 if (pid >= 0) {
984 if (pid == 0) {
985 int open_max = sysconf (_SC_OPEN_MAX), i;
986 for (i = 0; i < open_max; i++)
987 if (i != STDIN_FILENO &&
988 i != STDOUT_FILENO &&
989 i != STDERR_FILENO &&
990 i != fd)
991 close(i);
993 parg = args;
994 *parg++ = (char *)setup_script;
995 *parg++ = (char *)ifname;
996 *parg++ = NULL;
997 execv(setup_script, args);
998 _exit(1);
1000 while (waitpid(pid, &status, 0) != pid);
1001 if (!WIFEXITED(status) ||
1002 WEXITSTATUS(status) != 0) {
1003 fprintf(stderr, "%s: could not launch network script\n",
1004 setup_script);
1005 return -1;
1008 return 0;
1011 static int net_tap_init(VLANState *vlan, const char *model,
1012 const char *name, const char *ifname1,
1013 const char *setup_script, const char *down_script)
1015 TAPState *s;
1016 int fd;
1017 char ifname[128];
1019 if (ifname1 != NULL)
1020 pstrcpy(ifname, sizeof(ifname), ifname1);
1021 else
1022 ifname[0] = '\0';
1023 TFR(fd = tap_open(ifname, sizeof(ifname)));
1024 if (fd < 0)
1025 return -1;
1027 if (!setup_script || !strcmp(setup_script, "no"))
1028 setup_script = "";
1029 if (setup_script[0] != '\0') {
1030 if (launch_script(setup_script, ifname, fd))
1031 return -1;
1033 s = net_tap_fd_init(vlan, model, name, fd);
1034 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1035 "ifname=%s,script=%s,downscript=%s",
1036 ifname, setup_script, down_script);
1037 if (down_script && strcmp(down_script, "no")) {
1038 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
1039 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname);
1041 return 0;
1044 #endif /* !_WIN32 */
1046 #if defined(CONFIG_VDE)
1047 typedef struct VDEState {
1048 VLANClientState *vc;
1049 VDECONN *vde;
1050 } VDEState;
1052 static void vde_to_qemu(void *opaque)
1054 VDEState *s = opaque;
1055 uint8_t buf[4096];
1056 int size;
1058 size = vde_recv(s->vde, buf, sizeof(buf), 0);
1059 if (size > 0) {
1060 qemu_send_packet(s->vc, buf, size);
1064 static void vde_from_qemu(void *opaque, const uint8_t *buf, int size)
1066 VDEState *s = opaque;
1067 int ret;
1068 for(;;) {
1069 ret = vde_send(s->vde, buf, size, 0);
1070 if (ret < 0 && errno == EINTR) {
1071 } else {
1072 break;
1077 static void vde_cleanup(VLANClientState *vc)
1079 VDEState *s = vc->opaque;
1080 qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL);
1081 vde_close(s->vde);
1082 qemu_free(s);
1085 static int net_vde_init(VLANState *vlan, const char *model,
1086 const char *name, const char *sock,
1087 int port, const char *group, int mode)
1089 VDEState *s;
1090 char *init_group = strlen(group) ? (char *)group : NULL;
1091 char *init_sock = strlen(sock) ? (char *)sock : NULL;
1093 struct vde_open_args args = {
1094 .port = port,
1095 .group = init_group,
1096 .mode = mode,
1099 s = qemu_mallocz(sizeof(VDEState));
1100 s->vde = vde_open(init_sock, "QEMU", &args);
1101 if (!s->vde){
1102 free(s);
1103 return -1;
1105 s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_qemu,
1106 NULL, vde_cleanup, s);
1107 qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s);
1108 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d",
1109 sock, vde_datafd(s->vde));
1110 return 0;
1112 #endif
1114 /* network connection */
1115 typedef struct NetSocketState {
1116 VLANClientState *vc;
1117 int fd;
1118 int state; /* 0 = getting length, 1 = getting data */
1119 unsigned int index;
1120 unsigned int packet_len;
1121 uint8_t buf[4096];
1122 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
1123 } NetSocketState;
1125 typedef struct NetSocketListenState {
1126 VLANState *vlan;
1127 char *model;
1128 char *name;
1129 int fd;
1130 } NetSocketListenState;
1132 /* XXX: we consider we can send the whole packet without blocking */
1133 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
1135 NetSocketState *s = opaque;
1136 uint32_t len;
1137 len = htonl(size);
1139 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
1140 send_all(s->fd, buf, size);
1143 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
1145 NetSocketState *s = opaque;
1146 sendto(s->fd, buf, size, 0,
1147 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
1150 static void net_socket_send(void *opaque)
1152 NetSocketState *s = opaque;
1153 int size, err;
1154 unsigned l;
1155 uint8_t buf1[4096];
1156 const uint8_t *buf;
1158 size = recv(s->fd, buf1, sizeof(buf1), 0);
1159 if (size < 0) {
1160 err = socket_error();
1161 if (err != EWOULDBLOCK)
1162 goto eoc;
1163 } else if (size == 0) {
1164 /* end of connection */
1165 eoc:
1166 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1167 closesocket(s->fd);
1168 return;
1170 buf = buf1;
1171 while (size > 0) {
1172 /* reassemble a packet from the network */
1173 switch(s->state) {
1174 case 0:
1175 l = 4 - s->index;
1176 if (l > size)
1177 l = size;
1178 memcpy(s->buf + s->index, buf, l);
1179 buf += l;
1180 size -= l;
1181 s->index += l;
1182 if (s->index == 4) {
1183 /* got length */
1184 s->packet_len = ntohl(*(uint32_t *)s->buf);
1185 s->index = 0;
1186 s->state = 1;
1188 break;
1189 case 1:
1190 l = s->packet_len - s->index;
1191 if (l > size)
1192 l = size;
1193 if (s->index + l <= sizeof(s->buf)) {
1194 memcpy(s->buf + s->index, buf, l);
1195 } else {
1196 fprintf(stderr, "serious error: oversized packet received,"
1197 "connection terminated.\n");
1198 s->state = 0;
1199 goto eoc;
1202 s->index += l;
1203 buf += l;
1204 size -= l;
1205 if (s->index >= s->packet_len) {
1206 qemu_send_packet(s->vc, s->buf, s->packet_len);
1207 s->index = 0;
1208 s->state = 0;
1210 break;
1215 static void net_socket_send_dgram(void *opaque)
1217 NetSocketState *s = opaque;
1218 int size;
1220 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
1221 if (size < 0)
1222 return;
1223 if (size == 0) {
1224 /* end of connection */
1225 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1226 return;
1228 qemu_send_packet(s->vc, s->buf, size);
1231 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
1233 struct ip_mreq imr;
1234 int fd;
1235 int val, ret;
1236 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
1237 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
1238 inet_ntoa(mcastaddr->sin_addr),
1239 (int)ntohl(mcastaddr->sin_addr.s_addr));
1240 return -1;
1243 fd = socket(PF_INET, SOCK_DGRAM, 0);
1244 if (fd < 0) {
1245 perror("socket(PF_INET, SOCK_DGRAM)");
1246 return -1;
1249 val = 1;
1250 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
1251 (const char *)&val, sizeof(val));
1252 if (ret < 0) {
1253 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
1254 goto fail;
1257 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
1258 if (ret < 0) {
1259 perror("bind");
1260 goto fail;
1263 /* Add host to multicast group */
1264 imr.imr_multiaddr = mcastaddr->sin_addr;
1265 imr.imr_interface.s_addr = htonl(INADDR_ANY);
1267 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
1268 (const char *)&imr, sizeof(struct ip_mreq));
1269 if (ret < 0) {
1270 perror("setsockopt(IP_ADD_MEMBERSHIP)");
1271 goto fail;
1274 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
1275 val = 1;
1276 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
1277 (const char *)&val, sizeof(val));
1278 if (ret < 0) {
1279 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
1280 goto fail;
1283 socket_set_nonblock(fd);
1284 return fd;
1285 fail:
1286 if (fd >= 0)
1287 closesocket(fd);
1288 return -1;
1291 static void net_socket_cleanup(VLANClientState *vc)
1293 NetSocketState *s = vc->opaque;
1294 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
1295 close(s->fd);
1296 qemu_free(s);
1299 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan,
1300 const char *model,
1301 const char *name,
1302 int fd, int is_connected)
1304 struct sockaddr_in saddr;
1305 int newfd;
1306 socklen_t saddr_len;
1307 NetSocketState *s;
1309 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
1310 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
1311 * by ONLY ONE process: we must "clone" this dgram socket --jjo
1314 if (is_connected) {
1315 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
1316 /* must be bound */
1317 if (saddr.sin_addr.s_addr==0) {
1318 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
1319 fd);
1320 return NULL;
1322 /* clone dgram socket */
1323 newfd = net_socket_mcast_create(&saddr);
1324 if (newfd < 0) {
1325 /* error already reported by net_socket_mcast_create() */
1326 close(fd);
1327 return NULL;
1329 /* clone newfd to fd, close newfd */
1330 dup2(newfd, fd);
1331 close(newfd);
1333 } else {
1334 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
1335 fd, strerror(errno));
1336 return NULL;
1340 s = qemu_mallocz(sizeof(NetSocketState));
1341 s->fd = fd;
1343 s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive_dgram,
1344 NULL, net_socket_cleanup, s);
1345 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
1347 /* mcast: save bound address as dst */
1348 if (is_connected) s->dgram_dst=saddr;
1350 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1351 "socket: fd=%d (%s mcast=%s:%d)",
1352 fd, is_connected? "cloned" : "",
1353 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1354 return s;
1357 static void net_socket_connect(void *opaque)
1359 NetSocketState *s = opaque;
1360 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
1363 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan,
1364 const char *model,
1365 const char *name,
1366 int fd, int is_connected)
1368 NetSocketState *s;
1369 s = qemu_mallocz(sizeof(NetSocketState));
1370 s->fd = fd;
1371 s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive,
1372 NULL, net_socket_cleanup, s);
1373 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1374 "socket: fd=%d", fd);
1375 if (is_connected) {
1376 net_socket_connect(s);
1377 } else {
1378 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
1380 return s;
1383 static NetSocketState *net_socket_fd_init(VLANState *vlan,
1384 const char *model, const char *name,
1385 int fd, int is_connected)
1387 int so_type=-1, optlen=sizeof(so_type);
1389 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
1390 (socklen_t *)&optlen)< 0) {
1391 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
1392 return NULL;
1394 switch(so_type) {
1395 case SOCK_DGRAM:
1396 return net_socket_fd_init_dgram(vlan, model, name, fd, is_connected);
1397 case SOCK_STREAM:
1398 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
1399 default:
1400 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
1401 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
1402 return net_socket_fd_init_stream(vlan, model, name, fd, is_connected);
1404 return NULL;
1407 static void net_socket_accept(void *opaque)
1409 NetSocketListenState *s = opaque;
1410 NetSocketState *s1;
1411 struct sockaddr_in saddr;
1412 socklen_t len;
1413 int fd;
1415 for(;;) {
1416 len = sizeof(saddr);
1417 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
1418 if (fd < 0 && errno != EINTR) {
1419 return;
1420 } else if (fd >= 0) {
1421 break;
1424 s1 = net_socket_fd_init(s->vlan, s->model, s->name, fd, 1);
1425 if (!s1) {
1426 closesocket(fd);
1427 } else {
1428 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
1429 "socket: connection from %s:%d",
1430 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1434 static int net_socket_listen_init(VLANState *vlan,
1435 const char *model,
1436 const char *name,
1437 const char *host_str)
1439 NetSocketListenState *s;
1440 int fd, val, ret;
1441 struct sockaddr_in saddr;
1443 if (parse_host_port(&saddr, host_str) < 0)
1444 return -1;
1446 s = qemu_mallocz(sizeof(NetSocketListenState));
1448 fd = socket(PF_INET, SOCK_STREAM, 0);
1449 if (fd < 0) {
1450 perror("socket");
1451 return -1;
1453 socket_set_nonblock(fd);
1455 /* allow fast reuse */
1456 val = 1;
1457 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
1459 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1460 if (ret < 0) {
1461 perror("bind");
1462 return -1;
1464 ret = listen(fd, 0);
1465 if (ret < 0) {
1466 perror("listen");
1467 return -1;
1469 s->vlan = vlan;
1470 s->model = strdup(model);
1471 s->name = strdup(name);
1472 s->fd = fd;
1473 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
1474 return 0;
1477 static int net_socket_connect_init(VLANState *vlan,
1478 const char *model,
1479 const char *name,
1480 const char *host_str)
1482 NetSocketState *s;
1483 int fd, connected, ret, err;
1484 struct sockaddr_in saddr;
1486 if (parse_host_port(&saddr, host_str) < 0)
1487 return -1;
1489 fd = socket(PF_INET, SOCK_STREAM, 0);
1490 if (fd < 0) {
1491 perror("socket");
1492 return -1;
1494 socket_set_nonblock(fd);
1496 connected = 0;
1497 for(;;) {
1498 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
1499 if (ret < 0) {
1500 err = socket_error();
1501 if (err == EINTR || err == EWOULDBLOCK) {
1502 } else if (err == EINPROGRESS) {
1503 break;
1504 #ifdef _WIN32
1505 } else if (err == WSAEALREADY) {
1506 break;
1507 #endif
1508 } else {
1509 perror("connect");
1510 closesocket(fd);
1511 return -1;
1513 } else {
1514 connected = 1;
1515 break;
1518 s = net_socket_fd_init(vlan, model, name, fd, connected);
1519 if (!s)
1520 return -1;
1521 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1522 "socket: connect to %s:%d",
1523 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1524 return 0;
1527 static int net_socket_mcast_init(VLANState *vlan,
1528 const char *model,
1529 const char *name,
1530 const char *host_str)
1532 NetSocketState *s;
1533 int fd;
1534 struct sockaddr_in saddr;
1536 if (parse_host_port(&saddr, host_str) < 0)
1537 return -1;
1540 fd = net_socket_mcast_create(&saddr);
1541 if (fd < 0)
1542 return -1;
1544 s = net_socket_fd_init(vlan, model, name, fd, 0);
1545 if (!s)
1546 return -1;
1548 s->dgram_dst = saddr;
1550 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
1551 "socket: mcast=%s:%d",
1552 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
1553 return 0;
1557 /* find or alloc a new VLAN */
1558 VLANState *qemu_find_vlan(int id)
1560 VLANState **pvlan, *vlan;
1561 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1562 if (vlan->id == id)
1563 return vlan;
1565 vlan = qemu_mallocz(sizeof(VLANState));
1566 vlan->id = id;
1567 vlan->next = NULL;
1568 pvlan = &first_vlan;
1569 while (*pvlan != NULL)
1570 pvlan = &(*pvlan)->next;
1571 *pvlan = vlan;
1572 return vlan;
1575 static int nic_get_free_idx(void)
1577 int index;
1579 for (index = 0; index < MAX_NICS; index++)
1580 if (!nd_table[index].used)
1581 return index;
1582 return -1;
1585 void qemu_check_nic_model(NICInfo *nd, const char *model)
1587 const char *models[2];
1589 models[0] = model;
1590 models[1] = NULL;
1592 qemu_check_nic_model_list(nd, models, model);
1595 void qemu_check_nic_model_list(NICInfo *nd, const char * const *models,
1596 const char *default_model)
1598 int i, exit_status = 0;
1600 if (!nd->model)
1601 nd->model = strdup(default_model);
1603 if (strcmp(nd->model, "?") != 0) {
1604 for (i = 0 ; models[i]; i++)
1605 if (strcmp(nd->model, models[i]) == 0)
1606 return;
1608 fprintf(stderr, "qemu: Unsupported NIC model: %s\n", nd->model);
1609 exit_status = 1;
1612 fprintf(stderr, "qemu: Supported NIC models: ");
1613 for (i = 0 ; models[i]; i++)
1614 fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
1616 exit(exit_status);
1619 int net_client_init(const char *device, const char *p)
1621 char buf[1024];
1622 int vlan_id, ret;
1623 VLANState *vlan;
1624 char *name = NULL;
1626 vlan_id = 0;
1627 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
1628 vlan_id = strtol(buf, NULL, 0);
1630 vlan = qemu_find_vlan(vlan_id);
1632 if (get_param_value(buf, sizeof(buf), "name", p)) {
1633 name = strdup(buf);
1635 if (!strcmp(device, "nic")) {
1636 NICInfo *nd;
1637 uint8_t *macaddr;
1638 int idx = nic_get_free_idx();
1640 if (idx == -1 || nb_nics >= MAX_NICS) {
1641 fprintf(stderr, "Too Many NICs\n");
1642 ret = -1;
1643 goto out;
1645 nd = &nd_table[idx];
1646 macaddr = nd->macaddr;
1647 macaddr[0] = 0x52;
1648 macaddr[1] = 0x54;
1649 macaddr[2] = 0x00;
1650 macaddr[3] = 0x12;
1651 macaddr[4] = 0x34;
1652 macaddr[5] = 0x56 + idx;
1654 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
1655 if (parse_macaddr(macaddr, buf) < 0) {
1656 fprintf(stderr, "invalid syntax for ethernet address\n");
1657 ret = -1;
1658 goto out;
1661 if (get_param_value(buf, sizeof(buf), "model", p)) {
1662 nd->model = strdup(buf);
1664 nd->vlan = vlan;
1665 nd->name = name;
1666 nd->used = 1;
1667 name = NULL;
1668 nb_nics++;
1669 vlan->nb_guest_devs++;
1670 ret = idx;
1671 } else
1672 if (!strcmp(device, "none")) {
1673 /* does nothing. It is needed to signal that no network cards
1674 are wanted */
1675 ret = 0;
1676 } else
1677 #ifdef CONFIG_SLIRP
1678 if (!strcmp(device, "user")) {
1679 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
1680 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
1682 if (get_param_value(buf, sizeof(buf), "restrict", p)) {
1683 slirp_restrict = (buf[0] == 'y') ? 1 : 0;
1685 if (get_param_value(buf, sizeof(buf), "ip", p)) {
1686 slirp_ip = strdup(buf);
1688 vlan->nb_host_devs++;
1689 ret = net_slirp_init(vlan, device, name);
1690 } else if (!strcmp(device, "channel")) {
1691 long port;
1692 char name[20], *devname;
1693 struct VMChannel *vmc;
1695 port = strtol(p, &devname, 10);
1696 devname++;
1697 if (port < 1 || port > 65535) {
1698 fprintf(stderr, "vmchannel wrong port number\n");
1699 ret = -1;
1700 goto out;
1702 vmc = malloc(sizeof(struct VMChannel));
1703 snprintf(name, 20, "vmchannel%ld", port);
1704 vmc->hd = qemu_chr_open(name, devname, NULL);
1705 if (!vmc->hd) {
1706 fprintf(stderr, "qemu: could not open vmchannel device"
1707 "'%s'\n", devname);
1708 ret = -1;
1709 goto out;
1711 vmc->port = port;
1712 slirp_add_exec(3, vmc->hd, 4, port);
1713 qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
1714 NULL, vmc);
1715 ret = 0;
1716 } else
1717 #endif
1718 #ifdef _WIN32
1719 if (!strcmp(device, "tap")) {
1720 char ifname[64];
1721 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1722 fprintf(stderr, "tap: no interface name\n");
1723 ret = -1;
1724 goto out;
1726 vlan->nb_host_devs++;
1727 ret = tap_win32_init(vlan, device, name, ifname);
1728 } else
1729 #elif defined (_AIX)
1730 #else
1731 if (!strcmp(device, "tap")) {
1732 char ifname[64];
1733 char setup_script[1024], down_script[1024];
1734 int fd;
1735 vlan->nb_host_devs++;
1736 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1737 fd = strtol(buf, NULL, 0);
1738 fcntl(fd, F_SETFL, O_NONBLOCK);
1739 net_tap_fd_init(vlan, device, name, fd);
1740 ret = 0;
1741 } else {
1742 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
1743 ifname[0] = '\0';
1745 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
1746 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
1748 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
1749 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
1751 ret = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
1753 } else
1754 #endif
1755 if (!strcmp(device, "socket")) {
1756 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
1757 int fd;
1758 fd = strtol(buf, NULL, 0);
1759 ret = -1;
1760 if (net_socket_fd_init(vlan, device, name, fd, 1))
1761 ret = 0;
1762 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
1763 ret = net_socket_listen_init(vlan, device, name, buf);
1764 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
1765 ret = net_socket_connect_init(vlan, device, name, buf);
1766 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
1767 ret = net_socket_mcast_init(vlan, device, name, buf);
1768 } else {
1769 fprintf(stderr, "Unknown socket options: %s\n", p);
1770 ret = -1;
1771 goto out;
1773 vlan->nb_host_devs++;
1774 } else
1775 #ifdef CONFIG_VDE
1776 if (!strcmp(device, "vde")) {
1777 char vde_sock[1024], vde_group[512];
1778 int vde_port, vde_mode;
1779 vlan->nb_host_devs++;
1780 if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) {
1781 vde_sock[0] = '\0';
1783 if (get_param_value(buf, sizeof(buf), "port", p) > 0) {
1784 vde_port = strtol(buf, NULL, 10);
1785 } else {
1786 vde_port = 0;
1788 if (get_param_value(vde_group, sizeof(vde_group), "group", p) <= 0) {
1789 vde_group[0] = '\0';
1791 if (get_param_value(buf, sizeof(buf), "mode", p) > 0) {
1792 vde_mode = strtol(buf, NULL, 8);
1793 } else {
1794 vde_mode = 0700;
1796 ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode);
1797 } else
1798 #endif
1800 fprintf(stderr, "Unknown network device: %s\n", device);
1801 ret = -1;
1802 goto out;
1804 if (ret < 0) {
1805 fprintf(stderr, "Could not initialize device '%s'\n", device);
1807 out:
1808 if (name)
1809 free(name);
1810 return ret;
1813 void net_client_uninit(NICInfo *nd)
1815 nd->vlan->nb_guest_devs--;
1816 nb_nics--;
1817 nd->used = 0;
1818 free((void *)nd->model);
1821 static int net_host_check_device(const char *device)
1823 int i;
1824 const char *valid_param_list[] = { "tap", "socket"
1825 #ifdef CONFIG_SLIRP
1826 ,"user"
1827 #endif
1828 #ifdef CONFIG_VDE
1829 ,"vde"
1830 #endif
1832 for (i = 0; i < sizeof(valid_param_list) / sizeof(char *); i++) {
1833 if (!strncmp(valid_param_list[i], device,
1834 strlen(valid_param_list[i])))
1835 return 1;
1838 return 0;
1841 void net_host_device_add(const char *device, const char *opts)
1843 if (!net_host_check_device(device)) {
1844 term_printf("invalid host network device %s\n", device);
1845 return;
1847 net_client_init(device, opts);
1850 void net_host_device_remove(int vlan_id, const char *device)
1852 VLANState *vlan;
1853 VLANClientState *vc;
1855 vlan = qemu_find_vlan(vlan_id);
1857 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
1858 if (!strcmp(vc->name, device))
1859 break;
1861 if (!vc) {
1862 term_printf("can't find device %s\n", device);
1863 return;
1865 qemu_del_vlan_client(vc);
1868 int net_client_parse(const char *str)
1870 const char *p;
1871 char *q;
1872 char device[64];
1874 p = str;
1875 q = device;
1876 while (*p != '\0' && *p != ',') {
1877 if ((q - device) < sizeof(device) - 1)
1878 *q++ = *p;
1879 p++;
1881 *q = '\0';
1882 if (*p == ',')
1883 p++;
1885 return net_client_init(device, p);
1888 void do_info_network(void)
1890 VLANState *vlan;
1891 VLANClientState *vc;
1893 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1894 term_printf("VLAN %d devices:\n", vlan->id);
1895 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
1896 term_printf(" %s: %s\n", vc->name, vc->info_str);
1900 int do_set_link(const char *name, const char *up_or_down)
1902 VLANState *vlan;
1903 VLANClientState *vc = NULL;
1905 for (vlan = first_vlan; vlan != NULL; vlan = vlan->next)
1906 for (vc = vlan->first_client; vc != NULL; vc = vc->next)
1907 if (strcmp(vc->name, name) == 0)
1908 goto done;
1909 done:
1911 if (!vc) {
1912 term_printf("could not find network device '%s'", name);
1913 return 0;
1916 if (strcmp(up_or_down, "up") == 0)
1917 vc->link_down = 0;
1918 else if (strcmp(up_or_down, "down") == 0)
1919 vc->link_down = 1;
1920 else
1921 term_printf("invalid link status '%s'; only 'up' or 'down' valid\n",
1922 up_or_down);
1924 if (vc->link_status_changed)
1925 vc->link_status_changed(vc);
1927 return 1;
1930 void net_cleanup(void)
1932 VLANState *vlan;
1934 /* close network clients */
1935 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1936 VLANClientState *vc = vlan->first_client;
1938 while (vc) {
1939 VLANClientState *next = vc->next;
1941 qemu_del_vlan_client(vc);
1943 vc = next;
1948 void net_client_check(void)
1950 VLANState *vlan;
1952 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1953 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
1954 continue;
1955 if (vlan->nb_guest_devs == 0)
1956 fprintf(stderr, "Warning: vlan %d with no nics\n", vlan->id);
1957 if (vlan->nb_host_devs == 0)
1958 fprintf(stderr,
1959 "Warning: vlan %d is not connected to host network\n",
1960 vlan->id);