VirtualBox

Changeset 26404 in vbox


Ignore:
Timestamp:
Feb 10, 2010 10:32:37 AM (15 years ago)
Author:
vboxsync
Message:

NAT: applied patch from xtracker 3993 (use BSD mbufs)

Location:
trunk/src/VBox/Devices
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Makefile.kmk

    r26222 r26404  
    826826        Network/slirp/udp.c \
    827827        Network/slirp/dnsproxy/hash.c \
     828        Network/slirp/tftp.c \
    828829        Network/slirp/dnsproxy/dnsproxy.c
    829830
    … …  
    837838else
    838839# some notes dnsproxy will probably deprecate
    839 # tftp.c is temporally out of global slirp section
    840840 VBOX_SLIRP_SOURCES += \
    841841        Network/slirp/mbuf.c \
    842         Network/slirp/cksum.c \
    843         Network/slirp/tftp.c
     842        Network/slirp/cksum.c
    844843endif
    845844

  • trunk/src/VBox/Devices/Network/DrvNAT.cpp

    r26309 r26404  
    310310
    311311    slirp_ext_m_free(pThis->pNATState, pvArg);
     312#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     313    RTMemFree(pu8Buf);
     314#endif
    312315    if (ASMAtomicDecU32(&pThis->cUrgPkt) == 0)
    313316    {
    … …  
    351354    rc = RTCritSectLeave(&pThis->csDevAccess);
    352355    AssertRC(rc);
     356
    353357done_unlocked:
    354358    slirp_ext_m_free(pThis->pNATState, pvArg);
     359#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     360    RTMemFree(pu8Buf);
     361#endif
    355362    ASMAtomicDecU32(&pThis->cPkt);
    356363
    … …  
    369376    Assert(pThis->enmLinkState == PDMNETWORKLINKSTATE_UP);
    370377    if (pThis->enmLinkState == PDMNETWORKLINKSTATE_UP)
    371         slirp_input(pThis->pNATState, pvBuf);
     378        slirp_input(pThis->pNATState, (uint8_t *)pvBuf);
    372379}
    373380
    … …  
    399406
    400407    /* @todo: Here we should get mbuf instead temporal buffer */
    401 #if 0
    402     buf = RTMemAlloc(cb);
    403     if (buf == NULL)
    404     {
    405         LogRel(("NAT: Can't allocate send buffer\n"));
    406         return VERR_NO_MEMORY;
    407     }
    408     memcpy(buf, pvBuf, cb);
    409 #else
     408#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    410409    void *pvmBuf = slirp_ext_m_get(pThis->pNATState);
    411410    Assert(pvmBuf);
    412411    slirp_ext_m_append(pThis->pNATState, pvmBuf, (uint8_t *)pvBuf, cb);
     412#else
     413    void *pvmBuf = slirp_ext_m_get(pThis->pNATState, (uint8_t *)pvBuf, cb);
     414    Assert(pvmBuf);
    413415#endif
    414416
    … …  
    966968                              "PassDomain\0TFTPPrefix\0BootFile\0Network"
    967969                              "\0NextServer\0DNSProxy\0BindIP\0UseHostResolver\0"
    968 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    969970                              "SlirpMTU\0"
    970 #endif
    971                               "SocketRcvBuf\0SocketSndBuf\0TcpRcvSpace\0TcpSndSpace\0"))
     971                              "SockRcv\0SockSnd\0TcpRcv\0TcpSnd\0"))
    972972        return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES,
    973973                                N_("Unknown NAT configuration option, only supports PassDomain,"
    … …  
    10731073            } while(0)
    10741074
    1075         SLIRP_SET_TUNING_VALUE("SocketRcvBuf", slirp_set_rcvbuf);
    1076         SLIRP_SET_TUNING_VALUE("SocketSndBuf", slirp_set_sndbuf);
    1077         SLIRP_SET_TUNING_VALUE("TcpRcvSpace", slirp_set_tcp_rcvspace);
    1078         SLIRP_SET_TUNING_VALUE("TcpSndSpace", slirp_set_tcp_sndspace);
     1075        SLIRP_SET_TUNING_VALUE("SockRcv", slirp_set_rcvbuf);
     1076        SLIRP_SET_TUNING_VALUE("SockSnd", slirp_set_sndbuf);
     1077        SLIRP_SET_TUNING_VALUE("TcpRcv", slirp_set_tcp_rcvspace);
     1078        SLIRP_SET_TUNING_VALUE("TcpSnd", slirp_set_tcp_sndspace);
    10791079
    10801080        slirp_register_statistics(pThis->pNATState, pDrvIns);

  • trunk/src/VBox/Devices/Network/slirp/dnsproxy/dnsproxy.c

    r25265 r26404  
    100100    ++removed_queries;
    101101}
    102 #else
     102#else /* VBOX */
    103103static void
    104104timeout(PNATState pData, struct socket *so, void *arg)
    … …  
    154154        m->m_len += req->nbyte;
    155155        ip->ip_src.s_addr = so->so_laddr.s_addr;
    156         ip->ip_dst.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_DNS);
     156        ip->ip_dst.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_DNS);
    157157        udp->uh_dport = ntohs(53);
    158158        udp->uh_sport = so->so_lport;
    … …  
    169169    }
    170170}
    171 #endif
     171#endif /* VBOX */
    172172
    173173/* do_query -- Called by the event loop when a packet arrives at our

  • trunk/src/VBox/Devices/Network/slirp/ip_input.c

    r25822 r26404  
    7777#else
    7878    struct m_tag *t;
    79     if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
    80     {
     79    if ((t = m_tag_find(m, PACKET_TAG_ALIAS, NULL)) != 0)
    8180        return (struct libalias *)&t[1];
    82     }
    8381#endif
    8482

  • trunk/src/VBox/Devices/Network/slirp/ip_output.c

    r25822 r26404  
    189189            struct m_tag *t;
    190190            STAM_PROFILE_START(&pData->StatALIAS_output, b);
    191             if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
     191            if ((t = m_tag_find(m, PACKET_TAG_ALIAS, NULL)) != 0)
    192192                rc = LibAliasOut((struct libalias *)&t[1], mtod(m, char *),
    193193                                 m_length(m, NULL));
    … …  
    207207        memcpy(eh->h_source, eth_dst, ETH_ALEN);
    208208
    209 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    210         if_output(pData, so, m);
    211 #else
    212209        if_encap(pData, ETH_P_IP, m, urg? ETH_ENCAP_URG : 0);
    213 #endif
    214210        goto done;
    215211     }
    … …  
    237233        struct mbuf **mnext = &m->m_nextpkt;
    238234#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    239         uint8_t *buf; /* intermediate buffer we'll use for copy from orriginal packet*/
     235        char *buf; /* intermediate buffer we'll use for copy from orriginal packet */
    240236#endif
    241237        {
    … …  
    269265            }
    270266
    271             if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
     267            if ((t = m_tag_find(m, PACKET_TAG_ALIAS, NULL)) != 0)
    272268                rcLa = LibAliasOut((struct libalias *)&t[1], tmpbuf, tmplen);
    273269            else
    … …  
    390386                memcpy(eh->h_source, eth_dst, ETH_ALEN);
    391387
    392 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    393                 if_output(pData, so, m);
    394 #else
    395388                if_encap(pData, ETH_P_IP, m, 0);
    396 #endif
    397389            }
    398390            else

  • trunk/src/VBox/Devices/Network/slirp/libslirp.h

    r25402 r26404  
    4848#endif /* !RT_OS_WINDOWS */
    4949
    50 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    51 void slirp_input(PNATState pData, const uint8_t *pkt, int pkt_len);
    52 #else
    5350void slirp_input(PNATState pData, void *pvData);
    54 #endif
    5551void slirp_set_ethaddr_and_activate_port_forwarding(PNATState pData, const uint8_t *ethaddr, uint32_t GuestIP);
    5652
    … …  
    123119void slirp_ext_m_append(PNATState pData, void *, uint8_t *, size_t);
    124120void slirp_push_recv_thread(void *pvUser);
     121#else
     122void *slirp_ext_m_get(PNATState pData, uint8_t *, size_t);
     123void slirp_ext_m_free(PNATState pData, void *);
    125124#endif
    126125

  • trunk/src/VBox/Devices/Network/slirp/mbuf.h

    r23462 r26404  
    3737#ifndef _MBUF_H_
    3838#define _MBUF_H_
     39
    3940#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    4041/* #define M_BUF_DEBUG */
    … …  
    157158
    158159#define MBUF_IP_HEADER(m) (caddr_t)(MBUF_HEAD(m) + if_maxlinkhdr)
    159 #else
     160
     161#else /* VBOX_WITH_SLIRP_BSD_MBUF */
    160162# include "bsd/sys/mbuf.h"
    161 #endif
    162 #endif
     163#endif /* VBOX_WITH_SLIRP_BSD_MBUF */
     164
     165#endif /* _MBUF_H_ */
    163166
    164167#if defined(M_BUF_DEBUG) && !defined(RT_OS_WINDOWS)

  • trunk/src/VBox/Devices/Network/slirp/misc.c

    r23369 r26404  
    130130    uint32_t magic;
    131131    PNATState pData; /* to minimize changes in the rest of UMA emulation code */
     132    RTCRITSECT csZone;
    132133    const char *name;
    133134    size_t size; /* item size */
    … …  
    150151{
    151152    struct item *it;
    152     if (    (zone->max_items != 0 && zone->cur_items >= zone->max_items)
     153    RTCritSectEnter(&zone->csZone);
     154    if (   (zone->max_items != 0 && zone->cur_items >= zone->max_items)
    153155        || (zone->max_items == 0 && !LIST_EMPTY(&zone->free_items))
    154     )
     156        )
    155157    {
    156158        /*
    … …  
    160162         */
    161163        if (LIST_EMPTY(&zone->free_items))
     164        {
     165            RTCritSectLeave(&zone->csZone);
    162166            return NULL;
     167        }
    163168        it = LIST_FIRST(&zone->free_items);
    164169        LIST_REMOVE(it, list);
    … …  
    166171        goto allocated;
    167172    }
     173
    168174    /*@todo 'Z' should be depend on flag */
    169175    it = RTMemAllocZ(sizeof(struct item) + zone->size);
    … …  
    171177    {
    172178        Log(("NAT: uma no memory"));
     179        RTCritSectLeave(&zone->csZone);
    173180        return NULL;
    174181    }
    … …  
    181188    if (zone->pfInit)
    182189        zone->pfInit(zone->pData, (void *)&it[1], zone->size, M_DONTWAIT);
     190    RTCritSectLeave(&zone->csZone);
    183191    return (void *)&it[1];
    184192}
    … …  
    192200    Assert(it->magic == ITEM_MAGIC);
    193201    zone = it->zone;
     202    RTCritSectEnter(&zone->csZone);
    194203    Assert(zone->magic == ZONE_MAGIC);
    195204    LIST_REMOVE(it, list);
    196205    LIST_INSERT_HEAD(&zone->free_items, it, list);
     206    zone->cur_items--;
     207    RTCritSectLeave(&zone->csZone);
    197208}
    198209
    … …  
    212223    zone->pfAlloc = slirp_uma_alloc;
    213224    zone->pfFree = slirp_uma_free;
     225    RTCritSectInit(&zone->csZone);
    214226    return zone;
    215227
    … …  
    239251    zone->pfFree = slirp_uma_free;
    240252    zone->size = master->size;
     253    RTCritSectInit(&zone->csZone);
    241254    return zone;
    242255}
    … …  
    256269uint32_t *uma_find_refcnt(uma_zone_t zone, void *mem)
    257270{
    258     /*@todo (r-vvl) this function supposed to work with special zone storing
     271    /*@todo (vvl) this function supposed to work with special zone storing
    259272    reference counters */
    260273    struct item *it = (struct item *)mem; /* 1st element */
     274    Assert(mem != NULL);
    261275    Assert(zone->magic == ZONE_MAGIC);
    262276    /* for returning pointer to counter we need get 0 elemnt */
    … …  
    270284    if (zone->pfAlloc == NULL)
    271285        return NULL;
     286    RTCritSectEnter(&zone->csZone);
    272287    mem = zone->pfAlloc(zone, zone->size, NULL, 0);
    273288    if (zone->pfCtor)
    274289        zone->pfCtor(zone->pData, mem, zone->size, args, M_DONTWAIT);
     290    RTCritSectLeave(&zone->csZone);
    275291    return mem;
    276292}
    … …  
    288304        return;
    289305    Assert((mem));
     306    RTCritSectEnter(&zone->csZone);
    290307    it = &((struct item *)mem)[-1];
    291308    if (it->magic != ITEM_MAGIC)
    … …  
    293310        Log(("NAT:UMA: %p seems to be allocated on heap ... freeing\n", mem));
    294311        RTMemFree(mem);
     312        RTCritSectLeave(&zone->csZone);
    295313        return;
    296314    }
    … …  
    300318        zone->pfDtor(zone->pData, mem, zone->size, flags);
    301319    zone->pfFree(mem,  0, 0);
     320    RTCritSectLeave(&zone->csZone);
    302321}
    303322int uma_zone_exhausted_nolock(uma_zone_t zone)
    … …  
    320339    return NULL;
    321340}
    322 #endif
     341
     342void *slirp_ext_m_get(PNATState pData, uint8_t *pkt, size_t pkt_len)
     343{
     344    struct mbuf *m;
     345    size_t size = MCLBYTES;
     346    if (pkt_len < MSIZE)
     347        size = MCLBYTES;
     348    else if (pkt_len < MCLBYTES)
     349        size = MCLBYTES;
     350    else if (pkt_len < MJUM9BYTES)
     351        size = MJUM9BYTES;
     352    else if (pkt_len < MJUM16BYTES)
     353        size = MJUM16BYTES;
     354    else
     355        AssertMsgFailed(("Unsupported size"));
     356
     357    m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
     358    m->m_len = pkt_len ;
     359    memcpy(m->m_data, pkt, pkt_len);
     360    return (void *)m;
     361}
     362
     363void slirp_ext_m_free(PNATState pData, void *arg)
     364{
     365    struct mbuf *m = (struct mbuf *)arg;
     366    m_free(pData, m);
     367}
     368
     369static void zone_destroy(uma_zone_t zone)
     370{
     371    RTCritSectDelete(&zone->csZone);
     372    RTMemFree(zone);
     373}
     374void m_fini(PNATState pData)
     375{
     376    zone_destroy(pData->zone_mbuf);
     377    zone_destroy(pData->zone_clust);
     378    zone_destroy(pData->zone_pack);
     379    zone_destroy(pData->zone_jumbop);
     380    zone_destroy(pData->zone_jumbo9);
     381    zone_destroy(pData->zone_jumbo16);
     382    /*@todo do finalize here.*/
     383}
     384#endif /* VBOX_WITH_SLIRP_BSD_MBUF */

  • trunk/src/VBox/Devices/Network/slirp/misc.h

    r22943 r26404  
    108108
    109109void slirp_null_arg_free(void *, void *);
    110 #endif
     110void m_fini(PNATState pData);
     111#endif /* VBOX_WITH_SLIRP_BSD_MBUF */
    111112
    112113#endif

  • trunk/src/VBox/Devices/Network/slirp/sbuf.c

    r23369 r26404  
    7979#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    8080    int mlen = 0;
    81     uint8_t *buf = NULL;
     81    caddr_t buf = NULL;
    8282#endif
    8383

  • trunk/src/VBox/Devices/Network/slirp/slirp.c

    r25822 r26404  
    833833        so->so_poll_index = -1;
    834834#endif
     835#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    835836        if (pData->fmbuf_water_line == 1)
    836837        {
    … …  
    840841                pData->fmbuf_water_line = 0;
    841842            }
    842 #ifndef RT_OS_WINDOWS
     843# ifndef RT_OS_WINDOWS
    843844            poll_index = 0;
    844 #endif
     845# endif
    845846            goto done;
    846847        }
     848#endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    847849        STAM_COUNTER_INC(&pData->StatTCP);
    848850
    … …  
    916918    /* { */
    917919
     920#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    918921        if (pData->fmbuf_water_line == 1)
    919922        {
    … …  
    923926                pData->fmbuf_water_warn_sent = 0;
    924927            }
    925 #ifndef RT_OS_WINDOWS
     928# ifndef RT_OS_WINDOWS
    926929            poll_index = 0;
    927 #endif
     930# endif
    928931            goto done;
    929932        }
     933#endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    930934        STAM_COUNTER_INC(&pData->StatUDP);
    931935#if !defined(RT_OS_WINDOWS)
    … …  
    10561060    QSOCKET_FOREACH(so, so_next, tcp)
    10571061    /* { */
     1062#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    10581063        if (pData->fmbuf_water_line == 1)
    10591064        {
    … …  
    10651070            goto done;
    10661071        }
     1072#endif
    10671073
    10681074#ifdef VBOX_WITH_SLIRP_MT
    … …  
    13531359     QSOCKET_FOREACH(so, so_next, udp)
    13541360     /* { */
     1361#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    13551362        if (pData->fmbuf_water_line == 1)
    13561363        {
    … …  
    13621369            goto done;
    13631370        }
     1371#endif
    13641372#ifdef VBOX_WITH_SLIRP_MT
    13651373        if (   so->so_state & SS_NOFDREF
    … …  
    15531561}
    15541562
    1555 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    1556 void slirp_input(PNATState pData, const uint8_t *pkt, int pkt_len)
    1557 #else
    15581563void slirp_input(PNATState pData, void *pvArg)
    1559 #endif
    15601564{
    15611565    struct mbuf *m;
    15621566    int proto;
    15631567    static bool fWarnedIpv6;
    1564 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    1565     struct ethhdr *eh = (struct ethhdr*)pkt;
    1566     int size = 0;
    1567 #else
    15681568    struct ethhdr *eh;
    1569 #endif
    15701569    uint8_t au8Ether[ETH_ALEN];
    15711570
    1572 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    15731571    m = (struct mbuf *)pvArg;
    15741572    if (m->m_len < ETH_HLEN)
    … …  
    15801578    eh = mtod(m, struct ethhdr *);
    15811579    proto = RT_N2H_U16(eh->h_proto);
    1582 #else
    1583     Log2(("NAT: slirp_input %d\n", pkt_len));
    1584     if (pkt_len < ETH_HLEN)
    1585     {
    1586         LogRel(("NAT: packet having size %d has been ingnored\n", pkt_len));
    1587         return;
    1588     }
    1589     Log4(("NAT: in:%R[ether]->%R[ether]\n", &eh->h_source, &eh->h_dest));
    1590 
    1591     if (memcmp(eh->h_source, special_ethaddr, ETH_ALEN) == 0)
    1592     {
    1593         /* @todo vasily: add ether logging routine in debug.c */
    1594         Log(("NAT: packet was addressed to other MAC\n"));
    1595         RTMemFree((void *)pkt);
    1596         return;
    1597     }
    1598 
    1599     if (pkt_len < MSIZE)
    1600         size = MCLBYTES;
    1601     else if (pkt_len < MCLBYTES)
    1602         size = MCLBYTES;
    1603     else if (pkt_len < MJUM9BYTES)
    1604         size = MJUM9BYTES;
    1605     else if (pkt_len < MJUM16BYTES)
    1606         size = MJUM16BYTES;
    1607     else
    1608         AssertMsgFailed(("Unsupported size"));
    1609 
    1610     m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    1611     if (!m)
    1612     {
    1613         LogRel(("NAT: can't allocate new mbuf\n"));
    1614         RTMemFree((void *)pkt);
    1615         return;
    1616     }
    1617 
    1618     m->m_len = pkt_len ;
    1619     memcpy(m->m_data, pkt, pkt_len);
    1620     proto = RT_N2H_U16(*(uint16_t *)(pkt + 12));
    1621 #endif
    1622     /* Note: we add to align the IP header */
    16231580
    16241581    memcpy(au8Ether, eh->h_source, ETH_ALEN);
    … …  
    16381595            M_ASSERTPKTHDR(m);
    16391596            m->m_pkthdr.header = mtod(m, void *);
    1640 #endif
    1641 #if 1
     1597#else /* !VBOX_WITH_SLIRP_BSD_MBUF */
    16421598            if (   pData->fmbuf_water_line
    16431599                && pData->fmbuf_water_warn_sent == 0
    … …  
    16481604                pData->tsmbuf_water_warn_sent = curtime;
    16491605            }
    1650 #endif
     1606#endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    16511607            ip_input(pData, m);
    16521608            break;
    … …  
    16691625    if (pData->cRedirectionsActive != pData->cRedirectionsStored)
    16701626        activate_port_forwarding(pData, au8Ether);
    1671 
    1672 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    1673     RTMemFree((void *)pkt);
    1674 #endif
    16751627}
    16761628
    … …  
    17081660        {
    17091661            /* don't do anything */
     1662            m_free(pData, m);
    17101663            goto done;
    17111664        }
    … …  
    17191672    {
    17201673        LogRel(("NAT: Can't alloc memory for outgoing buffer\n"));
     1674        m_free(pData, m);
    17211675        goto done;
    17221676    }
    … …  
    17251679#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    17261680    m_copydata(m, 0, mlen, (char *)buf);
     1681    if (flags & ETH_ENCAP_URG)
     1682        slirp_urg_output(pData->pvUser, m, buf, mlen);
     1683    else
     1684        slirp_output(pData->pvUser, m, buf, mlen);
    17271685#else
    17281686    if (flags & ETH_ENCAP_URG)
    … …  
    17331691done:
    17341692    STAM_PROFILE_STOP(&pData->StatIF_encap, a);
    1735 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    1736     m_free(pData, m);
    1737 #endif
    17381693}
    17391694

  • trunk/src/VBox/Devices/Network/slirp/slirp.h

    r25822 r26404  
    398398
    399399#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    400 /* @todo might be useful to make it configurable,
    401  * especially in terms of Intnet behind NAT
     400/**
     401 * @todo might be useful to make it configurable, especially in terms of Intnet behind NAT
    402402 */
    403403# define maxusers 32
    404404# define max_protohdr 0
    405 /* @todo (r=vvl) for now ignore value,
    406  * latter here should be fetching of tuning parameters entered
     405/**
     406 * @todo (vvl) for now ignore these values, later perhaps initialize tuning parameters
    407407 */
    408408# define TUNABLE_INT_FETCH(name, pval) do { } while (0)
    409 # define SYSCTL_PROC(a0, a1, a2, a3, a4, a5, a6, a7, a8)
    410 # define SYSCTL_STRUCT(a0, a1, a2, a3, a4, a5, a6)
    411 # define SYSINIT(a0, a1, a2, a3, a4)
     409# define SYSCTL_PROC(a0, a1, a2, a3, a4, a5, a6, a7, a8) const int dummy_ ## a6 = 0
     410# define SYSCTL_STRUCT(a0, a1, a2, a3, a4, a5, a6) const int dummy_ ## a5 = 0
     411# define SYSINIT(a0, a1, a2, a3, a4) const int dummy_ ## a3 = 0
    412412# define sysctl_handle_int(a0, a1, a2, a3) 0
    413413# define EVENTHANDLER_INVOKE(a) do{}while(0)

  • trunk/src/VBox/Devices/Network/slirp/socket.c

    r25822 r26404  
    647647        len += n;
    648648
     649        size = MCLBYTES;
    649650        if (len < MSIZE)
    650         {
    651651            size = MCLBYTES;
    652         }
    653652        else if (len < MCLBYTES)
    654         {
    655653            size = MCLBYTES;
    656         }
    657654        else if (len < MJUM9BYTES)
    658         {
    659655            size = MJUM9BYTES;
    660         }
    661656        else if (len < MJUM16BYTES)
    662         {
    663657            size = MJUM16BYTES;
    664         }
    665658        else
    666         {
    667659            AssertMsgFailed(("Unsupported size"));
    668         }
     660
    669661        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    670662        m->m_data += ETH_HLEN;
    … …  
    673665        ret = recvfrom(so->s, mtod(m, char *), n, 0,
    674666                            (struct sockaddr *)&addr, &addrlen);
    675         /* @todo (r=vvl) check which flags and type should be passed */
     667        /* @todo (vvl) check which flags and type should be passed */
    676668#endif
    677669        m->m_len = ret;
    … …  
    751743#endif
    752744#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    753     uint8_t *buf;
     745    caddr_t buf;
    754746    int mlen;
    755747#endif

  • trunk/src/VBox/Devices/Network/slirp/tcp_output.c

    r25822 r26404  
    375375        m = m_get(pData);
    376376#else
     377        size = MCLBYTES;
    377378        if ((len + hdrlen + ETH_HLEN) < MSIZE)
    378         {
    379379            size = MCLBYTES;
    380         }
    381380        else if ((len + hdrlen + ETH_HLEN) < MCLBYTES)
    382         {
    383381            size = MCLBYTES;
    384         }
    385382        else if((len + hdrlen + ETH_HLEN) < MJUM9BYTES)
    386         {
    387383            size = MJUM9BYTES;
    388         }
    389384        else if ((len + hdrlen + ETH_HLEN) < MJUM16BYTES)
    390         {
    391385            size = MJUM16BYTES;
    392         }
    393386        else
    394         {
    395387            AssertMsgFailed(("Unsupported size"));
    396         }
    397388        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    398389#endif

  • trunk/src/VBox/Devices/Network/slirp/tftp.c

    r25822 r26404  
    126126    int n = 0;
    127127
     128#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    128129    m = m_get(pData);
     130#else
     131    m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR);
     132#endif
    129133    if (!m)
    130134        return -1;
    131135
     136#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    132137    memset(m->m_data, 0, m->m_size);
    133 
    134138    m->m_data += if_maxlinkhdr;
     139#else
     140    m->m_pkthdr.header = mtod(m, void *);
     141#endif
    135142    tp = (void *)m->m_data;
    136143    m->m_data += sizeof(struct udpiphdr);
    137144
    138145    tp->tp_op = RT_H2N_U16_C(TFTP_OACK);
     146#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    139147    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%s", key) + 1;
    140148    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%u", value) + 1;
     149#else
     150    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_TRAILINGSPACE(m), "%s", key) + 1;
     151    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_TRAILINGSPACE(m), "%u", value) + 1;
     152#endif
    141153
    142154    saddr.sin_addr = recv_tp->ip.ip_dst;
    … …  
    152164    return 0;
    153165}
    154 
    155 
    156166
    157167static int tftp_send_error(PNATState pData,
    … …  
    165175    int nobytes;
    166176
     177#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    167178    m = m_get(pData);
     179#else
     180    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
     181#endif
    168182    if (!m)
    169183        return -1;
    170184
     185#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    171186    memset(m->m_data, 0, m->m_size);
    172 
    173187    m->m_data += if_maxlinkhdr;
     188#else
     189    m->m_pkthdr.header = mtod(m, void *);
     190#endif
    174191    tp = (void *)m->m_data;
    175192    m->m_data += sizeof(struct udpiphdr);
    … …  
    214231        return -1;
    215232
     233#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    216234    m = m_get(pData);
     235#else
     236    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
     237#endif
    217238    if (!m)
    218239        return -1;
    219240
     241#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    220242    memset(m->m_data, 0, m->m_size);
    221 
    222243    m->m_data += if_maxlinkhdr;
     244#else
     245    m->m_pkthdr.header = mtod(m, void *);
     246#endif
    223247    tp = (void *)m->m_data;
    224248    m->m_data += sizeof(struct udpiphdr);

  • trunk/src/VBox/Devices/Network/slirp/udp.c

    r25822 r26404  
    181181     *  handle TFTP
    182182     */
    183 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    184183    if (   uh->uh_dport == RT_H2N_U16_C(TFTP_SERVER)
    185184        && CTL_CHECK(RT_N2H_U32(ip->ip_dst.s_addr), CTL_TFTP))
    … …  
    188187        goto done;
    189188    }
    190 #endif
    191189
    192190    /*
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