virtio-net: switch tx to safe iov functions
[qemu/ar7.git] / slirp / slirp.c
blob38e0a2193ae63282fc4ce96f687ba7bc49a2f9c1
1 /*
2 * libslirp glue
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
22 * THE SOFTWARE.
24 #include "qemu-common.h"
25 #include "qemu-timer.h"
26 #include "qemu-char.h"
27 #include "slirp.h"
28 #include "hw/hw.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;
45 u_int curtime;
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;
55 #ifdef _WIN32
57 int get_dns_addr(struct in_addr *pdns_addr)
59 FIXED_INFO *FixedInfo=NULL;
60 ULONG BufLen;
61 DWORD ret;
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;
67 return 0;
70 FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
71 BufLen = sizeof(FIXED_INFO);
73 if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
74 if (FixedInfo) {
75 GlobalFree(FixedInfo);
76 FixedInfo = NULL;
78 FixedInfo = GlobalAlloc(GPTR, BufLen);
81 if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
82 printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
83 if (FixedInfo) {
84 GlobalFree(FixedInfo);
85 FixedInfo = NULL;
87 return -1;
90 pIPAddr = &(FixedInfo->DnsServerList);
91 inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
92 *pdns_addr = tmp_addr;
93 dns_addr = tmp_addr;
94 dns_addr_time = curtime;
95 if (FixedInfo) {
96 GlobalFree(FixedInfo);
97 FixedInfo = NULL;
99 return 0;
102 static void winsock_cleanup(void)
104 WSACleanup();
107 #else
109 static struct stat dns_addr_stat;
111 int get_dns_addr(struct in_addr *pdns_addr)
113 char buff[512];
114 char buff2[257];
115 FILE *f;
116 int found = 0;
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;
123 return 0;
125 old_stat = dns_addr_stat;
126 if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
127 return -1;
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;
133 return 0;
137 f = fopen("/etc/resolv.conf", "r");
138 if (!f)
139 return -1;
141 #ifdef DEBUG
142 lprint("IP address of your DNS(s): ");
143 #endif
144 while (fgets(buff, 512, f) != NULL) {
145 if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
146 if (!inet_aton(buff2, &tmp_addr))
147 continue;
148 /* If it's the first one, set it to dns_addr */
149 if (!found) {
150 *pdns_addr = tmp_addr;
151 dns_addr = tmp_addr;
152 dns_addr_time = curtime;
154 #ifdef DEBUG
155 else
156 lprint(", ");
157 #endif
158 if (++found > 3) {
159 #ifdef DEBUG
160 lprint("(more)");
161 #endif
162 break;
164 #ifdef DEBUG
165 else
166 lprint("%s", inet_ntoa(tmp_addr));
167 #endif
170 fclose(f);
171 if (!found)
172 return -1;
173 return 0;
176 #endif
178 static void slirp_init_once(void)
180 static int initialized;
181 #ifdef _WIN32
182 WSADATA Data;
183 #endif
185 if (initialized) {
186 return;
188 initialized = 1;
190 #ifdef _WIN32
191 WSAStartup(MAKEWORD(2,0), &Data);
192 atexit(winsock_cleanup);
193 #endif
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, void *opaque)
208 Slirp *slirp = g_malloc0(sizeof(Slirp));
210 slirp_init_once();
212 slirp->restricted = restricted;
214 if_init(slirp);
215 ip_init(slirp);
217 /* Initialise mbufs *after* setting the MTU */
218 m_init(slirp);
220 slirp->vnetwork_addr = vnetwork;
221 slirp->vnetwork_mask = vnetmask;
222 slirp->vhost_addr = vhost;
223 if (vhostname) {
224 pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
225 vhostname);
227 if (tftp_path) {
228 slirp->tftp_prefix = g_strdup(tftp_path);
230 if (bootfile) {
231 slirp->bootp_filename = g_strdup(bootfile);
233 slirp->vdhcp_startaddr = vdhcp_start;
234 slirp->vnameserver_addr = vnameserver;
236 slirp->opaque = opaque;
238 register_savevm(NULL, "slirp", 0, 3,
239 slirp_state_save, slirp_state_load, slirp);
241 QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
243 return slirp;
246 void slirp_cleanup(Slirp *slirp)
248 QTAILQ_REMOVE(&slirp_instances, slirp, entry);
250 unregister_savevm(NULL, "slirp", slirp);
252 ip_cleanup(slirp);
253 m_cleanup(slirp);
255 g_free(slirp->tftp_prefix);
256 g_free(slirp->bootp_filename);
257 g_free(slirp);
260 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
261 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
262 #define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
264 void slirp_update_timeout(uint32_t *timeout)
266 if (!QTAILQ_EMPTY(&slirp_instances)) {
267 *timeout = MIN(1000, *timeout);
271 void slirp_select_fill(int *pnfds,
272 fd_set *readfds, fd_set *writefds, fd_set *xfds)
274 Slirp *slirp;
275 struct socket *so, *so_next;
276 int nfds;
278 if (QTAILQ_EMPTY(&slirp_instances)) {
279 return;
282 /* fail safe */
283 global_readfds = NULL;
284 global_writefds = NULL;
285 global_xfds = NULL;
287 nfds = *pnfds;
289 * First, TCP sockets
291 do_slowtimo = 0;
293 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
295 * *_slowtimo needs calling if there are IP fragments
296 * in the fragment queue, or there are TCP connections active
298 do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
299 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
301 for (so = slirp->tcb.so_next; so != &slirp->tcb;
302 so = so_next) {
303 so_next = so->so_next;
306 * See if we need a tcp_fasttimo
308 if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
309 time_fasttimo = curtime; /* Flag when we want a fasttimo */
312 * NOFDREF can include still connecting to local-host,
313 * newly socreated() sockets etc. Don't want to select these.
315 if (so->so_state & SS_NOFDREF || so->s == -1)
316 continue;
319 * Set for reading sockets which are accepting
321 if (so->so_state & SS_FACCEPTCONN) {
322 FD_SET(so->s, readfds);
323 UPD_NFDS(so->s);
324 continue;
328 * Set for writing sockets which are connecting
330 if (so->so_state & SS_ISFCONNECTING) {
331 FD_SET(so->s, writefds);
332 UPD_NFDS(so->s);
333 continue;
337 * Set for writing if we are connected, can send more, and
338 * we have something to send
340 if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
341 FD_SET(so->s, writefds);
342 UPD_NFDS(so->s);
346 * Set for reading (and urgent data) if we are connected, can
347 * receive more, and we have room for it XXX /2 ?
349 if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
350 FD_SET(so->s, readfds);
351 FD_SET(so->s, xfds);
352 UPD_NFDS(so->s);
357 * UDP sockets
359 for (so = slirp->udb.so_next; so != &slirp->udb;
360 so = so_next) {
361 so_next = so->so_next;
364 * See if it's timed out
366 if (so->so_expire) {
367 if (so->so_expire <= curtime) {
368 udp_detach(so);
369 continue;
370 } else
371 do_slowtimo = 1; /* Let socket expire */
375 * When UDP packets are received from over the
376 * link, they're sendto()'d straight away, so
377 * no need for setting for writing
378 * Limit the number of packets queued by this session
379 * to 4. Note that even though we try and limit this
380 * to 4 packets, the session could have more queued
381 * if the packets needed to be fragmented
382 * (XXX <= 4 ?)
384 if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
385 FD_SET(so->s, readfds);
386 UPD_NFDS(so->s);
391 * ICMP sockets
393 for (so = slirp->icmp.so_next; so != &slirp->icmp;
394 so = so_next) {
395 so_next = so->so_next;
398 * See if it's timed out
400 if (so->so_expire) {
401 if (so->so_expire <= curtime) {
402 icmp_detach(so);
403 continue;
404 } else {
405 do_slowtimo = 1; /* Let socket expire */
409 if (so->so_state & SS_ISFCONNECTED) {
410 FD_SET(so->s, readfds);
411 UPD_NFDS(so->s);
416 *pnfds = nfds;
419 void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
420 int select_error)
422 Slirp *slirp;
423 struct socket *so, *so_next;
424 int ret;
426 if (QTAILQ_EMPTY(&slirp_instances)) {
427 return;
430 global_readfds = readfds;
431 global_writefds = writefds;
432 global_xfds = xfds;
434 curtime = qemu_get_clock_ms(rt_clock);
436 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
438 * See if anything has timed out
440 if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
441 tcp_fasttimo(slirp);
442 time_fasttimo = 0;
444 if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
445 ip_slowtimo(slirp);
446 tcp_slowtimo(slirp);
447 last_slowtimo = curtime;
451 * Check sockets
453 if (!select_error) {
455 * Check TCP sockets
457 for (so = slirp->tcb.so_next; so != &slirp->tcb;
458 so = so_next) {
459 so_next = so->so_next;
462 * FD_ISSET is meaningless on these sockets
463 * (and they can crash the program)
465 if (so->so_state & SS_NOFDREF || so->s == -1)
466 continue;
469 * Check for URG data
470 * This will soread as well, so no need to
471 * test for readfds below if this succeeds
473 if (FD_ISSET(so->s, xfds))
474 sorecvoob(so);
476 * Check sockets for reading
478 else if (FD_ISSET(so->s, readfds)) {
480 * Check for incoming connections
482 if (so->so_state & SS_FACCEPTCONN) {
483 tcp_connect(so);
484 continue;
485 } /* else */
486 ret = soread(so);
488 /* Output it if we read something */
489 if (ret > 0)
490 tcp_output(sototcpcb(so));
494 * Check sockets for writing
496 if (FD_ISSET(so->s, writefds)) {
498 * Check for non-blocking, still-connecting sockets
500 if (so->so_state & SS_ISFCONNECTING) {
501 /* Connected */
502 so->so_state &= ~SS_ISFCONNECTING;
504 ret = send(so->s, (const void *) &ret, 0, 0);
505 if (ret < 0) {
506 /* XXXXX Must fix, zero bytes is a NOP */
507 if (errno == EAGAIN || errno == EWOULDBLOCK ||
508 errno == EINPROGRESS || errno == ENOTCONN)
509 continue;
511 /* else failed */
512 so->so_state &= SS_PERSISTENT_MASK;
513 so->so_state |= SS_NOFDREF;
515 /* else so->so_state &= ~SS_ISFCONNECTING; */
518 * Continue tcp_input
520 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
521 /* continue; */
522 } else
523 ret = sowrite(so);
525 * XXXXX If we wrote something (a lot), there
526 * could be a need for a window update.
527 * In the worst case, the remote will send
528 * a window probe to get things going again
533 * Probe a still-connecting, non-blocking socket
534 * to check if it's still alive
536 #ifdef PROBE_CONN
537 if (so->so_state & SS_ISFCONNECTING) {
538 ret = qemu_recv(so->s, &ret, 0,0);
540 if (ret < 0) {
541 /* XXX */
542 if (errno == EAGAIN || errno == EWOULDBLOCK ||
543 errno == EINPROGRESS || errno == ENOTCONN)
544 continue; /* Still connecting, continue */
546 /* else failed */
547 so->so_state &= SS_PERSISTENT_MASK;
548 so->so_state |= SS_NOFDREF;
550 /* tcp_input will take care of it */
551 } else {
552 ret = send(so->s, &ret, 0,0);
553 if (ret < 0) {
554 /* XXX */
555 if (errno == EAGAIN || errno == EWOULDBLOCK ||
556 errno == EINPROGRESS || errno == ENOTCONN)
557 continue;
558 /* else failed */
559 so->so_state &= SS_PERSISTENT_MASK;
560 so->so_state |= SS_NOFDREF;
561 } else
562 so->so_state &= ~SS_ISFCONNECTING;
565 tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
566 } /* SS_ISFCONNECTING */
567 #endif
571 * Now UDP sockets.
572 * Incoming packets are sent straight away, they're not buffered.
573 * Incoming UDP data isn't buffered either.
575 for (so = slirp->udb.so_next; so != &slirp->udb;
576 so = so_next) {
577 so_next = so->so_next;
579 if (so->s != -1 && FD_ISSET(so->s, readfds)) {
580 sorecvfrom(so);
585 * Check incoming ICMP relies.
587 for (so = slirp->icmp.so_next; so != &slirp->icmp;
588 so = so_next) {
589 so_next = so->so_next;
591 if (so->s != -1 && FD_ISSET(so->s, readfds)) {
592 icmp_receive(so);
597 if_start(slirp);
600 /* clear global file descriptor sets.
601 * these reside on the stack in vl.c
602 * so they're unusable if we're not in
603 * slirp_select_fill or slirp_select_poll.
605 global_readfds = NULL;
606 global_writefds = NULL;
607 global_xfds = NULL;
610 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
612 struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
613 uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
614 struct ethhdr *reh = (struct ethhdr *)arp_reply;
615 struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
616 int ar_op;
617 struct ex_list *ex_ptr;
619 ar_op = ntohs(ah->ar_op);
620 switch(ar_op) {
621 case ARPOP_REQUEST:
622 if (ah->ar_tip == ah->ar_sip) {
623 /* Gratuitous ARP */
624 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
625 return;
628 if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
629 slirp->vnetwork_addr.s_addr) {
630 if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
631 ah->ar_tip == slirp->vhost_addr.s_addr)
632 goto arp_ok;
633 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
634 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
635 goto arp_ok;
637 return;
638 arp_ok:
639 memset(arp_reply, 0, sizeof(arp_reply));
641 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
643 /* ARP request for alias/dns mac address */
644 memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
645 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
646 memcpy(&reh->h_source[2], &ah->ar_tip, 4);
647 reh->h_proto = htons(ETH_P_ARP);
649 rah->ar_hrd = htons(1);
650 rah->ar_pro = htons(ETH_P_IP);
651 rah->ar_hln = ETH_ALEN;
652 rah->ar_pln = 4;
653 rah->ar_op = htons(ARPOP_REPLY);
654 memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
655 rah->ar_sip = ah->ar_tip;
656 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
657 rah->ar_tip = ah->ar_sip;
658 slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
660 break;
661 case ARPOP_REPLY:
662 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
663 break;
664 default:
665 break;
669 void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
671 struct mbuf *m;
672 int proto;
674 if (pkt_len < ETH_HLEN)
675 return;
677 proto = ntohs(*(uint16_t *)(pkt + 12));
678 switch(proto) {
679 case ETH_P_ARP:
680 arp_input(slirp, pkt, pkt_len);
681 break;
682 case ETH_P_IP:
683 m = m_get(slirp);
684 if (!m)
685 return;
686 /* Note: we add to align the IP header */
687 if (M_FREEROOM(m) < pkt_len + 2) {
688 m_inc(m, pkt_len + 2);
690 m->m_len = pkt_len + 2;
691 memcpy(m->m_data + 2, pkt, pkt_len);
693 m->m_data += 2 + ETH_HLEN;
694 m->m_len -= 2 + ETH_HLEN;
696 ip_input(m);
697 break;
698 default:
699 break;
703 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
704 * re-queued.
706 int if_encap(Slirp *slirp, struct mbuf *ifm)
708 uint8_t buf[1600];
709 struct ethhdr *eh = (struct ethhdr *)buf;
710 uint8_t ethaddr[ETH_ALEN];
711 const struct ip *iph = (const struct ip *)ifm->m_data;
713 if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
714 return 1;
717 if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
718 uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
719 struct ethhdr *reh = (struct ethhdr *)arp_req;
720 struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
722 if (!ifm->arp_requested) {
723 /* If the client addr is not known, send an ARP request */
724 memset(reh->h_dest, 0xff, ETH_ALEN);
725 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
726 memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
727 reh->h_proto = htons(ETH_P_ARP);
728 rah->ar_hrd = htons(1);
729 rah->ar_pro = htons(ETH_P_IP);
730 rah->ar_hln = ETH_ALEN;
731 rah->ar_pln = 4;
732 rah->ar_op = htons(ARPOP_REQUEST);
734 /* source hw addr */
735 memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
736 memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
738 /* source IP */
739 rah->ar_sip = slirp->vhost_addr.s_addr;
741 /* target hw addr (none) */
742 memset(rah->ar_tha, 0, ETH_ALEN);
744 /* target IP */
745 rah->ar_tip = iph->ip_dst.s_addr;
746 slirp->client_ipaddr = iph->ip_dst;
747 slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
748 ifm->arp_requested = true;
750 /* Expire request and drop outgoing packet after 1 second */
751 ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL;
753 return 0;
754 } else {
755 memcpy(eh->h_dest, ethaddr, ETH_ALEN);
756 memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
757 /* XXX: not correct */
758 memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
759 eh->h_proto = htons(ETH_P_IP);
760 memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
761 slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
762 return 1;
766 /* Drop host forwarding rule, return 0 if found. */
767 int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
768 int host_port)
770 struct socket *so;
771 struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
772 struct sockaddr_in addr;
773 int port = htons(host_port);
774 socklen_t addr_len;
776 for (so = head->so_next; so != head; so = so->so_next) {
777 addr_len = sizeof(addr);
778 if ((so->so_state & SS_HOSTFWD) &&
779 getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
780 addr.sin_addr.s_addr == host_addr.s_addr &&
781 addr.sin_port == port) {
782 close(so->s);
783 sofree(so);
784 return 0;
788 return -1;
791 int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
792 int host_port, struct in_addr guest_addr, int guest_port)
794 if (!guest_addr.s_addr) {
795 guest_addr = slirp->vdhcp_startaddr;
797 if (is_udp) {
798 if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
799 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
800 return -1;
801 } else {
802 if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
803 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
804 return -1;
806 return 0;
809 int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
810 struct in_addr *guest_addr, int guest_port)
812 if (!guest_addr->s_addr) {
813 guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
814 (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
816 if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
817 slirp->vnetwork_addr.s_addr ||
818 guest_addr->s_addr == slirp->vhost_addr.s_addr ||
819 guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
820 return -1;
822 return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
823 htons(guest_port));
826 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
828 if (so->s == -1 && so->extra) {
829 qemu_chr_fe_write(so->extra, buf, len);
830 return len;
833 return send(so->s, buf, len, flags);
836 static struct socket *
837 slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
839 struct socket *so;
841 for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
842 if (so->so_faddr.s_addr == guest_addr.s_addr &&
843 htons(so->so_fport) == guest_port) {
844 return so;
847 return NULL;
850 size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
851 int guest_port)
853 struct iovec iov[2];
854 struct socket *so;
856 so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
858 if (!so || so->so_state & SS_NOFDREF)
859 return 0;
861 if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2))
862 return 0;
864 return sopreprbuf(so, iov, NULL);
867 void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
868 const uint8_t *buf, int size)
870 int ret;
871 struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
873 if (!so)
874 return;
876 ret = soreadbuf(so, (const char *)buf, size);
878 if (ret > 0)
879 tcp_output(sototcpcb(so));
882 static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
884 int i;
886 qemu_put_sbe16(f, tp->t_state);
887 for (i = 0; i < TCPT_NTIMERS; i++)
888 qemu_put_sbe16(f, tp->t_timer[i]);
889 qemu_put_sbe16(f, tp->t_rxtshift);
890 qemu_put_sbe16(f, tp->t_rxtcur);
891 qemu_put_sbe16(f, tp->t_dupacks);
892 qemu_put_be16(f, tp->t_maxseg);
893 qemu_put_sbyte(f, tp->t_force);
894 qemu_put_be16(f, tp->t_flags);
895 qemu_put_be32(f, tp->snd_una);
896 qemu_put_be32(f, tp->snd_nxt);
897 qemu_put_be32(f, tp->snd_up);
898 qemu_put_be32(f, tp->snd_wl1);
899 qemu_put_be32(f, tp->snd_wl2);
900 qemu_put_be32(f, tp->iss);
901 qemu_put_be32(f, tp->snd_wnd);
902 qemu_put_be32(f, tp->rcv_wnd);
903 qemu_put_be32(f, tp->rcv_nxt);
904 qemu_put_be32(f, tp->rcv_up);
905 qemu_put_be32(f, tp->irs);
906 qemu_put_be32(f, tp->rcv_adv);
907 qemu_put_be32(f, tp->snd_max);
908 qemu_put_be32(f, tp->snd_cwnd);
909 qemu_put_be32(f, tp->snd_ssthresh);
910 qemu_put_sbe16(f, tp->t_idle);
911 qemu_put_sbe16(f, tp->t_rtt);
912 qemu_put_be32(f, tp->t_rtseq);
913 qemu_put_sbe16(f, tp->t_srtt);
914 qemu_put_sbe16(f, tp->t_rttvar);
915 qemu_put_be16(f, tp->t_rttmin);
916 qemu_put_be32(f, tp->max_sndwnd);
917 qemu_put_byte(f, tp->t_oobflags);
918 qemu_put_byte(f, tp->t_iobc);
919 qemu_put_sbe16(f, tp->t_softerror);
920 qemu_put_byte(f, tp->snd_scale);
921 qemu_put_byte(f, tp->rcv_scale);
922 qemu_put_byte(f, tp->request_r_scale);
923 qemu_put_byte(f, tp->requested_s_scale);
924 qemu_put_be32(f, tp->ts_recent);
925 qemu_put_be32(f, tp->ts_recent_age);
926 qemu_put_be32(f, tp->last_ack_sent);
929 static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
931 uint32_t off;
933 qemu_put_be32(f, sbuf->sb_cc);
934 qemu_put_be32(f, sbuf->sb_datalen);
935 off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
936 qemu_put_sbe32(f, off);
937 off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
938 qemu_put_sbe32(f, off);
939 qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
942 static void slirp_socket_save(QEMUFile *f, struct socket *so)
944 qemu_put_be32(f, so->so_urgc);
945 qemu_put_be32(f, so->so_faddr.s_addr);
946 qemu_put_be32(f, so->so_laddr.s_addr);
947 qemu_put_be16(f, so->so_fport);
948 qemu_put_be16(f, so->so_lport);
949 qemu_put_byte(f, so->so_iptos);
950 qemu_put_byte(f, so->so_emu);
951 qemu_put_byte(f, so->so_type);
952 qemu_put_be32(f, so->so_state);
953 slirp_sbuf_save(f, &so->so_rcv);
954 slirp_sbuf_save(f, &so->so_snd);
955 slirp_tcp_save(f, so->so_tcpcb);
958 static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
960 int i;
962 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
963 qemu_put_be16(f, slirp->bootp_clients[i].allocated);
964 qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
968 static void slirp_state_save(QEMUFile *f, void *opaque)
970 Slirp *slirp = opaque;
971 struct ex_list *ex_ptr;
973 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
974 if (ex_ptr->ex_pty == 3) {
975 struct socket *so;
976 so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
977 ntohs(ex_ptr->ex_fport));
978 if (!so)
979 continue;
981 qemu_put_byte(f, 42);
982 slirp_socket_save(f, so);
984 qemu_put_byte(f, 0);
986 qemu_put_be16(f, slirp->ip_id);
988 slirp_bootp_save(f, slirp);
991 static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
993 int i;
995 tp->t_state = qemu_get_sbe16(f);
996 for (i = 0; i < TCPT_NTIMERS; i++)
997 tp->t_timer[i] = qemu_get_sbe16(f);
998 tp->t_rxtshift = qemu_get_sbe16(f);
999 tp->t_rxtcur = qemu_get_sbe16(f);
1000 tp->t_dupacks = qemu_get_sbe16(f);
1001 tp->t_maxseg = qemu_get_be16(f);
1002 tp->t_force = qemu_get_sbyte(f);
1003 tp->t_flags = qemu_get_be16(f);
1004 tp->snd_una = qemu_get_be32(f);
1005 tp->snd_nxt = qemu_get_be32(f);
1006 tp->snd_up = qemu_get_be32(f);
1007 tp->snd_wl1 = qemu_get_be32(f);
1008 tp->snd_wl2 = qemu_get_be32(f);
1009 tp->iss = qemu_get_be32(f);
1010 tp->snd_wnd = qemu_get_be32(f);
1011 tp->rcv_wnd = qemu_get_be32(f);
1012 tp->rcv_nxt = qemu_get_be32(f);
1013 tp->rcv_up = qemu_get_be32(f);
1014 tp->irs = qemu_get_be32(f);
1015 tp->rcv_adv = qemu_get_be32(f);
1016 tp->snd_max = qemu_get_be32(f);
1017 tp->snd_cwnd = qemu_get_be32(f);
1018 tp->snd_ssthresh = qemu_get_be32(f);
1019 tp->t_idle = qemu_get_sbe16(f);
1020 tp->t_rtt = qemu_get_sbe16(f);
1021 tp->t_rtseq = qemu_get_be32(f);
1022 tp->t_srtt = qemu_get_sbe16(f);
1023 tp->t_rttvar = qemu_get_sbe16(f);
1024 tp->t_rttmin = qemu_get_be16(f);
1025 tp->max_sndwnd = qemu_get_be32(f);
1026 tp->t_oobflags = qemu_get_byte(f);
1027 tp->t_iobc = qemu_get_byte(f);
1028 tp->t_softerror = qemu_get_sbe16(f);
1029 tp->snd_scale = qemu_get_byte(f);
1030 tp->rcv_scale = qemu_get_byte(f);
1031 tp->request_r_scale = qemu_get_byte(f);
1032 tp->requested_s_scale = qemu_get_byte(f);
1033 tp->ts_recent = qemu_get_be32(f);
1034 tp->ts_recent_age = qemu_get_be32(f);
1035 tp->last_ack_sent = qemu_get_be32(f);
1036 tcp_template(tp);
1039 static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
1041 uint32_t off, sb_cc, sb_datalen;
1043 sb_cc = qemu_get_be32(f);
1044 sb_datalen = qemu_get_be32(f);
1046 sbreserve(sbuf, sb_datalen);
1048 if (sbuf->sb_datalen != sb_datalen)
1049 return -ENOMEM;
1051 sbuf->sb_cc = sb_cc;
1053 off = qemu_get_sbe32(f);
1054 sbuf->sb_wptr = sbuf->sb_data + off;
1055 off = qemu_get_sbe32(f);
1056 sbuf->sb_rptr = sbuf->sb_data + off;
1057 qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1059 return 0;
1062 static int slirp_socket_load(QEMUFile *f, struct socket *so)
1064 if (tcp_attach(so) < 0)
1065 return -ENOMEM;
1067 so->so_urgc = qemu_get_be32(f);
1068 so->so_faddr.s_addr = qemu_get_be32(f);
1069 so->so_laddr.s_addr = qemu_get_be32(f);
1070 so->so_fport = qemu_get_be16(f);
1071 so->so_lport = qemu_get_be16(f);
1072 so->so_iptos = qemu_get_byte(f);
1073 so->so_emu = qemu_get_byte(f);
1074 so->so_type = qemu_get_byte(f);
1075 so->so_state = qemu_get_be32(f);
1076 if (slirp_sbuf_load(f, &so->so_rcv) < 0)
1077 return -ENOMEM;
1078 if (slirp_sbuf_load(f, &so->so_snd) < 0)
1079 return -ENOMEM;
1080 slirp_tcp_load(f, so->so_tcpcb);
1082 return 0;
1085 static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
1087 int i;
1089 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1090 slirp->bootp_clients[i].allocated = qemu_get_be16(f);
1091 qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1095 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1097 Slirp *slirp = opaque;
1098 struct ex_list *ex_ptr;
1100 while (qemu_get_byte(f)) {
1101 int ret;
1102 struct socket *so = socreate(slirp);
1104 if (!so)
1105 return -ENOMEM;
1107 ret = slirp_socket_load(f, so);
1109 if (ret < 0)
1110 return ret;
1112 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1113 slirp->vnetwork_addr.s_addr) {
1114 return -EINVAL;
1116 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1117 if (ex_ptr->ex_pty == 3 &&
1118 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1119 so->so_fport == ex_ptr->ex_fport) {
1120 break;
1123 if (!ex_ptr)
1124 return -EINVAL;
1126 so->extra = (void *)ex_ptr->ex_exec;
1129 if (version_id >= 2) {
1130 slirp->ip_id = qemu_get_be16(f);
1133 if (version_id >= 3) {
1134 slirp_bootp_load(f, slirp);
1137 return 0;