]>
git.proxmox.com Git - qemu.git/blob - slirp/slirp.c
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-common.h"
25 #include "qemu/timer.h"
26 #include "char/char.h"
30 /* host loopback address */
31 struct in_addr loopback_addr
;
32 /* host loopback network mask */
33 unsigned long loopback_mask
;
35 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
36 static const uint8_t special_ethaddr
[ETH_ALEN
] = {
37 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
40 static const uint8_t zero_ethaddr
[ETH_ALEN
] = { 0, 0, 0, 0, 0, 0 };
42 /* XXX: suppress those select globals */
43 fd_set
*global_readfds
, *global_writefds
, *global_xfds
;
46 static u_int time_fasttimo
, last_slowtimo
;
47 static int do_slowtimo
;
49 static QTAILQ_HEAD(slirp_instances
, Slirp
) slirp_instances
=
50 QTAILQ_HEAD_INITIALIZER(slirp_instances
);
52 static struct in_addr dns_addr
;
53 static u_int dns_addr_time
;
57 int get_dns_addr(struct in_addr
*pdns_addr
)
59 FIXED_INFO
*FixedInfo
=NULL
;
62 IP_ADDR_STRING
*pIPAddr
;
63 struct in_addr tmp_addr
;
65 if (dns_addr
.s_addr
!= 0 && (curtime
- dns_addr_time
) < 1000) {
66 *pdns_addr
= dns_addr
;
70 FixedInfo
= (FIXED_INFO
*)GlobalAlloc(GPTR
, sizeof(FIXED_INFO
));
71 BufLen
= sizeof(FIXED_INFO
);
73 if (ERROR_BUFFER_OVERFLOW
== GetNetworkParams(FixedInfo
, &BufLen
)) {
75 GlobalFree(FixedInfo
);
78 FixedInfo
= GlobalAlloc(GPTR
, BufLen
);
81 if ((ret
= GetNetworkParams(FixedInfo
, &BufLen
)) != ERROR_SUCCESS
) {
82 printf("GetNetworkParams failed. ret = %08x\n", (u_int
)ret
);
84 GlobalFree(FixedInfo
);
90 pIPAddr
= &(FixedInfo
->DnsServerList
);
91 inet_aton(pIPAddr
->IpAddress
.String
, &tmp_addr
);
92 *pdns_addr
= tmp_addr
;
94 dns_addr_time
= curtime
;
96 GlobalFree(FixedInfo
);
102 static void winsock_cleanup(void)
109 static struct stat dns_addr_stat
;
111 int get_dns_addr(struct in_addr
*pdns_addr
)
117 struct in_addr tmp_addr
;
119 if (dns_addr
.s_addr
!= 0) {
120 struct stat old_stat
;
121 if ((curtime
- dns_addr_time
) < 1000) {
122 *pdns_addr
= dns_addr
;
125 old_stat
= dns_addr_stat
;
126 if (stat("/etc/resolv.conf", &dns_addr_stat
) != 0)
128 if ((dns_addr_stat
.st_dev
== old_stat
.st_dev
)
129 && (dns_addr_stat
.st_ino
== old_stat
.st_ino
)
130 && (dns_addr_stat
.st_size
== old_stat
.st_size
)
131 && (dns_addr_stat
.st_mtime
== old_stat
.st_mtime
)) {
132 *pdns_addr
= dns_addr
;
137 f
= fopen("/etc/resolv.conf", "r");
142 lprint("IP address of your DNS(s): ");
144 while (fgets(buff
, 512, f
) != NULL
) {
145 if (sscanf(buff
, "nameserver%*[ \t]%256s", buff2
) == 1) {
146 if (!inet_aton(buff2
, &tmp_addr
))
148 /* If it's the first one, set it to dns_addr */
150 *pdns_addr
= tmp_addr
;
152 dns_addr_time
= curtime
;
166 lprint("%s", inet_ntoa(tmp_addr
));
178 static void slirp_init_once(void)
180 static int initialized
;
191 WSAStartup(MAKEWORD(2,0), &Data
);
192 atexit(winsock_cleanup
);
195 loopback_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
196 loopback_mask
= htonl(IN_CLASSA_NET
);
199 static void slirp_state_save(QEMUFile
*f
, void *opaque
);
200 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
);
202 Slirp
*slirp_init(int restricted
, struct in_addr vnetwork
,
203 struct in_addr vnetmask
, struct in_addr vhost
,
204 const char *vhostname
, const char *tftp_path
,
205 const char *bootfile
, struct in_addr vdhcp_start
,
206 struct in_addr vnameserver
, const char **vdnssearch
,
209 Slirp
*slirp
= g_malloc0(sizeof(Slirp
));
213 slirp
->restricted
= restricted
;
218 /* Initialise mbufs *after* setting the MTU */
221 slirp
->vnetwork_addr
= vnetwork
;
222 slirp
->vnetwork_mask
= vnetmask
;
223 slirp
->vhost_addr
= vhost
;
225 pstrcpy(slirp
->client_hostname
, sizeof(slirp
->client_hostname
),
228 slirp
->tftp_prefix
= g_strdup(tftp_path
);
229 slirp
->bootp_filename
= g_strdup(bootfile
);
230 slirp
->vdhcp_startaddr
= vdhcp_start
;
231 slirp
->vnameserver_addr
= vnameserver
;
234 translate_dnssearch(slirp
, vdnssearch
);
237 slirp
->opaque
= opaque
;
239 register_savevm(NULL
, "slirp", 0, 3,
240 slirp_state_save
, slirp_state_load
, slirp
);
242 QTAILQ_INSERT_TAIL(&slirp_instances
, slirp
, entry
);
247 void slirp_cleanup(Slirp
*slirp
)
249 QTAILQ_REMOVE(&slirp_instances
, slirp
, entry
);
251 unregister_savevm(NULL
, "slirp", slirp
);
256 g_free(slirp
->vdnssearch
);
257 g_free(slirp
->tftp_prefix
);
258 g_free(slirp
->bootp_filename
);
262 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
263 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
264 #define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
266 void slirp_update_timeout(uint32_t *timeout
)
268 if (!QTAILQ_EMPTY(&slirp_instances
)) {
269 *timeout
= MIN(1000, *timeout
);
273 void slirp_select_fill(int *pnfds
,
274 fd_set
*readfds
, fd_set
*writefds
, fd_set
*xfds
)
277 struct socket
*so
, *so_next
;
280 if (QTAILQ_EMPTY(&slirp_instances
)) {
285 global_readfds
= NULL
;
286 global_writefds
= NULL
;
295 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
297 * *_slowtimo needs calling if there are IP fragments
298 * in the fragment queue, or there are TCP connections active
300 do_slowtimo
|= ((slirp
->tcb
.so_next
!= &slirp
->tcb
) ||
301 (&slirp
->ipq
.ip_link
!= slirp
->ipq
.ip_link
.next
));
303 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
305 so_next
= so
->so_next
;
308 * See if we need a tcp_fasttimo
310 if (time_fasttimo
== 0 && so
->so_tcpcb
->t_flags
& TF_DELACK
) {
311 time_fasttimo
= curtime
; /* Flag when we want a fasttimo */
315 * NOFDREF can include still connecting to local-host,
316 * newly socreated() sockets etc. Don't want to select these.
318 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
323 * Set for reading sockets which are accepting
325 if (so
->so_state
& SS_FACCEPTCONN
) {
326 FD_SET(so
->s
, readfds
);
332 * Set for writing sockets which are connecting
334 if (so
->so_state
& SS_ISFCONNECTING
) {
335 FD_SET(so
->s
, writefds
);
341 * Set for writing if we are connected, can send more, and
342 * we have something to send
344 if (CONN_CANFSEND(so
) && so
->so_rcv
.sb_cc
) {
345 FD_SET(so
->s
, writefds
);
350 * Set for reading (and urgent data) if we are connected, can
351 * receive more, and we have room for it XXX /2 ?
353 if (CONN_CANFRCV(so
) &&
354 (so
->so_snd
.sb_cc
< (so
->so_snd
.sb_datalen
/2))) {
355 FD_SET(so
->s
, readfds
);
364 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
366 so_next
= so
->so_next
;
369 * See if it's timed out
372 if (so
->so_expire
<= curtime
) {
376 do_slowtimo
= 1; /* Let socket expire */
381 * When UDP packets are received from over the
382 * link, they're sendto()'d straight away, so
383 * no need for setting for writing
384 * Limit the number of packets queued by this session
385 * to 4. Note that even though we try and limit this
386 * to 4 packets, the session could have more queued
387 * if the packets needed to be fragmented
390 if ((so
->so_state
& SS_ISFCONNECTED
) && so
->so_queued
<= 4) {
391 FD_SET(so
->s
, readfds
);
399 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
401 so_next
= so
->so_next
;
404 * See if it's timed out
407 if (so
->so_expire
<= curtime
) {
411 do_slowtimo
= 1; /* Let socket expire */
415 if (so
->so_state
& SS_ISFCONNECTED
) {
416 FD_SET(so
->s
, readfds
);
425 void slirp_select_poll(fd_set
*readfds
, fd_set
*writefds
, fd_set
*xfds
,
429 struct socket
*so
, *so_next
;
432 if (QTAILQ_EMPTY(&slirp_instances
)) {
436 global_readfds
= readfds
;
437 global_writefds
= writefds
;
440 curtime
= qemu_get_clock_ms(rt_clock
);
442 QTAILQ_FOREACH(slirp
, &slirp_instances
, entry
) {
444 * See if anything has timed out
446 if (time_fasttimo
&& ((curtime
- time_fasttimo
) >= 2)) {
450 if (do_slowtimo
&& ((curtime
- last_slowtimo
) >= 499)) {
453 last_slowtimo
= curtime
;
463 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
;
465 so_next
= so
->so_next
;
468 * FD_ISSET is meaningless on these sockets
469 * (and they can crash the program)
471 if (so
->so_state
& SS_NOFDREF
|| so
->s
== -1) {
477 * This will soread as well, so no need to
478 * test for readfds below if this succeeds
480 if (FD_ISSET(so
->s
, xfds
)) {
484 * Check sockets for reading
486 else if (FD_ISSET(so
->s
, readfds
)) {
488 * Check for incoming connections
490 if (so
->so_state
& SS_FACCEPTCONN
) {
496 /* Output it if we read something */
498 tcp_output(sototcpcb(so
));
503 * Check sockets for writing
505 if (FD_ISSET(so
->s
, writefds
)) {
507 * Check for non-blocking, still-connecting sockets
509 if (so
->so_state
& SS_ISFCONNECTING
) {
511 so
->so_state
&= ~SS_ISFCONNECTING
;
513 ret
= send(so
->s
, (const void *) &ret
, 0, 0);
515 /* XXXXX Must fix, zero bytes is a NOP */
516 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
517 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
522 so
->so_state
&= SS_PERSISTENT_MASK
;
523 so
->so_state
|= SS_NOFDREF
;
525 /* else so->so_state &= ~SS_ISFCONNECTING; */
530 tcp_input((struct mbuf
*)NULL
, sizeof(struct ip
), so
);
536 * XXXXX If we wrote something (a lot), there
537 * could be a need for a window update.
538 * In the worst case, the remote will send
539 * a window probe to get things going again
544 * Probe a still-connecting, non-blocking socket
545 * to check if it's still alive
548 if (so
->so_state
& SS_ISFCONNECTING
) {
549 ret
= qemu_recv(so
->s
, &ret
, 0, 0);
553 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
554 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
555 continue; /* Still connecting, continue */
559 so
->so_state
&= SS_PERSISTENT_MASK
;
560 so
->so_state
|= SS_NOFDREF
;
562 /* tcp_input will take care of it */
564 ret
= send(so
->s
, &ret
, 0, 0);
567 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
||
568 errno
== EINPROGRESS
|| errno
== ENOTCONN
) {
572 so
->so_state
&= SS_PERSISTENT_MASK
;
573 so
->so_state
|= SS_NOFDREF
;
575 so
->so_state
&= ~SS_ISFCONNECTING
;
579 tcp_input((struct mbuf
*)NULL
, sizeof(struct ip
), so
);
580 } /* SS_ISFCONNECTING */
586 * Incoming packets are sent straight away, they're not buffered.
587 * Incoming UDP data isn't buffered either.
589 for (so
= slirp
->udb
.so_next
; so
!= &slirp
->udb
;
591 so_next
= so
->so_next
;
593 if (so
->s
!= -1 && FD_ISSET(so
->s
, readfds
)) {
599 * Check incoming ICMP relies.
601 for (so
= slirp
->icmp
.so_next
; so
!= &slirp
->icmp
;
603 so_next
= so
->so_next
;
605 if (so
->s
!= -1 && FD_ISSET(so
->s
, readfds
)) {
614 /* clear global file descriptor sets.
615 * these reside on the stack in vl.c
616 * so they're unusable if we're not in
617 * slirp_select_fill or slirp_select_poll.
619 global_readfds
= NULL
;
620 global_writefds
= NULL
;
624 static void arp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
626 struct arphdr
*ah
= (struct arphdr
*)(pkt
+ ETH_HLEN
);
627 uint8_t arp_reply
[max(ETH_HLEN
+ sizeof(struct arphdr
), 64)];
628 struct ethhdr
*reh
= (struct ethhdr
*)arp_reply
;
629 struct arphdr
*rah
= (struct arphdr
*)(arp_reply
+ ETH_HLEN
);
631 struct ex_list
*ex_ptr
;
633 ar_op
= ntohs(ah
->ar_op
);
636 if (ah
->ar_tip
== ah
->ar_sip
) {
638 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
642 if ((ah
->ar_tip
& slirp
->vnetwork_mask
.s_addr
) ==
643 slirp
->vnetwork_addr
.s_addr
) {
644 if (ah
->ar_tip
== slirp
->vnameserver_addr
.s_addr
||
645 ah
->ar_tip
== slirp
->vhost_addr
.s_addr
)
647 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
648 if (ex_ptr
->ex_addr
.s_addr
== ah
->ar_tip
)
653 memset(arp_reply
, 0, sizeof(arp_reply
));
655 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
657 /* ARP request for alias/dns mac address */
658 memcpy(reh
->h_dest
, pkt
+ ETH_ALEN
, ETH_ALEN
);
659 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
660 memcpy(&reh
->h_source
[2], &ah
->ar_tip
, 4);
661 reh
->h_proto
= htons(ETH_P_ARP
);
663 rah
->ar_hrd
= htons(1);
664 rah
->ar_pro
= htons(ETH_P_IP
);
665 rah
->ar_hln
= ETH_ALEN
;
667 rah
->ar_op
= htons(ARPOP_REPLY
);
668 memcpy(rah
->ar_sha
, reh
->h_source
, ETH_ALEN
);
669 rah
->ar_sip
= ah
->ar_tip
;
670 memcpy(rah
->ar_tha
, ah
->ar_sha
, ETH_ALEN
);
671 rah
->ar_tip
= ah
->ar_sip
;
672 slirp_output(slirp
->opaque
, arp_reply
, sizeof(arp_reply
));
676 arp_table_add(slirp
, ah
->ar_sip
, ah
->ar_sha
);
683 void slirp_input(Slirp
*slirp
, const uint8_t *pkt
, int pkt_len
)
688 if (pkt_len
< ETH_HLEN
)
691 proto
= ntohs(*(uint16_t *)(pkt
+ 12));
694 arp_input(slirp
, pkt
, pkt_len
);
700 /* Note: we add to align the IP header */
701 if (M_FREEROOM(m
) < pkt_len
+ 2) {
702 m_inc(m
, pkt_len
+ 2);
704 m
->m_len
= pkt_len
+ 2;
705 memcpy(m
->m_data
+ 2, pkt
, pkt_len
);
707 m
->m_data
+= 2 + ETH_HLEN
;
708 m
->m_len
-= 2 + ETH_HLEN
;
717 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
720 int if_encap(Slirp
*slirp
, struct mbuf
*ifm
)
723 struct ethhdr
*eh
= (struct ethhdr
*)buf
;
724 uint8_t ethaddr
[ETH_ALEN
];
725 const struct ip
*iph
= (const struct ip
*)ifm
->m_data
;
727 if (ifm
->m_len
+ ETH_HLEN
> sizeof(buf
)) {
731 if (!arp_table_search(slirp
, iph
->ip_dst
.s_addr
, ethaddr
)) {
732 uint8_t arp_req
[ETH_HLEN
+ sizeof(struct arphdr
)];
733 struct ethhdr
*reh
= (struct ethhdr
*)arp_req
;
734 struct arphdr
*rah
= (struct arphdr
*)(arp_req
+ ETH_HLEN
);
736 if (!ifm
->arp_requested
) {
737 /* If the client addr is not known, send an ARP request */
738 memset(reh
->h_dest
, 0xff, ETH_ALEN
);
739 memcpy(reh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
740 memcpy(&reh
->h_source
[2], &slirp
->vhost_addr
, 4);
741 reh
->h_proto
= htons(ETH_P_ARP
);
742 rah
->ar_hrd
= htons(1);
743 rah
->ar_pro
= htons(ETH_P_IP
);
744 rah
->ar_hln
= ETH_ALEN
;
746 rah
->ar_op
= htons(ARPOP_REQUEST
);
749 memcpy(rah
->ar_sha
, special_ethaddr
, ETH_ALEN
- 4);
750 memcpy(&rah
->ar_sha
[2], &slirp
->vhost_addr
, 4);
753 rah
->ar_sip
= slirp
->vhost_addr
.s_addr
;
755 /* target hw addr (none) */
756 memset(rah
->ar_tha
, 0, ETH_ALEN
);
759 rah
->ar_tip
= iph
->ip_dst
.s_addr
;
760 slirp
->client_ipaddr
= iph
->ip_dst
;
761 slirp_output(slirp
->opaque
, arp_req
, sizeof(arp_req
));
762 ifm
->arp_requested
= true;
764 /* Expire request and drop outgoing packet after 1 second */
765 ifm
->expiration_date
= qemu_get_clock_ns(rt_clock
) + 1000000000ULL;
769 memcpy(eh
->h_dest
, ethaddr
, ETH_ALEN
);
770 memcpy(eh
->h_source
, special_ethaddr
, ETH_ALEN
- 4);
771 /* XXX: not correct */
772 memcpy(&eh
->h_source
[2], &slirp
->vhost_addr
, 4);
773 eh
->h_proto
= htons(ETH_P_IP
);
774 memcpy(buf
+ sizeof(struct ethhdr
), ifm
->m_data
, ifm
->m_len
);
775 slirp_output(slirp
->opaque
, buf
, ifm
->m_len
+ ETH_HLEN
);
780 /* Drop host forwarding rule, return 0 if found. */
781 int slirp_remove_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
785 struct socket
*head
= (is_udp
? &slirp
->udb
: &slirp
->tcb
);
786 struct sockaddr_in addr
;
787 int port
= htons(host_port
);
790 for (so
= head
->so_next
; so
!= head
; so
= so
->so_next
) {
791 addr_len
= sizeof(addr
);
792 if ((so
->so_state
& SS_HOSTFWD
) &&
793 getsockname(so
->s
, (struct sockaddr
*)&addr
, &addr_len
) == 0 &&
794 addr
.sin_addr
.s_addr
== host_addr
.s_addr
&&
795 addr
.sin_port
== port
) {
805 int slirp_add_hostfwd(Slirp
*slirp
, int is_udp
, struct in_addr host_addr
,
806 int host_port
, struct in_addr guest_addr
, int guest_port
)
808 if (!guest_addr
.s_addr
) {
809 guest_addr
= slirp
->vdhcp_startaddr
;
812 if (!udp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
813 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
816 if (!tcp_listen(slirp
, host_addr
.s_addr
, htons(host_port
),
817 guest_addr
.s_addr
, htons(guest_port
), SS_HOSTFWD
))
823 int slirp_add_exec(Slirp
*slirp
, int do_pty
, const void *args
,
824 struct in_addr
*guest_addr
, int guest_port
)
826 if (!guest_addr
->s_addr
) {
827 guest_addr
->s_addr
= slirp
->vnetwork_addr
.s_addr
|
828 (htonl(0x0204) & ~slirp
->vnetwork_mask
.s_addr
);
830 if ((guest_addr
->s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
831 slirp
->vnetwork_addr
.s_addr
||
832 guest_addr
->s_addr
== slirp
->vhost_addr
.s_addr
||
833 guest_addr
->s_addr
== slirp
->vnameserver_addr
.s_addr
) {
836 return add_exec(&slirp
->exec_list
, do_pty
, (char *)args
, *guest_addr
,
840 ssize_t
slirp_send(struct socket
*so
, const void *buf
, size_t len
, int flags
)
842 if (so
->s
== -1 && so
->extra
) {
843 qemu_chr_fe_write(so
->extra
, buf
, len
);
847 return send(so
->s
, buf
, len
, flags
);
850 static struct socket
*
851 slirp_find_ctl_socket(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
)
855 for (so
= slirp
->tcb
.so_next
; so
!= &slirp
->tcb
; so
= so
->so_next
) {
856 if (so
->so_faddr
.s_addr
== guest_addr
.s_addr
&&
857 htons(so
->so_fport
) == guest_port
) {
864 size_t slirp_socket_can_recv(Slirp
*slirp
, struct in_addr guest_addr
,
870 so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
872 if (!so
|| so
->so_state
& SS_NOFDREF
) {
876 if (!CONN_CANFRCV(so
) || so
->so_snd
.sb_cc
>= (so
->so_snd
.sb_datalen
/2)) {
880 return sopreprbuf(so
, iov
, NULL
);
883 void slirp_socket_recv(Slirp
*slirp
, struct in_addr guest_addr
, int guest_port
,
884 const uint8_t *buf
, int size
)
887 struct socket
*so
= slirp_find_ctl_socket(slirp
, guest_addr
, guest_port
);
892 ret
= soreadbuf(so
, (const char *)buf
, size
);
895 tcp_output(sototcpcb(so
));
898 static void slirp_tcp_save(QEMUFile
*f
, struct tcpcb
*tp
)
902 qemu_put_sbe16(f
, tp
->t_state
);
903 for (i
= 0; i
< TCPT_NTIMERS
; i
++)
904 qemu_put_sbe16(f
, tp
->t_timer
[i
]);
905 qemu_put_sbe16(f
, tp
->t_rxtshift
);
906 qemu_put_sbe16(f
, tp
->t_rxtcur
);
907 qemu_put_sbe16(f
, tp
->t_dupacks
);
908 qemu_put_be16(f
, tp
->t_maxseg
);
909 qemu_put_sbyte(f
, tp
->t_force
);
910 qemu_put_be16(f
, tp
->t_flags
);
911 qemu_put_be32(f
, tp
->snd_una
);
912 qemu_put_be32(f
, tp
->snd_nxt
);
913 qemu_put_be32(f
, tp
->snd_up
);
914 qemu_put_be32(f
, tp
->snd_wl1
);
915 qemu_put_be32(f
, tp
->snd_wl2
);
916 qemu_put_be32(f
, tp
->iss
);
917 qemu_put_be32(f
, tp
->snd_wnd
);
918 qemu_put_be32(f
, tp
->rcv_wnd
);
919 qemu_put_be32(f
, tp
->rcv_nxt
);
920 qemu_put_be32(f
, tp
->rcv_up
);
921 qemu_put_be32(f
, tp
->irs
);
922 qemu_put_be32(f
, tp
->rcv_adv
);
923 qemu_put_be32(f
, tp
->snd_max
);
924 qemu_put_be32(f
, tp
->snd_cwnd
);
925 qemu_put_be32(f
, tp
->snd_ssthresh
);
926 qemu_put_sbe16(f
, tp
->t_idle
);
927 qemu_put_sbe16(f
, tp
->t_rtt
);
928 qemu_put_be32(f
, tp
->t_rtseq
);
929 qemu_put_sbe16(f
, tp
->t_srtt
);
930 qemu_put_sbe16(f
, tp
->t_rttvar
);
931 qemu_put_be16(f
, tp
->t_rttmin
);
932 qemu_put_be32(f
, tp
->max_sndwnd
);
933 qemu_put_byte(f
, tp
->t_oobflags
);
934 qemu_put_byte(f
, tp
->t_iobc
);
935 qemu_put_sbe16(f
, tp
->t_softerror
);
936 qemu_put_byte(f
, tp
->snd_scale
);
937 qemu_put_byte(f
, tp
->rcv_scale
);
938 qemu_put_byte(f
, tp
->request_r_scale
);
939 qemu_put_byte(f
, tp
->requested_s_scale
);
940 qemu_put_be32(f
, tp
->ts_recent
);
941 qemu_put_be32(f
, tp
->ts_recent_age
);
942 qemu_put_be32(f
, tp
->last_ack_sent
);
945 static void slirp_sbuf_save(QEMUFile
*f
, struct sbuf
*sbuf
)
949 qemu_put_be32(f
, sbuf
->sb_cc
);
950 qemu_put_be32(f
, sbuf
->sb_datalen
);
951 off
= (uint32_t)(sbuf
->sb_wptr
- sbuf
->sb_data
);
952 qemu_put_sbe32(f
, off
);
953 off
= (uint32_t)(sbuf
->sb_rptr
- sbuf
->sb_data
);
954 qemu_put_sbe32(f
, off
);
955 qemu_put_buffer(f
, (unsigned char*)sbuf
->sb_data
, sbuf
->sb_datalen
);
958 static void slirp_socket_save(QEMUFile
*f
, struct socket
*so
)
960 qemu_put_be32(f
, so
->so_urgc
);
961 qemu_put_be32(f
, so
->so_faddr
.s_addr
);
962 qemu_put_be32(f
, so
->so_laddr
.s_addr
);
963 qemu_put_be16(f
, so
->so_fport
);
964 qemu_put_be16(f
, so
->so_lport
);
965 qemu_put_byte(f
, so
->so_iptos
);
966 qemu_put_byte(f
, so
->so_emu
);
967 qemu_put_byte(f
, so
->so_type
);
968 qemu_put_be32(f
, so
->so_state
);
969 slirp_sbuf_save(f
, &so
->so_rcv
);
970 slirp_sbuf_save(f
, &so
->so_snd
);
971 slirp_tcp_save(f
, so
->so_tcpcb
);
974 static void slirp_bootp_save(QEMUFile
*f
, Slirp
*slirp
)
978 for (i
= 0; i
< NB_BOOTP_CLIENTS
; i
++) {
979 qemu_put_be16(f
, slirp
->bootp_clients
[i
].allocated
);
980 qemu_put_buffer(f
, slirp
->bootp_clients
[i
].macaddr
, 6);
984 static void slirp_state_save(QEMUFile
*f
, void *opaque
)
986 Slirp
*slirp
= opaque
;
987 struct ex_list
*ex_ptr
;
989 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
)
990 if (ex_ptr
->ex_pty
== 3) {
992 so
= slirp_find_ctl_socket(slirp
, ex_ptr
->ex_addr
,
993 ntohs(ex_ptr
->ex_fport
));
997 qemu_put_byte(f
, 42);
998 slirp_socket_save(f
, so
);
1000 qemu_put_byte(f
, 0);
1002 qemu_put_be16(f
, slirp
->ip_id
);
1004 slirp_bootp_save(f
, slirp
);
1007 static void slirp_tcp_load(QEMUFile
*f
, struct tcpcb
*tp
)
1011 tp
->t_state
= qemu_get_sbe16(f
);
1012 for (i
= 0; i
< TCPT_NTIMERS
; i
++)
1013 tp
->t_timer
[i
] = qemu_get_sbe16(f
);
1014 tp
->t_rxtshift
= qemu_get_sbe16(f
);
1015 tp
->t_rxtcur
= qemu_get_sbe16(f
);
1016 tp
->t_dupacks
= qemu_get_sbe16(f
);
1017 tp
->t_maxseg
= qemu_get_be16(f
);
1018 tp
->t_force
= qemu_get_sbyte(f
);
1019 tp
->t_flags
= qemu_get_be16(f
);
1020 tp
->snd_una
= qemu_get_be32(f
);
1021 tp
->snd_nxt
= qemu_get_be32(f
);
1022 tp
->snd_up
= qemu_get_be32(f
);
1023 tp
->snd_wl1
= qemu_get_be32(f
);
1024 tp
->snd_wl2
= qemu_get_be32(f
);
1025 tp
->iss
= qemu_get_be32(f
);
1026 tp
->snd_wnd
= qemu_get_be32(f
);
1027 tp
->rcv_wnd
= qemu_get_be32(f
);
1028 tp
->rcv_nxt
= qemu_get_be32(f
);
1029 tp
->rcv_up
= qemu_get_be32(f
);
1030 tp
->irs
= qemu_get_be32(f
);
1031 tp
->rcv_adv
= qemu_get_be32(f
);
1032 tp
->snd_max
= qemu_get_be32(f
);
1033 tp
->snd_cwnd
= qemu_get_be32(f
);
1034 tp
->snd_ssthresh
= qemu_get_be32(f
);
1035 tp
->t_idle
= qemu_get_sbe16(f
);
1036 tp
->t_rtt
= qemu_get_sbe16(f
);
1037 tp
->t_rtseq
= qemu_get_be32(f
);
1038 tp
->t_srtt
= qemu_get_sbe16(f
);
1039 tp
->t_rttvar
= qemu_get_sbe16(f
);
1040 tp
->t_rttmin
= qemu_get_be16(f
);
1041 tp
->max_sndwnd
= qemu_get_be32(f
);
1042 tp
->t_oobflags
= qemu_get_byte(f
);
1043 tp
->t_iobc
= qemu_get_byte(f
);
1044 tp
->t_softerror
= qemu_get_sbe16(f
);
1045 tp
->snd_scale
= qemu_get_byte(f
);
1046 tp
->rcv_scale
= qemu_get_byte(f
);
1047 tp
->request_r_scale
= qemu_get_byte(f
);
1048 tp
->requested_s_scale
= qemu_get_byte(f
);
1049 tp
->ts_recent
= qemu_get_be32(f
);
1050 tp
->ts_recent_age
= qemu_get_be32(f
);
1051 tp
->last_ack_sent
= qemu_get_be32(f
);
1055 static int slirp_sbuf_load(QEMUFile
*f
, struct sbuf
*sbuf
)
1057 uint32_t off
, sb_cc
, sb_datalen
;
1059 sb_cc
= qemu_get_be32(f
);
1060 sb_datalen
= qemu_get_be32(f
);
1062 sbreserve(sbuf
, sb_datalen
);
1064 if (sbuf
->sb_datalen
!= sb_datalen
)
1067 sbuf
->sb_cc
= sb_cc
;
1069 off
= qemu_get_sbe32(f
);
1070 sbuf
->sb_wptr
= sbuf
->sb_data
+ off
;
1071 off
= qemu_get_sbe32(f
);
1072 sbuf
->sb_rptr
= sbuf
->sb_data
+ off
;
1073 qemu_get_buffer(f
, (unsigned char*)sbuf
->sb_data
, sbuf
->sb_datalen
);
1078 static int slirp_socket_load(QEMUFile
*f
, struct socket
*so
)
1080 if (tcp_attach(so
) < 0)
1083 so
->so_urgc
= qemu_get_be32(f
);
1084 so
->so_faddr
.s_addr
= qemu_get_be32(f
);
1085 so
->so_laddr
.s_addr
= qemu_get_be32(f
);
1086 so
->so_fport
= qemu_get_be16(f
);
1087 so
->so_lport
= qemu_get_be16(f
);
1088 so
->so_iptos
= qemu_get_byte(f
);
1089 so
->so_emu
= qemu_get_byte(f
);
1090 so
->so_type
= qemu_get_byte(f
);
1091 so
->so_state
= qemu_get_be32(f
);
1092 if (slirp_sbuf_load(f
, &so
->so_rcv
) < 0)
1094 if (slirp_sbuf_load(f
, &so
->so_snd
) < 0)
1096 slirp_tcp_load(f
, so
->so_tcpcb
);
1101 static void slirp_bootp_load(QEMUFile
*f
, Slirp
*slirp
)
1105 for (i
= 0; i
< NB_BOOTP_CLIENTS
; i
++) {
1106 slirp
->bootp_clients
[i
].allocated
= qemu_get_be16(f
);
1107 qemu_get_buffer(f
, slirp
->bootp_clients
[i
].macaddr
, 6);
1111 static int slirp_state_load(QEMUFile
*f
, void *opaque
, int version_id
)
1113 Slirp
*slirp
= opaque
;
1114 struct ex_list
*ex_ptr
;
1116 while (qemu_get_byte(f
)) {
1118 struct socket
*so
= socreate(slirp
);
1123 ret
= slirp_socket_load(f
, so
);
1128 if ((so
->so_faddr
.s_addr
& slirp
->vnetwork_mask
.s_addr
) !=
1129 slirp
->vnetwork_addr
.s_addr
) {
1132 for (ex_ptr
= slirp
->exec_list
; ex_ptr
; ex_ptr
= ex_ptr
->ex_next
) {
1133 if (ex_ptr
->ex_pty
== 3 &&
1134 so
->so_faddr
.s_addr
== ex_ptr
->ex_addr
.s_addr
&&
1135 so
->so_fport
== ex_ptr
->ex_fport
) {
1142 so
->extra
= (void *)ex_ptr
->ex_exec
;
1145 if (version_id
>= 2) {
1146 slirp
->ip_id
= qemu_get_be16(f
);
1149 if (version_id
>= 3) {
1150 slirp_bootp_load(f
, slirp
);