X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=net.c;h=31ee95a4ff3daea30adb99a55ae8b80c0d7ef702;hb=7696d1ecd0fe4805b630161d276a169c01f80e91;hp=29beb286d6e7042619c3be9f15d48a68c823d8dc;hpb=8ca9217d04c070572a747e87288a0d36e44d5424;p=qemu diff --git a/net.c b/net.c index 29beb28..31ee95a 100644 --- a/net.c +++ b/net.c @@ -21,14 +21,6 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ -#include "qemu-common.h" -#include "net.h" -#include "console.h" -#include "sysemu.h" -#include "qemu-timer.h" -#include "qemu-char.h" -#include "audio/audio.h" - #include #include #include @@ -37,6 +29,9 @@ #include #include +/* Needed early for HOST_BSD etc. */ +#include "config-host.h" + #ifndef _WIN32 #include #include @@ -57,9 +52,9 @@ #include #include #include -#ifdef _BSD +#ifdef HOST_BSD #include -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) || defined(__DragonFly__) #include #else #include @@ -98,12 +93,6 @@ #endif #endif -#include "qemu_socket.h" - -#if defined(CONFIG_SLIRP) -#include "libslirp.h" -#endif - #if defined(__OpenBSD__) #include #endif @@ -113,6 +102,7 @@ #endif #ifdef _WIN32 +#include #include #include #include @@ -120,6 +110,21 @@ #define memalign(align, size) malloc(size) #endif +#include "qemu-common.h" +#include "net.h" +#include "monitor.h" +#include "sysemu.h" +#include "qemu-timer.h" +#include "qemu-char.h" +#include "audio/audio.h" +#include "qemu_socket.h" +#include "qemu-log.h" + +#if defined(CONFIG_SLIRP) +#include "libslirp.h" +#endif + + static VLANState *first_vlan; /***********************************************************/ @@ -329,6 +334,7 @@ VLANClientState *qemu_new_vlan_client(VLANState *vlan, const char *name, IOReadHandler *fd_read, IOCanRWHandler *fd_can_read, + NetCleanup *cleanup, void *opaque) { VLANClientState *vc, **pvc; @@ -340,6 +346,7 @@ VLANClientState *qemu_new_vlan_client(VLANState *vlan, vc->name = assign_name(vc, model); vc->fd_read = fd_read; vc->fd_can_read = fd_can_read; + vc->cleanup = cleanup; vc->opaque = opaque; vc->vlan = vlan; @@ -358,9 +365,12 @@ void qemu_del_vlan_client(VLANClientState *vc) while (*pvc != NULL) if (*pvc == vc) { *pvc = vc->next; + if (vc->cleanup) { + vc->cleanup(vc); + } free(vc->name); free(vc->model); - free(vc); + qemu_free(vc); break; } else pvc = &(*pvc)->next; @@ -393,22 +403,46 @@ int qemu_can_send_packet(VLANClientState *vc1) return 0; } -void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size) +static void +qemu_deliver_packet(VLANClientState *sender, const uint8_t *buf, int size) { - VLANState *vlan = vc1->vlan; VLANClientState *vc; - if (vc1->link_down) + for (vc = sender->vlan->first_client; vc != NULL; vc = vc->next) { + if (vc != sender && !vc->link_down) { + vc->fd_read(vc->opaque, buf, size); + } + } +} + +void qemu_send_packet(VLANClientState *vc, const uint8_t *buf, int size) +{ + VLANState *vlan = vc->vlan; + VLANPacket *packet; + + if (vc->link_down) return; #ifdef DEBUG_NET printf("vlan %d send:\n", vlan->id); hex_dump(stdout, buf, size); #endif - for(vc = vlan->first_client; vc != NULL; vc = vc->next) { - if (vc != vc1 && !vc->link_down) { - vc->fd_read(vc->opaque, buf, size); + if (vlan->delivering) { + packet = qemu_malloc(sizeof(VLANPacket) + size); + packet->next = vlan->send_queue; + packet->sender = vc; + packet->size = size; + memcpy(packet->data, buf, size); + vlan->send_queue = packet; + } else { + vlan->delivering = 1; + qemu_deliver_packet(vc, buf, size); + while ((packet = vlan->send_queue) != NULL) { + qemu_deliver_packet(packet->sender, packet->data, packet->size); + vlan->send_queue = packet->next; + qemu_free(packet); } + vlan->delivering = 0; } } @@ -510,23 +544,35 @@ static void slirp_receive(void *opaque, const uint8_t *buf, int size) slirp_input(buf, size); } +static int slirp_in_use; + +static void net_slirp_cleanup(VLANClientState *vc) +{ + slirp_in_use = 0; +} + static int net_slirp_init(VLANState *vlan, const char *model, const char *name) { + if (slirp_in_use) { + /* slirp only supports a single instance so far */ + return -1; + } if (!slirp_inited) { slirp_inited = 1; slirp_init(slirp_restrict, slirp_ip); } slirp_vc = qemu_new_vlan_client(vlan, model, name, - slirp_receive, NULL, NULL); + slirp_receive, NULL, net_slirp_cleanup, NULL); slirp_vc->info_str[0] = '\0'; + slirp_in_use = 1; return 0; } -void net_slirp_redir(const char *redir_str) +void net_slirp_redir(Monitor *mon, const char *redir_str) { int is_udp; char buf[256], *r; - const char *p; + const char *p, *errmsg; struct in_addr guest_addr; int host_port, guest_port; @@ -537,41 +583,48 @@ void net_slirp_redir(const char *redir_str) p = redir_str; if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) - goto fail; - if (!strcmp(buf, "tcp")) { + goto fail_syntax; + if (!strcmp(buf, "tcp") || buf[0] == '\0') { is_udp = 0; } else if (!strcmp(buf, "udp")) { is_udp = 1; } else { - goto fail; + goto fail_syntax; } if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) - goto fail; + goto fail_syntax; host_port = strtol(buf, &r, 0); if (r == buf) - goto fail; + goto fail_syntax; if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) - goto fail; + goto fail_syntax; if (buf[0] == '\0') { pstrcpy(buf, sizeof(buf), "10.0.2.15"); } if (!inet_aton(buf, &guest_addr)) - goto fail; + goto fail_syntax; guest_port = strtol(p, &r, 0); if (r == p) - goto fail; + goto fail_syntax; if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) { - fprintf(stderr, "qemu: could not set up redirection\n"); - exit(1); + errmsg = "could not set up redirection\n"; + goto fail; } return; + + fail_syntax: + errmsg = "invalid redirection format\n"; fail: - fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n"); - exit(1); + if (mon) { + monitor_printf(mon, "%s", errmsg); + } else { + fprintf(stderr, "qemu: %s", errmsg); + exit(1); + } } #ifndef _WIN32 @@ -585,7 +638,7 @@ static void erase_dir(char *dir_name) char filename[1024]; /* erase all the files in the directory */ - if ((d = opendir(dir_name)) != 0) { + if ((d = opendir(dir_name)) != NULL) { for(;;) { de = readdir(d); if (!de) @@ -622,7 +675,7 @@ void net_slirp_smb(const char *exported_dir) } /* XXX: better tmp dir construction */ - snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid()); + snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%ld", (long)getpid()); if (mkdir(smb_dir, 0700) < 0) { fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir); exit(1); @@ -665,7 +718,7 @@ void net_slirp_smb(const char *exported_dir) } #endif /* !defined(_WIN32) */ -void do_info_slirp(void) +void do_info_slirp(Monitor *mon) { slirp_stats(); } @@ -673,7 +726,7 @@ void do_info_slirp(void) struct VMChannel { CharDriverState *hd; int port; -} *vmchannels; +}; static int vmchannel_can_read(void *opaque) { @@ -698,7 +751,8 @@ typedef struct TAPState { char down_script_arg[128]; } TAPState; -#ifdef HAVE_IOVEC +static int launch_script(const char *setup_script, const char *ifname, int fd); + static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov, int iovcnt) { @@ -711,7 +765,6 @@ static ssize_t tap_receive_iov(void *opaque, const struct iovec *iov, return len; } -#endif static void tap_receive(void *opaque, const uint8_t *buf, int size) { @@ -736,7 +789,7 @@ static void tap_send(void *opaque) struct strbuf sbuf; int f = 0; sbuf.maxlen = sizeof(buf); - sbuf.buf = buf; + sbuf.buf = (char *)buf; size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1; #else size = read(s->fd, buf, sizeof(buf)); @@ -746,6 +799,18 @@ static void tap_send(void *opaque) } } +static void tap_cleanup(VLANClientState *vc) +{ + TAPState *s = vc->opaque; + + if (s->down_script[0]) + launch_script(s->down_script, s->down_script_arg, s->fd); + + qemu_set_fd_handler(s->fd, NULL, NULL, NULL); + close(s->fd); + qemu_free(s); +} + /* fd support */ static TAPState *net_tap_fd_init(VLANState *vlan, @@ -757,16 +822,15 @@ static TAPState *net_tap_fd_init(VLANState *vlan, s = qemu_mallocz(sizeof(TAPState)); s->fd = fd; - s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive, NULL, s); -#ifdef HAVE_IOVEC + s->vc = qemu_new_vlan_client(vlan, model, name, tap_receive, + NULL, tap_cleanup, s); s->vc->fd_readv = tap_receive_iov; -#endif qemu_set_fd_handler(s->fd, tap_send, NULL, s); snprintf(s->vc->info_str, sizeof(s->vc->info_str), "fd=%d", fd); return s; } -#if defined (_BSD) || defined (__FreeBSD_kernel__) +#if defined (HOST_BSD) || defined (__FreeBSD_kernel__) static int tap_open(char *ifname, int ifname_size) { int fd; @@ -792,7 +856,7 @@ static int tap_open(char *ifname, int ifname_size) * Allocate TAP device, returns opened fd. * Stores dev name in the first arg(must be large enough). */ -int tap_alloc(char *dev, size_t dev_size) +static int tap_alloc(char *dev, size_t dev_size) { int tap_fd, if_fd, ppa = -1; static int ip_fd = 0; @@ -1015,8 +1079,6 @@ static int net_tap_init(VLANState *vlan, const char *model, return -1; } s = net_tap_fd_init(vlan, model, name, fd); - if (!s) - return -1; snprintf(s->vc->info_str, sizeof(s->vc->info_str), "ifname=%s,script=%s,downscript=%s", ifname, setup_script, down_script); @@ -1041,7 +1103,7 @@ static void vde_to_qemu(void *opaque) uint8_t buf[4096]; int size; - size = vde_recv(s->vde, buf, sizeof(buf), 0); + size = vde_recv(s->vde, (char *)buf, sizeof(buf), 0); if (size > 0) { qemu_send_packet(s->vc, buf, size); } @@ -1052,7 +1114,7 @@ static void vde_from_qemu(void *opaque, const uint8_t *buf, int size) VDEState *s = opaque; int ret; for(;;) { - ret = vde_send(s->vde, buf, size, 0); + ret = vde_send(s->vde, (const char *)buf, size, 0); if (ret < 0 && errno == EINTR) { } else { break; @@ -1060,6 +1122,14 @@ static void vde_from_qemu(void *opaque, const uint8_t *buf, int size) } } +static void vde_cleanup(VLANClientState *vc) +{ + VDEState *s = vc->opaque; + qemu_set_fd_handler(vde_datafd(s->vde), NULL, NULL, NULL); + vde_close(s->vde); + qemu_free(s); +} + static int net_vde_init(VLANState *vlan, const char *model, const char *name, const char *sock, int port, const char *group, int mode) @@ -1075,12 +1145,13 @@ static int net_vde_init(VLANState *vlan, const char *model, }; s = qemu_mallocz(sizeof(VDEState)); - s->vde = vde_open(init_sock, "QEMU", &args); + s->vde = vde_open(init_sock, (char *)"QEMU", &args); if (!s->vde){ free(s); return -1; } - s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_qemu, NULL, s); + s->vc = qemu_new_vlan_client(vlan, model, name, vde_from_qemu, + NULL, vde_cleanup, s); qemu_set_fd_handler(vde_datafd(s->vde), vde_to_qemu, NULL, s); snprintf(s->vc->info_str, sizeof(s->vc->info_str), "sock=%s,fd=%d", sock, vde_datafd(s->vde)); @@ -1093,8 +1164,8 @@ typedef struct NetSocketState { VLANClientState *vc; int fd; int state; /* 0 = getting length, 1 = getting data */ - int index; - int packet_len; + unsigned int index; + unsigned int packet_len; uint8_t buf[4096]; struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */ } NetSocketState; @@ -1127,7 +1198,8 @@ static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size) static void net_socket_send(void *opaque) { NetSocketState *s = opaque; - int l, size, err; + int size, err; + unsigned l; uint8_t buf1[4096]; const uint8_t *buf; @@ -1166,7 +1238,15 @@ static void net_socket_send(void *opaque) l = s->packet_len - s->index; if (l > size) l = size; - memcpy(s->buf + s->index, buf, l); + if (s->index + l <= sizeof(s->buf)) { + memcpy(s->buf + s->index, buf, l); + } else { + fprintf(stderr, "serious error: oversized packet received," + "connection terminated.\n"); + s->state = 0; + goto eoc; + } + s->index += l; buf += l; size -= l; @@ -1256,6 +1336,14 @@ fail: return -1; } +static void net_socket_cleanup(VLANClientState *vc) +{ + NetSocketState *s = vc->opaque; + qemu_set_fd_handler(s->fd, NULL, NULL, NULL); + close(s->fd); + qemu_free(s); +} + static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, const char *model, const char *name, @@ -1300,7 +1388,8 @@ static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, s = qemu_mallocz(sizeof(NetSocketState)); s->fd = fd; - s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive_dgram, NULL, s); + s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive_dgram, + NULL, net_socket_cleanup, s); qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s); /* mcast: save bound address as dst */ @@ -1327,8 +1416,8 @@ static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, NetSocketState *s; s = qemu_mallocz(sizeof(NetSocketState)); s->fd = fd; - s->vc = qemu_new_vlan_client(vlan, model, name, - net_socket_receive, NULL, s); + s->vc = qemu_new_vlan_client(vlan, model, name, net_socket_receive, + NULL, net_socket_cleanup, s); snprintf(s->vc->info_str, sizeof(s->vc->info_str), "socket: fd=%d", fd); if (is_connected) { @@ -1427,7 +1516,7 @@ static int net_socket_listen_init(VLANState *vlan, } s->vlan = vlan; s->model = strdup(model); - s->name = strdup(name); + s->name = name ? strdup(name) : NULL; s->fd = fd; qemu_set_fd_handler(fd, net_socket_accept, NULL, s); return 0; @@ -1513,6 +1602,106 @@ static int net_socket_mcast_init(VLANState *vlan, } +typedef struct DumpState { + VLANClientState *pcap_vc; + int fd; + int pcap_caplen; +} DumpState; + +#define PCAP_MAGIC 0xa1b2c3d4 + +struct pcap_file_hdr { + uint32_t magic; + uint16_t version_major; + uint16_t version_minor; + int32_t thiszone; + uint32_t sigfigs; + uint32_t snaplen; + uint32_t linktype; +}; + +struct pcap_sf_pkthdr { + struct { + int32_t tv_sec; + int32_t tv_usec; + } ts; + uint32_t caplen; + uint32_t len; +}; + +static void dump_receive(void *opaque, const uint8_t *buf, int size) +{ + DumpState *s = opaque; + struct pcap_sf_pkthdr hdr; + int64_t ts; + int caplen; + + /* Early return in case of previous error. */ + if (s->fd < 0) { + return; + } + + ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec); + caplen = size > s->pcap_caplen ? s->pcap_caplen : size; + + hdr.ts.tv_sec = ts / 1000000; + hdr.ts.tv_usec = ts % 1000000; + hdr.caplen = caplen; + hdr.len = size; + if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) || + write(s->fd, buf, caplen) != caplen) { + qemu_log("-net dump write error - stop dump\n"); + close(s->fd); + s->fd = -1; + } +} + +static void net_dump_cleanup(VLANClientState *vc) +{ + DumpState *s = vc->opaque; + + close(s->fd); + qemu_free(s); +} + +static int net_dump_init(VLANState *vlan, const char *device, + const char *name, const char *filename, int len) +{ + struct pcap_file_hdr hdr; + DumpState *s; + + s = qemu_malloc(sizeof(DumpState)); + + s->fd = open(filename, O_CREAT | O_WRONLY, 0644); + if (s->fd < 0) { + fprintf(stderr, "-net dump: can't open %s\n", filename); + return -1; + } + + s->pcap_caplen = len; + + hdr.magic = PCAP_MAGIC; + hdr.version_major = 2; + hdr.version_minor = 4; + hdr.thiszone = 0; + hdr.sigfigs = 0; + hdr.snaplen = s->pcap_caplen; + hdr.linktype = 1; + + if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) { + perror("-net dump write error"); + close(s->fd); + qemu_free(s); + return -1; + } + + s->pcap_vc = qemu_new_vlan_client(vlan, device, name, dump_receive, NULL, + net_dump_cleanup, s); + snprintf(s->pcap_vc->info_str, sizeof(s->pcap_vc->info_str), + "dump to %s (len=%d)", filename, len); + return 0; +} + /* find or alloc a new VLAN */ VLANState *qemu_find_vlan(int id) { @@ -1577,6 +1766,9 @@ void qemu_check_nic_model_list(NICInfo *nd, const char * const *models, int net_client_init(const char *device, const char *p) { + static const char * const fd_params[] = { + "vlan", "name", "fd", NULL + }; char buf[1024]; int vlan_id, ret; VLANState *vlan; @@ -1587,21 +1779,27 @@ int net_client_init(const char *device, const char *p) vlan_id = strtol(buf, NULL, 0); } vlan = qemu_find_vlan(vlan_id); - if (!vlan) { - fprintf(stderr, "Could not create vlan %d\n", vlan_id); - return -1; - } + if (get_param_value(buf, sizeof(buf), "name", p)) { name = strdup(buf); } if (!strcmp(device, "nic")) { + static const char * const nic_params[] = { + "vlan", "name", "macaddr", "model", NULL + }; NICInfo *nd; uint8_t *macaddr; int idx = nic_get_free_idx(); + if (check_params(nic_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } if (idx == -1 || nb_nics >= MAX_NICS) { fprintf(stderr, "Too Many NICs\n"); - return -1; + ret = -1; + goto out; } nd = &nd_table[idx]; macaddr = nd->macaddr; @@ -1615,7 +1813,8 @@ int net_client_init(const char *device, const char *p) if (get_param_value(buf, sizeof(buf), "macaddr", p)) { if (parse_macaddr(macaddr, buf) < 0) { fprintf(stderr, "invalid syntax for ethernet address\n"); - return -1; + ret = -1; + goto out; } } if (get_param_value(buf, sizeof(buf), "model", p)) { @@ -1630,12 +1829,24 @@ int net_client_init(const char *device, const char *p) ret = idx; } else if (!strcmp(device, "none")) { + if (*p != '\0') { + fprintf(stderr, "qemu: 'none' takes no parameters\n"); + return -1; + } /* does nothing. It is needed to signal that no network cards are wanted */ ret = 0; } else #ifdef CONFIG_SLIRP if (!strcmp(device, "user")) { + static const char * const slirp_params[] = { + "vlan", "name", "hostname", "restrict", "ip", NULL + }; + if (check_params(slirp_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } if (get_param_value(buf, sizeof(buf), "hostname", p)) { pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf); } @@ -1655,8 +1866,9 @@ int net_client_init(const char *device, const char *p) port = strtol(p, &devname, 10); devname++; if (port < 1 || port > 65535) { - fprintf(stderr, "vmchannel wrong port number\n"); - return -1; + fprintf(stderr, "vmchannel wrong port number\n"); + ret = -1; + goto out; } vmc = malloc(sizeof(struct VMChannel)); snprintf(name, 20, "vmchannel%ld", port); @@ -1664,7 +1876,8 @@ int net_client_init(const char *device, const char *p) if (!vmc->hd) { fprintf(stderr, "qemu: could not open vmchannel device" "'%s'\n", devname); - return -1; + ret = -1; + goto out; } vmc->port = port; slirp_add_exec(3, vmc->hd, 4, port); @@ -1675,10 +1888,20 @@ int net_client_init(const char *device, const char *p) #endif #ifdef _WIN32 if (!strcmp(device, "tap")) { + static const char * const tap_params[] = { + "vlan", "name", "ifname", NULL + }; char ifname[64]; + + if (check_params(tap_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) { fprintf(stderr, "tap: no interface name\n"); - return -1; + ret = -1; + goto out; } vlan->nb_host_devs++; ret = tap_win32_init(vlan, device, name, ifname); @@ -1691,12 +1914,24 @@ int net_client_init(const char *device, const char *p) int fd; vlan->nb_host_devs++; if (get_param_value(buf, sizeof(buf), "fd", p) > 0) { + if (check_params(fd_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } fd = strtol(buf, NULL, 0); fcntl(fd, F_SETFL, O_NONBLOCK); - ret = -1; - if (net_tap_fd_init(vlan, device, name, fd)) - ret = 0; + net_tap_fd_init(vlan, device, name, fd); + ret = 0; } else { + static const char * const tap_params[] = { + "vlan", "name", "ifname", "script", "downscript", NULL + }; + if (check_params(tap_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) { ifname[0] = '\0'; } @@ -1713,26 +1948,65 @@ int net_client_init(const char *device, const char *p) if (!strcmp(device, "socket")) { if (get_param_value(buf, sizeof(buf), "fd", p) > 0) { int fd; + if (check_params(fd_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } fd = strtol(buf, NULL, 0); ret = -1; if (net_socket_fd_init(vlan, device, name, fd, 1)) ret = 0; } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) { + static const char * const listen_params[] = { + "vlan", "name", "listen", NULL + }; + if (check_params(listen_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } ret = net_socket_listen_init(vlan, device, name, buf); } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) { + static const char * const connect_params[] = { + "vlan", "name", "connect", NULL + }; + if (check_params(connect_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } ret = net_socket_connect_init(vlan, device, name, buf); } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) { + static const char * const mcast_params[] = { + "vlan", "name", "mcast", NULL + }; + if (check_params(mcast_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } ret = net_socket_mcast_init(vlan, device, name, buf); } else { fprintf(stderr, "Unknown socket options: %s\n", p); - return -1; + ret = -1; + goto out; } vlan->nb_host_devs++; } else #ifdef CONFIG_VDE if (!strcmp(device, "vde")) { + static const char * const vde_params[] = { + "vlan", "name", "sock", "port", "group", "mode", NULL + }; char vde_sock[1024], vde_group[512]; int vde_port, vde_mode; + + if (check_params(vde_params, p) < 0) { + fprintf(stderr, "qemu: invalid parameter '%s' in '%s'\n", + buf, p); + return -1; + } vlan->nb_host_devs++; if (get_param_value(vde_sock, sizeof(vde_sock), "sock", p) <= 0) { vde_sock[0] = '\0'; @@ -1753,15 +2027,25 @@ int net_client_init(const char *device, const char *p) ret = net_vde_init(vlan, device, name, vde_sock, vde_port, vde_group, vde_mode); } else #endif - { + if (!strcmp(device, "dump")) { + int len = 65536; + + if (get_param_value(buf, sizeof(buf), "len", p) > 0) { + len = strtol(buf, NULL, 0); + } + if (!get_param_value(buf, sizeof(buf), "file", p)) { + snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id); + } + ret = net_dump_init(vlan, device, name, buf, len); + } else { fprintf(stderr, "Unknown network device: %s\n", device); - if (name) - free(name); - return -1; + ret = -1; + goto out; } if (ret < 0) { fprintf(stderr, "Could not initialize device '%s'\n", device); } +out: if (name) free(name); return ret; @@ -1778,7 +2062,7 @@ void net_client_uninit(NICInfo *nd) static int net_host_check_device(const char *device) { int i; - const char *valid_param_list[] = { "tap", "socket" + const char *valid_param_list[] = { "tap", "socket", "dump" #ifdef CONFIG_SLIRP ,"user" #endif @@ -1795,37 +2079,36 @@ static int net_host_check_device(const char *device) return 0; } -void net_host_device_add(const char *device, const char *opts) +void net_host_device_add(Monitor *mon, const char *device, const char *opts) { if (!net_host_check_device(device)) { - term_printf("invalid host network device %s\n", device); + monitor_printf(mon, "invalid host network device %s\n", device); return; } - net_client_init(device, opts); + if (net_client_init(device, opts ? opts : "") < 0) { + monitor_printf(mon, "adding host network device %s failed\n", device); + } } -void net_host_device_remove(int vlan_id, const char *device) +void net_host_device_remove(Monitor *mon, int vlan_id, const char *device) { VLANState *vlan; VLANClientState *vc; - if (!net_host_check_device(device)) { - term_printf("invalid host network device %s\n", device); - return; - } - vlan = qemu_find_vlan(vlan_id); - if (!vlan) { - term_printf("can't find vlan %d\n", vlan_id); - return; - } - for(vc = vlan->first_client; vc != NULL; vc = vc->next) - if (!strcmp(vc->name, device)) + for (vc = vlan->first_client; vc != NULL; vc = vc->next) { + if (!strcmp(vc->name, device)) { break; + } + } if (!vc) { - term_printf("can't find device %s\n", device); + monitor_printf(mon, "can't find device %s\n", device); + return; + } + if (!net_host_check_device(vc->model)) { + monitor_printf(mon, "invalid host network device %s\n", device); return; } qemu_del_vlan_client(vc); @@ -1851,19 +2134,19 @@ int net_client_parse(const char *str) return net_client_init(device, p); } -void do_info_network(void) +void do_info_network(Monitor *mon) { VLANState *vlan; VLANClientState *vc; for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { - term_printf("VLAN %d devices:\n", vlan->id); + monitor_printf(mon, "VLAN %d devices:\n", vlan->id); for(vc = vlan->first_client; vc != NULL; vc = vc->next) - term_printf(" %s: %s\n", vc->name, vc->info_str); + monitor_printf(mon, " %s: %s\n", vc->name, vc->info_str); } } -int do_set_link(const char *name, const char *up_or_down) +int do_set_link(Monitor *mon, const char *name, const char *up_or_down) { VLANState *vlan; VLANClientState *vc = NULL; @@ -1875,7 +2158,7 @@ int do_set_link(const char *name, const char *up_or_down) done: if (!vc) { - term_printf("could not find network device '%s'", name); + monitor_printf(mon, "could not find network device '%s'", name); return 0; } @@ -1884,8 +2167,8 @@ done: else if (strcmp(up_or_down, "down") == 0) vc->link_down = 1; else - term_printf("invalid link status '%s'; only 'up' or 'down' valid\n", - up_or_down); + monitor_printf(mon, "invalid link status '%s'; only 'up' or 'down' " + "valid\n", up_or_down); if (vc->link_status_changed) vc->link_status_changed(vc); @@ -1897,27 +2180,18 @@ void net_cleanup(void) { VLANState *vlan; -#if !defined(_WIN32) /* close network clients */ for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) { - VLANClientState *vc; + VLANClientState *vc = vlan->first_client; - for(vc = vlan->first_client; vc != NULL; vc = vc->next) { - if (vc->fd_read == tap_receive) { - TAPState *s = vc->opaque; + while (vc) { + VLANClientState *next = vc->next; - if (s->down_script[0]) - launch_script(s->down_script, s->down_script_arg, s->fd); - } -#if defined(CONFIG_VDE) - if (vc->fd_read == vde_from_qemu) { - VDEState *s = vc->opaque; - vde_close(s->vde); - } -#endif + qemu_del_vlan_client(vc); + + vc = next; } } -#endif } void net_client_check(void)