slirp: Move smb, redir, tftp and bootp parameters and -net channel

So far a couple of slirp-related parameters were expressed via
stand-alone command line options. This it inconsistent and unintuitive.
Moreover, it prevents both dynamically reconfigured (host_net_add/
delete) and multi-instance slirp.

This patch refactors the configuration by turning -smb, -redir, -tftp
and -bootp as well as -net channel into options of "-net user". The old
stand-alone command line options are still processed, but no longer
advertised. This allows smooth migration of management applications to
to the new syntax and also the extension of that syntax later in this
series.
Signed-off-by: NJan Kiszka <jan.kiszka@siemens.com>
Signed-off-by: NAnthony Liguori <aliguori@us.ibm.com>

net.c

@@ -669,22 +669,28 @@ static void config_error(Monitor *mon, const char *fmt, ...)
 
 /* slirp network adapter */
 
+#define SLIRP_CFG_REDIR 1
+
 struct slirp_config_str {
     struct slirp_config_str *next;
-    const char *str;
+    int flags;
+    char str[1024];
 };
 
 static int slirp_inited;
-static struct slirp_config_str *slirp_redirs;
-#ifndef _WIN32
-static const char *slirp_smb_export;
-#endif
+static struct slirp_config_str *slirp_configs;
+const char *legacy_tftp_prefix;
+const char *legacy_bootp_filename;
 static VLANClientState *slirp_vc;
 
+static void slirp_redirection(Monitor *mon, const char *redir_str);
+static void vmchannel_init(Monitor *mon, const char *config_str);
+
 #ifndef _WIN32
+static const char *legacy_smb_export;
+
 static void slirp_smb(const char *exported_dir);
 #endif
-static void slirp_redirection(Monitor *mon, const char *redir_str);
 
 int slirp_can_output(void)
 {
@@ -724,27 +730,42 @@ static void net_slirp_cleanup(VLANClientState *vc)
     slirp_in_use = 0;
 }
 
