slirp/slirp.c

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