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