-static int net_slirp_init(VLANState *vlan, const char *model, const char *name,
-                          int restricted, const char *ip)
+static int net_slirp_init(Monitor *mon, VLANState *vlan, const char *model,
+                          const char *name, int restricted, const char *ip,
+                          const char *tftp_export, const char *bootfile,
+                          const char *smb_export)
 {
     if (slirp_in_use) {
         /* slirp only supports a single instance so far */
         return -1;
     }
     if (!slirp_inited) {
+        if (!tftp_export) {
+            tftp_export = legacy_tftp_prefix;
+        }
+        if (!bootfile) {
+            bootfile = legacy_bootp_filename;
+        }
         slirp_inited = 1;
-        slirp_init(restricted, ip);
+        slirp_init(restricted, ip, tftp_export, bootfile);
 
-        while (slirp_redirs) {
-            struct slirp_config_str *config = slirp_redirs;
+        while (slirp_configs) {
+            struct slirp_config_str *config = slirp_configs;
 
-            slirp_redirection(NULL, config->str);
-            slirp_redirs = config->next;
+            if (config->flags & SLIRP_CFG_REDIR) {
+                slirp_redirection(mon, config->str);
+            } else {
+                vmchannel_init(mon, config->str);
+            }
+            slirp_configs = config->next;
             qemu_free(config);
         }
 #ifndef _WIN32
-        if (slirp_smb_export) {
-            slirp_smb(slirp_smb_export);
+        if (!smb_export) {
+            smb_export = legacy_smb_export;
+        }
+        if (smb_export) {
+            slirp_smb(smb_export);
         }
 #endif
     }
@@ -853,9 +874,10 @@ void net_slirp_redir(Monitor *mon, const char *redir_str, const char *redir_opt2
             monitor_printf(mon, "user mode network stack not in use\n");
         } else {
             config = qemu_malloc(sizeof(*config));
-            config->str = redir_str;
-            config->next = slirp_redirs;
-            slirp_redirs = config;
+            pstrcpy(config->str, sizeof(config->str), redir_str);
+            config->flags = SLIRP_CFG_REDIR;
+            config->next = slirp_configs;
+            slirp_configs = config;
         }
         return;
     }
@@ -952,14 +974,14 @@ static void slirp_smb(const char *exported_dir)
     slirp_add_exec(0, smb_cmdline, 4, 139);
 }
 
-/* automatic user mode samba server configuration */
+/* automatic user mode samba server configuration (legacy interface) */
 void net_slirp_smb(const char *exported_dir)
 {
-    if (slirp_smb_export) {
+    if (legacy_smb_export) {
         fprintf(stderr, "-smb given twice\n");
         exit(1);
     }
-    slirp_smb_export = exported_dir;
+    legacy_smb_export = exported_dir;
     if (slirp_inited) {
         slirp_smb(exported_dir);
     }
@@ -989,6 +1011,36 @@ static void vmchannel_read(void *opaque, const uint8_t *buf, int size)
     slirp_socket_recv(4, vmc->port, buf, size);
 }
 
+static void vmchannel_init(Monitor *mon, const char *config_str)
+{
+    struct VMChannel *vmc;
+    char *devname;
+    char name[20];
+    int port;
+
+    port = strtol(config_str, &devname, 10);
+    if (port < 1 || port > 65535 || *devname != ':') {
+        config_error(mon, "invalid vmchannel port number\n");
+        return;
+    }
+    devname++;
+
+    vmc = qemu_malloc(sizeof(struct VMChannel));
+    snprintf(name, sizeof(name), "vmchannel%d", port);
+    vmc->hd = qemu_chr_open(name, devname, NULL);
+    if (!vmc->hd) {
+        config_error(mon, "could not open vmchannel device '%s'\n", devname);
+        qemu_free(vmc);
+        return;
+    }
+    vmc->port = port;
+
+    slirp_add_exec(3, vmc->hd, 4, port);
+    qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
+                          NULL, vmc);
+    return;
+}
+
 #endif /* CONFIG_SLIRP */
 
 #if !defined(_WIN32)
@@ -2200,10 +2252,16 @@ int net_client_init(Monitor *mon, const char *device, const char *p)
 #ifdef CONFIG_SLIRP
     if (!strcmp(device, "user")) {
         static const char * const slirp_params[] = {
-            "vlan", "name", "hostname", "restrict", "ip", NULL
+            "vlan", "name", "hostname", "restrict", "ip", "tftp", "bootfile",
+            "smb", "redir", "channel", NULL
         };
+        struct slirp_config_str *config;
+        char *tftp_export = NULL;
+        char *bootfile = NULL;
+        char *smb_export = NULL;
         int restricted = 0;
         char *ip = 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);
@@ -2219,34 +2277,59 @@ int net_client_init(Monitor *mon, const char *device, const char *p)
         if (get_param_value(buf, sizeof(buf), "ip", p)) {
             ip = 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);
+        }
+        q = p;
+        while (1) {
+            config = qemu_malloc(sizeof(*config));
+            if (!get_next_param_value(config->str, sizeof(config->str),
+                                      "redir", &q)) {
+                break;
+            }
+            config->flags = SLIRP_CFG_REDIR;
+            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),
+                                      "channel", &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(vlan, device, name, restricted, ip);
+        ret = net_slirp_init(mon, vlan, device, name, restricted, ip,
+                             tftp_export, bootfile, smb_export);
         qemu_free(ip);
