slirp/slirp.c

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