1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "qemu-common.h"
26#include "qemu/timer.h"
27#include "qemu/error-report.h"
28#include "chardev/char-fe.h"
29#include "migration/register.h"
30#include "slirp.h"
31#include "hw/hw.h"
32#include "qemu/cutils.h"
33
34#ifndef _WIN32
35#include <net/if.h>
36#endif
37
38
39struct in_addr loopback_addr;
40
41unsigned long loopback_mask;
42
43
44static const uint8_t special_ethaddr[ETH_ALEN] = {
45 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
46};
47
48u_int curtime;
49
50static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
51 QTAILQ_HEAD_INITIALIZER(slirp_instances);
52
53static struct in_addr dns_addr;
54#ifndef _WIN32
55static struct in6_addr dns6_addr;
56#endif
57static u_int dns_addr_time;
58#ifndef _WIN32
59static u_int dns6_addr_time;
60#endif
61
62#define TIMEOUT_FAST 2
63#define TIMEOUT_SLOW 499
64
65#define TIMEOUT_DEFAULT 1000
66
67#ifdef _WIN32
68
69int get_dns_addr(struct in_addr *pdns_addr)
70{
71 FIXED_INFO *FixedInfo=NULL;
72 ULONG BufLen;
73 DWORD ret;
74 IP_ADDR_STRING *pIPAddr;
75 struct in_addr tmp_addr;
76
77 if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < TIMEOUT_DEFAULT) {
78 *pdns_addr = dns_addr;
79 return 0;
80 }
81
82 FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
83 BufLen = sizeof(FIXED_INFO);
84
85 if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
86 if (FixedInfo) {
87 GlobalFree(FixedInfo);
88 FixedInfo = NULL;
89 }
90 FixedInfo = GlobalAlloc(GPTR, BufLen);
91 }
92
93 if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
94 printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
95 if (FixedInfo) {
96 GlobalFree(FixedInfo);
97 FixedInfo = NULL;
98 }
99 return -1;
100 }
101
102 pIPAddr = &(FixedInfo->DnsServerList);
103 inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
104 *pdns_addr = tmp_addr;
105 dns_addr = tmp_addr;
106 dns_addr_time = curtime;
107 if (FixedInfo) {
108 GlobalFree(FixedInfo);
109 FixedInfo = NULL;
110 }
111 return 0;
112}
113
114int get_dns6_addr(struct in6_addr *pdns6_addr, uint32_t *scope_id)
115{
116 return -1;
117}
118
119static void winsock_cleanup(void)
120{
121 WSACleanup();
122}
123
124#else
125
126static int get_dns_addr_cached(void *pdns_addr, void *cached_addr,
127 socklen_t addrlen,
128 struct stat *cached_stat, u_int *cached_time)
129{
130 struct stat old_stat;
131 if (curtime - *cached_time < TIMEOUT_DEFAULT) {
132 memcpy(pdns_addr, cached_addr, addrlen);
133 return 0;
134 }
135 old_stat = *cached_stat;
136 if (stat("/etc/resolv.conf", cached_stat) != 0) {
137 return -1;
138 }
139 if (cached_stat->st_dev == old_stat.st_dev
140 && cached_stat->st_ino == old_stat.st_ino
141 && cached_stat->st_size == old_stat.st_size
142 && cached_stat->st_mtime == old_stat.st_mtime) {
143 memcpy(pdns_addr, cached_addr, addrlen);
144 return 0;
145 }
146 return 1;
147}
148
149static int get_dns_addr_resolv_conf(int af, void *pdns_addr, void *cached_addr,
150 socklen_t addrlen, uint32_t *scope_id,
151 u_int *cached_time)
152{
153 char buff[512];
154 char buff2[257];
155 FILE *f;
156 int found = 0;
157 void *tmp_addr = alloca(addrlen);
158 unsigned if_index;
159
160 f = fopen("/etc/resolv.conf", "r");
161 if (!f)
162 return -1;
163
164#ifdef DEBUG
165 fprintf(stderr, "IP address of your DNS(s): ");
166#endif
167 while (fgets(buff, 512, f) != NULL) {
168 if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
169 char *c = strchr(buff2, '%');
170 if (c) {
171 if_index = if_nametoindex(c + 1);
172 *c = '\0';
173 } else {
174 if_index = 0;
175 }
176
177 if (!inet_pton(af, buff2, tmp_addr)) {
178 continue;
179 }
180
181 if (!found) {
182 memcpy(pdns_addr, tmp_addr, addrlen);
183 memcpy(cached_addr, tmp_addr, addrlen);
184 if (scope_id) {
185 *scope_id = if_index;
186 }
187 *cached_time = curtime;
188 }
189#ifdef DEBUG
190 else
191 fprintf(stderr, ", ");
192#endif
193 if (++found > 3) {
194#ifdef DEBUG
195 fprintf(stderr, "(more)");
196#endif
197 break;
198 }
199#ifdef DEBUG
200 else {
201 char s[INET6_ADDRSTRLEN];
202 const char *res = inet_ntop(af, tmp_addr, s, sizeof(s));
203 if (!res) {
204 res = "(string conversion error)";
205 }
206 fprintf(stderr, "%s", res);
207 }
208#endif
209 }
210 }
211 fclose(f);
212 if (!found)
213 return -1;
214 return 0;
215}
216
217int get_dns_addr(struct in_addr *pdns_addr)
218{
219 static struct stat dns_addr_stat;
220
221 if (dns_addr.s_addr != 0) {
222 int ret;
223 ret = get_dns_addr_cached(pdns_addr, &dns_addr, sizeof(dns_addr),
224 &dns_addr_stat, &dns_addr_time);
225 if (ret <= 0) {
226 return ret;
227 }
228 }
229 return get_dns_addr_resolv_conf(AF_INET, pdns_addr, &dns_addr,
230 sizeof(dns_addr), NULL, &dns_addr_time);
231}
232
233int get_dns6_addr(struct in6_addr *pdns6_addr, uint32_t *scope_id)
234{
235 static struct stat dns6_addr_stat;
236
237 if (!in6_zero(&dns6_addr)) {
238 int ret;
239 ret = get_dns_addr_cached(pdns6_addr, &dns6_addr, sizeof(dns6_addr),
240 &dns6_addr_stat, &dns6_addr_time);
241 if (ret <= 0) {
242 return ret;
243 }
244 }
245 return get_dns_addr_resolv_conf(AF_INET6, pdns6_addr, &dns6_addr,
246 sizeof(dns6_addr),
247 scope_id, &dns6_addr_time);
248}
249
250#endif
251
252static void slirp_init_once(void)
253{
254 static int initialized;
255#ifdef _WIN32
256 WSADATA Data;
257#endif
258
259 if (initialized) {
260 return;
261 }
262 initialized = 1;
263
264#ifdef _WIN32
265 WSAStartup(MAKEWORD(2,0), &Data);
266 atexit(winsock_cleanup);
267#endif
268
269 loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
270 loopback_mask = htonl(IN_CLASSA_NET);
271}
272
273static void slirp_state_save(QEMUFile *f, void *opaque);
274static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
275
276static SaveVMHandlers savevm_slirp_state = {
277 .save_state = slirp_state_save,
278 .load_state = slirp_state_load,
279};
280
281Slirp *slirp_init(int restricted, bool in_enabled, struct in_addr vnetwork,
282 struct in_addr vnetmask, struct in_addr vhost,
283 bool in6_enabled,
284 struct in6_addr vprefix_addr6, uint8_t vprefix_len,
285 struct in6_addr vhost6, const char *vhostname,
286 const char *tftp_path, const char *bootfile,
287 struct in_addr vdhcp_start, struct in_addr vnameserver,
288 struct in6_addr vnameserver6, const char **vdnssearch,
289 void *opaque)
290{
291 Slirp *slirp = g_malloc0(sizeof(Slirp));
292
293 slirp_init_once();
294
295 slirp->grand = g_rand_new();
296 slirp->restricted = restricted;
297
298 slirp->in_enabled = in_enabled;
299 slirp->in6_enabled = in6_enabled;
300
301 if_init(slirp);
302 ip_init(slirp);
303 ip6_init(slirp);
304
305
306 m_init(slirp);
307
308 slirp->vnetwork_addr = vnetwork;
309 slirp->vnetwork_mask = vnetmask;
310 slirp->vhost_addr = vhost;
311 slirp->vprefix_addr6 = vprefix_addr6;
312 slirp->vprefix_len = vprefix_len;
313 slirp->vhost_addr6 = vhost6;
314 if (vhostname) {
315 pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
316 vhostname);
317 }
318 slirp->tftp_prefix = g_strdup(tftp_path);
319 slirp->bootp_filename = g_strdup(bootfile);
320 slirp->vdhcp_startaddr = vdhcp_start;
321 slirp->vnameserver_addr = vnameserver;
322 slirp->vnameserver_addr6 = vnameserver6;
323
324 if (vdnssearch) {
325 translate_dnssearch(slirp, vdnssearch);
326 }
327
328 slirp->opaque = opaque;
329
330 register_savevm_live(NULL, "slirp", 0, 4, &savevm_slirp_state, slirp);
331
332 QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
333
334 return slirp;
335}
336
337void slirp_cleanup(Slirp *slirp)
338{
339 QTAILQ_REMOVE(&slirp_instances, slirp, entry);
340
341 unregister_savevm(NULL, "slirp", slirp);
342
343 ip_cleanup(slirp);
344 ip6_cleanup(slirp);
345 m_cleanup(slirp);
346
347 g_rand_free(slirp->grand);
348
349 g_free(slirp->vdnssearch);
350 g_free(slirp->tftp_prefix);
351 g_free(slirp->bootp_filename);
352 g_free(slirp);
353}
354
355#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
356#define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
357
358static void slirp_update_timeout(uint32_t *timeout)
359{
360 Slirp *slirp;
361 uint32_t t;
362
363 if (*timeout <= TIMEOUT_FAST) {
364 return;
365 }
366
367 t = MIN(1000, *timeout);
368
369
370
371
372 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
373 if (slirp->time_fasttimo) {
374 *timeout = TIMEOUT_FAST;
375 return;
376 }
377 if (slirp->do_slowtimo) {
378 t = MIN(TIMEOUT_SLOW, t);
379 }
380 }
381 *timeout = t;
382}
383
384void slirp_pollfds_fill(GArray *pollfds, uint32_t *timeout)
385{
386 Slirp *slirp;
387 struct socket *so, *so_next;
388
389 if (QTAILQ_EMPTY(&slirp_instances)) {
390 return;
391 }
392
393
394
395
396
397 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
398
399
400
401
402 slirp->do_slowtimo = ((slirp->tcb.so_next != &slirp->tcb) ||
403 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
404
405 for (so = slirp->tcb.so_next; so != &slirp->tcb;
406 so = so_next) {
407 int events = 0;
408
409 so_next = so->so_next;
410
411 so->pollfds_idx = -1;
412
413
414
415
416 if (slirp->time_fasttimo == 0 &&
417 so->so_tcpcb->t_flags & TF_DELACK) {
418 slirp->time_fasttimo = curtime;
419 }
420
421
422
423
424
425 if (so->so_state & SS_NOFDREF || so->s == -1) {
426 continue;
427 }
428
429
430
431
432 if (so->so_state & SS_FACCEPTCONN) {
433 GPollFD pfd = {
434 .fd = so->s,
435 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
436 };
437 so->pollfds_idx = pollfds->len;
438 g_array_append_val(pollfds, pfd);
439 continue;
440 }
441
442
443
444
445 if (so->so_state & SS_ISFCONNECTING) {
446 GPollFD pfd = {
447 .fd = so->s,
448 .events = G_IO_OUT | G_IO_ERR,
449 };
450 so->pollfds_idx = pollfds->len;
451 g_array_append_val(pollfds, pfd);
452 continue;
453 }
454
455
456
457
458
459 if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
460 events |= G_IO_OUT | G_IO_ERR;
461 }
462
463
464
465
466
467 if (CONN_CANFRCV(so) &&
468 (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
469 events |= G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI;
470 }
471
472 if (events) {
473 GPollFD pfd = {
474 .fd = so->s,
475 .events = events,
476 };
477 so->pollfds_idx = pollfds->len;
478 g_array_append_val(pollfds, pfd);
479 }
480 }
481
482
483
484
485 for (so = slirp->udb.so_next; so != &slirp->udb;
486 so = so_next) {
487 so_next = so->so_next;
488
489 so->pollfds_idx = -1;
490
491
492
493
494 if (so->so_expire) {
495 if (so->so_expire <= curtime) {
496 udp_detach(so);
497 continue;
498 } else {
499 slirp->do_slowtimo = true;
500 }
501 }
502
503
504
505
506
507
508
509
510
511
512
513 if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
514 GPollFD pfd = {
515 .fd = so->s,
516 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
517 };
518 so->pollfds_idx = pollfds->len;
519 g_array_append_val(pollfds, pfd);
520 }
521 }
522
523
524
525
526 for (so = slirp->icmp.so_next; so != &slirp->icmp;
527 so = so_next) {
528 so_next = so->so_next;
529
530 so->pollfds_idx = -1;
531
532
533
534
535 if (so->so_expire) {
536 if (so->so_expire <= curtime) {
537 icmp_detach(so);
538 continue;
539 } else {
540 slirp->do_slowtimo = true;
541 }
542 }
543
544 if (so->so_state & SS_ISFCONNECTED) {
545 GPollFD pfd = {
546 .fd = so->s,
547 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
548 };
549 so->pollfds_idx = pollfds->len;
550 g_array_append_val(pollfds, pfd);
551 }
552 }
553 }
554 slirp_update_timeout(timeout);
555}
556
557void slirp_pollfds_poll(GArray *pollfds, int select_error)
558{
559 Slirp *slirp;
560 struct socket *so, *so_next;
561 int ret;
562
563 if (QTAILQ_EMPTY(&slirp_instances)) {
564 return;
565 }
566
567 curtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
568
569 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
570
571
572
573 if (slirp->time_fasttimo &&
574 ((curtime - slirp->time_fasttimo) >= TIMEOUT_FAST)) {
575 tcp_fasttimo(slirp);
576 slirp->time_fasttimo = 0;
577 }
578 if (slirp->do_slowtimo &&
579 ((curtime - slirp->last_slowtimo) >= TIMEOUT_SLOW)) {
580 ip_slowtimo(slirp);
581 tcp_slowtimo(slirp);
582 slirp->last_slowtimo = curtime;
583 }
584
585
586
587
588 if (!select_error) {
589
590
591
592 for (so = slirp->tcb.so_next; so != &slirp->tcb;
593 so = so_next) {
594 int revents;
595
596 so_next = so->so_next;
597
598 revents = 0;
599 if (so->pollfds_idx != -1) {
600 revents = g_array_index(pollfds, GPollFD,
601 so->pollfds_idx).revents;
602 }
603
604 if (so->so_state & SS_NOFDREF || so->s == -1) {
605 continue;
606 }
607
608
609
610
611
612
613 if (revents & G_IO_PRI) {
614 ret = sorecvoob(so);
615 if (ret < 0) {
616
617
618 continue;
619 }
620 }
621
622
623
624 else if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) {
625
626
627
628 if (so->so_state & SS_FACCEPTCONN) {
629 tcp_connect(so);
630 continue;
631 }
632 ret = soread(so);
633
634
635 if (ret > 0) {
636 tcp_output(sototcpcb(so));
637 }
638 if (ret < 0) {
639
640
641 continue;
642 }
643 }
644
645
646
647
648 if (!(so->so_state & SS_NOFDREF) &&
649 (revents & (G_IO_OUT | G_IO_ERR))) {
650
651
652
653 if (so->so_state & SS_ISFCONNECTING) {
654
655 so->so_state &= ~SS_ISFCONNECTING;
656
657 ret = send(so->s, (const void *) &ret, 0, 0);
658 if (ret < 0) {
659
660 if (errno == EAGAIN || errno == EWOULDBLOCK ||
661 errno == EINPROGRESS || errno == ENOTCONN) {
662 continue;
663 }
664
665
666 so->so_state &= SS_PERSISTENT_MASK;
667 so->so_state |= SS_NOFDREF;
668 }
669
670
671
672
673
674 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so,
675 so->so_ffamily);
676
677 } else {
678 ret = sowrite(so);
679 }
680
681
682
683
684
685
686 }
687
688
689
690
691
692#ifdef PROBE_CONN
693 if (so->so_state & SS_ISFCONNECTING) {
694 ret = qemu_recv(so->s, &ret, 0, 0);
695
696 if (ret < 0) {
697
698 if (errno == EAGAIN || errno == EWOULDBLOCK ||
699 errno == EINPROGRESS || errno == ENOTCONN) {
700 continue;
701 }
702
703
704 so->so_state &= SS_PERSISTENT_MASK;
705 so->so_state |= SS_NOFDREF;
706
707
708 } else {
709 ret = send(so->s, &ret, 0, 0);
710 if (ret < 0) {
711
712 if (errno == EAGAIN || errno == EWOULDBLOCK ||
713 errno == EINPROGRESS || errno == ENOTCONN) {
714 continue;
715 }
716
717 so->so_state &= SS_PERSISTENT_MASK;
718 so->so_state |= SS_NOFDREF;
719 } else {
720 so->so_state &= ~SS_ISFCONNECTING;
721 }
722
723 }
724 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so,
725 so->so_ffamily);
726 }
727#endif
728 }
729
730
731
732
733
734
735 for (so = slirp->udb.so_next; so != &slirp->udb;
736 so = so_next) {
737 int revents;
738
739 so_next = so->so_next;
740
741 revents = 0;
742 if (so->pollfds_idx != -1) {
743 revents = g_array_index(pollfds, GPollFD,
744 so->pollfds_idx).revents;
745 }
746
747 if (so->s != -1 &&
748 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
749 sorecvfrom(so);
750 }
751 }
752
753
754
755
756 for (so = slirp->icmp.so_next; so != &slirp->icmp;
757 so = so_next) {
758 int revents;
759
760 so_next = so->so_next;
761
762 revents = 0;
763 if (so->pollfds_idx != -1) {
764 revents = g_array_index(pollfds, GPollFD,
765 so->pollfds_idx).revents;
766 }
767
768 if (so->s != -1 &&
769 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
770 icmp_receive(so);
771 }
772 }
773 }
774
775 if_start(slirp);
776 }
777}
778
779static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
780{
781 struct slirp_arphdr *ah = (struct slirp_arphdr *)(pkt + ETH_HLEN);
782 uint8_t arp_reply[MAX(ETH_HLEN + sizeof(struct slirp_arphdr), 64)];
783 struct ethhdr *reh = (struct ethhdr *)arp_reply;
784 struct slirp_arphdr *rah = (struct slirp_arphdr *)(arp_reply + ETH_HLEN);
785 int ar_op;
786 struct ex_list *ex_ptr;
787
788 if (!slirp->in_enabled) {
789 return;
790 }
791
792 ar_op = ntohs(ah->ar_op);
793 switch(ar_op) {
794 case ARPOP_REQUEST:
795 if (ah->ar_tip == ah->ar_sip) {
796
797 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
798 return;
799 }
800
801 if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
802 slirp->vnetwork_addr.s_addr) {
803 if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
804 ah->ar_tip == slirp->vhost_addr.s_addr)
805 goto arp_ok;
806 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
807 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
808 goto arp_ok;
809 }
810 return;
811 arp_ok:
812 memset(arp_reply, 0, sizeof(arp_reply));
813
814 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
815
816
817 memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
818 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
819 memcpy(&reh->h_source[2], &ah->ar_tip, 4);
820 reh->h_proto = htons(ETH_P_ARP);
821
822 rah->ar_hrd = htons(1);
823 rah->ar_pro = htons(ETH_P_IP);
824 rah->ar_hln = ETH_ALEN;
825 rah->ar_pln = 4;
826 rah->ar_op = htons(ARPOP_REPLY);
827 memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
828 rah->ar_sip = ah->ar_tip;
829 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
830 rah->ar_tip = ah->ar_sip;
831 slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
832 }
833 break;
834 case ARPOP_REPLY:
835 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
836 break;
837 default:
838 break;
839 }
840}
841
842void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
843{
844 struct mbuf *m;
845 int proto;
846
847 if (pkt_len < ETH_HLEN)
848 return;
849
850 proto = ntohs(*(uint16_t *)(pkt + 12));
851 switch(proto) {
852 case ETH_P_ARP:
853 arp_input(slirp, pkt, pkt_len);
854 break;
855 case ETH_P_IP:
856 case ETH_P_IPV6:
857 m = m_get(slirp);
858 if (!m)
859 return;
860
861
862 if (M_FREEROOM(m) < pkt_len + TCPIPHDR_DELTA + 2) {
863 m_inc(m, pkt_len + TCPIPHDR_DELTA + 2);
864 }
865 m->m_len = pkt_len + TCPIPHDR_DELTA + 2;
866 memcpy(m->m_data + TCPIPHDR_DELTA + 2, pkt, pkt_len);
867
868 m->m_data += TCPIPHDR_DELTA + 2 + ETH_HLEN;
869 m->m_len -= TCPIPHDR_DELTA + 2 + ETH_HLEN;
870
871 if (proto == ETH_P_IP) {
872 ip_input(m);
873 } else if (proto == ETH_P_IPV6) {
874 ip6_input(m);
875 }
876 break;
877
878 case ETH_P_NCSI:
879 ncsi_input(slirp, pkt, pkt_len);
880 break;
881
882 default:
883 break;
884 }
885}
886
887
888
889
890
891static int if_encap4(Slirp *slirp, struct mbuf *ifm, struct ethhdr *eh,
892 uint8_t ethaddr[ETH_ALEN])
893{
894 const struct ip *iph = (const struct ip *)ifm->m_data;
895
896 if (iph->ip_dst.s_addr == 0) {
897
898
899 return 1;
900 }
901 if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
902 uint8_t arp_req[ETH_HLEN + sizeof(struct slirp_arphdr)];
903 struct ethhdr *reh = (struct ethhdr *)arp_req;
904 struct slirp_arphdr *rah = (struct slirp_arphdr *)(arp_req + ETH_HLEN);
905
906 if (!ifm->resolution_requested) {
907
908 memset(reh->h_dest, 0xff, ETH_ALEN);
909 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
910 memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
911 reh->h_proto = htons(ETH_P_ARP);
912 rah->ar_hrd = htons(1);
913 rah->ar_pro = htons(ETH_P_IP);
914 rah->ar_hln = ETH_ALEN;
915 rah->ar_pln = 4;
916 rah->ar_op = htons(ARPOP_REQUEST);
917
918
919 memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
920 memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
921
922
923 rah->ar_sip = slirp->vhost_addr.s_addr;
924
925
926 memset(rah->ar_tha, 0, ETH_ALEN);
927
928
929 rah->ar_tip = iph->ip_dst.s_addr;
930 slirp->client_ipaddr = iph->ip_dst;
931 slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
932 ifm->resolution_requested = true;
933
934
935 ifm->expiration_date = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + 1000000000ULL;
936 }
937 return 0;
938 } else {
939 memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
940
941 memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
942 eh->h_proto = htons(ETH_P_IP);
943
944
945 return 2;
946 }
947}
948
949
950
951
952
953static int if_encap6(Slirp *slirp, struct mbuf *ifm, struct ethhdr *eh,
954 uint8_t ethaddr[ETH_ALEN])
955{
956 const struct ip6 *ip6h = mtod(ifm, const struct ip6 *);
957 if (!ndp_table_search(slirp, ip6h->ip_dst, ethaddr)) {
958 if (!ifm->resolution_requested) {
959 ndp_send_ns(slirp, ip6h->ip_dst);
960 ifm->resolution_requested = true;
961 ifm->expiration_date =
962 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + 1000000000ULL;
963 }
964 return 0;
965 } else {
966 eh->h_proto = htons(ETH_P_IPV6);
967 in6_compute_ethaddr(ip6h->ip_src, eh->h_source);
968
969
970 return 2;
971 }
972}
973
974
975
976
977int if_encap(Slirp *slirp, struct mbuf *ifm)
978{
979 uint8_t buf[1600];
980 struct ethhdr *eh = (struct ethhdr *)buf;
981 uint8_t ethaddr[ETH_ALEN];
982 const struct ip *iph = (const struct ip *)ifm->m_data;
983 int ret;
984
985 if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
986 return 1;
987 }
988
989 switch (iph->ip_v) {
990 case IPVERSION:
991 ret = if_encap4(slirp, ifm, eh, ethaddr);
992 if (ret < 2) {
993 return ret;
994 }
995 break;
996
997 case IP6VERSION:
998 ret = if_encap6(slirp, ifm, eh, ethaddr);
999 if (ret < 2) {
1000 return ret;
1001 }
1002 break;
1003
1004 default:
1005 g_assert_not_reached();
1006 break;
1007 }
1008
1009 memcpy(eh->h_dest, ethaddr, ETH_ALEN);
1010 DEBUG_ARGS((dfd, " src = %02x:%02x:%02x:%02x:%02x:%02x\n",
1011 eh->h_source[0], eh->h_source[1], eh->h_source[2],
1012 eh->h_source[3], eh->h_source[4], eh->h_source[5]));
1013 DEBUG_ARGS((dfd, " dst = %02x:%02x:%02x:%02x:%02x:%02x\n",
1014 eh->h_dest[0], eh->h_dest[1], eh->h_dest[2],
1015 eh->h_dest[3], eh->h_dest[4], eh->h_dest[5]));
1016 memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
1017 slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
1018 return 1;
1019}
1020
1021
1022int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
1023 int host_port)
1024{
1025 struct socket *so;
1026 struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
1027 struct sockaddr_in addr;
1028 int port = htons(host_port);
1029 socklen_t addr_len;
1030
1031 for (so = head->so_next; so != head; so = so->so_next) {
1032 addr_len = sizeof(addr);
1033 if ((so->so_state & SS_HOSTFWD) &&
1034 getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
1035 addr.sin_addr.s_addr == host_addr.s_addr &&
1036 addr.sin_port == port) {
1037 close(so->s);
1038 sofree(so);
1039 return 0;
1040 }
1041 }
1042
1043 return -1;
1044}
1045
1046int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
1047 int host_port, struct in_addr guest_addr, int guest_port)
1048{
1049 if (!guest_addr.s_addr) {
1050 guest_addr = slirp->vdhcp_startaddr;
1051 }
1052 if (is_udp) {
1053 if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
1054 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
1055 return -1;
1056 } else {
1057 if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
1058 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
1059 return -1;
1060 }
1061 return 0;
1062}
1063
1064int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
1065 struct in_addr *guest_addr, int guest_port)
1066{
1067 if (!guest_addr->s_addr) {
1068 guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
1069 (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
1070 }
1071 if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
1072 slirp->vnetwork_addr.s_addr ||
1073 guest_addr->s_addr == slirp->vhost_addr.s_addr ||
1074 guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
1075 return -1;
1076 }
1077 return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
1078 htons(guest_port));
1079}
1080
1081ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
1082{
1083 if (so->s == -1 && so->extra) {
1084
1085
1086 qemu_chr_fe_write_all(so->extra, buf, len);
1087 return len;
1088 }
1089
1090 return send(so->s, buf, len, flags);
1091}
1092
1093static struct socket *
1094slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
1095{
1096 struct socket *so;
1097
1098 for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
1099 if (so->so_faddr.s_addr == guest_addr.s_addr &&
1100 htons(so->so_fport) == guest_port) {
1101 return so;
1102 }
1103 }
1104 return NULL;
1105}
1106
1107size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
1108 int guest_port)
1109{
1110 struct iovec iov[2];
1111 struct socket *so;
1112
1113 so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
1114
1115 if (!so || so->so_state & SS_NOFDREF) {
1116 return 0;
1117 }
1118
1119 if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2)) {
1120 return 0;
1121 }
1122
1123 return sopreprbuf(so, iov, NULL);
1124}
1125
1126void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
1127 const uint8_t *buf, int size)
1128{
1129 int ret;
1130 struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
1131
1132 if (!so)
1133 return;
1134
1135 ret = soreadbuf(so, (const char *)buf, size);
1136
1137 if (ret > 0)
1138 tcp_output(sototcpcb(so));
1139}
1140
1141static int slirp_tcp_post_load(void *opaque, int version)
1142{
1143 tcp_template((struct tcpcb *)opaque);
1144
1145 return 0;
1146}
1147
1148static const VMStateDescription vmstate_slirp_tcp = {
1149 .name = "slirp-tcp",
1150 .version_id = 0,
1151 .post_load = slirp_tcp_post_load,
1152 .fields = (VMStateField[]) {
1153 VMSTATE_INT16(t_state, struct tcpcb),
1154 VMSTATE_INT16_ARRAY(t_timer, struct tcpcb, TCPT_NTIMERS),
1155 VMSTATE_INT16(t_rxtshift, struct tcpcb),
1156 VMSTATE_INT16(t_rxtcur, struct tcpcb),
1157 VMSTATE_INT16(t_dupacks, struct tcpcb),
1158 VMSTATE_UINT16(t_maxseg, struct tcpcb),
1159 VMSTATE_UINT8(t_force, struct tcpcb),
1160 VMSTATE_UINT16(t_flags, struct tcpcb),
1161 VMSTATE_UINT32(snd_una, struct tcpcb),
1162 VMSTATE_UINT32(snd_nxt, struct tcpcb),
1163 VMSTATE_UINT32(snd_up, struct tcpcb),
1164 VMSTATE_UINT32(snd_wl1, struct tcpcb),
1165 VMSTATE_UINT32(snd_wl2, struct tcpcb),
1166 VMSTATE_UINT32(iss, struct tcpcb),
1167 VMSTATE_UINT32(snd_wnd, struct tcpcb),
1168 VMSTATE_UINT32(rcv_wnd, struct tcpcb),
1169 VMSTATE_UINT32(rcv_nxt, struct tcpcb),
1170 VMSTATE_UINT32(rcv_up, struct tcpcb),
1171 VMSTATE_UINT32(irs, struct tcpcb),
1172 VMSTATE_UINT32(rcv_adv, struct tcpcb),
1173 VMSTATE_UINT32(snd_max, struct tcpcb),
1174 VMSTATE_UINT32(snd_cwnd, struct tcpcb),
1175 VMSTATE_UINT32(snd_ssthresh, struct tcpcb),
1176 VMSTATE_INT16(t_idle, struct tcpcb),
1177 VMSTATE_INT16(t_rtt, struct tcpcb),
1178 VMSTATE_UINT32(t_rtseq, struct tcpcb),
1179 VMSTATE_INT16(t_srtt, struct tcpcb),
1180 VMSTATE_INT16(t_rttvar, struct tcpcb),
1181 VMSTATE_UINT16(t_rttmin, struct tcpcb),
1182 VMSTATE_UINT32(max_sndwnd, struct tcpcb),
1183 VMSTATE_UINT8(t_oobflags, struct tcpcb),
1184 VMSTATE_UINT8(t_iobc, struct tcpcb),
1185 VMSTATE_INT16(t_softerror, struct tcpcb),
1186 VMSTATE_UINT8(snd_scale, struct tcpcb),
1187 VMSTATE_UINT8(rcv_scale, struct tcpcb),
1188 VMSTATE_UINT8(request_r_scale, struct tcpcb),
1189 VMSTATE_UINT8(requested_s_scale, struct tcpcb),
1190 VMSTATE_UINT32(ts_recent, struct tcpcb),
1191 VMSTATE_UINT32(ts_recent_age, struct tcpcb),
1192 VMSTATE_UINT32(last_ack_sent, struct tcpcb),
1193 VMSTATE_END_OF_LIST()
1194 }
1195};
1196
1197
1198
1199
1200
1201struct sbuf_tmp {
1202 struct sbuf *parent;
1203 uint32_t roff, woff;
1204};
1205
1206static int sbuf_tmp_pre_save(void *opaque)
1207{
1208 struct sbuf_tmp *tmp = opaque;
1209 tmp->woff = tmp->parent->sb_wptr - tmp->parent->sb_data;
1210 tmp->roff = tmp->parent->sb_rptr - tmp->parent->sb_data;
1211
1212 return 0;
1213}
1214
1215static int sbuf_tmp_post_load(void *opaque, int version)
1216{
1217 struct sbuf_tmp *tmp = opaque;
1218 uint32_t requested_len = tmp->parent->sb_datalen;
1219
1220
1221 sbreserve(tmp->parent, tmp->parent->sb_datalen);
1222
1223 if (tmp->parent->sb_datalen != requested_len) {
1224 return -ENOMEM;
1225 }
1226 if (tmp->woff >= requested_len ||
1227 tmp->roff >= requested_len) {
1228 error_report("invalid sbuf offsets r/w=%u/%u len=%u",
1229 tmp->roff, tmp->woff, requested_len);
1230 return -EINVAL;
1231 }
1232
1233 tmp->parent->sb_wptr = tmp->parent->sb_data + tmp->woff;
1234 tmp->parent->sb_rptr = tmp->parent->sb_data + tmp->roff;
1235
1236 return 0;
1237}
1238
1239
1240static const VMStateDescription vmstate_slirp_sbuf_tmp = {
1241 .name = "slirp-sbuf-tmp",
1242 .post_load = sbuf_tmp_post_load,
1243 .pre_save = sbuf_tmp_pre_save,
1244 .version_id = 0,
1245 .fields = (VMStateField[]) {
1246 VMSTATE_UINT32(woff, struct sbuf_tmp),
1247 VMSTATE_UINT32(roff, struct sbuf_tmp),
1248 VMSTATE_END_OF_LIST()
1249 }
1250};
1251
1252static const VMStateDescription vmstate_slirp_sbuf = {
1253 .name = "slirp-sbuf",
1254 .version_id = 0,
1255 .fields = (VMStateField[]) {
1256 VMSTATE_UINT32(sb_cc, struct sbuf),
1257 VMSTATE_UINT32(sb_datalen, struct sbuf),
1258 VMSTATE_WITH_TMP(struct sbuf, struct sbuf_tmp, vmstate_slirp_sbuf_tmp),
1259 VMSTATE_VBUFFER_UINT32(sb_data, struct sbuf, 0, NULL, sb_datalen),
1260 VMSTATE_END_OF_LIST()
1261 }
1262};
1263
1264static bool slirp_older_than_v4(void *opaque, int version_id)
1265{
1266 return version_id < 4;
1267}
1268
1269static bool slirp_family_inet(void *opaque, int version_id)
1270{
1271 union slirp_sockaddr *ssa = (union slirp_sockaddr *)opaque;
1272 return ssa->ss.ss_family == AF_INET;
1273}
1274
1275static int slirp_socket_pre_load(void *opaque)
1276{
1277 struct socket *so = opaque;
1278 if (tcp_attach(so) < 0) {
1279 return -ENOMEM;
1280 }
1281
1282 so->so_ffamily = AF_INET;
1283 so->so_lfamily = AF_INET;
1284 return 0;
1285}
1286
1287#ifndef _WIN32
1288#define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_UINT32_TEST(f, s, t)
1289#else
1290
1291#define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_SINGLE_TEST(f, s, t, 0, \
1292 vmstate_info_uint32, u_long)
1293#endif
1294
1295
1296
1297
1298
1299typedef struct SS_FamilyTmpStruct {
1300 union slirp_sockaddr *parent;
1301 uint16_t portable_family;
1302} SS_FamilyTmpStruct;
1303
1304#define SS_FAMILY_MIG_IPV4 2
1305#define SS_FAMILY_MIG_IPV6 10
1306#define SS_FAMILY_MIG_OTHER 0xffff
1307
1308static int ss_family_pre_save(void *opaque)
1309{
1310 SS_FamilyTmpStruct *tss = opaque;
1311
1312 tss->portable_family = SS_FAMILY_MIG_OTHER;
1313
1314 if (tss->parent->ss.ss_family == AF_INET) {
1315 tss->portable_family = SS_FAMILY_MIG_IPV4;
1316 } else if (tss->parent->ss.ss_family == AF_INET6) {
1317 tss->portable_family = SS_FAMILY_MIG_IPV6;
1318 }
1319
1320 return 0;
1321}
1322
1323static int ss_family_post_load(void *opaque, int version_id)
1324{
1325 SS_FamilyTmpStruct *tss = opaque;
1326
1327 switch (tss->portable_family) {
1328 case SS_FAMILY_MIG_IPV4:
1329 tss->parent->ss.ss_family = AF_INET;
1330 break;
1331 case SS_FAMILY_MIG_IPV6:
1332 case 23:
1333 case 28:
1334 tss->parent->ss.ss_family = AF_INET6;
1335 break;
1336 default:
1337 error_report("invalid ss_family type %x", tss->portable_family);
1338 return -EINVAL;
1339 }
1340
1341 return 0;
1342}
1343
1344static const VMStateDescription vmstate_slirp_ss_family = {
1345 .name = "slirp-socket-addr/ss_family",
1346 .pre_save = ss_family_pre_save,
1347 .post_load = ss_family_post_load,
1348 .fields = (VMStateField[]) {
1349 VMSTATE_UINT16(portable_family, SS_FamilyTmpStruct),
1350 VMSTATE_END_OF_LIST()
1351 }
1352};
1353
1354static const VMStateDescription vmstate_slirp_socket_addr = {
1355 .name = "slirp-socket-addr",
1356 .version_id = 4,
1357 .fields = (VMStateField[]) {
1358 VMSTATE_WITH_TMP(union slirp_sockaddr, SS_FamilyTmpStruct,
1359 vmstate_slirp_ss_family),
1360 VMSTATE_SIN4_ADDR(sin.sin_addr.s_addr, union slirp_sockaddr,
1361 slirp_family_inet),
1362 VMSTATE_UINT16_TEST(sin.sin_port, union slirp_sockaddr,
1363 slirp_family_inet),
1364
1365#if 0
1366
1367 VMSTATE_BUFFER_TEST(sin6.sin6_addr, union slirp_sockaddr,
1368 slirp_family_inet6),
1369 VMSTATE_UINT16_TEST(sin6.sin6_port, union slirp_sockaddr,
1370 slirp_family_inet6),
1371 VMSTATE_UINT32_TEST(sin6.sin6_flowinfo, union slirp_sockaddr,
1372 slirp_family_inet6),
1373 VMSTATE_UINT32_TEST(sin6.sin6_scope_id, union slirp_sockaddr,
1374 slirp_family_inet6),
1375#endif
1376
1377 VMSTATE_END_OF_LIST()
1378 }
1379};
1380
1381static const VMStateDescription vmstate_slirp_socket = {
1382 .name = "slirp-socket",
1383 .version_id = 4,
1384 .pre_load = slirp_socket_pre_load,
1385 .fields = (VMStateField[]) {
1386 VMSTATE_UINT32(so_urgc, struct socket),
1387
1388 VMSTATE_SIN4_ADDR(so_faddr.s_addr, struct socket,
1389 slirp_older_than_v4),
1390 VMSTATE_SIN4_ADDR(so_laddr.s_addr, struct socket,
1391 slirp_older_than_v4),
1392 VMSTATE_UINT16_TEST(so_fport, struct socket, slirp_older_than_v4),
1393 VMSTATE_UINT16_TEST(so_lport, struct socket, slirp_older_than_v4),
1394
1395 VMSTATE_STRUCT(fhost, struct socket, 4, vmstate_slirp_socket_addr,
1396 union slirp_sockaddr),
1397 VMSTATE_STRUCT(lhost, struct socket, 4, vmstate_slirp_socket_addr,
1398 union slirp_sockaddr),
1399
1400 VMSTATE_UINT8(so_iptos, struct socket),
1401 VMSTATE_UINT8(so_emu, struct socket),
1402 VMSTATE_UINT8(so_type, struct socket),
1403 VMSTATE_INT32(so_state, struct socket),
1404 VMSTATE_STRUCT(so_rcv, struct socket, 0, vmstate_slirp_sbuf,
1405 struct sbuf),
1406 VMSTATE_STRUCT(so_snd, struct socket, 0, vmstate_slirp_sbuf,
1407 struct sbuf),
1408 VMSTATE_STRUCT_POINTER(so_tcpcb, struct socket, vmstate_slirp_tcp,
1409 struct tcpcb),
1410 VMSTATE_END_OF_LIST()
1411 }
1412};
1413
1414static const VMStateDescription vmstate_slirp_bootp_client = {
1415 .name = "slirp_bootpclient",
1416 .fields = (VMStateField[]) {
1417 VMSTATE_UINT16(allocated, BOOTPClient),
1418 VMSTATE_BUFFER(macaddr, BOOTPClient),
1419 VMSTATE_END_OF_LIST()
1420 }
1421};
1422
1423static const VMStateDescription vmstate_slirp = {
1424 .name = "slirp",
1425 .version_id = 4,
1426 .fields = (VMStateField[]) {
1427 VMSTATE_UINT16_V(ip_id, Slirp, 2),
1428 VMSTATE_STRUCT_ARRAY(bootp_clients, Slirp, NB_BOOTP_CLIENTS, 3,
1429 vmstate_slirp_bootp_client, BOOTPClient),
1430 VMSTATE_END_OF_LIST()
1431 }
1432};
1433
1434static void slirp_state_save(QEMUFile *f, void *opaque)
1435{
1436 Slirp *slirp = opaque;
1437 struct ex_list *ex_ptr;
1438
1439 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
1440 if (ex_ptr->ex_pty == 3) {
1441 struct socket *so;
1442 so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
1443 ntohs(ex_ptr->ex_fport));
1444 if (!so)
1445 continue;
1446
1447 qemu_put_byte(f, 42);
1448 vmstate_save_state(f, &vmstate_slirp_socket, so, NULL);
1449 }
1450 qemu_put_byte(f, 0);
1451
1452 vmstate_save_state(f, &vmstate_slirp, slirp, NULL);
1453}
1454
1455
1456static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1457{
1458 Slirp *slirp = opaque;
1459 struct ex_list *ex_ptr;
1460
1461 while (qemu_get_byte(f)) {
1462 int ret;
1463 struct socket *so = socreate(slirp);
1464
1465 if (!so)
1466 return -ENOMEM;
1467
1468 ret = vmstate_load_state(f, &vmstate_slirp_socket, so, version_id);
1469
1470 if (ret < 0)
1471 return ret;
1472
1473 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1474 slirp->vnetwork_addr.s_addr) {
1475 return -EINVAL;
1476 }
1477 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1478 if (ex_ptr->ex_pty == 3 &&
1479 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1480 so->so_fport == ex_ptr->ex_fport) {
1481 break;
1482 }
1483 }
1484 if (!ex_ptr)
1485 return -EINVAL;
1486
1487 so->extra = (void *)ex_ptr->ex_exec;
1488 }
1489
1490 return vmstate_load_state(f, &vmstate_slirp, slirp, version_id);
1491}
1492
