![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to slirp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / slirp|
Return to slirp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / slirp |
1.1 ! root 1: #include "slirp.h" ! 2: ! 3: /* host address */ ! 4: struct in_addr our_addr; ! 5: /* host dns address */ ! 6: struct in_addr dns_addr; ! 7: /* host loopback address */ ! 8: struct in_addr loopback_addr; ! 9: ! 10: /* address for slirp virtual addresses */ ! 11: struct in_addr special_addr; ! 12: ! 13: const uint8_t special_ethaddr[6] = { ! 14: 0x52, 0x54, 0x00, 0x12, 0x35, 0x00 ! 15: }; ! 16: ! 17: uint8_t client_ethaddr[6]; ! 18: ! 19: int do_slowtimo; ! 20: int link_up; ! 21: struct timeval tt; ! 22: FILE *lfd; ! 23: struct ex_list *exec_list; ! 24: ! 25: /* XXX: suppress those select globals */ ! 26: fd_set *global_readfds, *global_writefds, *global_xfds; ! 27: ! 28: #ifdef _WIN32 ! 29: ! 30: static int get_dns_addr(struct in_addr *pdns_addr) ! 31: { ! 32: FIXED_INFO *FixedInfo=NULL; ! 33: ULONG BufLen; ! 34: DWORD ret; ! 35: IP_ADDR_STRING *pIPAddr; ! 36: struct in_addr tmp_addr; ! 37: ! 38: FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO)); ! 39: BufLen = sizeof(FIXED_INFO); ! 40: ! 41: if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) { ! 42: if (FixedInfo) { ! 43: GlobalFree(FixedInfo); ! 44: FixedInfo = NULL; ! 45: } ! 46: FixedInfo = GlobalAlloc(GPTR, BufLen); ! 47: } ! 48: ! 49: if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) { ! 50: printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret ); ! 51: if (FixedInfo) { ! 52: GlobalFree(FixedInfo); ! 53: FixedInfo = NULL; ! 54: } ! 55: return -1; ! 56: } ! 57: ! 58: pIPAddr = &(FixedInfo->DnsServerList); ! 59: inet_aton(pIPAddr->IpAddress.String, &tmp_addr); ! 60: *pdns_addr = tmp_addr; ! 61: #if 0 ! 62: printf( "DNS Servers:\n" ); ! 63: printf( "DNS Addr:%s\n", pIPAddr->IpAddress.String ); ! 64: ! 65: pIPAddr = FixedInfo -> DnsServerList.Next; ! 66: while ( pIPAddr ) { ! 67: printf( "DNS Addr:%s\n", pIPAddr ->IpAddress.String ); ! 68: pIPAddr = pIPAddr ->Next; ! 69: } ! 70: #endif ! 71: if (FixedInfo) { ! 72: GlobalFree(FixedInfo); ! 73: FixedInfo = NULL; ! 74: } ! 75: return 0; ! 76: } ! 77: ! 78: #else ! 79: ! 80: static int get_dns_addr(struct in_addr *pdns_addr) ! 81: { ! 82: char buff[512]; ! 83: char buff2[256]; ! 84: FILE *f; ! 85: int found = 0; ! 86: struct in_addr tmp_addr; ! 87: ! 88: f = fopen("/etc/resolv.conf", "r"); ! 89: if (!f) ! 90: return -1; ! 91: ! 92: lprint("IP address of your DNS(s): "); ! 93: while (fgets(buff, 512, f) != NULL) { ! 94: if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) { ! 95: if (!inet_aton(buff2, &tmp_addr)) ! 96: continue; ! 97: if (tmp_addr.s_addr == loopback_addr.s_addr) ! 98: tmp_addr = our_addr; ! 99: /* If it's the first one, set it to dns_addr */ ! 100: if (!found) ! 101: *pdns_addr = tmp_addr; ! 102: else ! 103: lprint(", "); ! 104: if (++found > 3) { ! 105: lprint("(more)"); ! 106: break; ! 107: } else ! 108: lprint("%s", inet_ntoa(tmp_addr)); ! 109: } ! 110: } ! 111: fclose(f); ! 112: if (!found) ! 113: return -1; ! 114: return 0; ! 115: } ! 116: ! 117: #endif ! 118: ! 119: #ifdef _WIN32 ! 120: void slirp_cleanup(void) ! 121: { ! 122: WSACleanup(); ! 123: } ! 124: #endif ! 125: ! 126: void slirp_init(void) ! 127: { ! 128: // debug_init("/tmp/slirp.log", DEBUG_DEFAULT); ! 129: ! 130: #ifdef _WIN32 ! 131: { ! 132: WSADATA Data; ! 133: WSAStartup(MAKEWORD(2,0), &Data); ! 134: atexit(slirp_cleanup); ! 135: } ! 136: #endif ! 137: ! 138: link_up = 1; ! 139: ! 140: if_init(); ! 141: ip_init(); ! 142: ! 143: /* Initialise mbufs *after* setting the MTU */ ! 144: m_init(); ! 145: ! 146: /* set default addresses */ ! 147: getouraddr(); ! 148: inet_aton("127.0.0.1", &loopback_addr); ! 149: ! 150: if (get_dns_addr(&dns_addr) < 0) { ! 151: fprintf(stderr, "Could not get DNS address\n"); ! 152: exit(1); ! 153: } ! 154: ! 155: inet_aton(CTL_SPECIAL, &special_addr); ! 156: } ! 157: ! 158: #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED) ! 159: #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED) ! 160: #define UPD_NFDS(x) if (nfds < (x)) nfds = (x) ! 161: ! 162: /* ! 163: * curtime kept to an accuracy of 1ms ! 164: */ ! 165: #ifdef _WIN32 ! 166: static void updtime(void) ! 167: { ! 168: struct _timeb tb; ! 169: ! 170: _ftime(&tb); ! 171: curtime = (u_int)tb.time * (u_int)1000; ! 172: curtime += (u_int)tb.millitm; ! 173: } ! 174: #else ! 175: static void updtime(void) ! 176: { ! 177: gettimeofday(&tt, 0); ! 178: ! 179: curtime = (u_int)tt.tv_sec * (u_int)1000; ! 180: curtime += (u_int)tt.tv_usec / (u_int)1000; ! 181: ! 182: if ((tt.tv_usec % 1000) >= 500) ! 183: curtime++; ! 184: } ! 185: #endif ! 186: ! 187: void slirp_select_fill(int *pnfds, ! 188: fd_set *readfds, fd_set *writefds, fd_set *xfds) ! 189: { ! 190: struct socket *so, *so_next; ! 191: struct timeval timeout; ! 192: int nfds; ! 193: int tmp_time; ! 194: ! 195: /* fail safe */ ! 196: global_readfds = NULL; ! 197: global_writefds = NULL; ! 198: global_xfds = NULL; ! 199: ! 200: nfds = *pnfds; ! 201: /* ! 202: * First, TCP sockets ! 203: */ ! 204: do_slowtimo = 0; ! 205: if (link_up) { ! 206: /* ! 207: * *_slowtimo needs calling if there are IP fragments ! 208: * in the fragment queue, or there are TCP connections active ! 209: */ ! 210: do_slowtimo = ((tcb.so_next != &tcb) || ! 211: ((struct ipasfrag *)&ipq != (struct ipasfrag *)ipq.next)); ! 212: ! 213: for (so = tcb.so_next; so != &tcb; so = so_next) { ! 214: so_next = so->so_next; ! 215: ! 216: /* ! 217: * See if we need a tcp_fasttimo ! 218: */ ! 219: if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK) ! 220: time_fasttimo = curtime; /* Flag when we want a fasttimo */ ! 221: ! 222: /* ! 223: * NOFDREF can include still connecting to local-host, ! 224: * newly socreated() sockets etc. Don't want to select these. ! 225: */ ! 226: if (so->so_state & SS_NOFDREF || so->s == -1) ! 227: continue; ! 228: ! 229: /* ! 230: * Set for reading sockets which are accepting ! 231: */ ! 232: if (so->so_state & SS_FACCEPTCONN) { ! 233: FD_SET(so->s, readfds); ! 234: UPD_NFDS(so->s); ! 235: continue; ! 236: } ! 237: ! 238: /* ! 239: * Set for writing sockets which are connecting ! 240: */ ! 241: if (so->so_state & SS_ISFCONNECTING) { ! 242: FD_SET(so->s, writefds); ! 243: UPD_NFDS(so->s); ! 244: continue; ! 245: } ! 246: ! 247: /* ! 248: * Set for writing if we are connected, can send more, and ! 249: * we have something to send ! 250: */ ! 251: if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) { ! 252: FD_SET(so->s, writefds); ! 253: UPD_NFDS(so->s); ! 254: } ! 255: ! 256: /* ! 257: * Set for reading (and urgent data) if we are connected, can ! 258: * receive more, and we have room for it XXX /2 ? ! 259: */ ! 260: if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) { ! 261: FD_SET(so->s, readfds); ! 262: FD_SET(so->s, xfds); ! 263: UPD_NFDS(so->s); ! 264: } ! 265: } ! 266: ! 267: /* ! 268: * UDP sockets ! 269: */ ! 270: for (so = udb.so_next; so != &udb; so = so_next) { ! 271: so_next = so->so_next; ! 272: ! 273: /* ! 274: * See if it's timed out ! 275: */ ! 276: if (so->so_expire) { ! 277: if (so->so_expire <= curtime) { ! 278: udp_detach(so); ! 279: continue; ! 280: } else ! 281: do_slowtimo = 1; /* Let socket expire */ ! 282: } ! 283: ! 284: /* ! 285: * When UDP packets are received from over the ! 286: * link, they're sendto()'d straight away, so ! 287: * no need for setting for writing ! 288: * Limit the number of packets queued by this session ! 289: * to 4. Note that even though we try and limit this ! 290: * to 4 packets, the session could have more queued ! 291: * if the packets needed to be fragmented ! 292: * (XXX <= 4 ?) ! 293: */ ! 294: if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) { ! 295: FD_SET(so->s, readfds); ! 296: UPD_NFDS(so->s); ! 297: } ! 298: } ! 299: } ! 300: ! 301: /* ! 302: * Setup timeout to use minimum CPU usage, especially when idle ! 303: */ ! 304: ! 305: /* ! 306: * First, see the timeout needed by *timo ! 307: */ ! 308: timeout.tv_sec = 0; ! 309: timeout.tv_usec = -1; ! 310: /* ! 311: * If a slowtimo is needed, set timeout to 500ms from the last ! 312: * slow timeout. If a fast timeout is needed, set timeout within ! 313: * 200ms of when it was requested. ! 314: */ ! 315: if (do_slowtimo) { ! 316: /* XXX + 10000 because some select()'s aren't that accurate */ ! 317: timeout.tv_usec = ((500 - (curtime - last_slowtimo)) * 1000) + 10000; ! 318: if (timeout.tv_usec < 0) ! 319: timeout.tv_usec = 0; ! 320: else if (timeout.tv_usec > 510000) ! 321: timeout.tv_usec = 510000; ! 322: ! 323: /* Can only fasttimo if we also slowtimo */ ! 324: if (time_fasttimo) { ! 325: tmp_time = (200 - (curtime - time_fasttimo)) * 1000; ! 326: if (tmp_time < 0) ! 327: tmp_time = 0; ! 328: ! 329: /* Choose the smallest of the 2 */ ! 330: if (tmp_time < timeout.tv_usec) ! 331: timeout.tv_usec = (u_int)tmp_time; ! 332: } ! 333: } ! 334: *pnfds = nfds; ! 335: } ! 336: ! 337: void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds) ! 338: { ! 339: struct socket *so, *so_next; ! 340: int ret; ! 341: ! 342: global_readfds = readfds; ! 343: global_writefds = writefds; ! 344: global_xfds = xfds; ! 345: ! 346: /* Update time */ ! 347: updtime(); ! 348: ! 349: /* ! 350: * See if anything has timed out ! 351: */ ! 352: if (link_up) { ! 353: if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) { ! 354: tcp_fasttimo(); ! 355: time_fasttimo = 0; ! 356: } ! 357: if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) { ! 358: ip_slowtimo(); ! 359: tcp_slowtimo(); ! 360: last_slowtimo = curtime; ! 361: } ! 362: } ! 363: ! 364: /* ! 365: * Check sockets ! 366: */ ! 367: if (link_up) { ! 368: /* ! 369: * Check TCP sockets ! 370: */ ! 371: for (so = tcb.so_next; so != &tcb; so = so_next) { ! 372: so_next = so->so_next; ! 373: ! 374: /* ! 375: * FD_ISSET is meaningless on these sockets ! 376: * (and they can crash the program) ! 377: */ ! 378: if (so->so_state & SS_NOFDREF || so->s == -1) ! 379: continue; ! 380: ! 381: /* ! 382: * Check for URG data ! 383: * This will soread as well, so no need to ! 384: * test for readfds below if this succeeds ! 385: */ ! 386: if (FD_ISSET(so->s, xfds)) ! 387: sorecvoob(so); ! 388: /* ! 389: * Check sockets for reading ! 390: */ ! 391: else if (FD_ISSET(so->s, readfds)) { ! 392: /* ! 393: * Check for incoming connections ! 394: */ ! 395: if (so->so_state & SS_FACCEPTCONN) { ! 396: tcp_connect(so); ! 397: continue; ! 398: } /* else */ ! 399: ret = soread(so); ! 400: ! 401: /* Output it if we read something */ ! 402: if (ret > 0) ! 403: tcp_output(sototcpcb(so)); ! 404: } ! 405: ! 406: /* ! 407: * Check sockets for writing ! 408: */ ! 409: if (FD_ISSET(so->s, writefds)) { ! 410: /* ! 411: * Check for non-blocking, still-connecting sockets ! 412: */ ! 413: if (so->so_state & SS_ISFCONNECTING) { ! 414: /* Connected */ ! 415: so->so_state &= ~SS_ISFCONNECTING; ! 416: ! 417: ret = send(so->s, &ret, 0, 0); ! 418: if (ret < 0) { ! 419: /* XXXXX Must fix, zero bytes is a NOP */ ! 420: if (errno == EAGAIN || errno == EWOULDBLOCK || ! 421: errno == EINPROGRESS || errno == ENOTCONN) ! 422: continue; ! 423: ! 424: /* else failed */ ! 425: so->so_state = SS_NOFDREF; ! 426: } ! 427: /* else so->so_state &= ~SS_ISFCONNECTING; */ ! 428: ! 429: /* ! 430: * Continue tcp_input ! 431: */ ! 432: tcp_input((struct mbuf *)NULL, sizeof(struct ip), so); ! 433: /* continue; */ ! 434: } else ! 435: ret = sowrite(so); ! 436: /* ! 437: * XXXXX If we wrote something (a lot), there ! 438: * could be a need for a window update. ! 439: * In the worst case, the remote will send ! 440: * a window probe to get things going again ! 441: */ ! 442: } ! 443: ! 444: /* ! 445: * Probe a still-connecting, non-blocking socket ! 446: * to check if it's still alive ! 447: */ ! 448: #ifdef PROBE_CONN ! 449: if (so->so_state & SS_ISFCONNECTING) { ! 450: ret = recv(so->s, (char *)&ret, 0,0); ! 451: ! 452: if (ret < 0) { ! 453: /* XXX */ ! 454: if (errno == EAGAIN || errno == EWOULDBLOCK || ! 455: errno == EINPROGRESS || errno == ENOTCONN) ! 456: continue; /* Still connecting, continue */ ! 457: ! 458: /* else failed */ ! 459: so->so_state = SS_NOFDREF; ! 460: ! 461: /* tcp_input will take care of it */ ! 462: } else { ! 463: ret = send(so->s, &ret, 0,0); ! 464: if (ret < 0) { ! 465: /* XXX */ ! 466: if (errno == EAGAIN || errno == EWOULDBLOCK || ! 467: errno == EINPROGRESS || errno == ENOTCONN) ! 468: continue; ! 469: /* else failed */ ! 470: so->so_state = SS_NOFDREF; ! 471: } else ! 472: so->so_state &= ~SS_ISFCONNECTING; ! 473: ! 474: } ! 475: tcp_input((struct mbuf *)NULL, sizeof(struct ip),so); ! 476: } /* SS_ISFCONNECTING */ ! 477: #endif ! 478: } ! 479: ! 480: /* ! 481: * Now UDP sockets. ! 482: * Incoming packets are sent straight away, they're not buffered. ! 483: * Incoming UDP data isn't buffered either. ! 484: */ ! 485: for (so = udb.so_next; so != &udb; so = so_next) { ! 486: so_next = so->so_next; ! 487: ! 488: if (so->s != -1 && FD_ISSET(so->s, readfds)) { ! 489: sorecvfrom(so); ! 490: } ! 491: } ! 492: } ! 493: ! 494: /* ! 495: * See if we can start outputting ! 496: */ ! 497: if (if_queued && link_up) ! 498: if_start(); ! 499: ! 500: /* clear global file descriptor sets. ! 501: * these reside on the stack in vl.c ! 502: * so they're unusable if we're not in ! 503: * slirp_select_fill or slirp_select_poll. ! 504: */ ! 505: global_readfds = NULL; ! 506: global_writefds = NULL; ! 507: global_xfds = NULL; ! 508: } ! 509: ! 510: #define ETH_ALEN 6 ! 511: #define ETH_HLEN 14 ! 512: ! 513: #define ETH_P_IP 0x0800 /* Internet Protocol packet */ ! 514: #define ETH_P_ARP 0x0806 /* Address Resolution packet */ ! 515: ! 516: #define ARPOP_REQUEST 1 /* ARP request */ ! 517: #define ARPOP_REPLY 2 /* ARP reply */ ! 518: ! 519: struct ethhdr ! 520: { ! 521: unsigned char h_dest[ETH_ALEN]; /* destination eth addr */ ! 522: unsigned char h_source[ETH_ALEN]; /* source ether addr */ ! 523: unsigned short h_proto; /* packet type ID field */ ! 524: }; ! 525: ! 526: struct arphdr ! 527: { ! 528: unsigned short ar_hrd; /* format of hardware address */ ! 529: unsigned short ar_pro; /* format of protocol address */ ! 530: unsigned char ar_hln; /* length of hardware address */ ! 531: unsigned char ar_pln; /* length of protocol address */ ! 532: unsigned short ar_op; /* ARP opcode (command) */ ! 533: ! 534: /* ! 535: * Ethernet looks like this : This bit is variable sized however... ! 536: */ ! 537: unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */ ! 538: unsigned char ar_sip[4]; /* sender IP address */ ! 539: unsigned char ar_tha[ETH_ALEN]; /* target hardware address */ ! 540: unsigned char ar_tip[4]; /* target IP address */ ! 541: }; ! 542: ! 543: void arp_input(const uint8_t *pkt, int pkt_len) ! 544: { ! 545: struct ethhdr *eh = (struct ethhdr *)pkt; ! 546: struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN); ! 547: uint8_t arp_reply[ETH_HLEN + sizeof(struct arphdr)]; ! 548: struct ethhdr *reh = (struct ethhdr *)arp_reply; ! 549: struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN); ! 550: int ar_op; ! 551: struct ex_list *ex_ptr; ! 552: ! 553: ar_op = ntohs(ah->ar_op); ! 554: switch(ar_op) { ! 555: case ARPOP_REQUEST: ! 556: if (!memcmp(ah->ar_tip, &special_addr, 3)) { ! 557: if (ah->ar_tip[3] == CTL_DNS || ah->ar_tip[3] == CTL_ALIAS) ! 558: goto arp_ok; ! 559: for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) { ! 560: if (ex_ptr->ex_addr == ah->ar_tip[3]) ! 561: goto arp_ok; ! 562: } ! 563: return; ! 564: arp_ok: ! 565: /* XXX: make an ARP request to have the client address */ ! 566: memcpy(client_ethaddr, eh->h_source, ETH_ALEN); ! 567: ! 568: /* ARP request for alias/dns mac address */ ! 569: memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN); ! 570: memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 1); ! 571: reh->h_source[5] = ah->ar_tip[3]; ! 572: reh->h_proto = htons(ETH_P_ARP); ! 573: ! 574: rah->ar_hrd = htons(1); ! 575: rah->ar_pro = htons(ETH_P_IP); ! 576: rah->ar_hln = ETH_ALEN; ! 577: rah->ar_pln = 4; ! 578: rah->ar_op = htons(ARPOP_REPLY); ! 579: memcpy(rah->ar_sha, reh->h_source, ETH_ALEN); ! 580: memcpy(rah->ar_sip, ah->ar_tip, 4); ! 581: memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN); ! 582: memcpy(rah->ar_tip, ah->ar_sip, 4); ! 583: slirp_output(arp_reply, sizeof(arp_reply)); ! 584: } ! 585: break; ! 586: default: ! 587: break; ! 588: } ! 589: } ! 590: ! 591: void slirp_input(const uint8_t *pkt, int pkt_len) ! 592: { ! 593: struct mbuf *m; ! 594: int proto; ! 595: ! 596: if (pkt_len < ETH_HLEN) ! 597: return; ! 598: ! 599: proto = ntohs(*(uint16_t *)(pkt + 12)); ! 600: switch(proto) { ! 601: case ETH_P_ARP: ! 602: arp_input(pkt, pkt_len); ! 603: break; ! 604: case ETH_P_IP: ! 605: m = m_get(); ! 606: if (!m) ! 607: return; ! 608: m->m_len = pkt_len; ! 609: memcpy(m->m_data, pkt, pkt_len); ! 610: ! 611: m->m_data += ETH_HLEN; ! 612: m->m_len -= ETH_HLEN; ! 613: ! 614: ip_input(m); ! 615: break; ! 616: default: ! 617: break; ! 618: } ! 619: } ! 620: ! 621: /* output the IP packet to the ethernet device */ ! 622: void if_encap(const uint8_t *ip_data, int ip_data_len) ! 623: { ! 624: uint8_t buf[1600]; ! 625: struct ethhdr *eh = (struct ethhdr *)buf; ! 626: ! 627: if (ip_data_len + ETH_HLEN > sizeof(buf)) ! 628: return; ! 629: ! 630: memcpy(eh->h_dest, client_ethaddr, ETH_ALEN); ! 631: memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 1); ! 632: /* XXX: not correct */ ! 633: eh->h_source[5] = CTL_ALIAS; ! 634: eh->h_proto = htons(ETH_P_IP); ! 635: memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len); ! 636: slirp_output(buf, ip_data_len + ETH_HLEN); ! 637: } ! 638: ! 639: int slirp_redir(int is_udp, int host_port, ! 640: struct in_addr guest_addr, int guest_port) ! 641: { ! 642: if (is_udp) { ! 643: if (!udp_listen(htons(host_port), guest_addr.s_addr, ! 644: htons(guest_port), 0)) ! 645: return -1; ! 646: } else { ! 647: if (!solisten(htons(host_port), guest_addr.s_addr, ! 648: htons(guest_port), 0)) ! 649: return -1; ! 650: } ! 651: return 0; ! 652: } ! 653: ! 654: int slirp_add_exec(int do_pty, const char *args, int addr_low_byte, ! 655: int guest_port) ! 656: { ! 657: return add_exec(&exec_list, do_pty, (char *)args, ! 658: addr_low_byte, htons(guest_port)); ! 659: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.