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
24 #include "qemu/osdep.h"
25 #include "net/slirp.h"
35 #include "monitor/monitor.h"
36 #include "qemu/error-report.h"
37 #include "qemu/sockets.h"
38 #include "slirp/libslirp.h"
39 #include "slirp/ip6.h"
40 #include "sysemu/char.h"
41 #include "qemu/cutils.h"
43 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
54 if (len
> buf_size
- 1)
63 /* slirp network adapter */
65 #define SLIRP_CFG_HOSTFWD 1
66 #define SLIRP_CFG_LEGACY 2
68 struct slirp_config_str
{
69 struct slirp_config_str
*next
;
75 typedef struct SlirpState
{
77 QTAILQ_ENTRY(SlirpState
) entry
;
84 static struct slirp_config_str
*slirp_configs
;
85 const char *legacy_tftp_prefix
;
86 const char *legacy_bootp_filename
;
87 static QTAILQ_HEAD(slirp_stacks
, SlirpState
) slirp_stacks
=
88 QTAILQ_HEAD_INITIALIZER(slirp_stacks
);
90 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
,
92 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
,
96 static const char *legacy_smb_export
;
98 static int slirp_smb(SlirpState
*s
, const char *exported_dir
,
99 struct in_addr vserver_addr
);
100 static void slirp_smb_cleanup(SlirpState
*s
);
102 static inline void slirp_smb_cleanup(SlirpState
*s
) { }
105 void slirp_output(void *opaque
, const uint8_t *pkt
, int pkt_len
)
107 SlirpState
*s
= opaque
;
109 qemu_send_packet(&s
->nc
, pkt
, pkt_len
);
112 static ssize_t
net_slirp_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
114 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
116 slirp_input(s
->slirp
, buf
, size
);
121 static void net_slirp_cleanup(NetClientState
*nc
)
123 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
125 slirp_cleanup(s
->slirp
);
126 slirp_smb_cleanup(s
);
127 QTAILQ_REMOVE(&slirp_stacks
, s
, entry
);
130 static NetClientInfo net_slirp_info
= {
131 .type
= NET_CLIENT_OPTIONS_KIND_USER
,
132 .size
= sizeof(SlirpState
),
133 .receive
= net_slirp_receive
,
134 .cleanup
= net_slirp_cleanup
,
137 static int net_slirp_init(NetClientState
*peer
, const char *model
,
138 const char *name
, int restricted
,
139 const char *vnetwork
, const char *vhost
,
140 const char *vprefix6
, int vprefix6_len
,
142 const char *vhostname
, const char *tftp_export
,
143 const char *bootfile
, const char *vdhcp_start
,
144 const char *vnameserver
, const char *vnameserver6
,
145 const char *smb_export
, const char *vsmbserver
,
146 const char **dnssearch
)
148 /* default settings according to historic slirp */
149 struct in_addr net
= { .s_addr
= htonl(0x0a000200) }; /* 10.0.2.0 */
150 struct in_addr mask
= { .s_addr
= htonl(0xffffff00) }; /* 255.255.255.0 */
151 struct in_addr host
= { .s_addr
= htonl(0x0a000202) }; /* 10.0.2.2 */
152 struct in_addr dhcp
= { .s_addr
= htonl(0x0a00020f) }; /* 10.0.2.15 */
153 struct in_addr dns
= { .s_addr
= htonl(0x0a000203) }; /* 10.0.2.3 */
154 struct in6_addr ip6_prefix
;
155 struct in6_addr ip6_host
;
156 struct in6_addr ip6_dns
;
158 struct in_addr smbsrv
= { .s_addr
= 0 };
166 struct slirp_config_str
*config
;
169 tftp_export
= legacy_tftp_prefix
;
172 bootfile
= legacy_bootp_filename
;
176 if (get_str_sep(buf
, sizeof(buf
), &vnetwork
, '/') < 0) {
177 if (!inet_aton(vnetwork
, &net
)) {
180 addr
= ntohl(net
.s_addr
);
181 if (!(addr
& 0x80000000)) {
182 mask
.s_addr
= htonl(0xff000000); /* class A */
183 } else if ((addr
& 0xfff00000) == 0xac100000) {
184 mask
.s_addr
= htonl(0xfff00000); /* priv. 172.16.0.0/12 */
185 } else if ((addr
& 0xc0000000) == 0x80000000) {
186 mask
.s_addr
= htonl(0xffff0000); /* class B */
187 } else if ((addr
& 0xffff0000) == 0xc0a80000) {
188 mask
.s_addr
= htonl(0xffff0000); /* priv. 192.168.0.0/16 */
189 } else if ((addr
& 0xffff0000) == 0xc6120000) {
190 mask
.s_addr
= htonl(0xfffe0000); /* tests 198.18.0.0/15 */
191 } else if ((addr
& 0xe0000000) == 0xe0000000) {
192 mask
.s_addr
= htonl(0xffffff00); /* class C */
194 mask
.s_addr
= htonl(0xfffffff0); /* multicast/reserved */
197 if (!inet_aton(buf
, &net
)) {
200 shift
= strtol(vnetwork
, &end
, 10);
202 if (!inet_aton(vnetwork
, &mask
)) {
205 } else if (shift
< 4 || shift
> 32) {
208 mask
.s_addr
= htonl(0xffffffff << (32 - shift
));
211 net
.s_addr
&= mask
.s_addr
;
212 host
.s_addr
= net
.s_addr
| (htonl(0x0202) & ~mask
.s_addr
);
213 dhcp
.s_addr
= net
.s_addr
| (htonl(0x020f) & ~mask
.s_addr
);
214 dns
.s_addr
= net
.s_addr
| (htonl(0x0203) & ~mask
.s_addr
);
217 if (vhost
&& !inet_aton(vhost
, &host
)) {
220 if ((host
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
224 if (vnameserver
&& !inet_aton(vnameserver
, &dns
)) {
227 if ((dns
.s_addr
& mask
.s_addr
) != net
.s_addr
||
228 dns
.s_addr
== host
.s_addr
) {
232 if (vdhcp_start
&& !inet_aton(vdhcp_start
, &dhcp
)) {
235 if ((dhcp
.s_addr
& mask
.s_addr
) != net
.s_addr
||
236 dhcp
.s_addr
== host
.s_addr
|| dhcp
.s_addr
== dns
.s_addr
) {
241 if (vsmbserver
&& !inet_aton(vsmbserver
, &smbsrv
)) {
246 #if defined(_WIN32) && (_WIN32_WINNT < 0x0600)
247 /* No inet_pton helper before Vista... */
252 memset(&ip6_prefix
, 0, sizeof(ip6_prefix
));
253 ip6_prefix
.s6_addr
[0] = 0xfe;
254 ip6_prefix
.s6_addr
[1] = 0xc0;
259 if (!inet_pton(AF_INET6
, vprefix6
, &ip6_prefix
)) {
267 if (vprefix6_len
< 0 || vprefix6_len
> 126) {
272 #if defined(_WIN32) && (_WIN32_WINNT < 0x0600)
275 if (!inet_pton(AF_INET6
, vhost6
, &ip6_host
)) {
278 if (!in6_equal_net(&ip6_prefix
, &ip6_host
, vprefix6_len
)) {
283 ip6_host
= ip6_prefix
;
284 ip6_host
.s6_addr
[15] |= 2;
288 #if defined(_WIN32) && (_WIN32_WINNT < 0x0600)
291 if (!inet_pton(AF_INET6
, vnameserver6
, &ip6_dns
)) {
294 if (!in6_equal_net(&ip6_prefix
, &ip6_dns
, vprefix6_len
)) {
299 ip6_dns
= ip6_prefix
;
300 ip6_dns
.s6_addr
[15] |= 3;
304 nc
= qemu_new_net_client(&net_slirp_info
, peer
, model
, name
);
306 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
307 "net=%s,restrict=%s", inet_ntoa(net
),
308 restricted
? "on" : "off");
310 s
= DO_UPCAST(SlirpState
, nc
, nc
);
312 s
->slirp
= slirp_init(restricted
, net
, mask
, host
,
313 ip6_prefix
, vprefix6_len
, ip6_host
,
314 vhostname
, tftp_export
, bootfile
, dhcp
,
315 dns
, ip6_dns
, dnssearch
, s
);
316 QTAILQ_INSERT_TAIL(&slirp_stacks
, s
, entry
);
318 for (config
= slirp_configs
; config
; config
= config
->next
) {
319 if (config
->flags
& SLIRP_CFG_HOSTFWD
) {
320 if (slirp_hostfwd(s
, config
->str
,
321 config
->flags
& SLIRP_CFG_LEGACY
) < 0)
324 if (slirp_guestfwd(s
, config
->str
,
325 config
->flags
& SLIRP_CFG_LEGACY
) < 0)
331 smb_export
= legacy_smb_export
;
334 if (slirp_smb(s
, smb_export
, smbsrv
) < 0)
342 qemu_del_net_client(nc
);
346 static SlirpState
*slirp_lookup(Monitor
*mon
, const char *vlan
,
352 nc
= net_hub_find_client_by_name(strtol(vlan
, NULL
, 0), stack
);
354 monitor_printf(mon
, "unrecognized (vlan-id, stackname) pair\n");
357 if (strcmp(nc
->model
, "user")) {
358 monitor_printf(mon
, "invalid device specified\n");
361 return DO_UPCAST(SlirpState
, nc
, nc
);
363 if (QTAILQ_EMPTY(&slirp_stacks
)) {
364 monitor_printf(mon
, "user mode network stack not in use\n");
367 return QTAILQ_FIRST(&slirp_stacks
);
371 void hmp_hostfwd_remove(Monitor
*mon
, const QDict
*qdict
)
373 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
376 const char *src_str
, *p
;
380 const char *arg1
= qdict_get_str(qdict
, "arg1");
381 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
382 const char *arg3
= qdict_get_try_str(qdict
, "arg3");
385 s
= slirp_lookup(mon
, arg1
, arg2
);
388 s
= slirp_lookup(mon
, NULL
, NULL
);
396 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
400 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
402 } else if (!strcmp(buf
, "udp")) {
408 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
411 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
417 err
= slirp_remove_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
);
419 monitor_printf(mon
, "host forwarding rule for %s %s\n", src_str
,
420 err
? "not found" : "removed");
424 monitor_printf(mon
, "invalid format\n");
427 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
,
430 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
431 struct in_addr guest_addr
= { .s_addr
= 0 };
432 int host_port
, guest_port
;
439 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
442 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
444 } else if (!strcmp(buf
, "udp")) {
450 if (!legacy_format
) {
451 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
454 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
459 if (get_str_sep(buf
, sizeof(buf
), &p
, legacy_format
? ':' : '-') < 0) {
462 host_port
= strtol(buf
, &end
, 0);
463 if (*end
!= '\0' || host_port
< 1 || host_port
> 65535) {
467 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
470 if (buf
[0] != '\0' && !inet_aton(buf
, &guest_addr
)) {
474 guest_port
= strtol(p
, &end
, 0);
475 if (*end
!= '\0' || guest_port
< 1 || guest_port
> 65535) {
479 if (slirp_add_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
, guest_addr
,
481 error_report("could not set up host forwarding rule '%s'",
488 error_report("invalid host forwarding rule '%s'", redir_str
);
492 void hmp_hostfwd_add(Monitor
*mon
, const QDict
*qdict
)
494 const char *redir_str
;
496 const char *arg1
= qdict_get_str(qdict
, "arg1");
497 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
498 const char *arg3
= qdict_get_try_str(qdict
, "arg3");
501 s
= slirp_lookup(mon
, arg1
, arg2
);
504 s
= slirp_lookup(mon
, NULL
, NULL
);
508 slirp_hostfwd(s
, redir_str
, 0);
513 int net_slirp_redir(const char *redir_str
)
515 struct slirp_config_str
*config
;
517 if (QTAILQ_EMPTY(&slirp_stacks
)) {
518 config
= g_malloc(sizeof(*config
));
519 pstrcpy(config
->str
, sizeof(config
->str
), redir_str
);
520 config
->flags
= SLIRP_CFG_HOSTFWD
| SLIRP_CFG_LEGACY
;
521 config
->next
= slirp_configs
;
522 slirp_configs
= config
;
526 return slirp_hostfwd(QTAILQ_FIRST(&slirp_stacks
), redir_str
, 1);
531 /* automatic user mode samba server configuration */
532 static void slirp_smb_cleanup(SlirpState
*s
)
537 if (s
->smb_dir
[0] != '\0') {
538 snprintf(cmd
, sizeof(cmd
), "rm -rf %s", s
->smb_dir
);
540 if (ret
== -1 || !WIFEXITED(ret
)) {
541 error_report("'%s' failed.", cmd
);
542 } else if (WEXITSTATUS(ret
)) {
543 error_report("'%s' failed. Error code: %d",
544 cmd
, WEXITSTATUS(ret
));
546 s
->smb_dir
[0] = '\0';
550 static int slirp_smb(SlirpState
* s
, const char *exported_dir
,
551 struct in_addr vserver_addr
)
554 char smb_cmdline
[128];
555 struct passwd
*passwd
;
558 passwd
= getpwuid(geteuid());
560 error_report("failed to retrieve user name");
564 if (access(CONFIG_SMBD_COMMAND
, F_OK
)) {
565 error_report("could not find '%s', please install it",
566 CONFIG_SMBD_COMMAND
);
570 if (access(exported_dir
, R_OK
| X_OK
)) {
571 error_report("error accessing shared directory '%s': %s",
572 exported_dir
, strerror(errno
));
576 snprintf(s
->smb_dir
, sizeof(s
->smb_dir
), "/tmp/qemu-smb.XXXXXX");
577 if (!mkdtemp(s
->smb_dir
)) {
578 error_report("could not create samba server dir '%s'", s
->smb_dir
);
582 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", s
->smb_dir
, "smb.conf");
584 f
= fopen(smb_conf
, "w");
586 slirp_smb_cleanup(s
);
587 error_report("could not create samba server configuration file '%s'",
594 "interfaces=127.0.0.1\n"
595 "bind interfaces only=yes\n"
597 "lock directory=%s\n"
598 "state directory=%s\n"
599 "cache directory=%s\n"
600 "ncalrpc dir=%s/ncalrpc\n"
601 "log file=%s/log.smbd\n"
602 "smb passwd file=%s/smbpasswd\n"
604 "map to guest = Bad User\n"
605 "load printers = no\n"
607 "disable spoolss = yes\n"
608 "usershare max shares = 0\n"
627 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -l %s -s %s",
628 CONFIG_SMBD_COMMAND
, s
->smb_dir
, smb_conf
);
630 if (slirp_add_exec(s
->slirp
, 0, smb_cmdline
, &vserver_addr
, 139) < 0 ||
631 slirp_add_exec(s
->slirp
, 0, smb_cmdline
, &vserver_addr
, 445) < 0) {
632 slirp_smb_cleanup(s
);
633 error_report("conflicting/invalid smbserver address");
639 /* automatic user mode samba server configuration (legacy interface) */
640 int net_slirp_smb(const char *exported_dir
)
642 struct in_addr vserver_addr
= { .s_addr
= 0 };
644 if (legacy_smb_export
) {
645 fprintf(stderr
, "-smb given twice\n");
648 legacy_smb_export
= exported_dir
;
649 if (!QTAILQ_EMPTY(&slirp_stacks
)) {
650 return slirp_smb(QTAILQ_FIRST(&slirp_stacks
), exported_dir
,
656 #endif /* !defined(_WIN32) */
660 struct in_addr server
;
665 static int guestfwd_can_read(void *opaque
)
667 struct GuestFwd
*fwd
= opaque
;
668 return slirp_socket_can_recv(fwd
->slirp
, fwd
->server
, fwd
->port
);
671 static void guestfwd_read(void *opaque
, const uint8_t *buf
, int size
)
673 struct GuestFwd
*fwd
= opaque
;
674 slirp_socket_recv(fwd
->slirp
, fwd
->server
, fwd
->port
, buf
, size
);
677 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
,
680 struct in_addr server
= { .s_addr
= 0 };
681 struct GuestFwd
*fwd
;
689 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
693 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
696 if (strcmp(buf
, "tcp") && buf
[0] != '\0') {
699 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
702 if (buf
[0] != '\0' && !inet_aton(buf
, &server
)) {
705 if (get_str_sep(buf
, sizeof(buf
), &p
, '-') < 0) {
709 port
= strtol(buf
, &end
, 10);
710 if (*end
!= '\0' || port
< 1 || port
> 65535) {
714 snprintf(buf
, sizeof(buf
), "guestfwd.tcp.%d", port
);
716 if ((strlen(p
) > 4) && !strncmp(p
, "cmd:", 4)) {
717 if (slirp_add_exec(s
->slirp
, 0, &p
[4], &server
, port
) < 0) {
718 error_report("conflicting/invalid host:port in guest forwarding "
719 "rule '%s'", config_str
);
723 fwd
= g_new(struct GuestFwd
, 1);
724 fwd
->hd
= qemu_chr_new(buf
, p
, NULL
);
726 error_report("could not open guest forwarding device '%s'", buf
);
731 if (slirp_add_exec(s
->slirp
, 3, fwd
->hd
, &server
, port
) < 0) {
732 error_report("conflicting/invalid host:port in guest forwarding "
733 "rule '%s'", config_str
);
737 fwd
->server
= server
;
739 fwd
->slirp
= s
->slirp
;
741 qemu_chr_fe_claim_no_fail(fwd
->hd
);
742 qemu_chr_add_handlers(fwd
->hd
, guestfwd_can_read
, guestfwd_read
,
748 error_report("invalid guest forwarding rule '%s'", config_str
);
752 void hmp_info_usernet(Monitor
*mon
, const QDict
*qdict
)
756 QTAILQ_FOREACH(s
, &slirp_stacks
, entry
) {
758 bool got_vlan_id
= net_hub_id_for_client(&s
->nc
, &id
) == 0;
759 monitor_printf(mon
, "VLAN %d (%s):\n",
760 got_vlan_id
? id
: -1,
762 slirp_connection_info(s
->slirp
, mon
);
767 net_init_slirp_configs(const StringList
*fwd
, int flags
)
770 struct slirp_config_str
*config
;
772 config
= g_malloc0(sizeof(*config
));
773 pstrcpy(config
->str
, sizeof(config
->str
), fwd
->value
->str
);
774 config
->flags
= flags
;
775 config
->next
= slirp_configs
;
776 slirp_configs
= config
;
782 static const char **slirp_dnssearch(const StringList
*dnsname
)
784 const StringList
*c
= dnsname
;
785 size_t i
= 0, num_opts
= 0;
797 ret
= g_malloc((num_opts
+ 1) * sizeof(*ret
));
800 ret
[i
++] = c
->value
->str
;
807 int net_init_slirp(const NetClientOptions
*opts
, const char *name
,
808 NetClientState
*peer
, Error
**errp
)
810 /* FIXME error_setg(errp, ...) on failure */
811 struct slirp_config_str
*config
;
814 const NetdevUserOptions
*user
;
815 const char **dnssearch
;
817 assert(opts
->type
== NET_CLIENT_OPTIONS_KIND_USER
);
818 user
= opts
->u
.user
.data
;
820 vnet
= user
->has_net
? g_strdup(user
->net
) :
821 user
->has_ip
? g_strdup_printf("%s/24", user
->ip
) :
824 dnssearch
= slirp_dnssearch(user
->dnssearch
);
826 /* all optional fields are initialized to "all bits zero" */
828 net_init_slirp_configs(user
->hostfwd
, SLIRP_CFG_HOSTFWD
);
829 net_init_slirp_configs(user
->guestfwd
, 0);
831 ret
= net_slirp_init(peer
, "user", name
, user
->q_restrict
, vnet
,
832 user
->host
, user
->ip6_prefix
, user
->ip6_prefixlen
,
833 user
->ip6_host
, user
->hostname
, user
->tftp
,
834 user
->bootfile
, user
->dhcpstart
,
835 user
->dns
, user
->ip6_dns
, user
->smb
,
836 user
->smbserver
, dnssearch
);
838 while (slirp_configs
) {
839 config
= slirp_configs
;
840 slirp_configs
= config
->next
;
850 int net_slirp_parse_legacy(QemuOptsList
*opts_list
, const char *optarg
, int *ret
)
852 if (strcmp(opts_list
->name
, "net") != 0 ||
853 strncmp(optarg
, "channel,", strlen("channel,")) != 0) {
857 error_report("The '-net channel' option is deprecated. "
858 "Please use '-netdev user,guestfwd=...' instead.");
860 /* handle legacy -net channel,port:chr */
861 optarg
+= strlen("channel,");
863 if (QTAILQ_EMPTY(&slirp_stacks
)) {
864 struct slirp_config_str
*config
;
866 config
= g_malloc(sizeof(*config
));
867 pstrcpy(config
->str
, sizeof(config
->str
), optarg
);
868 config
->flags
= SLIRP_CFG_LEGACY
;
869 config
->next
= slirp_configs
;
870 slirp_configs
= config
;
873 *ret
= slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks
), optarg
, 1);