xref: /openbmc/qemu/net/slirp.c (revision d62f4b6d0d9ba92a0fe5dd02e4eba674edffb3e9) 
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
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:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
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
22  * THE SOFTWARE.
23  */
24 
25 #include "qemu/osdep.h"
26 #include "qemu/log.h"
27 #include "net/slirp.h"
28 
29 
30 #if defined(CONFIG_SMBD_COMMAND)
31 #include <pwd.h>
32 #include <sys/wait.h>
33 #endif
34 #include "net/eth.h"
35 #include "net/net.h"
36 #include "clients.h"
37 #include "hub.h"
38 #include "monitor/monitor.h"
39 #include "qemu/error-report.h"
40 #include "qemu/sockets.h"
41 #include <libslirp.h>
42 #include "chardev/char-fe.h"
43 #include "sysemu/sysemu.h"
44 #include "qemu/cutils.h"
45 #include "qapi/error.h"
46 #include "qapi/qmp/qdict.h"
47 #include "util.h"
48 #include "migration/register.h"
49 #include "migration/vmstate.h"
50 #include "migration/qemu-file-types.h"
51 
get_str_sep(char * buf,int buf_size,const char ** pp,int sep)52 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
53 {
54     const char *p, *p1;
55     int len;
56     p = *pp;
57     p1 = strchr(p, sep);
58     if (!p1)
59         return -1;
60     len = p1 - p;
61     p1++;
62     if (buf_size > 0) {
63         if (len > buf_size - 1)
64             len = buf_size - 1;
65         memcpy(buf, p, len);
66         buf[len] = '\0';
67     }
68     *pp = p1;
69     return 0;
70 }
71 
72 /* slirp network adapter */
73 
74 #define SLIRP_CFG_HOSTFWD 1
75 
76 struct slirp_config_str {
77     struct slirp_config_str *next;
78     int flags;
79     char str[1024];
80 };
81 
82 struct GuestFwd {
83     CharBackend hd;
84     struct in_addr server;
85     int port;
86     Slirp *slirp;
87 };
88 
89 typedef struct SlirpState {
90     NetClientState nc;
91     QTAILQ_ENTRY(SlirpState) entry;
92     Slirp *slirp;
93     Notifier poll_notifier;
94     Notifier exit_notifier;
95 #if defined(CONFIG_SMBD_COMMAND)
96     gchar *smb_dir;
97 #endif
98     GSList *fwd;
99 } SlirpState;
100 
101 static struct slirp_config_str *slirp_configs;
102 static QTAILQ_HEAD(, SlirpState) slirp_stacks =
103     QTAILQ_HEAD_INITIALIZER(slirp_stacks);
104 
105 static int slirp_hostfwd(SlirpState *s, const char *redir_str, Error **errp);
106 static int slirp_guestfwd(SlirpState *s, const char *config_str, Error **errp);
107 
108 #if defined(CONFIG_SMBD_COMMAND)
109 static int slirp_smb(SlirpState *s, const char *exported_dir,
110                      struct in_addr vserver_addr, Error **errp);
111 static void slirp_smb_cleanup(SlirpState *s);
112 #else
slirp_smb_cleanup(SlirpState * s)113 static inline void slirp_smb_cleanup(SlirpState *s) { }
114 #endif
115 
net_slirp_send_packet(const void * pkt,size_t pkt_len,void * opaque)116 static ssize_t net_slirp_send_packet(const void *pkt, size_t pkt_len,
117                                      void *opaque)
118 {
119     SlirpState *s = opaque;
120     uint8_t min_pkt[ETH_ZLEN];
121     size_t min_pktsz = sizeof(min_pkt);
122 
123     if (net_peer_needs_padding(&s->nc)) {
124         if (eth_pad_short_frame(min_pkt, &min_pktsz, pkt, pkt_len)) {
125             pkt = min_pkt;
126             pkt_len = min_pktsz;
127         }
128     }
129 
130     return qemu_send_packet(&s->nc, pkt, pkt_len);
131 }
132 
net_slirp_receive(NetClientState * nc,const uint8_t * buf,size_t size)133 static ssize_t net_slirp_receive(NetClientState *nc, const uint8_t *buf, size_t size)
134 {
135     SlirpState *s = DO_UPCAST(SlirpState, nc, nc);
136 
137     slirp_input(s->slirp, buf, size);
138 
139     return size;
140 }
141 
slirp_smb_exit(Notifier * n,void * data)142 static void slirp_smb_exit(Notifier *n, void *data)
143 {
144     SlirpState *s = container_of(n, SlirpState, exit_notifier);
145     slirp_smb_cleanup(s);
146 }
147 
slirp_free_fwd(gpointer data)148 static void slirp_free_fwd(gpointer data)
149 {
150     struct GuestFwd *fwd = data;
151 
152     qemu_chr_fe_deinit(&fwd->hd, true);
153     g_free(data);
154 }
155 
net_slirp_cleanup(NetClientState * nc)156 static void net_slirp_cleanup(NetClientState *nc)
157 {
158     SlirpState *s = DO_UPCAST(SlirpState, nc, nc);
159 
160     g_slist_free_full(s->fwd, slirp_free_fwd);
161     main_loop_poll_remove_notifier(&s->poll_notifier);
162     unregister_savevm(NULL, "slirp", s->slirp);
163     slirp_cleanup(s->slirp);
164     if (s->exit_notifier.notify) {
165         qemu_remove_exit_notifier(&s->exit_notifier);
166     }
167     slirp_smb_cleanup(s);
168     QTAILQ_REMOVE(&slirp_stacks, s, entry);
169 }
170 
171 static NetClientInfo net_slirp_info = {
172     .type = NET_CLIENT_DRIVER_USER,
173     .size = sizeof(SlirpState),
174     .receive = net_slirp_receive,
175     .cleanup = net_slirp_cleanup,
176 };
177 
net_slirp_guest_error(const char * msg,void * opaque)178 static void net_slirp_guest_error(const char *msg, void *opaque)
179 {
180     qemu_log_mask(LOG_GUEST_ERROR, "%s", msg);
181 }
182 
net_slirp_clock_get_ns(void * opaque)183 static int64_t net_slirp_clock_get_ns(void *opaque)
184 {
185     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
186 }
187 
188 typedef struct SlirpTimer SlirpTimer;
189 struct SlirpTimer {
190     QEMUTimer timer;
191 #if SLIRP_CHECK_VERSION(4,7,0)
192     Slirp *slirp;
193     SlirpTimerId id;
194     void *cb_opaque;
195 #endif
196 };
197 
198 #if SLIRP_CHECK_VERSION(4,7,0)
net_slirp_init_completed(Slirp * slirp,void * opaque)199 static void net_slirp_init_completed(Slirp *slirp, void *opaque)
200 {
201     SlirpState *s = opaque;
202     s->slirp = slirp;
203 }
204 
net_slirp_timer_cb(void * opaque)205 static void net_slirp_timer_cb(void *opaque)
206 {
207     SlirpTimer *t = opaque;
208     slirp_handle_timer(t->slirp, t->id, t->cb_opaque);
209 }
210 
net_slirp_timer_new_opaque(SlirpTimerId id,void * cb_opaque,void * opaque)211 static void *net_slirp_timer_new_opaque(SlirpTimerId id,
212                                         void *cb_opaque, void *opaque)
213 {
214     SlirpState *s = opaque;
215     SlirpTimer *t = g_new(SlirpTimer, 1);
216     t->slirp = s->slirp;
217     t->id = id;
218     t->cb_opaque = cb_opaque;
219     timer_init_full(&t->timer, NULL, QEMU_CLOCK_VIRTUAL,
220                     SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
221                     net_slirp_timer_cb, t);
222     return t;
223 }
224 #else
net_slirp_timer_new(SlirpTimerCb cb,void * cb_opaque,void * opaque)225 static void *net_slirp_timer_new(SlirpTimerCb cb,
226                                  void *cb_opaque, void *opaque)
227 {
228     SlirpTimer *t = g_new(SlirpTimer, 1);
229     timer_init_full(&t->timer, NULL, QEMU_CLOCK_VIRTUAL,
230                     SCALE_MS, QEMU_TIMER_ATTR_EXTERNAL,
231                     cb, cb_opaque);
232     return t;
233 }
234 #endif
235 
net_slirp_timer_free(void * timer,void * opaque)236 static void net_slirp_timer_free(void *timer, void *opaque)
237 {
238     SlirpTimer *t = timer;
239     timer_del(&t->timer);
240     g_free(t);
241 }
242 
net_slirp_timer_mod(void * timer,int64_t expire_timer,void * opaque)243 static void net_slirp_timer_mod(void *timer, int64_t expire_timer,
244                                 void *opaque)
245 {
246     SlirpTimer *t = timer;
247     timer_mod(&t->timer, expire_timer);
248 }
249 
250 #if !SLIRP_CHECK_VERSION(4, 9, 0)
251 # define slirp_os_socket int
252 # define slirp_pollfds_fill_socket slirp_pollfds_fill
253 # define register_poll_socket register_poll_fd
254 # define unregister_poll_socket unregister_poll_fd
255 #endif
256 
net_slirp_register_poll_sock(slirp_os_socket fd,void * opaque)257 static void net_slirp_register_poll_sock(slirp_os_socket fd, void *opaque)
258 {
259 #ifdef WIN32
260     AioContext *ctxt = qemu_get_aio_context();
261 
262     if (WSAEventSelect(fd, event_notifier_get_handle(&ctxt->notifier),
263                        FD_READ | FD_ACCEPT | FD_CLOSE |
264                        FD_CONNECT | FD_WRITE | FD_OOB) != 0) {
265         error_setg_win32(&error_warn, WSAGetLastError(), "failed to WSAEventSelect()");
266     }
267 #endif
268 }
269 
net_slirp_unregister_poll_sock(slirp_os_socket fd,void * opaque)270 static void net_slirp_unregister_poll_sock(slirp_os_socket fd, void *opaque)
271 {
272 #ifdef WIN32
273     if (WSAEventSelect(fd, NULL, 0) != 0) {
274         error_setg_win32(&error_warn, WSAGetLastError(), "failed to WSAEventSelect()");
275     }
276 #endif
277 }
278 
net_slirp_notify(void * opaque)279 static void net_slirp_notify(void *opaque)
280 {
281     qemu_notify_event();
282 }
283 
284 static const SlirpCb slirp_cb = {
285     .send_packet = net_slirp_send_packet,
286     .guest_error = net_slirp_guest_error,
287     .clock_get_ns = net_slirp_clock_get_ns,
288 #if SLIRP_CHECK_VERSION(4,7,0)
289     .init_completed = net_slirp_init_completed,
290     .timer_new_opaque = net_slirp_timer_new_opaque,
291 #else
292     .timer_new = net_slirp_timer_new,
293 #endif
294     .timer_free = net_slirp_timer_free,
295     .timer_mod = net_slirp_timer_mod,
296     .register_poll_socket = net_slirp_register_poll_sock,
297     .unregister_poll_socket = net_slirp_unregister_poll_sock,
298     .notify = net_slirp_notify,
299 };
300 
slirp_poll_to_gio(int events)301 static int slirp_poll_to_gio(int events)
302 {
303     int ret = 0;
304 
305     if (events & SLIRP_POLL_IN) {
306         ret |= G_IO_IN;
307     }
308     if (events & SLIRP_POLL_OUT) {
309         ret |= G_IO_OUT;
310     }
311     if (events & SLIRP_POLL_PRI) {
312         ret |= G_IO_PRI;
313     }
314     if (events & SLIRP_POLL_ERR) {
315         ret |= G_IO_ERR;
316     }
317     if (events & SLIRP_POLL_HUP) {
318         ret |= G_IO_HUP;
319     }
320 
321     return ret;
322 }
323 
net_slirp_add_poll(slirp_os_socket fd,int events,void * opaque)324 static int net_slirp_add_poll(slirp_os_socket fd, int events, void *opaque)
325 {
326     GArray *pollfds = opaque;
327     GPollFD pfd = {
328         .fd = fd,
329         .events = slirp_poll_to_gio(events),
330     };
331     int idx = pollfds->len;
332     g_array_append_val(pollfds, pfd);
333     return idx;
334 }
335 
slirp_gio_to_poll(int events)336 static int slirp_gio_to_poll(int events)
337 {
338     int ret = 0;
339 
340     if (events & G_IO_IN) {
341         ret |= SLIRP_POLL_IN;
342     }
343     if (events & G_IO_OUT) {
344         ret |= SLIRP_POLL_OUT;
345     }
346     if (events & G_IO_PRI) {
347         ret |= SLIRP_POLL_PRI;
348     }
349     if (events & G_IO_ERR) {
350         ret |= SLIRP_POLL_ERR;
351     }
352     if (events & G_IO_HUP) {
353         ret |= SLIRP_POLL_HUP;
354     }
355 
356     return ret;
357 }
358 
net_slirp_get_revents(int idx,void * opaque)359 static int net_slirp_get_revents(int idx, void *opaque)
360 {
361     GArray *pollfds = opaque;
362 
363     return slirp_gio_to_poll(g_array_index(pollfds, GPollFD, idx).revents);
364 }
365 
net_slirp_poll_notify(Notifier * notifier,void * data)366 static void net_slirp_poll_notify(Notifier *notifier, void *data)
367 {
368     MainLoopPoll *poll = data;
369     SlirpState *s = container_of(notifier, SlirpState, poll_notifier);
370 
371     switch (poll->state) {
372     case MAIN_LOOP_POLL_FILL:
373         slirp_pollfds_fill_socket(s->slirp, &poll->timeout,
374                                   net_slirp_add_poll, poll->pollfds);
375         break;
376     case MAIN_LOOP_POLL_OK:
377     case MAIN_LOOP_POLL_ERR:
378         slirp_pollfds_poll(s->slirp, poll->state == MAIN_LOOP_POLL_ERR,
379                            net_slirp_get_revents, poll->pollfds);
380         break;
381     default:
382         g_assert_not_reached();
383     }
384 }
385 
386 static ssize_t
net_slirp_stream_read(void * buf,size_t size,void * opaque)387 net_slirp_stream_read(void *buf, size_t size, void *opaque)
388 {
389     QEMUFile *f = opaque;
390 
391     return qemu_get_buffer(f, buf, size);
392 }
393 
394 static ssize_t
net_slirp_stream_write(const void * buf,size_t size,void * opaque)395 net_slirp_stream_write(const void *buf, size_t size, void *opaque)
396 {
397     QEMUFile *f = opaque;
398 
399     qemu_put_buffer(f, buf, size);
400     if (qemu_file_get_error(f)) {
401         return -1;
402     }
403 
404     return size;
405 }
406 
net_slirp_state_load(QEMUFile * f,void * opaque,int version_id)407 static int net_slirp_state_load(QEMUFile *f, void *opaque, int version_id)
408 {
409     Slirp *slirp = opaque;
410 
411     return slirp_state_load(slirp, version_id, net_slirp_stream_read, f);
412 }
413 
net_slirp_state_save(QEMUFile * f,void * opaque)414 static void net_slirp_state_save(QEMUFile *f, void *opaque)
415 {
416     Slirp *slirp = opaque;
417 
418     slirp_state_save(slirp, net_slirp_stream_write, f);
419 }
420 
421 static SaveVMHandlers savevm_slirp_state = {
422     .save_state = net_slirp_state_save,
423     .load_state = net_slirp_state_load,
424 };
425 
net_slirp_init(NetClientState * peer,const char * model,const char * name,int restricted,bool ipv4,const char * vnetwork,const char * vhost,bool ipv6,const char * vprefix6,int vprefix6_len,const char * vhost6,const char * vhostname,const char * tftp_export,const char * bootfile,const char * vdhcp_start,const char * vnameserver,const char * vnameserver6,const char * smb_export,const char * vsmbserver,const char ** dnssearch,const char * vdomainname,const char * tftp_server_name,Error ** errp)426 static int net_slirp_init(NetClientState *peer, const char *model,
427                           const char *name, int restricted,
428                           bool ipv4, const char *vnetwork, const char *vhost,
429                           bool ipv6, const char *vprefix6, int vprefix6_len,
430                           const char *vhost6,
431                           const char *vhostname, const char *tftp_export,
432                           const char *bootfile, const char *vdhcp_start,
433                           const char *vnameserver, const char *vnameserver6,
434                           const char *smb_export, const char *vsmbserver,
435                           const char **dnssearch, const char *vdomainname,
436                           const char *tftp_server_name,
437                           Error **errp)
438 {
439     /* default settings according to historic slirp */
440     struct in_addr net  = { .s_addr = htonl(0x0a000200) }; /* 10.0.2.0 */
441     struct in_addr mask = { .s_addr = htonl(0xffffff00) }; /* 255.255.255.0 */
442     struct in_addr host = { .s_addr = htonl(0x0a000202) }; /* 10.0.2.2 */
443     struct in_addr dhcp = { .s_addr = htonl(0x0a00020f) }; /* 10.0.2.15 */
444     struct in_addr dns  = { .s_addr = htonl(0x0a000203) }; /* 10.0.2.3 */
445     struct in6_addr ip6_prefix;
446     struct in6_addr ip6_host;
447     struct in6_addr ip6_dns;
448 #if defined(CONFIG_SMBD_COMMAND)
449     struct in_addr smbsrv = { .s_addr = 0 };
450 #endif
451     SlirpConfig cfg = { 0 };
452     NetClientState *nc;
453     SlirpState *s;
454     char buf[20];
455     uint32_t addr;
456     int shift;
457     char *end;
458     struct slirp_config_str *config;
459 
460     if (!ipv4 && (vnetwork || vhost || vnameserver)) {
461         error_setg(errp, "IPv4 disabled but netmask/host/dns provided");
462         return -1;
463     }
464 
465     if (!ipv6 && (vprefix6 || vhost6 || vnameserver6)) {
466         error_setg(errp, "IPv6 disabled but prefix/host6/dns6 provided");
467         return -1;
468     }
469 
470     if (!ipv4 && !ipv6) {
471         /* It doesn't make sense to disable both */
472         error_setg(errp, "IPv4 and IPv6 disabled");
473         return -1;
474     }
475 
476     if (vnetwork) {
477         if (get_str_sep(buf, sizeof(buf), &vnetwork, '/') < 0) {
478             if (!inet_aton(vnetwork, &net)) {
479                 error_setg(errp, "Failed to parse netmask");
480                 return -1;
481             }
482             addr = ntohl(net.s_addr);
483             if (!(addr & 0x80000000)) {
484                 mask.s_addr = htonl(0xff000000); /* class A */
485             } else if ((addr & 0xfff00000) == 0xac100000) {
486                 mask.s_addr = htonl(0xfff00000); /* priv. 172.16.0.0/12 */
487             } else if ((addr & 0xc0000000) == 0x80000000) {
488                 mask.s_addr = htonl(0xffff0000); /* class B */
489             } else if ((addr & 0xffff0000) == 0xc0a80000) {
490                 mask.s_addr = htonl(0xffff0000); /* priv. 192.168.0.0/16 */
491             } else if ((addr & 0xffff0000) == 0xc6120000) {
492                 mask.s_addr = htonl(0xfffe0000); /* tests 198.18.0.0/15 */
493             } else if ((addr & 0xe0000000) == 0xe0000000) {
494                 mask.s_addr = htonl(0xffffff00); /* class C */
495             } else {
496                 mask.s_addr = htonl(0xfffffff0); /* multicast/reserved */
497             }
498         } else {
499             if (!inet_aton(buf, &net)) {
500                 error_setg(errp, "Failed to parse netmask");
501                 return -1;
502             }
503             shift = strtol(vnetwork, &end, 10);
504             if (*end != '\0') {
505                 if (!inet_aton(vnetwork, &mask)) {
506                     error_setg(errp,
507                                "Failed to parse netmask (trailing chars)");
508                     return -1;
509                 }
510             } else if (shift < 4 || shift > 32) {
511                 error_setg(errp,
512                            "Invalid netmask provided (must be in range 4-32)");
513                 return -1;
514             } else {
515                 mask.s_addr = htonl(0xffffffff << (32 - shift));
516             }
517         }
518         net.s_addr &= mask.s_addr;
519         host.s_addr = net.s_addr | (htonl(0x0202) & ~mask.s_addr);
520         dhcp.s_addr = net.s_addr | (htonl(0x020f) & ~mask.s_addr);
521         dns.s_addr  = net.s_addr | (htonl(0x0203) & ~mask.s_addr);
522     }
523 
524     if (vhost && !inet_aton(vhost, &host)) {
525         error_setg(errp, "Failed to parse host");
526         return -1;
527     }
528     if ((host.s_addr & mask.s_addr) != net.s_addr) {
529         error_setg(errp, "Host doesn't belong to network");
530         return -1;
531     }
532 
533     if (vnameserver && !inet_aton(vnameserver, &dns)) {
534         error_setg(errp, "Failed to parse DNS");
535         return -1;
536     }
537     if (restricted && (dns.s_addr & mask.s_addr) != net.s_addr) {
538         error_setg(errp, "DNS doesn't belong to network");
539         return -1;
540     }
541     if (dns.s_addr == host.s_addr) {
542         error_setg(errp, "DNS must be different from host");
543         return -1;
544     }
545 
546     if (vdhcp_start && !inet_aton(vdhcp_start, &dhcp)) {
547         error_setg(errp, "Failed to parse DHCP start address");
548         return -1;
549     }
550     if ((dhcp.s_addr & mask.s_addr) != net.s_addr) {
551         error_setg(errp, "DHCP doesn't belong to network");
552         return -1;
553     }
554     if (dhcp.s_addr == host.s_addr || dhcp.s_addr == dns.s_addr) {
555         error_setg(errp, "DHCP must be different from host and DNS");
556         return -1;
557     }
558 
559 #if defined(CONFIG_SMBD_COMMAND)
560     if (vsmbserver && !inet_aton(vsmbserver, &smbsrv)) {
561         error_setg(errp, "Failed to parse SMB address");
562         return -1;
563     }
564 #endif
565 
566     if (!vprefix6) {
567         vprefix6 = "fec0::";
568     }
569     if (!inet_pton(AF_INET6, vprefix6, &ip6_prefix)) {
570         error_setg(errp, "Failed to parse IPv6 prefix");
571         return -1;
572     }
573 
574     if (!vprefix6_len) {
575         vprefix6_len = 64;
576     }
577     if (vprefix6_len < 0 || vprefix6_len > 126) {
578         error_setg(errp,
579                    "Invalid IPv6 prefix provided "
580                    "(IPv6 prefix length must be between 0 and 126)");
581         return -1;
582     }
583 
584     if (vhost6) {
585         if (!inet_pton(AF_INET6, vhost6, &ip6_host)) {
586             error_setg(errp, "Failed to parse IPv6 host");
587             return -1;
588         }
589         if (!in6_equal_net(&ip6_prefix, &ip6_host, vprefix6_len)) {
590             error_setg(errp, "IPv6 Host doesn't belong to network");
591             return -1;
592         }
593     } else {
594         ip6_host = ip6_prefix;
595         ip6_host.s6_addr[15] |= 2;
596     }
597 
598     if (vnameserver6) {
599         if (!inet_pton(AF_INET6, vnameserver6, &ip6_dns)) {
600             error_setg(errp, "Failed to parse IPv6 DNS");
601             return -1;
602         }
603         if (restricted && !in6_equal_net(&ip6_prefix, &ip6_dns, vprefix6_len)) {
604             error_setg(errp, "IPv6 DNS doesn't belong to network");
605             return -1;
606         }
607     } else {
608         ip6_dns = ip6_prefix;
609         ip6_dns.s6_addr[15] |= 3;
610     }
611 
612     if (vdomainname && !*vdomainname) {
613         error_setg(errp, "'domainname' parameter cannot be empty");
614         return -1;
615     }
616 
617     if (vdomainname && strlen(vdomainname) > 255) {
618         error_setg(errp, "'domainname' parameter cannot exceed 255 bytes");
619         return -1;
620     }
621 
622     if (vhostname && strlen(vhostname) > 255) {
623         error_setg(errp, "'vhostname' parameter cannot exceed 255 bytes");
624         return -1;
625     }
626 
627     if (tftp_server_name && strlen(tftp_server_name) > 255) {
628         error_setg(errp, "'tftp-server-name' parameter cannot exceed 255 bytes");
629         return -1;
630     }
631 
632     nc = qemu_new_net_client(&net_slirp_info, peer, model, name);
633 
634     qemu_set_info_str(nc, "net=%s,restrict=%s", inet_ntoa(net),
635                       restricted ? "on" : "off");
636 
637     s = DO_UPCAST(SlirpState, nc, nc);
638 
639     cfg.version =
640          SLIRP_CHECK_VERSION(4, 9, 0) ? 6 :
641          SLIRP_CHECK_VERSION(4, 7, 0) ? 4 : 1;
642     cfg.restricted = restricted;
643     cfg.in_enabled = ipv4;
644     cfg.vnetwork = net;
645     cfg.vnetmask = mask;
646     cfg.vhost = host;
647     cfg.in6_enabled = ipv6;
648     cfg.vprefix_addr6 = ip6_prefix;
649     cfg.vprefix_len = vprefix6_len;
650     cfg.vhost6 = ip6_host;
651     cfg.vhostname = vhostname;
652     cfg.tftp_server_name = tftp_server_name;
653     cfg.tftp_path = tftp_export;
654     cfg.bootfile = bootfile;
655     cfg.vdhcp_start = dhcp;
656     cfg.vnameserver = dns;
657     cfg.vnameserver6 = ip6_dns;
658     cfg.vdnssearch = dnssearch;
659     cfg.vdomainname = vdomainname;
660     s->slirp = slirp_new(&cfg, &slirp_cb, s);
661     QTAILQ_INSERT_TAIL(&slirp_stacks, s, entry);
662 
663     /*
664      * Make sure the current bitstream version of slirp is 4, to avoid
665      * QEMU migration incompatibilities, if upstream slirp bumped the
666      * version.
667      *
668      * FIXME: use bitfields of features? teach libslirp to save with
669      * specific version?
670      */
671     g_assert(slirp_state_version() == 4);
672     register_savevm_live("slirp", VMSTATE_INSTANCE_ID_ANY,
673                          slirp_state_version(), &savevm_slirp_state, s->slirp);
674 
675     s->poll_notifier.notify = net_slirp_poll_notify;
676     main_loop_poll_add_notifier(&s->poll_notifier);
677 
678     for (config = slirp_configs; config; config = config->next) {
679         if (config->flags & SLIRP_CFG_HOSTFWD) {
680             if (slirp_hostfwd(s, config->str, errp) < 0) {
681                 goto error;
682             }
683         } else {
684             if (slirp_guestfwd(s, config->str, errp) < 0) {
685                 goto error;
686             }
687         }
688     }
689 #if defined(CONFIG_SMBD_COMMAND)
690     if (smb_export) {
691         if (slirp_smb(s, smb_export, smbsrv, errp) < 0) {
692             goto error;
693         }
694     }
695 #endif
696 
697     s->exit_notifier.notify = slirp_smb_exit;
698     qemu_add_exit_notifier(&s->exit_notifier);
699     return 0;
700 
701 error:
702     qemu_del_net_client(nc);
703     return -1;
704 }
705 
slirp_lookup(Monitor * mon,const char * id)706 static SlirpState *slirp_lookup(Monitor *mon, const char *id)
707 {
708     if (id) {
709         NetClientState *nc = qemu_find_netdev(id);
710         if (!nc) {
711             monitor_printf(mon, "unrecognized netdev id '%s'\n", id);
712             return NULL;
713         }
714         if (strcmp(nc->model, "user")) {
715             monitor_printf(mon, "invalid device specified\n");
716             return NULL;
717         }
718         return DO_UPCAST(SlirpState, nc, nc);
719     } else {
720         if (QTAILQ_EMPTY(&slirp_stacks)) {
721             monitor_printf(mon, "user mode network stack not in use\n");
722             return NULL;
723         }
724         return QTAILQ_FIRST(&slirp_stacks);
725     }
726 }
727 
hmp_hostfwd_remove(Monitor * mon,const QDict * qdict)728 void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
729 {
730     struct sockaddr_in host_addr = {
731         .sin_family = AF_INET,
732         .sin_addr = {
733             .s_addr = INADDR_ANY,
734         },
735     };
736     int host_port;
737     char buf[256];
738     const char *src_str, *p;
739     SlirpState *s;
740     int is_udp = 0;
741     int err;
742     const char *arg1 = qdict_get_str(qdict, "arg1");
743     const char *arg2 = qdict_get_try_str(qdict, "arg2");
744 
745     if (arg2) {
746         s = slirp_lookup(mon, arg1);
747         src_str = arg2;
748     } else {
749         s = slirp_lookup(mon, NULL);
750         src_str = arg1;
751     }
752     if (!s) {
753         return;
754     }
755 
756     p = src_str;
757     if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
758         goto fail_syntax;
759     }
760 
761     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
762         is_udp = 0;
763     } else if (!strcmp(buf, "udp")) {
764         is_udp = 1;
765     } else {
766         goto fail_syntax;
767     }
768 
769     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
770         goto fail_syntax;
771     }
772     if (buf[0] != '\0' && !inet_aton(buf, &host_addr.sin_addr)) {
773         goto fail_syntax;
774     }
775 
776     if (qemu_strtoi(p, NULL, 10, &host_port)) {
777         goto fail_syntax;
778     }
779     host_addr.sin_port = htons(host_port);
780 
781 #if SLIRP_CHECK_VERSION(4, 5, 0)
782     err = slirp_remove_hostxfwd(s->slirp, (struct sockaddr *) &host_addr,
783             sizeof(host_addr), is_udp ? SLIRP_HOSTFWD_UDP : 0);
784 #else
785     err = slirp_remove_hostfwd(s->slirp, is_udp, host_addr.sin_addr, host_port);
786 #endif
787 
788     monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
789                    err ? "not found" : "removed");
790     return;
791 
792  fail_syntax:
793     monitor_printf(mon, "invalid format\n");
794 }
795 
slirp_hostfwd(SlirpState * s,const char * redir_str,Error ** errp)796 static int slirp_hostfwd(SlirpState *s, const char *redir_str, Error **errp)
797 {
798     struct sockaddr_in host_addr = {
799         .sin_family = AF_INET,
800         .sin_addr = {
801             .s_addr = INADDR_ANY,
802         },
803     };
804     struct sockaddr_in guest_addr = {
805         .sin_family = AF_INET,
806         .sin_addr = {
807             .s_addr = 0,
808         },
809     };
810     int err;
811     int host_port, guest_port;
812     const char *p;
813     char buf[256];
814     int is_udp;
815     const char *end;
816     const char *fail_reason = "Unknown reason";
817 
818     p = redir_str;
819     if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
820         fail_reason = "No : separators";
821         goto fail_syntax;
822     }
823     if (!strcmp(buf, "tcp") || buf[0] == '\0') {
824         is_udp = 0;
825     } else if (!strcmp(buf, "udp")) {
826         is_udp = 1;
827     } else {
828         fail_reason = "Bad protocol name";
829         goto fail_syntax;
830     }
831 
832     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
833         fail_reason = "Missing : separator";
834         goto fail_syntax;
835     }
836     if (buf[0] != '\0' && !inet_aton(buf, &host_addr.sin_addr)) {
837         fail_reason = "Bad host address";
838         goto fail_syntax;
839     }
840 
841     if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
842         fail_reason = "Bad host port separator";
843         goto fail_syntax;
844     }
845     err = qemu_strtoi(buf, &end, 0, &host_port);
846     if (err || host_port < 0 || host_port > 65535) {
847         fail_reason = "Bad host port";
848         goto fail_syntax;
849     }
850     host_addr.sin_port = htons(host_port);
851 
852     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
853         fail_reason = "Missing guest address";
854         goto fail_syntax;
855     }
856     if (buf[0] != '\0' && !inet_aton(buf, &guest_addr.sin_addr)) {
857         fail_reason = "Bad guest address";
858         goto fail_syntax;
859     }
860 
861     err = qemu_strtoi(p, &end, 0, &guest_port);
862     if (err || guest_port < 1 || guest_port > 65535) {
863         fail_reason = "Bad guest port";
864         goto fail_syntax;
865     }
866     guest_addr.sin_port = htons(guest_port);
867 
868 #if SLIRP_CHECK_VERSION(4, 5, 0)
869     err = slirp_add_hostxfwd(s->slirp,
870             (struct sockaddr *) &host_addr, sizeof(host_addr),
871             (struct sockaddr *) &guest_addr, sizeof(guest_addr),
872             is_udp ? SLIRP_HOSTFWD_UDP : 0);
873 #else
874     err = slirp_add_hostfwd(s->slirp, is_udp,
875             host_addr.sin_addr, host_port,
876             guest_addr.sin_addr, guest_port);
877 #endif
878 
879     if (err < 0) {
880         error_setg(errp, "Could not set up host forwarding rule '%s'",
881                    redir_str);
882         return -1;
883     }
884     return 0;
885 
886  fail_syntax:
887     error_setg(errp, "Invalid host forwarding rule '%s' (%s)", redir_str,
888                fail_reason);
889     return -1;
890 }
891 
hmp_hostfwd_add(Monitor * mon,const QDict * qdict)892 void hmp_hostfwd_add(Monitor *mon, const QDict *qdict)
893 {
894     const char *redir_str;
895     SlirpState *s;
896     const char *arg1 = qdict_get_str(qdict, "arg1");
897     const char *arg2 = qdict_get_try_str(qdict, "arg2");
898 
899     if (arg2) {
900         s = slirp_lookup(mon, arg1);
901         redir_str = arg2;
902     } else {
903         s = slirp_lookup(mon, NULL);
904         redir_str = arg1;
905     }
906     if (s) {
907         Error *err = NULL;
908         if (slirp_hostfwd(s, redir_str, &err) < 0) {
909             error_report_err(err);
910         }
911     }
912 
913 }
914 
915 #if defined(CONFIG_SMBD_COMMAND)
916 
917 /* automatic user mode samba server configuration */
slirp_smb_cleanup(SlirpState * s)918 static void slirp_smb_cleanup(SlirpState *s)
919 {
920     int ret;
921 
922     if (s->smb_dir) {
923         gchar *cmd = g_strdup_printf("rm -rf %s", s->smb_dir);
924         ret = system(cmd);
925         if (ret == -1 || !WIFEXITED(ret)) {
926             error_report("'%s' failed.", cmd);
927         } else if (WEXITSTATUS(ret)) {
928             error_report("'%s' failed. Error code: %d",
929                          cmd, WEXITSTATUS(ret));
930         }
931         g_free(cmd);
932         g_free(s->smb_dir);
933         s->smb_dir = NULL;
934     }
935 }
936 
slirp_smb(SlirpState * s,const char * exported_dir,struct in_addr vserver_addr,Error ** errp)937 static int slirp_smb(SlirpState* s, const char *exported_dir,
938                      struct in_addr vserver_addr, Error **errp)
939 {
940     char *smb_conf;
941     char *smb_cmdline;
942     struct passwd *passwd;
943     FILE *f;
944 
945     passwd = getpwuid(geteuid());
946     if (!passwd) {
947         error_setg(errp, "Failed to retrieve user name");
948         return -1;
949     }
950 
951     if (access(CONFIG_SMBD_COMMAND, F_OK)) {
952         error_setg(errp, "Could not find '%s', please install it",
953                    CONFIG_SMBD_COMMAND);
954         return -1;
955     }
956 
957     if (access(exported_dir, R_OK | X_OK)) {
958         error_setg(errp, "Error accessing shared directory '%s': %s",
959                    exported_dir, strerror(errno));
960         return -1;
961     }
962 
963     s->smb_dir = g_dir_make_tmp("qemu-smb.XXXXXX", NULL);
964     if (!s->smb_dir) {
965         error_setg(errp, "Could not create samba server dir");
966         return -1;
967     }
968     smb_conf = g_strdup_printf("%s/%s", s->smb_dir, "smb.conf");
969 
970     f = fopen(smb_conf, "w");
971     if (!f) {
972         slirp_smb_cleanup(s);
973         error_setg(errp,
974                    "Could not create samba server configuration file '%s'",
975                     smb_conf);
976         g_free(smb_conf);
977         return -1;
978     }
979     fprintf(f,
980             "[global]\n"
981             "private dir=%s\n"
982             "interfaces=127.0.0.1\n"
983             "bind interfaces only=yes\n"
984             "pid directory=%s\n"
985             "lock directory=%s\n"
986             "state directory=%s\n"
987             "cache directory=%s\n"
988             "ncalrpc dir=%s/ncalrpc\n"
989             "log file=%s/log.smbd\n"
990             "smb passwd file=%s/smbpasswd\n"
991             "security = user\n"
992             "map to guest = Bad User\n"
993             "load printers = no\n"
994             "printing = bsd\n"
995             "disable spoolss = yes\n"
996             "usershare max shares = 0\n"
997             "[qemu]\n"
998             "path=%s\n"
999             "read only=no\n"
1000             "guest ok=yes\n"
1001             "force user=%s\n",
1002             s->smb_dir,
1003             s->smb_dir,
1004             s->smb_dir,
1005             s->smb_dir,
1006             s->smb_dir,
1007             s->smb_dir,
1008             s->smb_dir,
1009             s->smb_dir,
1010             exported_dir,
1011             passwd->pw_name
1012             );
1013     fclose(f);
1014 
1015     smb_cmdline = g_strdup_printf("%s -l %s -s %s",
1016              CONFIG_SMBD_COMMAND, s->smb_dir, smb_conf);
1017     g_free(smb_conf);
1018 
1019     if (slirp_add_exec(s->slirp, smb_cmdline, &vserver_addr, 139) < 0 ||
1020         slirp_add_exec(s->slirp, smb_cmdline, &vserver_addr, 445) < 0) {
1021         slirp_smb_cleanup(s);
1022         g_free(smb_cmdline);
1023         error_setg(errp, "Conflicting/invalid smbserver address");
1024         return -1;
1025     }
1026     g_free(smb_cmdline);
1027     return 0;
1028 }
1029 
1030 #endif /* defined(CONFIG_SMBD_COMMAND) */
1031 
guestfwd_can_read(void * opaque)1032 static int guestfwd_can_read(void *opaque)
1033 {
1034     struct GuestFwd *fwd = opaque;
1035     return slirp_socket_can_recv(fwd->slirp, fwd->server, fwd->port);
1036 }
1037 
guestfwd_read(void * opaque,const uint8_t * buf,int size)1038 static void guestfwd_read(void *opaque, const uint8_t *buf, int size)
1039 {
1040     struct GuestFwd *fwd = opaque;
1041     slirp_socket_recv(fwd->slirp, fwd->server, fwd->port, buf, size);
1042 }
1043 
guestfwd_write(const void * buf,size_t len,void * chr)1044 static ssize_t guestfwd_write(const void *buf, size_t len, void *chr)
1045 {
1046     return qemu_chr_fe_write_all(chr, buf, len);
1047 }
1048 
slirp_guestfwd(SlirpState * s,const char * config_str,Error ** errp)1049 static int slirp_guestfwd(SlirpState *s, const char *config_str, Error **errp)
1050 {
1051     /* TODO: IPv6 */
1052     struct in_addr server = { .s_addr = 0 };
1053     struct GuestFwd *fwd;
1054     const char *p;
1055     char buf[128];
1056     char *end;
1057     int port;
1058 
1059     p = config_str;
1060     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1061         goto fail_syntax;
1062     }
1063     if (strcmp(buf, "tcp") && buf[0] != '\0') {
1064         goto fail_syntax;
1065     }
1066     if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
1067         goto fail_syntax;
1068     }
1069     if (buf[0] != '\0' && !inet_aton(buf, &server)) {
1070         goto fail_syntax;
1071     }
1072     if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
1073         goto fail_syntax;
1074     }
1075     port = strtol(buf, &end, 10);
1076     if (*end != '\0' || port < 1 || port > 65535) {
1077         goto fail_syntax;
1078     }
1079 
1080     snprintf(buf, sizeof(buf), "guestfwd.tcp.%d", port);
1081 
1082     if (g_str_has_prefix(p, "cmd:")) {
1083         if (slirp_add_exec(s->slirp, &p[4], &server, port) < 0) {
1084             error_setg(errp, "Conflicting/invalid host:port in guest "
1085                        "forwarding rule '%s'", config_str);
1086             return -1;
1087         }
1088     } else {
1089         Error *err = NULL;
1090         /*
1091          * FIXME: sure we want to support implicit
1092          * muxed monitors here?
1093          */
1094         Chardev *chr = qemu_chr_new_mux_mon(buf, p, NULL);
1095 
1096         if (!chr) {
1097             error_setg(errp, "Could not open guest forwarding device '%s'",
1098                        buf);
1099             return -1;
1100         }
1101 
1102         fwd = g_new(struct GuestFwd, 1);
1103         qemu_chr_fe_init(&fwd->hd, chr, &err);
1104         if (err) {
1105             error_propagate(errp, err);
1106             object_unparent(OBJECT(chr));
1107             g_free(fwd);
1108             return -1;
1109         }
1110 
1111         if (slirp_add_guestfwd(s->slirp, guestfwd_write, &fwd->hd,
1112                                &server, port) < 0) {
1113             error_setg(errp, "Conflicting/invalid host:port in guest "
1114                        "forwarding rule '%s'", config_str);
1115             qemu_chr_fe_deinit(&fwd->hd, true);
1116             g_free(fwd);
1117             return -1;
1118         }
1119         fwd->server = server;
1120         fwd->port = port;
1121         fwd->slirp = s->slirp;
1122 
1123         qemu_chr_fe_set_handlers(&fwd->hd, guestfwd_can_read, guestfwd_read,
1124                                  NULL, NULL, fwd, NULL, true);
1125         s->fwd = g_slist_append(s->fwd, fwd);
1126     }
1127     return 0;
1128 
1129  fail_syntax:
1130     error_setg(errp, "Invalid guest forwarding rule '%s'", config_str);
1131     return -1;
1132 }
1133 
hmp_info_usernet(Monitor * mon,const QDict * qdict)1134 void hmp_info_usernet(Monitor *mon, const QDict *qdict)
1135 {
1136     SlirpState *s;
1137 
1138     QTAILQ_FOREACH(s, &slirp_stacks, entry) {
1139         int id;
1140         bool got_hub_id = net_hub_id_for_client(&s->nc, &id) == 0;
1141         char *info = slirp_connection_info(s->slirp);
1142         monitor_printf(mon, "Hub %d (%s):\n%s",
1143                        got_hub_id ? id : -1,
1144                        s->nc.name, info);
1145         g_free(info);
1146     }
1147 }
1148 
1149 static void
net_init_slirp_configs(const StringList * fwd,int flags)1150 net_init_slirp_configs(const StringList *fwd, int flags)
1151 {
1152     while (fwd) {
1153         struct slirp_config_str *config;
1154 
1155         config = g_malloc0(sizeof(*config));
1156         pstrcpy(config->str, sizeof(config->str), fwd->value->str);
1157         config->flags = flags;
1158         config->next = slirp_configs;
1159         slirp_configs = config;
1160 
1161         fwd = fwd->next;
1162     }
1163 }
1164 
slirp_dnssearch(const StringList * dnsname)1165 static const char **slirp_dnssearch(const StringList *dnsname)
1166 {
1167     const StringList *c = dnsname;
1168     size_t i = 0, num_opts = 0;
1169     const char **ret;
1170 
1171     while (c) {
1172         num_opts++;
1173         c = c->next;
1174     }
1175 
1176     if (num_opts == 0) {
1177         return NULL;
1178     }
1179 
1180     ret = g_malloc((num_opts + 1) * sizeof(*ret));
1181     c = dnsname;
1182     while (c) {
1183         ret[i++] = c->value->str;
1184         c = c->next;
1185     }
1186     ret[i] = NULL;
1187     return ret;
1188 }
1189 
net_init_slirp(const Netdev * netdev,const char * name,NetClientState * peer,Error ** errp)1190 int net_init_slirp(const Netdev *netdev, const char *name,
1191                    NetClientState *peer, Error **errp)
1192 {
1193     struct slirp_config_str *config;
1194     char *vnet;
1195     int ret;
1196     const NetdevUserOptions *user;
1197     const char **dnssearch;
1198     bool ipv4 = true, ipv6 = true;
1199 
1200     assert(netdev->type == NET_CLIENT_DRIVER_USER);
1201     user = &netdev->u.user;
1202 
1203     if ((user->has_ipv6 && user->ipv6 && !user->has_ipv4) ||
1204         (user->has_ipv4 && !user->ipv4)) {
1205         ipv4 = 0;
1206     }
1207     if ((user->has_ipv4 && user->ipv4 && !user->has_ipv6) ||
1208         (user->has_ipv6 && !user->ipv6)) {
1209         ipv6 = 0;
1210     }
1211 
1212     vnet = user->net ? g_strdup(user->net) :
1213            user->ip  ? g_strdup_printf("%s/24", user->ip) :
1214            NULL;
1215 
1216     dnssearch = slirp_dnssearch(user->dnssearch);
1217 
1218     /* all optional fields are initialized to "all bits zero" */
1219 
1220     net_init_slirp_configs(user->hostfwd, SLIRP_CFG_HOSTFWD);
1221     net_init_slirp_configs(user->guestfwd, 0);
1222 
1223     ret = net_slirp_init(peer, "user", name, user->q_restrict,
1224                          ipv4, vnet, user->host,
1225                          ipv6, user->ipv6_prefix, user->ipv6_prefixlen,
1226                          user->ipv6_host, user->hostname, user->tftp,
1227                          user->bootfile, user->dhcpstart,
1228                          user->dns, user->ipv6_dns, user->smb,
1229                          user->smbserver, dnssearch, user->domainname,
1230                          user->tftp_server_name, errp);
1231 
1232     while (slirp_configs) {
1233         config = slirp_configs;
1234         slirp_configs = config->next;
1235         g_free(config);
1236     }
1237 
1238     g_free(vnet);
1239     g_free(dnssearch);
1240 
1241     return ret;
1242 }
1243