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