slirp/socket.c

   1 /*
   2  * Copyright (c) 1995 Danny Gasparovski.
   3  *
   4  * Please read the file COPYRIGHT for the
   5  * terms and conditions of the copyright.
   6  */
   7
   8 #include "qemu/osdep.h"
   9 #include "qemu-common.h"
  10 #include "slirp.h"
  11 #include "ip_icmp.h"
  12 #ifdef __sun__
  13 #include <sys/filio.h>
  14 #endif
  15
  16 static void sofcantrcvmore(struct socket *so);
  17 static void sofcantsendmore(struct socket *so);
  18
  19 struct socket *solookup(struct socket **last, struct socket *head,
  20         struct sockaddr_storage *lhost, struct sockaddr_storage *fhost)
  21 {
  22     struct socket *so = *last;
  23
  24     /* Optimisation */
  25     if (so != head && sockaddr_equal(&(so->lhost.ss), lhost)
  26             && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) {
  27         return so;
  28     }
  29
  30     for (so = head->so_next; so != head; so = so->so_next) {
  31         if (sockaddr_equal(&(so->lhost.ss), lhost)
  32                 && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) {
  33             *last = so;
  34             return so;
  35         }
  36     }
  37
  38     return (struct socket *)NULL;
  39 }
  40
  41 /*
  42  * Create a new socket, initialise the fields
  43  * It is the responsibility of the caller to
  44  * insque() it into the correct linked-list
  45  */
  46 struct socket *
  47 socreate(Slirp *slirp)
  48 {
  49   struct socket *so;
  50
  51   so = (struct socket *)malloc(sizeof(struct socket));
  52   if(so) {
  53     memset(so, 0, sizeof(struct socket));
  54     so->so_state = SS_NOFDREF;
  55     so->s = -1;
  56     so->slirp = slirp;
  57     so->pollfds_idx = -1;
  58   }
  59   return(so);
  60 }
  61
  62 /*
  63  * remque and free a socket, clobber cache
  64  */
  65 void
  66 sofree(struct socket *so)
  67 {
  68   Slirp *slirp = so->slirp;
  69   struct mbuf *ifm;
  70
  71   for (ifm = (struct mbuf *) slirp->if_fastq.qh_link;
  72        (struct quehead *) ifm != &slirp->if_fastq;
  73        ifm = ifm->ifq_next) {
  74     if (ifm->ifq_so == so) {
  75       ifm->ifq_so = NULL;
  76     }
  77   }
  78
  79   for (ifm = (struct mbuf *) slirp->if_batchq.qh_link;
  80        (struct quehead *) ifm != &slirp->if_batchq;
  81        ifm = ifm->ifq_next) {
  82     if (ifm->ifq_so == so) {
  83       ifm->ifq_so = NULL;
  84     }
  85   }
  86
  87   if (so->so_emu==EMU_RSH && so->extra) {
  88         sofree(so->extra);
  89         so->extra=NULL;
  90   }
  91   if (so == slirp->tcp_last_so) {
  92       slirp->tcp_last_so = &slirp->tcb;
  93   } else if (so == slirp->udp_last_so) {
  94       slirp->udp_last_so = &slirp->udb;
  95   } else if (so == slirp->icmp_last_so) {
  96       slirp->icmp_last_so = &slirp->icmp;
  97   }
  98   m_free(so->so_m);
  99
 100   if(so->so_next && so->so_prev)
 101     remque(so);  /* crashes if so is not in a queue */
 102
 103   free(so);
 104 }
 105
 106 size_t sopreprbuf(struct socket *so, struct iovec *iov, int *np)
 107 {
 108         int n, lss, total;
 109         struct sbuf *sb = &so->so_snd;
 110         int len = sb->sb_datalen - sb->sb_cc;
 111         int mss = so->so_tcpcb->t_maxseg;
 112
 113         DEBUG_CALL("sopreprbuf");
 114         DEBUG_ARG("so = %p", so);
 115
 116         if (len <= 0)
 117                 return 0;
 118
 119         iov[0].iov_base = sb->sb_wptr;
 120         iov[1].iov_base = NULL;
 121         iov[1].iov_len = 0;
 122         if (sb->sb_wptr < sb->sb_rptr) {
 123                 iov[0].iov_len = sb->sb_rptr - sb->sb_wptr;
 124                 /* Should never succeed, but... */
 125                 if (iov[0].iov_len > len)
 126                    iov[0].iov_len = len;
 127                 if (iov[0].iov_len > mss)
 128                    iov[0].iov_len -= iov[0].iov_len%mss;
 129                 n = 1;
 130         } else {
 131                 iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr;
 132                 /* Should never succeed, but... */
 133                 if (iov[0].iov_len > len) iov[0].iov_len = len;
 134                 len -= iov[0].iov_len;
 135                 if (len) {
 136                         iov[1].iov_base = sb->sb_data;
 137                         iov[1].iov_len = sb->sb_rptr - sb->sb_data;
 138                         if(iov[1].iov_len > len)
 139                            iov[1].iov_len = len;
 140                         total = iov[0].iov_len + iov[1].iov_len;
 141                         if (total > mss) {
 142                                 lss = total%mss;
 143                                 if (iov[1].iov_len > lss) {
 144                                         iov[1].iov_len -= lss;
 145                                         n = 2;
 146                                 } else {
 147                                         lss -= iov[1].iov_len;
 148                                         iov[0].iov_len -= lss;
 149                                         n = 1;
 150                                 }
 151                         } else
 152                                 n = 2;
 153                 } else {
 154                         if (iov[0].iov_len > mss)
 155                            iov[0].iov_len -= iov[0].iov_len%mss;
 156                         n = 1;
 157                 }
 158         }
 159         if (np)
 160                 *np = n;
 161
 162         return iov[0].iov_len + (n - 1) * iov[1].iov_len;
 163 }
 164
 165 /*
 166  * Read from so's socket into sb_snd, updating all relevant sbuf fields
 167  * NOTE: This will only be called if it is select()ed for reading, so
 168  * a read() of 0 (or less) means it's disconnected
 169  */
 170 int
 171 soread(struct socket *so)
 172 {
 173         int n, nn;
 174         struct sbuf *sb = &so->so_snd;
 175         struct iovec iov[2];
 176
 177         DEBUG_CALL("soread");
 178         DEBUG_ARG("so = %p", so);
 179
 180         /*
 181          * No need to check if there's enough room to read.
 182          * soread wouldn't have been called if there weren't
 183          */
 184         sopreprbuf(so, iov, &n);
 185
 186 #ifdef HAVE_READV
 187         nn = readv(so->s, (struct iovec *)iov, n);
 188         DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
 189 #else
 190         nn = qemu_recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
 191 #endif
 192         if (nn <= 0) {
 193                 if (nn < 0 && (errno == EINTR || errno == EAGAIN))
 194                         return 0;
 195                 else {
 196                         int err;
 197                         socklen_t slen = sizeof err;
 198
 199                         err = errno;
 200                         if (nn == 0) {
 201                                 getsockopt(so->s, SOL_SOCKET, SO_ERROR,
 202                                            &err, &slen);
 203                         }
 204
 205                         DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
 206                         sofcantrcvmore(so);
 207
 208                         if (err == ECONNRESET || err == ECONNREFUSED
 209                             || err == ENOTCONN || err == EPIPE) {
 210                                 tcp_drop(sototcpcb(so), err);
 211                         } else {
 212                                 tcp_sockclosed(sototcpcb(so));
 213                         }
 214                         return -1;
 215                 }
 216         }
 217
 218 #ifndef HAVE_READV
 219         /*
 220          * If there was no error, try and read the second time round
 221          * We read again if n = 2 (ie, there's another part of the buffer)
 222          * and we read as much as we could in the first read
 223          * We don't test for <= 0 this time, because there legitimately
 224          * might not be any more data (since the socket is non-blocking),
 225          * a close will be detected on next iteration.
 226          * A return of -1 won't (shouldn't) happen, since it didn't happen above
 227          */
 228         if (n == 2 && nn == iov[0].iov_len) {
 229             int ret;
 230             ret = qemu_recv(so->s, iov[1].iov_base, iov[1].iov_len,0);
 231             if (ret > 0)
 232                 nn += ret;
 233         }
 234
 235         DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
 236 #endif
 237
 238         /* Update fields */
 239         sb->sb_cc += nn;
 240         sb->sb_wptr += nn;
 241         if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
 242                 sb->sb_wptr -= sb->sb_datalen;
 243         return nn;
 244 }
 245
 246 int soreadbuf(struct socket *so, const char *buf, int size)
 247 {
 248     int n, nn, copy = size;
 249         struct sbuf *sb = &so->so_snd;
 250         struct iovec iov[2];
 251
 252         DEBUG_CALL("soreadbuf");
 253         DEBUG_ARG("so = %p", so);
 254
 255         /*
 256          * No need to check if there's enough room to read.
 257          * soread wouldn't have been called if there weren't
 258          */
 259         if (sopreprbuf(so, iov, &n) < size)
 260         goto err;
 261
 262     nn = MIN(iov[0].iov_len, copy);
 263     memcpy(iov[0].iov_base, buf, nn);
 264
 265     copy -= nn;
 266     buf += nn;
 267
 268     if (copy == 0)
 269         goto done;
 270
 271     memcpy(iov[1].iov_base, buf, copy);
 272
 273 done:
 274     /* Update fields */
 275         sb->sb_cc += size;
 276         sb->sb_wptr += size;
 277         if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
 278                 sb->sb_wptr -= sb->sb_datalen;
 279     return size;
 280 err:
 281
 282     sofcantrcvmore(so);
 283     tcp_sockclosed(sototcpcb(so));
 284     fprintf(stderr, "soreadbuf buffer to small");
 285     return -1;
 286 }
 287
 288 /*
 289  * Get urgent data
 290  *
 291  * When the socket is created, we set it SO_OOBINLINE,
 292  * so when OOB data arrives, we soread() it and everything
 293  * in the send buffer is sent as urgent data
 294  */
 295 int
 296 sorecvoob(struct socket *so)
 297 {
 298         struct tcpcb *tp = sototcpcb(so);
 299         int ret;
 300
 301         DEBUG_CALL("sorecvoob");
 302         DEBUG_ARG("so = %p", so);
 303
 304         /*
 305          * We take a guess at how much urgent data has arrived.
 306          * In most situations, when urgent data arrives, the next
 307          * read() should get all the urgent data.  This guess will
 308          * be wrong however if more data arrives just after the
 309          * urgent data, or the read() doesn't return all the
 310          * urgent data.
 311          */
 312         ret = soread(so);
 313         if (ret > 0) {
 314             tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
 315             tp->t_force = 1;
 316             tcp_output(tp);
 317             tp->t_force = 0;
 318         }
 319
 320         return ret;
 321 }
 322
 323 /*
 324  * Send urgent data
 325  * There's a lot duplicated code here, but...
 326  */
 327 int
 328 sosendoob(struct socket *so)
 329 {
 330         struct sbuf *sb = &so->so_rcv;
 331         char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
 332
 333         int n, len;
 334
 335         DEBUG_CALL("sosendoob");
 336         DEBUG_ARG("so = %p", so);
 337         DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc);
 338
 339         if (so->so_urgc > 2048)
 340            so->so_urgc = 2048; /* XXXX */
 341
 342         if (sb->sb_rptr < sb->sb_wptr) {
 343                 /* We can send it directly */
 344                 n = slirp_send(so, sb->sb_rptr, so->so_urgc, (MSG_OOB)); /* |MSG_DONTWAIT)); */
 345                 so->so_urgc -= n;
 346
 347                 DEBUG_MISC((dfd, " --- sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
 348         } else {
 349                 /*
 350                  * Since there's no sendv or sendtov like writev,
 351                  * we must copy all data to a linear buffer then
 352                  * send it all
 353                  */
 354                 len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
 355                 if (len > so->so_urgc) len = so->so_urgc;
 356                 memcpy(buff, sb->sb_rptr, len);
 357                 so->so_urgc -= len;
 358                 if (so->so_urgc) {
 359                         n = sb->sb_wptr - sb->sb_data;
 360                         if (n > so->so_urgc) n = so->so_urgc;
 361                         memcpy((buff + len), sb->sb_data, n);
 362                         so->so_urgc -= n;
 363                         len += n;
 364                 }
 365                 n = slirp_send(so, buff, len, (MSG_OOB)); /* |MSG_DONTWAIT)); */
 366 #ifdef DEBUG
 367                 if (n != len)
 368                    DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n"));
 369 #endif
 370                 DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
 371         }
 372
 373         sb->sb_cc -= n;
 374         sb->sb_rptr += n;
 375         if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
 376                 sb->sb_rptr -= sb->sb_datalen;
 377
 378         return n;
 379 }
 380
 381 /*
 382  * Write data from so_rcv to so's socket,
 383  * updating all sbuf field as necessary
 384  */
 385 int
 386 sowrite(struct socket *so)
 387 {
 388         int  n,nn;
 389         struct sbuf *sb = &so->so_rcv;
 390         int len = sb->sb_cc;
 391         struct iovec iov[2];
 392
 393         DEBUG_CALL("sowrite");
 394         DEBUG_ARG("so = %p", so);
 395
 396         if (so->so_urgc) {
 397                 sosendoob(so);
 398                 if (sb->sb_cc == 0)
 399                         return 0;
 400         }
 401
 402         /*
 403          * No need to check if there's something to write,
 404          * sowrite wouldn't have been called otherwise
 405          */
 406
 407         iov[0].iov_base = sb->sb_rptr;
 408         iov[1].iov_base = NULL;
 409         iov[1].iov_len = 0;
 410         if (sb->sb_rptr < sb->sb_wptr) {
 411                 iov[0].iov_len = sb->sb_wptr - sb->sb_rptr;
 412                 /* Should never succeed, but... */
 413                 if (iov[0].iov_len > len) iov[0].iov_len = len;
 414                 n = 1;
 415         } else {
 416                 iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
 417                 if (iov[0].iov_len > len) iov[0].iov_len = len;
 418                 len -= iov[0].iov_len;
 419                 if (len) {
 420                         iov[1].iov_base = sb->sb_data;
 421                         iov[1].iov_len = sb->sb_wptr - sb->sb_data;
 422                         if (iov[1].iov_len > len) iov[1].iov_len = len;
 423                         n = 2;
 424                 } else
 425                         n = 1;
 426         }
 427         /* Check if there's urgent data to send, and if so, send it */
 428
 429 #ifdef HAVE_READV
 430         nn = writev(so->s, (const struct iovec *)iov, n);
 431
 432         DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
 433 #else
 434         nn = slirp_send(so, iov[0].iov_base, iov[0].iov_len,0);
 435 #endif
 436         /* This should never happen, but people tell me it does *shrug* */
 437         if (nn < 0 && (errno == EAGAIN || errno == EINTR))
 438                 return 0;
 439
 440         if (nn <= 0) {
 441                 DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
 442                         so->so_state, errno));
 443                 sofcantsendmore(so);
 444                 tcp_sockclosed(sototcpcb(so));
 445                 return -1;
 446         }
 447
 448 #ifndef HAVE_READV
 449         if (n == 2 && nn == iov[0].iov_len) {
 450             int ret;
 451             ret = slirp_send(so, iov[1].iov_base, iov[1].iov_len,0);
 452             if (ret > 0)
 453                 nn += ret;
 454         }
 455         DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
 456 #endif
 457
 458         /* Update sbuf */
 459         sb->sb_cc -= nn;
 460         sb->sb_rptr += nn;
 461         if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
 462                 sb->sb_rptr -= sb->sb_datalen;
 463
 464         /*
 465          * If in DRAIN mode, and there's no more data, set
 466          * it CANTSENDMORE
 467          */
 468         if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0)
 469                 sofcantsendmore(so);
 470
 471         return nn;
 472 }
 473
 474 /*
 475  * recvfrom() a UDP socket
 476  */
 477 void
 478 sorecvfrom(struct socket *so)
 479 {
 480         struct sockaddr_storage addr;
 481         struct sockaddr_storage saddr, daddr;
 482         socklen_t addrlen = sizeof(struct sockaddr_storage);
 483
 484         DEBUG_CALL("sorecvfrom");
 485         DEBUG_ARG("so = %p", so);
 486
 487         if (so->so_type == IPPROTO_ICMP) {   /* This is a "ping" reply */
 488           char buff[256];
 489           int len;
 490
 491           len = recvfrom(so->s, buff, 256, 0,
 492                          (struct sockaddr *)&addr, &addrlen);
 493           /* XXX Check if reply is "correct"? */
 494
 495           if(len == -1 || len == 0) {
 496             u_char code=ICMP_UNREACH_PORT;
 497
 498             if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
 499             else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
 500
 501             DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
 502                         errno,strerror(errno)));
 503             icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno));
 504           } else {
 505             icmp_reflect(so->so_m);
 506             so->so_m = NULL; /* Don't m_free() it again! */
 507           }
 508           /* No need for this socket anymore, udp_detach it */
 509           udp_detach(so);
 510         } else {                                /* A "normal" UDP packet */
 511           struct mbuf *m;
 512           int len;
 513 #ifdef _WIN32
 514           unsigned long n;
 515 #else
 516           int n;
 517 #endif
 518
 519           m = m_get(so->slirp);
 520           if (!m) {
 521               return;
 522           }
 523           switch (so->so_ffamily) {
 524           case AF_INET:
 525               m->m_data += IF_MAXLINKHDR + sizeof(struct udpiphdr);
 526               break;
 527           case AF_INET6:
 528               m->m_data += IF_MAXLINKHDR + sizeof(struct ip6)
 529                                          + sizeof(struct udphdr);
 530               break;
 531           default:
 532               g_assert_not_reached();
 533               break;
 534           }
 535
 536           /*
 537            * XXX Shouldn't FIONREAD packets destined for port 53,
 538            * but I don't know the max packet size for DNS lookups
 539            */
 540           len = M_FREEROOM(m);
 541           /* if (so->so_fport != htons(53)) { */
 542           ioctlsocket(so->s, FIONREAD, &n);
 543
 544           if (n > len) {
 545             n = (m->m_data - m->m_dat) + m->m_len + n + 1;
 546             m_inc(m, n);
 547             len = M_FREEROOM(m);
 548           }
 549           /* } */
 550
 551           m->m_len = recvfrom(so->s, m->m_data, len, 0,
 552                               (struct sockaddr *)&addr, &addrlen);
 553           DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n",
 554                       m->m_len, errno,strerror(errno)));
 555           if(m->m_len<0) {
 556             /* Report error as ICMP */
 557             switch (so->so_lfamily) {
 558             uint8_t code;
 559             case AF_INET:
 560               code = ICMP_UNREACH_PORT;
 561
 562               if (errno == EHOSTUNREACH) {
 563                 code = ICMP_UNREACH_HOST;
 564               } else if (errno == ENETUNREACH) {
 565                 code = ICMP_UNREACH_NET;
 566               }
 567
 568               DEBUG_MISC((dfd, " rx error, tx icmp ICMP_UNREACH:%i\n", code));
 569               icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno));
 570               break;
 571             case AF_INET6:
 572               code = ICMP6_UNREACH_PORT;
 573
 574               if (errno == EHOSTUNREACH) {
 575                 code = ICMP6_UNREACH_ADDRESS;
 576               } else if (errno == ENETUNREACH) {
 577                 code = ICMP6_UNREACH_NO_ROUTE;
 578               }
 579
 580               DEBUG_MISC((dfd, " rx error, tx icmp6 ICMP_UNREACH:%i\n", code));
 581               icmp6_send_error(so->so_m, ICMP6_UNREACH, code);
 582               break;
 583             default:
 584               g_assert_not_reached();
 585               break;
 586             }
 587             m_free(m);
 588           } else {
 589           /*
 590            * Hack: domain name lookup will be used the most for UDP,
 591            * and since they'll only be used once there's no need
 592            * for the 4 minute (or whatever) timeout... So we time them
 593            * out much quicker (10 seconds  for now...)
 594            */
 595             if (so->so_expire) {
 596               if (so->so_fport == htons(53))
 597                 so->so_expire = curtime + SO_EXPIREFAST;
 598               else
 599                 so->so_expire = curtime + SO_EXPIRE;
 600             }
 601
 602             /*
 603              * If this packet was destined for CTL_ADDR,
 604              * make it look like that's where it came from
 605              */
 606             saddr = addr;
 607             sotranslate_in(so, &saddr);
 608             daddr = so->lhost.ss;
 609
 610             switch (so->so_ffamily) {
 611             case AF_INET:
 612                 udp_output(so, m, (struct sockaddr_in *) &saddr,
 613                            (struct sockaddr_in *) &daddr,
 614                            so->so_iptos);
 615                 break;
 616             case AF_INET6:
 617                 udp6_output(so, m, (struct sockaddr_in6 *) &saddr,
 618                             (struct sockaddr_in6 *) &daddr);
 619                 break;
 620             default:
 621                 g_assert_not_reached();
 622                 break;
 623             }
 624           } /* rx error */
 625         } /* if ping packet */
 626 }
 627
 628 /*
 629  * sendto() a socket
 630  */
 631 int
 632 sosendto(struct socket *so, struct mbuf *m)
 633 {
 634         int ret;
 635         struct sockaddr_storage addr;
 636
 637         DEBUG_CALL("sosendto");
 638         DEBUG_ARG("so = %p", so);
 639         DEBUG_ARG("m = %p", m);
 640
 641         addr = so->fhost.ss;
 642         DEBUG_CALL(" sendto()ing)");
 643         sotranslate_out(so, &addr);
 644
 645         /* Don't care what port we get */
 646         ret = sendto(so->s, m->m_data, m->m_len, 0,
 647                      (struct sockaddr *)&addr, sockaddr_size(&addr));
 648         if (ret < 0)
 649                 return -1;
 650
 651         /*
 652          * Kill the socket if there's no reply in 4 minutes,
 653          * but only if it's an expirable socket
 654          */
 655         if (so->so_expire)
 656                 so->so_expire = curtime + SO_EXPIRE;
 657         so->so_state &= SS_PERSISTENT_MASK;
 658         so->so_state |= SS_ISFCONNECTED; /* So that it gets select()ed */
 659         return 0;
 660 }
 661
 662 /*
 663  * Listen for incoming TCP connections
 664  */
 665 struct socket *
 666 tcp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
 667            u_int lport, int flags)
 668 {
 669         struct sockaddr_in addr;
 670         struct socket *so;
 671         int s, opt = 1;
 672         socklen_t addrlen = sizeof(addr);
 673         memset(&addr, 0, addrlen);
 674
 675         DEBUG_CALL("tcp_listen");
 676         DEBUG_ARG("haddr = %x", haddr);
 677         DEBUG_ARG("hport = %d", hport);
 678         DEBUG_ARG("laddr = %x", laddr);
 679         DEBUG_ARG("lport = %d", lport);
 680         DEBUG_ARG("flags = %x", flags);
 681
 682         so = socreate(slirp);
 683         if (!so) {
 684           return NULL;
 685         }
 686
 687         /* Don't tcp_attach... we don't need so_snd nor so_rcv */
 688         if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {
 689                 free(so);
 690                 return NULL;
 691         }
 692         insque(so, &slirp->tcb);
 693
 694         /*
 695          * SS_FACCEPTONCE sockets must time out.
 696          */
 697         if (flags & SS_FACCEPTONCE)
 698            so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;
 699
 700         so->so_state &= SS_PERSISTENT_MASK;
 701         so->so_state |= (SS_FACCEPTCONN | flags);
 702         so->so_lfamily = AF_INET;
 703         so->so_lport = lport; /* Kept in network format */
 704         so->so_laddr.s_addr = laddr; /* Ditto */
 705
 706         addr.sin_family = AF_INET;
 707         addr.sin_addr.s_addr = haddr;
 708         addr.sin_port = hport;
 709
 710         if (((s = qemu_socket(AF_INET,SOCK_STREAM,0)) < 0) ||
 711             (socket_set_fast_reuse(s) < 0) ||
 712             (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||
 713             (listen(s,1) < 0)) {
 714                 int tmperrno = errno; /* Don't clobber the real reason we failed */
 715
 716                 if (s >= 0) {
 717                     closesocket(s);
 718                 }
 719                 sofree(so);
 720                 /* Restore the real errno */
 721 #ifdef _WIN32
 722                 WSASetLastError(tmperrno);
 723 #else
 724                 errno = tmperrno;
 725 #endif
 726                 return NULL;
 727         }
 728         qemu_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(int));
 729
 730         getsockname(s,(struct sockaddr *)&addr,&addrlen);
 731         so->so_ffamily = AF_INET;
 732         so->so_fport = addr.sin_port;
 733         if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)
 734            so->so_faddr = slirp->vhost_addr;
 735         else
 736            so->so_faddr = addr.sin_addr;
 737
 738         so->s = s;
 739         return so;
 740 }
 741
 742 /*
 743  * Various session state calls
 744  * XXX Should be #define's
 745  * The socket state stuff needs work, these often get call 2 or 3
 746  * times each when only 1 was needed
 747  */
 748 void
 749 soisfconnecting(struct socket *so)
 750 {
 751         so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
 752                           SS_FCANTSENDMORE|SS_FWDRAIN);
 753         so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
 754 }
 755
 756 void
 757 soisfconnected(struct socket *so)
 758 {
 759         so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
 760         so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
 761 }
 762
 763 static void
 764 sofcantrcvmore(struct socket *so)
 765 {
 766         if ((so->so_state & SS_NOFDREF) == 0) {
 767                 shutdown(so->s,0);
 768         }
 769         so->so_state &= ~(SS_ISFCONNECTING);
 770         if (so->so_state & SS_FCANTSENDMORE) {
 771            so->so_state &= SS_PERSISTENT_MASK;
 772            so->so_state |= SS_NOFDREF; /* Don't select it */
 773         } else {
 774            so->so_state |= SS_FCANTRCVMORE;
 775         }
 776 }
 777
 778 static void
 779 sofcantsendmore(struct socket *so)
 780 {
 781         if ((so->so_state & SS_NOFDREF) == 0) {
 782             shutdown(so->s,1);           /* send FIN to fhost */
 783         }
 784         so->so_state &= ~(SS_ISFCONNECTING);
 785         if (so->so_state & SS_FCANTRCVMORE) {
 786            so->so_state &= SS_PERSISTENT_MASK;
 787            so->so_state |= SS_NOFDREF; /* as above */
 788         } else {
 789            so->so_state |= SS_FCANTSENDMORE;
 790         }
 791 }
 792
 793 /*
 794  * Set write drain mode
 795  * Set CANTSENDMORE once all data has been write()n
 796  */
 797 void
 798 sofwdrain(struct socket *so)
 799 {
 800         if (so->so_rcv.sb_cc)
 801                 so->so_state |= SS_FWDRAIN;
 802         else
 803                 sofcantsendmore(so);
 804 }
 805
 806 /*
 807  * Translate addr in host addr when it is a virtual address
 808  */
 809 void sotranslate_out(struct socket *so, struct sockaddr_storage *addr)
 810 {
 811     Slirp *slirp = so->slirp;
 812     struct sockaddr_in *sin = (struct sockaddr_in *)addr;
 813     struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
 814
 815     switch (addr->ss_family) {
 816     case AF_INET:
 817         if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
 818                 slirp->vnetwork_addr.s_addr) {
 819             /* It's an alias */
 820             if (so->so_faddr.s_addr == slirp->vnameserver_addr.s_addr) {
 821                 if (get_dns_addr(&sin->sin_addr) < 0) {
 822                     sin->sin_addr = loopback_addr;
 823                 }
 824             } else {
 825                 sin->sin_addr = loopback_addr;
 826             }
 827         }
 828
 829         DEBUG_MISC((dfd, " addr.sin_port=%d, "
 830             "addr.sin_addr.s_addr=%.16s\n",
 831             ntohs(sin->sin_port), inet_ntoa(sin->sin_addr)));
 832         break;
 833
 834     case AF_INET6:
 835         if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6,
 836                     slirp->vprefix_len)) {
 837             if (in6_equal(&so->so_faddr6, &slirp->vnameserver_addr6)) {
 838                 uint32_t scope_id;
 839                 if (get_dns6_addr(&sin6->sin6_addr, &scope_id) >= 0) {
 840                     sin6->sin6_scope_id = scope_id;
 841                 } else {
 842                     sin6->sin6_addr = in6addr_loopback;
 843                 }
 844             } else {
 845                 sin6->sin6_addr = in6addr_loopback;
 846             }
 847         }
 848         break;
 849
 850     default:
 851         break;
 852     }
 853 }
 854
 855 void sotranslate_in(struct socket *so, struct sockaddr_storage *addr)
 856 {
 857     Slirp *slirp = so->slirp;
 858     struct sockaddr_in *sin = (struct sockaddr_in *)addr;
 859     struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
 860
 861     switch (addr->ss_family) {
 862     case AF_INET:
 863         if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
 864             slirp->vnetwork_addr.s_addr) {
 865             uint32_t inv_mask = ~slirp->vnetwork_mask.s_addr;
 866
 867             if ((so->so_faddr.s_addr & inv_mask) == inv_mask) {
 868                 sin->sin_addr = slirp->vhost_addr;
 869             } else if (sin->sin_addr.s_addr == loopback_addr.s_addr ||
 870                        so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
 871                 sin->sin_addr = so->so_faddr;
 872             }
 873         }
 874         break;
 875
 876     case AF_INET6:
 877         if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6,
 878                     slirp->vprefix_len)) {
 879             if (in6_equal(&sin6->sin6_addr, &in6addr_loopback)
 880                     || !in6_equal(&so->so_faddr6, &slirp->vhost_addr6)) {
 881                 sin6->sin6_addr = so->so_faddr6;
 882             }
 883         }
 884         break;
 885
 886     default:
 887         break;
 888     }
 889 }
 890
 891 /*
 892  * Translate connections from localhost to the real hostname
 893  */
 894 void sotranslate_accept(struct socket *so)
 895 {
 896     Slirp *slirp = so->slirp;
 897
 898     switch (so->so_ffamily) {
 899     case AF_INET:
 900         if (so->so_faddr.s_addr == INADDR_ANY ||
 901             (so->so_faddr.s_addr & loopback_mask) ==
 902             (loopback_addr.s_addr & loopback_mask)) {
 903            so->so_faddr = slirp->vhost_addr;
 904         }
 905         break;
 906
 907    case AF_INET6:
 908         if (in6_equal(&so->so_faddr6, &in6addr_any) ||
 909                 in6_equal(&so->so_faddr6, &in6addr_loopback)) {
 910            so->so_faddr6 = slirp->vhost_addr6;
 911         }
 912         break;
 913
 914     default:
 915         break;
 916     }
 917 }