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