VirtualBox

Ignore:
Timestamp:
Sep 11, 2014 9:37:27 PM (10 years ago)
Author:
vboxsync
Message:

NAT: G/c bogus VBOX && !NO_USE_SOCKETS code disabled in r93447.
Same object code is generated.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Network/slirp/libalias/alias_db.c

    r52711 r52712  
    2929__FBSDID("$FreeBSD: src/sys/netinet/libalias/alias_db.c,v 1.71.2.2.4.1 2009/04/15 03:14:26 kensmith Exp $");
    3030#endif
     31
    3132/*
    3233    Alias_db.c encapsulates all data structures used for storing
     
    338339
    339340#ifndef NO_USE_SOCKETS
    340 # ifndef VBOX
    341     /*
    342      * in VBox we do not use host's sockets here, which are managed
    343      * inside slirp. yes we have to create new sockets here but latter
    344      * managment and deletion are in repsponsible of Slirp.
    345      */
    346341    int     sockfd; /* socket descriptor                   */
    347 #  else
    348     struct socket *pSo;
    349 # endif
    350342#endif
    351343            LIST_ENTRY    (alias_link) list_out;    /* Linked list of
     
    572564static int  GetNewPort(struct libalias *, struct alias_link *, int);
    573565#ifndef NO_USE_SOCKETS
    574 # ifdef VBOX
    575 static u_short  GetSocket(struct libalias *, u_short, struct alias_link*, int);
    576 # else
    577566static u_short  GetSocket(struct libalias *, u_short, int *, int);
    578 # endif
    579567#endif
    580568static void CleanupAliasData(struct libalias *);
     
    691679                && ((lnk->link_type == LINK_TCP) ||
    692680                (lnk->link_type == LINK_UDP))) {
    693 #ifndef VBOX
    694681                if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
    695 #else
    696                 if (GetSocket(la, port_net, lnk, lnk->link_type)) {
    697 #endif
    698682                    lnk->alias_port = port_net;
    699683                    return (0);
     
    722706#ifndef NO_USE_SOCKETS
    723707static      u_short
    724 # ifndef VBOX
    725708GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
    726 # else
    727 GetSocket(struct libalias *la, u_short port_net, struct alias_link *pLnk, int link_type)
    728 # endif
    729709{
    730710    int err;
    731711    int sock;
    732712    struct sockaddr_in sock_addr;
    733 #ifdef VBOX
    734     int opt = 1;
    735     int status = 0;
    736     struct socket *so = NULL;
    737     struct sockaddr sa_addr;
    738     socklen_t socklen = sizeof(struct sockaddr);
    739 #endif
    740 
    741     LIBALIAS_LOCK_ASSERT(la);
    742 #ifdef VBOX
    743     so = socreate();
    744     if (so == NULL)
    745     {
    746         return 0;
    747     }
    748 #endif
     713
     714    LIBALIAS_LOCK_ASSERT(la);
    749715    if (link_type == LINK_TCP)
    750716        sock = socket(AF_INET, SOCK_STREAM, 0);
     
    756722        fprintf(stderr, "incorrect link type\n");
    757723#endif
    758 #ifdef VBOX
    759         RTMemFree(so);
    760 #endif
    761724        return (0);
    762725    }
     
    765728#ifdef LIBALIAS_DEBUG
    766729        fprintf(stderr, "PacketAlias/GetSocket(): ");
    767 # ifndef VBOX
    768730        fprintf(stderr, "socket() error %d\n", *sockfd);
    769 # else
    770         fprintf(stderr, "socket() error %d\n", errno);
    771 # endif
    772731#endif
    773732        return (0);
    774733    }
    775 #ifdef VBOX
    776     so->s = sock;
    777     fd_nonblock(so->s);
    778 #endif
     734
    779735    memset(&sock_addr, 0, sizeof(struct sockaddr_in));
    780736    sock_addr.sin_family = AF_INET;
    781737    sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    782 #if 0
    783     sock_addr.sin_port = htons(port_net);
    784 #endif
     738    sock_addr.sin_port = port_net;
    785739#ifdef RT_OS_DARWIN
    786740    sock_addr.sin_len = sizeof(struct sockaddr_in);
     
    793747    if (err == 0) {
    794748        la->sockCount++;
    795 #ifdef VBOX
    796         so->so_expire = la->curtime + SO_EXPIRE;
    797         setsockopt(so->s, SOL_SOCKET, SO_BROADCAST,
    798             (const char *)&opt, sizeof(opt));
    799         status = getsockname(so->s, &sa_addr, &socklen);
    800         if (status != 0 || sa_addr.sa_family != AF_INET)
    801         {
    802             closesocket(so->s);
    803             RTMemFree(so);
    804             return 0;
    805         }
    806         so->so_laddr.s_addr = la->aliasAddress.s_addr;
    807         so->so_lport = htons(port_net);
    808         so->so_faddr.s_addr = la->true_addr.s_addr;
    809         so->so_fport = la->true_port;
    810         so->so_hlport = ((struct sockaddr_in *)&sa_addr)->sin_port;
    811         so->so_hladdr.s_addr =
    812             ((struct sockaddr_in *)&sa_addr)->sin_addr.s_addr;
    813         NSOCK_INC_EX(la);
    814         if (link_type == LINK_TCP)
    815         {
    816             int ret = 0;
    817             struct sockaddr_in sin;
    818             RT_ZERO(sin);
    819             sin.sin_family = AF_INET;
    820             sin.sin_addr.s_addr = so->so_faddr.s_addr;
    821             sin.sin_port = so->so_fport;
    822             ret = connect(so->s, (struct sockaddr *)&sin, sizeof(sin));
    823             if (   ret < 0
    824                 && !soIgnorableErrorCode(errno))
    825             {
    826                 closesocket(so->s);
    827                 RTMemFree(so);
    828                 return 0;
    829             }
    830             so->so_state = SS_ISFCONNECTING; /* slirp happy??? */
    831             tcp_attach(la->pData, so);
    832             /* tcp_{snd,rcv}space -> pData->tcp_{snd,rcv}space */
    833             sbreserve(la->pData, &so->so_snd, la->tcp_sndspace);
    834             sbreserve(la->pData, &so->so_rcv, la->tcp_rcvspace);
    835         }
    836         else if (link_type == LINK_UDP)
    837         {
    838             so->so_type = IPPROTO_UDP;
    839             insque(la->pData, so, &la->udb);
    840         }
    841         else
    842         {
    843             /* socket wasn't added to queue */
    844             closesocket(so->s);
    845             RTMemFree(so);
    846             Assert(!"Shouldn't be here");
    847             return 0;
    848         }
    849         LogFunc(("bind called for socket: %R[natsock]\n", so));
    850         pLnk->pSo = so;
    851         so->so_pvLnk = pLnk;
    852 #else
    853749        *sockfd = sock;
    854 #endif
    855750        return (1);
    856751    } else {
    857 #ifdef VBOX
    858         if (sock >= 0)
    859             closesocket(sock);
    860         /* socket wasn't enqueued so we shouldn't use sofree */
    861         RTMemFree(so);
    862 #else
    863             close(sock);
    864 #endif
     752        closesocket(sock);
    865753        return (0);
    866754    }
     
    999887}
    1000888
    1001 #if defined(VBOX) && !defined(NO_USE_SOCKETS)
    1002 
    1003 /**
    1004  * when slirp delete the link we need inform libalias about it.
    1005  */
    1006 void slirpDeleteLinkSocket(void *pvLnk)
    1007 {
    1008     struct alias_link *lnk = (struct alias_link *)pvLnk;
    1009     if (   lnk
    1010         && lnk->pSo)
    1011     {
    1012         struct libalias *la = lnk->la;
    1013         la->sockCount--;
    1014         lnk->pSo->fShouldBeRemoved = 1;
    1015         lnk->pSo->so_pvLnk = NULL; /* forget me, please ! */
    1016         lnk->pSo = NULL;
    1017     }
    1018 }
    1019 #endif /* VBOX && !NO_USE_SOCKETS */
    1020 
    1021889static void
    1022890DeleteLink(struct alias_link *lnk)
    1023891{
    1024892    struct libalias *la = lnk->la;
    1025 #ifndef NO_USE_SOCKETS
    1026     LogFlowFunc(("ENTER: lnk->pSo:%R[natsock]\n", lnk->pSo));
    1027 #else
    1028893    LogFlowFuncEnter();
    1029 #endif
    1030894
    1031895    LIBALIAS_LOCK_ASSERT(la);
     
    1056920#ifndef NO_USE_SOCKETS
    1057921/* Close socket, if one has been allocated */
    1058 # ifndef VBOX
    1059922    if (lnk->sockfd != -1) {
    1060923        la->sockCount--;
    1061         close(lnk->sockfd);
    1062     }
    1063 # else /* VBOX */
    1064     if (lnk->pSo)
    1065     {
    1066         /* libalias's sockCount decremented in slirpDeleteLinkSocket,
    1067          * which called from sofree
    1068          */
    1069         /* la->sockCount--; */
    1070         /* should we be more smart, or it's enough to be
    1071          * narrow-minded and just do sofree here
    1072          */
    1073 #if 0
    1074         sofree(la->pData, lnk->pSo);
    1075 #else
    1076         slirpDeleteLinkSocket(lnk);
    1077 #endif
    1078     }
    1079 # endif
     924        closesocket(lnk->sockfd);
     925    }
    1080926#endif
    1081927/* Link-type dependent cleanup */
     
    1148994        lnk->link_type = link_type;
    1149995#ifndef NO_USE_SOCKETS
    1150 # ifndef VBOX
    1151996        lnk->sockfd = -1;
    1152 # else
    1153         lnk->pSo = NULL;
    1154 # endif
    1155997#endif
    1156998        lnk->flags = 0;
     
    29662808    ClearAllFWHoles(la);
    29672809    if (la->fireWallFD >= 0)
    2968 #ifdef VBOX /* this code is currently dead but anyway ... */
    29692810        closesocket(la->fireWallFD);
    2970 #else
    2971         close(la->fireWallFD);
    2972 #endif
    29732811    la->fireWallFD = -1;
    29742812    if (la->fireWallField)
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette