VirtualBox

Changeset 25822 in vbox for trunk/src/VBox/Devices/Network


Ignore:
Timestamp:
Jan 14, 2010 9:09:04 AM (15 years ago)
Author:
vboxsync
Message:

NAT: -Wshadow fixes. Use RT_N2H and RT_H2N instead of ntoh and hton because the latter trigger this warning as well.

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

Legend:

Unmodified
Added
Removed

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

    r25362 r25822  
    8888        return NULL;
    8989
    90     paddr->s_addr = htonl(ntohl(pData->special_addr.s_addr) | (bc->number + START_ADDR));
     90    paddr->s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | (bc->number + START_ADDR));
    9191    bc->addr.s_addr = paddr->s_addr;
    9292    return bc;
    … …  
    167167            bc = &bootp_clients[i];
    168168            bc->allocated = 1;
    169             paddr->s_addr = htonl(ntohl(pData->special_addr.s_addr) | (i + START_ADDR));
     169            paddr->s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | (i + START_ADDR));
    170170            return bc;
    171171        }
    … …  
    192192    rbp->bp_giaddr.s_addr = bp->bp_giaddr.s_addr;
    193193#if 0 /*check flags*/
    194     saddr.sin_port = htons(BOOTP_SERVER);
    195     daddr.sin_port = htons(BOOTP_CLIENT);
     194    saddr.sin_port = RT_H2N_U16_C(BOOTP_SERVER);
     195    daddr.sin_port = RT_H2N_U16_C(BOOTP_CLIENT);
    196196#endif
    197197    rbp->bp_htype = 1;
    … …  
    220220    int added = 0;
    221221    uint8_t *q_dns_header = NULL;
    222     uint32_t lease_time = htonl(LEASE_TIME);
    223     uint32_t netmask = htonl(pData->netmask);
     222    uint32_t lease_time = RT_H2N_U32_C(LEASE_TIME);
     223    uint32_t netmask = RT_H2N_U32(pData->netmask);
    224224
    225225    rbp = mtod(m, struct bootp_t *);
    … …  
    244244    }
    245245#ifndef VBOX_WITH_NAT_SERVICE
    246     saddr.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     246    saddr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    247247#else
    248248    saddr.s_addr = pData->special_addr.s_addr;
    … …  
    274274    if (pData->use_dns_proxy || pData->use_host_resolver)
    275275    {
    276         uint32_t addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_DNS);
     276        uint32_t addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_DNS);
    277277        FILL_BOOTP_EXT(q, RFC1533_DNS, 4, &addr);
    278278        goto skip_dns_servers;
    … …  
    441441            else
    442442            {
    443                if ((bp->bp_ciaddr.s_addr & htonl(pData->netmask)) != pData->special_addr.s_addr)
     443               if ((bp->bp_ciaddr.s_addr & RT_H2N_U32(pData->netmask)) != pData->special_addr.s_addr)
    444444               {
    445445                   LogRel(("NAT: Client %R[IP4] requested IP -- sending NAK\n", &bp->bp_ciaddr));
    … …  
    465465            Assert(req_ip != NULL);
    466466            ui32 = *(uint32_t *)(req_ip + 2);
    467             if ((ui32 & htonl(pData->netmask)) != pData->special_addr.s_addr)
     467            if ((ui32 & RT_H2N_U32(pData->netmask)) != pData->special_addr.s_addr)
    468468            {
    469469                LogRel(("NAT: address %R[IP4] has been requested -- sending NAK\n", &ui32));
    … …  
    712712
    713713#ifndef VBOX_WITH_NAT_SERVICE
    714     saddr.sin_addr.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     714    saddr.sin_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    715715#else
    716716    saddr.sin_addr.s_addr = pData->special_addr.s_addr;
    … …  
    733733    else
    734734        daddr.sin_addr.s_addr = rbp->bp_yiaddr.s_addr; /*unicast requested by client*/
    735     saddr.sin_port = htons(BOOTP_SERVER);
    736     daddr.sin_port = htons(BOOTP_CLIENT);
     735    saddr.sin_port = RT_H2N_U16_C(BOOTP_SERVER);
     736    daddr.sin_port = RT_H2N_U16_C(BOOTP_CLIENT);
    737737    udp_output2(pData, NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
    738738}

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

    r23466 r25822  
    207207        buff[17] = 0;
    208208        lprint("%s %3d   %15s %5d ",
    209                buff, so->s, inet_ntoa(so->so_laddr), ntohs(so->so_lport));
     209               buff, so->s, inet_ntoa(so->so_laddr), RT_N2H_U16(so->so_lport));
    210210        lprint("%15s %5d %5d %5d\n",
    211                 inet_ntoa(so->so_faddr), ntohs(so->so_fport),
     211                inet_ntoa(so->so_faddr), RT_N2H_U16(so->so_fport),
    212212                so->so_rcv.sb_cc, so->so_snd.sb_cc);
    213213    LOOP_LABEL(tcp, so, so_next);
    … …  
    221221        buff[17] = 0;
    222222        lprint("%s %3d  %15s %5d  ",
    223                 buff, so->s, inet_ntoa(so->so_laddr), ntohs(so->so_lport));
     223                buff, so->s, inet_ntoa(so->so_laddr), RT_N2H_U16(so->so_lport));
    224224        lprint("%15s %5d %5d %5d\n",
    225                 inet_ntoa(so->so_faddr), ntohs(so->so_fport),
     225                inet_ntoa(so->so_faddr), RT_N2H_U16(so->so_fport),
    226226                so->so_rcv.sb_cc, so->so_snd.sb_cc);
    227227    LOOP_LABEL(udp, so, so_next);
    … …  
    240240    AssertReturn(strcmp(pszType, "IP4") == 0, 0);
    241241
    242     ip = ntohl(*(uint32_t*)pvValue);
     242    ip = RT_N2H_U32(*(uint32_t*)pvValue);
    243243    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, IP4_ADDR_PRINTF_FORMAT,
    244244           IP4_ADDR_PRINTF_DECOMP(ip));
    … …  
    292292
    293293    in_addr = (struct sockaddr_in *)&addr;
    294     ip = ntohl(so->so_faddr.s_addr);
     294    ip = RT_N2H_U32(so->so_faddr.s_addr);
    295295    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "socket %4d:(proto:%u) "
    296296            "state=%04x ip=" IP4_ADDR_PRINTF_FORMAT ":%d "
    297297            "name=" IP4_ADDR_PRINTF_FORMAT ":%d",
    298298            so->s, so->so_type, so->so_state, IP4_ADDR_PRINTF_DECOMP(ip),
    299             ntohs(so->so_fport),
    300             IP4_ADDR_PRINTF_DECOMP(ntohl(in_addr->sin_addr.s_addr)),
    301             ntohs(in_addr->sin_port));
     299            RT_N2H_U16(so->so_fport),
     300            IP4_ADDR_PRINTF_DECOMP(RT_N2H_U32(in_addr->sin_addr.s_addr)),
     301            RT_N2H_U16(in_addr->sin_port));
    302302}
    303303

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

    r17191 r25822  
    5555#else
    5656# ifndef NTOHL
    57 #  define NTOHL(d) ((d) = ntohl((d)))
     57#  define NTOHL(d) ((d) = RT_N2H_U32((d)))
    5858# endif
    5959# ifndef NTOHS
    60 #  define NTOHS(d) ((d) = ntohs((u_int16_t)(d)))
     60#  define NTOHS(d) ((d) = RT_N2H_U16((u_int16_t)(d)))
    6161# endif
    6262# ifndef HTONL
    63 #  define HTONL(d) ((d) = htonl((d)))
     63#  define HTONL(d) ((d) = RT_H2N_U32((d)))
    6464# endif
    6565# ifndef HTONS
    66 #  define HTONS(d) ((d) = htons((u_int16_t)(d)))
     66#  define HTONS(d) ((d) = RT_H2N_U16((u_int16_t)(d)))
    6767# endif
    6868#endif

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

    r25265 r25822  
    372372#endif
    373373                addr.sin_family = AF_INET;
    374                 if ((ip->ip_dst.s_addr & htonl(pData->netmask)) == pData->special_addr.s_addr)
     374                if ((ip->ip_dst.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
    375375                {
    376376                    /* It's an alias */
    377                     switch (ntohl(ip->ip_dst.s_addr) & ~pData->netmask)
     377                    switch (RT_N2H_U32(ip->ip_dst.s_addr) & ~pData->netmask)
    378378                    {
    379379                        case CTL_DNS:

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

    r25799 r25822  
    102102    DEBUG_ARG("m = %lx", (long)m);
    103103    ip = mtod(m, struct ip *);
    104     Log2(("ip_dst=%R[IP4](len:%d) m_len = %d", &ip->ip_dst, ntohs(ip->ip_len), m->m_len));
    105     Log2(("ip_dst=%R[IP4](len:%d) m_len = %d\n", &ip->ip_dst, ntohs(ip->ip_len), m->m_len));
     104    Log2(("ip_dst=%R[IP4](len:%d) m_len = %d", &ip->ip_dst, RT_N2H_U16(ip->ip_len), m->m_len));
     105    Log2(("ip_dst=%R[IP4](len:%d) m_len = %d\n", &ip->ip_dst, RT_N2H_U16(ip->ip_len), m->m_len));
    106106
    107107    ipstat.ips_total++;
    … …  
    112112        STAM_PROFILE_STOP(&pData->StatALIAS_input, b);
    113113        Log2(("NAT: LibAlias return %d\n", rc));
    114         if (m->m_len != ntohs(ip->ip_len))
    115         {
    116             m->m_len = ntohs(ip->ip_len);
    117         }
     114        if (m->m_len != RT_N2H_U16(ip->ip_len))
     115            m->m_len = RT_N2H_U16(ip->ip_len);
    118116    }
    119117
    … …  
    291289         * before proceeding further
    292290         */
    293         struct ipq_t *q = TAILQ_LAST(head, ipqhead);
    294         if (q == NULL)
     291        struct ipq_t *pHead = TAILQ_LAST(head, ipqhead);
     292        if (pHead == NULL)
    295293        {
    296294            /* gak */
    297295            for (i = 0; i < IPREASS_NHASH; i++)
    298296            {
    299                 struct ipq_t *r = TAILQ_LAST(&ipq[i], ipqhead);
    300                 if (r)
     297                struct ipq_t *pTail = TAILQ_LAST(&ipq[i], ipqhead);
     298                if (pTail)
    301299                {
    302                     ipstat.ips_fragtimeout += r->ipq_nfrags;
    303                     ip_freef(pData, &ipq[i], r);
     300                    ipstat.ips_fragtimeout += pTail->ipq_nfrags;
     301                    ip_freef(pData, &ipq[i], pTail);
    304302                    break;
    305303                }
    … …  
    308306        else
    309307        {
    310             ipstat.ips_fragtimeout += q->ipq_nfrags;
    311             ip_freef(pData, head, q);
     308            ipstat.ips_fragtimeout += pHead->ipq_nfrags;
     309            ip_freef(pData, head, pHead);
    312310        }
    313311    }

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

    r25265 r25822  
    128128    ip->ip_v = IPVERSION;
    129129    ip->ip_off &= IP_DF;
    130     ip->ip_id = htons(ip_currid++);
     130    ip->ip_id = RT_H2N_U16(ip_currid++);
    131131    ip->ip_hl = hlen >> 2;
    132132    ipstat.ips_localout++;
    … …  
    175175    if ((u_int16_t)ip->ip_len <= if_mtu)
    176176    {
    177         ip->ip_len = htons((u_int16_t)ip->ip_len);
    178         ip->ip_off = htons((u_int16_t)ip->ip_off);
     177        ip->ip_len = RT_H2N_U16((u_int16_t)ip->ip_len);
     178        ip->ip_off = RT_H2N_U16((u_int16_t)ip->ip_off);
    179179        ip->ip_sum = 0;
    180180        ip->ip_sum = cksum(m, hlen);
    … …  
    182182        {
    183183#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    184             STAM_PROFILE_START(&pData->StatALIAS_output, a);
     184            STAM_PROFILE_START(&pData->StatALIAS_output, b);
    185185            rc = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
    186186                mtod(m, char *), m->m_len);
    … …  
    188188#else
    189189            struct m_tag *t;
    190             STAM_PROFILE_START(&pData->StatALIAS_output, a);
     190            STAM_PROFILE_START(&pData->StatALIAS_output, b);
    191191            if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
    192192                rc = LibAliasOut((struct libalias *)&t[1], mtod(m, char *),
    … …  
    202202            }
    203203#endif
    204             STAM_PROFILE_STOP(&pData->StatALIAS_output, a);
     204            STAM_PROFILE_STOP(&pData->StatALIAS_output, b);
    205205        }
    206206
    … …  
    245245            int tmplen = 0;
    246246#endif
    247             int rc;
     247            int rcLa;
    248248            HTONS(ip->ip_len);
    249249            HTONS(ip->ip_off);
    … …  
    251251            ip->ip_sum = cksum(m, hlen);
    252252#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    253             rc = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
    254                               mtod(m, char *), m->m_len);
     253            rcLa = LibAliasOut((m->m_la ? m->m_la : pData->proxy_alias),
     254                                mtod(m, char *), m->m_len);
    255255#else
    256256            if (m->m_next != NULL)
    … …  
    270270
    271271            if (t = m_tag_find(m, PACKET_TAG_ALIAS, NULL) != 0)
    272                 rc = LibAliasOut((struct libalias *)&t[1], tmpbuf, tmplen);
     272                rcLa = LibAliasOut((struct libalias *)&t[1], tmpbuf, tmplen);
    273273            else
    274                 rc = LibAliasOut(pData->proxy_alias, tmpbuf, tmplen);
     274                rcLa = LibAliasOut(pData->proxy_alias, tmpbuf, tmplen);
    275275
    276276            if (m->m_next != NULL)
    277277            {
    278                 if (rc != PKT_ALIAS_IGNORED)
     278                if (rcLa != PKT_ALIAS_IGNORED)
    279279                {
    280280                    struct ip *tmpip = (struct ip *)tmpbuf;
    281                     m_copyback(pData, m, 0, ntohs(tmpip->ip_len) + (tmpip->ip_hl << 2), tmpbuf);
     281                    m_copyback(pData, m, 0, RT_N2H_U16(tmpip->ip_len) + (tmpip->ip_hl << 2), tmpbuf);
    282282                }
    283283                if (tmpbuf != NULL)
    284284                    RTMemFree(tmpbuf);
    285285            }
    286             if (rc == PKT_ALIAS_IGNORED)
     286            if (rcLa == PKT_ALIAS_IGNORED)
    287287            {
    288288                Log(("NAT: packet was droppped\n"));
    … …  
    292292            NTOHS(ip->ip_len);
    293293            NTOHS(ip->ip_off);
    294             Log2(("NAT: LibAlias return %d\n", rc));
     294            Log2(("NAT: LibAlias return %d\n", rcLa));
    295295        }
    296296
    … …  
    337337            else
    338338                mhip->ip_off |= IP_MF;
    339             mhip->ip_len = htons((u_int16_t)(len + mhlen));
     339            mhip->ip_len = RT_H2N_U16((u_int16_t)(len + mhlen));
    340340
    341341#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    … …  
    353353            m->m_len += mhlen;
    354354            RTMemFree(buf);
    355             m->m_len += ntohs(mhip->ip_len);
    356 #endif
    357 
    358             mhip->ip_off = htons((u_int16_t)mhip->ip_off);
     355            m->m_len += RT_N2H_U16(mhip->ip_len);
     356#endif
     357
     358            mhip->ip_off = RT_H2N_U16((u_int16_t)mhip->ip_off);
    359359            mhip->ip_sum = 0;
    360360            mhip->ip_sum = cksum(m, mhlen);
    … …  
    369369        m = m0;
    370370        m_adj(m, hlen + firstlen - (u_int16_t)ip->ip_len);
    371         ip->ip_len = htons((u_int16_t)m->m_len);
    372         ip->ip_off = htons((u_int16_t)(ip->ip_off | IP_MF));
     371        ip->ip_len = RT_H2N_U16((u_int16_t)m->m_len);
     372        ip->ip_off = RT_H2N_U16((u_int16_t)(ip->ip_off | IP_MF));
    373373        ip->ip_sum = 0;
    374374        ip->ip_sum = cksum(m, hlen);

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

    r25375 r25822  
    133133    {
    134134#if 1
    135         int rc = mbuf_zone_init(pData);
     135        rc = mbuf_zone_init(pData);
    136136        if (rc == 0)
    137137            goto recheck_zone;

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

    r25799 r25822  
    282282
    283283            LogRel(("NAT: adding %R[IP4] to DNS server list\n", &InAddr));
    284             if ((InAddr.s_addr & htonl(IN_CLASSA_NET)) == ntohl(INADDR_LOOPBACK & IN_CLASSA_NET))
    285                 pDns->de_addr.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     284            if ((InAddr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
     285                pDns->de_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    286286            else
    287287                pDns->de_addr.s_addr = InAddr.s_addr;
    … …  
    433433            /* check */
    434434            pDns->de_addr.s_addr = tmp_addr.s_addr;
    435             if ((pDns->de_addr.s_addr & htonl(IN_CLASSA_NET)) == ntohl(INADDR_LOOPBACK & IN_CLASSA_NET))
    436             {
    437                 pDns->de_addr.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     435            if ((pDns->de_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
     436            {
     437                pDns->de_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    438438            }
    439439            TAILQ_INSERT_HEAD(&pData->pDnsList, pDns, de_list);
    … …  
    580580#endif
    581581    pData->slirp_ethaddr = &special_ethaddr[0];
    582     alias_addr.s_addr = pData->special_addr.s_addr | htonl(CTL_ALIAS);
     582    alias_addr.s_addr = pData->special_addr.s_addr | RT_H2N_U32_C(CTL_ALIAS);
    583583    /* @todo: add ability to configure this staff */
    584584
    … …  
    609609        flags |= PKT_ALIAS_LOG; /* set logging */
    610610        flags = LibAliasSetMode(pData->proxy_alias, flags, ~0);
    611         proxy_addr.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     611        proxy_addr.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    612612        LibAliasSetAddress(pData->proxy_alias, proxy_addr);
    613613        ftp_alias_load(pData);
    … …  
    14471447    eh = mtod(m, struct ethhdr *);
    14481448    ah = (struct arphdr *)&eh[1];
    1449     htip = ntohl(*(uint32_t*)ah->ar_tip);
     1449    htip = RT_N2H_U32(*(uint32_t*)ah->ar_tip);
    14501450    tip = *(uint32_t*)ah->ar_tip;
    14511451
    1452     ar_op = ntohs(ah->ar_op);
     1452    ar_op = RT_N2H_U16(ah->ar_op);
     1453
    14531454    switch (ar_op)
    14541455    {
    … …  
    14791480                goto arp_ok;
    14801481#endif
    1481             if ((htip & pData->netmask) == ntohl(pData->special_addr.s_addr))
     1482            if ((htip & pData->netmask) == RT_N2H_U32(pData->special_addr.s_addr))
    14821483            {
    14831484                if (   CTL_CHECK(htip, CTL_DNS)
    … …  
    14971498
    14981499         arp_ok:
    1499                 rah->ar_hrd = htons(1);
    1500                 rah->ar_pro = htons(ETH_P_IP);
     1500                rah->ar_hrd = RT_H2N_U16_C(1);
     1501                rah->ar_pro = RT_H2N_U16_C(ETH_P_IP);
    15011502                rah->ar_hln = ETH_ALEN;
    15021503                rah->ar_pln = 4;
    1503                 rah->ar_op = htons(ARPOP_REPLY);
     1504                rah->ar_op = RT_H2N_U16_C(ARPOP_REPLY);
    15041505                memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN);
    15051506
    … …  
    15781579    }
    15791580    eh = mtod(m, struct ethhdr *);
    1580     proto = ntohs(eh->h_proto);
     1581    proto = RT_N2H_U16(eh->h_proto);
    15811582#else
    15821583    Log2(("NAT: slirp_input %d\n", pkt_len));
    … …  
    16171618    m->m_len = pkt_len ;
    16181619    memcpy(m->m_data, pkt, pkt_len);
    1619     proto = ntohs(*(uint16_t *)(pkt + 12));
     1620    proto = RT_N2H_U16(*(uint16_t *)(pkt + 12));
    16201621#endif
    16211622    /* Note: we add to align the IP header */
    … …  
    17211722    }
    17221723#endif
    1723     eh->h_proto = htons(eth_proto);
     1724    eh->h_proto = RT_H2N_U16(eth_proto);
    17241725#ifdef VBOX_WITH_SLIRP_BSD_MBUF
    17251726    m_copydata(m, 0, mlen, (char *)buf);
    … …  
    18161817
    18171818        if (rule->proto == IPPROTO_UDP)
    1818             so = udp_listen(pData, rule->bind_ip.s_addr, htons(rule->host_port), guest_addr,
    1819                             htons(rule->guest_port), 0);
     1819            so = udp_listen(pData, rule->bind_ip.s_addr, RT_H2N_U16(rule->host_port), guest_addr,
     1820                            RT_H2N_U16(rule->guest_port), 0);
    18201821        else
    1821             so = solisten(pData, rule->bind_ip.s_addr, htons(rule->host_port), guest_addr,
    1822                           htons(rule->guest_port), 0);
     1822            so = solisten(pData, rule->bind_ip.s_addr, RT_H2N_U16(rule->host_port), guest_addr,
     1823                          RT_H2N_U16(rule->guest_port), 0);
    18231824
    18241825        if (so == NULL)
    … …  
    18431844        flags = LibAliasSetMode(lib, flags, ~0);
    18441845
    1845         alias.s_addr =  htonl(ntohl(guest_addr) | CTL_ALIAS);
    1846         alias_link = LibAliasRedirectPort(lib, psin->sin_addr, htons(rule->host_port),
    1847                                           alias, htons(rule->guest_port),
     1846        alias.s_addr = RT_H2N_U32(RT_N2H_U32(guest_addr) | CTL_ALIAS);
     1847        alias_link = LibAliasRedirectPort(lib, psin->sin_addr, RT_H2N_U16(rule->host_port),
     1848                                          alias, RT_H2N_U16(rule->guest_port),
    18481849                                          pData->special_addr,  -1, /* not very clear for now */
    18491850                                          rule->proto);
    … …  
    19051906{
    19061907    return add_exec(&exec_list, do_pty, (char *)args,
    1907                     addr_low_byte, htons(guest_port));
     1908                    addr_low_byte, RT_H2N_U16(guest_port));
    19081909}
    19091910
    … …  
    19871988    Log2(("next_server:%s\n", next_server));
    19881989    if (next_server == NULL)
    1989         pData->tftp_server.s_addr = htonl(ntohl(pData->special_addr.s_addr) | CTL_TFTP);
     1990        pData->tftp_server.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_TFTP);
    19901991    else
    19911992        inet_aton(next_server, &pData->tftp_server);
    … …  
    21172118    memset(ehdr->h_source, 0xff, ETH_ALEN);
    21182119    ahdr = (struct arphdr *)&ehdr[1];
    2119     ahdr->ar_hrd = htons(1);
    2120     ahdr->ar_pro = htons(ETH_P_IP);
     2120    ahdr->ar_hrd = RT_H2N_U16_C(1);
     2121    ahdr->ar_pro = RT_H2N_U16_C(ETH_P_IP);
    21212122    ahdr->ar_hln = ETH_ALEN;
    21222123    ahdr->ar_pln = 4;
    2123     ahdr->ar_op = htons(ARPOP_REQUEST);
     2124    ahdr->ar_op = RT_H2N_U16_C(ARPOP_REQUEST);
    21242125    memcpy(ahdr->ar_sha, special_ethaddr, ETH_ALEN);
    2125     *(uint32_t *)ahdr->ar_sip = htonl(ntohl(pData->special_addr.s_addr) | CTL_ALIAS);
     2126    *(uint32_t *)ahdr->ar_sip = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_ALIAS);
    21262127    memset(ahdr->ar_tha, 0xff, ETH_ALEN); /*broadcast*/
    21272128    *(uint32_t *)ahdr->ar_tip = dst;

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

    r25362 r25822  
    3333# include <io.h>
    3434#endif
     35#include <iprt/asm.h>
    3536#include <iprt/assert.h>
    3637#include <iprt/string.h>

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

    r25265 r25822  
    596596         */
    597597        len = M_FREEROOM(m);
    598         /* if (so->so_fport != htons(53)) */
     598        /* if (so->so_fport != RT_H2N_U16_C(53)) */
    599599        rc = ioctlsocket(so->s, FIONREAD, &n);
    600600        if (   rc == -1
    … …  
    708708            if (so->so_expire)
    709709            {
    710                 if (so->so_fport != htons(53))
     710                if (so->so_fport != RT_H2N_U16_C(53))
    711711                    so->so_expire = curtime + SO_EXPIRE;
    712712            }
    … …  
    716716             */
    717717#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    718             if (so->so_fport == htons(53))
     718            if (so->so_fport == RT_H2N_U16_C(53))
    719719                dnsproxy_answer(pData, so, m);
    720720#endif
    … …  
    765765    paddr = (struct sockaddr_in *)&addr;
    766766    paddr->sin_family = AF_INET;
    767     if ((so->so_faddr.s_addr & htonl(pData->netmask)) == pData->special_addr.s_addr)
     767    if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
    768768    {
    769769        /* It's an alias */
    770         uint32_t last_byte = ntohl(so->so_faddr.s_addr) & ~pData->netmask;
     770        uint32_t last_byte = RT_N2H_U32(so->so_faddr.s_addr) & ~pData->netmask;
    771771        switch(last_byte)
    772772        {
    … …  
    802802
    803803    DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n",
    804                 ntohs(paddr->sin_port), inet_ntoa(paddr->sin_addr)));
     804                RT_N2H_U16(paddr->sin_port), inet_ntoa(paddr->sin_addr)));
    805805
    806806    /* Don't care what port we get */

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

    r22584 r25822  
    352352    tlen = ((struct ip *)ti)->ip_len;
    353353    memset(ti->ti_x1, 0, 9);
    354     ti->ti_len = htons((u_int16_t)tlen);
     354    ti->ti_len = RT_H2N_U16((u_int16_t)tlen);
    355355    len = sizeof(struct ip ) + tlen;
    356356    /* keep checksum for ICMP reply
    … …  
    392392             || (   optlen  > TCPOLEN_TSTAMP_APPA
    393393                 && optp[TCPOLEN_TSTAMP_APPA] == TCPOPT_EOL)) &&
    394                 *(u_int32_t *)optp == htonl(TCPOPT_TSTAMP_HDR) &&
     394                *(u_int32_t *)optp == RT_H2N_U32_C(TCPOPT_TSTAMP_HDR) &&
    395395                (ti->ti_flags & TH_SYN) == 0)
    396396        {
    397397            ts_present = 1;
    398             ts_val = ntohl(*(u_int32_t *)(optp + 4));
    399             ts_ecr = ntohl(*(u_int32_t *)(optp + 8));
     398            ts_val = RT_N2H_U32(*(u_int32_t *)(optp + 4));
     399            ts_ecr = RT_N2H_U32(*(u_int32_t *)(optp + 8));
    400400            optp = NULL;   / * we have parsed the options * /
    401401        }

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

    r23462 r25822  
    301301            opt[0] = TCPOPT_MAXSEG;
    302302            opt[1] = 4;
    303             mss = htons((u_int16_t) tcp_mss(pData, tp, 0));
     303            mss = RT_H2N_U16((u_int16_t) tcp_mss(pData, tp, 0));
    304304            memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
    305305            optlen = 4;
    … …  
    310310                    || (tp->t_flags & TF_RCVD_SCALE)))
    311311            {
    312                 *((u_int32_t *) (opt + optlen)) = htonl(  TCPOPT_NOP << 24
    313                                                         | TCPOPT_WINDOW << 16
    314                                                         | TCPOLEN_WINDOW << 8
    315                                                         | tp->request_r_scale);
     312                *((u_int32_t *) (opt + optlen)) = RT_H2N_U32(  TCPOPT_NOP << 24
     313                                                             | TCPOPT_WINDOW << 16
     314                                                             | TCPOLEN_WINDOW << 8
     315                                                             | tp->request_r_scale);
    316316                optlen += 4;
    317317            }
    … …  
    334334
    335335        /* Form timestamp option as shown in appendix A of RFC 1323. */
    336         *lp++ = htonl(TCPOPT_TSTAMP_HDR);
    337         *lp++ = htonl(tcp_now);
    338         *lp   = htonl(tp->ts_recent);
     336        *lp++ = RT_H2N_U32_C(TCPOPT_TSTAMP_HDR);
     337        *lp++ = RT_H2N_U32(tcp_now);
     338        *lp   = RT_H2N_U32(tp->ts_recent);
    339339        optlen += TCPOLEN_TSTAMP_APPA;
    340340    }
    … …  
    519519     */
    520520    if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
    521         ti->ti_seq = htonl(tp->snd_nxt);
     521        ti->ti_seq = RT_H2N_U32(tp->snd_nxt);
    522522    else
    523         ti->ti_seq = htonl(tp->snd_max);
    524     ti->ti_ack = htonl(tp->rcv_nxt);
     523        ti->ti_seq = RT_H2N_U32(tp->snd_max);
     524    ti->ti_ack = RT_H2N_U32(tp->rcv_nxt);
    525525    if (optlen)
    526526    {
    … …  
    539539    if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
    540540        win = (long)(tp->rcv_adv - tp->rcv_nxt);
    541     ti->ti_win = htons((u_int16_t) (win>>tp->rcv_scale));
     541    ti->ti_win = RT_H2N_U16((u_int16_t) (win>>tp->rcv_scale));
    542542
    543543#if 0
    544544    if (SEQ_GT(tp->snd_up, tp->snd_nxt))
    545545    {
    546         ti->ti_urp = htons((u_int16_t)(tp->snd_up - tp->snd_nxt));
     546        ti->ti_urp = RT_H2N_U16((u_int16_t)(tp->snd_up - tp->snd_nxt));
    547547#else
    548548    if (SEQ_GT(tp->snd_up, tp->snd_una))
    549549    {
    550         ti->ti_urp = htons((u_int16_t)(tp->snd_up - ntohl(ti->ti_seq)));
     550        ti->ti_urp = RT_H2N_U16((u_int16_t)(tp->snd_up - RT_N2H_U32(ti->ti_seq)));
    551551#endif
    552552        ti->ti_flags |= TH_URG;
    … …  
    566566     */
    567567    if (len + optlen)
    568         ti->ti_len = htons((u_int16_t)(sizeof (struct tcphdr)
    569                                        + optlen + len));
     568        ti->ti_len = RT_H2N_U16((u_int16_t)(sizeof (struct tcphdr)
     569                                            + optlen + len));
    570570    ti->ti_sum = cksum(m, (int)(hdrlen + len));
    571571

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

    r25754 r25822  
    7575    memset(n->ti_x1, 0, 9);
    7676    n->ti_pr = IPPROTO_TCP;
    77     n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
     77    n->ti_len = RT_H2N_U16(sizeof (struct tcpiphdr) - sizeof (struct ip));
    7878    n->ti_src = so->so_faddr;
    7979    n->ti_dst = so->so_laddr;
    … …  
    156156#undef xchg
    157157    }
    158     ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
     158    ti->ti_len = RT_H2N_U16((u_short)(sizeof (struct tcphdr) + tlen));
    159159    tlen += sizeof (struct tcpiphdr);
    160160    m->m_len = tlen;
    161161
    162162    memset(ti->ti_x1, 0, 9);
    163     ti->ti_seq = htonl(seq);
    164     ti->ti_ack = htonl(ack);
     163    ti->ti_seq = RT_H2N_U32(seq);
     164    ti->ti_ack = RT_H2N_U32(ack);
    165165    ti->ti_x2 = 0;
    166166    ti->ti_off = sizeof (struct tcphdr) >> 2;
    167167    ti->ti_flags = flags;
    168168    if (tp)
    169         ti->ti_win = htons((u_int16_t) (win >> tp->rcv_scale));
     169        ti->ti_win = RT_H2N_U16((u_int16_t) (win >> tp->rcv_scale));
    170170    else
    171         ti->ti_win = htons((u_int16_t)win);
     171        ti->ti_win = RT_H2N_U16((u_int16_t)win);
    172172    ti->ti_urp = 0;
    173173    ti->ti_sum = 0;
    … …  
    407407
    408408        addr.sin_family = AF_INET;
    409         if ((so->so_faddr.s_addr & htonl(pData->netmask)) == pData->special_addr.s_addr)
     409        if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
    410410        {
    411411            /* It's an alias */
    412             switch(ntohl(so->so_faddr.s_addr) & ~pData->netmask)
     412            switch(RT_N2H_U32(so->so_faddr.s_addr) & ~pData->netmask)
    413413            {
    414414                case CTL_DNS:
    … …  
    425425        DEBUG_MISC((dfd, " connect()ing, addr.sin_port=%d, "
    426426                         "addr.sin_addr.s_addr=%.16s\n",
    427                          ntohs(addr.sin_port), inet_ntoa(addr.sin_addr)));
     427                         RT_N2H_U16(addr.sin_port), inet_ntoa(addr.sin_addr)));
    428428        /* We don't care what port we get */
    429429        ret = connect(s,(struct sockaddr *)&addr,sizeof (addr));

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

    r23369 r25822  
    136136    m->m_data += sizeof(struct udpiphdr);
    137137
    138     tp->tp_op = htons(TFTP_OACK);
     138    tp->tp_op = RT_H2N_U16_C(TFTP_OACK);
    139139    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%s", key) + 1;
    140140    n += RTStrPrintf((char *)tp->x.tp_buf + n, M_FREEROOM(m), "%u", value) + 1;
    … …  
    175175    m->m_data += sizeof(struct udpiphdr);
    176176
    177     tp->tp_op = htons(TFTP_ERROR);
    178     tp->x.tp_error.tp_error_code = htons(errorcode);
     177    tp->tp_op = RT_H2N_U16_C(TFTP_ERROR);
     178    tp->x.tp_error.tp_error_code = RT_H2N_U16(errorcode);
    179179    strcpy((char *)tp->x.tp_error.tp_msg, msg);
    180180
    … …  
    224224    m->m_data += sizeof(struct udpiphdr);
    225225
    226     tp->tp_op = htons(TFTP_DATA);
    227     tp->x.tp_data.tp_block_nr = htons(block_nr);
     226    tp->tp_op = RT_H2N_U16_C(TFTP_DATA);
     227    tp->x.tp_data.tp_block_nr = RT_H2N_U16(block_nr);
    228228
    229229    saddr.sin_addr = recv_tp->ip.ip_dst;
    … …  
    385385
    386386    if (tftp_send_data(pData, &tftp_sessions[s],
    387                        ntohs(tp->x.tp_data.tp_block_nr) + 1, tp) < 0)
     387                       RT_N2H_U16(tp->x.tp_data.tp_block_nr) + 1, tp) < 0)
    388388    {
    389389        /* XXX */
    … …  
    395395    struct tftp_t *tp = (struct tftp_t *)m->m_data;
    396396
    397     switch(ntohs(tp->tp_op))
     397    switch(RT_N2H_U16(tp->tp_op))
    398398    {
    399399        case TFTP_RRQ:

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

    r25747 r25822  
    106106     * If not enough data to reflect UDP length, drop.
    107107     */
    108     len = ntohs((u_int16_t)uh->uh_ulen);
     108    len = RT_N2H_U16((u_int16_t)uh->uh_ulen);
    109109    Assert((ip->ip_len == len));
    110110    Assert((ip->ip_len + iphlen == m->m_len));
    … …  
    156156     *  handle DHCP/BOOTP
    157157     */
    158     if (ntohs(uh->uh_dport) == BOOTP_SERVER)
     158    if (uh->uh_dport == RT_H2N_U16_C(BOOTP_SERVER))
    159159    {
    160160        bootp_input(pData, m);
    … …  
    163163
    164164    if (   pData->use_host_resolver
    165         && ntohs(uh->uh_dport) == 53
    166         && CTL_CHECK(ntohl(ip->ip_dst.s_addr), CTL_DNS))
     165        && uh->uh_dport == RT_H2N_U16_C(53)
     166        && CTL_CHECK(RT_N2H_U32(ip->ip_dst.s_addr), CTL_DNS))
    167167    {
    168168        struct sockaddr_in dst, src;
    … …  
    182182     */
    183183#ifndef VBOX_WITH_SLIRP_BSD_MBUF
    184     if (   ntohs(uh->uh_dport) == TFTP_SERVER
    185         && CTL_CHECK(ntohl(ip->ip_dst.s_addr), CTL_TFTP))
     184    if (   uh->uh_dport == RT_H2N_U16_C(TFTP_SERVER)
     185        && CTL_CHECK(RT_N2H_U32(ip->ip_dst.s_addr), CTL_TFTP))
    186186    {
    187187        tftp_input(pData, m);
    … …  
    259259     */
    260260    if (   pData->use_dns_proxy
    261         && (ip->ip_dst.s_addr == htonl(ntohl(pData->special_addr.s_addr) | CTL_DNS))
    262         && (ntohs(uh->uh_dport) == 53))
     261        && (ip->ip_dst.s_addr == RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_DNS))
     262        && (uh->uh_dport == RT_H2N_U16_C(53)))
    263263    {
    264264        dnsproxy_query(pData, so, m, iphlen);
    … …  
    343343    memset(ui->ui_x1, 0, 9);
    344344    ui->ui_pr = IPPROTO_UDP;
    345     ui->ui_len = htons(m->m_len - sizeof(struct ip));
     345    ui->ui_len = RT_H2N_U16(m->m_len - sizeof(struct ip));
    346346    /* XXXXX Check for from-one-location sockets, or from-any-location sockets */
    347347    ui->ui_src = saddr->sin_addr;
    … …  
    377377
    378378    saddr = *addr;
    379     if ((so->so_faddr.s_addr & htonl(pData->netmask)) == pData->special_addr.s_addr)
     379    if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
    380380    {
    381381        saddr.sin_addr.s_addr = so->so_faddr.s_addr;
    382         if ((so->so_faddr.s_addr & htonl(~pData->netmask)) == htonl(~pData->netmask))
     382        if ((so->so_faddr.s_addr & RT_H2N_U32(~pData->netmask)) == RT_H2N_U32(~pData->netmask))
    383383            saddr.sin_addr.s_addr = alias_addr.s_addr;
    384384    }
    … …  
    386386    /* Any UDP packet to the loopback address must be translated to be from
    387387     * the forwarding address, i.e. 10.0.2.2. */
    388     if (   (saddr.sin_addr.s_addr & htonl(IN_CLASSA_NET))
    389         == htonl(INADDR_LOOPBACK & IN_CLASSA_NET))
     388    if (   (saddr.sin_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET))
     389        == RT_H2N_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
    390390        saddr.sin_addr.s_addr = alias_addr.s_addr;
    391391
    … …  
    482482    while(udptos[i].tos)
    483483    {
    484         if (   (udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport)
    485             || (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport))
     484        if (   (udptos[i].fport && RT_N2H_U16(so->so_fport) == udptos[i].fport)
     485            || (udptos[i].lport && RT_N2H_U16(so->so_lport) == udptos[i].lport))
    486486        {
    487487            so->so_emu = udptos[i].emu;
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