VirtualBox

Changeset 23154 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Sep 19, 2009 11:02:11 AM (15 years ago)
Author:
vboxsync
Message:

NAT: BSD mbuf

Location:
trunk/src/VBox/Devices/Network/slirp
Files:
24 edited

Legend:

Unmodified
Added
Removed

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

    r22669 r23154  
    176176    uint8_t *q;
    177177
     178    eh = mtod(m, struct ethhdr *);
     179    memcpy(eh->h_source, bp->bp_hwaddr, ETH_ALEN); /* XXX: if_encap just swap source with dest*/
     180
     181    m->m_data += if_maxlinkhdr; /*reserve ether header */
     182
    178183    rbp = mtod(m, struct bootp_t *);
    179184    memset(rbp, 0, sizeof(struct bootp_t));
    180     eh = mtod(m, struct ethhdr *);
    181     memcpy(eh->h_source, bp->bp_hwaddr, ETH_ALEN); /* XXX: if_encap just swap source with dest*/
    182     m->m_data += if_maxlinkhdr; /*reserve ether header */
    183     rbp = mtod(m, struct bootp_t *);
    184185    rbp->bp_op = BOOTP_REPLY;
    185186    rbp->bp_xid = bp->bp_xid; /* see table 3 of rfc2131*/
    … …  
    607608    if (p == NULL)
    608609        return;
     610#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    609611    if ((m = m_get(pData)) == NULL)
     612#else
     613    if ((m = m_getcl(pData, M_DONTWAIT, MT_HEADER, M_PKTHDR)) == NULL)
     614#endif
    610615    {
    611616        LogRel(("NAT: can't alocate memory for response!\n"));
    … …  
    673678   
    674679
     680#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     681    m->m_pkthdr.header = mtod(m, void *);
     682#endif
    675683    m->m_len = sizeof(struct bootp_t)
    676684             - sizeof(struct ip)

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

    r23141 r23154  
    3434    do {                                                            \
    3535        PDMDrvHlpSTAMRegisterF(pDrvIns,                             \
    36                                &(storage)->Stat ## name,            \
     36                               &(storage)->Stat ## name,   \
    3737                               type,                                \
    3838                               STAMVISIBILITY_ALWAYS,               \

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

    r22873 r23154  
    159159mbufstats(PNATState pData)
    160160{
     161#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    161162    struct mbuf *m;
    162163    int i;
    … …  
    178179    lprint("  %6d mbufs on used list\n",  i);
    179180    lprint("  %6d mbufs queued as packets\n\n", if_queued);
     181#endif
    180182}
    181183

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

    r22894 r23154  
    5757#ifndef _EXT_H_
    5858#define _EXT_H_
     59# define fprintf vbox_slirp_fprintf
     60# define printf vbox_slirp_printf
    5961#ifndef vbox_slirp_printfV
    6062static void vbox_slirp_printV(char *format, va_list args)

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

    r22206 r23154  
    99
    1010
    11 #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
     11#ifndef VBOX_WITH_SLIRP_BSD_MBUF
     12# define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
    1213
    1314static void ifs_insque(struct mbuf *ifm, struct mbuf *ifmhead)
    … …  
    2425    ifm->ifs_next->ifs_prev = ifm->ifs_prev;
    2526}
     27#else
     28#endif
    2629
    2730void
    … …  
    3235    if_queued = 0;
    3336    if_thresh = 10;
     37    if_comp = IF_AUTOCOMP;
     38#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    3439    if_mtu = 1500;
    3540    if_mru = 1500;
    36     if_comp = IF_AUTOCOMP;
    3741    if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;
    3842    if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
    3943/*  sl_compress_init(&comp_s); */
    4044    next_m = &if_batchq;
     45#else
     46    if_mtu = 1500;
     47    if_mru = 1500;
     48    TAILQ_INIT(&if_fastq);
     49    TAILQ_INIT(&if_batchq);
     50    next_m = TAILQ_FIRST(&if_fastq);
     51#endif
    4152}
    4253
    … …  
    6475    DEBUG_ARG("ifm = %lx", (long)ifm);
    6576
     77#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    6678    /*
    6779     * First remove the mbuf from m_usedlist,
    … …  
    7486        ifm->m_flags &= ~M_USEDLIST;
    7587    }
     88#endif
    7689
    7790    /*
    … …  
    8295     * XXX add cache here?
    8396     */
     97#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    8498    for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev)
     99#else
     100    TAILQ_FOREACH_REVERSE(ifq, &if_batchq, if_queue, m_ifq)
     101#endif
    85102    {
    86103        if (so == ifq->ifq_so)
    … …  
    88105            /* A match! */
    89106            ifm->ifq_so = so;
     107#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    90108            ifs_insque(ifm, ifq->ifs_prev);
     109#endif
    91110            goto diddit;
    92111        }
    … …  
    96115    if (so && (so->so_iptos & IPTOS_LOWDELAY))
    97116    {
     117#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    98118        ifq = if_fastq.ifq_prev;
     119#else
     120        ifq = TAILQ_LAST(&if_fastq, if_queue);
     121#endif
    99122        on_fastq = 1;
    100123        /*
    … …  
    105128        {
    106129            ifm->ifq_so = so;
     130#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    107131            ifs_insque(ifm, ifq->ifs_prev);
     132#endif
    108133            goto diddit;
    109134        }
    110135    }
     136#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    111137    else
    112138        ifq = if_batchq.ifq_prev;
    … …  
    116142    ifs_init(ifm);
    117143    insque(pData, ifm, ifq);
     144#else
     145    else
     146    {
     147        TAILQ_INSERT_TAIL(&if_batchq, ifm, m_ifq);
     148        ifq = TAILQ_LAST(&if_batchq, if_queue);
     149    }
     150   
     151    /* queue already created */
     152#endif
    118153
    119154diddit:
    … …  
    136171            && (so->so_nqueued - so->so_queued) >= 3)
    137172        {
     173#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    138174            /* Remove from current queue... */
    139175            remque(pData, ifm->ifs_next);
    … …  
    141177            /* ...And insert in the new.  That'll teach ya! */
    142178            insque(pData, ifm->ifs_next, &if_batchq);
     179#endif
    143180        }
    144181    }
    … …  
    172209{
    173210    struct mbuf *ifm, *ifqt;
     211#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     212    struct if_queue *pqueue = NULL;
     213    ifm = NULL;
     214    ifqt = NULL;
     215#endif
    174216
    175217    DEBUG_CALL("if_start");
    … …  
    187229        }
    188230
     231#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    189232        /*
    190233         * See which queue to get next packet from
    … …  
    215258            ifs_remque(ifm);
    216259        }
     260#else
     261        if (!TAILQ_EMPTY(&if_fastq))
     262        {
     263            pqueue = &if_fastq;
     264        }
     265        else if (!TAILQ_EMPTY(&if_batchq))
     266        {
     267            pqueue = &if_batchq;
     268        }
     269        if (pqueue != NULL) {
     270            ifm = TAILQ_FIRST(pqueue);
     271            TAILQ_REMOVE(pqueue, ifm, m_ifq);
     272            --if_queued;
     273        }
     274#endif
    217275
    218276        /* Update so_queued */

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

    r22897 r23154  
    326326    m->m_len -= hlen;
    327327    m->m_data += hlen;
     328#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    328329    icp = mtod(m, struct icmp *);
     330#else
     331    if (m->m_next != NULL)
     332    {
     333        char *buf = RTMemAlloc(icmplen);
     334        m_copydata(m, 0, icmplen, buf);
     335        icp = (struct icmp *)buf;
     336    }
     337    else
     338    {
     339        icp = mtod(m, struct icmp *);
     340    }
     341#endif
    329342    if (cksum(m, icmplen))
    330343    {
    … …  
    388401                              (struct sockaddr *)&addr, sizeof(addr)) == -1)
    389402                    {
    390                         Log((dfd,"icmp_input udp sendto tx errno = %d-%s\n",
     403                        LogRel((dfd,"icmp_input udp sendto tx errno = %d-%s\n",
    391404                                    errno, strerror(errno)));
    392405                        icmp_error(pData, m, ICMP_UNREACH, ICMP_UNREACH_NET, 0, strerror(errno));
    … …  
    455468            m_freem(pData, m);
    456469    } /* switch */
     470#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     471    if (m->m_next != NULL && icp != NULL)
     472        RTMemFree(icp);
     473#endif
    457474
    458475end_error:
    … …  
    487504    register struct icmp *icp;
    488505    register struct mbuf *m;
    489 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    490     uint8_t *buf; /*(vvl) probably should be used mbuf of corresponded size instead*/
    491 #endif
     506    int new_m_size = 0;
     507    int size = 0;
    492508
    493509    DEBUG_CALL("icmp_error");
    … …  
    495511    DEBUG_ARG("msrc_len = %d", msrc ? msrc->m_len : 0);
    496512#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    497     M_ASSERTPKTHDR(msrc);
     513    if (msrc != NULL)
     514        M_ASSERTPKTHDR(msrc);
    498515#endif
    499516
    … …  
    532549#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    533550    /* make a copy */
    534     if (!(m = m_get(pData)))
     551    m = m_get(pData);
     552#else
     553    new_m_size = sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
     554    if (new_m_size < MSIZE)
     555    {
     556        size = MCLBYTES;
     557    }
     558    else if (new_m_size < MCLBYTES)
     559    {
     560        size = MCLBYTES;
     561    }
     562    else if(new_m_size < MJUM9BYTES)
     563    {
     564        size = MJUM9BYTES;
     565    }
     566    else if (new_m_size < MJUM16BYTES)
     567    {
     568        size = MJUM16BYTES;
     569    }
     570    else
     571    {
     572        AssertMsgFailed(("Unsupported size"));
     573    }
     574    m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
     575#endif
     576    if (m == NULL)
    535577        goto end_error;                    /* get mbuf */
    536     {
    537         int new_m_size;
    538         m->m_data += if_maxlinkhdr;
    539         new_m_size = sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
    540         if (new_m_size > m->m_size)
    541             m_inc(m, new_m_size);
    542     }
     578
     579    m->m_data += if_maxlinkhdr;
     580#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     581    m->m_pkthdr.header = mtod(m, void *);
     582#else
     583    new_m_size = sizeof(struct ip) + ICMP_MINLEN + msrc->m_len + ICMP_MAXDATALEN;
     584    if (new_m_size > m->m_size)
     585        m_inc(m, new_m_size);
     586#endif
    543587
    544588    memcpy(m->m_data, msrc->m_data, msrc->m_len);
    545589    m->m_len = msrc->m_len;                /* copy msrc to m */
    546 #else
    547     if (!(m = m_gethdr(pData, M_DONTWAIT, MT_HEADER)))
    548         goto end_error;                    /* get mbuf */
    549     if (m_append(pData, m, m_length(msrc, NULL), mtod(msrc, const char *)) == 0)
    550     {
    551         m_freem(pData, m);
    552         goto end_error;
    553     }
    554     m->m_pkthdr.header = mtod(m, void *);
    555 #endif
    556590
    557591    /* make the header of the reply packet */
    … …  
    560594
    561595    /* fill in icmp */
    562 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    563596    m->m_data += hlen;
    564597    m->m_len  -= hlen;
    565 #else
    566     m_adj(m, hlen);
    567 #endif
    568598
    569599    icp = mtod(m, struct icmp *);
    … …  
    574604        s_ip_len = ICMP_MAXDATALEN;
    575605
    576 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    577606    m->m_len = ICMP_MINLEN + s_ip_len;     /* 8 bytes ICMP header */
    578 #else
    579     m_adj(m, ICMP_MINLEN);
    580 #endif
    581607
    582608    /* min. size = 8+sizeof(struct ip)+8 */
    … …  
    587613    icp->icmp_seq = 0;
    588614
    589 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    590615    memcpy(&icp->icmp_ip, msrc->m_data, s_ip_len);   /* report the ip packet */
    591 #else
    592     buf = RTMemAlloc(s_ip_len);
    593     if (buf == NULL)
    594     {
    595         m_free(pData, m);
    596         LogRel(("NAT:ICMP: can't allocate intermediate buffer, icmp error wasn't sent\n"));
    597         goto end_error;
    598     }
    599     m_copydata(msrc, 0, s_ip_len, buf);
    600     m_append(pData, m, s_ip_len, buf);
    601 #endif
     616
    602617    HTONS(icp->icmp_ip.ip_len);
    603618    HTONS(icp->icmp_ip.ip_id);

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

    r23005 r23154  
    7272    struct ip *pip = NULL;
    7373
     74#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    7475    if (m->m_la)
    7576        return m->m_la;
    76 
    77 #if 0
    78     pip = mtod(m, struct ip *);
    79     if (pip->ip_p == IPPROTO_UDP) {
    80         udp = (struct udphdr *)((uint8_t *)pip + (pip->ip_hl << 2));
    81         if (   pip->ip_dst.s_addr == htonl(ntohl(special_addr.s_addr) | CTL_DNS)
    82             && htons(udp->uh_dport) == 53)
    83         {
    84             return pData->dns_alias;
    85         }
    86         /* here we can add catch for dhcp and tftp servers */
     77#else
     78    struct m_tag *t;
     79    if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
     80    {
     81        return (struct libalias *)&t[1];
    8782    }
    8883#endif
     84
    8985    return la;
    9086}
    … …  
    9995    register struct ip *ip;
    10096    int hlen = 0;
     97    int mlen = 0;
     98
    10199    STAM_PROFILE_START(&pData->StatIP_input, a);
    102100
    … …  
    116114    }
    117115
    118     if (m->m_len < sizeof(struct ip))
     116    mlen = m->m_len;
     117
     118    if (mlen < sizeof(struct ip))
    119119    {
    120120        ipstat.ips_toosmall++;
    … …  
    168168     * Drop packet if shorter than we expect.
    169169     */
    170     if (m->m_len < ip->ip_len)
     170    if (mlen < ip->ip_len)
    171171    {
    172172        ipstat.ips_tooshort++;
    … …  
    175175
    176176    /* Should drop packet if mbuf too long? hmmm... */
    177     if (m->m_len > ip->ip_len)
     177    if (mlen > ip->ip_len)
    178178        m_adj(m, ip->ip_len - m->m_len);
    179179
    … …  
    371371    }
    372372
     373#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    373374#define GETIP(m)    ((struct ip*)(MBUF_IP_HEADER(m)))
     375#else
     376#define GETIP(m)    ((struct ip*)((m)->m_pkthdr.header))
     377#endif
    374378
    375379

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

    r23007 r23154  
    4646#include "alias.h"
    4747
     48static const uint8_t broadcast_ethaddr[6] =
     49{
     50    0xff, 0xff, 0xff, 0xff, 0xff, 0xff
     51};
     52
    4853static int rt_lookup_in_cache(PNATState pData, uint32_t dst, uint8_t *ether)
    4954{
    5055    int rc = 1;
     56    if (dst == INADDR_BROADCAST)
     57    {
     58        memcpy(ether, broadcast_ethaddr, ETH_ALEN);
     59        return 0;
     60    }
    5161    rc = slirp_arp_lookup_ether_by_ip(pData, dst, ether);
    5262    if (rc == 0)
    … …  
    104114    }
    105115#endif
    106 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    107     M_ASSERTPKTHDR(m);
    108     Assert(m->m_pkthdr.header);
    109     ip = (struct ip *)m->m_pkthdr.header;
    110 #else
    111116    ip = mtod(m, struct ip *);
    112 #endif
    113117    /*
    114118     * Fill in IP header.
    … …  
    149153#else
    150154    /*
    151      * (vvl) Note: Here we should care about dhcp and other services
    152      * aware of ethernet address
     155     * (vvl) Assumption is that m_data points at the IP header and only
     156     * in case of dhcp we know and have header before IP.
    153157     */
    154158    rc = rt_lookup_in_cache(pData, ip->ip_dst.s_addr, eth_dst);
    155159    if (rc != 0)
    156160        goto bad;
     161    eh = (struct ethhdr *)(m->m_data - ETH_HLEN);
    157162#endif
    158163    /*
    … …  
    191196            STAM_PROFILE_STOP(&pData->StatALIAS_output, a);
    192197        }
    193 #ifdef VBOX_WITH_SLIRP_BSD_MBUF
    194         /*todo: make prepend */
    195         m = m_prepend(pData, m, ETH_HLEN, M_DONTWAIT);
    196         Assert(m);
    197         eh = mtod(m, struct ethhdr *);
    198 #endif
     198
    199199        memcpy(eh->h_source, eth_dst, ETH_ALEN);
    200200
    … …  
    225225        struct mbuf **mnext = &m->m_nextpkt;
    226226#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    227         uint8_t buf[len]; /* intermediate buffer we'll use for copy from orriginal packet*/
     227        uint8_t *buf; /* intermediate buffer we'll use for copy from orriginal packet*/
    228228#endif
    229229            {
    230230                int rc;
     231                HTONS(ip->ip_len);
     232                HTONS(ip->ip_off);
     233                ip->ip_sum = 0;
     234                ip->ip_sum = cksum(m, hlen);
    231235#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    232236                rc = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
    … …  
    234238#else
    235239                struct m_tag *t;
     240                char *tmpbuf = NULL;
     241                int tmplen = 0;
     242                if (m->m_next != NULL)
     243                {
     244                    /*we've receives packet in fragments*/
     245                    tmplen = m_length(m, NULL);
     246                    tmpbuf = RTMemAlloc(tmplen);
     247                    Assert(tmpbuf);
     248                    m_copydata(m, 0, tmplen, tmpbuf);
     249                }
     250                else
     251                {
     252                    tmpbuf = mtod(m, char *);
     253                    tmplen = m_length(m, NULL);
     254
     255                }
    236256                if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
    237257                {
    238                     rc = LibAliasOut((struct libalias *)&t[1], mtod(m, char *), m_length(m, NULL));
     258                    rc = LibAliasOut((struct libalias *)&t[1], tmpbuf, tmplen);
    239259                }
    240260                else
    241261                {
    242                     rc = LibAliasOut(pData->proxy_alias, mtod(m, char *),
    243                                      m_length(m, NULL));
     262                    rc = LibAliasOut(pData->proxy_alias, tmpbuf, tmplen);
    244263                }
     264                if (m->m_next != NULL)
     265                {
     266                    if (rc != PKT_ALIAS_IGNORED)
     267                    {
     268                        struct ip *tmpip = (struct ip *)tmpbuf;
     269                        m_copyback(pData, m, 0, ntohs(tmpip->ip_len) + (tmpip->ip_hl << 2), tmpbuf);
     270                    }
     271                    if (tmpbuf != NULL)
     272                        RTMemFree(tmpbuf);
     273                }
    245274                if (rc == PKT_ALIAS_IGNORED)
    246275                {
    … …  
    249278                }
    250279#endif
     280                NTOHS(ip->ip_len);
     281                NTOHS(ip->ip_off);
    251282                Log2(("NAT: LibAlias return %d\n", rc));
    252283        }
    … …  
    264295            m = m_get(pData);
    265296#else
    266             m = m_gethdr(pData, M_DONTWAIT, MT_HEADER);
     297            m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
    267298#endif
    268299            if (m == 0)
    … …  
    272303                goto sendorfree;
    273304            }
    274 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    275305            m->m_data += if_maxlinkhdr;
    276306            mhip = mtod(m, struct ip *);
    277307            *mhip = *ip;
    278 #else
    279             m_copyback(pData, m, 0, mhlen, ip);
     308#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    280309            m->m_pkthdr.header = mtod(m, void *);
    281             mhip = mtod(m, struct ip *);
    282             m_adj(m, mhlen);
    283310#endif
    284311            /* we've calculated eth_dst for first packet */
    … …  
    289316                mhip->ip_hl = mhlen >> 2;
    290317            }
    291 #endif
    292 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    293             m->m_len = mhlen;
    294318#endif
    295319            mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
    … …  
    309333            }
    310334#else
     335            buf = RTMemAlloc(len);
    311336            m_copydata(m0, off, len, buf); /* copy to buffer */
    312             m_append(pData, m, len, buf); /* copy from buffer */
     337            m->m_data += mhlen;
     338            m_copyback(pData, m, 0, len, buf); /* copy from buffer */
     339            m->m_data -= mhlen;
     340            m->m_len += mhlen;
     341            RTMemFree(buf);
     342            m->m_len = ntohs(mhip->ip_len);
    313343#endif
    314344
    … …  
    341371                eh = (struct ethhdr *)MBUF_HEAD(m);
    342372#else
    343                 m = m_prepend(pData, m, ETH_HLEN, M_DONTWAIT);
    344                 Assert(m);
     373                m->m_data -= ETH_HLEN;
    345374                eh = mtod(m, struct ethhdr *);
     375                m->m_data += ETH_HLEN;
    346376#endif
    347377                memcpy(eh->h_source, eth_dst, ETH_ALEN);

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

    r20958 r23154  
    16661666#endif
    16671667
    1668 #ifdef _KERNEL
     1668#if defined(_KERNEL) || (defined(VBOX) && defined(VBOX_WITH_SLIRP_BSD_MBUF))
    16691669/*
    16701670 * m_megapullup() - this function is a big hack.
    … …  
    16801680 */
    16811681struct mbuf *
    1682 m_megapullup(struct mbuf *m, int len) {
     1682#ifndef VBOX
     1683m_megapullup(struct mbuf *m, int len)
     1684#else
     1685m_megapullup(PNATState pData, struct mbuf *m, int len)
     1686#endif
     1687{
    16831688    struct mbuf *mcl;
    16841689   
    … …  
    16941699
    16951700    if (len <= MCLBYTES - RESERVE) {
     1701#ifndef VBOX
    16961702        mcl = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
     1703#else
     1704        mcl = m_getcl(pData, M_DONTWAIT, MT_DATA, M_PKTHDR);
     1705#endif
    16971706    } else if (len < MJUM16BYTES) {
    16981707        int size;
    … …  
    17041713            size = MJUM16BYTES;
    17051714        };
     1715#ifndef VBOX
    17061716        mcl = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
     1717#else
     1718        mcl = m_getjcl(pData, M_DONTWAIT, MT_DATA, M_PKTHDR, size);
     1719#endif
    17071720    } else {
    17081721        goto bad;
    … …  
    17141727    m_copydata(m, 0, len, mtod(mcl, caddr_t));
    17151728    mcl->m_len = mcl->m_pkthdr.len = len;
     1729#ifndef VBOX
    17161730    m_freem(m);
     1731#else
     1732    m_freem(pData, m);
     1733#endif
    17171734 
    17181735    return (mcl);
    17191736bad:
     1737#ifndef VBOX
    17201738    m_freem(m);
     1739#else
     1740    m_freem(pData, m);
     1741#endif
    17211742    return (NULL);
    17221743}

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

    r20958 r23154  
    205205
    206206/* Mbuf helper function. */
     207#ifndef VBOX
    207208struct mbuf    *m_megapullup(struct mbuf *, int);
     209#else
     210struct mbuf    *m_megapullup(PNATState, struct mbuf *, int);
     211#endif
    208212
    209213/*

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

    r21718 r23154  
    175175#else /* !VBOX */
    176176# include <iprt/assert.h>
    177 # include <slirp.h>
    178177# include "alias.h"
    179178# include "alias_local.h"
    180179# include "alias_mod.h"
     180# include <slirp.h>
    181181#endif /* VBOX */
    182182

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

    r22881 r23154  
    8383        uint16_t addr_off = (uint16_t)~0;
    8484       
     85#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    8586        m = dtom(la->pData, hdr);
     87#else
     88        AssertMsgFailed(("Unimplemented"));
     89#endif
    8690        Assert((m));
    8791       

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

    r22013 r23154  
    3737#ifndef _MBUF_H_
    3838#define _MBUF_H_
     39#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    3940
    4041#define m_freem m_free
    … …  
    150151#define MBUF_IP_HEADER(m) (caddr_t)(MBUF_HEAD(m) + if_maxlinkhdr)
    151152
     153#else
     154# include "bsd/sys/mbuf.h"
    152155#endif
     156#endif

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

    r22942 r23154  
    238238    zone->pfAlloc = slirp_uma_alloc;
    239239    zone->pfFree = slirp_uma_free;
     240    zone->size = master->size;
    240241    return zone;
    241242}

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

    r22576 r23154  
    7777{
    7878    int ret = 0;
     79#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     80    int mlen = 0;
     81    uint8_t *buf = NULL;
     82#endif
    7983
    8084    STAM_PROFILE_START(&pData->StatIOSBAppend_pf, a);
    … …  
    8690    STAM_COUNTER_INC(&pData->StatIOSBAppend);
    8791    /* Shouldn't happen, but...  e.g. foreign host closes connection */
     92#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    8893    if (m->m_len <= 0)
     94#else
     95    mlen = m_length(m, NULL);
     96    if (mlen <= 0)
     97#endif
    8998    {
    9099        STAM_COUNTER_INC(&pData->StatIOSBAppend_zm);
    … …  
    109118     * ottherwise it'll arrive out of order, and hence corrupt
    110119     */
    111     if (!so->so_rcv.sb_cc)
     120#ifndef VBOX_WITH_SLIRP_BSD_MBUF
     121    if(!so->so_rcv.sb_cc)
    112122        ret = send(so->s, m->m_data, m->m_len, 0);
     123#else
     124    buf = RTMemAlloc(mlen);
     125    if (buf == NULL)
     126    {
     127        ret = 0;
     128        goto no_sent;
     129    }   
     130    m_copydata(m, 0, mlen, buf);
     131    if(!so->so_rcv.sb_cc)
     132        ret = send(so->s, buf, mlen, 0);
     133    RTMemFree(buf);
     134no_sent:
     135#endif
    113136
    114137    if (ret <= 0)
    … …  
    125148        goto done;
    126149    }
     150#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    127151    else if (ret != m->m_len)
     152#else
     153    else if (ret != mlen)
     154#endif
    128155    {
    129156        STAM_COUNTER_INC(&pData->StatIOSBAppend_wp);
    … …  
    132159         * sbappendsb the rest
    133160         */
     161#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    134162        m->m_len -= ret;
    135163        m->m_data += ret;
     164#else
     165        m_adj(m, ret);
     166#endif
    136167        sbappendsb(pData, &so->so_rcv, m);
    137168        STAM_PROFILE_STOP(&pData->StatIOSBAppend_pf_wp, a);
    … …  
    154185    int len, n,  nn;
    155186
     187#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    156188    len = m->m_len;
     189#else
     190    len = m_length(m, NULL);
     191#endif
    157192
    158193    STAM_COUNTER_INC(&pData->StatIOSBAppendSB);
    … …  
    163198        if (n > len)
    164199            n = len;
     200#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    165201        memcpy(sb->sb_wptr, m->m_data, n);
     202#else
     203        m_copydata(m, 0, n, sb->sb_wptr);
     204#endif
    166205    }
    167206    else
    … …  
    172211        if (n > len)
    173212            n = len;
     213#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    174214        memcpy(sb->sb_wptr, m->m_data, n);
     215#else
     216        m_copydata(m, 0, n, sb->sb_wptr);
     217#endif
    175218        len -= n;
    176219        if (len)
    … …  
    180223            if (nn > len)
    181224                nn = len;
     225#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    182226            memcpy(sb->sb_data, m->m_data+n, nn);
     227#else
     228            m_copydata(m, n, nn, sb->sb_wptr);
     229#endif
    183230            n += nn;
    184231        }

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

    r20377 r23154  
    2929void sbappendsb (PNATState, struct sbuf *, struct mbuf *);
    3030void sbcopy (struct sbuf *, int, int, char *);
    31 
    3231#endif

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

    r22941 r23154  
    576576        fNATfailed = 1;
    577577
     578#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    578579    dnsproxy_init(pData);
     580#endif
    579581
    580582    getouraddr(pData);
    … …  
    13801382            rah = mtod(mr, struct arphdr *);
    13811383#else
    1382             mr = m_gethdr(pData, M_NOWAIT, MT_HEADER);
     1384            mr = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
     1385            reh = mtod(mr, struct ethhdr *);
     1386            mr->m_data += ETH_HLEN;
    13831387            rah = mtod(mr, struct arphdr *);
     1388            mr->m_len = sizeof(struct arphdr);
    13841389            Assert(mr);
    1385             mr->m_pkthdr.len = mr->m_len = sizeof(* rah);
    1386             mr = m_prepend(pData, mr, ETH_HLEN, M_DONTWAIT);
    1387             reh = mtod(mr, struct ethhdr *);
    13881390            memcpy(reh->h_source, eh->h_source, ETH_ALEN); /* XXX: if_encap will swap src and dst*/
    13891391#endif
    … …  
    14721474    static bool fWarnedIpv6;
    14731475    struct ethhdr *eh = (struct ethhdr*)pkt;
     1476#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     1477    int size = 0;
     1478#endif
    14741479
    14751480    Log2(("NAT: slirp_input %d\n", pkt_len));
    … …  
    14921497    m = m_get(pData);
    14931498#else
    1494     m = m_gethdr(pData, M_NOWAIT, MT_HEADER);
     1499    if (pkt_len < MSIZE)
     1500    {
     1501        size = MCLBYTES;
     1502    }
     1503    else if (pkt_len < MCLBYTES)
     1504    {
     1505        size = MCLBYTES;
     1506    }
     1507    else if(pkt_len < MJUM9BYTES)
     1508    {
     1509        size = MJUM9BYTES;
     1510    }
     1511    else if (pkt_len < MJUM16BYTES)
     1512    {
     1513        size = MJUM16BYTES;
     1514    }
     1515    else
     1516    {
     1517        AssertMsgFailed(("Unsupported size"));
     1518    }
     1519    m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    14951520#endif
    14961521    if (!m)
    … …  
    15061531    if (M_FREEROOM(m) < pkt_len)
    15071532       m_inc(m, pkt_len);
     1533#endif
    15081534
    15091535    m->m_len = pkt_len ;
    15101536    memcpy(m->m_data, pkt, pkt_len);
    1511 #else
    1512     if (m_append(pData, m, pkt_len, pkt) != 1)
    1513     {
    1514         AssertMsgFailed(("Can't append incommin to mbuf"));
    1515         RTMemFree(pkt);
    1516         m_free(pData, m);
    1517     }
    1518 #endif
    1519 
    1520 #if 1
     1537
    15211538    if (pData->port_forwarding_activated == 0)
    15221539        activate_port_forwarding(pData, mtod(m, struct ethhdr *));
    1523 #endif
    15241540
    15251541    proto = ntohs(*(uint16_t *)(pkt + 12));
    … …  
    15761592#else
    15771593    M_ASSERTPKTHDR(m);
     1594    m->m_data -= ETH_HLEN;
     1595    m->m_len += ETH_HLEN;
    15781596    eh = mtod(m, struct ethhdr *);
    15791597#endif
    … …  
    15931611    mlen = m->m_len;
    15941612#else
    1595     mlen = m_length(pData, m);
     1613    mlen = m_length(m, NULL);
    15961614#endif
    15971615    buf = RTMemAlloc(mlen);
    … …  
    19701988    struct arphdr *ahdr;
    19711989
     1990#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    19721991    m = m_get(pData);
     1992#else
     1993    m = m_getcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR);
     1994#endif
    19731995    if (m == NULL)
    19741996    {
    … …  
    19882010    memset(ahdr->ar_tha, 0xff, ETH_ALEN); /*broadcast*/
    19892011    *(uint32_t *)ahdr->ar_tip = dst;
     2012#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    19902013    m->m_data += if_maxlinkhdr;
    19912014    m->m_len = sizeof(struct arphdr);
     2015#else
     2016    /* warn!!! should falls in mbuf minimal size */
     2017    m->m_len = sizeof(struct arphdr) + ETH_HLEN;
     2018#endif
    19922019    if_encap(pData, ETH_P_ARP, m);
    19932020    LogRel(("NAT: ARP request sent\n"));

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

    r23135 r23154  
    355355int sscanf(const char *s, const char *format, ...);
    356356
    357 #if defined(VBOX_SLIRP_ALIAS)
     357#if defined(VBOX_SLIRP_ALIAS) || defined(VBOX_SLIRP_BSD)
    358358
    359359# define ip_next(ip) (void *)((uint8_t *)(ip) + ((ip)->ip_hl << 2))
    … …  
    385385# define stderr NULL
    386386# define stdout NULL
     387
    387388# ifdef DEBUG
    388389#  define LIBALIAS_DEBUG
    389390# endif
    390 # ifdef fprintf
    391 #  undef fprintf
    392 # endif
    393 # ifdef fflush
    394 #  undef fflush
    395 # endif
    396 # ifdef printf
    397 #  undef printf
    398 # endif
     391
    399392# define fflush(x) do{} while(0)
    400 # define fprintf vbox_slirp_fprintf
    401 # define printf vbox_slirp_printf
    402393# include "ext.h"
    403394#endif /*VBOX_SLIRP_ALIAS*/

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

    r23135 r23154  
    100100typedef struct NATState
    101101{
     102#define PROFILE_COUNTER(name, dsc)     STAMPROFILE Stat ## name
     103#define COUNTING_COUNTER(name, dsc)    STAMCOUNTER Stat ## name
     104#include "counters.h"
    102105    /* Stuff from boot.c */
    103106    void *pbootp_clients;
    … …  
    301304    struct proto_handler *nbt_module;
    302305    struct proto_handler *dns_module;
    303 
    304 #define PROFILE_COUNTER(name, dsc)     STAMPROFILE Stat ## name
    305 #define COUNTING_COUNTER(name, dsc)    STAMCOUNTER Stat ## name
    306 
    307 #include "counters.h"
    308306
    309307} NATState;

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

    r23004 r23154  
    566566        u_long n = 0;
    567567#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    568         uint8_t *buffer;
     568        int size;
    569569#endif
    570570
    … …  
    610610                    m->m_len, errno, strerror(errno)));
    611611#else
    612         if (!(m = m_gethdr(pData, M_NOWAIT, MT_HEADER)))
    613         {
    614             SOCKET_UNLOCK(so);
    615             return;
    616         }
    617612        /*How many data has been received ?*/
    618613        /*
    … …  
    621616        * 3. attach buffer to allocated header mbuf
    622617        */
    623         ioctlsocket(so->s, FIONREAD, &n);
    624         Assert(n > 0);
    625         buffer = RTMemAlloc(n);
    626         Assert(buffer);
    627         len = recvfrom(so->s, buffer, n, 0,
     618        static int signaled = 0;
     619        int rc = ioctlsocket(so->s, FIONREAD, &n);
     620       
     621        if (rc == -1 && signaled == 0)
     622        {
     623            LogRel(("NAT: can't fetch amount of bytes on socket %R[natsock], so message will be truncated.\n", so));
     624            signaled = 1;
     625        }
     626
     627        len = sizeof(struct udpiphdr) + ETH_HLEN;
     628        len += n;
     629       
     630        if (len < MSIZE)
     631        {
     632            size = MCLBYTES;
     633        }
     634        else if (len < MCLBYTES)
     635        {
     636            size = MCLBYTES;
     637        }
     638        else if(len < MJUM9BYTES)
     639        {
     640            size = MJUM9BYTES;
     641        }
     642        else if (len < MJUM16BYTES)
     643        {
     644            size = MJUM16BYTES;
     645        }
     646        else
     647        {
     648            AssertMsgFailed(("Unsupported size"));
     649        }
     650        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
     651        m->m_data += ETH_HLEN;
     652        m->m_pkthdr.header = mtod(m, void *);
     653        m->m_data += sizeof(struct udpiphdr);
     654        len = recvfrom(so->s, mtod(m, char *), n, 0,
    628655                            (struct sockaddr *)&addr, &addrlen);
     656        m->m_len = len;
    629657        /* @todo (r=vvl) check which flags and type should be passed */
    630         if (len > 0)
    631             m_append(pData, m, len, buffer);
    632         RTMemFree(buffer);
    633658#endif
    634659        if(len < 0)
    … …  
    663688             *  Note: Here we can't check if dnsproxy's sent initial request
    664689             */
     690#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    665691            if (so->so_fport == htons(53))
    666692                dnsproxy_answer(pData, so, m);
     693#endif
    667694
    668695#if 0
    … …  
    10561083    /* saves original ip header and options */
    10571084    memcpy(m->m_data + original_hlen, buff + hlen, len - hlen);
     1085#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    10581086    m->m_len = len - hlen + original_hlen;
    10591087    ip->ip_len = m->m_len;
     1088#else
     1089    ip->ip_len = m_length(m, NULL);
     1090#endif
    10601091    ip->ip_p = IPPROTO_ICMP; /* the original package could be whatever, but we're response via ICMP*/
    10611092

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

    r15054 r23154  
    116116 * We make this 1460 because we only care about Ethernet in the qemu context.
    117117 */
     118#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    118119#define TCP_MSS 1460
     120#else
     121#define TCP_MSS (if_mtu - 80)
     122#endif
    119123
    120124#define TCP_MAXWIN      65535   /* largest value for (unscaled) window */

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

    r22896 r23154  
    8181    unsigned optlen, hdrlen;
    8282    int idle, sendalot;
     83    int size;
    8384
    8485    DEBUG_CALL("tcp_output");
    … …  
    374375        m = m_get(pData);
    375376#else
    376         m = m_gethdr(pData, M_NOWAIT, MT_HEADER);
    377         /* @todo (r=vvl) should we append other bufs here ???*/
     377        if ((len + hdrlen + ETH_HLEN) < MSIZE)
     378        {
     379            size = MCLBYTES;
     380        }
     381        else if ((len + hdrlen + ETH_HLEN) < MCLBYTES)
     382        {
     383            size = MCLBYTES;
     384        }
     385        else if((len + hdrlen + ETH_HLEN) < MJUM9BYTES)
     386        {
     387            size = MJUM9BYTES;
     388        }
     389        else if ((len + hdrlen + ETH_HLEN) < MJUM16BYTES)
     390        {
     391            size = MJUM16BYTES;
     392        }
     393        else
     394        {
     395            AssertMsgFailed(("Unsupported size"));
     396        }
     397        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
    378398#endif
    379399        if (m == NULL)
    … …  
    383403            goto out;
    384404        }
    385 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    386405        m->m_data += if_maxlinkhdr;
     406#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     407        m->m_pkthdr.header = mtod(m, void *);
     408#endif
    387409        m->m_len = hdrlen;
    388 #endif
    389410
    390411        /*
    … …  
    396417        {
    397418#endif
    398 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    399419            sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
    400420            m->m_len += len;
    401 #else
    402             sbcopy(pData, &so->so_snd, off, (int) len, m);
    403             m = m_prepend(pData, m, sizeof (struct tcpiphdr), M_DONTWAIT);
    404 #endif
    405421#if 0
    406422        }
    … …  
    440456            goto out;
    441457        }
    442         m->m_data += if_maxlinkhdr;
    443         m->m_len = hdrlen;
    444458#else
    445         m = m_gethdr(pData, M_NOWAIT, MT_HEADER);
     459        if ((hdrlen + ETH_HLEN) < MSIZE)
     460        {
     461            size = MCLBYTES;
     462        }
     463        else if ((hdrlen + ETH_HLEN) < MCLBYTES)
     464        {
     465            size = MCLBYTES;
     466        }
     467        else if((hdrlen + ETH_HLEN) < MJUM9BYTES)
     468        {
     469            size = MJUM9BYTES;
     470        }
     471        else if ((hdrlen + ETH_HLEN) < MJUM16BYTES)
     472        {
     473            size = MJUM16BYTES;
     474        }
     475        else
     476        {
     477            AssertMsgFailed(("Unsupported size"));
     478        }
     479        m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
     480#endif
    446481        if (m == NULL)
    447482        {
    … …  
    450485            goto out;
    451486        }
    452 #endif
    453     }
    454 
    455 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
     487        m->m_data += if_maxlinkhdr;
     488#ifdef VBOX_WITH_SLIRP_BSD_MBUF
     489        m->m_pkthdr.header = mtod(m, void *);
     490#endif
     491        m->m_len = hdrlen;
     492    }
     493
    456494    ti = mtod(m, struct tcpiphdr *);
    457495
    458496    memcpy((caddr_t)ti, &tp->t_template, sizeof (struct tcpiphdr));
    459 #else
    460     /*already copied header from template */
    461 
    462     m_copyback(pData, m, 0, sizeof (struct tcpiphdr), &tp->t_template);
    463     ti = mtod(m, struct tcpiphdr *);
    464 #endif
    465497
    466498    /*
    … …  
    493525    if (optlen)
    494526    {
    495 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
    496527        memcpy((caddr_t)(ti + 1), (caddr_t)opt, optlen);
    497 #else
    498         m_append(pData, m,  optlen, opt);
    499 #endif
    500528        ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
    501529    }
    … …  
    610638#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    611639    Assert(m->m_len == (hdrlen + len));
    612     m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
    613640#else
    614641    M_ASSERTPKTHDR(m);
    615642    m->m_pkthdr.header = mtod(m, void *);
    616643#endif
    617 
    618     {
    619 #ifndef VBOX_WITH_SLIRP_BSD_MBUF
     644    m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
     645
     646    {
    620647        ((struct ip *)ti)->ip_len = m->m_len;
    621 #else
    622        ((struct ip *)ti)->ip_len = m_length(m, NULL);
    623 #endif
    624648        ((struct ip *)ti)->ip_ttl = ip_defttl;
    625649       ((struct ip *)ti)->ip_tos = so->so_iptos;

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

    r22664 r23154  
    122122    if (m == 0)
    123123    {
     124#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    124125        if ((m = m_get(pData)) == NULL)
     126#else
     127        if ((m = m_gethdr(pData, M_DONTWAIT, MT_HEADER)) == NULL)
     128#endif
    125129            return;
    126130#ifdef TCP_COMPAT_42

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

    r22976 r23154  
    180180     *  handle TFTP
    181181     */
     182#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    182183    if (   ntohs(uh->uh_dport) == TFTP_SERVER
    183184        && CTL_CHECK(ntohl(ip->ip_dst.s_addr), CTL_TFTP))
    … …  
    186187        goto done;
    187188    }
     189#endif
    188190
    189191    /*
    … …  
    292294    }
    293295
    294     m_free(pData, so->so_m);   /* used for ICMP if error on sorecvfrom */
     296    if (so->so_m)
     297        m_free(pData, so->so_m);   /* used for ICMP if error on sorecvfrom */
    295298
    296299    /* restore the orig mbuf packet */
    … …  
    340343    memset(ui->ui_x1, 0, 9);
    341344    ui->ui_pr = IPPROTO_UDP;
    342     ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
     345    ui->ui_len = htons(m->m_len - sizeof(struct ip));
    343346    /* XXXXX Check for from-one-location sockets, or from-any-location sockets */
    344347    ui->ui_src = saddr->sin_addr;
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