+        qemu_free(tftp_export);
+        qemu_free(bootfile);
+        qemu_free(smb_export);
     } else if (!strcmp(device, "channel")) {
-        long port;
-        char name[20], *devname;
-        struct VMChannel *vmc;
-
-        port = strtol(p, &devname, 10);
-        devname++;
-        if (port < 1 || port > 65535) {
-            config_error(mon, "vmchannel wrong port number\n");
-            ret = -1;
-            goto out;
-        }
-        vmc = malloc(sizeof(struct VMChannel));
-        snprintf(name, 20, "vmchannel%ld", port);
-        vmc->hd = qemu_chr_open(name, devname, NULL);
-        if (!vmc->hd) {
-            config_error(mon, "could not open vmchannel device '%s'\n",
-                         devname);
-            ret = -1;
-            goto out;
+        if (!slirp_inited) {
+            struct slirp_config_str *config;
+
+            config = qemu_malloc(sizeof(*config));
+            pstrcpy(config->str, sizeof(config->str), p);
+            config->flags = 0;
+            config->next = slirp_configs;
+            slirp_configs = config;
+        } else {
+            vmchannel_init(mon, p);
         }
-        vmc->port = port;
-        slirp_add_exec(3, vmc->hd, 4, port);
-        qemu_chr_add_handlers(vmc->hd, vmchannel_can_read, vmchannel_read,
-                NULL, vmc);
         ret = 0;
     } else
 #endif

net.h

@@ -125,6 +125,9 @@ uint16_t net_checksum_tcpudp(uint16_t length, uint16_t proto,
 void net_checksum_calculate(uint8_t *data, int length);
 
 /* from net.c */
+extern const char *legacy_tftp_prefix;
+extern const char *legacy_bootp_filename;
+
 int net_client_init(Monitor *mon, const char *device, const char *p);
 void net_client_uninit(NICInfo *nd);
 int net_client_parse(const char *str);

qemu-options.hx

@@ -735,13 +735,27 @@ STEXI
 @table @option
 ETEXI
 
+HXCOMM Legacy slirp options (now moved to -net user):
+#ifdef CONFIG_SLIRP
+DEF("tftp", HAS_ARG, QEMU_OPTION_tftp, "")
+DEF("bootp", HAS_ARG, QEMU_OPTION_bootp, "")
+DEF("redir", HAS_ARG, QEMU_OPTION_redir, "")
+#ifndef _WIN32
+DEF("smb", HAS_ARG, QEMU_OPTION_smb, "")
+#endif
+#endif
+
 DEF("net", HAS_ARG, QEMU_OPTION_net,
     "-net nic[,vlan=n][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n"
     "                create a new Network Interface Card and connect it to VLAN 'n'\n"
 #ifdef CONFIG_SLIRP
-    "-net user[,vlan=n][,name=str][,hostname=host]\n"
-    "                connect the user mode network stack to VLAN 'n' and send\n"
-    "                hostname 'host' to DHCP clients\n"
+    "-net user[,vlan=n][,name=str][ip=netaddr][,restrict=y|n][,hostname=host]\n"
+    "         [,tftp=dir][,bootfile=f][,redir=rule][,channel=rule]"
+#ifndef _WIN32
+                                                                  "[,smb=dir]\n"
+#endif
+    "                connect the user mode network stack to VLAN 'n', configure its\n"
+    "                DHCP server and enabled optional services\n"
 #endif
 #ifdef _WIN32
     "-net tap[,vlan=n][,name=str],ifname=name\n"
@@ -794,13 +808,102 @@ Valid values for @var{type} are
 Not all devices are supported on all targets.  Use -net nic,model=?
 for a list of available devices for your target.
 
-@item -net user[,vlan=@var{n}][,hostname=@var{name}][,name=@var{name}]
+@item -net user[,@var{option}][,@var{option}][,...]
 Use the user mode network stack which requires no administrator
-privilege to run.  @option{hostname=name} can be used to specify the client
-hostname reported by the builtin DHCP server.
+privilege to run. Valid options are:
+
+@table @code
+@item vlan=@var{n}
+Connect user mode stack to VLAN @var{n} (@var{n} = 0 is the default).
+
+@item name=@var{name}
+Assign symbolic name for use in monitor commands.
+
+@item ip=@var{netaddr}
+Set IP network address the guest will see (default: 10.0.2.x).
+
+@item restrict=y|yes|n|no
+If this options is enabled, the guest will be isolated, i.e. it will not be
+able to contact the host and no guest IP packets will be routed over the host
+to the outside. This option does not affect explicitly set forwarding rule.
+
+@item hostname=@var{name}
+Specifies the client hostname reported by the builtin DHCP server.
+
+@item tftp=@var{dir}
+When using the user mode network stack, activate a built-in TFTP
+server. The files in @var{dir} will be exposed as the root of a TFTP server.
+The TFTP client on the guest must be configured in binary mode (use the command
+@code{bin} of the Unix TFTP client). The host IP address on the guest is
+10.0.2.2 by default.
+
+@item bootfile=@var{file}
+When using the user mode network stack, broadcast @var{file} as the BOOTP
+filename. In conjunction with @option{tftp}, this can be used to network boot
+a guest from a local directory.
+
+Example (using pxelinux):
+@example
+qemu -hda linux.img -boot n -net user,tftp=/path/to/tftp/files,bootfile=/pxelinux.0
+@end example
+
+@item smb=@var{dir}
+When using the user mode network stack, activate a built-in SMB
+server so that Windows OSes can access to the host files in @file{@var{dir}}
+transparently.
+
+In the guest Windows OS, the line:
+@example
+10.0.2.4 smbserver
+@end example
+must be added in the file @file{C:\WINDOWS\LMHOSTS} (for windows 9x/Me)
+or @file{C:\WINNT\SYSTEM32\DRIVERS\ETC\LMHOSTS} (Windows NT/2000).
+
+Then @file{@var{dir}} can be accessed in @file{\\smbserver\qemu}.
+
+Note that a SAMBA server must be installed on the host OS in
+@file{/usr/sbin/smbd}. QEMU was tested successfully with smbd versions from
+Red Hat 9, Fedora Core 3 and OpenSUSE 11.x.
+
+@item redir=[tcp|udp]:@var{host-port}:[@var{guest-host}]:@var{guest-port}
+Redirect incoming TCP or UDP connections to the host port @var{host-port} to
+the guest @var{guest-host} on guest port @var{guest-port}. If @var{guest-host}
+is not specified, its value is 10.0.2.15 (default address given by the built-in
+DHCP server). If no connection type is specified, TCP is used. This option can
+be given multiple times.
+
+For example, to redirect host X11 connection from screen 1 to guest
+screen 0, use the following:
+
+@example
+# on the host
+qemu -net user,redir=tcp:6001::6000 [...]
+# this host xterm should open in the guest X11 server
+xterm -display :1
+@end example
+
+To redirect telnet connections from host port 5555 to telnet port on
+the guest, use the following:
+
+@example
+# on the host
+qemu -net user,redir=tcp:5555::23 [...]
+telnet localhost 5555
+@end example
+
+Then when you use on the host @code{telnet localhost 5555}, you
+connect to the guest telnet server.
 
-@item -net channel,@var{port}:@var{dev}
-Forward @option{user} TCP connection to port @var{port} to character device @var{dev}
+@item channel=@var{port}:@var{dev}
+Forward guest TCP connections to port @var{port} on the host to character
+device @var{dev}. This option can be given multiple times.
+
+@end table
+
+Note: Legacy stand-alone options -tftp, -bootp, -smb and -redir are still
+processed and applied to -net user. Mixing them with the new configuration
+syntax gives undefined results. Their use for new applications is discouraged
+as they will be removed from future versions.
 
 @item -net tap[,vlan=@var{n}][,name=@var{name}][,fd=@var{h}][,ifname=@var{name}][,script=@var{file}][,downscript=@var{dfile}]
 Connect the host TAP network interface @var{name} to VLAN @var{n}, use
@@ -906,96 +1009,6 @@ libpcap, so it can be analyzed with tools such as tcpdump or Wireshark.
 Indicate that no network devices should be configured. It is used to
 override the default configuration (@option{-net nic -net user}) which
 is activated if no @option{-net} options are provided.
-ETEXI
-
-#ifdef CONFIG_SLIRP
-DEF("tftp", HAS_ARG, QEMU_OPTION_tftp, \
-    "-tftp dir       allow tftp access to files in dir [-net user]\n")
-#endif
-STEXI
-@item -tftp @var{dir}
-When using the user mode network stack, activate a built-in TFTP
-server. The files in @var{dir} will be exposed as the root of a TFTP server.
-The TFTP client on the guest must be configured in binary mode (use the command
-@code{bin} of the Unix TFTP client). The host IP address on the guest is as
-usual 10.0.2.2.
-ETEXI
-
-#ifdef CONFIG_SLIRP
-DEF("bootp", HAS_ARG, QEMU_OPTION_bootp, \
-    "-bootp file     advertise file in BOOTP replies\n")
-#endif
-STEXI
-@item -bootp @var{file}
-When using the user mode network stack, broadcast @var{file} as the BOOTP
-filename.  In conjunction with @option{-tftp}, this can be used to network boot
-a guest from a local directory.
-
-Example (using pxelinux):
-@example
-qemu -hda linux.img -boot n -tftp /path/to/tftp/files -bootp /pxelinux.0
-@end example
-ETEXI
-
-#ifndef _WIN32
-DEF("smb", HAS_ARG, QEMU_OPTION_smb, \
-           "-smb dir        allow SMB access to files in 'dir' [-net user]\n")
-#endif
-STEXI
-@item -smb @var{dir}
-When using the user mode network stack, activate a built-in SMB
-server so that Windows OSes can access to the host files in @file{@var{dir}}
-transparently.
-
-In the guest Windows OS, the line:
-@example
-10.0.2.4 smbserver
-@end example
-must be added in the file @file{C:\WINDOWS\LMHOSTS} (for windows 9x/Me)
-or @file{C:\WINNT\SYSTEM32\DRIVERS\ETC\LMHOSTS} (Windows NT/2000).
-
-Then @file{@var{dir}} can be accessed in @file{\\smbserver\qemu}.
-
-Note that a SAMBA server must be installed on the host OS in
-@file{/usr/sbin/smbd}. QEMU was tested successfully with smbd version
-2.2.7a from the Red Hat 9 and version 3.0.10-1.fc3 from Fedora Core 3.
-ETEXI
-
-#ifdef CONFIG_SLIRP
-DEF("redir", HAS_ARG, QEMU_OPTION_redir, \
-    "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n" \
-    "                redirect TCP or UDP connections from host to guest [-net user]\n")
-#endif
-STEXI
-@item -redir [tcp|udp]:@var{host-port}:[@var{guest-host}]:@var{guest-port}
-
-When using the user mode network stack, redirect incoming TCP or UDP
-connections to the host port @var{host-port} to the guest
-@var{guest-host} on guest port @var{guest-port}. If @var{guest-host}
-is not specified, its value is 10.0.2.15 (default address given by the
-built-in DHCP server). If no connection type is specified, TCP is used.
-
-For example, to redirect host X11 connection from screen 1 to guest
-screen 0, use the following:
-
-@example
-# on the host
-qemu -redir tcp:6001::6000 [...]
-# this host xterm should open in the guest X11 server
-xterm -display :1
-@end example
-
-To redirect telnet connections from host port 5555 to telnet port on
-the guest, use the following:
-
-@example
-# on the host
-qemu -redir tcp:5555::23 [...]
-telnet localhost 5555
-@end example
-
-Then when you use on the host @code{telnet localhost 5555}, you
-connect to the guest telnet server.
 
 @end table
 ETEXI

slirp/bootp.c

@@ -38,7 +38,7 @@ typedef struct {
 
 static BOOTPClient bootp_clients[NB_ADDR];
 
-const char *bootp_filename;
+char *bootp_filename;
 
 static const uint8_t rfc1533_cookie[] = { RFC1533_COOKIE };
 

slirp/libslirp.h

@@ -5,7 +5,8 @@
 extern "C" {
 #endif
 
-void slirp_init(int restricted, const char *special_ip);
+void slirp_init(int restricted, const char *special_ip, const char *tftp_path,
+                const char *bootfile);
 
 void slirp_select_fill(int *pnfds,
                        fd_set *readfds, fd_set *writefds, fd_set *xfds);
@@ -24,9 +25,7 @@ int slirp_redir(int is_udp, int host_port,
 int slirp_add_exec(int do_pty, const void *args, int addr_low_byte,
                    int guest_port);
 
-extern const char *tftp_prefix;
 extern char slirp_hostname[33];
-extern const char *bootp_filename;
 
 void slirp_stats(void);
 void slirp_socket_recv(int addr_low_byte, int guest_port, const uint8_t *buf,

slirp/main.h

@@ -46,6 +46,8 @@ extern int tcp_keepintvl;
 extern uint8_t client_ethaddr[6];
 extern const char *slirp_special_ip;
 extern int slirp_restrict;
+extern char *tftp_prefix;
+extern char *bootp_filename;
 
 #define PROTO_SLIP 0x1
 #ifdef USE_PPP

slirp/slirp.c

@@ -171,7 +171,8 @@ static void slirp_cleanup(void)
 static void slirp_state_save(QEMUFile *f, void *opaque);
 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
 
-void slirp_init(int restricted, const char *special_ip)
+void slirp_init(int restricted, const char *special_ip, const char *tftp_path,
+                const char *bootfile)
 {
     //    debug_init("/tmp/slirp.log", DEBUG_DEFAULT);
 
@@ -203,6 +204,17 @@ void slirp_init(int restricted, const char *special_ip)
     if (special_ip)
         slirp_special_ip = special_ip;
 
+    qemu_free(tftp_prefix);
+    tftp_prefix = NULL;
+    if (tftp_path) {
+        tftp_prefix = qemu_strdup(tftp_path);
+    }
+    qemu_free(bootp_filename);
+    bootp_filename = NULL;
+    if (bootfile) {
+        bootp_filename = qemu_strdup(bootfile);
+    }
+
     inet_aton(slirp_special_ip, &special_addr);
     alias_addr.s_addr = special_addr.s_addr | htonl(CTL_ALIAS);
     getouraddr();

slirp/tftp.c

@@ -37,7 +37,7 @@ struct tftp_session {
 
 static struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX];
 
-const char *tftp_prefix;
+char *tftp_prefix;
 
 static void tftp_session_update(struct tftp_session *spt)
 {

vl.c

@@ -5308,14 +5308,14 @@ int main(int argc, char **argv, char **envp)
                 break;
 #ifdef CONFIG_SLIRP
             case QEMU_OPTION_tftp:
-		tftp_prefix = optarg;
+                legacy_tftp_prefix = optarg;
                 break;
             case QEMU_OPTION_bootp:
-                bootp_filename = optarg;
+                legacy_bootp_filename = optarg;
                 break;
 #ifndef _WIN32
             case QEMU_OPTION_smb:
-		net_slirp_smb(optarg);
+                net_slirp_smb(optarg);
                 break;
 #endif
             case QEMU_OPTION_redir: