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 "sysemu/char.h"
31 #include "qemu/cutils.h"
33 /* host loopback address */
34 struct in_addr loopback_addr
;
35 /* host loopback network mask */
36 unsigned long loopback_mask
;
38 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
39 static const uint8_t special_ethaddr
[ETH_ALEN
] = {
40 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
45 static QTAILQ_HEAD(slirp_instances
, Slirp
) slirp_instances
=
46 QTAILQ_HEAD_INITIALIZER(slirp_instances
);
48 static struct in_addr dns_addr
;
49 static struct in6_addr dns6_addr
;
50 static u_int dns_addr_time
;
51 static u_int dns6_addr_time
;
53 #define TIMEOUT_FAST 2 /* milliseconds */
54 #define TIMEOUT_SLOW 499 /* milliseconds */
55 /* for the aging of certain requests like DNS */
56 #define TIMEOUT_DEFAULT 1000 /* milliseconds */
60 int get_dns_addr(struct in_addr
*pdns_addr
)
62 FIXED_INFO
*FixedInfo
=NULL
;
65 IP_ADDR_STRING
*pIPAddr
;
66 struct in_addr tmp_addr
;
68 if (dns_addr
.s_addr
!= 0 && (curtime
- dns_addr_time
) < TIMEOUT_DEFAULT
) {
69 *pdns_addr
= dns_addr
;
73 FixedInfo
= (FIXED_INFO
*)GlobalAlloc(GPTR
, sizeof(FIXED_INFO
));
74 BufLen
= sizeof(FIXED_INFO
);
76 if (ERROR_BUFFER_OVERFLOW
== GetNetworkParams(FixedInfo
, &BufLen
)) {
78 GlobalFree(FixedInfo
);
81 FixedInfo
= GlobalAlloc(GPTR
, BufLen
);
84 if ((ret
= GetNetworkParams(FixedInfo
, &BufLen
)) != ERROR_SUCCESS
) {
85 printf("GetNetworkParams failed. ret = %08x\n", (u_int
)ret
);
87 GlobalFree(FixedInfo
);
93 pIPAddr
= &(FixedInfo
->DnsServerList
);
94 inet_aton(pIPAddr
->IpAddress
.String
, &tmp_addr
);
95 *pdns_addr
= tmp_addr
;
97 dns_addr_time
= curtime
;
99 GlobalFree(FixedInfo
);
105 int get_dns6_addr(struct in6_addr
*pdns_addr6
)
110 static void winsock_cleanup(void)
117 static int get_dns_addr_cached(void *pdns_addr
, void *cached_addr
,
119 struct stat
*cached_stat
, u_int
*cached_time
)
121 struct stat old_stat
;
122 if (curtime
- *cached_time
< TIMEOUT_DEFAULT
) {
123 memcpy(pdns_addr
, cached_addr
, addrlen
);
126 old_stat
= *cached_stat
;
127 if (stat("/etc/resolv.conf", cached_stat
) != 0) {
130 if (cached_stat
->st_dev
== old_stat
.st_dev
131 && cached_stat
->st_ino
== old_stat
.st_ino
132 && cached_stat
->st_size
== old_stat
.st_size
133 && cached_stat
->st_mtime
== old_stat
.st_mtime
) {
134 memcpy(pdns_addr
, cached_addr
, addrlen
);
140 static int get_dns_addr_resolv_conf(int af
, void *pdns_addr
, void *cached_addr
,
141 socklen_t addrlen
, u_int
*cached_time
)
147 void *tmp_addr
= alloca(addrlen
);
149 f
= fopen("/etc/resolv.conf", "r");
154 fprintf(stderr
, "IP address of your DNS(s): ");
156 while (fgets(buff
, 512, f
) != NULL
) {
157 if (sscanf(buff
, "nameserver%*[ \t]%256s", buff2
) == 1) {
158 if (!inet_pton(af
, buff2
, tmp_addr
)) {
161 /* If it's the first one, set it to dns_addr */
163 memcpy(pdns_addr
, tmp_addr
, addrlen
);
164 memcpy(cached_addr
, tmp_addr
, addrlen
);
165 *cached_time
= curtime
;
169 fprintf(stderr
, ", ");
173 fprintf(stderr
, "(more)");
179 char s
[INET6_ADDRSTRLEN
];
180 char *res
= inet_ntop(af
, tmp_addr
, s
, sizeof(s
));
182 res
= "(string conversion error)";
184 fprintf(stderr
, "%s", res
);
195 int get_dns_addr(struct in_addr
*pdns_addr
)
197 static struct stat dns_addr_stat
;
199 if (dns_addr
.s_addr
!= 0) {
201 ret
= get_dns_addr_cached(pdns_addr
, &dns_addr
, sizeof(dns_addr
),
202 &dns_addr_stat
, &dns_addr_time
);
207 return get_dns_addr_resolv_conf(AF_INET
, pdns_addr
, &dns_addr
,
208 sizeof(dns_addr
), &dns_addr_time
);
211 int get_dns6_addr(struct in6_addr
*pdns6_addr
)
213 static struct stat dns6_addr_stat
;
215 if (!in6_zero(&dns6_addr
)) {
217 ret
= get_dns_addr_cached(pdns6_addr
, &dns6_addr
, sizeof(dns6_addr
),
218 &dns6_addr_stat
, &dns6_addr_time
);
223 return get_dns_addr_resolv_conf(AF_INET6
, pdns6_addr
, &dns6_addr
,
224 sizeof(dns6_addr
), &dns6_addr_time
);
229 static void slirp_init_once(void)
231 static int initialized
;
242 WSAStartup(MAKEWORD(2,0), &Data
);
243 atexit(winsock_cleanup
);
246 loopback_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
247 loopback_mask
= htonl(IN_CLASSA_NET
);
250 static void slirp_state_save(QEMUFile
*f
, void *opaque
);
251 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
);
253 Slirp
*slirp_init(int restricted
, bool in_enabled
, struct in_addr vnetwork
,
254 struct in_addr vnetmask
, struct in_addr vhost
,
256 struct in6_addr vprefix_addr6
, uint8_t vprefix_len
,
257 struct in6_addr vhost6
, const char *vhostname
,
258 const char *tftp_path
, const char *bootfile
,
259 struct in_addr vdhcp_start
, struct in_addr vnameserver
,
260 struct in6_addr vnameserver6
, const char **vdnssearch
,
263 Slirp
*slirp
= g_malloc0(sizeof(Slirp
));
267 slirp
->grand
= g_rand_new();
268 slirp
->restricted
= restricted
;
270 slirp
->in_enabled
= in_enabled
;
271 slirp
->in6_enabled
= in6_enabled
;
277 /* Initialise mbufs *after* setting the MTU */
280 slirp
->vnetwork_addr
= vnetwork
;
281 slirp
->vnetwork_mask
= vnetmask
;
282 slirp
->vhost_addr
= vhost
;
283 slirp
->vprefix_addr6
= vprefix_addr6
;
284 slirp
->vprefix_len
= vprefix_len
;
285 slirp
->vhost_addr6
= vhost6
;
287 pstrcpy(slirp
->client_hostname
, sizeof(slirp
->client_hostname
),
290 slirp
->tftp_prefix
= g_strdup(tftp_path
);
291 slirp
->bootp_filename
= g_strdup(bootfile
);
292 slirp
->vdhcp_startaddr
= vdhcp_start
;
293 slirp
->vnameserver_addr
= vnameserver
;
294 slirp
->vnameserver_addr6
= vnameserver6
;
297 translate_dnssearch(slirp
, vdnssearch
);
300 slirp
->opaque
= opaque
;
302 register_savevm(NULL
, "slirp", 0, 4,
303 slirp_state_save
, slirp_state_load
, slirp
);
305 QTAILQ_INSERT_TAIL(&slirp_instances
, slirp
, entry
);
310 void slirp_cleanup(Slirp
*slirp
)
312 QTAILQ_REMOVE(&slirp_instances
, slirp
, entry
);
314 unregister_savevm(NULL
, "slirp", slirp
);
320 g_rand_free(slirp
->grand
);
322 g_free(slirp
->vdnssearch
);
323 g_free(slirp
->tftp_prefix
);
324 g_free(slirp
->bootp_filename
);
328 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
329 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
331 static void slirp_update_timeout(uint32_t *timeout
)
336 if (*timeout
<= TIMEOUT_FAST
) {
340 t
= MIN(1000, *timeout
);
342 /* If we have tcp timeout with slirp, then we will fill @timeout with
343 * more precise value.
345 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
346 if (slirp
->time_fasttimo
) {
347 *timeout
= TIMEOUT_FAST
;
350 if (slirp
->do_slowtimo
) {
351 t
= MIN(TIMEOUT_SLOW
, t
);
357 void slirp_pollfds_fill(GArray
*pollfds
, uint32_t *timeout
)
360 struct socket
*so
, *so_next
;
362 if (QTAILQ_EMPTY(&slirp_instances
)) {
370 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
372 * *_slowtimo needs calling if there are IP fragments
373 * in the fragment queue, or there are TCP connections active
375 slirp
->do_slowtimo
= ((slirp
->tcb
.so_next
!= &slirp
->tcb
) ||
376 (&slirp
->ipq
.ip_link
!= slirp
->ipq
.ip_link
.next
));
378 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
382 so_next
= so
->so_next
;
384 so
->pollfds_idx
= -1;
387 * See if we need a tcp_fasttimo
389 if (slirp
->time_fasttimo
== 0 &&
390 so
->so_tcpcb
->t_flags
& TF_DELACK
) {
391 slirp
->time_fasttimo
= curtime
; /* Flag when want a fasttimo */
395 * NOFDREF can include still connecting to local-host,
396 * newly socreated() sockets etc. Don't want to select these.
398 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
403 * Set for reading sockets which are accepting
405 if (so
->so_state
& SS_FACCEPTCONN
) {
408 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
410 so
->pollfds_idx
= pollfds
->len
;
411 g_array_append_val(pollfds
, pfd
);
416 * Set for writing sockets which are connecting
418 if (so
->so_state
& SS_ISFCONNECTING
) {
421 .events
= G_IO_OUT
| G_IO_ERR
,
423 so
->pollfds_idx
= pollfds
->len
;
424 g_array_append_val(pollfds
, pfd
);
429 * Set for writing if we are connected, can send more, and
430 * we have something to send
432 if (CONN_CANFSEND(so
) && so
->so_rcv
.sb_cc
) {
433 events
|= G_IO_OUT
| G_IO_ERR
;
437 * Set for reading (and urgent data) if we are connected, can
438 * receive more, and we have room for it XXX /2 ?
440 if (CONN_CANFRCV(so
) &&
441 (so
->so_snd
.sb_cc
< (so
->so_snd
.sb_datalen
/2))) {
442 events
|= G_IO_IN
| G_IO_HUP
| G_IO_ERR
| G_IO_PRI
;
450 so
->pollfds_idx
= pollfds
->len
;
451 g_array_append_val(pollfds
, pfd
);
458 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
460 so_next
= so
->so_next
;
462 so
->pollfds_idx
= -1;
465 * See if it's timed out
468 if (so
->so_expire
<= curtime
) {
472 slirp
->do_slowtimo
= true; /* Let socket expire */
477 * When UDP packets are received from over the
478 * link, they're sendto()'d straight away, so
479 * no need for setting for writing
480 * Limit the number of packets queued by this session
481 * to 4. Note that even though we try and limit this
482 * to 4 packets, the session could have more queued
483 * if the packets needed to be fragmented
486 if ((so
->so_state
& SS_ISFCONNECTED
) && so
->so_queued
<= 4) {
489 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
491 so
->pollfds_idx
= pollfds
->len
;
492 g_array_append_val(pollfds
, pfd
);
499 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
501 so_next
= so
->so_next
;
503 so
->pollfds_idx
= -1;
506 * See if it's timed out
509 if (so
->so_expire
<= curtime
) {
513 slirp
->do_slowtimo
= true; /* Let socket expire */
517 if (so
->so_state
& SS_ISFCONNECTED
) {
520 .events
= G_IO_IN
| G_IO_HUP
| G_IO_ERR
,
522 so
->pollfds_idx
= pollfds
->len
;
523 g_array_append_val(pollfds
, pfd
);
527 slirp_update_timeout(timeout
);
530 void slirp_pollfds_poll(GArray
*pollfds
, int select_error
)
533 struct socket
*so
, *so_next
;
536 if (QTAILQ_EMPTY(&slirp_instances
)) {
540 curtime
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
542 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
544 * See if anything has timed out
546 if (slirp
->time_fasttimo
&&
547 ((curtime
- slirp
->time_fasttimo
) >= TIMEOUT_FAST
)) {
549 slirp
->time_fasttimo
= 0;
551 if (slirp
->do_slowtimo
&&
552 ((curtime
- slirp
->last_slowtimo
) >= TIMEOUT_SLOW
)) {
555 slirp
->last_slowtimo
= curtime
;
565 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
569 so_next
= so
->so_next
;
572 if (so
->pollfds_idx
!= -1) {
573 revents
= g_array_index(pollfds
, GPollFD
,
574 so
->pollfds_idx
).revents
;
577 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
583 * This will soread as well, so no need to
584 * test for G_IO_IN below if this succeeds
586 if (revents
& G_IO_PRI
) {
589 /* Socket error might have resulted in the socket being
590 * removed, do not try to do anything more with it. */
595 * Check sockets for reading
597 else if (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
)) {
599 * Check for incoming connections
601 if (so
->so_state
& SS_FACCEPTCONN
) {
607 /* Output it if we read something */
609 tcp_output(sototcpcb(so
));
612 /* Socket error might have resulted in the socket being
613 * removed, do not try to do anything more with it. */
619 * Check sockets for writing
621 if (!(so
->so_state
& SS_NOFDREF
) &&
622 (revents
& (G_IO_OUT
| G_IO_ERR
))) {
624 * Check for non-blocking, still-connecting sockets
626 if (so
->so_state
& SS_ISFCONNECTING
) {
628 so
->so_state
&= ~SS_ISFCONNECTING
;
630 ret
= send(so
->s
, (const void *) &ret
, 0, 0);
632 /* XXXXX Must fix, zero bytes is a NOP */
633 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
634 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
639 so
->so_state
&= SS_PERSISTENT_MASK
;
640 so
->so_state
|= SS_NOFDREF
;
642 /* else so->so_state &= ~SS_ISFCONNECTING; */
647 tcp_input((struct mbuf
*)NULL
, sizeof(struct ip
), so
,
654 * XXXXX If we wrote something (a lot), there
655 * could be a need for a window update.
656 * In the worst case, the remote will send
657 * a window probe to get things going again
662 * Probe a still-connecting, non-blocking socket
663 * to check if it's still alive
666 if (so
->so_state
& SS_ISFCONNECTING
) {
667 ret
= qemu_recv(so
->s
, &ret
, 0, 0);
671 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
672 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
673 continue; /* Still connecting, continue */
677 so
->so_state
&= SS_PERSISTENT_MASK
;
678 so
->so_state
|= SS_NOFDREF
;
680 /* tcp_input will take care of it */
682 ret
= send(so
->s
, &ret
, 0, 0);
685 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
686 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
690 so
->so_state
&= SS_PERSISTENT_MASK
;
691 so
->so_state
|= SS_NOFDREF
;
693 so
->so_state
&= ~SS_ISFCONNECTING
;
697 tcp_input((struct mbuf
*)NULL
, sizeof(struct ip
), so
,
699 } /* SS_ISFCONNECTING */
705 * Incoming packets are sent straight away, they're not buffered.
706 * Incoming UDP data isn't buffered either.
708 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
712 so_next
= so
->so_next
;
715 if (so
->pollfds_idx
!= -1) {
716 revents
= g_array_index(pollfds
, GPollFD
,
717 so
->pollfds_idx
).revents
;
721 (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
))) {
727 * Check incoming ICMP relies.
729 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
733 so_next
= so
->so_next
;
736 if (so
->pollfds_idx
!= -1) {
737 revents
= g_array_index(pollfds
, GPollFD
,
738 so
->pollfds_idx
).revents
;
742 (revents
& (G_IO_IN
| G_IO_HUP
| G_IO_ERR
))) {
752 static void arp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
754 struct arphdr
*ah
= (struct arphdr
*)(pkt
+ ETH_HLEN
);
755 uint8_t arp_reply
[max(ETH_HLEN
+ sizeof(struct arphdr
), 64)];
756 struct ethhdr
*reh
= (struct ethhdr
*)arp_reply
;
757 struct arphdr
*rah
= (struct arphdr
*)(arp_reply
+ ETH_HLEN
);
759 struct ex_list
*ex_ptr
;
761 if (!slirp
->in_enabled
) {
765 ar_op
= ntohs(ah
->ar_op
);
768 if (ah
->ar_tip
== ah
->ar_sip
) {
770 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
774 if ((ah
->ar_tip
& slirp
->vnetwork_mask
.s_addr
) ==
775 slirp
->vnetwork_addr
.s_addr
) {
776 if (ah
->ar_tip
== slirp
->vnameserver_addr
.s_addr
||
777 ah
->ar_tip
== slirp
->vhost_addr
.s_addr
)
779 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
780 if (ex_ptr
->ex_addr
.s_addr
== ah
->ar_tip
)
785 memset(arp_reply
, 0, sizeof(arp_reply
));
787 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
789 /* ARP request for alias/dns mac address */
790 memcpy(reh
->h_dest
, pkt
+ ETH_ALEN
, ETH_ALEN
);
791 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
792 memcpy(&reh
->h_source
[2], &ah
->ar_tip
, 4);
793 reh
->h_proto
= htons(ETH_P_ARP
);
795 rah
->ar_hrd
= htons(1);
796 rah
->ar_pro
= htons(ETH_P_IP
);
797 rah
->ar_hln
= ETH_ALEN
;
799 rah
->ar_op
= htons(ARPOP_REPLY
);
800 memcpy(rah
->ar_sha
, reh
->h_source
, ETH_ALEN
);
801 rah
->ar_sip
= ah
->ar_tip
;
802 memcpy(rah
->ar_tha
, ah
->ar_sha
, ETH_ALEN
);
803 rah
->ar_tip
= ah
->ar_sip
;
804 slirp_output(slirp
->opaque
, arp_reply
, sizeof(arp_reply
));
808 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
815 void slirp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
820 if (pkt_len
< ETH_HLEN
)
823 proto
= ntohs(*(uint16_t *)(pkt
+ 12));
826 arp_input(slirp
, pkt
, pkt_len
);
833 /* Note: we add 2 to align the IP header on 4 bytes,
834 * and add the margin for the tcpiphdr overhead */
835 if (M_FREEROOM(m
) < pkt_len
+ TCPIPHDR_DELTA
+ 2) {
836 m_inc(m
, pkt_len
+ TCPIPHDR_DELTA
+ 2);
838 m
->m_len
= pkt_len
+ TCPIPHDR_DELTA
+ 2;
839 memcpy(m
->m_data
+ TCPIPHDR_DELTA
+ 2, pkt
, pkt_len
);
841 m
->m_data
+= TCPIPHDR_DELTA
+ 2 + ETH_HLEN
;
842 m
->m_len
-= TCPIPHDR_DELTA
+ 2 + ETH_HLEN
;
844 if (proto
== ETH_P_IP
) {
846 } else if (proto
== ETH_P_IPV6
) {
856 /* Prepare the IPv4 packet to be sent to the ethernet device. Returns 1 if no
857 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
860 static int if_encap4(Slirp
*slirp
, struct mbuf
*ifm
, struct ethhdr
*eh
,
861 uint8_t ethaddr
[ETH_ALEN
])
863 const struct ip
*iph
= (const struct ip
*)ifm
->m_data
;
865 if (iph
->ip_dst
.s_addr
== 0) {
866 /* 0.0.0.0 can not be a destination address, something went wrong,
867 * avoid making it worse */
870 if (!arp_table_search(slirp
, iph
->ip_dst
.s_addr
, ethaddr
)) {
871 uint8_t arp_req
[ETH_HLEN
+ sizeof(struct arphdr
)];
872 struct ethhdr
*reh
= (struct ethhdr
*)arp_req
;
873 struct arphdr
*rah
= (struct arphdr
*)(arp_req
+ ETH_HLEN
);
875 if (!ifm
->resolution_requested
) {
876 /* If the client addr is not known, send an ARP request */
877 memset(reh
->h_dest
, 0xff, ETH_ALEN
);
878 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
879 memcpy(&reh
->h_source
[2], &slirp
->vhost_addr
, 4);
880 reh
->h_proto
= htons(ETH_P_ARP
);
881 rah
->ar_hrd
= htons(1);
882 rah
->ar_pro
= htons(ETH_P_IP
);
883 rah
->ar_hln
= ETH_ALEN
;
885 rah
->ar_op
= htons(ARPOP_REQUEST
);
888 memcpy(rah
->ar_sha
, special_ethaddr
, ETH_ALEN
- 4);
889 memcpy(&rah
->ar_sha
[2], &slirp
->vhost_addr
, 4);
892 rah
->ar_sip
= slirp
->vhost_addr
.s_addr
;
894 /* target hw addr (none) */
895 memset(rah
->ar_tha
, 0, ETH_ALEN
);
898 rah
->ar_tip
= iph
->ip_dst
.s_addr
;
899 slirp
->client_ipaddr
= iph
->ip_dst
;
900 slirp_output(slirp
->opaque
, arp_req
, sizeof(arp_req
));
901 ifm
->resolution_requested
= true;
903 /* Expire request and drop outgoing packet after 1 second */
904 ifm
->expiration_date
= qemu_clock_get_ns(QEMU_CLOCK_REALTIME
) + 1000000000ULL;
908 memcpy(eh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
909 /* XXX: not correct */
910 memcpy(&eh
->h_source
[2], &slirp
->vhost_addr
, 4);
911 eh
->h_proto
= htons(ETH_P_IP
);
918 /* Prepare the IPv6 packet to be sent to the ethernet device. Returns 1 if no
919 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
922 static int if_encap6(Slirp
*slirp
, struct mbuf
*ifm
, struct ethhdr
*eh
,
923 uint8_t ethaddr
[ETH_ALEN
])
925 const struct ip6
*ip6h
= mtod(ifm
, const struct ip6
*);
926 if (!ndp_table_search(slirp
, ip6h
->ip_dst
, ethaddr
)) {
927 if (!ifm
->resolution_requested
) {
928 ndp_send_ns(slirp
, ip6h
->ip_dst
);
929 ifm
->resolution_requested
= true;
930 ifm
->expiration_date
=
931 qemu_clock_get_ns(QEMU_CLOCK_REALTIME
) + 1000000000ULL;
935 eh
->h_proto
= htons(ETH_P_IPV6
);
936 in6_compute_ethaddr(ip6h
->ip_src
, eh
->h_source
);
943 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
946 int if_encap(Slirp
*slirp
, struct mbuf
*ifm
)
949 struct ethhdr
*eh
= (struct ethhdr
*)buf
;
950 uint8_t ethaddr
[ETH_ALEN
];
951 const struct ip
*iph
= (const struct ip
*)ifm
->m_data
;
954 if (ifm
->m_len
+ ETH_HLEN
> sizeof(buf
)) {
960 ret
= if_encap4(slirp
, ifm
, eh
, ethaddr
);
967 ret
= if_encap6(slirp
, ifm
, eh
, ethaddr
);
974 g_assert_not_reached();
978 memcpy(eh
->h_dest
, ethaddr
, ETH_ALEN
);
979 DEBUG_ARGS((dfd
, " src = %02x:%02x:%02x:%02x:%02x:%02x\n",
980 eh
->h_source
[0], eh
->h_source
[1], eh
->h_source
[2],
981 eh
->h_source
[3], eh
->h_source
[4], eh
->h_source
[5]));
982 DEBUG_ARGS((dfd
, " dst = %02x:%02x:%02x:%02x:%02x:%02x\n",
983 eh
->h_dest
[0], eh
->h_dest
[1], eh
->h_dest
[2],
984 eh
->h_dest
[3], eh
->h_dest
[4], eh
->h_dest
[5]));
985 memcpy(buf
+ sizeof(struct ethhdr
), ifm
->m_data
, ifm
->m_len
);
986 slirp_output(slirp
->opaque
, buf
, ifm
->m_len
+ ETH_HLEN
);
990 /* Drop host forwarding rule, return 0 if found. */
991 int slirp_remove_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
995 struct socket
*head
= (is_udp
? &slirp
->udb
: &slirp
->tcb
);
996 struct sockaddr_in addr
;
997 int port
= htons(host_port
);
1000 for (so
= head
->so_next
; so
!= head
; so
= so
->so_next
) {
1001 addr_len
= sizeof(addr
);
1002 if ((so
->so_state
& SS_HOSTFWD
) &&
1003 getsockname(so
->s
, (struct sockaddr
*)&addr
, &addr_len
) == 0 &&
1004 addr
.sin_addr
.s_addr
== host_addr
.s_addr
&&
1005 addr
.sin_port
== port
) {
1015 int slirp_add_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
1016 int host_port
, struct in_addr guest_addr
, int guest_port
)
1018 if (!guest_addr
.s_addr
) {
1019 guest_addr
= slirp
->vdhcp_startaddr
;
1022 if (!udp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
1023 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
1026 if (!tcp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
1027 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
1033 int slirp_add_exec(Slirp
*slirp
, int do_pty
, const void *args
,
1034 struct in_addr
*guest_addr
, int guest_port
)
1036 if (!guest_addr
->s_addr
) {
1037 guest_addr
->s_addr
= slirp
->vnetwork_addr
.s_addr
|
1038 (htonl(0x0204) & ~slirp
->vnetwork_mask
.s_addr
);
1040 if ((guest_addr
->s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
1041 slirp
->vnetwork_addr
.s_addr
||
1042 guest_addr
->s_addr
== slirp
->vhost_addr
.s_addr
||
1043 guest_addr
->s_addr
== slirp
->vnameserver_addr
.s_addr
) {
1046 return add_exec(&slirp
->exec_list
, do_pty
, (char *)args
, *guest_addr
,
1050 ssize_t
slirp_send(struct socket
*so
, const void *buf
, size_t len
, int flags
)
1052 if (so
->s
== -1 && so
->extra
) {
1053 qemu_chr_fe_write(so
->extra
, buf
, len
);
1057 return send(so
->s
, buf
, len
, flags
);
1060 static struct socket
*
1061 slirp_find_ctl_socket(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
)
1065 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
; so
= so
->so_next
) {
1066 if (so
->so_faddr
.s_addr
== guest_addr
.s_addr
&&
1067 htons(so
->so_fport
) == guest_port
) {
1074 size_t slirp_socket_can_recv(Slirp
*slirp
, struct in_addr guest_addr
,
1077 struct iovec iov
[2];
1080 so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
1082 if (!so
|| so
->so_state
& SS_NOFDREF
) {
1086 if (!CONN_CANFRCV(so
) || so
->so_snd
.sb_cc
>= (so
->so_snd
.sb_datalen
/2)) {
1090 return sopreprbuf(so
, iov
, NULL
);
1093 void slirp_socket_recv(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
,
1094 const uint8_t *buf
, int size
)
1097 struct socket
*so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
1102 ret
= soreadbuf(so
, (const char *)buf
, size
);
1105 tcp_output(sototcpcb(so
));
1108 static void slirp_tcp_save(QEMUFile
*f
, struct tcpcb
*tp
)
1112 qemu_put_sbe16(f
, tp
->t_state
);
1113 for (i
= 0; i
< TCPT_NTIMERS
; i
++)
1114 qemu_put_sbe16(f
, tp
->t_timer
[i
]);
1115 qemu_put_sbe16(f
, tp
->t_rxtshift
);
1116 qemu_put_sbe16(f
, tp
->t_rxtcur
);
1117 qemu_put_sbe16(f
, tp
->t_dupacks
);
1118 qemu_put_be16(f
, tp
->t_maxseg
);
1119 qemu_put_sbyte(f
, tp
->t_force
);
1120 qemu_put_be16(f
, tp
->t_flags
);
1121 qemu_put_be32(f
, tp
->snd_una
);
1122 qemu_put_be32(f
, tp
->snd_nxt
);
1123 qemu_put_be32(f
, tp
->snd_up
);
1124 qemu_put_be32(f
, tp
->snd_wl1
);
1125 qemu_put_be32(f
, tp
->snd_wl2
);
1126 qemu_put_be32(f
, tp
->iss
);
1127 qemu_put_be32(f
, tp
->snd_wnd
);
1128 qemu_put_be32(f
, tp
->rcv_wnd
);
1129 qemu_put_be32(f
, tp
->rcv_nxt
);
1130 qemu_put_be32(f
, tp
->rcv_up
);
1131 qemu_put_be32(f
, tp
->irs
);
1132 qemu_put_be32(f
, tp
->rcv_adv
);
1133 qemu_put_be32(f
, tp
->snd_max
);
1134 qemu_put_be32(f
, tp
->snd_cwnd
);
1135 qemu_put_be32(f
, tp
->snd_ssthresh
);
1136 qemu_put_sbe16(f
, tp
->t_idle
);
1137 qemu_put_sbe16(f
, tp
->t_rtt
);
1138 qemu_put_be32(f
, tp
->t_rtseq
);
1139 qemu_put_sbe16(f
, tp
->t_srtt
);
1140 qemu_put_sbe16(f
, tp
->t_rttvar
);
1141 qemu_put_be16(f
, tp
->t_rttmin
);
1142 qemu_put_be32(f
, tp
->max_sndwnd
);
1143 qemu_put_byte(f
, tp
->t_oobflags
);
1144 qemu_put_byte(f
, tp
->t_iobc
);
1145 qemu_put_sbe16(f
, tp
->t_softerror
);
1146 qemu_put_byte(f
, tp
->snd_scale
);
1147 qemu_put_byte(f
, tp
->rcv_scale
);
1148 qemu_put_byte(f
, tp
->request_r_scale
);
1149 qemu_put_byte(f
, tp
->requested_s_scale
);
1150 qemu_put_be32(f
, tp
->ts_recent
);
1151 qemu_put_be32(f
, tp
->ts_recent_age
);
1152 qemu_put_be32(f
, tp
->last_ack_sent
);
1155 static void slirp_sbuf_save(QEMUFile
*f
, struct sbuf
*sbuf
)
1159 qemu_put_be32(f
, sbuf
->sb_cc
);
1160 qemu_put_be32(f
, sbuf
->sb_datalen
);
1161 off
= (uint32_t)(sbuf
->sb_wptr
- sbuf
->sb_data
);
1162 qemu_put_sbe32(f
, off
);
1163 off
= (uint32_t)(sbuf
->sb_rptr
- sbuf
->sb_data
);
1164 qemu_put_sbe32(f
, off
);
1165 qemu_put_buffer(f
, (unsigned char*)sbuf
->sb_data
, sbuf
->sb_datalen
);
1168 static void slirp_socket_save(QEMUFile
*f
, struct socket
*so
)
1170 qemu_put_be32(f
, so
->so_urgc
);
1171 qemu_put_be16(f
, so
->so_ffamily
);
1172 switch (so
->so_ffamily
) {
1174 qemu_put_be32(f
, so
->so_faddr
.s_addr
);
1175 qemu_put_be16(f
, so
->so_fport
);
1179 "so_ffamily unknown, unable to save so_faddr and so_fport\n");
1181 qemu_put_be16(f
, so
->so_lfamily
);
1182 switch (so
->so_lfamily
) {
1184 qemu_put_be32(f
, so
->so_laddr
.s_addr
);
1185 qemu_put_be16(f
, so
->so_lport
);
1189 "so_ffamily unknown, unable to save so_laddr and so_lport\n");
1191 qemu_put_byte(f
, so
->so_iptos
);
1192 qemu_put_byte(f
, so
->so_emu
);
1193 qemu_put_byte(f
, so
->so_type
);
1194 qemu_put_be32(f
, so
->so_state
);
1195 slirp_sbuf_save(f
, &so
->so_rcv
);
1196 slirp_sbuf_save(f
, &so
->so_snd
);
1197 slirp_tcp_save(f
, so
->so_tcpcb
);
1200 static void slirp_bootp_save(QEMUFile
*f
, Slirp
*slirp
)
1204 for (i
= 0; i
< NB_BOOTP_CLIENTS
; i
++) {
1205 qemu_put_be16(f
, slirp
->bootp_clients
[i
].allocated
);
1206 qemu_put_buffer(f
, slirp
->bootp_clients
[i
].macaddr
, 6);
1210 static void slirp_state_save(QEMUFile
*f
, void *opaque
)
1212 Slirp
*slirp
= opaque
;
1213 struct ex_list
*ex_ptr
;
1215 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
)
1216 if (ex_ptr
->ex_pty
== 3) {
1218 so
= slirp_find_ctl_socket(slirp
, ex_ptr
->ex_addr
,
1219 ntohs(ex_ptr
->ex_fport
));
1223 qemu_put_byte(f
, 42);
1224 slirp_socket_save(f
, so
);
1226 qemu_put_byte(f
, 0);
1228 qemu_put_be16(f
, slirp
->ip_id
);
1230 slirp_bootp_save(f
, slirp
);
1233 static void slirp_tcp_load(QEMUFile
*f
, struct tcpcb
*tp
)
1237 tp
->t_state
= qemu_get_sbe16(f
);
1238 for (i
= 0; i
< TCPT_NTIMERS
; i
++)
1239 tp
->t_timer
[i
] = qemu_get_sbe16(f
);
1240 tp
->t_rxtshift
= qemu_get_sbe16(f
);
1241 tp
->t_rxtcur
= qemu_get_sbe16(f
);
1242 tp
->t_dupacks
= qemu_get_sbe16(f
);
1243 tp
->t_maxseg
= qemu_get_be16(f
);
1244 tp
->t_force
= qemu_get_sbyte(f
);
1245 tp
->t_flags
= qemu_get_be16(f
);
1246 tp
->snd_una
= qemu_get_be32(f
);
1247 tp
->snd_nxt
= qemu_get_be32(f
);
1248 tp
->snd_up
= qemu_get_be32(f
);
1249 tp
->snd_wl1
= qemu_get_be32(f
);
1250 tp
->snd_wl2
= qemu_get_be32(f
);
1251 tp
->iss
= qemu_get_be32(f
);
1252 tp
->snd_wnd
= qemu_get_be32(f
);
1253 tp
->rcv_wnd
= qemu_get_be32(f
);
1254 tp
->rcv_nxt
= qemu_get_be32(f
);
1255 tp
->rcv_up
= qemu_get_be32(f
);
1256 tp
->irs
= qemu_get_be32(f
);
1257 tp
->rcv_adv
= qemu_get_be32(f
);
1258 tp
->snd_max
= qemu_get_be32(f
);
1259 tp
->snd_cwnd
= qemu_get_be32(f
);
1260 tp
->snd_ssthresh
= qemu_get_be32(f
);
1261 tp
->t_idle
= qemu_get_sbe16(f
);
1262 tp
->t_rtt
= qemu_get_sbe16(f
);
1263 tp
->t_rtseq
= qemu_get_be32(f
);
1264 tp
->t_srtt
= qemu_get_sbe16(f
);
1265 tp
->t_rttvar
= qemu_get_sbe16(f
);
1266 tp
->t_rttmin
= qemu_get_be16(f
);
1267 tp
->max_sndwnd
= qemu_get_be32(f
);
1268 tp
->t_oobflags
= qemu_get_byte(f
);
1269 tp
->t_iobc
= qemu_get_byte(f
);
1270 tp
->t_softerror
= qemu_get_sbe16(f
);
1271 tp
->snd_scale
= qemu_get_byte(f
);
1272 tp
->rcv_scale
= qemu_get_byte(f
);
1273 tp
->request_r_scale
= qemu_get_byte(f
);
1274 tp
->requested_s_scale
= qemu_get_byte(f
);
1275 tp
->ts_recent
= qemu_get_be32(f
);
1276 tp
->ts_recent_age
= qemu_get_be32(f
);
1277 tp
->last_ack_sent
= qemu_get_be32(f
);
1281 static int slirp_sbuf_load(QEMUFile
*f
, struct sbuf
*sbuf
)
1283 uint32_t off
, sb_cc
, sb_datalen
;
1285 sb_cc
= qemu_get_be32(f
);
1286 sb_datalen
= qemu_get_be32(f
);
1288 sbreserve(sbuf
, sb_datalen
);
1290 if (sbuf
->sb_datalen
!= sb_datalen
)
1293 sbuf
->sb_cc
= sb_cc
;
1295 off
= qemu_get_sbe32(f
);
1296 sbuf
->sb_wptr
= sbuf
->sb_data
+ off
;
1297 off
= qemu_get_sbe32(f
);
1298 sbuf
->sb_rptr
= sbuf
->sb_data
+ off
;
1299 qemu_get_buffer(f
, (unsigned char*)sbuf
->sb_data
, sbuf
->sb_datalen
);
1304 static int slirp_socket_load(QEMUFile
*f
, struct socket
*so
, int version_id
)
1306 if (tcp_attach(so
) < 0)
1309 so
->so_urgc
= qemu_get_be32(f
);
1310 if (version_id
<= 3) {
1311 so
->so_ffamily
= AF_INET
;
1312 so
->so_faddr
.s_addr
= qemu_get_be32(f
);
1313 so
->so_laddr
.s_addr
= qemu_get_be32(f
);
1314 so
->so_fport
= qemu_get_be16(f
);
1315 so
->so_lport
= qemu_get_be16(f
);
1317 so
->so_ffamily
= qemu_get_be16(f
);
1318 switch (so
->so_ffamily
) {
1320 so
->so_faddr
.s_addr
= qemu_get_be32(f
);
1321 so
->so_fport
= qemu_get_be16(f
);
1325 "so_ffamily unknown, unable to restore so_faddr and so_lport");
1327 so
->so_lfamily
= qemu_get_be16(f
);
1328 switch (so
->so_lfamily
) {
1330 so
->so_laddr
.s_addr
= qemu_get_be32(f
);
1331 so
->so_lport
= qemu_get_be16(f
);
1335 "so_ffamily unknown, unable to restore so_laddr and so_lport");
1338 so
->so_iptos
= qemu_get_byte(f
);
1339 so
->so_emu
= qemu_get_byte(f
);
1340 so
->so_type
= qemu_get_byte(f
);
1341 so
->so_state
= qemu_get_be32(f
);
1342 if (slirp_sbuf_load(f
, &so
->so_rcv
) < 0)
1344 if (slirp_sbuf_load(f
, &so
->so_snd
) < 0)
1346 slirp_tcp_load(f
, so
->so_tcpcb
);
1351 static void slirp_bootp_load(QEMUFile
*f
, Slirp
*slirp
)
1355 for (i
= 0; i
< NB_BOOTP_CLIENTS
; i
++) {
1356 slirp
->bootp_clients
[i
].allocated
= qemu_get_be16(f
);
1357 qemu_get_buffer(f
, slirp
->bootp_clients
[i
].macaddr
, 6);
1361 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
)
1363 Slirp
*slirp
= opaque
;
1364 struct ex_list
*ex_ptr
;
1366 while (qemu_get_byte(f
)) {
1368 struct socket
*so
= socreate(slirp
);
1373 ret
= slirp_socket_load(f
, so
, version_id
);
1378 if ((so
->so_faddr
.s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
1379 slirp
->vnetwork_addr
.s_addr
) {
1382 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
1383 if (ex_ptr
->ex_pty
== 3 &&
1384 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
&&
1385 so
->so_fport
== ex_ptr
->ex_fport
) {
1392 so
->extra
= (void *)ex_ptr
->ex_exec
;
1395 if (version_id
>= 2) {
1396 slirp
->ip_id
= qemu_get_be16(f
);
1399 if (version_id
>= 3) {
1400 slirp_bootp_load(f
, slirp
);