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