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"
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"
47 #include "migration/register.h"
48 #include "migration/qemu-file-types.h"
50 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
61 if (len
> buf_size
- 1)
70 /* slirp network adapter */
72 #define SLIRP_CFG_HOSTFWD 1
74 struct slirp_config_str
{
75 struct slirp_config_str
*next
;
82 struct in_addr server
;
87 typedef struct SlirpState
{
89 QTAILQ_ENTRY(SlirpState
) entry
;
91 Notifier poll_notifier
;
92 Notifier exit_notifier
;
99 static struct slirp_config_str
*slirp_configs
;
100 static QTAILQ_HEAD(, SlirpState
) slirp_stacks
=
101 QTAILQ_HEAD_INITIALIZER(slirp_stacks
);
103 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
, Error
**errp
);
104 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
, Error
**errp
);
107 static int slirp_smb(SlirpState
*s
, const char *exported_dir
,
108 struct in_addr vserver_addr
, Error
**errp
);
109 static void slirp_smb_cleanup(SlirpState
*s
);
111 static inline void slirp_smb_cleanup(SlirpState
*s
) { }
114 static ssize_t
net_slirp_send_packet(const void *pkt
, size_t pkt_len
,
117 SlirpState
*s
= opaque
;
119 return qemu_send_packet(&s
->nc
, pkt
, pkt_len
);
122 static ssize_t
net_slirp_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
124 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
126 slirp_input(s
->slirp
, buf
, size
);
131 static void slirp_smb_exit(Notifier
*n
, void *data
)
133 SlirpState
*s
= container_of(n
, SlirpState
, exit_notifier
);
134 slirp_smb_cleanup(s
);
137 static void slirp_free_fwd(gpointer data
)
139 struct GuestFwd
*fwd
= data
;
141 qemu_chr_fe_deinit(&fwd
->hd
, true);
145 static void net_slirp_cleanup(NetClientState
*nc
)
147 SlirpState
*s
= DO_UPCAST(SlirpState
, nc
, nc
);
149 g_slist_free_full(s
->fwd
, slirp_free_fwd
);
150 main_loop_poll_remove_notifier(&s
->poll_notifier
);
151 unregister_savevm(NULL
, "slirp", s
->slirp
);
152 slirp_cleanup(s
->slirp
);
153 if (s
->exit_notifier
.notify
) {
154 qemu_remove_exit_notifier(&s
->exit_notifier
);
156 slirp_smb_cleanup(s
);
157 QTAILQ_REMOVE(&slirp_stacks
, s
, entry
);
160 static NetClientInfo net_slirp_info
= {
161 .type
= NET_CLIENT_DRIVER_USER
,
162 .size
= sizeof(SlirpState
),
163 .receive
= net_slirp_receive
,
164 .cleanup
= net_slirp_cleanup
,
167 static void net_slirp_guest_error(const char *msg
, void *opaque
)
169 qemu_log_mask(LOG_GUEST_ERROR
, "%s", msg
);
172 static int64_t net_slirp_clock_get_ns(void *opaque
)
174 return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
177 static void *net_slirp_timer_new(SlirpTimerCb cb
,
178 void *cb_opaque
, void *opaque
)
180 return timer_new_full(NULL
, QEMU_CLOCK_VIRTUAL
,
181 SCALE_MS
, QEMU_TIMER_ATTR_EXTERNAL
,
185 static void net_slirp_timer_free(void *timer
, void *opaque
)
190 static void net_slirp_timer_mod(void *timer
, int64_t expire_timer
,
193 timer_mod(timer
, expire_timer
);
196 static void net_slirp_register_poll_fd(int fd
, void *opaque
)
198 qemu_fd_register(fd
);
201 static void net_slirp_unregister_poll_fd(int fd
, void *opaque
)
203 /* no qemu_fd_unregister */
206 static void net_slirp_notify(void *opaque
)
211 static const SlirpCb slirp_cb
= {
212 .send_packet
= net_slirp_send_packet
,
213 .guest_error
= net_slirp_guest_error
,
214 .clock_get_ns
= net_slirp_clock_get_ns
,
215 .timer_new
= net_slirp_timer_new
,
216 .timer_free
= net_slirp_timer_free
,
217 .timer_mod
= net_slirp_timer_mod
,
218 .register_poll_fd
= net_slirp_register_poll_fd
,
219 .unregister_poll_fd
= net_slirp_unregister_poll_fd
,
220 .notify
= net_slirp_notify
,
223 static int slirp_poll_to_gio(int events
)
227 if (events
& SLIRP_POLL_IN
) {
230 if (events
& SLIRP_POLL_OUT
) {
233 if (events
& SLIRP_POLL_PRI
) {
236 if (events
& SLIRP_POLL_ERR
) {
239 if (events
& SLIRP_POLL_HUP
) {
246 static int net_slirp_add_poll(int fd
, int events
, void *opaque
)
248 GArray
*pollfds
= opaque
;
251 .events
= slirp_poll_to_gio(events
),
253 int idx
= pollfds
->len
;
254 g_array_append_val(pollfds
, pfd
);
258 static int slirp_gio_to_poll(int events
)
262 if (events
& G_IO_IN
) {
263 ret
|= SLIRP_POLL_IN
;
265 if (events
& G_IO_OUT
) {
266 ret
|= SLIRP_POLL_OUT
;
268 if (events
& G_IO_PRI
) {
269 ret
|= SLIRP_POLL_PRI
;
271 if (events
& G_IO_ERR
) {
272 ret
|= SLIRP_POLL_ERR
;
274 if (events
& G_IO_HUP
) {
275 ret
|= SLIRP_POLL_HUP
;
281 static int net_slirp_get_revents(int idx
, void *opaque
)
283 GArray
*pollfds
= opaque
;
285 return slirp_gio_to_poll(g_array_index(pollfds
, GPollFD
, idx
).revents
);
288 static void net_slirp_poll_notify(Notifier
*notifier
, void *data
)
290 MainLoopPoll
*poll
= data
;
291 SlirpState
*s
= container_of(notifier
, SlirpState
, poll_notifier
);
293 switch (poll
->state
) {
294 case MAIN_LOOP_POLL_FILL
:
295 slirp_pollfds_fill(s
->slirp
, &poll
->timeout
,
296 net_slirp_add_poll
, poll
->pollfds
);
298 case MAIN_LOOP_POLL_OK
:
299 case MAIN_LOOP_POLL_ERR
:
300 slirp_pollfds_poll(s
->slirp
, poll
->state
== MAIN_LOOP_POLL_ERR
,
301 net_slirp_get_revents
, poll
->pollfds
);
304 g_assert_not_reached();
309 net_slirp_stream_read(void *buf
, size_t size
, void *opaque
)
311 QEMUFile
*f
= opaque
;
313 return qemu_get_buffer(f
, buf
, size
);
317 net_slirp_stream_write(const void *buf
, size_t size
, void *opaque
)
319 QEMUFile
*f
= opaque
;
321 qemu_put_buffer(f
, buf
, size
);
322 if (qemu_file_get_error(f
)) {
329 static int net_slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
)
331 Slirp
*slirp
= opaque
;
333 return slirp_state_load(slirp
, version_id
, net_slirp_stream_read
, f
);
336 static void net_slirp_state_save(QEMUFile
*f
, void *opaque
)
338 Slirp
*slirp
= opaque
;
340 slirp_state_save(slirp
, net_slirp_stream_write
, f
);
343 static SaveVMHandlers savevm_slirp_state
= {
344 .save_state
= net_slirp_state_save
,
345 .load_state
= net_slirp_state_load
,
348 static int net_slirp_init(NetClientState
*peer
, const char *model
,
349 const char *name
, int restricted
,
350 bool ipv4
, const char *vnetwork
, const char *vhost
,
351 bool ipv6
, const char *vprefix6
, int vprefix6_len
,
353 const char *vhostname
, const char *tftp_export
,
354 const char *bootfile
, const char *vdhcp_start
,
355 const char *vnameserver
, const char *vnameserver6
,
356 const char *smb_export
, const char *vsmbserver
,
357 const char **dnssearch
, const char *vdomainname
,
358 const char *tftp_server_name
,
361 /* default settings according to historic slirp */
362 struct in_addr net
= { .s_addr
= htonl(0x0a000200) }; /* 10.0.2.0 */
363 struct in_addr mask
= { .s_addr
= htonl(0xffffff00) }; /* 255.255.255.0 */
364 struct in_addr host
= { .s_addr
= htonl(0x0a000202) }; /* 10.0.2.2 */
365 struct in_addr dhcp
= { .s_addr
= htonl(0x0a00020f) }; /* 10.0.2.15 */
366 struct in_addr dns
= { .s_addr
= htonl(0x0a000203) }; /* 10.0.2.3 */
367 struct in6_addr ip6_prefix
;
368 struct in6_addr ip6_host
;
369 struct in6_addr ip6_dns
;
371 struct in_addr smbsrv
= { .s_addr
= 0 };
379 struct slirp_config_str
*config
;
380 NetdevUserOptions
*stored
;
381 StringList
**stored_hostfwd
;
382 StringList
**stored_guestfwd
;
384 if (!ipv4
&& (vnetwork
|| vhost
|| vnameserver
)) {
385 error_setg(errp
, "IPv4 disabled but netmask/host/dns provided");
389 if (!ipv6
&& (vprefix6
|| vhost6
|| vnameserver6
)) {
390 error_setg(errp
, "IPv6 disabled but prefix/host6/dns6 provided");
394 if (!ipv4
&& !ipv6
) {
395 /* It doesn't make sense to disable both */
396 error_setg(errp
, "IPv4 and IPv6 disabled");
401 if (get_str_sep(buf
, sizeof(buf
), &vnetwork
, '/') < 0) {
402 if (!inet_aton(vnetwork
, &net
)) {
403 error_setg(errp
, "Failed to parse netmask");
406 addr
= ntohl(net
.s_addr
);
407 if (!(addr
& 0x80000000)) {
408 mask
.s_addr
= htonl(0xff000000); /* class A */
409 } else if ((addr
& 0xfff00000) == 0xac100000) {
410 mask
.s_addr
= htonl(0xfff00000); /* priv. 172.16.0.0/12 */
411 } else if ((addr
& 0xc0000000) == 0x80000000) {
412 mask
.s_addr
= htonl(0xffff0000); /* class B */
413 } else if ((addr
& 0xffff0000) == 0xc0a80000) {
414 mask
.s_addr
= htonl(0xffff0000); /* priv. 192.168.0.0/16 */
415 } else if ((addr
& 0xffff0000) == 0xc6120000) {
416 mask
.s_addr
= htonl(0xfffe0000); /* tests 198.18.0.0/15 */
417 } else if ((addr
& 0xe0000000) == 0xe0000000) {
418 mask
.s_addr
= htonl(0xffffff00); /* class C */
420 mask
.s_addr
= htonl(0xfffffff0); /* multicast/reserved */
423 if (!inet_aton(buf
, &net
)) {
424 error_setg(errp
, "Failed to parse netmask");
427 shift
= strtol(vnetwork
, &end
, 10);
429 if (!inet_aton(vnetwork
, &mask
)) {
431 "Failed to parse netmask (trailing chars)");
434 } else if (shift
< 4 || shift
> 32) {
436 "Invalid netmask provided (must be in range 4-32)");
439 mask
.s_addr
= htonl(0xffffffff << (32 - shift
));
442 net
.s_addr
&= mask
.s_addr
;
443 host
.s_addr
= net
.s_addr
| (htonl(0x0202) & ~mask
.s_addr
);
444 dhcp
.s_addr
= net
.s_addr
| (htonl(0x020f) & ~mask
.s_addr
);
445 dns
.s_addr
= net
.s_addr
| (htonl(0x0203) & ~mask
.s_addr
);
448 if (vhost
&& !inet_aton(vhost
, &host
)) {
449 error_setg(errp
, "Failed to parse host");
452 if ((host
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
453 error_setg(errp
, "Host doesn't belong to network");
457 if (vnameserver
&& !inet_aton(vnameserver
, &dns
)) {
458 error_setg(errp
, "Failed to parse DNS");
461 if (restricted
&& (dns
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
462 error_setg(errp
, "DNS doesn't belong to network");
465 if (dns
.s_addr
== host
.s_addr
) {
466 error_setg(errp
, "DNS must be different from host");
470 if (vdhcp_start
&& !inet_aton(vdhcp_start
, &dhcp
)) {
471 error_setg(errp
, "Failed to parse DHCP start address");
474 if ((dhcp
.s_addr
& mask
.s_addr
) != net
.s_addr
) {
475 error_setg(errp
, "DHCP doesn't belong to network");
478 if (dhcp
.s_addr
== host
.s_addr
|| dhcp
.s_addr
== dns
.s_addr
) {
479 error_setg(errp
, "DHCP must be different from host and DNS");
484 if (vsmbserver
&& !inet_aton(vsmbserver
, &smbsrv
)) {
485 error_setg(errp
, "Failed to parse SMB address");
493 if (!inet_pton(AF_INET6
, vprefix6
, &ip6_prefix
)) {
494 error_setg(errp
, "Failed to parse IPv6 prefix");
501 if (vprefix6_len
< 0 || vprefix6_len
> 126) {
503 "Invalid IPv6 prefix provided "
504 "(IPv6 prefix length must be between 0 and 126)");
509 if (!inet_pton(AF_INET6
, vhost6
, &ip6_host
)) {
510 error_setg(errp
, "Failed to parse IPv6 host");
513 if (!in6_equal_net(&ip6_prefix
, &ip6_host
, vprefix6_len
)) {
514 error_setg(errp
, "IPv6 Host doesn't belong to network");
518 ip6_host
= ip6_prefix
;
519 ip6_host
.s6_addr
[15] |= 2;
523 if (!inet_pton(AF_INET6
, vnameserver6
, &ip6_dns
)) {
524 error_setg(errp
, "Failed to parse IPv6 DNS");
527 if (restricted
&& !in6_equal_net(&ip6_prefix
, &ip6_dns
, vprefix6_len
)) {
528 error_setg(errp
, "IPv6 DNS doesn't belong to network");
532 ip6_dns
= ip6_prefix
;
533 ip6_dns
.s6_addr
[15] |= 3;
536 if (vdomainname
&& !*vdomainname
) {
537 error_setg(errp
, "'domainname' parameter cannot be empty");
541 if (vdomainname
&& strlen(vdomainname
) > 255) {
542 error_setg(errp
, "'domainname' parameter cannot exceed 255 bytes");
546 if (vhostname
&& strlen(vhostname
) > 255) {
547 error_setg(errp
, "'vhostname' parameter cannot exceed 255 bytes");
551 if (tftp_server_name
&& strlen(tftp_server_name
) > 255) {
552 error_setg(errp
, "'tftp-server-name' parameter cannot exceed 255 bytes");
556 nc
= qemu_new_net_client(&net_slirp_info
, peer
, model
, name
);
558 /* Store startup parameters */
559 nc
->stored_config
= g_new0(NetdevInfo
, 1);
560 nc
->stored_config
->type
= NET_BACKEND_USER
;
561 stored
= &nc
->stored_config
->u
.user
;
564 stored
->has_hostname
= true;
565 stored
->hostname
= g_strdup(vhostname
);
568 stored
->has_q_restrict
= true;
569 stored
->q_restrict
= restricted
;
571 stored
->has_ipv4
= true;
574 stored
->has_ipv6
= true;
578 uint8_t *net_bytes
= (uint8_t *)&net
;
579 uint8_t *mask_bytes
= (uint8_t *)&mask
;
581 stored
->has_net
= true;
582 stored
->net
= g_strdup_printf("%d.%d.%d.%d/%d.%d.%d.%d",
583 net_bytes
[0], net_bytes
[1],
584 net_bytes
[2], net_bytes
[3],
585 mask_bytes
[0], mask_bytes
[1],
586 mask_bytes
[2], mask_bytes
[3]);
588 stored
->has_host
= true;
589 stored
->host
= g_strdup(inet_ntoa(host
));
593 stored
->has_tftp
= true;
594 stored
->tftp
= g_strdup(tftp_export
);
598 stored
->has_bootfile
= true;
599 stored
->bootfile
= g_strdup(bootfile
);
603 stored
->has_dhcpstart
= true;
604 stored
->dhcpstart
= g_strdup(vdhcp_start
);
608 stored
->has_dns
= true;
609 stored
->dns
= g_strdup(inet_ntoa(dns
));
613 stored
->has_dnssearch
= true;
614 StringList
**stored_list
= &stored
->dnssearch
;
616 for (int i
= 0; dnssearch
[i
]; i
++) {
617 String
*element
= g_new0(String
, 1);
619 element
->str
= g_strdup(dnssearch
[i
]);
620 QAPI_LIST_APPEND(stored_list
, element
);
625 stored
->has_domainname
= true;
626 stored
->domainname
= g_strdup(vdomainname
);
630 char addrstr
[INET6_ADDRSTRLEN
];
633 stored
->has_ipv6_prefix
= true;
634 stored
->ipv6_prefix
= g_strdup(vprefix6
);
636 stored
->has_ipv6_prefixlen
= true;
637 stored
->ipv6_prefixlen
= vprefix6_len
;
639 res
= inet_ntop(AF_INET6
, &ip6_host
,
640 addrstr
, sizeof(addrstr
));
642 stored
->has_ipv6_host
= true;
643 stored
->ipv6_host
= g_strdup(res
);
645 res
= inet_ntop(AF_INET6
, &ip6_dns
,
646 addrstr
, sizeof(addrstr
));
648 stored
->has_ipv6_dns
= true;
649 stored
->ipv6_dns
= g_strdup(res
);
653 stored
->has_smb
= true;
654 stored
->smb
= g_strdup(smb_export
);
658 stored
->has_smbserver
= true;
659 stored
->smbserver
= g_strdup(vsmbserver
);
662 if (tftp_server_name
) {
663 stored
->has_tftp_server_name
= true;
664 stored
->tftp_server_name
= g_strdup(tftp_server_name
);
667 s
= DO_UPCAST(SlirpState
, nc
, nc
);
669 s
->slirp
= slirp_init(restricted
, ipv4
, net
, mask
, host
,
670 ipv6
, ip6_prefix
, vprefix6_len
, ip6_host
,
671 vhostname
, tftp_server_name
,
672 tftp_export
, bootfile
, dhcp
,
673 dns
, ip6_dns
, dnssearch
, vdomainname
,
675 QTAILQ_INSERT_TAIL(&slirp_stacks
, s
, entry
);
678 * Make sure the current bitstream version of slirp is 4, to avoid
679 * QEMU migration incompatibilities, if upstream slirp bumped the
682 * FIXME: use bitfields of features? teach libslirp to save with
685 g_assert(slirp_state_version() == 4);
686 register_savevm_live("slirp", 0, slirp_state_version(),
687 &savevm_slirp_state
, s
->slirp
);
689 s
->poll_notifier
.notify
= net_slirp_poll_notify
;
690 main_loop_poll_add_notifier(&s
->poll_notifier
);
692 stored_hostfwd
= &stored
->hostfwd
;
693 stored_guestfwd
= &stored
->guestfwd
;
695 for (config
= slirp_configs
; config
; config
= config
->next
) {
696 String
*element
= g_new0(String
, 1);
698 element
->str
= g_strdup(config
->str
);
699 if (config
->flags
& SLIRP_CFG_HOSTFWD
) {
700 if (slirp_hostfwd(s
, config
->str
, errp
) < 0) {
703 stored
->has_hostfwd
= true;
704 QAPI_LIST_APPEND(stored_hostfwd
, element
);
706 if (slirp_guestfwd(s
, config
->str
, errp
) < 0) {
709 stored
->has_guestfwd
= true;
710 QAPI_LIST_APPEND(stored_guestfwd
, element
);
715 if (slirp_smb(s
, smb_export
, smbsrv
, errp
) < 0) {
721 s
->exit_notifier
.notify
= slirp_smb_exit
;
722 qemu_add_exit_notifier(&s
->exit_notifier
);
726 qemu_del_net_client(nc
);
730 static SlirpState
*slirp_lookup(Monitor
*mon
, const char *id
)
733 NetClientState
*nc
= qemu_find_netdev(id
);
735 monitor_printf(mon
, "unrecognized netdev id '%s'\n", id
);
738 if (strcmp(nc
->model
, "user")) {
739 monitor_printf(mon
, "invalid device specified\n");
742 return DO_UPCAST(SlirpState
, nc
, nc
);
744 if (QTAILQ_EMPTY(&slirp_stacks
)) {
745 monitor_printf(mon
, "user mode network stack not in use\n");
748 return QTAILQ_FIRST(&slirp_stacks
);
752 void hmp_hostfwd_remove(Monitor
*mon
, const QDict
*qdict
)
754 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
757 const char *src_str
, *p
;
761 const char *arg1
= qdict_get_str(qdict
, "arg1");
762 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
765 s
= slirp_lookup(mon
, arg1
);
768 s
= slirp_lookup(mon
, NULL
);
776 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
780 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
782 } else if (!strcmp(buf
, "udp")) {
788 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
791 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
795 if (qemu_strtoi(p
, NULL
, 10, &host_port
)) {
799 err
= slirp_remove_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
);
801 monitor_printf(mon
, "host forwarding rule for %s %s\n", src_str
,
802 err
? "not found" : "removed");
806 monitor_printf(mon
, "invalid format\n");
809 static int slirp_hostfwd(SlirpState
*s
, const char *redir_str
, Error
**errp
)
811 struct in_addr host_addr
= { .s_addr
= INADDR_ANY
};
812 struct in_addr guest_addr
= { .s_addr
= 0 };
813 int host_port
, guest_port
;
818 const char *fail_reason
= "Unknown reason";
821 if (!p
|| get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
822 fail_reason
= "No : separators";
825 if (!strcmp(buf
, "tcp") || buf
[0] == '\0') {
827 } else if (!strcmp(buf
, "udp")) {
830 fail_reason
= "Bad protocol name";
834 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
835 fail_reason
= "Missing : separator";
838 if (buf
[0] != '\0' && !inet_aton(buf
, &host_addr
)) {
839 fail_reason
= "Bad host address";
843 if (get_str_sep(buf
, sizeof(buf
), &p
, '-') < 0) {
844 fail_reason
= "Bad host port separator";
847 host_port
= strtol(buf
, &end
, 0);
848 if (*end
!= '\0' || host_port
< 0 || host_port
> 65535) {
849 fail_reason
= "Bad host port";
853 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
854 fail_reason
= "Missing guest address";
857 if (buf
[0] != '\0' && !inet_aton(buf
, &guest_addr
)) {
858 fail_reason
= "Bad guest address";
862 guest_port
= strtol(p
, &end
, 0);
863 if (*end
!= '\0' || guest_port
< 1 || guest_port
> 65535) {
864 fail_reason
= "Bad guest port";
868 if (slirp_add_hostfwd(s
->slirp
, is_udp
, host_addr
, host_port
, guest_addr
,
870 error_setg(errp
, "Could not set up host forwarding rule '%s'",
877 error_setg(errp
, "Invalid host forwarding rule '%s' (%s)", redir_str
,
882 void hmp_hostfwd_add(Monitor
*mon
, const QDict
*qdict
)
884 const char *redir_str
;
886 const char *arg1
= qdict_get_str(qdict
, "arg1");
887 const char *arg2
= qdict_get_try_str(qdict
, "arg2");
890 s
= slirp_lookup(mon
, arg1
);
893 s
= slirp_lookup(mon
, NULL
);
898 if (slirp_hostfwd(s
, redir_str
, &err
) < 0) {
899 error_report_err(err
);
907 /* automatic user mode samba server configuration */
908 static void slirp_smb_cleanup(SlirpState
*s
)
913 gchar
*cmd
= g_strdup_printf("rm -rf %s", s
->smb_dir
);
915 if (ret
== -1 || !WIFEXITED(ret
)) {
916 error_report("'%s' failed.", cmd
);
917 } else if (WEXITSTATUS(ret
)) {
918 error_report("'%s' failed. Error code: %d",
919 cmd
, WEXITSTATUS(ret
));
927 static int slirp_smb(SlirpState
* s
, const char *exported_dir
,
928 struct in_addr vserver_addr
, Error
**errp
)
932 struct passwd
*passwd
;
935 passwd
= getpwuid(geteuid());
937 error_setg(errp
, "Failed to retrieve user name");
941 if (access(CONFIG_SMBD_COMMAND
, F_OK
)) {
942 error_setg(errp
, "Could not find '%s', please install it",
943 CONFIG_SMBD_COMMAND
);
947 if (access(exported_dir
, R_OK
| X_OK
)) {
948 error_setg(errp
, "Error accessing shared directory '%s': %s",
949 exported_dir
, strerror(errno
));
953 s
->smb_dir
= g_dir_make_tmp("qemu-smb.XXXXXX", NULL
);
955 error_setg(errp
, "Could not create samba server dir");
958 smb_conf
= g_strdup_printf("%s/%s", s
->smb_dir
, "smb.conf");
960 f
= fopen(smb_conf
, "w");
962 slirp_smb_cleanup(s
);
964 "Could not create samba server configuration file '%s'",
972 "interfaces=127.0.0.1\n"
973 "bind interfaces only=yes\n"
975 "lock directory=%s\n"
976 "state directory=%s\n"
977 "cache directory=%s\n"
978 "ncalrpc dir=%s/ncalrpc\n"
979 "log file=%s/log.smbd\n"
980 "smb passwd file=%s/smbpasswd\n"
982 "map to guest = Bad User\n"
983 "load printers = no\n"
985 "disable spoolss = yes\n"
986 "usershare max shares = 0\n"
1005 smb_cmdline
= g_strdup_printf("%s -l %s -s %s",
1006 CONFIG_SMBD_COMMAND
, s
->smb_dir
, smb_conf
);
1009 if (slirp_add_exec(s
->slirp
, smb_cmdline
, &vserver_addr
, 139) < 0 ||
1010 slirp_add_exec(s
->slirp
, smb_cmdline
, &vserver_addr
, 445) < 0) {
1011 slirp_smb_cleanup(s
);
1012 g_free(smb_cmdline
);
1013 error_setg(errp
, "Conflicting/invalid smbserver address");
1016 g_free(smb_cmdline
);
1020 #endif /* !defined(_WIN32) */
1022 static int guestfwd_can_read(void *opaque
)
1024 struct GuestFwd
*fwd
= opaque
;
1025 return slirp_socket_can_recv(fwd
->slirp
, fwd
->server
, fwd
->port
);
1028 static void guestfwd_read(void *opaque
, const uint8_t *buf
, int size
)
1030 struct GuestFwd
*fwd
= opaque
;
1031 slirp_socket_recv(fwd
->slirp
, fwd
->server
, fwd
->port
, buf
, size
);
1034 static ssize_t
guestfwd_write(const void *buf
, size_t len
, void *chr
)
1036 return qemu_chr_fe_write_all(chr
, buf
, len
);
1039 static int slirp_guestfwd(SlirpState
*s
, const char *config_str
, Error
**errp
)
1042 struct in_addr server
= { .s_addr
= 0 };
1043 struct GuestFwd
*fwd
;
1050 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
1053 if (strcmp(buf
, "tcp") && buf
[0] != '\0') {
1056 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0) {
1059 if (buf
[0] != '\0' && !inet_aton(buf
, &server
)) {
1062 if (get_str_sep(buf
, sizeof(buf
), &p
, '-') < 0) {
1065 port
= strtol(buf
, &end
, 10);
1066 if (*end
!= '\0' || port
< 1 || port
> 65535) {
1070 snprintf(buf
, sizeof(buf
), "guestfwd.tcp.%d", port
);
1072 if (g_str_has_prefix(p
, "cmd:")) {
1073 if (slirp_add_exec(s
->slirp
, &p
[4], &server
, port
) < 0) {
1074 error_setg(errp
, "Conflicting/invalid host:port in guest "
1075 "forwarding rule '%s'", config_str
);
1081 * FIXME: sure we want to support implicit
1082 * muxed monitors here?
1084 Chardev
*chr
= qemu_chr_new_mux_mon(buf
, p
, NULL
);
1087 error_setg(errp
, "Could not open guest forwarding device '%s'",
1092 fwd
= g_new(struct GuestFwd
, 1);
1093 qemu_chr_fe_init(&fwd
->hd
, chr
, &err
);
1095 error_propagate(errp
, err
);
1096 object_unparent(OBJECT(chr
));
1101 if (slirp_add_guestfwd(s
->slirp
, guestfwd_write
, &fwd
->hd
,
1102 &server
, port
) < 0) {
1103 error_setg(errp
, "Conflicting/invalid host:port in guest "
1104 "forwarding rule '%s'", config_str
);
1105 qemu_chr_fe_deinit(&fwd
->hd
, true);
1109 fwd
->server
= server
;
1111 fwd
->slirp
= s
->slirp
;
1113 qemu_chr_fe_set_handlers(&fwd
->hd
, guestfwd_can_read
, guestfwd_read
,
1114 NULL
, NULL
, fwd
, NULL
, true);
1115 s
->fwd
= g_slist_append(s
->fwd
, fwd
);
1120 error_setg(errp
, "Invalid guest forwarding rule '%s'", config_str
);
1124 void hmp_info_usernet(Monitor
*mon
, const QDict
*qdict
)
1128 QTAILQ_FOREACH(s
, &slirp_stacks
, entry
) {
1130 bool got_hub_id
= net_hub_id_for_client(&s
->nc
, &id
) == 0;
1131 char *info
= slirp_connection_info(s
->slirp
);
1132 monitor_printf(mon
, "Hub %d (%s):\n%s",
1133 got_hub_id
? id
: -1,
1140 net_init_slirp_configs(const StringList
*fwd
, int flags
)
1143 struct slirp_config_str
*config
;
1145 config
= g_malloc0(sizeof(*config
));
1146 pstrcpy(config
->str
, sizeof(config
->str
), fwd
->value
->str
);
1147 config
->flags
= flags
;
1148 config
->next
= slirp_configs
;
1149 slirp_configs
= config
;
1155 static const char **slirp_dnssearch(const StringList
*dnsname
)
1157 const StringList
*c
= dnsname
;
1158 size_t i
= 0, num_opts
= 0;
1166 if (num_opts
== 0) {
1170 ret
= g_malloc((num_opts
+ 1) * sizeof(*ret
));
1173 ret
[i
++] = c
->value
->str
;
1180 int net_init_slirp(const Netdev
*netdev
, const char *name
,
1181 NetClientState
*peer
, Error
**errp
)
1183 struct slirp_config_str
*config
;
1186 const NetdevUserOptions
*user
;
1187 const char **dnssearch
;
1188 bool ipv4
= true, ipv6
= true;
1190 assert(netdev
->type
== NET_CLIENT_DRIVER_USER
);
1191 user
= &netdev
->u
.user
;
1193 if ((user
->has_ipv6
&& user
->ipv6
&& !user
->has_ipv4
) ||
1194 (user
->has_ipv4
&& !user
->ipv4
)) {
1197 if ((user
->has_ipv4
&& user
->ipv4
&& !user
->has_ipv6
) ||
1198 (user
->has_ipv6
&& !user
->ipv6
)) {
1202 vnet
= user
->has_net
? g_strdup(user
->net
) :
1203 user
->has_ip
? g_strdup_printf("%s/24", user
->ip
) :
1206 dnssearch
= slirp_dnssearch(user
->dnssearch
);
1208 /* all optional fields are initialized to "all bits zero" */
1210 net_init_slirp_configs(user
->hostfwd
, SLIRP_CFG_HOSTFWD
);
1211 net_init_slirp_configs(user
->guestfwd
, 0);
1213 ret
= net_slirp_init(peer
, "user", name
, user
->q_restrict
,
1214 ipv4
, vnet
, user
->host
,
1215 ipv6
, user
->ipv6_prefix
, user
->ipv6_prefixlen
,
1216 user
->ipv6_host
, user
->hostname
, user
->tftp
,
1217 user
->bootfile
, user
->dhcpstart
,
1218 user
->dns
, user
->ipv6_dns
, user
->smb
,
1219 user
->smbserver
, dnssearch
, user
->domainname
,
1220 user
->tftp_server_name
, errp
);
1222 while (slirp_configs
) {
1223 config
= slirp_configs
;
1224 slirp_configs
= config
->next
;