4 * Copyright (c) 2004-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "qemu/timer.h"
27 #include "qemu/error-report.h"
28 #include "migration/register.h"
31 #include "qemu/cutils.h"
39 /* Define to 1 if you want KEEPALIVE timers */
40 bool slirp_do_keepalive
;
42 /* host loopback address */
43 struct in_addr loopback_addr
;
44 /* host loopback network mask */
45 unsigned long loopback_mask
;
47 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
48 static const uint8_t special_ethaddr
[ETH_ALEN
] = {
49 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
54 static QTAILQ_HEAD(, Slirp
) slirp_instances
=
55 QTAILQ_HEAD_INITIALIZER(slirp_instances
);
57 static struct in_addr dns_addr
;
59 static struct in6_addr dns6_addr
;
61 static u_int dns_addr_time
;
63 static u_int dns6_addr_time
;
66 #define TIMEOUT_FAST 2 /* milliseconds */
67 #define TIMEOUT_SLOW 499 /* milliseconds */
68 /* for the aging of certain requests like DNS */
69 #define TIMEOUT_DEFAULT 1000 /* milliseconds */
73 int get_dns_addr(struct in_addr
*pdns_addr
)
75 FIXED_INFO
*FixedInfo
=NULL
;
78 IP_ADDR_STRING
*pIPAddr
;
79 struct in_addr tmp_addr
;
81 if (dns_addr
.s_addr
!= 0 && (curtime
- dns_addr_time
) < TIMEOUT_DEFAULT
) {
82 *pdns_addr
= dns_addr
;
86 FixedInfo
= (FIXED_INFO
*)GlobalAlloc(GPTR
, sizeof(FIXED_INFO
));
87 BufLen
= sizeof(FIXED_INFO
);
89 if (ERROR_BUFFER_OVERFLOW
== GetNetworkParams(FixedInfo
, &BufLen
)) {
91 GlobalFree(FixedInfo
);
94 FixedInfo
= GlobalAlloc(GPTR
, BufLen
);
97 if ((ret
= GetNetworkParams(FixedInfo
, &BufLen
)) != ERROR_SUCCESS
) {
98 printf("GetNetworkParams failed. ret = %08x\n", (u_int
)ret
);
100 GlobalFree(FixedInfo
);
106 pIPAddr
= &(FixedInfo
->DnsServerList
);
107 inet_aton(pIPAddr
->IpAddress
.String
, &tmp_addr
);
108 *pdns_addr
= tmp_addr
;
110 dns_addr_time
= curtime
;
112 GlobalFree(FixedInfo
);
118 int get_dns6_addr(struct in6_addr
*pdns6_addr
, uint32_t *scope_id
)
123 static void winsock_cleanup(void)
130 static int get_dns_addr_cached(void *pdns_addr
, void *cached_addr
,
132 struct stat
*cached_stat
, u_int
*cached_time
)
134 struct stat old_stat
;
135 if (curtime
- *cached_time
< TIMEOUT_DEFAULT
) {
136 memcpy(pdns_addr
, cached_addr
, addrlen
);
139 old_stat
= *cached_stat
;
140 if (stat("/etc/resolv.conf", cached_stat
) != 0) {
143 if (cached_stat
->st_dev
== old_stat
.st_dev
144 && cached_stat
->st_ino
== old_stat
.st_ino
145 && cached_stat
->st_size
== old_stat
.st_size
146 && cached_stat
->st_mtime
== old_stat
.st_mtime
) {
147 memcpy(pdns_addr
, cached_addr
, addrlen
);
153 static int get_dns_addr_resolv_conf(int af
, void *pdns_addr
, void *cached_addr
,
154 socklen_t addrlen
, uint32_t *scope_id
,
161 void *tmp_addr
= alloca(addrlen
);
164 f
= fopen("/etc/resolv.conf", "r");
168 DEBUG_MISC("IP address of your DNS(s):");
169 while (fgets(buff
, 512, f
) != NULL
) {
170 if (sscanf(buff
, "nameserver%*[ \t]%256s", buff2
) == 1) {
171 char *c
= strchr(buff2
, '%');
173 if_index
= if_nametoindex(c
+ 1);
179 if (!inet_pton(af
, buff2
, tmp_addr
)) {
182 /* If it's the first one, set it to dns_addr */
184 memcpy(pdns_addr
, tmp_addr
, addrlen
);
185 memcpy(cached_addr
, tmp_addr
, addrlen
);
187 *scope_id
= if_index
;
189 *cached_time
= curtime
;
193 DEBUG_MISC(" (more)");
195 } else if (slirp_debug
& DBG_MISC
) {
196 char s
[INET6_ADDRSTRLEN
];
197 const char *res
= inet_ntop(af
, tmp_addr
, s
, sizeof(s
));
199 res
= " (string conversion error)";
201 DEBUG_MISC(" %s", res
);
211 int get_dns_addr(struct in_addr
*pdns_addr
)
213 static struct stat dns_addr_stat
;
215 if (dns_addr
.s_addr
!= 0) {
217 ret
= get_dns_addr_cached(pdns_addr
, &dns_addr
, sizeof(dns_addr
),
218 &dns_addr_stat
, &dns_addr_time
);
223 return get_dns_addr_resolv_conf(AF_INET
, pdns_addr
, &dns_addr
,
224 sizeof(dns_addr
), NULL
, &dns_addr_time
);
227 int get_dns6_addr(struct in6_addr
*pdns6_addr
, uint32_t *scope_id
)
229 static struct stat dns6_addr_stat
;
231 if (!in6_zero(&dns6_addr
)) {
233 ret
= get_dns_addr_cached(pdns6_addr
, &dns6_addr
, sizeof(dns6_addr
),
234 &dns6_addr_stat
, &dns6_addr_time
);
239 return get_dns_addr_resolv_conf(AF_INET6
, pdns6_addr
, &dns6_addr
,
241 scope_id
, &dns6_addr_time
);
246 static void slirp_init_once(void)
248 static int initialized
;
260 WSAStartup(MAKEWORD(2,0), &Data
);
261 atexit(winsock_cleanup
);
264 loopback_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
265 loopback_mask
= htonl(IN_CLASSA_NET
);
267 debug
= g_getenv("SLIRP_DEBUG");
269 const GDebugKey keys
[] = {
270 { "call", DBG_CALL
},
271 { "misc", DBG_MISC
},
272 { "error", DBG_ERROR
},
273 { "tftp", DBG_TFTP
},
275 slirp_debug
= g_parse_debug_string(debug
, keys
, G_N_ELEMENTS(keys
));
281 static void slirp_state_save(QEMUFile
*f
, void *opaque
);
282 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
);
284 static SaveVMHandlers savevm_slirp_state
= {
285 .save_state
= slirp_state_save
,
286 .load_state
= slirp_state_load
,
289 Slirp
*slirp_init(int restricted
, bool in_enabled
, struct in_addr vnetwork
,
290 struct in_addr vnetmask
, struct in_addr vhost
,
292 struct in6_addr vprefix_addr6
, uint8_t vprefix_len
,
293 struct in6_addr vhost6
, const char *vhostname
,
294 const char *tftp_server_name
,
295 const char *tftp_path
, const char *bootfile
,
296 struct in_addr vdhcp_start
, struct in_addr vnameserver
,
297 struct in6_addr vnameserver6
, const char **vdnssearch
,
298 const char *vdomainname
,
299 const SlirpCb
*callbacks
,
302 Slirp
*slirp
= g_malloc0(sizeof(Slirp
));
306 slirp
->cb
= callbacks
;
307 slirp
->grand
= g_rand_new();
308 slirp
->restricted
= restricted
;
310 slirp
->in_enabled
= in_enabled
;
311 slirp
->in6_enabled
= in6_enabled
;
317 /* Initialise mbufs *after* setting the MTU */
320 slirp
->vnetwork_addr
= vnetwork
;
321 slirp
->vnetwork_mask
= vnetmask
;
322 slirp
->vhost_addr
= vhost
;
323 slirp
->vprefix_addr6
= vprefix_addr6
;
324 slirp
->vprefix_len
= vprefix_len
;
325 slirp
->vhost_addr6
= vhost6
;
327 pstrcpy(slirp
->client_hostname
, sizeof(slirp
->client_hostname
),
330 slirp
->tftp_prefix
= g_strdup(tftp_path
);
331 slirp
->bootp_filename
= g_strdup(bootfile
);
332 slirp
->vdomainname
= g_strdup(vdomainname
);
333 slirp
->vdhcp_startaddr
= vdhcp_start
;
334 slirp
->vnameserver_addr
= vnameserver
;
335 slirp
->vnameserver_addr6
= vnameserver6
;
336 slirp
->tftp_server_name
= g_strdup(tftp_server_name
);
339 translate_dnssearch(slirp
, vdnssearch
);
342 slirp
->opaque
= opaque
;
344 register_savevm_live(NULL
, "slirp", 0, 4, &savevm_slirp_state
, slirp
);
346 QTAILQ_INSERT_TAIL(&slirp_instances
, slirp
, entry
);
351 void slirp_cleanup(Slirp
*slirp
)
353 struct gfwd_list
*e
, *next
;
355 for (e
= slirp
->guestfwd_list
; e
; e
= next
) {
361 QTAILQ_REMOVE(&slirp_instances
, slirp
, entry
);
363 unregister_savevm(NULL
, "slirp", slirp
);
369 g_rand_free(slirp
->grand
);
371 g_free(slirp
->vdnssearch
);
372 g_free(slirp
->tftp_prefix
);
373 g_free(slirp
->bootp_filename
);
374 g_free(slirp
->vdomainname
);
378 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
379 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
381 static void slirp_update_timeout(uint32_t *timeout
)
386 if (*timeout
<= TIMEOUT_FAST
) {
390 t
= MIN(1000, *timeout
);
392 /* If we have tcp timeout with slirp, then we will fill @timeout with
393 * more precise value.
395 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
396 if (slirp
->time_fasttimo
) {
397 *timeout
= TIMEOUT_FAST
;
400 if (slirp
->do_slowtimo
) {
401 t
= MIN(TIMEOUT_SLOW
, t
);
407 void slirp_pollfds_fill(GArray
*pollfds
, uint32_t *timeout
)
410 struct socket
*so
, *so_next
;
412 if (QTAILQ_EMPTY(&slirp_instances
)) {
420 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
422 * *_slowtimo needs calling if there are IP fragments
423 * in the fragment queue, or there are TCP connections active
425 slirp
->do_slowtimo
= ((slirp
->tcb
.so_next
!= &slirp
->tcb
) ||
426 (&slirp
->ipq
.ip_link
!= slirp
->ipq
.ip_link
.next
));
428 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
432 so_next
= so
->so_next
;
434 so
->pollfds_idx
= -1;
437 * See if we need a tcp_fasttimo
439 if (slirp
->time_fasttimo
== 0 &&
440 so
->so_tcpcb
->t_flags
& TF_DELACK
) {
441 slirp
->time_fasttimo
= curtime
; /* Flag when want a fasttimo */
445 * NOFDREF can include still connecting to local-host,
446 * newly socreated() sockets etc. Don't want to select these.
448 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
453 * Set for reading sockets which are accepting
455 if (so
->so_state
& SS_FACCEPTCONN
) {
458 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
460 so
->pollfds_idx
= pollfds
->len
;
461 g_array_append_val(pollfds
, pfd
);
466 * Set for writing sockets which are connecting
468 if (so
->so_state
& SS_ISFCONNECTING
) {
471 .events
= G_IO_OUT
| G_IO_ERR
,
473 so
->pollfds_idx
= pollfds
->len
;
474 g_array_append_val(pollfds
, pfd
);
479 * Set for writing if we are connected, can send more, and
480 * we have something to send
482 if (CONN_CANFSEND(so
) && so
->so_rcv
.sb_cc
) {
483 events
|= G_IO_OUT
| G_IO_ERR
;
487 * Set for reading (and urgent data) if we are connected, can
488 * receive more, and we have room for it XXX /2 ?
490 if (CONN_CANFRCV(so
) &&
491 (so
->so_snd
.sb_cc
< (so
->so_snd
.sb_datalen
/2))) {
492 events
|= G_IO_IN
| G_IO_HUP
| G_IO_ERR
| G_IO_PRI
;
500 so
->pollfds_idx
= pollfds
->len
;
501 g_array_append_val(pollfds
, pfd
);
508 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
510 so_next
= so
->so_next
;
512 so
->pollfds_idx
= -1;
515 * See if it's timed out
518 if (so
->so_expire
<= curtime
) {
522 slirp
->do_slowtimo
= true; /* Let socket expire */
527 * When UDP packets are received from over the
528 * link, they're sendto()'d straight away, so
529 * no need for setting for writing
530 * Limit the number of packets queued by this session
531 * to 4. Note that even though we try and limit this
532 * to 4 packets, the session could have more queued
533 * if the packets needed to be fragmented
536 if ((so
->so_state
& SS_ISFCONNECTED
) && so
->so_queued
<= 4) {
539 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
541 so
->pollfds_idx
= pollfds
->len
;
542 g_array_append_val(pollfds
, pfd
);
549 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
551 so_next
= so
->so_next
;
553 so
->pollfds_idx
= -1;
556 * See if it's timed out
559 if (so
->so_expire
<= curtime
) {
563 slirp
->do_slowtimo
= true; /* Let socket expire */
567 if (so
->so_state
& SS_ISFCONNECTED
) {
570 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
572 so
->pollfds_idx
= pollfds
->len
;
573 g_array_append_val(pollfds
, pfd
);
577 slirp_update_timeout(timeout
);
580 void slirp_pollfds_poll(GArray
*pollfds
, int select_error
)
582 Slirp
*slirp
= QTAILQ_FIRST(&slirp_instances
);
583 struct socket
*so
, *so_next
;
590 curtime
= slirp
->cb
->clock_get_ns() / SCALE_MS
;
592 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
594 * See if anything has timed out
596 if (slirp
->time_fasttimo
&&
597 ((curtime
- slirp
->time_fasttimo
) >= TIMEOUT_FAST
)) {
599 slirp
->time_fasttimo
= 0;
601 if (slirp
->do_slowtimo
&&
602 ((curtime
- slirp
->last_slowtimo
) >= TIMEOUT_SLOW
)) {
605 slirp
->last_slowtimo
= curtime
;
615 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
619 so_next
= so
->so_next
;
622 if (so
->pollfds_idx
!= -1) {
623 revents
= g_array_index(pollfds
, GPollFD
,
624 so
->pollfds_idx
).revents
;
627 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
633 * This will soread as well, so no need to
634 * test for G_IO_IN below if this succeeds
636 if (revents
& G_IO_PRI
) {
639 /* Socket error might have resulted in the socket being
640 * removed, do not try to do anything more with it. */
645 * Check sockets for reading
647 else if (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
)) {
649 * Check for incoming connections
651 if (so
->so_state
& SS_FACCEPTCONN
) {
657 /* Output it if we read something */
659 tcp_output(sototcpcb(so
));
662 /* Socket error might have resulted in the socket being
663 * removed, do not try to do anything more with it. */
669 * Check sockets for writing
671 if (!(so
->so_state
& SS_NOFDREF
) &&
672 (revents
& (G_IO_OUT
| G_IO_ERR
))) {
674 * Check for non-blocking, still-connecting sockets
676 if (so
->so_state
& SS_ISFCONNECTING
) {
678 so
->so_state
&= ~SS_ISFCONNECTING
;
680 ret
= send(so
->s
, (const void *) &ret
, 0, 0);
682 /* XXXXX Must fix, zero bytes is a NOP */
683 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
684 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
689 so
->so_state
&= SS_PERSISTENT_MASK
;
690 so
->so_state
|= SS_NOFDREF
;
692 /* else so->so_state &= ~SS_ISFCONNECTING; */
697 tcp_input((struct mbuf
*)NULL
, sizeof(struct ip
), so
,
703 /* Call tcp_output in case we need to send a window
704 * update to the guest, otherwise it will be stuck
705 * until it sends a window probe. */
706 tcp_output(sototcpcb(so
));
714 * Incoming packets are sent straight away, they're not buffered.
715 * Incoming UDP data isn't buffered either.
717 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
721 so_next
= so
->so_next
;
724 if (so
->pollfds_idx
!= -1) {
725 revents
= g_array_index(pollfds
, GPollFD
,
726 so
->pollfds_idx
).revents
;
730 (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
))) {
736 * Check incoming ICMP relies.
738 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
742 so_next
= so
->so_next
;
745 if (so
->pollfds_idx
!= -1) {
746 revents
= g_array_index(pollfds
, GPollFD
,
747 so
->pollfds_idx
).revents
;
751 (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
))) {
761 static void arp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
763 struct slirp_arphdr
*ah
= (struct slirp_arphdr
*)(pkt
+ ETH_HLEN
);
764 uint8_t arp_reply
[MAX(ETH_HLEN
+ sizeof(struct slirp_arphdr
), 64)];
765 struct ethhdr
*reh
= (struct ethhdr
*)arp_reply
;
766 struct slirp_arphdr
*rah
= (struct slirp_arphdr
*)(arp_reply
+ ETH_HLEN
);
768 struct gfwd_list
*ex_ptr
;
770 if (!slirp
->in_enabled
) {
774 ar_op
= ntohs(ah
->ar_op
);
777 if (ah
->ar_tip
== ah
->ar_sip
) {
779 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
783 if ((ah
->ar_tip
& slirp
->vnetwork_mask
.s_addr
) ==
784 slirp
->vnetwork_addr
.s_addr
) {
785 if (ah
->ar_tip
== slirp
->vnameserver_addr
.s_addr
||
786 ah
->ar_tip
== slirp
->vhost_addr
.s_addr
)
788 for (ex_ptr
= slirp
->guestfwd_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
789 if (ex_ptr
->ex_addr
.s_addr
== ah
->ar_tip
)
794 memset(arp_reply
, 0, sizeof(arp_reply
));
796 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
798 /* ARP request for alias/dns mac address */
799 memcpy(reh
->h_dest
, pkt
+ ETH_ALEN
, ETH_ALEN
);
800 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
801 memcpy(&reh
->h_source
[2], &ah
->ar_tip
, 4);
802 reh
->h_proto
= htons(ETH_P_ARP
);
804 rah
->ar_hrd
= htons(1);
805 rah
->ar_pro
= htons(ETH_P_IP
);
806 rah
->ar_hln
= ETH_ALEN
;
808 rah
->ar_op
= htons(ARPOP_REPLY
);
809 memcpy(rah
->ar_sha
, reh
->h_source
, ETH_ALEN
);
810 rah
->ar_sip
= ah
->ar_tip
;
811 memcpy(rah
->ar_tha
, ah
->ar_sha
, ETH_ALEN
);
812 rah
->ar_tip
= ah
->ar_sip
;
813 slirp
->cb
->output(slirp
->opaque
, arp_reply
, sizeof(arp_reply
));
817 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
824 void slirp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
829 if (pkt_len
< ETH_HLEN
)
832 proto
= (((uint16_t) pkt
[12]) << 8) + pkt
[13];
835 arp_input(slirp
, pkt
, pkt_len
);
842 /* Note: we add 2 to align the IP header on 4 bytes,
843 * and add the margin for the tcpiphdr overhead */
844 if (M_FREEROOM(m
) < pkt_len
+ TCPIPHDR_DELTA
+ 2) {
845 m_inc(m
, pkt_len
+ TCPIPHDR_DELTA
+ 2);
847 m
->m_len
= pkt_len
+ TCPIPHDR_DELTA
+ 2;
848 memcpy(m
->m_data
+ TCPIPHDR_DELTA
+ 2, pkt
, pkt_len
);
850 m
->m_data
+= TCPIPHDR_DELTA
+ 2 + ETH_HLEN
;
851 m
->m_len
-= TCPIPHDR_DELTA
+ 2 + ETH_HLEN
;
853 if (proto
== ETH_P_IP
) {
855 } else if (proto
== ETH_P_IPV6
) {
861 ncsi_input(slirp
, pkt
, pkt_len
);
869 /* Prepare the IPv4 packet to be sent to the ethernet device. Returns 1 if no
870 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
873 static int if_encap4(Slirp
*slirp
, struct mbuf
*ifm
, struct ethhdr
*eh
,
874 uint8_t ethaddr
[ETH_ALEN
])
876 const struct ip
*iph
= (const struct ip
*)ifm
->m_data
;
878 if (iph
->ip_dst
.s_addr
== 0) {
879 /* 0.0.0.0 can not be a destination address, something went wrong,
880 * avoid making it worse */
883 if (!arp_table_search(slirp
, iph
->ip_dst
.s_addr
, ethaddr
)) {
884 uint8_t arp_req
[ETH_HLEN
+ sizeof(struct slirp_arphdr
)];
885 struct ethhdr
*reh
= (struct ethhdr
*)arp_req
;
886 struct slirp_arphdr
*rah
= (struct slirp_arphdr
*)(arp_req
+ ETH_HLEN
);
888 if (!ifm
->resolution_requested
) {
889 /* If the client addr is not known, send an ARP request */
890 memset(reh
->h_dest
, 0xff, ETH_ALEN
);
891 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
892 memcpy(&reh
->h_source
[2], &slirp
->vhost_addr
, 4);
893 reh
->h_proto
= htons(ETH_P_ARP
);
894 rah
->ar_hrd
= htons(1);
895 rah
->ar_pro
= htons(ETH_P_IP
);
896 rah
->ar_hln
= ETH_ALEN
;
898 rah
->ar_op
= htons(ARPOP_REQUEST
);
901 memcpy(rah
->ar_sha
, special_ethaddr
, ETH_ALEN
- 4);
902 memcpy(&rah
->ar_sha
[2], &slirp
->vhost_addr
, 4);
905 rah
->ar_sip
= slirp
->vhost_addr
.s_addr
;
907 /* target hw addr (none) */
908 memset(rah
->ar_tha
, 0, ETH_ALEN
);
911 rah
->ar_tip
= iph
->ip_dst
.s_addr
;
912 slirp
->client_ipaddr
= iph
->ip_dst
;
913 slirp
->cb
->output(slirp
->opaque
, arp_req
, sizeof(arp_req
));
914 ifm
->resolution_requested
= true;
916 /* Expire request and drop outgoing packet after 1 second */
917 ifm
->expiration_date
= slirp
->cb
->clock_get_ns() + 1000000000ULL;
921 memcpy(eh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
922 /* XXX: not correct */
923 memcpy(&eh
->h_source
[2], &slirp
->vhost_addr
, 4);
924 eh
->h_proto
= htons(ETH_P_IP
);
931 /* Prepare the IPv6 packet to be sent to the ethernet device. Returns 1 if no
932 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
935 static int if_encap6(Slirp
*slirp
, struct mbuf
*ifm
, struct ethhdr
*eh
,
936 uint8_t ethaddr
[ETH_ALEN
])
938 const struct ip6
*ip6h
= mtod(ifm
, const struct ip6
*);
939 if (!ndp_table_search(slirp
, ip6h
->ip_dst
, ethaddr
)) {
940 if (!ifm
->resolution_requested
) {
941 ndp_send_ns(slirp
, ip6h
->ip_dst
);
942 ifm
->resolution_requested
= true;
943 ifm
->expiration_date
= slirp
->cb
->clock_get_ns() + 1000000000ULL;
947 eh
->h_proto
= htons(ETH_P_IPV6
);
948 in6_compute_ethaddr(ip6h
->ip_src
, eh
->h_source
);
955 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
958 int if_encap(Slirp
*slirp
, struct mbuf
*ifm
)
961 struct ethhdr
*eh
= (struct ethhdr
*)buf
;
962 uint8_t ethaddr
[ETH_ALEN
];
963 const struct ip
*iph
= (const struct ip
*)ifm
->m_data
;
966 if (ifm
->m_len
+ ETH_HLEN
> sizeof(buf
)) {
972 ret
= if_encap4(slirp
, ifm
, eh
, ethaddr
);
979 ret
= if_encap6(slirp
, ifm
, eh
, ethaddr
);
986 g_assert_not_reached();
990 memcpy(eh
->h_dest
, ethaddr
, ETH_ALEN
);
991 DEBUG_ARG("src = %02x:%02x:%02x:%02x:%02x:%02x",
992 eh
->h_source
[0], eh
->h_source
[1], eh
->h_source
[2],
993 eh
->h_source
[3], eh
->h_source
[4], eh
->h_source
[5]);
994 DEBUG_ARG("dst = %02x:%02x:%02x:%02x:%02x:%02x",
995 eh
->h_dest
[0], eh
->h_dest
[1], eh
->h_dest
[2],
996 eh
->h_dest
[3], eh
->h_dest
[4], eh
->h_dest
[5]);
997 memcpy(buf
+ sizeof(struct ethhdr
), ifm
->m_data
, ifm
->m_len
);
998 slirp
->cb
->output(slirp
->opaque
, buf
, ifm
->m_len
+ ETH_HLEN
);
1002 /* Drop host forwarding rule, return 0 if found. */
1003 int slirp_remove_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
1007 struct socket
*head
= (is_udp
? &slirp
->udb
: &slirp
->tcb
);
1008 struct sockaddr_in addr
;
1009 int port
= htons(host_port
);
1012 for (so
= head
->so_next
; so
!= head
; so
= so
->so_next
) {
1013 addr_len
= sizeof(addr
);
1014 if ((so
->so_state
& SS_HOSTFWD
) &&
1015 getsockname(so
->s
, (struct sockaddr
*)&addr
, &addr_len
) == 0 &&
1016 addr
.sin_addr
.s_addr
== host_addr
.s_addr
&&
1017 addr
.sin_port
== port
) {
1018 so
->slirp
->cb
->unregister_poll_fd(so
->s
);
1019 slirp_closesocket(so
->s
);
1028 int slirp_add_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
1029 int host_port
, struct in_addr guest_addr
, int guest_port
)
1031 if (!guest_addr
.s_addr
) {
1032 guest_addr
= slirp
->vdhcp_startaddr
;
1035 if (!udp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
1036 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
1039 if (!tcp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
1040 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
1047 check_guestfwd(Slirp
*slirp
, struct in_addr
*guest_addr
, int guest_port
)
1049 struct gfwd_list
*tmp_ptr
;
1051 if (!guest_addr
->s_addr
) {
1052 guest_addr
->s_addr
= slirp
->vnetwork_addr
.s_addr
|
1053 (htonl(0x0204) & ~slirp
->vnetwork_mask
.s_addr
);
1055 if ((guest_addr
->s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
1056 slirp
->vnetwork_addr
.s_addr
||
1057 guest_addr
->s_addr
== slirp
->vhost_addr
.s_addr
||
1058 guest_addr
->s_addr
== slirp
->vnameserver_addr
.s_addr
) {
1062 /* check if the port is "bound" */
1063 for (tmp_ptr
= slirp
->guestfwd_list
; tmp_ptr
; tmp_ptr
= tmp_ptr
->ex_next
) {
1064 if (guest_port
== tmp_ptr
->ex_fport
&&
1065 guest_addr
->s_addr
== tmp_ptr
->ex_addr
.s_addr
)
1072 int slirp_add_exec(Slirp
*slirp
, const char *cmdline
,
1073 struct in_addr
*guest_addr
, int guest_port
)
1075 if (!check_guestfwd(slirp
, guest_addr
, guest_port
)) {
1079 add_exec(&slirp
->guestfwd_list
, cmdline
, *guest_addr
, htons(guest_port
));
1083 int slirp_add_guestfwd(Slirp
*slirp
, SlirpWriteCb write_cb
, void *opaque
,
1084 struct in_addr
*guest_addr
, int guest_port
)
1086 if (!check_guestfwd(slirp
, guest_addr
, guest_port
)) {
1090 add_guestfwd(&slirp
->guestfwd_list
, write_cb
, opaque
,
1091 *guest_addr
, htons(guest_port
));
1095 ssize_t
slirp_send(struct socket
*so
, const void *buf
, size_t len
, int flags
)
1097 if (so
->s
== -1 && so
->guestfwd
) {
1098 /* XXX this blocks entire thread. Rewrite to use
1099 * qemu_chr_fe_write and background I/O callbacks */
1100 so
->guestfwd
->write_cb(buf
, len
, so
->guestfwd
->opaque
);
1106 * This should in theory not happen but it is hard to be
1107 * sure because some code paths will end up with so->s == -1
1108 * on a failure but don't dispose of the struct socket.
1109 * Check specifically, so we don't pass -1 to send().
1115 return send(so
->s
, buf
, len
, flags
);
1118 static struct socket
*
1119 slirp_find_ctl_socket(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
)
1123 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
; so
= so
->so_next
) {
1124 if (so
->so_faddr
.s_addr
== guest_addr
.s_addr
&&
1125 htons(so
->so_fport
) == guest_port
) {
1132 size_t slirp_socket_can_recv(Slirp
*slirp
, struct in_addr guest_addr
,
1135 struct iovec iov
[2];
1138 so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
1140 if (!so
|| so
->so_state
& SS_NOFDREF
) {
1144 if (!CONN_CANFRCV(so
) || so
->so_snd
.sb_cc
>= (so
->so_snd
.sb_datalen
/2)) {
1148 return sopreprbuf(so
, iov
, NULL
);
1151 void slirp_socket_recv(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
,
1152 const uint8_t *buf
, int size
)
1155 struct socket
*so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
1160 ret
= soreadbuf(so
, (const char *)buf
, size
);
1163 tcp_output(sototcpcb(so
));
1166 static int slirp_tcp_post_load(void *opaque
, int version
)
1168 tcp_template((struct tcpcb
*)opaque
);
1173 static const VMStateDescription vmstate_slirp_tcp
= {
1174 .name
= "slirp-tcp",
1176 .post_load
= slirp_tcp_post_load
,
1177 .fields
= (VMStateField
[]) {
1178 VMSTATE_INT16(t_state
, struct tcpcb
),
1179 VMSTATE_INT16_ARRAY(t_timer
, struct tcpcb
, TCPT_NTIMERS
),
1180 VMSTATE_INT16(t_rxtshift
, struct tcpcb
),
1181 VMSTATE_INT16(t_rxtcur
, struct tcpcb
),
1182 VMSTATE_INT16(t_dupacks
, struct tcpcb
),
1183 VMSTATE_UINT16(t_maxseg
, struct tcpcb
),
1184 VMSTATE_UINT8(t_force
, struct tcpcb
),
1185 VMSTATE_UINT16(t_flags
, struct tcpcb
),
1186 VMSTATE_UINT32(snd_una
, struct tcpcb
),
1187 VMSTATE_UINT32(snd_nxt
, struct tcpcb
),
1188 VMSTATE_UINT32(snd_up
, struct tcpcb
),
1189 VMSTATE_UINT32(snd_wl1
, struct tcpcb
),
1190 VMSTATE_UINT32(snd_wl2
, struct tcpcb
),
1191 VMSTATE_UINT32(iss
, struct tcpcb
),
1192 VMSTATE_UINT32(snd_wnd
, struct tcpcb
),
1193 VMSTATE_UINT32(rcv_wnd
, struct tcpcb
),
1194 VMSTATE_UINT32(rcv_nxt
, struct tcpcb
),
1195 VMSTATE_UINT32(rcv_up
, struct tcpcb
),
1196 VMSTATE_UINT32(irs
, struct tcpcb
),
1197 VMSTATE_UINT32(rcv_adv
, struct tcpcb
),
1198 VMSTATE_UINT32(snd_max
, struct tcpcb
),
1199 VMSTATE_UINT32(snd_cwnd
, struct tcpcb
),
1200 VMSTATE_UINT32(snd_ssthresh
, struct tcpcb
),
1201 VMSTATE_INT16(t_idle
, struct tcpcb
),
1202 VMSTATE_INT16(t_rtt
, struct tcpcb
),
1203 VMSTATE_UINT32(t_rtseq
, struct tcpcb
),
1204 VMSTATE_INT16(t_srtt
, struct tcpcb
),
1205 VMSTATE_INT16(t_rttvar
, struct tcpcb
),
1206 VMSTATE_UINT16(t_rttmin
, struct tcpcb
),
1207 VMSTATE_UINT32(max_sndwnd
, struct tcpcb
),
1208 VMSTATE_UINT8(t_oobflags
, struct tcpcb
),
1209 VMSTATE_UINT8(t_iobc
, struct tcpcb
),
1210 VMSTATE_INT16(t_softerror
, struct tcpcb
),
1211 VMSTATE_UINT8(snd_scale
, struct tcpcb
),
1212 VMSTATE_UINT8(rcv_scale
, struct tcpcb
),
1213 VMSTATE_UINT8(request_r_scale
, struct tcpcb
),
1214 VMSTATE_UINT8(requested_s_scale
, struct tcpcb
),
1215 VMSTATE_UINT32(ts_recent
, struct tcpcb
),
1216 VMSTATE_UINT32(ts_recent_age
, struct tcpcb
),
1217 VMSTATE_UINT32(last_ack_sent
, struct tcpcb
),
1218 VMSTATE_END_OF_LIST()
1222 /* The sbuf has a pair of pointers that are migrated as offsets;
1223 * we calculate the offsets and restore the pointers using
1224 * pre_save/post_load on a tmp structure.
1227 struct sbuf
*parent
;
1228 uint32_t roff
, woff
;
1231 static int sbuf_tmp_pre_save(void *opaque
)
1233 struct sbuf_tmp
*tmp
= opaque
;
1234 tmp
->woff
= tmp
->parent
->sb_wptr
- tmp
->parent
->sb_data
;
1235 tmp
->roff
= tmp
->parent
->sb_rptr
- tmp
->parent
->sb_data
;
1240 static int sbuf_tmp_post_load(void *opaque
, int version
)
1242 struct sbuf_tmp
*tmp
= opaque
;
1243 uint32_t requested_len
= tmp
->parent
->sb_datalen
;
1245 /* Allocate the buffer space used by the field after the tmp */
1246 sbreserve(tmp
->parent
, tmp
->parent
->sb_datalen
);
1248 if (tmp
->parent
->sb_datalen
!= requested_len
) {
1251 if (tmp
->woff
>= requested_len
||
1252 tmp
->roff
>= requested_len
) {
1253 g_critical("invalid sbuf offsets r/w=%u/%u len=%u",
1254 tmp
->roff
, tmp
->woff
, requested_len
);
1258 tmp
->parent
->sb_wptr
= tmp
->parent
->sb_data
+ tmp
->woff
;
1259 tmp
->parent
->sb_rptr
= tmp
->parent
->sb_data
+ tmp
->roff
;
1265 static const VMStateDescription vmstate_slirp_sbuf_tmp
= {
1266 .name
= "slirp-sbuf-tmp",
1267 .post_load
= sbuf_tmp_post_load
,
1268 .pre_save
= sbuf_tmp_pre_save
,
1270 .fields
= (VMStateField
[]) {
1271 VMSTATE_UINT32(woff
, struct sbuf_tmp
),
1272 VMSTATE_UINT32(roff
, struct sbuf_tmp
),
1273 VMSTATE_END_OF_LIST()
1277 static const VMStateDescription vmstate_slirp_sbuf
= {
1278 .name
= "slirp-sbuf",
1280 .fields
= (VMStateField
[]) {
1281 VMSTATE_UINT32(sb_cc
, struct sbuf
),
1282 VMSTATE_UINT32(sb_datalen
, struct sbuf
),
1283 VMSTATE_WITH_TMP(struct sbuf
, struct sbuf_tmp
, vmstate_slirp_sbuf_tmp
),
1284 VMSTATE_VBUFFER_UINT32(sb_data
, struct sbuf
, 0, NULL
, sb_datalen
),
1285 VMSTATE_END_OF_LIST()
1289 static bool slirp_older_than_v4(void *opaque
, int version_id
)
1291 return version_id
< 4;
1294 static bool slirp_family_inet(void *opaque
, int version_id
)
1296 union slirp_sockaddr
*ssa
= (union slirp_sockaddr
*)opaque
;
1297 return ssa
->ss
.ss_family
== AF_INET
;
1300 static int slirp_socket_pre_load(void *opaque
)
1302 struct socket
*so
= opaque
;
1303 if (tcp_attach(so
) < 0) {
1306 /* Older versions don't load these fields */
1307 so
->so_ffamily
= AF_INET
;
1308 so
->so_lfamily
= AF_INET
;
1313 #define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_UINT32_TEST(f, s, t)
1315 /* Win uses u_long rather than uint32_t - but it's still 32bits long */
1316 #define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_SINGLE_TEST(f, s, t, 0, \
1317 vmstate_info_uint32, u_long)
1320 /* The OS provided ss_family field isn't that portable; it's size
1321 * and type varies (16/8 bit, signed, unsigned)
1322 * and the values it contains aren't fully portable.
1324 typedef struct SS_FamilyTmpStruct
{
1325 union slirp_sockaddr
*parent
;
1326 uint16_t portable_family
;
1327 } SS_FamilyTmpStruct
;
1329 #define SS_FAMILY_MIG_IPV4 2 /* Linux, BSD, Win... */
1330 #define SS_FAMILY_MIG_IPV6 10 /* Linux */
1331 #define SS_FAMILY_MIG_OTHER 0xffff
1333 static int ss_family_pre_save(void *opaque
)
1335 SS_FamilyTmpStruct
*tss
= opaque
;
1337 tss
->portable_family
= SS_FAMILY_MIG_OTHER
;
1339 if (tss
->parent
->ss
.ss_family
== AF_INET
) {
1340 tss
->portable_family
= SS_FAMILY_MIG_IPV4
;
1341 } else if (tss
->parent
->ss
.ss_family
== AF_INET6
) {
1342 tss
->portable_family
= SS_FAMILY_MIG_IPV6
;
1348 static int ss_family_post_load(void *opaque
, int version_id
)
1350 SS_FamilyTmpStruct
*tss
= opaque
;
1352 switch (tss
->portable_family
) {
1353 case SS_FAMILY_MIG_IPV4
:
1354 tss
->parent
->ss
.ss_family
= AF_INET
;
1356 case SS_FAMILY_MIG_IPV6
:
1357 case 23: /* compatibility: AF_INET6 from mingw */
1358 case 28: /* compatibility: AF_INET6 from FreeBSD sys/socket.h */
1359 tss
->parent
->ss
.ss_family
= AF_INET6
;
1362 g_critical("invalid ss_family type %x", tss
->portable_family
);
1369 static const VMStateDescription vmstate_slirp_ss_family
= {
1370 .name
= "slirp-socket-addr/ss_family",
1371 .pre_save
= ss_family_pre_save
,
1372 .post_load
= ss_family_post_load
,
1373 .fields
= (VMStateField
[]) {
1374 VMSTATE_UINT16(portable_family
, SS_FamilyTmpStruct
),
1375 VMSTATE_END_OF_LIST()
1379 static const VMStateDescription vmstate_slirp_socket_addr
= {
1380 .name
= "slirp-socket-addr",
1382 .fields
= (VMStateField
[]) {
1383 VMSTATE_WITH_TMP(union slirp_sockaddr
, SS_FamilyTmpStruct
,
1384 vmstate_slirp_ss_family
),
1385 VMSTATE_SIN4_ADDR(sin
.sin_addr
.s_addr
, union slirp_sockaddr
,
1387 VMSTATE_UINT16_TEST(sin
.sin_port
, union slirp_sockaddr
,
1391 /* Untested: Needs checking by someone with IPv6 test */
1392 VMSTATE_BUFFER_TEST(sin6
.sin6_addr
, union slirp_sockaddr
,
1393 slirp_family_inet6
),
1394 VMSTATE_UINT16_TEST(sin6
.sin6_port
, union slirp_sockaddr
,
1395 slirp_family_inet6
),
1396 VMSTATE_UINT32_TEST(sin6
.sin6_flowinfo
, union slirp_sockaddr
,
1397 slirp_family_inet6
),
1398 VMSTATE_UINT32_TEST(sin6
.sin6_scope_id
, union slirp_sockaddr
,
1399 slirp_family_inet6
),
1402 VMSTATE_END_OF_LIST()
1406 static const VMStateDescription vmstate_slirp_socket
= {
1407 .name
= "slirp-socket",
1409 .pre_load
= slirp_socket_pre_load
,
1410 .fields
= (VMStateField
[]) {
1411 VMSTATE_UINT32(so_urgc
, struct socket
),
1412 /* Pre-v4 versions */
1413 VMSTATE_SIN4_ADDR(so_faddr
.s_addr
, struct socket
,
1414 slirp_older_than_v4
),
1415 VMSTATE_SIN4_ADDR(so_laddr
.s_addr
, struct socket
,
1416 slirp_older_than_v4
),
1417 VMSTATE_UINT16_TEST(so_fport
, struct socket
, slirp_older_than_v4
),
1418 VMSTATE_UINT16_TEST(so_lport
, struct socket
, slirp_older_than_v4
),
1420 VMSTATE_STRUCT(fhost
, struct socket
, 4, vmstate_slirp_socket_addr
,
1421 union slirp_sockaddr
),
1422 VMSTATE_STRUCT(lhost
, struct socket
, 4, vmstate_slirp_socket_addr
,
1423 union slirp_sockaddr
),
1425 VMSTATE_UINT8(so_iptos
, struct socket
),
1426 VMSTATE_UINT8(so_emu
, struct socket
),
1427 VMSTATE_UINT8(so_type
, struct socket
),
1428 VMSTATE_INT32(so_state
, struct socket
),
1429 VMSTATE_STRUCT(so_rcv
, struct socket
, 0, vmstate_slirp_sbuf
,
1431 VMSTATE_STRUCT(so_snd
, struct socket
, 0, vmstate_slirp_sbuf
,
1433 VMSTATE_STRUCT_POINTER(so_tcpcb
, struct socket
, vmstate_slirp_tcp
,
1435 VMSTATE_END_OF_LIST()
1439 static const VMStateDescription vmstate_slirp_bootp_client
= {
1440 .name
= "slirp_bootpclient",
1441 .fields
= (VMStateField
[]) {
1442 VMSTATE_UINT16(allocated
, BOOTPClient
),
1443 VMSTATE_BUFFER(macaddr
, BOOTPClient
),
1444 VMSTATE_END_OF_LIST()
1448 static const VMStateDescription vmstate_slirp
= {
1451 .fields
= (VMStateField
[]) {
1452 VMSTATE_UINT16_V(ip_id
, Slirp
, 2),
1453 VMSTATE_STRUCT_ARRAY(bootp_clients
, Slirp
, NB_BOOTP_CLIENTS
, 3,
1454 vmstate_slirp_bootp_client
, BOOTPClient
),
1455 VMSTATE_END_OF_LIST()
1459 static void slirp_state_save(QEMUFile
*f
, void *opaque
)
1461 Slirp
*slirp
= opaque
;
1462 struct gfwd_list
*ex_ptr
;
1464 for (ex_ptr
= slirp
->guestfwd_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
)
1465 if (ex_ptr
->write_cb
) {
1467 so
= slirp_find_ctl_socket(slirp
, ex_ptr
->ex_addr
,
1468 ntohs(ex_ptr
->ex_fport
));
1472 qemu_put_byte(f
, 42);
1473 vmstate_save_state(f
, &vmstate_slirp_socket
, so
, NULL
);
1475 qemu_put_byte(f
, 0);
1477 vmstate_save_state(f
, &vmstate_slirp
, slirp
, NULL
);
1481 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
)
1483 Slirp
*slirp
= opaque
;
1484 struct gfwd_list
*ex_ptr
;
1486 while (qemu_get_byte(f
)) {
1488 struct socket
*so
= socreate(slirp
);
1490 ret
= vmstate_load_state(f
, &vmstate_slirp_socket
, so
, version_id
);
1495 if ((so
->so_faddr
.s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
1496 slirp
->vnetwork_addr
.s_addr
) {
1499 for (ex_ptr
= slirp
->guestfwd_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
1500 if (ex_ptr
->write_cb
&&
1501 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
&&
1502 so
->so_fport
== ex_ptr
->ex_fport
) {
1510 return vmstate_load_state(f
, &vmstate_slirp
, slirp
, version_id
);