VirtualBox

Changeset 30016 in vbox


Ignore:
Timestamp:
Jun 3, 2010 6:31:14 PM (15 years ago)
Author:
vboxsync
Message:

NAT: clean up.

Location:
trunk/src/VBox/Devices
Files:
3 deleted
25 edited

Legend:

Unmodified
Added
Removed

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

    r29590 r30016  
    823823endif
    824824
    825 VBOX_WITH_SLIRP_BSD_MBUF=1
    826 
    827825Drivers_INCS      := \
    828826        $(PATH_SUB_CURRENT) \
    … …  
    857855        Network/slirp/bootp.c \
    858856        Network/slirp/debug.c \
    859         Network/slirp/if.c \
    860857        Network/slirp/ip_icmp.c \
    861858        Network/slirp/ip_input.c \
    … …  
    874871        Network/slirp/dnsproxy/dnsproxy.c
    875872
    876 ifdef VBOX_WITH_SLIRP_BSD_MBUF
    877  VBOX_SLIRP_BSD_ARCH = $(subst x86,i386,$(KBUILD_TARGET_ARCH))
    878  VBOX_SLIRP_BSD_SOURCES += \
    879         Network/slirp/bsd/kern/kern_mbuf.c \
    880         Network/slirp/bsd/kern/uipc_mbuf.c \
    881         Network/slirp/bsd/kern/uipc_mbuf2.c \
    882         Network/slirp/bsd/$(VBOX_SLIRP_BSD_ARCH)/in_cksum.c
    883 else
    884 # some notes dnsproxy will probably deprecate
    885  VBOX_SLIRP_SOURCES += \
    886         Network/slirp/mbuf.c \
    887         Network/slirp/cksum.c
    888 endif
     873VBOX_SLIRP_BSD_ARCH = $(subst x86,i386,$(KBUILD_TARGET_ARCH))
     874VBOX_SLIRP_BSD_SOURCES += \
     875        Network/slirp/bsd/kern/kern_mbuf.c \
     876        Network/slirp/bsd/kern/uipc_mbuf.c \
     877        Network/slirp/bsd/kern/uipc_mbuf2.c \
     878        Network/slirp/bsd/$(VBOX_SLIRP_BSD_ARCH)/in_cksum.c
    889879
    890880VBOX_SLIRP_ALIAS_SOURCES = \
    … …  
    905895      $(if $(VBOX_WITH_SLIRP_MEMORY_CHECK),RTMEM_WRAP_TO_EF_APIS,) \
    906896      $(if $(VBOX_WITH_DEBUG_NAT_SOCKETS),VBOX_WITH_DEBUG_NAT_SOCKETS,) \
    907       $(if $(VBOX_WITH_SLIRP_MT),VBOX_WITH_SLIRP_MT,) \
    908       $(if $(VBOX_WITH_SLIRP_BSD_MBUF),VBOX_WITH_SLIRP_BSD_MBUF,)
    909  ifdef VBOX_WITH_SLIRP_BSD_MBUF
    910   $(file)_INCS += $(1)/slirp/bsd/sys
    911   $(file)_INCS += $(1)/slirp/bsd/sys/sys
    912   $(file)_INCS += $(1)/slirp/bsd/$(VBOX_SLIRP_BSD_ARCH)/include
    913   $(file)_INCS += $(1)/slirp/bsd/netinet
    914  endif
     897      $(if $(VBOX_WITH_SLIRP_MT),VBOX_WITH_SLIRP_MT,)
     898 $(file)_INCS += $(1)/slirp/bsd/sys
     899 $(file)_INCS += $(1)/slirp/bsd/sys/sys
     900 $(file)_INCS += $(1)/slirp/bsd/$(VBOX_SLIRP_BSD_ARCH)/include
     901 $(file)_INCS += $(1)/slirp/bsd/netinet
    915902 $(file)_INCS += $(1)/slirp
    916903 $(file)_INCS += $(1)/slirp/libalias
    … …  
    919906 else
    920907  $(file)_CFLAGS += -Wno-sign-compare
    921   ifdef VBOX_WITH_SLIRP_BSD_MBUF
    922    $(file)_CFLAGS += -Wno-format
    923    $(file)_CFLAGS += -Wno-bad-function-cast
    924   endif
     908  $(file)_CFLAGS += -Wno-format
     909  $(file)_CFLAGS += -Wno-bad-function-cast
    925910 endif
    926911endef
    … …  
    942927$(foreach file,$(VBOX_SLIRP_ALIAS_SOURCES),$(eval $(call def_vbox_slirp_alias_cflags, Network)))
    943928
    944 ifdef VBOX_WITH_SLIRP_BSD_MBUF
    945929VBOX_SLIRP_BSD_SOURCES += $(VBOX_SLIRP_BSD_SOURCES.${KBUILD_TARGET_ARCH})
    946930Drivers_SOURCES += $(VBOX_SLIRP_BSD_SOURCES)
    … …  
    951935$(foreach file,$(VBOX_SLIRP_BSD_SOURCES),$(eval $(call def_vbox_slirp_cflags, Network)))
    952936$(foreach file,$(VBOX_SLIRP_BSD_SOURCES),$(eval $(call def_vbox_slirp_bsd_cflags, Network)))
    953 endif
    954937
    955938ifdef VBOX_WITH_DRV_DISK_INTEGRITY

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

    r28800 r30016  
    284284
    285285    slirp_ext_m_free(pThis->pNATState, m);
    286 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    287286    RTMemFree(pu8Buf);
    288 #endif
    289287    if (ASMAtomicDecU32(&pThis->cUrgPkts) == 0)
    290288    {
    … …  
    331329done_unlocked:
    332330    slirp_ext_m_free(pThis->pNATState, m);
    333 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    334331    RTMemFree(pu8Buf);
    335 #endif
    336332    ASMAtomicDecU32(&pThis->cPkts);
    337333
    … …  
    11231119    int fUseHostResolver = 0;
    11241120    GET_S32(rc, pThis, pCfg, "UseHostResolver", fUseHostResolver);
    1125 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    11261121    int MTU = 1500;
    11271122    GET_S32(rc, pThis, pCfg, "SlirpMTU", MTU);
    1128 #endif
    11291123    int i32AliasMode = 0;
    11301124    int i32MainAliasMode = 0;
    … …  
    11751169        slirp_set_dhcp_next_server(pThis->pNATState, pThis->pszNextServer);
    11761170        slirp_set_dhcp_dns_proxy(pThis->pNATState, !!fDNSProxy);
    1177 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    11781171        slirp_set_mtu(pThis->pNATState, MTU);
    1179 #endif
    11801172        char *pszBindIP = NULL;
    11811173        GET_STRING_ALLOC(rc, pThis, pCfg, "BindIP", pszBindIP);

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

    r30013 r30016  
    674674    }
    675675
    676 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    677     if ((m = m_get(pData)) == NULL)
    678 #else
    679676    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
    680 #endif
    681677    {
    682678        LogRel(("NAT: can't alocate memory for response!\n"));
    … …  
    759755    *q++ = RFC1533_END; /* end of message */
    760756
    761 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    762757    m->m_pkthdr.header = mtod(m, void *);
    763 #endif
    764758    m->m_len = sizeof(struct bootp_t)
    765759             - sizeof(struct ip)

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

    r28800 r30016  
    179179mbufstats(PNATState pData)
    180180{
    181 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    182181    /*
    183182     * (vvl) this static code can't work with mbuf zone anymore
    184183     * @todo: make statistic correct
    185184     */
    186 #if 0
    187     struct mbuf *m;
    188     int i;
    189 
    190     lprint(" \n");
    191 
    192     lprint("Mbuf stats:\n");
    193 
    194     lprint("  %6d mbufs allocated (%d max)\n", mbuf_alloced, mbuf_max);
    195 
    196     i = 0;
    197     for (m = m_freelist.m_next; m != &m_freelist; m = m->m_next)
    198         i++;
    199     lprint("  %6d mbufs on free list\n",  i);
    200 
    201     i = 0;
    202     for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next)
    203         i++;
    204     lprint("  %6d mbufs on used list\n",  i);
    205     lprint("  %6d mbufs queued as packets\n\n", if_queued);
    206 #endif
    207 #endif
    208185}
    209186

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

    r26495 r30016  
    133133            return;
    134134        }
    135 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    136         m = m_get(pData);
    137 #else
    138135        m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
    139 #endif
    140136        if (m == NULL)
    141137        {

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

    r28800 r30016  
    1616 */
    1717
    18 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    1918# ifndef IN_BSD
    20 #  define zone_mbuf slirp_zone_mbuf(pData)
    21 #  define zone_clust slirp_zone_clust(pData)
    22 #  define zone_pack slirp_zone_pack(pData)
    23 #  define zone_jumbop slirp_zone_jumbop(pData)
    24 #  define zone_jumbo9 slirp_zone_jumbo9(pData)
    25 #  define zone_jumbo16 slirp_zone_jumbo16(pData)
    26 #  define zone_ext_refcnt slirp_zone_ext_refcnt(pData)
     19# define zone_mbuf slirp_zone_mbuf(pData)
     20# define zone_clust slirp_zone_clust(pData)
     21# define zone_pack slirp_zone_pack(pData)
     22# define zone_jumbop slirp_zone_jumbop(pData)
     23# define zone_jumbo9 slirp_zone_jumbo9(pData)
     24# define zone_jumbo16 slirp_zone_jumbo16(pData)
     25# define zone_ext_refcnt slirp_zone_ext_refcnt(pData)
    2726static inline uma_zone_t slirp_zone_mbuf(PNATState);
    2827static inline uma_zone_t slirp_zone_clust(PNATState);
    … …  
    3231static inline uma_zone_t slirp_zone_jumbo16(PNATState);
    3332static inline uma_zone_t slirp_zone_ext_refcnt(PNATState);
    34 # else
    35 #  undef zone_mbuf
    36 #  undef zone_clust
    37 #  undef zone_pack
    38 #  undef zone_jumbop
    39 #  undef zone_jumbo9
    40 #  undef zone_jumbo16
    41 #  undef zone_ext_refcnt
     33#else
     34# undef zone_mbuf
     35# undef zone_clust
     36# undef zone_pack
     37# undef zone_jumbop
     38# undef zone_jumbo9
     39# undef zone_jumbo16
     40# undef zone_ext_refcnt
    4241
    43 #  define zone_mbuf pData->zone_mbuf
    44 #  define zone_clust pData->zone_clust
    45 #  define zone_pack pData->zone_pack
    46 #  define zone_jumbop pData->zone_jumbop
    47 #  define zone_jumbo9 pData->zone_jumbo9
    48 #  define zone_jumbo16 pData->zone_jumbo16
    49 #  define zone_ext_refcnt pData->zone_ext_refcnt
    50 # endif
     42# define zone_mbuf pData->zone_mbuf
     43# define zone_clust pData->zone_clust
     44# define zone_pack pData->zone_pack
     45# define zone_jumbop pData->zone_jumbop
     46# define zone_jumbo9 pData->zone_jumbo9
     47# define zone_jumbo16 pData->zone_jumbo16
     48# define zone_ext_refcnt pData->zone_ext_refcnt
    5149#endif
    5250

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

    r28800 r30016  
    3333#define IF_NOCIDCOMP    0x08    /* CID compression */
    3434
    35 /* Needed for FreeBSD */
    36 #undef if_mtu
    37 extern int      if_mtu;
    38 extern int      if_mru;         /* MTU and MRU */
    39 extern int      if_comp;        /* Flags for compression */
    40 extern int      if_maxlinkhdr;
    41 extern int      if_queued;      /* Number of packets queued so far */
    42 extern int      if_thresh;      /* Number of packets queued before we start sending
    43                                  * (to prevent allocing too many mbufs) */
    44 
    45 extern  struct mbuf if_fastq;   /* fast queue (for interactive data) */
    46 extern  struct mbuf if_batchq;  /* queue for non-interactive data */
    47 extern  struct mbuf *next_m;
    48 
    49 #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
    5035
    5136#ifdef ETH_P_ARP

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

    r28800 r30016  
    361361    m->m_len -= hlen;
    362362    m->m_data += hlen;
    363 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    364     icp = mtod(m, struct icmp *);
    365 #else
    366363    if (m->m_next != NULL)
    367364    {
    … …  
    374371        icp = mtod(m, struct icmp *);
    375372    }
    376 #endif
    377373    if (cksum(m, icmplen))
    378374    {
    … …  
    505501            m_freem(pData, m);
    506502    } /* switch */
    507 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    508503    if (m->m_next != NULL && icp != NULL)
    509504        RTMemFree(icp);
    510 #endif
    511505
    512506end_error:
    … …  
    547541    DEBUG_ARG("msrc = %lx", (long )msrc);
    548542    DEBUG_ARG("msrc_len = %d", msrc ? msrc->m_len : 0);
    549 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    550543    if (msrc != NULL)
    551544        M_ASSERTPKTHDR(msrc);
    552 #endif
    553545
    554546    if (type!=ICMP_UNREACH && type!=ICMP_TIMXCEED && type != ICMP_SOURCEQUENCH)
    … …  
    584576    }
    585577
    586 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    587     /* make a copy */
    588     m = m_get(pData);
    589 #else
    590578    new_m_size = sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
    591579    if (new_m_size < MSIZE)
    … …  
    610598    }
    611599    m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    612 #endif
     600
    613601    if (m == NULL)
    614602        goto end_error;                    /* get mbuf */
    615603
    616604    m->m_data += if_maxlinkhdr;
    617 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    618605    m->m_pkthdr.header = mtod(m, void *);
    619 #else
    620     new_m_size = if_maxlinkhdr + sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
    621     if (new_m_size > m->m_size)
    622     {
    623         m_inc(m, new_m_size);
    624         if (new_m_size > m->m_size)
    625             goto end_error_free_m;
    626     }
    627 #endif
    628606
    629607    memcpy(m->m_data, msrc->m_data, msrc->m_len);
    … …  
    670648            message_len = ICMP_MAXDATALEN;
    671649        cpnt = (char *)m->m_data+m->m_len;
    672 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    673         memcpy(cpnt, message, message_len);
    674         m->m_len += message_len;
    675 #else
    676650        m_append(pData, m, message_len, message);
    677 #endif
    678651    }
    679652#endif
    … …  
    681654    icp->icmp_cksum = 0;
    682655    icp->icmp_cksum = cksum(m, m->m_len);
    683 
    684 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    685     m->m_data -= hlen;
    686     m->m_len += hlen;
    687 #endif
    688656
    689657    /* fill in ip */

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

    r28800 r30016  
    9191    struct ip *pip = NULL;
    9292
    93 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    94     if (m->m_la)
    95         return m->m_la;
    96 #else
    9793    struct m_tag *t;
    9894    if ((t = m_tag_find(m, PACKET_TAG_ALIAS, NULL)) != 0)
    9995        return (struct libalias *)&t[1];
    100 #endif
    10196
    10297    return la;
    … …  
    391386    }
    392387
    393 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    394 #define GETIP(m)    ((struct ip*)(MBUF_IP_HEADER(m)))
    395 #else
    396388#define GETIP(m)    ((struct ip*)((m)->m_pkthdr.header))
    397 #endif
    398 
    399389
    400390    /*

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

    r28800 r30016  
    123123    DEBUG_ARG("m0 = %lx", (long)m0);
    124124
    125 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    126     if(m->m_data != (MBUF_HEAD(m) + if_maxlinkhdr))
    127     {
    128         LogRel(("NAT: ethernet detects corruption of the packet"));
    129         AssertMsgFailed(("!!Ethernet frame corrupted!!"));
    130     }
    131 #else
    132125    M_ASSERTPKTHDR(m);
    133126    Assert(m->m_pkthdr.header);
    134 #endif
    135127
    136128#if 0 /* We do no options */
    … …  
    151143    ipstat.ips_localout++;
    152144
    153     /*
    154      * Verify that we have any chance at all of being able to queue
    155      *      the packet or packet fragments
    156      */
    157 #if 0 /* XXX Hmmm... */
    158     if (if_queued > if_thresh && towrite <= 0)
    159     {
    160         error = ENOBUFS;
    161         goto exit_drop_package;
    162     }
    163 #endif
    164145    /* Current TCP/IP stack hasn't routing information at
    165146     * all so we need to calculate destination ethernet address
    166      */
    167 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    168     eh = (struct ethhdr *)MBUF_HEAD(m);
    169     if (memcmp(eh->h_source, zerro_ethaddr, ETH_ALEN) == 0)
    170     {
    171        rc = rt_lookup_in_cache(pData, ip->ip_dst.s_addr, eth_dst);
    172        if (RT_FAILURE(rc))
    173            goto exit_drop_package;
    174     }
    175     else
    176     {
    177        memcpy(eth_dst, eh->h_source, ETH_ALEN);
    178        rc = 0; /*some times we've already know where to send packet*/
    179     }
    180 #else
    181     /*
    182      * (vvl) Assumption is that m_data points at the IP header and only
    183      * in case of dhcp we know and have header before IP.
    184147     */
    185148    rc = rt_lookup_in_cache(pData, ip->ip_dst.s_addr, eth_dst);
    … …  
    188151
    189152    eh = (struct ethhdr *)(m->m_data - ETH_HLEN);
    190 #endif
    191153    /*
    192154     * If small enough for interface, can just send directly.
    … …  
    200162
    201163        {
    202 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    203             STAM_PROFILE_START(&pData->StatALIAS_output, b);
    204             rc = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
    205                 mtod(m, char *), m->m_len);
    206             Log2(("NAT: LibAlias return %d\n", rc));
    207 #else
    208164            struct m_tag *t;
    209165            STAM_PROFILE_START(&pData->StatALIAS_output, b);
    … …  
    220176                goto exit_drop_package;
    221177            }
    222 #endif
    223178            STAM_PROFILE_STOP(&pData->StatALIAS_output, b);
    224179        }
    … …  
    251206        int mhlen, firstlen = len;
    252207        struct mbuf **mnext = &m->m_nextpkt;
    253 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    254208        char *buf; /* intermediate buffer we'll use for copy from orriginal packet */
    255 #endif
    256209        {
    257 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    258210            struct m_tag *t;
    259211            char *tmpbuf = NULL;
    260212            int tmplen = 0;
    261 #endif
    262213            int rcLa;
    263214            HTONS(ip->ip_len);
    … …  
    265216            ip->ip_sum = 0;
    266217            ip->ip_sum = cksum(m, hlen);
    267 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    268             rcLa = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
    269                                 mtod(m, char *), m->m_len);
    270 #else
    271218            if (m->m_next != NULL)
    272219            {
    … …  
    304251                goto exit_drop_package;
    305252            }
    306 #endif
    307253            NTOHS(ip->ip_len);
    308254            NTOHS(ip->ip_off);
    … …  
    319265        {
    320266            register struct ip *mhip;
    321 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    322             m = m_get(pData);
    323 #else
    324267            m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
    325 #endif
    326268            if (m == 0)
    327269            {
    … …  
    334276            *mhip = *ip;
    335277            m->m_len += ip->ip_hl << 2;
    336 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    337278            m->m_pkthdr.header = mtod(m, void *);
    338 #endif
    339279            /* we've calculated eth_dst for first packet */
    340280#if 0 /* No options */
    … …  
    354294            mhip->ip_len = RT_H2N_U16((u_int16_t)(len + mhlen));
    355295
    356 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    357             if (m_copy(m, m0, off, len) < 0)
    358             {
    359                 error = -1;
    360                 goto sendorfree;
    361             }
    362 #else
    363296            buf = RTMemAlloc(len);
    364297            m_copydata(m0, off, len, buf); /* copy to buffer */
    … …  
    369302            RTMemFree(buf);
    370303            m->m_len += RT_N2H_U16(mhip->ip_len);
    371 #endif
    372304
    373305            mhip->ip_off = RT_H2N_U16((u_int16_t)mhip->ip_off);
    … …  
    396328            if (error == 0)
    397329            {
    398 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    399                 eh = (struct ethhdr *)MBUF_HEAD(m);
    400 #else
    401330                m->m_data -= ETH_HLEN;
    402331                eh = mtod(m, struct ethhdr *);
    403332                m->m_data += ETH_HLEN;
    404 #endif
    405333                memcpy(eh->h_source, eth_dst, ETH_ALEN);
    406334

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

    r26495 r30016  
    16661666#endif
    16671667
    1668 #if defined(_KERNEL) || (defined(VBOX) && defined(VBOX_WITH_SLIRP_BSD_MBUF))
     1668#if defined(_KERNEL) || defined(VBOX)
    16691669/*
    16701670 * m_megapullup() - this function is a big hack.

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

    r28800 r30016  
    8888
    8989int slirp_set_binding_address(PNATState, char *addr);
    90 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    9190void slirp_set_mtu(PNATState, int);
    92 #endif
    9391
    9492#if defined(RT_OS_WINDOWS)
    … …  
    130128struct mbuf *slirp_ext_m_get(PNATState pData, size_t cbMin, void **ppvBuf, size_t *pcbBuf);
    131129void slirp_ext_m_free(PNATState pData, struct mbuf *);
    132 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    133 void slirp_push_recv_thread(void *pvUser);
    134 #endif
    135130
    136131/*

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

    r30013 r30016  
    9797
    9898
    99 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    10099#define ITEM_MAGIC 0xdead0001
    101100struct item
    … …  
    445444    /*@todo do finalize here.*/
    446445}
    447 #endif /* VBOX_WITH_SLIRP_BSD_MBUF */
     446
     447void
     448if_init(PNATState pData)
     449{
     450    /* 14 for ethernet */
     451    if_maxlinkhdr = 14;
     452    if_comp = IF_AUTOCOMP;
     453    if_mtu = 1500;
     454    if_mru = 1500;
     455}

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

    r28800 r30016  
    3434void fd_nonblock (int);
    3535
    36 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    3736/* UVM interface */
    3837#define UMA_ALIGN_PTR       (1 << 0)
    … …  
    6867void slirp_null_arg_free(void *, void *);
    6968void m_fini(PNATState pData);
    70 #endif /* VBOX_WITH_SLIRP_BSD_MBUF */
    7169
    7270#endif

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

    r28800 r30016  
    109109{
    110110    int ret = 0;
    111 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    112111    int mlen = 0;
    113112    caddr_t buf = NULL;
    114 #endif
    115113
    116114    STAM_PROFILE_START(&pData->StatIOSBAppend_pf, a);
    … …  
    122120    STAM_COUNTER_INC(&pData->StatIOSBAppend);
    123121    /* Shouldn't happen, but...  e.g. foreign host closes connection */
    124 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    125     if (m->m_len <= 0)
    126 #else
    127122    mlen = m_length(m, NULL);
    128123    if (mlen <= 0)
    129 #endif
    130124    {
    131125        STAM_COUNTER_INC(&pData->StatIOSBAppend_zm);
    … …  
    150144     * ottherwise it'll arrive out of order, and hence corrupt
    151145     */
    152 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    153     if(!so->so_rcv.sb_cc)
    154         ret = send(so->s, m->m_data, m->m_len, 0);
    155 #else
    156146    buf = RTMemAlloc(mlen);
    157147    if (buf == NULL)
    … …  
    165155    RTMemFree(buf);
    166156no_sent:
    167 #endif
    168157
    169158    if (ret <= 0)
    … …  
    180169        goto done;
    181170    }
    182 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    183     else if (ret != m->m_len)
    184 #else
    185171    else if (ret != mlen)
    186 #endif
    187172    {
    188173        STAM_COUNTER_INC(&pData->StatIOSBAppend_wp);
    … …  
    191176         * sbappendsb the rest
    192177         */
    193 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    194         m->m_len -= ret;
    195         m->m_data += ret;
    196 #else
    197178        m_adj(m, ret);
    198 #endif
    199179        sbappendsb(pData, &so->so_rcv, m);
    200180        STAM_PROFILE_STOP(&pData->StatIOSBAppend_pf_wp, a);
    … …  
    217197    int len, n,  nn;
    218198
    219 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    220     len = m->m_len;
    221 #else
    222199    len = m_length(m, NULL);
    223 #endif
    224200
    225201    STAM_COUNTER_INC(&pData->StatIOSBAppendSB);
    … …  
    230206        if (n > len)
    231207            n = len;
    232 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    233         memcpy(sb->sb_wptr, m->m_data, n);
    234 #else
    235208        m_copydata(m, 0, n, sb->sb_wptr);
    236 #endif
    237209    }
    238210    else
    … …  
    243215        if (n > len)
    244216            n = len;
    245 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    246         memcpy(sb->sb_wptr, m->m_data, n);
    247 #else
    248217        m_copydata(m, 0, n, sb->sb_wptr);
    249 #endif
    250218        len -= n;
    251219        if (len)
    … …  
    255223            if (nn > len)
    256224                nn = len;
    257 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    258             memcpy(sb->sb_data, m->m_data+n, nn);
    259 #else
    260225            m_copydata(m, n, nn, sb->sb_data);
    261 #endif
    262226            n += nn;
    263227        }

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

    r29946 r30016  
    626626
    627627    /* Initialise mbufs *after* setting the MTU */
    628 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    629     m_init(pData);
    630 #else
    631628    mbuf_init(pData);
    632 #endif
    633629
    634630    pData->special_addr.s_addr = u32NetAddr;
    … …  
    899895        so->so_poll_index = -1;
    900896#endif
    901 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    902         if (pData->fmbuf_water_line == 1)
    903         {
    904             if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    905             {
    906                 pData->fmbuf_water_warn_sent = 0;
    907                 pData->fmbuf_water_line = 0;
    908             }
    909 # ifndef RT_OS_WINDOWS
    910             poll_index = 0;
    911 # endif
    912             goto done;
    913         }
    914 #endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    915897        STAM_COUNTER_INC(&pData->StatTCP);
    916898
    … …  
    983965    /* { */
    984966
    985 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    986         if (pData->fmbuf_water_line == 1)
    987         {
    988             if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    989             {
    990                 pData->fmbuf_water_line = 0;
    991                 pData->fmbuf_water_warn_sent = 0;
    992             }
    993 # ifndef RT_OS_WINDOWS
    994             poll_index = 0;
    995 # endif
    996             goto done;
    997         }
    998 #endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    999967        STAM_COUNTER_INC(&pData->StatUDP);
    1000968#if !defined(RT_OS_WINDOWS)
    … …  
    11241092    QSOCKET_FOREACH(so, so_next, tcp)
    11251093    /* { */
    1126 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1127         if (pData->fmbuf_water_line == 1)
    1128         {
    1129             if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    1130             {
    1131                 pData->fmbuf_water_line = 0;
    1132                 pData->fmbuf_water_warn_sent = 0;
    1133             }
    1134             goto done;
    1135         }
    1136 #endif
    11371094
    11381095#ifdef VBOX_WITH_SLIRP_MT
    … …  
    13551312     QSOCKET_FOREACH(so, so_next, udp)
    13561313     /* { */
    1357 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1358         if (pData->fmbuf_water_line == 1)
    1359         {
    1360             if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    1361             {
    1362                 pData->fmbuf_water_line = 0;
    1363                 pData->fmbuf_water_warn_sent = 0;
    1364             }
    1365             goto done;
    1366         }
    1367 #endif
    13681314#ifdef VBOX_WITH_SLIRP_MT
    13691315        if (   so->so_state & SS_NOFDREF
    … …  
    14081354
    14091355done:
    1410 #if 0
    1411     /*
    1412      * See if we can start outputting
    1413      */
    1414     if (if_queued && link_up)
    1415         if_start(pData);
    1416 #endif
    14171356
    14181357    STAM_PROFILE_STOP(&pData->StatPoll, a);
    … …  
    14581397    {
    14591398        case ARPOP_REQUEST:
    1460 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1461             mr = m_get(pData);
    1462 
    1463             reh = mtod(mr, struct ethhdr *);
    1464             memcpy(reh->h_source, eh->h_source, ETH_ALEN); /* XXX: if_encap will swap src and dst*/
    1465             Log4(("NAT: arp:%R[ether]->%R[ether]\n",
    1466                 reh->h_source, reh->h_dest));
    1467             Log4(("NAT: arp: %R[IP4]\n", &tip));
    1468 
    1469             mr->m_data += if_maxlinkhdr;
    1470             mr->m_len = sizeof(struct arphdr);
    1471             rah = mtod(mr, struct arphdr *);
    1472 #else
    14731399            mr = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
    14741400            if (mr == NULL)
    … …  
    14801406            Assert(mr);
    14811407            memcpy(reh->h_source, eh->h_source, ETH_ALEN); /* XXX: if_encap will swap src and dst*/
    1482 #endif
    14831408#ifdef VBOX_WITH_NAT_SERVICE
    14841409            if (tip == pData->special_addr.s_addr)
    … …  
    15871512            updtime(pData);
    15881513            m_adj(m, ETH_HLEN);
    1589 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    15901514            M_ASSERTPKTHDR(m);
    15911515            m->m_pkthdr.header = mtod(m, void *);
    1592 #else /* !VBOX_WITH_SLIRP_BSD_MBUF */
    1593             if (   pData->fmbuf_water_line
    1594                 && pData->fmbuf_water_warn_sent == 0
    1595                 && (curtime - pData->tsmbuf_water_warn_sent) > 500)
    1596             {
    1597                 icmp_error(pData, m, ICMP_SOURCEQUENCH, 0, 0, "Out of resources!!!");
    1598                 pData->fmbuf_water_warn_sent = 1;
    1599                 pData->tsmbuf_water_warn_sent = curtime;
    1600             }
    1601 #endif /* !VBOX_WITH_SLIRP_BSD_MBUF */
    16021516            ip_input(pData, m);
    16031517            break;
    … …  
    16301544    STAM_PROFILE_START(&pData->StatIF_encap, a);
    16311545
    1632 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1633     m->m_data -= if_maxlinkhdr;
    1634     m->m_len += ETH_HLEN;
    1635     eh = mtod(m, struct ethhdr *);
    1636 
    1637     if (MBUF_HEAD(m) != m->m_data)
    1638     {
    1639         LogRel(("NAT: ethernet detects corruption of the packet"));
    1640         AssertMsgFailed(("!!Ethernet frame corrupted!!"));
    1641     }
    1642 #else
    16431546    M_ASSERTPKTHDR(m);
    16441547    m->m_data -= ETH_HLEN;
    16451548    m->m_len += ETH_HLEN;
    16461549    eh = mtod(m, struct ethhdr *);
    1647 #endif
    16481550
    16491551    if (memcmp(eh->h_source, special_ethaddr, ETH_ALEN) != 0)
    … …  
    16591561        }
    16601562    }
    1661 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1662     mlen = m->m_len;
    1663 #else
    16641563    mlen = m_length(m, NULL);
    16651564    buf = RTMemAlloc(mlen);
    … …  
    16701569        goto done;
    16711570    }
    1672 #endif
    16731571    eh->h_proto = RT_H2N_U16(eth_proto);
    1674 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    16751572    m_copydata(m, 0, mlen, (char *)buf);
    16761573    if (flags & ETH_ENCAP_URG)
    … …  
    16781575    else
    16791576        slirp_output(pData->pvUser, m, buf, mlen);
    1680 #else
    1681     if (flags & ETH_ENCAP_URG)
    1682         slirp_urg_output(pData->pvUser, m, mtod(m, const uint8_t *), mlen);
    1683     else
    1684         slirp_output(pData->pvUser, m, mtod(m, const uint8_t *), mlen);
    1685 #endif
    16861577done:
    16871578    STAM_PROFILE_STOP(&pData->StatIF_encap, a);
    … …  
    20481939    struct arphdr *ahdr;
    20491940
    2050 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    2051     m = m_get(pData);
    2052 #else
    20531941    m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
    2054 #endif
    20551942    if (m == NULL)
    20561943    {
    … …  
    20701957    memset(ahdr->ar_tha, 0xff, ETH_ALEN); /*broadcast*/
    20711958    *(uint32_t *)ahdr->ar_tip = dst;
    2072 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    2073     m->m_data += if_maxlinkhdr;
    2074     m->m_len = sizeof(struct arphdr);
    2075 #else
    20761959    /* warn!!! should falls in mbuf minimal size */
    20771960    m->m_len = sizeof(struct arphdr) + ETH_HLEN;
    20781961    m->m_data += ETH_HLEN;
    20791962    m->m_len -= ETH_HLEN;
    2080 #endif
    20811963    if_encap(pData, ETH_P_ARP, m, ETH_ENCAP_URG);
    20821964}
    … …  
    21222004}
    21232005
    2124 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    21252006void slirp_set_mtu(PNATState pData, int mtu)
    21262007{
    … …  
    21332014    if_mru = mtu;
    21342015}
    2135 #endif

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

    r29656 r30016  
    248248#include "icmp_var.h"
    249249#include "mbuf.h"
     250#include "if.h"
    250251#include "sbuf.h"
    251252#include "socket.h"
    252 #include "if.h"
    253253#include "main.h"
    254254#include "misc.h"
    … …  
    286286
    287287/* cksum.c */
    288 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    289 int cksum(struct mbuf *m, int len);
    290 #else
    291288typedef uint16_t u_short;
    292289typedef unsigned int u_int;
    293290#include "in_cksum.h"
    294 #endif
    295291
    296292/* if.c */
    … …  
    419415#endif /*VBOX_SLIRP_ALIAS*/
    420416
    421 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    422417/**
    423418 * @todo might be useful to make it configurable, especially in terms of Intnet behind NAT
    … …  
    446441void mbuf_init(void *);
    447442# define cksum(m, len) in_cksum_skip((m), (len), 0)
    448 #endif
    449443
    450444int ftp_alias_load(PNATState);

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

    r29656 r30016  
    7272};
    7373TAILQ_HEAD(dns_list_head, dns_entry);
    74 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    7574TAILQ_HEAD(if_queue, mbuf);
    76 #endif
    7775
    7876struct port_forward_rule
    … …  
    9189LIST_HEAD(port_forward_rule_list, port_forward_rule);
    9290
    93 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    94 struct mbuf_zone
    95 {
    96     LIST_ENTRY(mbuf_zone) list;
    97     uint8_t *mbuf_zone_base_addr;
    98 };
    99 LIST_HEAD(mbuf_zone_list, mbuf_zone);
    100 #endif
    10191
    10292
    … …  
    119109    int if_queued;
    120110    int if_thresh;
    121 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    122     struct mbuf if_fastq;
    123     struct mbuf if_batchq;
    124 #else
    125     struct if_queue if_fastq;
    126     struct if_queue if_batchq;
    127 #endif
    128     struct mbuf *next_m;
    129111    /* Stuff from icmp.c */
    130112    struct icmpstat_t icmpstat;
    … …  
    137119    uint16_t ip_currid;
    138120    /* Stuff from mbuf.c */
    139     int mbuf_alloced, mbuf_max;
    140     int msize;
    141     struct mbuf m_freelist, m_usedlist;
    142 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    143     struct mbuf_zone_list mbuf_zone_head;
    144     RTCRITSECT cs_mbuf_zone;
    145     int fmbuf_water_line;
    146     int mbuf_water_line_limit;
    147     int mbuf_zone_count;
    148     int fmbuf_water_warn_sent;
    149     uint32_t tsmbuf_water_warn_sent;
    150 #endif
    151121    /* Stuff from slirp.c */
    152122    void *pvUser;
    … …  
    242212    HANDLE phEvents[VBOX_EVENT_COUNT];
    243213#endif
    244 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    245 # ifdef zone_mbuf
    246 #  undef zone_mbuf
    247 # endif
     214#ifdef zone_mbuf
     215# undef zone_mbuf
     216#endif
    248217    uma_zone_t zone_mbuf;
    249 # ifdef zone_clust
    250 #  undef zone_clust
    251 # endif
     218#ifdef zone_clust
     219# undef zone_clust
     220#endif
    252221    uma_zone_t zone_clust;
    253 # ifdef zone_pack
    254 #  undef zone_pack
    255 # endif
     222#ifdef zone_pack
     223# undef zone_pack
     224#endif
    256225    uma_zone_t zone_pack;
    257 # ifdef zone_jumbop
    258 #  undef zone_jumbop
    259 # endif
     226#ifdef zone_jumbop
     227# undef zone_jumbop
     228#endif
    260229    uma_zone_t zone_jumbop;
    261 # ifdef zone_jumbo9
    262 #  undef zone_jumbo9
    263 # endif
     230#ifdef zone_jumbo9
     231# undef zone_jumbo9
     232#endif
    264233    uma_zone_t zone_jumbo9;
    265 # ifdef zone_jumbo16
    266 #  undef zone_jumbo16
    267 # endif
     234#ifdef zone_jumbo16
     235# undef zone_jumbo16
     236#endif
    268237    uma_zone_t zone_jumbo16;
    269 # ifdef zone_ext_refcnt
    270 #  undef zone_ext_refcnt
     238#ifdef zone_ext_refcnt
     239# undef zone_ext_refcnt
    271240    int nmbclusters;                    /* limits number of mbuf clusters */
    272241    int nmbjumbop;                      /* limits number of page size jumbo clusters */
    … …  
    274243    int nmbjumbo16;                     /* limits number of 16k jumbo clusters */
    275244    struct mbstat mbstat;
    276 # endif
     245#endif
    277246    uma_zone_t zone_ext_refcnt;
    278 #endif
    279247    bool fUseHostResolver;
    280248    /* from dnsproxy/dnsproxy.h*/
    … …  
    372340#define if_queued pData->if_queued
    373341#define if_thresh pData->if_thresh
    374 #define if_fastq pData->if_fastq
    375 #define if_batchq pData->if_batchq
    376 #define next_m pData->next_m
    377342
    378343#define icmpstat pData->icmpstat
    … …  
    709674#define instancehead pData->instancehead
    710675
    711 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    712 # define nmbclusters    pData->nmbclusters
    713 # define nmbjumbop  pData->nmbjumbop
    714 # define nmbjumbo9  pData->nmbjumbo9
    715 # define nmbjumbo16 pData->nmbjumbo16
    716 # define mbstat pData->mbstat
    717 # include "ext.h"
    718 # undef zone_mbuf
    719 # undef zone_clust
    720 # undef zone_pack
    721 # undef zone_jumbop
    722 # undef zone_jumbo9
    723 # undef zone_jumbo16
    724 # undef zone_ext_refcnt
     676#define nmbclusters    pData->nmbclusters
     677#define nmbjumbop  pData->nmbjumbop
     678#define nmbjumbo9  pData->nmbjumbo9
     679#define nmbjumbo16 pData->nmbjumbo16
     680#define mbstat pData->mbstat
     681#include "ext.h"
     682#undef zone_mbuf
     683#undef zone_clust
     684#undef zone_pack
     685#undef zone_jumbop
     686#undef zone_jumbo9
     687#undef zone_jumbo16
     688#undef zone_ext_refcnt
    725689static inline uma_zone_t slirp_zone_pack(PNATState pData)
    726690{
    … …  
    754718# define m_adj(m, len) m_adj(pData, (m), (len))
    755719#endif
    756 #endif
    757720
    758721#endif /* !___slirp_state_h */

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

    r30013 r30016  
    588588        ssize_t len;
    589589        u_long n = 0;
    590 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    591590        int size;
    592 #endif
    593591        int rc = 0;
    594592        static int signalled = 0;
    … …  
    598596        QSOCKET_UNLOCK(udb);
    599597
    600 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    601         if (!(m = m_get(pData)))
    602         {
    603             SOCKET_UNLOCK(so);
    604             return;
    605         }
    606         /* adjust both parameters to maks M_FREEROOM calculate correct */
    607         m->m_data += if_maxlinkhdr + sizeof(struct udphdr) + sizeof(struct ip);
    608 
    609         /*
    610          * XXX Shouldn't FIONREAD packets destined for port 53,
    611          * but I don't know the max packet size for DNS lookups
    612          */
    613         len = M_FREEROOM(m);
    614         /* if (so->so_fport != RT_H2N_U16_C(53)) */
    615         rc = ioctlsocket(so->s, FIONREAD, &n);
    616         if (   rc == -1
    617             && (  errno == EAGAIN
    618                || errno == EWOULDBLOCK
    619                || errno == EINPROGRESS
    620                || errno == ENOTCONN))
    621         {
    622             m_freem(pData, m);
    623             return;
    624         }
    625 
    626         Log2(("NAT: %R[natsock] ioctlsocket before read "
    627             "(rc:%d errno:%d, n:%d)\n", so, rc, errno, n));
    628 
    629         if (rc == -1 && signalled == 0)
    630         {
    631             LogRel(("NAT: can't fetch amount of bytes on socket %R[natsock], so message will be truncated.\n", so));
    632             signalled = 1;
    633             m_freem(pData, m);
    634             return;
    635         }
    636 
    637         if (rc != -1 && n > len)
    638         {
    639             n = (m->m_data - m->m_dat) + m->m_len + n + 1;
    640             m_inc(m, n);
    641             len = M_FREEROOM(m);
    642         }
    643         ret = recvfrom(so->s, m->m_data, len, 0,
    644                             (struct sockaddr *)&addr, &addrlen);
    645         Log2(("NAT: %R[natsock] ioctlsocket after read "
    646             "(rc:%d errno:%d, n:%d) ret:%d, len:%d\n", so,
    647              rc, errno, n, ret, len));
    648 #else
    649598        /*How many data has been received ?*/
    650599        /*
    … …  
    688637                            (struct sockaddr *)&addr, &addrlen);
    689638        /* @todo (vvl) check which flags and type should be passed */
    690 #endif
    691639        m->m_len = ret;
    692640        if (ret < 0)
    … …  
    763711    struct sockaddr_in host_addr;
    764712#endif
    765 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    766713    caddr_t buf;
    767714    int mlen;
    768 #endif
    769715
    770716    DEBUG_CALL("sosendto");
    … …  
    818764
    819765    /* Don't care what port we get */
    820 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    821     ret = sendto(so->s, m->m_data, m->m_len, 0, &addr, sizeof (struct sockaddr_in));
    822 #else
    823766    mlen = m_length(m, NULL);
    824767    buf = RTMemAlloc(mlen);
    … …  
    830773    ret = sendto(so->s, buf, mlen, 0,
    831774                 (struct sockaddr *)&addr, sizeof (struct sockaddr));
    832 #endif
    833775    if (ret < 0)
    834776    {
    … …  
    10701012    uint8_t proto;
    10711013    int type = 0;
    1072 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1073     int m_room;
    1074 #endif
    10751014
    10761015    ip = (struct ip *)buff;
    … …  
    11821121    original_hlen = ip->ip_hl << 2;
    11831122    /* saves original ip header and options */
    1184 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    11851123    m_copyback(pData, m, original_hlen, len - hlen, buff + hlen);
    11861124    ip->ip_len = m_length(m, NULL);
    1187 #else
    1188     /* m_room space in the saved m buffer */
    1189     m_room = M_ROOM(m);
    1190     if (m_room < len - hlen + original_hlen)
    1191     {
    1192         /* we need involve ether header length into new buffer buffer calculation */
    1193         m_inc(m, if_maxlinkhdr + len - hlen + original_hlen);
    1194         if (m->m_size < if_maxlinkhdr + len - hlen + original_hlen)
    1195         {
    1196             Log(("send_icmp_to_guest: extending buffer was failed (packet is dropped)\n"));
    1197             return;
    1198         }
    1199     }
    1200     memcpy(m->m_data + original_hlen, buff + hlen, len - hlen);
    1201     m->m_len = len - hlen + original_hlen;
    1202     ip->ip_len = m->m_len;
    1203 #endif
    12041125    ip->ip_p = IPPROTO_ICMP; /* the original package could be whatever, but we're response via ICMP*/
    12051126
    … …  
    12881209                break;
    12891210            case IP_SUCCESS: /* echo replied */
    1290 # ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1291                 m = m_get(pData);
    1292 # else
    12931211                out_len = ETH_HLEN + sizeof(struct ip) +  8;
    12941212                size;
    … …  
    13081226                if (m == NULL)
    13091227                    return;
    1310 # endif
    13111228                m->m_len = 0;
    13121229                m->m_data += if_maxlinkhdr;
    … …  
    13271244                data_len += ICMP_MINLEN;
    13281245
    1329 # ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1330                 nbytes = (data_len + icr[i].DataSize > m->m_size? m->m_size - data_len: icr[i].DataSize);
    1331                 memcpy(icp->icmp_data, icr[i].Data, nbytes);
    1332 # else
    13331246                hlen = (ip->ip_hl << 2);
    13341247                m->m_pkthdr.header = mtod(m, void *);
    … …  
    13361249
    13371250                m_copyback(pData, m, hlen + 8, icr[i].DataSize, icr[i].Data);
    1338 # endif
    13391251
    13401252                data_len += icr[i].DataSize;
    … …  
    13651277                data_len = (ip_broken->ip_hl << 2) + 64;
    13661278
    1367 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    1368                 nbytes =(hlen + ICMP_MINLEN + data_len > m->m_size? m->m_size - (hlen + ICMP_MINLEN): data_len);
    1369                 memcpy(icp->icmp_data, ip_broken,  nbytes);
    1370 #else
    13711279                m->m_len = data_len;
    13721280                m->m_pkthdr.header = mtod(m, void *);
    13731281                m_copyback(pData, m, ip->ip_hl >> 2, icr[i].DataSize, icr[i].Data);
    1374 #endif
    13751282                icmp_reflect(pData, m);
    13761283                break;

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

    r28800 r30016  
    135135 * We make this 1460 because we only care about Ethernet in the qemu context.
    136136 */
    137 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    138 #define TCP_MSS 1460
    139 #else
    140137#define TCP_MSS (if_mtu - 80)
    141 #endif
    142138
    143139#define TCP_MAXWIN      65535   /* largest value for (unscaled) window */

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

    r28800 r30016  
    359359     * here we do the test the same as input method of UDP protocol.
    360360     */
    361 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    362361    Assert((ip->ip_len + iphlen == m_length(m, NULL)));
    363 #else
    364     Assert((ip->ip_len  + iphlen == m->m_len));
    365 #endif
    366362    save_ip = *ip;
    367363    save_ip.ip_len+= iphlen;

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

    r28800 r30016  
    100100    unsigned optlen, hdrlen;
    101101    int idle, sendalot;
    102 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    103102    int size;
    104 #endif
    105103
    106104    DEBUG_CALL("tcp_output");
    … …  
    393391        }
    394392
    395 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    396         m = m_get(pData);
    397 #else
    398393        size = MCLBYTES;
    399394        if ((len + hdrlen + ETH_HLEN) < MSIZE)
    … …  
    408403            AssertMsgFailed(("Unsupported size"));
    409404        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    410 #endif
    411405        if (m == NULL)
    412406        {
    … …  
    416410        }
    417411        m->m_data += if_maxlinkhdr;
    418 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    419412        m->m_pkthdr.header = mtod(m, void *);
    420 #endif
    421413        m->m_len = hdrlen;
    422414
    … …  
    460452            tcpstat.tcps_sndwinup++;
    461453
    462 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    463         m = m_get(pData);
     454        if ((hdrlen + ETH_HLEN) < MSIZE)
     455        {
     456            size = MCLBYTES;
     457        }
     458        else if ((hdrlen + ETH_HLEN) < MCLBYTES)
     459        {
     460            size = MCLBYTES;
     461        }
     462        else if((hdrlen + ETH_HLEN) < MJUM9BYTES)
     463        {
     464            size = MJUM9BYTES;
     465        }
     466        else if ((hdrlen + ETH_HLEN) < MJUM16BYTES)
     467        {
     468            size = MJUM16BYTES;
     469        }
     470        else
     471        {
     472            AssertMsgFailed(("Unsupported size"));
     473        }
     474        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    464475        if (m == NULL)
    465476        {
    … …  
    468479            goto out;
    469480        }
    470 #else
    471         if ((hdrlen + ETH_HLEN) < MSIZE)
    472         {
    473             size = MCLBYTES;
    474         }
    475         else if ((hdrlen + ETH_HLEN) < MCLBYTES)
    476         {
    477             size = MCLBYTES;
    478         }
    479         else if((hdrlen + ETH_HLEN) < MJUM9BYTES)
    480         {
    481             size = MJUM9BYTES;
    482         }
    483         else if ((hdrlen + ETH_HLEN) < MJUM16BYTES)
    484         {
    485             size = MJUM16BYTES;
    486         }
    487         else
    488         {
    489             AssertMsgFailed(("Unsupported size"));
    490         }
    491         m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    492 #endif
    493         if (m == NULL)
    494         {
    495 /*          error = ENOBUFS; */
    496             error = 1;
    497             goto out;
    498         }
    499481        m->m_data += if_maxlinkhdr;
    500 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    501482        m->m_pkthdr.header = mtod(m, void *);
    502 #endif
    503483        m->m_len = hdrlen;
    504484    }
    … …  
    648628     * the template, but need a way to checksum without them.
    649629     */
    650 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    651     Assert(m->m_len == (hdrlen + len));
    652 #else
    653630    M_ASSERTPKTHDR(m);
    654631    m->m_pkthdr.header = mtod(m, void *);
    655 #endif
    656632    m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
    657633
    … …  
    666642        error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,
    667643                         so->so_options & SO_DONTROUTE, 0);
    668 #endif
    669 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    670         if(so->so_la != NULL)
    671             m->m_la = so->so_la;
    672644#endif
    673645        error = ip_output(pData, so, m);

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

    r28800 r30016  
    141141    if (m == 0)
    142142    {
    143 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    144         if ((m = m_get(pData)) == NULL)
    145 #else
    146143        if ((m = m_gethdr(pData, M_DONTWAIT, MT_HEADER)) == NULL)
    147 #endif
    148144            return;
    149145#ifdef TCP_COMPAT_42
    … …  
    153149#endif
    154150        m->m_data += if_maxlinkhdr;
    155 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    156151        m->m_pkthdr.header = mtod(m, void *);
    157 #endif
    158152        *mtod(m, struct tcpiphdr *) = *ti;
    159153        ti = mtod(m, struct tcpiphdr *);

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

    r29050 r30016  
    145145    int n = 0;
    146146
    147 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    148     m = m_get(pData);
    149 #else
    150147    m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR);
    151 #endif
    152148    if (!m)
    153149        return -1;
    154150
    155 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    156     memset(m->m_data, 0, m->m_size);
    157     m->m_data += if_maxlinkhdr;
    158 #else
    159151    m->m_data += if_maxlinkhdr;
    160152    m->m_pkthdr.header = mtod(m, void *);
    161 #endif
    162153    tp = (void *)m->m_data;
    163154    m->m_data += sizeof(struct udpiphdr);
    164155
    165156    tp->tp_op = RT_H2N_U16_C(TFTP_OACK);
    166 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    167     n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%s", key) + 1;
    168     n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%u", value) + 1;
    169 #else
    170157    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_TRAILINGSPACE(m), "%s", key) + 1;
    171158    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_TRAILINGSPACE(m), "%u", value) + 1;
    172 #endif
    173159
    174160    saddr.sin_addr = recv_tp->ip.ip_dst;
    … …  
    195181    int nobytes;
    196182
    197 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    198     m = m_get(pData);
    199 #else
    200183    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
    201 #endif
    202184    if (!m)
    203185        return -1;
    204186
    205 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    206     memset(m->m_data, 0, m->m_size);
    207     m->m_data += if_maxlinkhdr;
    208 #else
    209187    m->m_data += if_maxlinkhdr;
    210188    m->m_pkthdr.header = mtod(m, void *);
    211 #endif
    212189    tp = (void *)m->m_data;
    213190    m->m_data += sizeof(struct udpiphdr);
    … …  
    252229        return -1;
    253230
    254 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    255     m = m_get(pData);
    256 #else
    257231    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
    258 #endif
    259232    if (!m)
    260233        return -1;
    261234
    262 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    263     memset(m->m_data, 0, m->m_size);
    264     m->m_data += if_maxlinkhdr;
    265 #else
    266235    m->m_data += if_maxlinkhdr;
    267236    m->m_pkthdr.header = mtod(m, void *);
    268 #endif
    269237    tp = mtod(m, void *);
    270238    m->m_data += sizeof(struct udpiphdr);

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

    r28800 r30016  
    127127    len = RT_N2H_U16((u_int16_t)uh->uh_ulen);
    128128    Assert((ip->ip_len == len));
    129 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    130     Assert((ip->ip_len + iphlen == m->m_len));
    131 #else
    132129    Assert((ip->ip_len + iphlen == m_length(m, NULL)));
    133 #endif
    134130
    135131    if (ip->ip_len != len)
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