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
25 #include "qemu/osdep.h"
27 #include "net/slirp.h"
37 #include "monitor/monitor.h"
38 #include "qemu/error-report.h"
39 #include "qemu/sockets.h"
40 #include "slirp/libslirp.h"
41 #include "chardev/char-fe.h"
42 #include "sysemu/sysemu.h"
43 #include "qemu/cutils.h"
44 #include "qapi/error.h"
45 #include "qapi/qmp/qdict.h"
48 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
59 if (len
> buf_size
- 1)
68 /* slirp network adapter */
70 #define SLIRP_CFG_HOSTFWD 1
72 struct slirp_config_str
{
73 struct slirp_config_str
*next
;
80 struct in_addr server
;
85 typedef struct SlirpState
{
87 QTAILQ_ENTRY(SlirpState
) entry
;
89 Notifier poll_notifier
;
90 Notifier exit_notifier
;
97 static struct slirp_config_str
*slirp_configs
;
98 static QTAILQ_HEAD(, SlirpState
) slirp_stacks
=
99 QTAILQ_HEAD_INITIALIZER(slirp_stacks
);
101 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
, Error
**errp
);
102 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
, Error
**errp
);
105 static int slirp_smb(SlirpState
*s
, const char *exported_dir
,
106 struct in_addr vserver_addr
, Error
**errp
);
107 static void slirp_smb_cleanup(SlirpState
*s
);
109 static inline void slirp_smb_cleanup(SlirpState
*s
) { }
112 static ssize_t
net_slirp_send_packet(const void *pkt
, size_t pkt_len
,
115 SlirpState
*s
= opaque
;
117 return qemu_send_packet(&s
->nc
, pkt
, pkt_len
);
120 static ssize_t
net_slirp_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
122 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
124 slirp_input(s
->slirp
, buf
, size
);
129 static void slirp_smb_exit(Notifier
*n
, void *data
)
131 SlirpState
*s
= container_of(n
, SlirpState
, exit_notifier
);
132 slirp_smb_cleanup(s
);
135 static void slirp_free_fwd(gpointer data
)
137 struct GuestFwd
*fwd
= data
;
139 qemu_chr_fe_deinit(&fwd
->hd
, true);
143 static void net_slirp_cleanup(NetClientState
*nc
)
145 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
147 g_slist_free_full(s
->fwd
, slirp_free_fwd
);
148 main_loop_poll_remove_notifier(&s
->poll_notifier
);
149 slirp_cleanup(s
->slirp
);
150 if (s
->exit_notifier
.notify
) {
151 qemu_remove_exit_notifier(&s
->exit_notifier
);
153 slirp_smb_cleanup(s
);
154 QTAILQ_REMOVE(&slirp_stacks
, s
, entry
);
157 static NetClientInfo net_slirp_info
= {
158 .type
= NET_CLIENT_DRIVER_USER
,
159 .size
= sizeof(SlirpState
),
160 .receive
= net_slirp_receive
,
161 .cleanup
= net_slirp_cleanup
,
164 static void net_slirp_guest_error(const char *msg
, void *opaque
)
166 qemu_log_mask(LOG_GUEST_ERROR
, "%s", msg
);
169 static int64_t net_slirp_clock_get_ns(void *opaque
)
171 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
174 static void *net_slirp_timer_new(SlirpTimerCb cb
,
175 void *cb_opaque
, void *opaque
)
177 return timer_new_full(NULL
, QEMU_CLOCK_VIRTUAL
,
178 SCALE_MS
, QEMU_TIMER_ATTR_EXTERNAL
,
182 static void net_slirp_timer_free(void *timer
, void *opaque
)
188 static void net_slirp_timer_mod(void *timer
, int64_t expire_timer
,
191 timer_mod(timer
, expire_timer
);
194 static void net_slirp_register_poll_fd(int fd
, void *opaque
)
196 qemu_fd_register(fd
);
199 static void net_slirp_unregister_poll_fd(int fd
, void *opaque
)
201 /* no qemu_fd_unregister */
204 static void net_slirp_notify(void *opaque
)
209 static const SlirpCb slirp_cb
= {
210 .send_packet
= net_slirp_send_packet
,
211 .guest_error
= net_slirp_guest_error
,
212 .clock_get_ns
= net_slirp_clock_get_ns
,
213 .timer_new
= net_slirp_timer_new
,
214 .timer_free
= net_slirp_timer_free
,
215 .timer_mod
= net_slirp_timer_mod
,
216 .register_poll_fd
= net_slirp_register_poll_fd
,
217 .unregister_poll_fd
= net_slirp_unregister_poll_fd
,
218 .notify
= net_slirp_notify
,
221 static int slirp_poll_to_gio(int events
)
225 if (events
& SLIRP_POLL_IN
) {
228 if (events
& SLIRP_POLL_OUT
) {
231 if (events
& SLIRP_POLL_PRI
) {
234 if (events
& SLIRP_POLL_ERR
) {
237 if (events
& SLIRP_POLL_HUP
) {
244 static int net_slirp_add_poll(int fd
, int events
, void *opaque
)
246 GArray
*pollfds
= opaque
;
249 .events
= slirp_poll_to_gio(events
),
251 int idx
= pollfds
->len
;
252 g_array_append_val(pollfds
, pfd
);
256 static int slirp_gio_to_poll(int events
)
260 if (events
& G_IO_IN
) {
261 ret
|= SLIRP_POLL_IN
;
263 if (events
& G_IO_OUT
) {
264 ret
|= SLIRP_POLL_OUT
;
266 if (events
& G_IO_PRI
) {
267 ret
|= SLIRP_POLL_PRI
;
269 if (events
& G_IO_ERR
) {
270 ret
|= SLIRP_POLL_ERR
;
272 if (events
& G_IO_HUP
) {
273 ret
|= SLIRP_POLL_HUP
;
279 static int net_slirp_get_revents(int idx
, void *opaque
)
281 GArray
*pollfds
= opaque
;
283 return slirp_gio_to_poll(g_array_index(pollfds
, GPollFD
, idx
).revents
);
286 static void net_slirp_poll_notify(Notifier
*notifier
, void *data
)
288 MainLoopPoll
*poll
= data
;
289 SlirpState
*s
= container_of(notifier
, SlirpState
, poll_notifier
);
291 switch (poll
->state
) {
292 case MAIN_LOOP_POLL_FILL
:
293 slirp_pollfds_fill(s
->slirp
, &poll
->timeout
,
294 net_slirp_add_poll
, poll
->pollfds
);
296 case MAIN_LOOP_POLL_OK
:
297 case MAIN_LOOP_POLL_ERR
:
298 slirp_pollfds_poll(s
->slirp
, poll
->state
== MAIN_LOOP_POLL_ERR
,
299 net_slirp_get_revents
, poll
->pollfds
);
302 g_assert_not_reached();
306 static int net_slirp_init(NetClientState
*peer
, const char *model
,
307 const char *name
, int restricted
,
308 bool ipv4
, const char *vnetwork
, const char *vhost
,
309 bool ipv6
, const char *vprefix6
, int vprefix6_len
,
311 const char *vhostname
, const char *tftp_export
,
312 const char *bootfile
, const char *vdhcp_start
,
313 const char *vnameserver
, const char *vnameserver6
,
314 const char *smb_export
, const char *vsmbserver
,
315 const char **dnssearch
, const char *vdomainname
,
316 const char *tftp_server_name
,
319 /* default settings according to historic slirp */
320 struct in_addr net
= { .s_addr
= htonl(0x0a000200) }; /* 10.0.2.0 */
321 struct in_addr mask
= { .s_addr
= htonl(0xffffff00) }; /* 255.255.255.0 */
322 struct in_addr host
= { .s_addr
= htonl(0x0a000202) }; /* 10.0.2.2 */
323 struct in_addr dhcp
= { .s_addr
= htonl(0x0a00020f) }; /* 10.0.2.15 */
324 struct in_addr dns
= { .s_addr
= htonl(0x0a000203) }; /* 10.0.2.3 */
325 struct in6_addr ip6_prefix
;
326 struct in6_addr ip6_host
;
327 struct in6_addr ip6_dns
;
329 struct in_addr smbsrv
= { .s_addr
= 0 };
337 struct slirp_config_str
*config
;
339 if (!ipv4
&& (vnetwork
|| vhost
|| vnameserver
)) {
340 error_setg(errp
, "IPv4 disabled but netmask/host/dns provided");
344 if (!ipv6
&& (vprefix6
|| vhost6
|| vnameserver6
)) {
345 error_setg(errp
, "IPv6 disabled but prefix/host6/dns6 provided");
349 if (!ipv4
&& !ipv6
) {
350 /* It doesn't make sense to disable both */
351 error_setg(errp
, "IPv4 and IPv6 disabled");
356 if (get_str_sep(buf
, sizeof(buf
), &vnetwork
, '/') < 0) {
357 if (!inet_aton(vnetwork
, &net
)) {
358 error_setg(errp
, "Failed to parse netmask");
361 addr
= ntohl(net
.s_addr
);
362 if (!(addr
& 0x80000000)) {
363 mask
.s_addr
= htonl(0xff000000); /* class A */
364 } else if ((addr
& 0xfff00000) == 0xac100000) {
365 mask
.s_addr
= htonl(0xfff00000); /* priv. 172.16.0.0/12 */
366 } else if ((addr
& 0xc0000000) == 0x80000000) {
367 mask
.s_addr
= htonl(0xffff0000); /* class B */
368 } else if ((addr
& 0xffff0000) == 0xc0a80000) {
369 mask
.s_addr
= htonl(0xffff0000); /* priv. 192.168.0.0/16 */
370 } else if ((addr
& 0xffff0000) == 0xc6120000) {
371 mask
.s_addr
= htonl(0xfffe0000); /* tests 198.18.0.0/15 */
372 } else if ((addr
& 0xe0000000) == 0xe0000000) {
373 mask
.s_addr
= htonl(0xffffff00); /* class C */
375 mask
.s_addr
= htonl(0xfffffff0); /* multicast/reserved */
378 if (!inet_aton(buf
, &net
)) {
379 error_setg(errp
, "Failed to parse netmask");
382 shift
= strtol(vnetwork
, &end
, 10);
384 if (!inet_aton(vnetwork
, &mask
)) {
386 "Failed to parse netmask (trailing chars)");
389 } else if (shift
< 4 || shift
> 32) {
391 "Invalid netmask provided (must be in range 4-32)");
394 mask
.s_addr
= htonl(0xffffffff << (32 - shift
));
397 net
.s_addr
&= mask
.s_addr
;
398 host
.s_addr
= net
.s_addr
| (htonl(0x0202) & ~mask
.s_addr
);
399 dhcp
.s_addr
= net
.s_addr
| (htonl(0x020f) & ~mask
.s_addr
);
400 dns
.s_addr
= net
.s_addr
| (htonl(0x0203) & ~mask
.s_addr
);
403 if (vhost
&& !inet_aton(vhost
, &host
)) {
404 error_setg(errp
, "Failed to parse host");
407 if ((host
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
408 error_setg(errp
, "Host doesn't belong to network");
412 if (vnameserver
&& !inet_aton(vnameserver
, &dns
)) {
413 error_setg(errp
, "Failed to parse DNS");
416 if ((dns
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
417 error_setg(errp
, "DNS doesn't belong to network");
420 if (dns
.s_addr
== host
.s_addr
) {
421 error_setg(errp
, "DNS must be different from host");
425 if (vdhcp_start
&& !inet_aton(vdhcp_start
, &dhcp
)) {
426 error_setg(errp
, "Failed to parse DHCP start address");
429 if ((dhcp
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
430 error_setg(errp
, "DHCP doesn't belong to network");
433 if (dhcp
.s_addr
== host
.s_addr
|| dhcp
.s_addr
== dns
.s_addr
) {
434 error_setg(errp
, "DNS must be different from host and DNS");
439 if (vsmbserver
&& !inet_aton(vsmbserver
, &smbsrv
)) {
440 error_setg(errp
, "Failed to parse SMB address");
448 if (!inet_pton(AF_INET6
, vprefix6
, &ip6_prefix
)) {
449 error_setg(errp
, "Failed to parse IPv6 prefix");
456 if (vprefix6_len
< 0 || vprefix6_len
> 126) {
458 "Invalid prefix provided (prefix len must be in range 0-126");
463 if (!inet_pton(AF_INET6
, vhost6
, &ip6_host
)) {
464 error_setg(errp
, "Failed to parse IPv6 host");
467 if (!in6_equal_net(&ip6_prefix
, &ip6_host
, vprefix6_len
)) {
468 error_setg(errp
, "IPv6 Host doesn't belong to network");
472 ip6_host
= ip6_prefix
;
473 ip6_host
.s6_addr
[15] |= 2;
477 if (!inet_pton(AF_INET6
, vnameserver6
, &ip6_dns
)) {
478 error_setg(errp
, "Failed to parse IPv6 DNS");
481 if (!in6_equal_net(&ip6_prefix
, &ip6_dns
, vprefix6_len
)) {
482 error_setg(errp
, "IPv6 DNS doesn't belong to network");
486 ip6_dns
= ip6_prefix
;
487 ip6_dns
.s6_addr
[15] |= 3;
490 if (vdomainname
&& !*vdomainname
) {
491 error_setg(errp
, "'domainname' parameter cannot be empty");
495 if (vdomainname
&& strlen(vdomainname
) > 255) {
496 error_setg(errp
, "'domainname' parameter cannot exceed 255 bytes");
500 if (vhostname
&& strlen(vhostname
) > 255) {
501 error_setg(errp
, "'vhostname' parameter cannot exceed 255 bytes");
505 if (tftp_server_name
&& strlen(tftp_server_name
) > 255) {
506 error_setg(errp
, "'tftp-server-name' parameter cannot exceed 255 bytes");
510 nc
= qemu_new_net_client(&net_slirp_info
, peer
, model
, name
);
512 snprintf(nc
->info_str
, sizeof(nc
->info_str
),
513 "net=%s,restrict=%s", inet_ntoa(net
),
514 restricted
? "on" : "off");
516 s
= DO_UPCAST(SlirpState
, nc
, nc
);
518 s
->slirp
= slirp_init(restricted
, ipv4
, net
, mask
, host
,
519 ipv6
, ip6_prefix
, vprefix6_len
, ip6_host
,
520 vhostname
, tftp_server_name
,
521 tftp_export
, bootfile
, dhcp
,
522 dns
, ip6_dns
, dnssearch
, vdomainname
,
524 QTAILQ_INSERT_TAIL(&slirp_stacks
, s
, entry
);
526 s
->poll_notifier
.notify
= net_slirp_poll_notify
;
527 main_loop_poll_add_notifier(&s
->poll_notifier
);
529 for (config
= slirp_configs
; config
; config
= config
->next
) {
530 if (config
->flags
& SLIRP_CFG_HOSTFWD
) {
531 if (slirp_hostfwd(s
, config
->str
, errp
) < 0) {
535 if (slirp_guestfwd(s
, config
->str
, errp
) < 0) {
542 if (slirp_smb(s
, smb_export
, smbsrv
, errp
) < 0) {
548 s
->exit_notifier
.notify
= slirp_smb_exit
;
549 qemu_add_exit_notifier(&s
->exit_notifier
);
553 qemu_del_net_client(nc
);
557 static SlirpState
*slirp_lookup(Monitor
*mon
, const char *hub_id
,
563 nc
= net_hub_find_client_by_name(strtol(hub_id
, NULL
, 0), name
);
565 monitor_printf(mon
, "unrecognized (hub-id, stackname) pair\n");
568 warn_report("Using 'hub-id' is deprecated, specify the netdev id "
571 nc
= qemu_find_netdev(name
);
573 monitor_printf(mon
, "unrecognized netdev id '%s'\n", name
);
577 if (strcmp(nc
->model
, "user")) {
578 monitor_printf(mon
, "invalid device specified\n");
581 return DO_UPCAST(SlirpState
, nc
, nc
);
583 if (QTAILQ_EMPTY(&slirp_stacks
)) {
584 monitor_printf(mon
, "user mode network stack not in use\n");
587 return QTAILQ_FIRST(&slirp_stacks
);
591 void hmp_hostfwd_remove(Monitor
*mon
, const QDict
*qdict
)
593 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
596 const char *src_str
, *p
;
600 const char *arg1
= qdict_get_str(qdict
, "arg1");
601 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
602 const char *arg3
= qdict_get_try_str(qdict
, "arg3");
605 s
= slirp_lookup(mon
, arg1
, arg2
);
608 s
= slirp_lookup(mon
, NULL
, arg1
);
611 s
= slirp_lookup(mon
, NULL
, NULL
);
619 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
623 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
625 } else if (!strcmp(buf
, "udp")) {
631 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
634 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
638 if (qemu_strtoi(p
, NULL
, 10, &host_port
)) {
642 err
= slirp_remove_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
);
644 monitor_printf(mon
, "host forwarding rule for %s %s\n", src_str
,
645 err
? "not found" : "removed");
649 monitor_printf(mon
, "invalid format\n");
652 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
, Error
**errp
)
654 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
655 struct in_addr guest_addr
= { .s_addr
= 0 };
656 int host_port
, guest_port
;
661 const char *fail_reason
= "Unknown reason";
664 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
665 fail_reason
= "No : separators";
668 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
670 } else if (!strcmp(buf
, "udp")) {
673 fail_reason
= "Bad protocol name";
677 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
678 fail_reason
= "Missing : separator";
681 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
682 fail_reason
= "Bad host address";
686 if (get_str_sep(buf
, sizeof(buf
), &p
, '-') < 0) {
687 fail_reason
= "Bad host port separator";
690 host_port
= strtol(buf
, &end
, 0);
691 if (*end
!= '\0' || host_port
< 0 || host_port
> 65535) {
692 fail_reason
= "Bad host port";
696 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
697 fail_reason
= "Missing guest address";
700 if (buf
[0] != '\0' && !inet_aton(buf
, &guest_addr
)) {
701 fail_reason
= "Bad guest address";
705 guest_port
= strtol(p
, &end
, 0);
706 if (*end
!= '\0' || guest_port
< 1 || guest_port
> 65535) {
707 fail_reason
= "Bad guest port";
711 if (slirp_add_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
, guest_addr
,
713 error_setg(errp
, "Could not set up host forwarding rule '%s'",
720 error_setg(errp
, "Invalid host forwarding rule '%s' (%s)", redir_str
,
725 void hmp_hostfwd_add(Monitor
*mon
, const QDict
*qdict
)
727 const char *redir_str
;
729 const char *arg1
= qdict_get_str(qdict
, "arg1");
730 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
731 const char *arg3
= qdict_get_try_str(qdict
, "arg3");
734 s
= slirp_lookup(mon
, arg1
, arg2
);
737 s
= slirp_lookup(mon
, NULL
, arg1
);
740 s
= slirp_lookup(mon
, NULL
, NULL
);
745 if (slirp_hostfwd(s
, redir_str
, &err
) < 0) {
746 error_report_err(err
);
754 /* automatic user mode samba server configuration */
755 static void slirp_smb_cleanup(SlirpState
*s
)
760 gchar
*cmd
= g_strdup_printf("rm -rf %s", s
->smb_dir
);
762 if (ret
== -1 || !WIFEXITED(ret
)) {
763 error_report("'%s' failed.", cmd
);
764 } else if (WEXITSTATUS(ret
)) {
765 error_report("'%s' failed. Error code: %d",
766 cmd
, WEXITSTATUS(ret
));
774 static int slirp_smb(SlirpState
* s
, const char *exported_dir
,
775 struct in_addr vserver_addr
, Error
**errp
)
779 struct passwd
*passwd
;
782 passwd
= getpwuid(geteuid());
784 error_setg(errp
, "Failed to retrieve user name");
788 if (access(CONFIG_SMBD_COMMAND
, F_OK
)) {
789 error_setg(errp
, "Could not find '%s', please install it",
790 CONFIG_SMBD_COMMAND
);
794 if (access(exported_dir
, R_OK
| X_OK
)) {
795 error_setg(errp
, "Error accessing shared directory '%s': %s",
796 exported_dir
, strerror(errno
));
800 s
->smb_dir
= g_dir_make_tmp("qemu-smb.XXXXXX", NULL
);
802 error_setg(errp
, "Could not create samba server dir");
805 smb_conf
= g_strdup_printf("%s/%s", s
->smb_dir
, "smb.conf");
807 f
= fopen(smb_conf
, "w");
809 slirp_smb_cleanup(s
);
811 "Could not create samba server configuration file '%s'",
819 "interfaces=127.0.0.1\n"
820 "bind interfaces only=yes\n"
822 "lock directory=%s\n"
823 "state directory=%s\n"
824 "cache directory=%s\n"
825 "ncalrpc dir=%s/ncalrpc\n"
826 "log file=%s/log.smbd\n"
827 "smb passwd file=%s/smbpasswd\n"
829 "map to guest = Bad User\n"
830 "load printers = no\n"
832 "disable spoolss = yes\n"
833 "usershare max shares = 0\n"
852 smb_cmdline
= g_strdup_printf("%s -l %s -s %s",
853 CONFIG_SMBD_COMMAND
, s
->smb_dir
, smb_conf
);
856 if (slirp_add_exec(s
->slirp
, smb_cmdline
, &vserver_addr
, 139) < 0 ||
857 slirp_add_exec(s
->slirp
, smb_cmdline
, &vserver_addr
, 445) < 0) {
858 slirp_smb_cleanup(s
);
860 error_setg(errp
, "Conflicting/invalid smbserver address");
867 #endif /* !defined(_WIN32) */
869 static int guestfwd_can_read(void *opaque
)
871 struct GuestFwd
*fwd
= opaque
;
872 return slirp_socket_can_recv(fwd
->slirp
, fwd
->server
, fwd
->port
);
875 static void guestfwd_read(void *opaque
, const uint8_t *buf
, int size
)
877 struct GuestFwd
*fwd
= opaque
;
878 slirp_socket_recv(fwd
->slirp
, fwd
->server
, fwd
->port
, buf
, size
);
881 static ssize_t
guestfwd_write(const void *buf
, size_t len
, void *chr
)
883 return qemu_chr_fe_write_all(chr
, buf
, len
);
886 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
, Error
**errp
)
888 struct in_addr server
= { .s_addr
= 0 };
889 struct GuestFwd
*fwd
;
896 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
899 if (strcmp(buf
, "tcp") && buf
[0] != '\0') {
902 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
905 if (buf
[0] != '\0' && !inet_aton(buf
, &server
)) {
908 if (get_str_sep(buf
, sizeof(buf
), &p
, '-') < 0) {
911 port
= strtol(buf
, &end
, 10);
912 if (*end
!= '\0' || port
< 1 || port
> 65535) {
916 snprintf(buf
, sizeof(buf
), "guestfwd.tcp.%d", port
);
918 if (g_str_has_prefix(p
, "cmd:")) {
919 if (slirp_add_exec(s
->slirp
, &p
[4], &server
, port
) < 0) {
920 error_setg(errp
, "Conflicting/invalid host:port in guest "
921 "forwarding rule '%s'", config_str
);
927 * FIXME: sure we want to support implicit
928 * muxed monitors here?
930 Chardev
*chr
= qemu_chr_new_mux_mon(buf
, p
, NULL
);
933 error_setg(errp
, "Could not open guest forwarding device '%s'",
938 fwd
= g_new(struct GuestFwd
, 1);
939 qemu_chr_fe_init(&fwd
->hd
, chr
, &err
);
941 error_propagate(errp
, err
);
942 object_unparent(OBJECT(chr
));
947 if (slirp_add_guestfwd(s
->slirp
, guestfwd_write
, &fwd
->hd
,
948 &server
, port
) < 0) {
949 error_setg(errp
, "Conflicting/invalid host:port in guest "
950 "forwarding rule '%s'", config_str
);
951 qemu_chr_fe_deinit(&fwd
->hd
, true);
955 fwd
->server
= server
;
957 fwd
->slirp
= s
->slirp
;
959 qemu_chr_fe_set_handlers(&fwd
->hd
, guestfwd_can_read
, guestfwd_read
,
960 NULL
, NULL
, fwd
, NULL
, true);
961 s
->fwd
= g_slist_append(s
->fwd
, fwd
);
966 error_setg(errp
, "Invalid guest forwarding rule '%s'", config_str
);
970 void hmp_info_usernet(Monitor
*mon
, const QDict
*qdict
)
974 QTAILQ_FOREACH(s
, &slirp_stacks
, entry
) {
976 bool got_hub_id
= net_hub_id_for_client(&s
->nc
, &id
) == 0;
977 char *info
= slirp_connection_info(s
->slirp
);
978 monitor_printf(mon
, "Hub %d (%s):\n%s",
979 got_hub_id
? id
: -1,
986 net_init_slirp_configs(const StringList
*fwd
, int flags
)
989 struct slirp_config_str
*config
;
991 config
= g_malloc0(sizeof(*config
));
992 pstrcpy(config
->str
, sizeof(config
->str
), fwd
->value
->str
);
993 config
->flags
= flags
;
994 config
->next
= slirp_configs
;
995 slirp_configs
= config
;
1001 static const char **slirp_dnssearch(const StringList
*dnsname
)
1003 const StringList
*c
= dnsname
;
1004 size_t i
= 0, num_opts
= 0;
1012 if (num_opts
== 0) {
1016 ret
= g_malloc((num_opts
+ 1) * sizeof(*ret
));
1019 ret
[i
++] = c
->value
->str
;
1026 int net_init_slirp(const Netdev
*netdev
, const char *name
,
1027 NetClientState
*peer
, Error
**errp
)
1029 struct slirp_config_str
*config
;
1032 const NetdevUserOptions
*user
;
1033 const char **dnssearch
;
1034 bool ipv4
= true, ipv6
= true;
1036 assert(netdev
->type
== NET_CLIENT_DRIVER_USER
);
1037 user
= &netdev
->u
.user
;
1039 if ((user
->has_ipv6
&& user
->ipv6
&& !user
->has_ipv4
) ||
1040 (user
->has_ipv4
&& !user
->ipv4
)) {
1043 if ((user
->has_ipv4
&& user
->ipv4
&& !user
->has_ipv6
) ||
1044 (user
->has_ipv6
&& !user
->ipv6
)) {
1048 vnet
= user
->has_net
? g_strdup(user
->net
) :
1049 user
->has_ip
? g_strdup_printf("%s/24", user
->ip
) :
1052 dnssearch
= slirp_dnssearch(user
->dnssearch
);
1054 /* all optional fields are initialized to "all bits zero" */
1056 net_init_slirp_configs(user
->hostfwd
, SLIRP_CFG_HOSTFWD
);
1057 net_init_slirp_configs(user
->guestfwd
, 0);
1059 ret
= net_slirp_init(peer
, "user", name
, user
->q_restrict
,
1060 ipv4
, vnet
, user
->host
,
1061 ipv6
, user
->ipv6_prefix
, user
->ipv6_prefixlen
,
1062 user
->ipv6_host
, user
->hostname
, user
->tftp
,
1063 user
->bootfile
, user
->dhcpstart
,
1064 user
->dns
, user
->ipv6_dns
, user
->smb
,
1065 user
->smbserver
, dnssearch
, user
->domainname
,
1066 user
->tftp_server_name
, errp
);
1068 while (slirp_configs
) {
1069 config
= slirp_configs
;
1070 slirp_configs
= config
->next
;