#include <sys/time.h>
#include <zlib.h>
-/* Needed early for HOST_BSD etc. */
+/* Needed early for CONFIG_BSD etc. */
#include "config-host.h"
#ifndef _WIN32
#include <dirent.h>
#include <netdb.h>
#include <sys/select.h>
-#ifdef HOST_BSD
+#ifdef CONFIG_BSD
#include <sys/stat.h>
#if defined(__FreeBSD__) || defined(__DragonFly__)
#include <libutil.h>
#include <libvdeplug.h>
#endif
-#ifdef _WIN32
-#include <windows.h>
-#include <malloc.h>
-#include <sys/timeb.h>
-#include <mmsystem.h>
-#define getopt_long_only getopt_long
-#define memalign(align, size) malloc(size)
-#endif
-
#include "qemu-common.h"
#include "net.h"
#include "monitor.h"
#include "audio/audio.h"
#include "qemu_socket.h"
#include "qemu-log.h"
+#include "qemu-config.h"
#include "slirp/libslirp.h"
+#include "qemu-queue.h"
static VLANState *first_vlan;
return 0;
}
-#if !defined(_WIN32) && 0
-static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
-{
- const char *p;
- int len;
-
- len = MIN(108, strlen(str));
- p = strchr(str, ',');
- if (p)
- len = MIN(len, p - str);
-
- memset(uaddr, 0, sizeof(*uaddr));
-
- uaddr->sun_family = AF_UNIX;
- memcpy(uaddr->sun_path, str, len);
-
- return 0;
-}
-#endif
-
void qemu_format_nic_info_str(VLANClientState *vc, uint8_t macaddr[6])
{
snprintf(vc->info_str, sizeof(vc->info_str),
snprintf(buf, sizeof(buf), "%s.%d", model, id);
- return strdup(buf);
+ return qemu_strdup(buf);
}
VLANClientState *qemu_new_vlan_client(VLANState *vlan,
{
VLANClientState *vc, **pvc;
vc = qemu_mallocz(sizeof(VLANClientState));
- vc->model = strdup(model);
+ vc->model = qemu_strdup(model);
if (name)
- vc->name = strdup(name);
+ vc->name = qemu_strdup(name);
else
vc->name = assign_name(vc, model);
vc->can_receive = can_receive;
if (vc->cleanup) {
vc->cleanup(vc);
}
- free(vc->name);
- free(vc->model);
+ qemu_free(vc->name);
+ qemu_free(vc->model);
qemu_free(vc);
break;
} else
return NULL;
}
+static VLANClientState *
+qemu_find_vlan_client_by_name(Monitor *mon, int vlan_id,
+ const char *client_str)
+{
+ VLANState *vlan;
+ VLANClientState *vc;
+
+ vlan = qemu_find_vlan(vlan_id, 0);
+ if (!vlan) {
+ monitor_printf(mon, "unknown VLAN %d\n", vlan_id);
+ return NULL;
+ }
+
+ for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
+ if (!strcmp(vc->name, client_str)) {
+ break;
+ }
+ }
+ if (!vc) {
+ monitor_printf(mon, "can't find device %s on VLAN %d\n",
+ client_str, vlan_id);
+ }
+
+ return vc;
+}
+
int qemu_can_send_packet(VLANClientState *sender)
{
VLANState *vlan = sender->vlan;
void qemu_purge_queued_packets(VLANClientState *vc)
{
- VLANPacket **pp = &vc->vlan->send_queue;
-
- while (*pp != NULL) {
- VLANPacket *packet = *pp;
+ VLANPacket *packet, *next;
+ QTAILQ_FOREACH_SAFE(packet, &vc->vlan->send_queue, entry, next) {
if (packet->sender == vc) {
- *pp = packet->next;
+ QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
qemu_free(packet);
- } else {
- pp = &packet->next;
}
}
}
void qemu_flush_queued_packets(VLANClientState *vc)
{
- VLANPacket *packet;
-
- while ((packet = vc->vlan->send_queue) != NULL) {
+ while (!QTAILQ_EMPTY(&vc->vlan->send_queue)) {
+ VLANPacket *packet;
int ret;
- vc->vlan->send_queue = packet->next;
+ packet = QTAILQ_FIRST(&vc->vlan->send_queue);
+ QTAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
ret = qemu_deliver_packet(packet->sender, packet->data, packet->size);
if (ret == 0 && packet->sent_cb != NULL) {
- packet->next = vc->vlan->send_queue;
- vc->vlan->send_queue = packet;
+ QTAILQ_INSERT_HEAD(&vc->vlan->send_queue, packet, entry);
break;
}
VLANPacket *packet;
packet = qemu_malloc(sizeof(VLANPacket) + size);
- packet->next = sender->vlan->send_queue;
packet->sender = sender;
packet->size = size;
packet->sent_cb = sent_cb;
memcpy(packet->data, buf, size);
- sender->vlan->send_queue = packet;
+
+ QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
}
ssize_t qemu_send_packet_async(VLANClientState *sender,
max_len = calc_iov_length(iov, iovcnt);
packet = qemu_malloc(sizeof(VLANPacket) + max_len);
- packet->next = sender->vlan->send_queue;
packet->sender = sender;
packet->sent_cb = sent_cb;
packet->size = 0;
packet->size += len;
}
- sender->vlan->send_queue = packet;
+ QTAILQ_INSERT_TAIL(&sender->vlan->send_queue, packet, entry);
return packet->size;
}
return qemu_sendv_packet_async(vc, iov, iovcnt, NULL);
}
-static void config_error(Monitor *mon, const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- if (mon) {
- monitor_vprintf(mon, fmt, ap);
- } else {
- fprintf(stderr, "qemu: ");
- vfprintf(stderr, fmt, ap);
- exit(1);
- }
- va_end(ap);
-}
-
#if defined(CONFIG_SLIRP)
/* slirp network adapter */
};
typedef struct SlirpState {
- TAILQ_ENTRY(SlirpState) entry;
+ QTAILQ_ENTRY(SlirpState) entry;
VLANClientState *vc;
Slirp *slirp;
+#ifndef _WIN32
+ char smb_dir[128];
+#endif
} SlirpState;
static struct slirp_config_str *slirp_configs;
const char *legacy_tftp_prefix;
const char *legacy_bootp_filename;
-static TAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
- TAILQ_HEAD_INITIALIZER(slirp_stacks);
+static QTAILQ_HEAD(slirp_stacks, SlirpState) slirp_stacks =
+ QTAILQ_HEAD_INITIALIZER(slirp_stacks);
-static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,
+static int slirp_hostfwd(SlirpState *s, const char *redir_str,
+ int legacy_format);
+static int slirp_guestfwd(SlirpState *s, const char *config_str,
int legacy_format);
-static void slirp_guestfwd(SlirpState *s, Monitor *mon, const char *config_str,
- int legacy_format);
#ifndef _WIN32
static const char *legacy_smb_export;
-static void slirp_smb(SlirpState *s, const char *exported_dir,
- struct in_addr vserver_addr);
+static int slirp_smb(SlirpState *s, const char *exported_dir,
+ struct in_addr vserver_addr);
+static void slirp_smb_cleanup(SlirpState *s);
+#else
+static inline void slirp_smb_cleanup(SlirpState *s) { }
#endif
int slirp_can_output(void *opaque)
SlirpState *s = vc->opaque;
slirp_cleanup(s->slirp);
- TAILQ_REMOVE(&slirp_stacks, s, entry);
+ slirp_smb_cleanup(s);
+ QTAILQ_REMOVE(&slirp_stacks, s, entry);
qemu_free(s);
}
-static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model,
+static int net_slirp_init(VLANState *vlan, const char *model,
const char *name, int restricted,
const char *vnetwork, const char *vhost,
const char *vhostname, const char *tftp_export,
const char *vsmbserver)
{
/* default settings according to historic slirp */
- struct in_addr net = { .s_addr = htonl(0x0a000000) }; /* 10.0.0.0 */
- struct in_addr mask = { .s_addr = htonl(0xff000000) }; /* 255.0.0.0 */
+ struct in_addr net = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
+ struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
struct in_addr dns = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
uint32_t addr;
int shift;
char *end;
+ struct slirp_config_str *config;
if (!tftp_export) {
tftp_export = legacy_tftp_prefix;
s = qemu_mallocz(sizeof(SlirpState));
s->slirp = slirp_init(restricted, net, mask, host, vhostname,
tftp_export, bootfile, dhcp, dns, s);
- TAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
-
- while (slirp_configs) {
- struct slirp_config_str *config = slirp_configs;
+ QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
+ for (config = slirp_configs; config; config = config->next) {
if (config->flags & SLIRP_CFG_HOSTFWD) {
- slirp_hostfwd(s, mon, config->str,
- config->flags & SLIRP_CFG_LEGACY);
+ if (slirp_hostfwd(s, config->str,
+ config->flags & SLIRP_CFG_LEGACY) < 0)
+ return -1;
} else {
- slirp_guestfwd(s, mon, config->str,
- config->flags & SLIRP_CFG_LEGACY);
+ if (slirp_guestfwd(s, config->str,
+ config->flags & SLIRP_CFG_LEGACY) < 0)
+ return -1;
}
- slirp_configs = config->next;
- qemu_free(config);
}
#ifndef _WIN32
if (!smb_export) {
smb_export = legacy_smb_export;
}
if (smb_export) {
- slirp_smb(s, smb_export, smbsrv);
+ if (slirp_smb(s, smb_export, smbsrv) < 0)
+ return -1;
}
#endif
s->vc = qemu_new_vlan_client(vlan, model, name, NULL, slirp_receive, NULL,
net_slirp_cleanup, s);
- s->vc->info_str[0] = '\0';
+ snprintf(s->vc->info_str, sizeof(s->vc->info_str),
+ "net=%s, restricted=%c", inet_ntoa(net), restricted ? 'y' : 'n');
return 0;
}
-void net_slirp_hostfwd_remove(Monitor *mon, const char *src_str)
+static SlirpState *slirp_lookup(Monitor *mon, const char *vlan,
+ const char *stack)
+{
+ VLANClientState *vc;
+
+ if (vlan) {
+ vc = qemu_find_vlan_client_by_name(mon, strtol(vlan, NULL, 0), stack);
+ if (!vc) {
+ return NULL;
+ }
+ if (strcmp(vc->model, "user")) {
+ monitor_printf(mon, "invalid device specified\n");
+ return NULL;
+ }
+ return vc->opaque;
+ } else {
+ if (QTAILQ_EMPTY(&slirp_stacks)) {
+ monitor_printf(mon, "user mode network stack not in use\n");
+ return NULL;
+ }
+ return QTAILQ_FIRST(&slirp_stacks);
+ }
+}
+
+void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
{
struct in_addr host_addr = { .s_addr = INADDR_ANY };
int host_port;
char buf[256] = "";
- const char *p = src_str;
+ const char *src_str, *p;
+ SlirpState *s;
int is_udp = 0;
int err;
+ const char *arg1 = qdict_get_str(qdict, "arg1");
+ const char *arg2 = qdict_get_try_str(qdict, "arg2");
+ const char *arg3 = qdict_get_try_str(qdict, "arg3");
- if (TAILQ_EMPTY(&slirp_stacks)) {
- monitor_printf(mon, "user mode network stack not in use\n");
+ if (arg2) {
+ s = slirp_lookup(mon, arg1, arg2);
+ src_str = arg3;
+ } else {
+ s = slirp_lookup(mon, NULL, NULL);
+ src_str = arg1;
+ }
+ if (!s) {
return;
}
if (!src_str || !src_str[0])
goto fail_syntax;
+ p = src_str;
get_str_sep(buf, sizeof(buf), &p, ':');
if (!strcmp(buf, "tcp") || buf[0] == '\0') {
host_port = atoi(p);
- err = slirp_remove_hostfwd(TAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
+ err = slirp_remove_hostfwd(QTAILQ_FIRST(&slirp_stacks)->slirp, is_udp,
host_addr, host_port);
monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
monitor_printf(mon, "invalid format\n");
}
-static void slirp_hostfwd(SlirpState *s, Monitor *mon, const char *redir_str,
- int legacy_format)
+static int slirp_hostfwd(SlirpState *s, const char *redir_str,
+ int legacy_format)
{
struct in_addr host_addr = { .s_addr = INADDR_ANY };
struct in_addr guest_addr = { .s_addr = 0 };
char *end;
p = redir_str;
- if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
+ if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
goto fail_syntax;
}
if (!strcmp(buf, "tcp") || buf[0] == '\0') {
if (slirp_add_hostfwd(s->slirp, is_udp, host_addr, host_port, guest_addr,
guest_port) < 0) {
- config_error(mon, "could not set up host forwarding rule '%s'\n",
- redir_str);
+ qemu_error("could not set up host forwarding rule '%s'\n",
+ redir_str);
+ return -1;
}
- return;
+ return 0;
fail_syntax:
- config_error(mon, "invalid host forwarding rule '%s'\n", redir_str);
+ qemu_error("invalid host forwarding rule '%s'\n", redir_str);
+ return -1;
}
-void net_slirp_hostfwd_add(Monitor *mon, const char *redir_str)
+void net_slirp_hostfwd_add(Monitor *mon, const QDict *qdict)
{
- if (TAILQ_EMPTY(&slirp_stacks)) {
- monitor_printf(mon, "user mode network stack not in use\n");
- return;
+ const char *redir_str;
+ SlirpState *s;
+ const char *arg1 = qdict_get_str(qdict, "arg1");
+ const char *arg2 = qdict_get_try_str(qdict, "arg2");
+ const char *arg3 = qdict_get_try_str(qdict, "arg3");
+
+ if (arg2) {
+ s = slirp_lookup(mon, arg1, arg2);
+ redir_str = arg3;
+ } else {
+ s = slirp_lookup(mon, NULL, NULL);
+ redir_str = arg1;
+ }
+ if (s) {
+ slirp_hostfwd(s, redir_str, 0);
}
- slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), mon, redir_str, 0);
}
-void net_slirp_redir(const char *redir_str)
+int net_slirp_redir(const char *redir_str)
{
struct slirp_config_str *config;
- if (TAILQ_EMPTY(&slirp_stacks)) {
+ if (QTAILQ_EMPTY(&slirp_stacks)) {
config = qemu_malloc(sizeof(*config));
pstrcpy(config->str, sizeof(config->str), redir_str);
config->flags = SLIRP_CFG_HOSTFWD | SLIRP_CFG_LEGACY;
config->next = slirp_configs;
slirp_configs = config;
- return;
+ return 0;
}
- slirp_hostfwd(TAILQ_FIRST(&slirp_stacks), NULL, redir_str, 1);
+ return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks), redir_str, 1);
}
#ifndef _WIN32
-static char smb_dir[1024];
-
-static void erase_dir(char *dir_name)
+/* automatic user mode samba server configuration */
+static void slirp_smb_cleanup(SlirpState *s)
{
- DIR *d;
- struct dirent *de;
- char filename[1024];
+ char cmd[128];
- /* erase all the files in the directory */
- if ((d = opendir(dir_name)) != NULL) {
- for(;;) {
- de = readdir(d);
- if (!de)
- break;
- if (strcmp(de->d_name, ".") != 0 &&
- strcmp(de->d_name, "..") != 0) {
- snprintf(filename, sizeof(filename), "%s/%s",
- smb_dir, de->d_name);
- if (unlink(filename) != 0) /* is it a directory? */
- erase_dir(filename);
- }
- }
- closedir(d);
- rmdir(dir_name);
+ if (s->smb_dir[0] != '\0') {
+ snprintf(cmd, sizeof(cmd), "rm -rf %s", s->smb_dir);
+ system(cmd);
+ s->smb_dir[0] = '\0';
}
}
-/* automatic user mode samba server configuration */
-static void smb_exit(void)
-{
- erase_dir(smb_dir);
-}
-
-static void slirp_smb(SlirpState* s, const char *exported_dir,
- struct in_addr vserver_addr)
+static int slirp_smb(SlirpState* s, const char *exported_dir,
+ struct in_addr vserver_addr)
{
- char smb_conf[1024];
- char smb_cmdline[1024];
+ static int instance;
+ char smb_conf[128];
+ char smb_cmdline[128];
FILE *f;
- /* XXX: better tmp dir construction */
- 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);
+ snprintf(s->smb_dir, sizeof(s->smb_dir), "/tmp/qemu-smb.%ld-%d",
+ (long)getpid(), instance++);
+ if (mkdir(s->smb_dir, 0700) < 0) {
+ qemu_error("could not create samba server dir '%s'\n", s->smb_dir);
+ return -1;
}
- snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
+ snprintf(smb_conf, sizeof(smb_conf), "%s/%s", s->smb_dir, "smb.conf");
f = fopen(smb_conf, "w");
if (!f) {
- fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
- exit(1);
+ slirp_smb_cleanup(s);
+ qemu_error("could not create samba server configuration file '%s'\n",
+ smb_conf);
+ return -1;
}
fprintf(f,
"[global]\n"
"path=%s\n"
"read only=no\n"
"guest ok=yes\n",
- smb_dir,
- smb_dir,
- smb_dir,
- smb_dir,
- smb_dir,
+ s->smb_dir,
+ s->smb_dir,
+ s->smb_dir,
+ s->smb_dir,
+ s->smb_dir,
exported_dir
);
fclose(f);
- atexit(smb_exit);
snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
SMBD_COMMAND, smb_conf);
- if (slirp_add_exec(s->slirp, 0, smb_cmdline, vserver_addr, 139) < 0) {
- fprintf(stderr, "conflicting/invalid smbserver address\n");
- exit(1);
+ if (slirp_add_exec(s->slirp, 0, smb_cmdline, &vserver_addr, 139) < 0) {
+ slirp_smb_cleanup(s);
+ qemu_error("conflicting/invalid smbserver address\n");
+ return -1;
}
+ return 0;
}
/* automatic user mode samba server configuration (legacy interface) */
-void net_slirp_smb(const char *exported_dir)
+int net_slirp_smb(const char *exported_dir)
{
struct in_addr vserver_addr = { .s_addr = 0 };
if (legacy_smb_export) {
fprintf(stderr, "-smb given twice\n");
- exit(1);
+ return -1;
}
legacy_smb_export = exported_dir;
- if (!TAILQ_EMPTY(&slirp_stacks)) {
- slirp_smb(TAILQ_FIRST(&slirp_stacks), exported_dir, vserver_addr);
+ if (!QTAILQ_EMPTY(&slirp_stacks)) {
+ return slirp_smb(QTAILQ_FIRST(&slirp_stacks), exported_dir,
+ vserver_addr);
}
+ return 0;
}
#endif /* !defined(_WIN32) */
slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
}
-static void slirp_guestfwd(SlirpState *s, Monitor *mon, const char *config_str,
- int legacy_format)
+static int slirp_guestfwd(SlirpState *s, const char *config_str,
+ int legacy_format)
{
struct in_addr server = { .s_addr = 0 };
struct GuestFwd *fwd;
snprintf(buf, sizeof(buf), "guestfwd.tcp:%d", port);
fwd->hd = qemu_chr_open(buf, p, NULL);
if (!fwd->hd) {
- config_error(mon, "could not open guest forwarding device '%s'\n",
- buf);
+ qemu_error("could not open guest forwarding device '%s'\n", buf);
qemu_free(fwd);
- return;
+ return -1;
+ }
+
+ if (slirp_add_exec(s->slirp, 3, fwd->hd, &server, port) < 0) {
+ qemu_error("conflicting/invalid host:port in guest forwarding "
+ "rule '%s'\n", config_str);
+ qemu_free(fwd);
+ return -1;
}
fwd->server = server;
fwd->port = port;
fwd->slirp = s->slirp;
- if (slirp_add_exec(s->slirp, 3, fwd->hd, server, port) < 0) {
- config_error(mon, "conflicting/invalid host:port in guest forwarding "
- "rule '%s'\n", config_str);
- qemu_free(fwd);
- return;
- }
qemu_chr_add_handlers(fwd->hd, guestfwd_can_read, guestfwd_read,
NULL, fwd);
- return;
+ return 0;
fail_syntax:
- config_error(mon, "invalid guest forwarding rule '%s'\n", config_str);
+ qemu_error("invalid guest forwarding rule '%s'\n", config_str);
+ return -1;
}
void do_info_usernet(Monitor *mon)
{
SlirpState *s;
- TAILQ_FOREACH(s, &slirp_stacks, entry) {
+ QTAILQ_FOREACH(s, &slirp_stacks, entry) {
monitor_printf(mon, "VLAN %d (%s):\n", s->vc->vlan->id, s->vc->name);
slirp_connection_info(s->slirp, mon);
}
} while (size > 0);
}
-static void tap_set_sndbuf(TAPState *s, int sndbuf, Monitor *mon)
-{
#ifdef TUNSETSNDBUF
- if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1) {
- config_error(mon, "TUNSETSNDBUF ioctl failed: %s\n",
- strerror(errno));
+/* sndbuf should be set to a value lower than the tx queue
+ * capacity of any destination network interface.
+ * Ethernet NICs generally have txqueuelen=1000, so 1Mb is
+ * a good default, given a 1500 byte MTU.
+ */
+#define TAP_DEFAULT_SNDBUF 1024*1024
+
+static int tap_set_sndbuf(TAPState *s, const char *sndbuf_str)
+{
+ int sndbuf = TAP_DEFAULT_SNDBUF;
+
+ if (sndbuf_str) {
+ sndbuf = atoi(sndbuf_str);
+ }
+
+ if (!sndbuf) {
+ sndbuf = INT_MAX;
+ }
+
+ if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1 && sndbuf_str) {
+ qemu_error("TUNSETSNDBUF ioctl failed: %s\n", strerror(errno));
+ return -1;
}
+ return 0;
+}
#else
- config_error(mon, "No '-net tap,sndbuf=<nbytes>' support available\n");
-#endif
+static int tap_set_sndbuf(TAPState *s, const char *sndbuf_str)
+{
+ if (sndbuf_str) {
+ qemu_error("No '-net tap,sndbuf=<nbytes>' support available\n");
+ return -1;
+ }
+ return 0;
}
+#endif /* TUNSETSNDBUF */
static void tap_cleanup(VLANClientState *vc)
{
return s;
}
-#if defined (HOST_BSD) || defined (__FreeBSD_kernel__)
+#if defined (CONFIG_BSD) || defined (__FreeBSD_kernel__)
static int tap_open(char *ifname, int ifname_size)
{
int fd;
const char *model, const char *name,
int fd, int is_connected)
{
- int so_type=-1, optlen=sizeof(so_type);
+ int so_type = -1, optlen=sizeof(so_type);
if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
(socklen_t *)&optlen)< 0) {
return -1;
}
s->vlan = vlan;
- s->model = strdup(model);
- s->name = name ? strdup(name) : NULL;
+ s->model = qemu_strdup(model);
+ s->name = name ? qemu_strdup(name) : NULL;
s->fd = fd;
qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
return 0;
return size;
}
- ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);
+ ts = muldiv64(qemu_get_clock(vm_clock), 1000000, get_ticks_per_sec());
caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
hdr.ts.tv_sec = ts / 1000000;
qemu_free(s);
}
-static int net_dump_init(Monitor *mon, VLANState *vlan, const char *device,
+static int net_dump_init(VLANState *vlan, const char *device,
const char *name, const char *filename, int len)
{
struct pcap_file_hdr hdr;
s->fd = open(filename, O_CREAT | O_WRONLY | O_BINARY, 0644);
if (s->fd < 0) {
- config_error(mon, "-net dump: can't open %s\n", filename);
+ qemu_error("-net dump: can't open %s\n", filename);
return -1;
}
hdr.linktype = 1;
if (write(s->fd, &hdr, sizeof(hdr)) < sizeof(hdr)) {
- config_error(mon, "-net dump write error: %s\n", strerror(errno));
+ qemu_error("-net dump write error: %s\n", strerror(errno));
close(s->fd);
qemu_free(s);
return -1;
}
/* find or alloc a new VLAN */
-VLANState *qemu_find_vlan(int id)
+VLANState *qemu_find_vlan(int id, int allocate)
{
VLANState **pvlan, *vlan;
for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
if (vlan->id == id)
return vlan;
}
+ if (!allocate) {
+ return NULL;
+ }
vlan = qemu_mallocz(sizeof(VLANState));
vlan->id = id;
+ QTAILQ_INIT(&vlan->send_queue);
vlan->next = NULL;
pvlan = &first_vlan;
while (*pvlan != NULL)
return -1;
}
+int qemu_show_nic_models(const char *arg, const char *const *models)
+{
+ int i;
+
+ if (!arg || strcmp(arg, "?"))
+ return 0;
+
+ fprintf(stderr, "qemu: Supported NIC models: ");
+ for (i = 0 ; models[i]; i++)
+ fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
+ return 1;
+}
+
void qemu_check_nic_model(NICInfo *nd, const char *model)
{
const char *models[2];
models[0] = model;
models[1] = NULL;
- qemu_check_nic_model_list(nd, models, model);
+ if (qemu_show_nic_models(nd->model, models))
+ exit(0);
+ if (qemu_find_nic_model(nd, models, model) < 0)
+ exit(1);
}
-void qemu_check_nic_model_list(NICInfo *nd, const char * const *models,
- const char *default_model)
+int qemu_find_nic_model(NICInfo *nd, const char * const *models,
+ const char *default_model)
{
- int i, exit_status = 0;
+ int i;
if (!nd->model)
- nd->model = strdup(default_model);
+ nd->model = qemu_strdup(default_model);
+
+ for (i = 0 ; models[i]; i++) {
+ if (strcmp(nd->model, models[i]) == 0)
+ return i;
+ }
- if (strcmp(nd->model, "?") != 0) {
- for (i = 0 ; models[i]; i++)
- if (strcmp(nd->model, models[i]) == 0)
- return;
+ qemu_error("qemu: Unsupported NIC model: %s\n", nd->model);
+ return -1;
+}
+
+static int net_handle_fd_param(Monitor *mon, const char *param)
+{
+ if (!qemu_isdigit(param[0])) {
+ int fd;
- fprintf(stderr, "qemu: Unsupported NIC model: %s\n", nd->model);
- exit_status = 1;
+ fd = monitor_get_fd(mon, param);
+ if (fd == -1) {
+ qemu_error("No file descriptor named %s found", param);
+ return -1;
+ }
+
+ return fd;
+ } else {
+ return strtol(param, NULL, 0);
}
+}
- fprintf(stderr, "qemu: Supported NIC models: ");
- for (i = 0 ; models[i]; i++)
- fprintf(stderr, "%s%c", models[i], models[i+1] ? ',' : '\n');
+static int net_init_nic(QemuOpts *opts, Monitor *mon)
+{
+ int idx;
+ NICInfo *nd;
+
+ idx = nic_get_free_idx();
+ if (idx == -1 || nb_nics >= MAX_NICS) {
+ qemu_error("Too Many NICs\n");
+ return -1;
+ }
- exit(exit_status);
+ nd = &nd_table[idx];
+
+ memset(nd, 0, sizeof(*nd));
+
+ nd->vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
+
+ if (qemu_opts_id(opts)) {
+ nd->id = qemu_strdup(qemu_opts_id(opts));
+ }
+ if (qemu_opt_get(opts, "name")) {
+ nd->name = qemu_strdup(qemu_opt_get(opts, "name"));
+ }
+ if (qemu_opt_get(opts, "model")) {
+ nd->model = qemu_strdup(qemu_opt_get(opts, "model"));
+ }
+ if (qemu_opt_get(opts, "addr")) {
+ nd->devaddr = qemu_strdup(qemu_opt_get(opts, "addr"));
+ }
+
+ nd->macaddr[0] = 0x52;
+ nd->macaddr[1] = 0x54;
+ nd->macaddr[2] = 0x00;
+ nd->macaddr[3] = 0x12;
+ nd->macaddr[4] = 0x34;
+ nd->macaddr[5] = 0x56 + idx;
+
+ if (qemu_opt_get(opts, "macaddr") &&
+ parse_macaddr(nd->macaddr, qemu_opt_get(opts, "macaddr")) < 0) {
+ qemu_error("invalid syntax for ethernet address\n");
+ return -1;
+ }
+
+ nd->nvectors = qemu_opt_get_number(opts, "vectors", NIC_NVECTORS_UNSPECIFIED);
+ if (nd->nvectors != NIC_NVECTORS_UNSPECIFIED &&
+ (nd->nvectors < 0 || nd->nvectors > 0x7ffffff)) {
+ qemu_error("invalid # of vectors: %d\n", nd->nvectors);
+ return -1;
+ }
+
+ nd->used = 1;
+ nd->vlan->nb_guest_devs++;
+ nb_nics++;
+
+ return idx;
+}
+
+static int net_init_slirp_configs(const char *name, const char *value, void *opaque)
+{
+ struct slirp_config_str *config;
+
+ if (strcmp(name, "hostfwd") != 0 && strcmp(name, "guestfwd") != 0) {
+ return 0;
+ }
+
+ config = qemu_mallocz(sizeof(*config));
+
+ pstrcpy(config->str, sizeof(config->str), value);
+
+ if (!strcmp(name, "hostfwd")) {
+ config->flags = SLIRP_CFG_HOSTFWD;
+ }
+
+ config->next = slirp_configs;
+ slirp_configs = config;
+
+ return 0;
+}
+
+static int net_init_slirp(QemuOpts *opts, Monitor *mon)
+{
+ VLANState *vlan;
+ struct slirp_config_str *config;
+ const char *name;
+ const char *vhost;
+ const char *vhostname;
+ const char *vdhcp_start;
+ const char *vnamesrv;
+ const char *tftp_export;
+ const char *bootfile;
+ const char *smb_export;
+ const char *vsmbsrv;
+ char *vnet = NULL;
+ int restricted = 0;
+ int ret;
+
+ vlan = qemu_find_vlan(qemu_opt_get_number(opts, "vlan", 0), 1);
+
+ name = qemu_opt_get(opts, "name");
+
+ vhost = qemu_opt_get(opts, "host");
+ vhostname = qemu_opt_get(opts, "hostname");
+ vdhcp_start = qemu_opt_get(opts, "dhcpstart");
+ vnamesrv = qemu_opt_get(opts, "dns");
+ tftp_export = qemu_opt_get(opts, "tftp");
+ bootfile = qemu_opt_get(opts, "bootfile");
+ smb_export = qemu_opt_get(opts, "smb");
+ vsmbsrv = qemu_opt_get(opts, "smbserver");
+
+ if (qemu_opt_get(opts, "ip")) {
+ const char *ip = qemu_opt_get(opts, "ip");
+ int l = strlen(ip) + strlen("/24") + 1;
+
+ vnet = qemu_malloc(l);
+
+ /* emulate legacy ip= parameter */
+ pstrcpy(vnet, l, ip);
+ pstrcat(vnet, l, "/24");
+ }
+
+ if (qemu_opt_get(opts, "net")) {
+ if (vnet) {
+ qemu_free(vnet);
+ }
+ vnet = qemu_strdup(qemu_opt_get(opts, "net"));
+ }
+
+ if (qemu_opt_get(opts, "restrict") &&
+ qemu_opt_get(opts, "restrict")[0] == 'y') {
+ restricted = 1;
+ }
+
+ qemu_opt_foreach(opts, net_init_slirp_configs, NULL, 0);
+
+ ret = net_slirp_init(vlan, "user", name, restricted, vnet, vhost,
+ vhostname, tftp_export, bootfile, vdhcp_start,
+ vnamesrv, smb_export, vsmbsrv);
+
+ while (slirp_configs) {
+ config = slirp_configs;
+ slirp_configs = config->next;
+ qemu_free(config);
+ }
+
+ if (ret != -1) {
+ vlan->nb_host_devs++;
+ }
+
+ qemu_free(vnet);
+
+ return ret;
+}
+
+#define NET_COMMON_PARAMS_DESC \
+ { \
+ .name = "type", \
+ .type = QEMU_OPT_STRING, \
+ .help = "net client type (nic, tap etc.)", \
+ }, { \
+ .name = "vlan", \
+ .type = QEMU_OPT_NUMBER, \
+ .help = "vlan number", \
+ }, { \
+ .name = "name", \
+ .type = QEMU_OPT_STRING, \
+ .help = "identifier for monitor commands", \
+ }
+
+typedef int (*net_client_init_func)(QemuOpts *opts, Monitor *mon);
+
+/* magic number, but compiler will warn if too small */
+#define NET_MAX_DESC 20
+
+static struct {
+ const char *type;
+ net_client_init_func init;
+ QemuOptDesc desc[NET_MAX_DESC];
+} net_client_types[] = {
+ {
+ .type = "none",
+ .desc = {
+ NET_COMMON_PARAMS_DESC,
+ { /* end of list */ }
+ },
+ }, {
+ .type = "nic",
+ .init = net_init_nic,
+ .desc = {
+ NET_COMMON_PARAMS_DESC,
+ {
+ .name = "macaddr",
+ .type = QEMU_OPT_STRING,
+ .help = "MAC address",
+ }, {
+ .name = "model",
+ .type = QEMU_OPT_STRING,
+ .help = "device model (e1000, rtl8139, virtio etc.)",
+ }, {
+ .name = "addr",
+ .type = QEMU_OPT_STRING,
+ .help = "PCI device address",
+ }, {
+ .name = "vectors",
+ .type = QEMU_OPT_NUMBER,
+ .help = "number of MSI-x vectors, 0 to disable MSI-X",
+ },
+ { /* end of list */ }
+ },
+#ifdef CONFIG_SLIRP
+ }, {
+ .type = "user",
+ .init = net_init_slirp,
+ .desc = {
+ NET_COMMON_PARAMS_DESC,
+ {
+ .name = "hostname",
+ .type = QEMU_OPT_STRING,
+ .help = "client hostname reported by the builtin DHCP server",
+ }, {
+ .name = "restrict",
+ .type = QEMU_OPT_STRING,
+ .help = "isolate the guest from the host (y|yes|n|no)",
+ }, {
+ .name = "ip",
+ .type = QEMU_OPT_STRING,
+ .help = "legacy parameter, use net= instead",
+ }, {
+ .name = "net",
+ .type = QEMU_OPT_STRING,
+ .help = "IP address and optional netmask",
+ }, {
+ .name = "host",
+ .type = QEMU_OPT_STRING,
+ .help = "guest-visible address of the host",
+ }, {
+ .name = "tftp",
+ .type = QEMU_OPT_STRING,
+ .help = "root directory of the built-in TFTP server",
+ }, {
+ .name = "bootfile",
+ .type = QEMU_OPT_STRING,
+ .help = "BOOTP filename, for use with tftp=",
+ }, {
+ .name = "dhcpstart",
+ .type = QEMU_OPT_STRING,
+ .help = "the first of the 16 IPs the built-in DHCP server can assign",
+ }, {
+ .name = "dns",
+ .type = QEMU_OPT_STRING,
+ .help = "guest-visible address of the virtual nameserver",
+ }, {
+ .name = "smb",
+ .type = QEMU_OPT_STRING,
+ .help = "root directory of the built-in SMB server",
+ }, {
+ .name = "smbserver",
+ .type = QEMU_OPT_STRING,
+ .help = "IP address of the built-in SMB server",
+ }, {
+ .name = "hostfwd",
+ .type = QEMU_OPT_STRING,
+ .help = "guest port number to forward incoming TCP or UDP connections",
+ }, {
+ .name = "guestfwd",
+ .type = QEMU_OPT_STRING,
+ .help = "IP address and port to forward guest TCP connections",
+ },
+ { /* end of list */ }
+ },
+#endif
+ },
+ { /* end of list */ }
+};
+
+static int net_client_init_from_opts(Monitor *mon, QemuOpts *opts)
+{
+ const char *type;
+ int i;
+
+ type = qemu_opt_get(opts, "type");
+ if (!type) {
+ qemu_error("No type specified for -net\n");
+ return -1;
+ }
+
+ for (i = 0; net_client_types[i].type != NULL; i++) {
+ if (!strcmp(net_client_types[i].type, type)) {
+ if (qemu_opts_validate(opts, &net_client_types[i].desc[0]) == -1) {
+ return -1;
+ }
+
+ if (net_client_types[i].init) {
+ return net_client_types[i].init(opts, NULL);
+ } else {
+ return 0;
+ }
+ }
+ }
+
+ qemu_error("Invalid -net type '%s'\n", type);
+ return -1;
}
int net_client_init(Monitor *mon, const char *device, const char *p)
VLANState *vlan;
char *name = NULL;
+ if (!strcmp(device, "none") ||
+ !strcmp(device, "nic") ||
+ !strcmp(device, "user")) {
+ QemuOpts *opts;
+
+ opts = qemu_opts_parse(&qemu_net_opts, p, NULL);
+ if (!opts) {
+ return -1;
+ }
+
+ qemu_opt_set(opts, "type", device);
+
+ return net_client_init_from_opts(mon, opts);
+ }
+
vlan_id = 0;
if (get_param_value(buf, sizeof(buf), "vlan", p)) {
vlan_id = strtol(buf, NULL, 0);
}
- vlan = qemu_find_vlan(vlan_id);
+ vlan = qemu_find_vlan(vlan_id, 1);
if (get_param_value(buf, sizeof(buf), "name", p)) {
name = qemu_strdup(buf);
}
- if (!strcmp(device, "nic")) {
- static const char * const nic_params[] = {
- "vlan", "name", "macaddr", "model", "addr", "vectors", NULL
- };
- NICInfo *nd;
- uint8_t *macaddr;
- int idx = nic_get_free_idx();
- if (check_params(buf, sizeof(buf), nic_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
- ret = -1;
- goto out;
- }
- if (idx == -1 || nb_nics >= MAX_NICS) {
- config_error(mon, "Too Many NICs\n");
- ret = -1;
- goto out;
- }
- nd = &nd_table[idx];
- macaddr = nd->macaddr;
- macaddr[0] = 0x52;
- macaddr[1] = 0x54;
- macaddr[2] = 0x00;
- macaddr[3] = 0x12;
- macaddr[4] = 0x34;
- macaddr[5] = 0x56 + idx;
-
- if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
- if (parse_macaddr(macaddr, buf) < 0) {
- config_error(mon, "invalid syntax for ethernet address\n");
- ret = -1;
- goto out;
- }
- }
- if (get_param_value(buf, sizeof(buf), "model", p)) {
- nd->model = strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "addr", p)) {
- nd->devaddr = strdup(buf);
- }
- nd->nvectors = NIC_NVECTORS_UNSPECIFIED;
- if (get_param_value(buf, sizeof(buf), "vectors", p)) {
- char *endptr;
- long vectors = strtol(buf, &endptr, 0);
- if (*endptr) {
- config_error(mon, "invalid syntax for # of vectors\n");
- ret = -1;
- goto out;
- }
- if (vectors < 0 || vectors > 0x7ffffff) {
- config_error(mon, "invalid # of vectors\n");
- ret = -1;
- goto out;
- }
- nd->nvectors = vectors;
- }
- nd->vlan = vlan;
- nd->name = name;
- nd->used = 1;
- name = NULL;
- nb_nics++;
- vlan->nb_guest_devs++;
- ret = idx;
- } else
- if (!strcmp(device, "none")) {
- if (*p != '\0') {
- config_error(mon, "'none' takes no parameters\n");
- ret = -1;
- goto out;
- }
- /* 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", "net", "host",
- "tftp", "bootfile", "dhcpstart", "dns", "smb", "smbserver",
- "hostfwd", "guestfwd", NULL
- };
- struct slirp_config_str *config;
- int restricted = 0;
- char *vnet = NULL;
- char *vhost = NULL;
- char *vhostname = NULL;
- char *tftp_export = NULL;
- char *bootfile = NULL;
- char *vdhcp_start = NULL;
- char *vnamesrv = NULL;
- char *smb_export = NULL;
- char *vsmbsrv = NULL;
- const char *q;
-
- if (check_params(buf, sizeof(buf), slirp_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
- ret = -1;
- goto out;
- }
- if (get_param_value(buf, sizeof(buf), "ip", p)) {
- /* emulate legacy parameter */
- vnet = qemu_malloc(strlen(buf) + strlen("/24") + 1);
- strcpy(vnet, buf);
- strcat(vnet, "/24");
- }
- if (get_param_value(buf, sizeof(buf), "net", p)) {
- vnet = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "host", p)) {
- vhost = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "hostname", p)) {
- vhostname = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "restrict", p)) {
- restricted = (buf[0] == 'y') ? 1 : 0;
- }
- if (get_param_value(buf, sizeof(buf), "dhcpstart", p)) {
- vdhcp_start = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "dns", p)) {
- vnamesrv = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "tftp", p)) {
- tftp_export = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "bootfile", p)) {
- bootfile = qemu_strdup(buf);
- }
- if (get_param_value(buf, sizeof(buf), "smb", p)) {
- smb_export = qemu_strdup(buf);
- if (get_param_value(buf, sizeof(buf), "smbserver", p)) {
- vsmbsrv = qemu_strdup(buf);
- }
- }
- q = p;
- while (1) {
- config = qemu_malloc(sizeof(*config));
- if (!get_next_param_value(config->str, sizeof(config->str),
- "hostfwd", &q)) {
- break;
- }
- config->flags = SLIRP_CFG_HOSTFWD;
- config->next = slirp_configs;
- slirp_configs = config;
- config = NULL;
- }
- q = p;
- while (1) {
- config = qemu_malloc(sizeof(*config));
- if (!get_next_param_value(config->str, sizeof(config->str),
- "guestfwd", &q)) {
- break;
- }
- config->flags = 0;
- config->next = slirp_configs;
- slirp_configs = config;
- config = NULL;
- }
- qemu_free(config);
- vlan->nb_host_devs++;
- ret = net_slirp_init(mon, vlan, device, name, restricted, vnet, vhost,
- vhostname, tftp_export, bootfile, vdhcp_start,
- vnamesrv, smb_export, vsmbsrv);
- qemu_free(vnet);
- qemu_free(vhost);
- qemu_free(vhostname);
- qemu_free(tftp_export);
- qemu_free(bootfile);
- qemu_free(vdhcp_start);
- qemu_free(vnamesrv);
- qemu_free(smb_export);
- qemu_free(vsmbsrv);
- } else if (!strcmp(device, "channel")) {
- if (TAILQ_EMPTY(&slirp_stacks)) {
+ if (!strcmp(device, "channel")) {
+ if (QTAILQ_EMPTY(&slirp_stacks)) {
struct slirp_config_str *config;
config = qemu_malloc(sizeof(*config));
config->flags = SLIRP_CFG_LEGACY;
config->next = slirp_configs;
slirp_configs = config;
+ ret = 0;
} else {
- slirp_guestfwd(TAILQ_FIRST(&slirp_stacks), mon, p, 1);
+ ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), p, 1);
}
- ret = 0;
} else
#endif
#ifdef _WIN32
char ifname[64];
if (check_params(buf, sizeof(buf), tap_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", buf, p);
ret = -1;
goto out;
}
if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
- config_error(mon, "tap: no interface name\n");
+ qemu_error("tap: no interface name\n");
ret = -1;
goto out;
}
static const char * const fd_params[] = {
"vlan", "name", "fd", "sndbuf", NULL
};
+ ret = -1;
if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
- ret = -1;
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
+ goto out;
+ }
+ fd = net_handle_fd_param(mon, buf);
+ if (fd == -1) {
goto out;
}
- fd = strtol(buf, NULL, 0);
fcntl(fd, F_SETFL, O_NONBLOCK);
s = net_tap_fd_init(vlan, device, name, fd);
+ if (!s) {
+ close(fd);
+ }
} else {
static const char * const tap_params[] = {
"vlan", "name", "ifname", "script", "downscript", "sndbuf", NULL
};
if (check_params(chkbuf, sizeof(chkbuf), tap_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
ret = -1;
goto out;
}
s = net_tap_init(vlan, device, name, ifname, setup_script, down_script);
}
if (s != NULL) {
+ const char *sndbuf_str = NULL;
if (get_param_value(buf, sizeof(buf), "sndbuf", p)) {
- tap_set_sndbuf(s, atoi(buf), mon);
+ sndbuf_str = buf;
}
- ret = 0;
+ ret = tap_set_sndbuf(s, sndbuf_str);
} else {
ret = -1;
}
"vlan", "name", "fd", NULL
};
int fd;
+ ret = -1;
if (check_params(chkbuf, sizeof(chkbuf), fd_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
- ret = -1;
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
goto out;
}
- fd = strtol(buf, NULL, 0);
- ret = -1;
- if (net_socket_fd_init(vlan, device, name, fd, 1))
- ret = 0;
+ fd = net_handle_fd_param(mon, buf);
+ if (fd == -1) {
+ goto out;
+ }
+ if (!net_socket_fd_init(vlan, device, name, fd, 1)) {
+ close(fd);
+ goto out;
+ }
+ 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(chkbuf, sizeof(chkbuf), listen_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
ret = -1;
goto out;
}
"vlan", "name", "connect", NULL
};
if (check_params(chkbuf, sizeof(chkbuf), connect_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
ret = -1;
goto out;
}
"vlan", "name", "mcast", NULL
};
if (check_params(chkbuf, sizeof(chkbuf), mcast_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", chkbuf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", chkbuf, p);
ret = -1;
goto out;
}
ret = net_socket_mcast_init(vlan, device, name, buf);
} else {
- config_error(mon, "Unknown socket options: %s\n", p);
+ qemu_error("Unknown socket options: %s\n", p);
ret = -1;
goto out;
}
int vde_port, vde_mode;
if (check_params(buf, sizeof(buf), vde_params, p) < 0) {
- config_error(mon, "invalid parameter '%s' in '%s'\n", buf, p);
+ qemu_error("invalid parameter '%s' in '%s'\n", buf, p);
ret = -1;
goto out;
}
if (!get_param_value(buf, sizeof(buf), "file", p)) {
snprintf(buf, sizeof(buf), "qemu-vlan%d.pcap", vlan_id);
}
- ret = net_dump_init(mon, vlan, device, name, buf, len);
+ ret = net_dump_init(vlan, device, name, buf, len);
} else {
- config_error(mon, "Unknown network device: %s\n", device);
+ qemu_error("Unknown network device: %s\n", device);
ret = -1;
goto out;
}
if (ret < 0) {
- config_error(mon, "Could not initialize device '%s'\n", device);
+ qemu_error("Could not initialize device '%s'\n", device);
}
out:
qemu_free(name);
{
nd->vlan->nb_guest_devs--;
nb_nics--;
+
+ qemu_free(nd->model);
+ qemu_free(nd->name);
+ qemu_free(nd->devaddr);
+ qemu_free(nd->id);
+
nd->used = 0;
- free((void *)nd->model);
}
static int net_host_check_device(const char *device)
return 0;
}
-void net_host_device_add(Monitor *mon, const char *device, const char *opts)
+void net_host_device_add(Monitor *mon, const QDict *qdict)
{
+ const char *device = qdict_get_str(qdict, "device");
+ const char *opts = qdict_get_try_str(qdict, "opts");
+
if (!net_host_check_device(device)) {
monitor_printf(mon, "invalid host network device %s\n", device);
return;
}
}
-void net_host_device_remove(Monitor *mon, int vlan_id, const char *device)
+void net_host_device_remove(Monitor *mon, const QDict *qdict)
{
- VLANState *vlan;
VLANClientState *vc;
+ int vlan_id = qdict_get_int(qdict, "vlan_id");
+ const char *device = qdict_get_str(qdict, "device");
- vlan = qemu_find_vlan(vlan_id);
-
- for (vc = vlan->first_client; vc != NULL; vc = vc->next) {
- if (!strcmp(vc->name, device)) {
- break;
- }
- }
-
+ vc = qemu_find_vlan_client_by_name(mon, vlan_id, device);
if (!vc) {
- monitor_printf(mon, "can't find device %s\n", device);
return;
}
if (!net_host_check_device(vc->model)) {
}
}
-int do_set_link(Monitor *mon, const char *name, const char *up_or_down)
+void do_set_link(Monitor *mon, const QDict *qdict)
{
VLANState *vlan;
VLANClientState *vc = NULL;
+ const char *name = qdict_get_str(qdict, "name");
+ const char *up_or_down = qdict_get_str(qdict, "up_or_down");
for (vlan = first_vlan; vlan != NULL; vlan = vlan->next)
for (vc = vlan->first_client; vc != NULL; vc = vc->next)
done:
if (!vc) {
- monitor_printf(mon, "could not find network device '%s'", name);
- return 0;
+ monitor_printf(mon, "could not find network device '%s'\n", name);
+ return;
}
if (strcmp(up_or_down, "up") == 0)
if (vc->link_status_changed)
vc->link_status_changed(vc);
-
- return 1;
}
void net_cleanup(void)
projects / qemu.git / blobdiff