1: /*
2: * libslirp glue
3: *
4: * Copyright (c) 2004-2008 Fabrice Bellard
5: *
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:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
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.
23: */
24: #include "qemu-common.h"
25: #include "qemu-timer.h"
26: #include "qemu-char.h"
27: #include "slirp.h"
28: #include "hw/hw.h"
29:
30: /* host loopback address */
31: struct in_addr loopback_addr;
32:
33: /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
34: static const uint8_t special_ethaddr[6] = {
35: 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
36: };
37:
38: static const uint8_t zero_ethaddr[6] = { 0, 0, 0, 0, 0, 0 };
39:
40: /* XXX: suppress those select globals */
41: fd_set *global_readfds, *global_writefds, *global_xfds;
42:
43: u_int curtime;
44: static u_int time_fasttimo, last_slowtimo;
45: static int do_slowtimo;
46:
47: static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
48: QTAILQ_HEAD_INITIALIZER(slirp_instances);
49:
50: static struct in_addr dns_addr;
51: static u_int dns_addr_time;
52:
53: #ifdef _WIN32
54:
55: int get_dns_addr(struct in_addr *pdns_addr)
56: {
57: FIXED_INFO *FixedInfo=NULL;
58: ULONG BufLen;
59: DWORD ret;
60: IP_ADDR_STRING *pIPAddr;
61: struct in_addr tmp_addr;
62:
63: if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < 1000) {
64: *pdns_addr = dns_addr;
65: return 0;
66: }
67:
68: FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
69: BufLen = sizeof(FIXED_INFO);
70:
71: if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
72: if (FixedInfo) {
73: GlobalFree(FixedInfo);
74: FixedInfo = NULL;
75: }
76: FixedInfo = GlobalAlloc(GPTR, BufLen);
77: }
78:
79: if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
80: printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
81: if (FixedInfo) {
82: GlobalFree(FixedInfo);
83: FixedInfo = NULL;
84: }
85: return -1;
86: }
87:
88: pIPAddr = &(FixedInfo->DnsServerList);
89: inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
90: *pdns_addr = tmp_addr;
91: dns_addr = tmp_addr;
92: dns_addr_time = curtime;
93: if (FixedInfo) {
94: GlobalFree(FixedInfo);
95: FixedInfo = NULL;
96: }
97: return 0;
98: }
99:
100: static void winsock_cleanup(void)
101: {
102: WSACleanup();
103: }
104:
105: #else
106:
107: static struct stat dns_addr_stat;
108:
109: int get_dns_addr(struct in_addr *pdns_addr)
110: {
111: char buff[512];
112: char buff2[257];
113: FILE *f;
114: int found = 0;
115: struct in_addr tmp_addr;
116:
117: if (dns_addr.s_addr != 0) {
118: struct stat old_stat;
119: if ((curtime - dns_addr_time) < 1000) {
120: *pdns_addr = dns_addr;
121: return 0;
122: }
123: old_stat = dns_addr_stat;
124: if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
125: return -1;
126: if ((dns_addr_stat.st_dev == old_stat.st_dev)
127: && (dns_addr_stat.st_ino == old_stat.st_ino)
128: && (dns_addr_stat.st_size == old_stat.st_size)
129: && (dns_addr_stat.st_mtime == old_stat.st_mtime)) {
130: *pdns_addr = dns_addr;
131: return 0;
132: }
133: }
134:
135: f = fopen("/etc/resolv.conf", "r");
136: if (!f)
137: return -1;
138:
139: #ifdef DEBUG
140: lprint("IP address of your DNS(s): ");
141: #endif
142: while (fgets(buff, 512, f) != NULL) {
143: if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
144: if (!inet_aton(buff2, &tmp_addr))
145: continue;
146: /* If it's the first one, set it to dns_addr */
147: if (!found) {
148: *pdns_addr = tmp_addr;
149: dns_addr = tmp_addr;
150: dns_addr_time = curtime;
151: }
152: #ifdef DEBUG
153: else
154: lprint(", ");
155: #endif
156: if (++found > 3) {
157: #ifdef DEBUG
158: lprint("(more)");
159: #endif
160: break;
161: }
162: #ifdef DEBUG
163: else
164: lprint("%s", inet_ntoa(tmp_addr));
165: #endif
166: }
167: }
168: fclose(f);
169: if (!found)
170: return -1;
171: return 0;
172: }
173:
174: #endif
175:
176: static void slirp_init_once(void)
177: {
178: static int initialized;
179: #ifdef _WIN32
180: WSADATA Data;
181: #endif
182:
183: if (initialized) {
184: return;
185: }
186: initialized = 1;
187:
188: #ifdef _WIN32
189: WSAStartup(MAKEWORD(2,0), &Data);
190: atexit(winsock_cleanup);
191: #endif
192:
193: loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
194: }
195:
196: static void slirp_state_save(QEMUFile *f, void *opaque);
197: static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
198:
199: Slirp *slirp_init(int restricted, struct in_addr vnetwork,
200: struct in_addr vnetmask, struct in_addr vhost,
201: const char *vhostname, const char *tftp_path,
202: const char *bootfile, struct in_addr vdhcp_start,
203: struct in_addr vnameserver, void *opaque)
204: {
205: Slirp *slirp = qemu_mallocz(sizeof(Slirp));
206:
207: slirp_init_once();
208:
209: slirp->restricted = restricted;
210:
211: if_init(slirp);
212: ip_init(slirp);
213:
214: /* Initialise mbufs *after* setting the MTU */
215: m_init(slirp);
216:
217: slirp->vnetwork_addr = vnetwork;
218: slirp->vnetwork_mask = vnetmask;
219: slirp->vhost_addr = vhost;
220: if (vhostname) {
221: pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
222: vhostname);
223: }
224: if (tftp_path) {
225: slirp->tftp_prefix = qemu_strdup(tftp_path);
226: }
227: if (bootfile) {
228: slirp->bootp_filename = qemu_strdup(bootfile);
229: }
230: slirp->vdhcp_startaddr = vdhcp_start;
231: slirp->vnameserver_addr = vnameserver;
232:
233: slirp->opaque = opaque;
234:
235: register_savevm("slirp", 0, 3, slirp_state_save, slirp_state_load, slirp);
236:
237: QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
238:
239: return slirp;
240: }
241:
242: void slirp_cleanup(Slirp *slirp)
243: {
244: QTAILQ_REMOVE(&slirp_instances, slirp, entry);
245:
246: unregister_savevm("slirp", slirp);
247:
248: qemu_free(slirp->tftp_prefix);
249: qemu_free(slirp->bootp_filename);
250: qemu_free(slirp);
251: }
252:
253: #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
254: #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
255: #define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
256:
257: void slirp_select_fill(int *pnfds,
258: fd_set *readfds, fd_set *writefds, fd_set *xfds)
259: {
260: Slirp *slirp;
261: struct socket *so, *so_next;
262: int nfds;
263:
264: if (QTAILQ_EMPTY(&slirp_instances)) {
265: return;
266: }
267:
268: /* fail safe */
269: global_readfds = NULL;
270: global_writefds = NULL;
271: global_xfds = NULL;
272:
273: nfds = *pnfds;
274: /*
275: * First, TCP sockets
276: */
277: do_slowtimo = 0;
278:
279: QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
280: /*
281: * *_slowtimo needs calling if there are IP fragments
282: * in the fragment queue, or there are TCP connections active
283: */
284: do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
285: (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
286:
287: for (so = slirp->tcb.so_next; so != &slirp->tcb;
288: so = so_next) {
289: so_next = so->so_next;
290:
291: /*
292: * See if we need a tcp_fasttimo
293: */
294: if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
295: time_fasttimo = curtime; /* Flag when we want a fasttimo */
296:
297: /*
298: * NOFDREF can include still connecting to local-host,
299: * newly socreated() sockets etc. Don't want to select these.
300: */
301: if (so->so_state & SS_NOFDREF || so->s == -1)
302: continue;
303:
304: /*
305: * Set for reading sockets which are accepting
306: */
307: if (so->so_state & SS_FACCEPTCONN) {
308: FD_SET(so->s, readfds);
309: UPD_NFDS(so->s);
310: continue;
311: }
312:
313: /*
314: * Set for writing sockets which are connecting
315: */
316: if (so->so_state & SS_ISFCONNECTING) {
317: FD_SET(so->s, writefds);
318: UPD_NFDS(so->s);
319: continue;
320: }
321:
322: /*
323: * Set for writing if we are connected, can send more, and
324: * we have something to send
325: */
326: if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
327: FD_SET(so->s, writefds);
328: UPD_NFDS(so->s);
329: }
330:
331: /*
332: * Set for reading (and urgent data) if we are connected, can
333: * receive more, and we have room for it XXX /2 ?
334: */
335: if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
336: FD_SET(so->s, readfds);
337: FD_SET(so->s, xfds);
338: UPD_NFDS(so->s);
339: }
340: }
341:
342: /*
343: * UDP sockets
344: */
345: for (so = slirp->udb.so_next; so != &slirp->udb;
346: so = so_next) {
347: so_next = so->so_next;
348:
349: /*
350: * See if it's timed out
351: */
352: if (so->so_expire) {
353: if (so->so_expire <= curtime) {
354: udp_detach(so);
355: continue;
356: } else
357: do_slowtimo = 1; /* Let socket expire */
358: }
359:
360: /*
361: * When UDP packets are received from over the
362: * link, they're sendto()'d straight away, so
363: * no need for setting for writing
364: * Limit the number of packets queued by this session
365: * to 4. Note that even though we try and limit this
366: * to 4 packets, the session could have more queued
367: * if the packets needed to be fragmented
368: * (XXX <= 4 ?)
369: */
370: if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
371: FD_SET(so->s, readfds);
372: UPD_NFDS(so->s);
373: }
374: }
375: }
376:
377: *pnfds = nfds;
378: }
379:
380: void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
381: int select_error)
382: {
383: Slirp *slirp;
384: struct socket *so, *so_next;
385: int ret;
386:
387: if (QTAILQ_EMPTY(&slirp_instances)) {
388: return;
389: }
390:
391: global_readfds = readfds;
392: global_writefds = writefds;
393: global_xfds = xfds;
394:
395: curtime = qemu_get_clock(rt_clock);
396:
397: QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
398: /*
399: * See if anything has timed out
400: */
401: if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
402: tcp_fasttimo(slirp);
403: time_fasttimo = 0;
404: }
405: if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
406: ip_slowtimo(slirp);
407: tcp_slowtimo(slirp);
408: last_slowtimo = curtime;
409: }
410:
411: /*
412: * Check sockets
413: */
414: if (!select_error) {
415: /*
416: * Check TCP sockets
417: */
418: for (so = slirp->tcb.so_next; so != &slirp->tcb;
419: so = so_next) {
420: so_next = so->so_next;
421:
422: /*
423: * FD_ISSET is meaningless on these sockets
424: * (and they can crash the program)
425: */
426: if (so->so_state & SS_NOFDREF || so->s == -1)
427: continue;
428:
429: /*
430: * Check for URG data
431: * This will soread as well, so no need to
432: * test for readfds below if this succeeds
433: */
434: if (FD_ISSET(so->s, xfds))
435: sorecvoob(so);
436: /*
437: * Check sockets for reading
438: */
439: else if (FD_ISSET(so->s, readfds)) {
440: /*
441: * Check for incoming connections
442: */
443: if (so->so_state & SS_FACCEPTCONN) {
444: tcp_connect(so);
445: continue;
446: } /* else */
447: ret = soread(so);
448:
449: /* Output it if we read something */
450: if (ret > 0)
451: tcp_output(sototcpcb(so));
452: }
453:
454: /*
455: * Check sockets for writing
456: */
457: if (FD_ISSET(so->s, writefds)) {
458: /*
459: * Check for non-blocking, still-connecting sockets
460: */
461: if (so->so_state & SS_ISFCONNECTING) {
462: /* Connected */
463: so->so_state &= ~SS_ISFCONNECTING;
464:
465: ret = send(so->s, (const void *) &ret, 0, 0);
466: if (ret < 0) {
467: /* XXXXX Must fix, zero bytes is a NOP */
468: if (errno == EAGAIN || errno == EWOULDBLOCK ||
469: errno == EINPROGRESS || errno == ENOTCONN)
470: continue;
471:
472: /* else failed */
473: so->so_state &= SS_PERSISTENT_MASK;
474: so->so_state |= SS_NOFDREF;
475: }
476: /* else so->so_state &= ~SS_ISFCONNECTING; */
477:
478: /*
479: * Continue tcp_input
480: */
481: tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
482: /* continue; */
483: } else
484: ret = sowrite(so);
485: /*
486: * XXXXX If we wrote something (a lot), there
487: * could be a need for a window update.
488: * In the worst case, the remote will send
489: * a window probe to get things going again
490: */
491: }
492:
493: /*
494: * Probe a still-connecting, non-blocking socket
495: * to check if it's still alive
496: */
497: #ifdef PROBE_CONN
498: if (so->so_state & SS_ISFCONNECTING) {
499: ret = recv(so->s, (char *)&ret, 0,0);
500:
501: if (ret < 0) {
502: /* XXX */
503: if (errno == EAGAIN || errno == EWOULDBLOCK ||
504: errno == EINPROGRESS || errno == ENOTCONN)
505: continue; /* Still connecting, continue */
506:
507: /* else failed */
508: so->so_state &= SS_PERSISTENT_MASK;
509: so->so_state |= SS_NOFDREF;
510:
511: /* tcp_input will take care of it */
512: } else {
513: ret = send(so->s, &ret, 0,0);
514: if (ret < 0) {
515: /* XXX */
516: if (errno == EAGAIN || errno == EWOULDBLOCK ||
517: errno == EINPROGRESS || errno == ENOTCONN)
518: continue;
519: /* else failed */
520: so->so_state &= SS_PERSISTENT_MASK;
521: so->so_state |= SS_NOFDREF;
522: } else
523: so->so_state &= ~SS_ISFCONNECTING;
524:
525: }
526: tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
527: } /* SS_ISFCONNECTING */
528: #endif
529: }
530:
531: /*
532: * Now UDP sockets.
533: * Incoming packets are sent straight away, they're not buffered.
534: * Incoming UDP data isn't buffered either.
535: */
536: for (so = slirp->udb.so_next; so != &slirp->udb;
537: so = so_next) {
538: so_next = so->so_next;
539:
540: if (so->s != -1 && FD_ISSET(so->s, readfds)) {
541: sorecvfrom(so);
542: }
543: }
544: }
545:
546: /*
547: * See if we can start outputting
548: */
549: if (slirp->if_queued) {
550: if_start(slirp);
551: }
552: }
553:
554: /* clear global file descriptor sets.
555: * these reside on the stack in vl.c
556: * so they're unusable if we're not in
557: * slirp_select_fill or slirp_select_poll.
558: */
559: global_readfds = NULL;
560: global_writefds = NULL;
561: global_xfds = NULL;
562: }
563:
564: #define ETH_ALEN 6
565: #define ETH_HLEN 14
566:
567: #define ETH_P_IP 0x0800 /* Internet Protocol packet */
568: #define ETH_P_ARP 0x0806 /* Address Resolution packet */
569:
570: #define ARPOP_REQUEST 1 /* ARP request */
571: #define ARPOP_REPLY 2 /* ARP reply */
572:
573: struct ethhdr
574: {
575: unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
576: unsigned char h_source[ETH_ALEN]; /* source ether addr */
577: unsigned short h_proto; /* packet type ID field */
578: };
579:
580: struct arphdr
581: {
582: unsigned short ar_hrd; /* format of hardware address */
583: unsigned short ar_pro; /* format of protocol address */
584: unsigned char ar_hln; /* length of hardware address */
585: unsigned char ar_pln; /* length of protocol address */
586: unsigned short ar_op; /* ARP opcode (command) */
587:
588: /*
589: * Ethernet looks like this : This bit is variable sized however...
590: */
591: unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
592: uint32_t ar_sip; /* sender IP address */
593: unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
594: uint32_t ar_tip ; /* target IP address */
595: } __attribute__((packed));
596:
597: static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
598: {
599: struct ethhdr *eh = (struct ethhdr *)pkt;
600: struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
601: uint8_t arp_reply[ETH_HLEN + sizeof(struct arphdr)];
602: struct ethhdr *reh = (struct ethhdr *)arp_reply;
603: struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
604: int ar_op;
605: struct ex_list *ex_ptr;
606:
607: ar_op = ntohs(ah->ar_op);
608: switch(ar_op) {
609: case ARPOP_REQUEST:
610: if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
611: slirp->vnetwork_addr.s_addr) {
612: if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
613: ah->ar_tip == slirp->vhost_addr.s_addr)
614: goto arp_ok;
615: for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
616: if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
617: goto arp_ok;
618: }
619: return;
620: arp_ok:
621: /* XXX: make an ARP request to have the client address */
622: memcpy(slirp->client_ethaddr, eh->h_source, ETH_ALEN);
623:
624: /* ARP request for alias/dns mac address */
625: memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
626: memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
627: memcpy(&reh->h_source[2], &ah->ar_tip, 4);
628: reh->h_proto = htons(ETH_P_ARP);
629:
630: rah->ar_hrd = htons(1);
631: rah->ar_pro = htons(ETH_P_IP);
632: rah->ar_hln = ETH_ALEN;
633: rah->ar_pln = 4;
634: rah->ar_op = htons(ARPOP_REPLY);
635: memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
636: rah->ar_sip = ah->ar_tip;
637: memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
638: rah->ar_tip = ah->ar_sip;
639: slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
640: }
641: break;
642: case ARPOP_REPLY:
643: /* reply to request of client mac address ? */
644: if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN) &&
645: ah->ar_sip == slirp->client_ipaddr.s_addr) {
646: memcpy(slirp->client_ethaddr, ah->ar_sha, ETH_ALEN);
647: }
648: break;
649: default:
650: break;
651: }
652: }
653:
654: void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
655: {
656: struct mbuf *m;
657: int proto;
658:
659: if (pkt_len < ETH_HLEN)
660: return;
661:
662: proto = ntohs(*(uint16_t *)(pkt + 12));
663: switch(proto) {
664: case ETH_P_ARP:
665: arp_input(slirp, pkt, pkt_len);
666: break;
667: case ETH_P_IP:
668: m = m_get(slirp);
669: if (!m)
670: return;
671: /* Note: we add to align the IP header */
672: if (M_FREEROOM(m) < pkt_len + 2) {
673: m_inc(m, pkt_len + 2);
674: }
675: m->m_len = pkt_len + 2;
676: memcpy(m->m_data + 2, pkt, pkt_len);
677:
678: m->m_data += 2 + ETH_HLEN;
679: m->m_len -= 2 + ETH_HLEN;
680:
681: ip_input(m);
682: break;
683: default:
684: break;
685: }
686: }
687:
688: /* output the IP packet to the ethernet device */
689: void if_encap(Slirp *slirp, const uint8_t *ip_data, int ip_data_len)
690: {
691: uint8_t buf[1600];
692: struct ethhdr *eh = (struct ethhdr *)buf;
693:
694: if (ip_data_len + ETH_HLEN > sizeof(buf))
695: return;
696:
697: if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN)) {
698: uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
699: struct ethhdr *reh = (struct ethhdr *)arp_req;
700: struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
701: const struct ip *iph = (const struct ip *)ip_data;
702:
703: /* If the client addr is not known, there is no point in
704: sending the packet to it. Normally the sender should have
705: done an ARP request to get its MAC address. Here we do it
706: in place of sending the packet and we hope that the sender
707: will retry sending its packet. */
708: memset(reh->h_dest, 0xff, ETH_ALEN);
709: memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
710: memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
711: reh->h_proto = htons(ETH_P_ARP);
712: rah->ar_hrd = htons(1);
713: rah->ar_pro = htons(ETH_P_IP);
714: rah->ar_hln = ETH_ALEN;
715: rah->ar_pln = 4;
716: rah->ar_op = htons(ARPOP_REQUEST);
717: /* source hw addr */
718: memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
719: memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
720: /* source IP */
721: rah->ar_sip = slirp->vhost_addr.s_addr;
722: /* target hw addr (none) */
723: memset(rah->ar_tha, 0, ETH_ALEN);
724: /* target IP */
725: rah->ar_tip = iph->ip_dst.s_addr;
726: slirp->client_ipaddr = iph->ip_dst;
727: slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
728: } else {
729: memcpy(eh->h_dest, slirp->client_ethaddr, ETH_ALEN);
730: memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
731: /* XXX: not correct */
732: memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
733: eh->h_proto = htons(ETH_P_IP);
734: memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len);
735: slirp_output(slirp->opaque, buf, ip_data_len + ETH_HLEN);
736: }
737: }
738:
739: /* Drop host forwarding rule, return 0 if found. */
740: int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
741: int host_port)
742: {
743: struct socket *so;
744: struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
745: struct sockaddr_in addr;
746: int port = htons(host_port);
747: socklen_t addr_len;
748:
749: for (so = head->so_next; so != head; so = so->so_next) {
750: addr_len = sizeof(addr);
751: if ((so->so_state & SS_HOSTFWD) &&
752: getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
753: addr.sin_addr.s_addr == host_addr.s_addr &&
754: addr.sin_port == port) {
755: close(so->s);
756: sofree(so);
757: return 0;
758: }
759: }
760:
761: return -1;
762: }
763:
764: int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
765: int host_port, struct in_addr guest_addr, int guest_port)
766: {
767: if (!guest_addr.s_addr) {
768: guest_addr = slirp->vdhcp_startaddr;
769: }
770: if (is_udp) {
771: if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
772: guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
773: return -1;
774: } else {
775: if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
776: guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
777: return -1;
778: }
779: return 0;
780: }
781:
782: int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
783: struct in_addr *guest_addr, int guest_port)
784: {
785: if (!guest_addr->s_addr) {
786: guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
787: (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
788: }
789: if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
790: slirp->vnetwork_addr.s_addr ||
791: guest_addr->s_addr == slirp->vhost_addr.s_addr ||
792: guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
793: return -1;
794: }
795: return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
796: htons(guest_port));
797: }
798:
799: ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
800: {
801: if (so->s == -1 && so->extra) {
802: qemu_chr_write(so->extra, buf, len);
803: return len;
804: }
805:
806: return send(so->s, buf, len, flags);
807: }
808:
809: static struct socket *
810: slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
811: {
812: struct socket *so;
813:
814: for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
815: if (so->so_faddr.s_addr == guest_addr.s_addr &&
816: htons(so->so_fport) == guest_port) {
817: return so;
818: }
819: }
820: return NULL;
821: }
822:
823: size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
824: int guest_port)
825: {
826: struct iovec iov[2];
827: struct socket *so;
828:
829: so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
830:
831: if (!so || so->so_state & SS_NOFDREF)
832: return 0;
833:
834: if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2))
835: return 0;
836:
837: return sopreprbuf(so, iov, NULL);
838: }
839:
840: void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
841: const uint8_t *buf, int size)
842: {
843: int ret;
844: struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
845:
846: if (!so)
847: return;
848:
849: ret = soreadbuf(so, (const char *)buf, size);
850:
851: if (ret > 0)
852: tcp_output(sototcpcb(so));
853: }
854:
855: static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
856: {
857: int i;
858:
859: qemu_put_sbe16(f, tp->t_state);
860: for (i = 0; i < TCPT_NTIMERS; i++)
861: qemu_put_sbe16(f, tp->t_timer[i]);
862: qemu_put_sbe16(f, tp->t_rxtshift);
863: qemu_put_sbe16(f, tp->t_rxtcur);
864: qemu_put_sbe16(f, tp->t_dupacks);
865: qemu_put_be16(f, tp->t_maxseg);
866: qemu_put_sbyte(f, tp->t_force);
867: qemu_put_be16(f, tp->t_flags);
868: qemu_put_be32(f, tp->snd_una);
869: qemu_put_be32(f, tp->snd_nxt);
870: qemu_put_be32(f, tp->snd_up);
871: qemu_put_be32(f, tp->snd_wl1);
872: qemu_put_be32(f, tp->snd_wl2);
873: qemu_put_be32(f, tp->iss);
874: qemu_put_be32(f, tp->snd_wnd);
875: qemu_put_be32(f, tp->rcv_wnd);
876: qemu_put_be32(f, tp->rcv_nxt);
877: qemu_put_be32(f, tp->rcv_up);
878: qemu_put_be32(f, tp->irs);
879: qemu_put_be32(f, tp->rcv_adv);
880: qemu_put_be32(f, tp->snd_max);
881: qemu_put_be32(f, tp->snd_cwnd);
882: qemu_put_be32(f, tp->snd_ssthresh);
883: qemu_put_sbe16(f, tp->t_idle);
884: qemu_put_sbe16(f, tp->t_rtt);
885: qemu_put_be32(f, tp->t_rtseq);
886: qemu_put_sbe16(f, tp->t_srtt);
887: qemu_put_sbe16(f, tp->t_rttvar);
888: qemu_put_be16(f, tp->t_rttmin);
889: qemu_put_be32(f, tp->max_sndwnd);
890: qemu_put_byte(f, tp->t_oobflags);
891: qemu_put_byte(f, tp->t_iobc);
892: qemu_put_sbe16(f, tp->t_softerror);
893: qemu_put_byte(f, tp->snd_scale);
894: qemu_put_byte(f, tp->rcv_scale);
895: qemu_put_byte(f, tp->request_r_scale);
896: qemu_put_byte(f, tp->requested_s_scale);
897: qemu_put_be32(f, tp->ts_recent);
898: qemu_put_be32(f, tp->ts_recent_age);
899: qemu_put_be32(f, tp->last_ack_sent);
900: }
901:
902: static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
903: {
904: uint32_t off;
905:
906: qemu_put_be32(f, sbuf->sb_cc);
907: qemu_put_be32(f, sbuf->sb_datalen);
908: off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
909: qemu_put_sbe32(f, off);
910: off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
911: qemu_put_sbe32(f, off);
912: qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
913: }
914:
915: static void slirp_socket_save(QEMUFile *f, struct socket *so)
916: {
917: qemu_put_be32(f, so->so_urgc);
918: qemu_put_be32(f, so->so_faddr.s_addr);
919: qemu_put_be32(f, so->so_laddr.s_addr);
920: qemu_put_be16(f, so->so_fport);
921: qemu_put_be16(f, so->so_lport);
922: qemu_put_byte(f, so->so_iptos);
923: qemu_put_byte(f, so->so_emu);
924: qemu_put_byte(f, so->so_type);
925: qemu_put_be32(f, so->so_state);
926: slirp_sbuf_save(f, &so->so_rcv);
927: slirp_sbuf_save(f, &so->so_snd);
928: slirp_tcp_save(f, so->so_tcpcb);
929: }
930:
931: static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
932: {
933: int i;
934:
935: for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
936: qemu_put_be16(f, slirp->bootp_clients[i].allocated);
937: qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
938: }
939: }
940:
941: static void slirp_state_save(QEMUFile *f, void *opaque)
942: {
943: Slirp *slirp = opaque;
944: struct ex_list *ex_ptr;
945:
946: for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
947: if (ex_ptr->ex_pty == 3) {
948: struct socket *so;
949: so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
950: ntohs(ex_ptr->ex_fport));
951: if (!so)
952: continue;
953:
954: qemu_put_byte(f, 42);
955: slirp_socket_save(f, so);
956: }
957: qemu_put_byte(f, 0);
958:
959: qemu_put_be16(f, slirp->ip_id);
960:
961: slirp_bootp_save(f, slirp);
962: }
963:
964: static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
965: {
966: int i;
967:
968: tp->t_state = qemu_get_sbe16(f);
969: for (i = 0; i < TCPT_NTIMERS; i++)
970: tp->t_timer[i] = qemu_get_sbe16(f);
971: tp->t_rxtshift = qemu_get_sbe16(f);
972: tp->t_rxtcur = qemu_get_sbe16(f);
973: tp->t_dupacks = qemu_get_sbe16(f);
974: tp->t_maxseg = qemu_get_be16(f);
975: tp->t_force = qemu_get_sbyte(f);
976: tp->t_flags = qemu_get_be16(f);
977: tp->snd_una = qemu_get_be32(f);
978: tp->snd_nxt = qemu_get_be32(f);
979: tp->snd_up = qemu_get_be32(f);
980: tp->snd_wl1 = qemu_get_be32(f);
981: tp->snd_wl2 = qemu_get_be32(f);
982: tp->iss = qemu_get_be32(f);
983: tp->snd_wnd = qemu_get_be32(f);
984: tp->rcv_wnd = qemu_get_be32(f);
985: tp->rcv_nxt = qemu_get_be32(f);
986: tp->rcv_up = qemu_get_be32(f);
987: tp->irs = qemu_get_be32(f);
988: tp->rcv_adv = qemu_get_be32(f);
989: tp->snd_max = qemu_get_be32(f);
990: tp->snd_cwnd = qemu_get_be32(f);
991: tp->snd_ssthresh = qemu_get_be32(f);
992: tp->t_idle = qemu_get_sbe16(f);
993: tp->t_rtt = qemu_get_sbe16(f);
994: tp->t_rtseq = qemu_get_be32(f);
995: tp->t_srtt = qemu_get_sbe16(f);
996: tp->t_rttvar = qemu_get_sbe16(f);
997: tp->t_rttmin = qemu_get_be16(f);
998: tp->max_sndwnd = qemu_get_be32(f);
999: tp->t_oobflags = qemu_get_byte(f);
1000: tp->t_iobc = qemu_get_byte(f);
1001: tp->t_softerror = qemu_get_sbe16(f);
1002: tp->snd_scale = qemu_get_byte(f);
1003: tp->rcv_scale = qemu_get_byte(f);
1004: tp->request_r_scale = qemu_get_byte(f);
1005: tp->requested_s_scale = qemu_get_byte(f);
1006: tp->ts_recent = qemu_get_be32(f);
1007: tp->ts_recent_age = qemu_get_be32(f);
1008: tp->last_ack_sent = qemu_get_be32(f);
1009: tcp_template(tp);
1010: }
1011:
1012: static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
1013: {
1014: uint32_t off, sb_cc, sb_datalen;
1015:
1016: sb_cc = qemu_get_be32(f);
1017: sb_datalen = qemu_get_be32(f);
1018:
1019: sbreserve(sbuf, sb_datalen);
1020:
1021: if (sbuf->sb_datalen != sb_datalen)
1022: return -ENOMEM;
1023:
1024: sbuf->sb_cc = sb_cc;
1025:
1026: off = qemu_get_sbe32(f);
1027: sbuf->sb_wptr = sbuf->sb_data + off;
1028: off = qemu_get_sbe32(f);
1029: sbuf->sb_rptr = sbuf->sb_data + off;
1030: qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1031:
1032: return 0;
1033: }
1034:
1035: static int slirp_socket_load(QEMUFile *f, struct socket *so)
1036: {
1037: if (tcp_attach(so) < 0)
1038: return -ENOMEM;
1039:
1040: so->so_urgc = qemu_get_be32(f);
1041: so->so_faddr.s_addr = qemu_get_be32(f);
1042: so->so_laddr.s_addr = qemu_get_be32(f);
1043: so->so_fport = qemu_get_be16(f);
1044: so->so_lport = qemu_get_be16(f);
1045: so->so_iptos = qemu_get_byte(f);
1046: so->so_emu = qemu_get_byte(f);
1047: so->so_type = qemu_get_byte(f);
1048: so->so_state = qemu_get_be32(f);
1049: if (slirp_sbuf_load(f, &so->so_rcv) < 0)
1050: return -ENOMEM;
1051: if (slirp_sbuf_load(f, &so->so_snd) < 0)
1052: return -ENOMEM;
1053: slirp_tcp_load(f, so->so_tcpcb);
1054:
1055: return 0;
1056: }
1057:
1058: static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
1059: {
1060: int i;
1061:
1062: for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1063: slirp->bootp_clients[i].allocated = qemu_get_be16(f);
1064: qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1065: }
1066: }
1067:
1068: static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1069: {
1070: Slirp *slirp = opaque;
1071: struct ex_list *ex_ptr;
1072: int r;
1073:
1074: while ((r = qemu_get_byte(f))) {
1075: int ret;
1076: struct socket *so = socreate(slirp);
1077:
1078: if (!so)
1079: return -ENOMEM;
1080:
1081: ret = slirp_socket_load(f, so);
1082:
1083: if (ret < 0)
1084: return ret;
1085:
1086: if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1087: slirp->vnetwork_addr.s_addr) {
1088: return -EINVAL;
1089: }
1090: for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1091: if (ex_ptr->ex_pty == 3 &&
1092: so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1093: so->so_fport == ex_ptr->ex_fport) {
1094: break;
1095: }
1096: }
1097: if (!ex_ptr)
1098: return -EINVAL;
1099:
1100: so->extra = (void *)ex_ptr->ex_exec;
1101: }
1102:
1103: if (version_id >= 2) {
1104: slirp->ip_id = qemu_get_be16(f);
1105: }
1106:
1107: if (version_id >= 3) {
1108: slirp_bootp_load(f, slirp);
1109: }
1110:
1111: return 0;
1112: }
unix.superglobalmegacorp.com