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