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