mirror/lwip
1
0
Fork 0
mirror of https://github.com/lwip-tcpip/lwip.git synced 2024-07-04 20:08:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup hton*/ntoh* function handling and platform abstraction

Browse Source 
Let lwip use functions/macros prefixed by lwip_ internally to avoid naming clashes with external #includes.
Remove over-complicated #define handling in def.h
Make functions easier to override in cc.h. The following is sufficient now (no more LWIP_PLATFORM_BYTESWAP):
#define lwip_htons(x) <your_htons>
#define lwip_htonl(x) <your_htonl>
This commit is contained in:
Dirk Ziegelmeier 2016-10-06 12:55:57 +02:00
parent 0c06073819
commit 13fb616bb2
44 changed files with 370 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
doc/rawapi.txt
View File

@ -456,9 +456,8 @@ introduction to this subject.
Other significant improvements can be made by supplying Other significant improvements can be made by supplying
assembly or inline replacements for htons() and htonl() assembly or inline replacements for htons() and htonl()
if you're using a little-endian architecture. if you're using a little-endian architecture.
#define LWIP_PLATFORM_BYTESWAP 1 #define lwip_htons(x) <your_htons>
#define LWIP_PLATFORM_HTONS(x) <your_htons> #define lwip_htonl(x) <your_htonl>
#define LWIP_PLATFORM_HTONL(x) <your_htonl>
Check your network interface driver if it reads at Check your network interface driver if it reads at
a higher speed than the maximum wire-speed. If the a higher speed than the maximum wire-speed. If the

4
src/api/netdb.c
View File

@ -375,7 +375,7 @@ lwip_getaddrinfo(const char *nodename, const char *servname,
inet6_addr_from_ip6addr(&sa6->sin6_addr, ip_2_ip6(&addr)); inet6_addr_from_ip6addr(&sa6->sin6_addr, ip_2_ip6(&addr));
sa6->sin6_family = AF_INET6; sa6->sin6_family = AF_INET6;
sa6->sin6_len = sizeof(struct sockaddr_in6); sa6->sin6_len = sizeof(struct sockaddr_in6);
sa6->sin6_port = htons((u16_t)port_nr); sa6->sin6_port = lwip_htons((u16_t)port_nr);
ai->ai_family = AF_INET6; ai->ai_family = AF_INET6;
#endif /* LWIP_IPV6 */ #endif /* LWIP_IPV6 */
} else { } else {
@ -385,7 +385,7 @@ lwip_getaddrinfo(const char *nodename, const char *servname,
inet_addr_from_ipaddr(&sa4->sin_addr, ip_2_ip4(&addr)); inet_addr_from_ipaddr(&sa4->sin_addr, ip_2_ip4(&addr));
sa4->sin_family = AF_INET; sa4->sin_family = AF_INET;
sa4->sin_len = sizeof(struct sockaddr_in); sa4->sin_len = sizeof(struct sockaddr_in);
sa4->sin_port = htons((u16_t)port_nr); sa4->sin_port = lwip_htons((u16_t)port_nr);
ai->ai_family = AF_INET; ai->ai_family = AF_INET;
#endif /* LWIP_IPV4 */ #endif /* LWIP_IPV4 */
} }

8
src/api/sockets.c
View File

@ -81,25 +81,25 @@
#define IP4ADDR_PORT_TO_SOCKADDR(sin, ipaddr, port) do { \ #define IP4ADDR_PORT_TO_SOCKADDR(sin, ipaddr, port) do { \
(sin)->sin_len = sizeof(struct sockaddr_in); \ (sin)->sin_len = sizeof(struct sockaddr_in); \
(sin)->sin_family = AF_INET; \ (sin)->sin_family = AF_INET; \
(sin)->sin_port = htons((port)); \ (sin)->sin_port = lwip_htons((port)); \
inet_addr_from_ipaddr(&(sin)->sin_addr, ipaddr); \ inet_addr_from_ipaddr(&(sin)->sin_addr, ipaddr); \
memset((sin)->sin_zero, 0, SIN_ZERO_LEN); }while(0) memset((sin)->sin_zero, 0, SIN_ZERO_LEN); }while(0)
#define SOCKADDR4_TO_IP4ADDR_PORT(sin, ipaddr, port) do { \ #define SOCKADDR4_TO_IP4ADDR_PORT(sin, ipaddr, port) do { \
inet_addr_to_ipaddr(ip_2_ip4(ipaddr), &((sin)->sin_addr)); \ inet_addr_to_ipaddr(ip_2_ip4(ipaddr), &((sin)->sin_addr)); \
(port) = ntohs((sin)->sin_port); }while(0) (port) = lwip_ntohs((sin)->sin_port); }while(0)
#endif /* LWIP_IPV4 */ #endif /* LWIP_IPV4 */
#if LWIP_IPV6 #if LWIP_IPV6
#define IP6ADDR_PORT_TO_SOCKADDR(sin6, ipaddr, port) do { \ #define IP6ADDR_PORT_TO_SOCKADDR(sin6, ipaddr, port) do { \
(sin6)->sin6_len = sizeof(struct sockaddr_in6); \ (sin6)->sin6_len = sizeof(struct sockaddr_in6); \
(sin6)->sin6_family = AF_INET6; \ (sin6)->sin6_family = AF_INET6; \
(sin6)->sin6_port = htons((port)); \ (sin6)->sin6_port = lwip_htons((port)); \
(sin6)->sin6_flowinfo = 0; \ (sin6)->sin6_flowinfo = 0; \
inet6_addr_from_ip6addr(&(sin6)->sin6_addr, ipaddr); \ inet6_addr_from_ip6addr(&(sin6)->sin6_addr, ipaddr); \
(sin6)->sin6_scope_id = 0; }while(0) (sin6)->sin6_scope_id = 0; }while(0)
#define SOCKADDR6_TO_IP6ADDR_PORT(sin6, ipaddr, port) do { \ #define SOCKADDR6_TO_IP6ADDR_PORT(sin6, ipaddr, port) do { \
inet6_addr_to_ip6addr(ip_2_ip6(ipaddr), &((sin6)->sin6_addr)); \ inet6_addr_to_ip6addr(ip_2_ip6(ipaddr), &((sin6)->sin6_addr)); \
(port) = ntohs((sin6)->sin6_port); }while(0) (port) = lwip_ntohs((sin6)->sin6_port); }while(0)
#endif /* LWIP_IPV6 */ #endif /* LWIP_IPV6 */
#if LWIP_IPV4 && LWIP_IPV6 #if LWIP_IPV4 && LWIP_IPV6

6
src/apps/lwiperf/lwiperf.c
View File

@ -262,7 +262,7 @@ lwiperf_tcp_client_send_more(lwiperf_state_tcp_t* conn)
/* this session is time-limited */ /* this session is time-limited */
u32_t now = sys_now(); u32_t now = sys_now();
u32_t diff_ms = now - conn->time_started; u32_t diff_ms = now - conn->time_started;
u32_t time = (u32_t)-(s32_t)htonl(conn->settings.amount); u32_t time = (u32_t)-(s32_t)lwip_htonl(conn->settings.amount);
u32_t time_ms = time * 10; u32_t time_ms = time * 10;
if (diff_ms >= time_ms) { if (diff_ms >= time_ms) {
/* time specified by the client is over -> close the connection */ /* time specified by the client is over -> close the connection */
@ -271,7 +271,7 @@ lwiperf_tcp_client_send_more(lwiperf_state_tcp_t* conn)
} }
} else { } else {
/* this session is byte-limited */ /* this session is byte-limited */
u32_t amount_bytes = htonl(conn->settings.amount); u32_t amount_bytes = lwip_htonl(conn->settings.amount);
/* @todo: this can send up to 1*MSS more than requested... */ /* @todo: this can send up to 1*MSS more than requested... */
if (amount_bytes >= conn->bytes_transferred) { if (amount_bytes >= conn->bytes_transferred) {
/* all requested bytes transferred -> close the connection */ /* all requested bytes transferred -> close the connection */
@ -390,7 +390,7 @@ lwiperf_tx_start(lwiperf_state_tcp_t* conn)
tcp_err(newpcb, lwiperf_tcp_err); tcp_err(newpcb, lwiperf_tcp_err);
ip_addr_copy(remote_addr, conn->conn_pcb->remote_ip); ip_addr_copy(remote_addr, conn->conn_pcb->remote_ip);
remote_port = (u16_t)htonl(client_conn->settings.remote_port); remote_port = (u16_t)lwip_htonl(client_conn->settings.remote_port);
err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected); err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected);
if (err != ERR_OK) { if (err != ERR_OK) {

44
src/apps/mdns/mdns.c
View File

@ -820,7 +820,7 @@ mdns_write_domain(struct mdns_outpacket *outpkt, struct mdns_domain *domain)
} }
if (jump_offset) { if (jump_offset) {
/* Write jump */ /* Write jump */
jump = htons(DOMAIN_JUMP | jump_offset); jump = lwip_htons(DOMAIN_JUMP | jump_offset);
res = pbuf_take_at(outpkt->pbuf, &jump, DOMAIN_JUMP_SIZE, outpkt->write_offset); res = pbuf_take_at(outpkt->pbuf, &jump, DOMAIN_JUMP_SIZE, outpkt->write_offset);
if (res != ERR_OK) { if (res != ERR_OK) {
return res; return res;
@ -872,7 +872,7 @@ mdns_add_question(struct mdns_outpacket *outpkt, struct mdns_domain *domain, u16
} }
/* Write type */ /* Write type */
field16 = htons(type); field16 = lwip_htons(type);
res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset);
if (res != ERR_OK) { if (res != ERR_OK) {
return res; return res;
@ -883,7 +883,7 @@ mdns_add_question(struct mdns_outpacket *outpkt, struct mdns_domain *domain, u16
if (unicast) { if (unicast) {
klass |= 0x8000; klass |= 0x8000;
} }
field16 = htons(klass); field16 = lwip_htons(klass);
res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset);
if (res != ERR_OK) { if (res != ERR_OK) {
return res; return res;
@ -947,7 +947,7 @@ mdns_add_answer(struct mdns_outpacket *reply, struct mdns_domain *domain, u16_t
mdns_add_question(reply, domain, type, klass, cache_flush); mdns_add_question(reply, domain, type, klass, cache_flush);
/* Write TTL */ /* Write TTL */
field32 = htonl(ttl); field32 = lwip_htonl(ttl);
res = pbuf_take_at(reply->pbuf, &field32, sizeof(field32), reply->write_offset); res = pbuf_take_at(reply->pbuf, &field32, sizeof(field32), reply->write_offset);
if (res != ERR_OK) { if (res != ERR_OK) {
return res; return res;
@ -977,7 +977,7 @@ mdns_add_answer(struct mdns_outpacket *reply, struct mdns_domain *domain, u16_t
} }
/* Write rd_length after when we know the answer size */ /* Write rd_length after when we know the answer size */
field16 = htons(reply->write_offset - answer_offset); field16 = lwip_htons(reply->write_offset - answer_offset);
res = pbuf_take_at(reply->pbuf, &field16, sizeof(field16), rdlen_offset); res = pbuf_take_at(reply->pbuf, &field16, sizeof(field16), rdlen_offset);
return res; return res;
@ -1005,14 +1005,14 @@ mdns_read_rr_info(struct mdns_packet *pkt, struct mdns_rr_info *info)
return ERR_VAL; return ERR_VAL;
} }
pkt->parse_offset += copied; pkt->parse_offset += copied;
info->type = ntohs(field16); info->type = lwip_ntohs(field16);
copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset);
if (copied != sizeof(field16)) { if (copied != sizeof(field16)) {
return ERR_VAL; return ERR_VAL;
} }
pkt->parse_offset += copied; pkt->parse_offset += copied;
info->klass = ntohs(field16); info->klass = lwip_ntohs(field16);
return ERR_OK; return ERR_OK;
} }
@ -1094,14 +1094,14 @@ mdns_read_answer(struct mdns_packet *pkt, struct mdns_answer *answer)
return ERR_VAL; return ERR_VAL;
} }
pkt->parse_offset += copied; pkt->parse_offset += copied;
answer->ttl = ntohl(ttl); answer->ttl = lwip_ntohl(ttl);
copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset);
if (copied != sizeof(field16)) { if (copied != sizeof(field16)) {
return ERR_VAL; return ERR_VAL;
} }
pkt->parse_offset += copied; pkt->parse_offset += copied;
answer->rd_length = ntohs(field16); answer->rd_length = lwip_ntohs(field16);
answer->rd_offset = pkt->parse_offset; answer->rd_offset = pkt->parse_offset;
pkt->parse_offset += answer->rd_length; pkt->parse_offset += answer->rd_length;
@ -1194,9 +1194,9 @@ mdns_add_srv_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct mdns
*/ */
srvhost.skip_compression = 1; srvhost.skip_compression = 1;
} }
srvdata[0] = htons(SRV_PRIORITY); srvdata[0] = lwip_htons(SRV_PRIORITY);
srvdata[1] = htons(SRV_WEIGHT); srvdata[1] = lwip_htons(SRV_WEIGHT);
srvdata[2] = htons(service->port); srvdata[2] = lwip_htons(service->port);
LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with SRV record\n")); LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with SRV record\n"));
return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_SRV, DNS_RRCLASS_IN, cache_flush, service->dns_ttl, return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_SRV, DNS_RRCLASS_IN, cache_flush, service->dns_ttl,
(const u8_t *) &srvdata, sizeof(srvdata), &srvhost); (const u8_t *) &srvdata, sizeof(srvdata), &srvhost);
@ -1411,11 +1411,11 @@ mdns_send_outpacket(struct mdns_outpacket *outpkt)
/* Write header */ /* Write header */
memset(&hdr, 0, sizeof(hdr)); memset(&hdr, 0, sizeof(hdr));
hdr.flags1 = DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE; hdr.flags1 = DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE;
hdr.numanswers = htons(outpkt->answers); hdr.numanswers = lwip_htons(outpkt->answers);
hdr.numextrarr = htons(outpkt->additional); hdr.numextrarr = lwip_htons(outpkt->additional);
if (outpkt->legacy_query) { if (outpkt->legacy_query) {
hdr.numquestions = htons(1); hdr.numquestions = lwip_htons(1);
hdr.id = htons(outpkt->tx_id); hdr.id = lwip_htons(outpkt->tx_id);
} }
pbuf_take(outpkt->pbuf, &hdr, sizeof(hdr)); pbuf_take(outpkt->pbuf, &hdr, sizeof(hdr));
@ -1657,19 +1657,19 @@ mdns_handle_question(struct mdns_packet *pkt)
do { do {
/* Check priority field */ /* Check priority field */
len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos);
if (len != sizeof(field16) || ntohs(field16) != SRV_PRIORITY) { if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_PRIORITY) {
break; break;
} }
read_pos += len; read_pos += len;
/* Check weight field */ /* Check weight field */
len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos);
if (len != sizeof(field16) || ntohs(field16) != SRV_WEIGHT) { if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_WEIGHT) {
break; break;
} }
read_pos += len; read_pos += len;
/* Check port field */ /* Check port field */
len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos);
if (len != sizeof(field16) || ntohs(field16) != service->port) { if (len != sizeof(field16) || lwip_ntohs(field16) != service->port) {
break; break;
} }
read_pos += len; read_pos += len;
@ -1780,9 +1780,9 @@ mdns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
packet.netif = recv_netif; packet.netif = recv_netif;
packet.pbuf = p; packet.pbuf = p;
packet.parse_offset = offset; packet.parse_offset = offset;
packet.tx_id = ntohs(hdr.id); packet.tx_id = lwip_ntohs(hdr.id);
packet.questions = packet.questions_left = ntohs(hdr.numquestions); packet.questions = packet.questions_left = lwip_ntohs(hdr.numquestions);
packet.answers = packet.answers_left = ntohs(hdr.numanswers) + ntohs(hdr.numauthrr) + ntohs(hdr.numextrarr); packet.answers = packet.answers_left = lwip_ntohs(hdr.numanswers) + lwip_ntohs(hdr.numauthrr) + lwip_ntohs(hdr.numextrarr);
#if LWIP_IPV6 #if LWIP_IPV6
if (IP_IS_V6(ip_current_dest_addr())) { if (IP_IS_V6(ip_current_dest_addr())) {

8
src/apps/sntp/sntp.c
View File

@ -212,13 +212,13 @@ sntp_process(u32_t *receive_timestamp)
/* convert SNTP time (1900-based) to unix GMT time (1970-based) /* convert SNTP time (1900-based) to unix GMT time (1970-based)
* if MSB is 0, SNTP time is 2036-based! * if MSB is 0, SNTP time is 2036-based!
*/ */
u32_t rx_secs = ntohl(receive_timestamp[0]); u32_t rx_secs = lwip_ntohl(receive_timestamp[0]);
int is_1900_based = ((rx_secs & 0x80000000) != 0); int is_1900_based = ((rx_secs & 0x80000000) != 0);
u32_t t = is_1900_based ? (rx_secs - DIFF_SEC_1900_1970) : (rx_secs + DIFF_SEC_1970_2036); u32_t t = is_1900_based ? (rx_secs - DIFF_SEC_1900_1970) : (rx_secs + DIFF_SEC_1970_2036);
time_t tim = t; time_t tim = t;
#if SNTP_CALC_TIME_US #if SNTP_CALC_TIME_US
u32_t us = ntohl(receive_timestamp[1]) / 4295; u32_t us = lwip_ntohl(receive_timestamp[1]) / 4295;
SNTP_SET_SYSTEM_TIME_US(t, us); SNTP_SET_SYSTEM_TIME_US(t, us);
/* display local time from GMT time */ /* display local time from GMT time */
LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_process: %s, %"U32_F" us", ctime(&tim), us)); LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_process: %s, %"U32_F" us", ctime(&tim), us));
@ -247,10 +247,10 @@ sntp_initialize_request(struct sntp_msg *req)
u32_t sntp_time_sec, sntp_time_us; u32_t sntp_time_sec, sntp_time_us;
/* fill in transmit timestamp and save it in 'sntp_last_timestamp_sent' */ /* fill in transmit timestamp and save it in 'sntp_last_timestamp_sent' */
SNTP_GET_SYSTEM_TIME(sntp_time_sec, sntp_time_us); SNTP_GET_SYSTEM_TIME(sntp_time_sec, sntp_time_us);
sntp_last_timestamp_sent[0] = htonl(sntp_time_sec + DIFF_SEC_1900_1970); sntp_last_timestamp_sent[0] = lwip_htonl(sntp_time_sec + DIFF_SEC_1900_1970);
req->transmit_timestamp[0] = sntp_last_timestamp_sent[0]; req->transmit_timestamp[0] = sntp_last_timestamp_sent[0];
/* we send/save us instead of fraction to be faster... */ /* we send/save us instead of fraction to be faster... */
sntp_last_timestamp_sent[1] = htonl(sntp_time_us); sntp_last_timestamp_sent[1] = lwip_htonl(sntp_time_us);
req->transmit_timestamp[1] = sntp_last_timestamp_sent[1]; req->transmit_timestamp[1] = sntp_last_timestamp_sent[1];
} }
#endif /* SNTP_CHECK_RESPONSE >= 2 */ #endif /* SNTP_CHECK_RESPONSE >= 2 */

10
src/apps/tftp/tftp_server.c
View File

@ -128,7 +128,7 @@ send_error(const ip_addr_t *addr, u16_t port, enum tftp_error code, const char *
payload = (u16_t*) p->payload; payload = (u16_t*) p->payload;
payload[0] = PP_HTONS(TFTP_ERROR); payload[0] = PP_HTONS(TFTP_ERROR);
payload[1] = htons(code); payload[1] = lwip_htons(code);
MEMCPY(&payload[2], str, str_length + 1); MEMCPY(&payload[2], str, str_length + 1);
udp_sendto(tftp_state.upcb, p, addr, port); udp_sendto(tftp_state.upcb, p, addr, port);
@ -148,7 +148,7 @@ send_ack(u16_t blknum)
payload = (u16_t*) p->payload; payload = (u16_t*) p->payload;
payload[0] = PP_HTONS(TFTP_ACK); payload[0] = PP_HTONS(TFTP_ACK);
payload[1] = htons(blknum); payload[1] = lwip_htons(blknum);
udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port); udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port);
pbuf_free(p); pbuf_free(p);
} }
@ -187,7 +187,7 @@ send_data(void)
payload = (u16_t *) tftp_state.last_data->payload; payload = (u16_t *) tftp_state.last_data->payload;
payload[0] = PP_HTONS(TFTP_DATA); payload[0] = PP_HTONS(TFTP_DATA);
payload[1] = htons(tftp_state.blknum); payload[1] = lwip_htons(tftp_state.blknum);
ret = tftp_state.ctx->read(tftp_state.handle, &payload[2], TFTP_MAX_PAYLOAD_SIZE); ret = tftp_state.ctx->read(tftp_state.handle, &payload[2], TFTP_MAX_PAYLOAD_SIZE);
if (ret < 0) { if (ret < 0) {
@ -295,7 +295,7 @@ recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16
break; break;
} }
blknum = ntohs(sbuf[1]); blknum = lwip_ntohs(sbuf[1]);
pbuf_header(p, -TFTP_HEADER_LENGTH); pbuf_header(p, -TFTP_HEADER_LENGTH);
ret = tftp_state.ctx->write(tftp_state.handle, p); ret = tftp_state.ctx->write(tftp_state.handle, p);
@ -327,7 +327,7 @@ recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16
break; break;
} }
blknum = ntohs(sbuf[1]); blknum = lwip_ntohs(sbuf[1]);
if (blknum != tftp_state.blknum) { if (blknum != tftp_state.blknum) {
send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number"); send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number");
break; break;

39
src/core/def.c
View File

@ -7,11 +7,10 @@
* Byte swapping is the second thing you would want to optimize. You will * Byte swapping is the second thing you would want to optimize. You will
* need to port it to your architecture and in your cc.h: * need to port it to your architecture and in your cc.h:
* *
* \#define LWIP_PLATFORM_BYTESWAP 1 * \#define lwip_htons(x) your_htons
* \#define LWIP_PLATFORM_HTONS(x) your_htons * \#define lwip_htonl(x) your_htonl
* \#define LWIP_PLATFORM_HTONL(x) your_htonl
* *
* Note ntohs() and ntohl() are merely references to the htonx counterparts. * Note lwip_ntohs() and lwip_ntohl() are merely references to the htonx counterparts.
*/ */
/* /*
@ -51,8 +50,9 @@
#include <string.h> #include <string.h>
#if (LWIP_PLATFORM_BYTESWAP == 0) && (BYTE_ORDER == LITTLE_ENDIAN) #if BYTE_ORDER == LITTLE_ENDIAN
#if !defined(lwip_htons)
/** /**
* Convert an u16_t from host- to network byte order. * Convert an u16_t from host- to network byte order.
* *
@ -64,19 +64,9 @@ lwip_htons(u16_t n)
{ {
return (u16_t)PP_HTONS(n); return (u16_t)PP_HTONS(n);
} }
#endif /* lwip_htons */
/** #if !defined(lwip_htonl)
* Convert an u16_t from network- to host byte order.
*
* @param n u16_t in network byte order
* @return n in host byte order
*/
u16_t
lwip_ntohs(u16_t n)
{
return lwip_htons(n);
}
/** /**
* Convert an u32_t from host- to network byte order. * Convert an u32_t from host- to network byte order.
* *
@ -88,20 +78,9 @@ lwip_htonl(u32_t n)
{ {
return (u32_t)PP_HTONL(n); return (u32_t)PP_HTONL(n);
} }
#endif /* lwip_htonl */
/** #endif /* BYTE_ORDER == LITTLE_ENDIAN */
* Convert an u32_t from network- to host byte order.
*
* @param n u32_t in network byte order
* @return n in host byte order
*/
u32_t
lwip_ntohl(u32_t n)
{
return lwip_htonl(n);
}
#endif /* (LWIP_PLATFORM_BYTESWAP == 0) && (BYTE_ORDER == LITTLE_ENDIAN) */
#ifndef lwip_strnstr #ifndef lwip_strnstr
/** Like strstr but does not need 'buffer' to be NULL-terminated */ /** Like strstr but does not need 'buffer' to be NULL-terminated */

16
src/core/dns.c
View File

@ -680,7 +680,7 @@ dns_send(u8_t idx)
if (p != NULL) { if (p != NULL) {
/* fill dns header */ /* fill dns header */
memset(&hdr, 0, SIZEOF_DNS_HDR); memset(&hdr, 0, SIZEOF_DNS_HDR);
hdr.id = htons(entry->txid); hdr.id = lwip_htons(entry->txid);
hdr.flags1 = DNS_FLAG1_RD; hdr.flags1 = DNS_FLAG1_RD;
hdr.numquestions = PP_HTONS(1); hdr.numquestions = PP_HTONS(1);
pbuf_take(p, &hdr, SIZEOF_DNS_HDR); pbuf_take(p, &hdr, SIZEOF_DNS_HDR);
@ -1041,7 +1041,7 @@ dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
/* copy dns payload inside static buffer for processing */ /* copy dns payload inside static buffer for processing */
if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, 0) == SIZEOF_DNS_HDR) { if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, 0) == SIZEOF_DNS_HDR) {
/* Match the ID in the DNS header with the name table. */ /* Match the ID in the DNS header with the name table. */
txid = htons(hdr.id); txid = lwip_htons(hdr.id);
for (i = 0; i < DNS_TABLE_SIZE; i++) { for (i = 0; i < DNS_TABLE_SIZE; i++) {
const struct dns_table_entry *entry = &dns_table[i]; const struct dns_table_entry *entry = &dns_table[i];
if ((entry->state == DNS_STATE_ASKING) && if ((entry->state == DNS_STATE_ASKING) &&
@ -1049,8 +1049,8 @@ dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
/* We only care about the question(s) and the answers. The authrr /* We only care about the question(s) and the answers. The authrr
and the extrarr are simply discarded. */ and the extrarr are simply discarded. */
nquestions = htons(hdr.numquestions); nquestions = lwip_htons(hdr.numquestions);
nanswers = htons(hdr.numanswers); nanswers = lwip_htons(hdr.numanswers);
/* Check for correct response. */ /* Check for correct response. */
if ((hdr.flags1 & DNS_FLAG1_RESPONSE) == 0) { if ((hdr.flags1 & DNS_FLAG1_RESPONSE) == 0) {
@ -1121,7 +1121,7 @@ dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
ip_addr_copy_from_ip4(dns_table[i].ipaddr, ip4addr); ip_addr_copy_from_ip4(dns_table[i].ipaddr, ip4addr);
pbuf_free(p); pbuf_free(p);
/* handle correct response */ /* handle correct response */
dns_correct_response(i, ntohl(ans.ttl)); dns_correct_response(i, lwip_ntohl(ans.ttl));
return; return;
} }
} }
@ -1140,17 +1140,17 @@ dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
ip_addr_copy_from_ip6(dns_table[i].ipaddr, ip6addr); ip_addr_copy_from_ip6(dns_table[i].ipaddr, ip6addr);
pbuf_free(p); pbuf_free(p);
/* handle correct response */ /* handle correct response */
dns_correct_response(i, ntohl(ans.ttl)); dns_correct_response(i, lwip_ntohl(ans.ttl));
return; return;
} }
} }
#endif /* LWIP_IPV6 */ #endif /* LWIP_IPV6 */
} }
/* skip this answer */ /* skip this answer */
if ((int)(res_idx + htons(ans.len)) > 0xFFFF) { if ((int)(res_idx + lwip_htons(ans.len)) > 0xFFFF) {
goto memerr; /* ignore this packet */ goto memerr; /* ignore this packet */
} }
res_idx += htons(ans.len); res_idx += lwip_htons(ans.len);
--nanswers; --nanswers;
} }
#if LWIP_IPV4 && LWIP_IPV6 #if LWIP_IPV4 && LWIP_IPV6

14
src/core/inet_chksum.c
View File

@ -108,10 +108,10 @@ lwip_standard_chksum(const void *dataptr, int len)
if ((acc & 0xffff0000UL) != 0) { if ((acc & 0xffff0000UL) != 0) {
acc = (acc >> 16) + (acc & 0x0000ffffUL); acc = (acc >> 16) + (acc & 0x0000ffffUL);
} }
/* This maybe a little confusing: reorder sum using htons() /* This maybe a little confusing: reorder sum using lwip_htons()
instead of ntohs() since it has a little less call overhead. instead of lwip_ntohs() since it has a little less call overhead.
The caller must invert bits for Internet sum ! */ The caller must invert bits for Internet sum ! */
return htons((u16_t)acc); return lwip_htons((u16_t)acc);
} }
#endif #endif
@ -283,8 +283,8 @@ inet_cksum_pseudo_base(struct pbuf *p, u8_t proto, u16_t proto_len, u32_t acc)
acc = SWAP_BYTES_IN_WORD(acc); acc = SWAP_BYTES_IN_WORD(acc);
} }
acc += (u32_t)htons((u16_t)proto); acc += (u32_t)lwip_htons((u16_t)proto);
acc += (u32_t)htons(proto_len); acc += (u32_t)lwip_htons(proto_len);
/* Fold 32-bit sum to 16 bits /* Fold 32-bit sum to 16 bits
calling this twice is probably faster than if statements... */ calling this twice is probably faster than if statements... */
@ -429,8 +429,8 @@ inet_cksum_pseudo_partial_base(struct pbuf *p, u8_t proto, u16_t proto_len,
acc = SWAP_BYTES_IN_WORD(acc); acc = SWAP_BYTES_IN_WORD(acc);
} }
acc += (u32_t)htons((u16_t)proto); acc += (u32_t)lwip_htons((u16_t)proto);
acc += (u32_t)htons(proto_len); acc += (u32_t)lwip_htons(proto_len);
/* Fold 32-bit sum to 16 bits /* Fold 32-bit sum to 16 bits
calling this twice is probably faster than if statements... */ calling this twice is probably faster than if statements... */

6
src/core/ipv4/autoip.c
View File

@ -87,7 +87,7 @@
*/ */
#ifndef LWIP_AUTOIP_CREATE_SEED_ADDR #ifndef LWIP_AUTOIP_CREATE_SEED_ADDR
#define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \ #define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \
htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \ lwip_htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \
((u32_t)((u8_t)(netif->hwaddr[5]))) << 8))) ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8)))
#endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */ #endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */
@ -176,7 +176,7 @@ autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
* compliant to RFC 3927 Section 2.1 * compliant to RFC 3927 Section 2.1
* We have 254 * 256 possibilities */ * We have 254 * 256 possibilities */
u32_t addr = ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif)); u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif));
addr += autoip->tried_llipaddr; addr += autoip->tried_llipaddr;
addr = AUTOIP_NET | (addr & 0xffff); addr = AUTOIP_NET | (addr & 0xffff);
/* Now, 169.254.0.0 <= addr <= 169.254.255.255 */ /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */
@ -189,7 +189,7 @@ autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
} }
LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) && LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) &&
(addr <= AUTOIP_RANGE_END)); (addr <= AUTOIP_RANGE_END));
ip4_addr_set_u32(ipaddr, htonl(addr)); ip4_addr_set_u32(ipaddr, lwip_htonl(addr));
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",

30
src/core/ipv4/dhcp.c
View File

@ -311,7 +311,7 @@ dhcp_handle_offer(struct netif *netif)
(void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num));
/* obtain the server address */ /* obtain the server address */
if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) { if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) {
ip_addr_set_ip4_u32(&dhcp->server_ip_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID))); ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID)));
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n", LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n",
ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr))));
/* remember offered address */ /* remember offered address */
@ -353,10 +353,10 @@ dhcp_select(struct netif *netif)
/* MUST request the offered IP address */ /* MUST request the offered IP address */
dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4); dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr))));
dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) {
@ -621,7 +621,7 @@ dhcp_handle_ack(struct netif *netif)
/* subnet mask given? */ /* subnet mask given? */
if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) { if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) {
/* remember given subnet mask */ /* remember given subnet mask */
ip4_addr_set_u32(&dhcp->offered_sn_mask, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK))); ip4_addr_set_u32(&dhcp->offered_sn_mask, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)));
dhcp->subnet_mask_given = 1; dhcp->subnet_mask_given = 1;
} else { } else {
dhcp->subnet_mask_given = 0; dhcp->subnet_mask_given = 0;
@ -629,13 +629,13 @@ dhcp_handle_ack(struct netif *netif)
/* gateway router */ /* gateway router */
if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) { if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) {
ip4_addr_set_u32(&dhcp->offered_gw_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER))); ip4_addr_set_u32(&dhcp->offered_gw_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER)));
} }
#if LWIP_DHCP_GET_NTP_SRV #if LWIP_DHCP_GET_NTP_SRV
/* NTP servers */ /* NTP servers */
for (n = 0; (n < LWIP_DHCP_MAX_NTP_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n); n++) { for (n = 0; (n < LWIP_DHCP_MAX_NTP_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n); n++) {
ip4_addr_set_u32(&ntp_server_addrs[n], htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n))); ip4_addr_set_u32(&ntp_server_addrs[n], lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n)));
} }
dhcp_set_ntp_servers(n, ntp_server_addrs); dhcp_set_ntp_servers(n, ntp_server_addrs);
#endif /* LWIP_DHCP_GET_NTP_SRV */ #endif /* LWIP_DHCP_GET_NTP_SRV */
@ -644,7 +644,7 @@ dhcp_handle_ack(struct netif *netif)
/* DNS servers */ /* DNS servers */
for (n = 0; (n < DNS_MAX_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) { for (n = 0; (n < DNS_MAX_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) {
ip_addr_t dns_addr; ip_addr_t dns_addr;
ip_addr_set_ip4_u32(&dns_addr, htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n))); ip_addr_set_ip4_u32(&dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n)));
dns_setserver(n, &dns_addr); dns_setserver(n, &dns_addr);
} }
#endif /* LWIP_DNS */ #endif /* LWIP_DNS */
@ -913,7 +913,7 @@ dhcp_decline(struct netif *netif)
result = dhcp_create_msg(netif, dhcp, DHCP_DECLINE); result = dhcp_create_msg(netif, dhcp, DHCP_DECLINE);
if (result == ERR_OK) { if (result == ERR_OK) {
dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
dhcp_option_trailer(dhcp); dhcp_option_trailer(dhcp);
/* resize pbuf to reflect true size of options */ /* resize pbuf to reflect true size of options */
@ -1228,7 +1228,7 @@ dhcp_reboot(struct netif *netif)
dhcp_option_short(dhcp, 576); dhcp_option_short(dhcp, 576);
dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4);
dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr)));
dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options));
for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) {
@ -1300,7 +1300,7 @@ dhcp_release(struct netif *netif)
result = dhcp_create_msg(netif, dhcp, DHCP_RELEASE); result = dhcp_create_msg(netif, dhcp, DHCP_RELEASE);
if (result == ERR_OK) { if (result == ERR_OK) {
dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4); dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4);
dhcp_option_long(dhcp, ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr)))); dhcp_option_long(dhcp, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr))));
dhcp_option_trailer(dhcp); dhcp_option_trailer(dhcp);
@ -1579,13 +1579,13 @@ decode_next:
/* decode more than one u32_t */ /* decode more than one u32_t */
LWIP_ERROR("decode_len % 4 == 0", decode_len % 4 == 0, return ERR_VAL;); LWIP_ERROR("decode_len % 4 == 0", decode_len % 4 == 0, return ERR_VAL;);
dhcp_got_option(dhcp, decode_idx); dhcp_got_option(dhcp, decode_idx);
dhcp_set_option_value(dhcp, decode_idx, htonl(value)); dhcp_set_option_value(dhcp, decode_idx, lwip_htonl(value));
decode_len -= 4; decode_len -= 4;
val_offset += 4; val_offset += 4;
decode_idx++; decode_idx++;
goto decode_next; goto decode_next;
} else if (decode_len == 4) { } else if (decode_len == 4) {
value = ntohl(value); value = lwip_ntohl(value);
} else { } else {
LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;); LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;);
value = ((u8_t*)&value)[0]; value = ((u8_t*)&value)[0];
@ -1704,9 +1704,9 @@ dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr,
} }
} }
/* match transaction ID against what we expected */ /* match transaction ID against what we expected */
if (ntohl(reply_msg->xid) != dhcp->xid) { if (lwip_ntohl(reply_msg->xid) != dhcp->xid) {
LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING,
("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",ntohl(reply_msg->xid),dhcp->xid)); ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",lwip_ntohl(reply_msg->xid),dhcp->xid));
goto free_pbuf_and_return; goto free_pbuf_and_return;
} }
/* option fields could be unfold? */ /* option fields could be unfold? */
@ -1835,7 +1835,7 @@ dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type)
dhcp->msg_out->htype = DHCP_HTYPE_ETH; dhcp->msg_out->htype = DHCP_HTYPE_ETH;
dhcp->msg_out->hlen = netif->hwaddr_len; dhcp->msg_out->hlen = netif->hwaddr_len;
dhcp->msg_out->hops = 0; dhcp->msg_out->hops = 0;
dhcp->msg_out->xid = htonl(dhcp->xid); dhcp->msg_out->xid = lwip_htonl(dhcp->xid);
dhcp->msg_out->secs = 0; dhcp->msg_out->secs = 0;
/* we don't need the broadcast flag since we can receive unicast traffic /* we don't need the broadcast flag since we can receive unicast traffic
before being fully configured! */ before being fully configured! */

6
src/core/ipv4/etharp.c
View File

@ -701,7 +701,7 @@ etharp_input(struct pbuf *p, struct netif *netif)
/* Re-use pbuf to send ARP reply. /* Re-use pbuf to send ARP reply.
Since we are re-using an existing pbuf, we can't call etharp_raw since Since we are re-using an existing pbuf, we can't call etharp_raw since
that would allocate a new pbuf. */ that would allocate a new pbuf. */
hdr->opcode = htons(ARP_REPLY); hdr->opcode = lwip_htons(ARP_REPLY);
IPADDR2_COPY(&hdr->dipaddr, &hdr->sipaddr); IPADDR2_COPY(&hdr->dipaddr, &hdr->sipaddr);
IPADDR2_COPY(&hdr->sipaddr, netif_ip4_addr(netif)); IPADDR2_COPY(&hdr->sipaddr, netif_ip4_addr(netif));
@ -750,7 +750,7 @@ etharp_input(struct pbuf *p, struct netif *netif)
#endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */ #endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */
break; break;
default: default:
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", htons(hdr->opcode))); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", lwip_htons(hdr->opcode)));
ETHARP_STATS_INC(etharp.err); ETHARP_STATS_INC(etharp.err);
break; break;
} }
@ -1144,7 +1144,7 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
hdr = (struct etharp_hdr *)p->payload; hdr = (struct etharp_hdr *)p->payload;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n")); LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n"));
hdr->opcode = htons(opcode); hdr->opcode = lwip_htons(opcode);
LWIP_ASSERT("netif->hwaddr_len must be the same as ETH_HWADDR_LEN for etharp!", LWIP_ASSERT("netif->hwaddr_len must be the same as ETH_HWADDR_LEN for etharp!",
(netif->hwaddr_len == ETH_HWADDR_LEN)); (netif->hwaddr_len == ETH_HWADDR_LEN));

28
src/core/ipv4/ip4.c
View File

@ -228,7 +228,7 @@ ip4_route(const ip4_addr_t *dest)
static int static int
ip4_canforward(struct pbuf *p) ip4_canforward(struct pbuf *p)
{ {
u32_t addr = htonl(ip4_addr_get_u32(ip4_current_dest_addr())); u32_t addr = lwip_htonl(ip4_addr_get_u32(ip4_current_dest_addr()));
if (p->flags & PBUF_FLAG_LLBCAST) { if (p->flags & PBUF_FLAG_LLBCAST) {
/* don't route link-layer broadcasts */ /* don't route link-layer broadcasts */
@ -405,7 +405,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
/* calculate IP header length in bytes */ /* calculate IP header length in bytes */
iphdr_hlen *= 4; iphdr_hlen *= 4;
/* obtain ip length in bytes */ /* obtain ip length in bytes */
iphdr_len = ntohs(IPH_LEN(iphdr)); iphdr_len = lwip_ntohs(IPH_LEN(iphdr));
/* Trim pbuf. This is especially required for packets < 60 bytes. */ /* Trim pbuf. This is especially required for packets < 60 bytes. */
if (iphdr_len < p->tot_len) { if (iphdr_len < p->tot_len) {
@ -545,7 +545,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
if (IPH_PROTO(iphdr) == IP_PROTO_UDP) { if (IPH_PROTO(iphdr) == IP_PROTO_UDP) {
struct udp_hdr *udphdr = (struct udp_hdr *)((u8_t *)iphdr + iphdr_hlen); struct udp_hdr *udphdr = (struct udp_hdr *)((u8_t *)iphdr + iphdr_hlen);
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n", LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n",
ntohs(udphdr->dest))); lwip_ntohs(udphdr->dest)));
if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) { if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) {
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n")); LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n"));
netif = inp; netif = inp;
@ -600,7 +600,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) { if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) {
#if IP_REASSEMBLY /* packet fragment reassembly code present? */ #if IP_REASSEMBLY /* packet fragment reassembly code present? */
LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n", LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n",
ntohs(IPH_ID(iphdr)), p->tot_len, ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8))); lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)*8)));
/* reassemble the packet*/ /* reassemble the packet*/
p = ip4_reass(p); p = ip4_reass(p);
/* packet not fully reassembled yet? */ /* packet not fully reassembled yet? */
@ -611,7 +611,7 @@ ip4_input(struct pbuf *p, struct netif *inp)
#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */ #else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */
pbuf_free(p); pbuf_free(p);
LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n", LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n",
ntohs(IPH_OFFSET(iphdr)))); lwip_ntohs(IPH_OFFSET(iphdr))));
IP_STATS_INC(ip.opterr); IP_STATS_INC(ip.opterr);
IP_STATS_INC(ip.drop); IP_STATS_INC(ip.drop);
/* unsupported protocol feature */ /* unsupported protocol feature */
@ -869,12 +869,12 @@ ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *d
#if CHECKSUM_GEN_IP_INLINE #if CHECKSUM_GEN_IP_INLINE
chk_sum += LWIP_MAKE_U16(tos, iphdr->_v_hl); chk_sum += LWIP_MAKE_U16(tos, iphdr->_v_hl);
#endif /* CHECKSUM_GEN_IP_INLINE */ #endif /* CHECKSUM_GEN_IP_INLINE */
IPH_LEN_SET(iphdr, htons(p->tot_len)); IPH_LEN_SET(iphdr, lwip_htons(p->tot_len));
#if CHECKSUM_GEN_IP_INLINE #if CHECKSUM_GEN_IP_INLINE
chk_sum += iphdr->_len; chk_sum += iphdr->_len;
#endif /* CHECKSUM_GEN_IP_INLINE */ #endif /* CHECKSUM_GEN_IP_INLINE */
IPH_OFFSET_SET(iphdr, 0); IPH_OFFSET_SET(iphdr, 0);
IPH_ID_SET(iphdr, htons(ip_id)); IPH_ID_SET(iphdr, lwip_htons(ip_id));
#if CHECKSUM_GEN_IP_INLINE #if CHECKSUM_GEN_IP_INLINE
chk_sum += iphdr->_id; chk_sum += iphdr->_id;
#endif /* CHECKSUM_GEN_IP_INLINE */ #endif /* CHECKSUM_GEN_IP_INLINE */
@ -1041,19 +1041,19 @@ ip4_debug_print(struct pbuf *p)
(u16_t)IPH_V(iphdr), (u16_t)IPH_V(iphdr),
(u16_t)IPH_HL(iphdr), (u16_t)IPH_HL(iphdr),
(u16_t)IPH_TOS(iphdr), (u16_t)IPH_TOS(iphdr),
ntohs(IPH_LEN(iphdr)))); lwip_ntohs(IPH_LEN(iphdr))));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n", LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n",
ntohs(IPH_ID(iphdr)), lwip_ntohs(IPH_ID(iphdr)),
(u16_t)(ntohs(IPH_OFFSET(iphdr)) >> 15 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 15 & 1),
(u16_t)(ntohs(IPH_OFFSET(iphdr)) >> 14 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 14 & 1),
(u16_t)(ntohs(IPH_OFFSET(iphdr)) >> 13 & 1), (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 13 & 1),
(u16_t)(ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK))); (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK)));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n", LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n",
(u16_t)IPH_TTL(iphdr), (u16_t)IPH_TTL(iphdr),
(u16_t)IPH_PROTO(iphdr), (u16_t)IPH_PROTO(iphdr),
ntohs(IPH_CHKSUM(iphdr)))); lwip_ntohs(IPH_CHKSUM(iphdr))));
LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n", LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n",
ip4_addr1_16(&iphdr->src), ip4_addr1_16(&iphdr->src),

2
src/core/ipv4/ip4_addr.c
View File

@ -260,7 +260,7 @@ ip4addr_aton(const char *cp, ip4_addr_t *addr)
break; break;
} }
if (addr) { if (addr) {
ip4_addr_set_u32(addr, htonl(val)); ip4_addr_set_u32(addr, lwip_htonl(val));
} }
return 1; return 1;
} }

22
src/core/ipv4/ip4_frag.c
View File

@ -346,8 +346,8 @@ ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct
/* Extract length and fragment offset from current fragment */ /* Extract length and fragment offset from current fragment */
fraghdr = (struct ip_hdr*)new_p->payload; fraghdr = (struct ip_hdr*)new_p->payload;
len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4; len = lwip_ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8; offset = (lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
/* overwrite the fragment's ip header from the pbuf with our helper struct, /* overwrite the fragment's ip header from the pbuf with our helper struct,
* and setup the embedded helper structure. */ * and setup the embedded helper structure. */
@ -500,8 +500,8 @@ ip4_reass(struct pbuf *p)
goto nullreturn; goto nullreturn;
} }
offset = (ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8; offset = (lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) * 8;
len = ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4; len = lwip_ntohs(IPH_LEN(fraghdr)) - IPH_HL(fraghdr) * 4;
/* Check if we are allowed to enqueue more datagrams. */ /* Check if we are allowed to enqueue more datagrams. */
clen = pbuf_clen(p); clen = pbuf_clen(p);
@ -529,7 +529,7 @@ ip4_reass(struct pbuf *p)
fragment into the buffer. */ fragment into the buffer. */
if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) { if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) {
LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n", LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n",
ntohs(IPH_ID(fraghdr)))); lwip_ntohs(IPH_ID(fraghdr))));
IPFRAG_STATS_INC(ip_frag.cachehit); IPFRAG_STATS_INC(ip_frag.cachehit);
break; break;
} }
@ -543,8 +543,8 @@ ip4_reass(struct pbuf *p)
goto nullreturn; goto nullreturn;
} }
} else { } else {
if (((ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) &&
((ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) { ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) {
/* ipr->iphdr is not the header from the first fragment, but fraghdr is /* ipr->iphdr is not the header from the first fragment, but fraghdr is
* -> copy fraghdr into ipr->iphdr since we want to have the header * -> copy fraghdr into ipr->iphdr since we want to have the header
* of the first fragment (for ICMP time exceeded and later, for copying * of the first fragment (for ICMP time exceeded and later, for copying
@ -581,7 +581,7 @@ ip4_reass(struct pbuf *p)
/* copy the original ip header back to the first pbuf */ /* copy the original ip header back to the first pbuf */
fraghdr = (struct ip_hdr*)(ipr->p->payload); fraghdr = (struct ip_hdr*)(ipr->p->payload);
SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN); SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN);
IPH_LEN_SET(fraghdr, htons(ipr->datagram_len)); IPH_LEN_SET(fraghdr, lwip_htons(ipr->datagram_len));
IPH_OFFSET_SET(fraghdr, 0); IPH_OFFSET_SET(fraghdr, 0);
IPH_CHKSUM_SET(fraghdr, 0); IPH_CHKSUM_SET(fraghdr, 0);
/* @todo: do we need to set/calculate the correct checksum? */ /* @todo: do we need to set/calculate the correct checksum? */
@ -706,7 +706,7 @@ ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
iphdr = original_iphdr; iphdr = original_iphdr;
/* Save original offset */ /* Save original offset */
tmp = ntohs(IPH_OFFSET(iphdr)); tmp = lwip_ntohs(IPH_OFFSET(iphdr));
ofo = tmp & IP_OFFMASK; ofo = tmp & IP_OFFMASK;
omf = tmp & IP_MF; omf = tmp & IP_MF;
@ -799,8 +799,8 @@ ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest)
#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
/* Correct header */ /* Correct header */
IPH_OFFSET_SET(iphdr, htons(tmp)); IPH_OFFSET_SET(iphdr, lwip_htons(tmp));
IPH_LEN_SET(iphdr, htons(cop + IP_HLEN)); IPH_LEN_SET(iphdr, lwip_htons(cop + IP_HLEN));
IPH_CHKSUM_SET(iphdr, 0); IPH_CHKSUM_SET(iphdr, 0);
#if CHECKSUM_GEN_IP #if CHECKSUM_GEN_IP
IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) {

6
src/core/ipv6/ip6_addr.c
View File

@ -152,7 +152,7 @@ ip6addr_aton(const char *cp, ip6_addr_t *addr)
/* convert to network byte order. */ /* convert to network byte order. */
if (addr) { if (addr) {
for (addr_index = 0; addr_index < 4; addr_index++) { for (addr_index = 0; addr_index < 4; addr_index++) {
addr->addr[addr_index] = htonl(addr->addr[addr_index]); addr->addr[addr_index] = lwip_htonl(addr->addr[addr_index]);
} }
} }
@ -199,7 +199,7 @@ ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen)
for (current_block_index = 0; current_block_index < 8; current_block_index++) { for (current_block_index = 0; current_block_index < 8; current_block_index++) {
/* get the current 16-bit block */ /* get the current 16-bit block */
current_block_value = htonl(addr->addr[current_block_index >> 1]); current_block_value = lwip_htonl(addr->addr[current_block_index >> 1]);
if ((current_block_index & 0x1) == 0) { if ((current_block_index & 0x1) == 0) {
current_block_value = current_block_value >> 16; current_block_value = current_block_value >> 16;
} }
@ -218,7 +218,7 @@ ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen)
if (empty_block_flag == 0) { if (empty_block_flag == 0) {
/* generate empty block "::", but only if more than one contiguous zero block, /* generate empty block "::", but only if more than one contiguous zero block,
* according to current formatting suggestions RFC 5952. */ * according to current formatting suggestions RFC 5952. */
next_block_value = htonl(addr->addr[(current_block_index + 1) >> 1]); next_block_value = lwip_htonl(addr->addr[(current_block_index + 1) >> 1]);
if ((current_block_index & 0x1) == 0x01) { if ((current_block_index & 0x1) == 0x01) {
next_block_value = next_block_value >> 16; next_block_value = next_block_value >> 16;
} }

10
src/core/ipv6/ip6_frag.c
View File

@ -279,12 +279,12 @@ ip6_reass(struct pbuf *p)
clen = pbuf_clen(p); clen = pbuf_clen(p);
offset = ntohs(frag_hdr->_fragment_offset); offset = lwip_ntohs(frag_hdr->_fragment_offset);
/* Calculate fragment length from IPv6 payload length. /* Calculate fragment length from IPv6 payload length.
* Adjust for headers before Fragment Header. * Adjust for headers before Fragment Header.
* And finally adjust by Fragment Header length. */ * And finally adjust by Fragment Header length. */
len = ntohs(ip6_current_header()->_plen); len = lwip_ntohs(ip6_current_header()->_plen);
len -= (u16_t)(((u8_t*)p->payload - (const u8_t*)ip6_current_header()) - IP6_HLEN); len -= (u16_t)(((u8_t*)p->payload - (const u8_t*)ip6_current_header()) - IP6_HLEN);
len -= IP6_FRAG_HLEN; len -= IP6_FRAG_HLEN;
@ -560,7 +560,7 @@ ip6_reass(struct pbuf *p)
- IP6_HLEN); - IP6_HLEN);
/* Set payload length in ip header. */ /* Set payload length in ip header. */
iphdr_ptr->_plen = htons(ipr->datagram_len); iphdr_ptr->_plen = lwip_htons(ipr->datagram_len);
/* Get the first pbuf. */ /* Get the first pbuf. */
p = ipr->p; p = ipr->p;
@ -748,8 +748,8 @@ ip6_frag(struct pbuf *p, struct netif *netif, const ip6_addr_t *dest)
/* Set headers */ /* Set headers */
frag_hdr->_nexth = original_ip6hdr->_nexth; frag_hdr->_nexth = original_ip6hdr->_nexth;
frag_hdr->reserved = 0; frag_hdr->reserved = 0;
frag_hdr->_fragment_offset = htons((fragment_offset & IP6_FRAG_OFFSET_MASK) | (last ? 0 : IP6_FRAG_MORE_FLAG)); frag_hdr->_fragment_offset = lwip_htons((fragment_offset & IP6_FRAG_OFFSET_MASK) | (last ? 0 : IP6_FRAG_MORE_FLAG));
frag_hdr->_identification = htonl(identification); frag_hdr->_identification = lwip_htonl(identification);
IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_FRAGMENT); IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_FRAGMENT);
IP6H_PLEN_SET(ip6hdr, cop + IP6_FRAG_HLEN); IP6H_PLEN_SET(ip6hdr, cop + IP6_FRAG_HLEN);

14
src/core/ipv6/nd6.c
View File

@ -420,15 +420,15 @@ nd6_input(struct pbuf *p, struct netif *inp)
} }
/* Re-set invalidation timer. */ /* Re-set invalidation timer. */
default_router_list[i].invalidation_timer = htons(ra_hdr->router_lifetime); default_router_list[i].invalidation_timer = lwip_htons(ra_hdr->router_lifetime);
/* Re-set default timer values. */ /* Re-set default timer values. */
#if LWIP_ND6_ALLOW_RA_UPDATES #if LWIP_ND6_ALLOW_RA_UPDATES
if (ra_hdr->retrans_timer > 0) { if (ra_hdr->retrans_timer > 0) {
retrans_timer = htonl(ra_hdr->retrans_timer); retrans_timer = lwip_htonl(ra_hdr->retrans_timer);
} }
if (ra_hdr->reachable_time > 0) { if (ra_hdr->reachable_time > 0) {
reachable_time = htonl(ra_hdr->reachable_time); reachable_time = lwip_htonl(ra_hdr->reachable_time);
} }
#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ #endif /* LWIP_ND6_ALLOW_RA_UPDATES */
@ -479,9 +479,9 @@ nd6_input(struct pbuf *p, struct netif *inp)
{ {
struct mtu_option *mtu_opt; struct mtu_option *mtu_opt;
mtu_opt = (struct mtu_option *)buffer; mtu_opt = (struct mtu_option *)buffer;
if (htonl(mtu_opt->mtu) >= 1280) { if (lwip_htonl(mtu_opt->mtu) >= 1280) {
#if LWIP_ND6_ALLOW_RA_UPDATES #if LWIP_ND6_ALLOW_RA_UPDATES
inp->mtu = (u16_t)htonl(mtu_opt->mtu); inp->mtu = (u16_t)lwip_htonl(mtu_opt->mtu);
#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ #endif /* LWIP_ND6_ALLOW_RA_UPDATES */
} }
break; break;
@ -507,7 +507,7 @@ nd6_input(struct pbuf *p, struct netif *inp)
prefix = nd6_new_onlink_prefix(ip6_current_dest_addr(), inp); prefix = nd6_new_onlink_prefix(ip6_current_dest_addr(), inp);
} }
if (prefix >= 0) { if (prefix >= 0) {
prefix_list[prefix].invalidation_timer = htonl(prefix_opt->valid_lifetime); prefix_list[prefix].invalidation_timer = lwip_htonl(prefix_opt->valid_lifetime);
#if LWIP_IPV6_AUTOCONFIG #if LWIP_IPV6_AUTOCONFIG
if (prefix_opt->flags & ND6_PREFIX_FLAG_AUTONOMOUS) { if (prefix_opt->flags & ND6_PREFIX_FLAG_AUTONOMOUS) {
@ -640,7 +640,7 @@ nd6_input(struct pbuf *p, struct netif *inp)
} }
/* Change the Path MTU. */ /* Change the Path MTU. */
pmtu = htonl(icmp6hdr->data); pmtu = lwip_htonl(icmp6hdr->data);
destination_cache[i].pmtu = (u16_t)LWIP_MIN(pmtu, 0xFFFF); destination_cache[i].pmtu = (u16_t)LWIP_MIN(pmtu, 0xFFFF);
break; /* ICMP6_TYPE_PTB */ break; /* ICMP6_TYPE_PTB */

4
src/core/netif.c
View File

@ -1175,11 +1175,11 @@ netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit)
/* Generate interface ID. */ /* Generate interface ID. */
if (from_mac_48bit) { if (from_mac_48bit) {
/* Assume hwaddr is a 48-bit IEEE 802 MAC. Convert to EUI-64 address. Complement Group bit. */ /* Assume hwaddr is a 48-bit IEEE 802 MAC. Convert to EUI-64 address. Complement Group bit. */
ip_2_ip6(&netif->ip6_addr[0])->addr[2] = htonl((((u32_t)(netif->hwaddr[0] ^ 0x02)) << 24) | ip_2_ip6(&netif->ip6_addr[0])->addr[2] = lwip_htonl((((u32_t)(netif->hwaddr[0] ^ 0x02)) << 24) |
((u32_t)(netif->hwaddr[1]) << 16) | ((u32_t)(netif->hwaddr[1]) << 16) |
((u32_t)(netif->hwaddr[2]) << 8) | ((u32_t)(netif->hwaddr[2]) << 8) |
(0xff)); (0xff));
ip_2_ip6(&netif->ip6_addr[0])->addr[3] = htonl((0xfeul << 24) | ip_2_ip6(&netif->ip6_addr[0])->addr[3] = lwip_htonl((0xfeul << 24) |
((u32_t)(netif->hwaddr[3]) << 16) | ((u32_t)(netif->hwaddr[3]) << 16) |
((u32_t)(netif->hwaddr[4]) << 8) | ((u32_t)(netif->hwaddr[4]) << 8) |
(netif->hwaddr[5])); (netif->hwaddr[5]));

10
src/core/tcp.c
View File

@ -1972,13 +1972,13 @@ tcp_debug_print(struct tcp_hdr *tcphdr)
LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n")); LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n"));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(TCP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", LWIP_DEBUGF(TCP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n",
ntohs(tcphdr->src), ntohs(tcphdr->dest))); lwip_ntohs(tcphdr->src), lwip_ntohs(tcphdr->dest)));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (seq no)\n", LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (seq no)\n",
ntohl(tcphdr->seqno))); lwip_ntohl(tcphdr->seqno)));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (ack no)\n", LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (ack no)\n",
ntohl(tcphdr->ackno))); lwip_ntohl(tcphdr->ackno)));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" | |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"| %5"U16_F" | (hdrlen, flags (", LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" | |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"| %5"U16_F" | (hdrlen, flags (",
TCPH_HDRLEN(tcphdr), TCPH_HDRLEN(tcphdr),
@ -1988,12 +1988,12 @@ tcp_debug_print(struct tcp_hdr *tcphdr)
(u16_t)(TCPH_FLAGS(tcphdr) >> 2 & 1), (u16_t)(TCPH_FLAGS(tcphdr) >> 2 & 1),
(u16_t)(TCPH_FLAGS(tcphdr) >> 1 & 1), (u16_t)(TCPH_FLAGS(tcphdr) >> 1 & 1),
(u16_t)(TCPH_FLAGS(tcphdr) & 1), (u16_t)(TCPH_FLAGS(tcphdr) & 1),
ntohs(tcphdr->wnd))); lwip_ntohs(tcphdr->wnd)));
tcp_debug_print_flags(TCPH_FLAGS(tcphdr)); tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
LWIP_DEBUGF(TCP_DEBUG, ("), win)\n")); LWIP_DEBUGF(TCP_DEBUG, ("), win)\n"));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(TCP_DEBUG, ("| 0x%04"X16_F" | %5"U16_F" | (chksum, urgp)\n", LWIP_DEBUGF(TCP_DEBUG, ("| 0x%04"X16_F" | %5"U16_F" | (chksum, urgp)\n",
ntohs(tcphdr->chksum), ntohs(tcphdr->urgp))); lwip_ntohs(tcphdr->chksum), lwip_ntohs(tcphdr->urgp)));
LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
} }

30
src/core/tcp_in.c
View File

@ -209,11 +209,11 @@ tcp_input(struct pbuf *p, struct netif *inp)
} }
/* Convert fields in TCP header to host byte order. */ /* Convert fields in TCP header to host byte order. */
tcphdr->src = ntohs(tcphdr->src); tcphdr->src = lwip_ntohs(tcphdr->src);
tcphdr->dest = ntohs(tcphdr->dest); tcphdr->dest = lwip_ntohs(tcphdr->dest);
seqno = tcphdr->seqno = ntohl(tcphdr->seqno); seqno = tcphdr->seqno = lwip_ntohl(tcphdr->seqno);
ackno = tcphdr->ackno = ntohl(tcphdr->ackno); ackno = tcphdr->ackno = lwip_ntohl(tcphdr->ackno);
tcphdr->wnd = ntohs(tcphdr->wnd); tcphdr->wnd = lwip_ntohs(tcphdr->wnd);
flags = TCPH_FLAGS(tcphdr); flags = TCPH_FLAGS(tcphdr);
tcplen = p->tot_len + ((flags & (TCP_FIN | TCP_SYN)) ? 1 : 0); tcplen = p->tot_len + ((flags & (TCP_FIN | TCP_SYN)) ? 1 : 0);
@ -747,7 +747,7 @@ tcp_process(struct tcp_pcb *pcb)
switch (pcb->state) { switch (pcb->state) {
case SYN_SENT: case SYN_SENT:
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno, LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno,
pcb->snd_nxt, ntohl(pcb->unacked->tcphdr->seqno))); pcb->snd_nxt, lwip_ntohl(pcb->unacked->tcphdr->seqno)));
/* received SYN ACK with expected sequence number? */ /* received SYN ACK with expected sequence number? */
if ((flags & TCP_ACK) && (flags & TCP_SYN) if ((flags & TCP_ACK) && (flags & TCP_SYN)
&& (ackno == pcb->lastack + 1)) { && (ackno == pcb->lastack + 1)) {
@ -1140,18 +1140,18 @@ tcp_receive(struct tcp_pcb *pcb)
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: ACK for %"U32_F", unacked->seqno %"U32_F":%"U32_F"\n", LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: ACK for %"U32_F", unacked->seqno %"U32_F":%"U32_F"\n",
ackno, ackno,
pcb->unacked != NULL? pcb->unacked != NULL?
ntohl(pcb->unacked->tcphdr->seqno): 0, lwip_ntohl(pcb->unacked->tcphdr->seqno): 0,
pcb->unacked != NULL? pcb->unacked != NULL?
ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked): 0)); lwip_ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked): 0));
/* Remove segment from the unacknowledged list if the incoming /* Remove segment from the unacknowledged list if the incoming
ACK acknowledges them. */ ACK acknowledges them. */
while (pcb->unacked != NULL && while (pcb->unacked != NULL &&
TCP_SEQ_LEQ(ntohl(pcb->unacked->tcphdr->seqno) + TCP_SEQ_LEQ(lwip_ntohl(pcb->unacked->tcphdr->seqno) +
TCP_TCPLEN(pcb->unacked), ackno)) { TCP_TCPLEN(pcb->unacked), ackno)) {
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unacked\n", LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unacked\n",
ntohl(pcb->unacked->tcphdr->seqno), lwip_ntohl(pcb->unacked->tcphdr->seqno),
ntohl(pcb->unacked->tcphdr->seqno) + lwip_ntohl(pcb->unacked->tcphdr->seqno) +
TCP_TCPLEN(pcb->unacked))); TCP_TCPLEN(pcb->unacked)));
next = pcb->unacked; next = pcb->unacked;
@ -1199,10 +1199,10 @@ tcp_receive(struct tcp_pcb *pcb)
->unsent list after a retransmission, so these segments may ->unsent list after a retransmission, so these segments may
in fact have been sent once. */ in fact have been sent once. */
while (pcb->unsent != NULL && while (pcb->unsent != NULL &&
TCP_SEQ_BETWEEN(ackno, ntohl(pcb->unsent->tcphdr->seqno) + TCP_SEQ_BETWEEN(ackno, lwip_ntohl(pcb->unsent->tcphdr->seqno) +
TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) { TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) {
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unsent\n", LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unsent\n",
ntohl(pcb->unsent->tcphdr->seqno), ntohl(pcb->unsent->tcphdr->seqno) + lwip_ntohl(pcb->unsent->tcphdr->seqno), lwip_ntohl(pcb->unsent->tcphdr->seqno) +
TCP_TCPLEN(pcb->unsent))); TCP_TCPLEN(pcb->unsent)));
next = pcb->unsent; next = pcb->unsent;
@ -1779,12 +1779,12 @@ tcp_parseopt(struct tcp_pcb *pcb)
tsval |= (tcp_getoptbyte() << 16); tsval |= (tcp_getoptbyte() << 16);
tsval |= (tcp_getoptbyte() << 24); tsval |= (tcp_getoptbyte() << 24);
if (flags & TCP_SYN) { if (flags & TCP_SYN) {
pcb->ts_recent = ntohl(tsval); pcb->ts_recent = lwip_ntohl(tsval);
/* Enable sending timestamps in every segment now that we know /* Enable sending timestamps in every segment now that we know
the remote host supports it. */ the remote host supports it. */
pcb->flags |= TF_TIMESTAMP; pcb->flags |= TF_TIMESTAMP;
} else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno+tcplen)) { } else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno+tcplen)) {
pcb->ts_recent = ntohl(tsval); pcb->ts_recent = lwip_ntohl(tsval);
} }
/* Advance to next option (6 bytes already read) */ /* Advance to next option (6 bytes already read) */
tcp_optidx += LWIP_TCP_OPT_LEN_TS - 6; tcp_optidx += LWIP_TCP_OPT_LEN_TS - 6;

72
src/core/tcp_out.c
View File

@ -114,12 +114,12 @@ tcp_output_alloc_header(struct tcp_pcb *pcb, u16_t optlen, u16_t datalen,
LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr", LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
(p->len >= TCP_HLEN + optlen)); (p->len >= TCP_HLEN + optlen));
tcphdr = (struct tcp_hdr *)p->payload; tcphdr = (struct tcp_hdr *)p->payload;
tcphdr->src = htons(pcb->local_port); tcphdr->src = lwip_htons(pcb->local_port);
tcphdr->dest = htons(pcb->remote_port); tcphdr->dest = lwip_htons(pcb->remote_port);
tcphdr->seqno = seqno_be; tcphdr->seqno = seqno_be;
tcphdr->ackno = htonl(pcb->rcv_nxt); tcphdr->ackno = lwip_htonl(pcb->rcv_nxt);
TCPH_HDRLEN_FLAGS_SET(tcphdr, (5 + optlen / 4), TCP_ACK); TCPH_HDRLEN_FLAGS_SET(tcphdr, (5 + optlen / 4), TCP_ACK);
tcphdr->wnd = htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); tcphdr->wnd = lwip_htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd)));
tcphdr->chksum = 0; tcphdr->chksum = 0;
tcphdr->urgp = 0; tcphdr->urgp = 0;
@ -204,9 +204,9 @@ tcp_create_segment(struct tcp_pcb *pcb, struct pbuf *p, u8_t flags, u32_t seqno,
return NULL; return NULL;
} }
seg->tcphdr = (struct tcp_hdr *)seg->p->payload; seg->tcphdr = (struct tcp_hdr *)seg->p->payload;
seg->tcphdr->src = htons(pcb->local_port); seg->tcphdr->src = lwip_htons(pcb->local_port);
seg->tcphdr->dest = htons(pcb->remote_port); seg->tcphdr->dest = lwip_htons(pcb->remote_port);
seg->tcphdr->seqno = htonl(seqno); seg->tcphdr->seqno = lwip_htonl(seqno);
/* ackno is set in tcp_output */ /* ackno is set in tcp_output */
TCPH_HDRLEN_FLAGS_SET(seg->tcphdr, (5 + optlen / 4), flags); TCPH_HDRLEN_FLAGS_SET(seg->tcphdr, (5 + optlen / 4), flags);
/* wnd and chksum are set in tcp_output */ /* wnd and chksum are set in tcp_output */
@ -633,8 +633,8 @@ tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags)
prev_seg = seg; prev_seg = seg;
LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_write: queueing %"U32_F":%"U32_F"\n", LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_write: queueing %"U32_F":%"U32_F"\n",
ntohl(seg->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno),
ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg))); lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg)));
pos += seglen; pos += seglen;
} }
@ -808,8 +808,8 @@ tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags)
LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE,
("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n", ("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n",
ntohl(seg->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno),
ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg), lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg),
(u16_t)flags)); (u16_t)flags));
/* Now append seg to pcb->unsent queue */ /* Now append seg to pcb->unsent queue */
@ -856,8 +856,8 @@ tcp_build_timestamp_option(struct tcp_pcb *pcb, u32_t *opts)
{ {
/* Pad with two NOP options to make everything nicely aligned */ /* Pad with two NOP options to make everything nicely aligned */
opts[0] = PP_HTONL(0x0101080A); opts[0] = PP_HTONL(0x0101080A);
opts[1] = htonl(sys_now()); opts[1] = lwip_htonl(sys_now());
opts[2] = htonl(pcb->ts_recent); opts[2] = lwip_htonl(pcb->ts_recent);
} }
#endif #endif
@ -896,7 +896,7 @@ tcp_send_empty_ack(struct tcp_pcb *pcb)
} }
#endif #endif
p = tcp_output_alloc_header(pcb, optlen, 0, htonl(pcb->snd_nxt)); p = tcp_output_alloc_header(pcb, optlen, 0, lwip_htonl(pcb->snd_nxt));
if (p == NULL) { if (p == NULL) {
/* let tcp_fasttmr retry sending this ACK */ /* let tcp_fasttmr retry sending this ACK */
pcb->flags |= (TF_ACK_DELAY | TF_ACK_NOW); pcb->flags |= (TF_ACK_DELAY | TF_ACK_NOW);
@ -989,7 +989,7 @@ tcp_output(struct tcp_pcb *pcb)
*/ */
if (pcb->flags & TF_ACK_NOW && if (pcb->flags & TF_ACK_NOW &&
(seg == NULL || (seg == NULL ||
ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd)) { lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd)) {
return tcp_send_empty_ack(pcb); return tcp_send_empty_ack(pcb);
} }
@ -1030,13 +1030,13 @@ tcp_output(struct tcp_pcb *pcb)
("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F
", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n", ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n",
pcb->snd_wnd, pcb->cwnd, wnd, pcb->snd_wnd, pcb->cwnd, wnd,
ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len, lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len,
ntohl(seg->tcphdr->seqno), pcb->lastack)); lwip_ntohl(seg->tcphdr->seqno), pcb->lastack));
} }
#endif /* TCP_CWND_DEBUG */ #endif /* TCP_CWND_DEBUG */
/* data available and window allows it to be sent? */ /* data available and window allows it to be sent? */
while (seg != NULL && while (seg != NULL &&
ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) { lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) {
LWIP_ASSERT("RST not expected here!", LWIP_ASSERT("RST not expected here!",
(TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0); (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0);
/* Stop sending if the nagle algorithm would prevent it /* Stop sending if the nagle algorithm would prevent it
@ -1053,9 +1053,9 @@ tcp_output(struct tcp_pcb *pcb)
#if TCP_CWND_DEBUG #if TCP_CWND_DEBUG
LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F", effwnd %"U32_F", seq %"U32_F", ack %"U32_F", i %"S16_F"\n", LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F", effwnd %"U32_F", seq %"U32_F", ack %"U32_F", i %"S16_F"\n",
pcb->snd_wnd, pcb->cwnd, wnd, pcb->snd_wnd, pcb->cwnd, wnd,
ntohl(seg->tcphdr->seqno) + seg->len - lwip_ntohl(seg->tcphdr->seqno) + seg->len -
pcb->lastack, pcb->lastack,
ntohl(seg->tcphdr->seqno), pcb->lastack, i)); lwip_ntohl(seg->tcphdr->seqno), pcb->lastack, i));
++i; ++i;
#endif /* TCP_CWND_DEBUG */ #endif /* TCP_CWND_DEBUG */
@ -1076,7 +1076,7 @@ tcp_output(struct tcp_pcb *pcb)
if (pcb->state != SYN_SENT) { if (pcb->state != SYN_SENT) {
pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW); pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
} }
snd_nxt = ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg); snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg);
if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) {
pcb->snd_nxt = snd_nxt; pcb->snd_nxt = snd_nxt;
} }
@ -1092,11 +1092,11 @@ tcp_output(struct tcp_pcb *pcb)
/* In the case of fast retransmit, the packet should not go to the tail /* In the case of fast retransmit, the packet should not go to the tail
* of the unacked queue, but rather somewhere before it. We need to check for * of the unacked queue, but rather somewhere before it. We need to check for
* this case. -STJ Jul 27, 2004 */ * this case. -STJ Jul 27, 2004 */
if (TCP_SEQ_LT(ntohl(seg->tcphdr->seqno), ntohl(useg->tcphdr->seqno))) { if (TCP_SEQ_LT(lwip_ntohl(seg->tcphdr->seqno), lwip_ntohl(useg->tcphdr->seqno))) {
/* add segment to before tail of unacked list, keeping the list sorted */ /* add segment to before tail of unacked list, keeping the list sorted */
struct tcp_seg **cur_seg = &(pcb->unacked); struct tcp_seg **cur_seg = &(pcb->unacked);
while (*cur_seg && while (*cur_seg &&
TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) { TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) {
cur_seg = &((*cur_seg)->next ); cur_seg = &((*cur_seg)->next );
} }
seg->next = (*cur_seg); seg->next = (*cur_seg);
@ -1147,18 +1147,18 @@ tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif
/* The TCP header has already been constructed, but the ackno and /* The TCP header has already been constructed, but the ackno and
wnd fields remain. */ wnd fields remain. */
seg->tcphdr->ackno = htonl(pcb->rcv_nxt); seg->tcphdr->ackno = lwip_htonl(pcb->rcv_nxt);
/* advertise our receive window size in this TCP segment */ /* advertise our receive window size in this TCP segment */
#if LWIP_WND_SCALE #if LWIP_WND_SCALE
if (seg->flags & TF_SEG_OPTS_WND_SCALE) { if (seg->flags & TF_SEG_OPTS_WND_SCALE) {
/* The Window field in a SYN segment itself (the only type where we send /* The Window field in a SYN segment itself (the only type where we send
the window scale option) is never scaled. */ the window scale option) is never scaled. */
seg->tcphdr->wnd = htons(TCPWND_MIN16(pcb->rcv_ann_wnd)); seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(pcb->rcv_ann_wnd));
} else } else
#endif /* LWIP_WND_SCALE */ #endif /* LWIP_WND_SCALE */
{ {
seg->tcphdr->wnd = htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd)));
} }
pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd; pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
@ -1200,12 +1200,12 @@ tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif
if (pcb->rttest == 0) { if (pcb->rttest == 0) {
pcb->rttest = tcp_ticks; pcb->rttest = tcp_ticks;
pcb->rtseq = ntohl(seg->tcphdr->seqno); pcb->rtseq = lwip_ntohl(seg->tcphdr->seqno);
LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq)); LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq));
} }
LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n", LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n",
htonl(seg->tcphdr->seqno), htonl(seg->tcphdr->seqno) + lwip_htonl(seg->tcphdr->seqno), lwip_htonl(seg->tcphdr->seqno) +
seg->len)); seg->len));
len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload); len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload);
@ -1303,10 +1303,10 @@ tcp_rst(u32_t seqno, u32_t ackno,
(p->len >= sizeof(struct tcp_hdr))); (p->len >= sizeof(struct tcp_hdr)));
tcphdr = (struct tcp_hdr *)p->payload; tcphdr = (struct tcp_hdr *)p->payload;
tcphdr->src = htons(local_port); tcphdr->src = lwip_htons(local_port);
tcphdr->dest = htons(remote_port); tcphdr->dest = lwip_htons(remote_port);
tcphdr->seqno = htonl(seqno); tcphdr->seqno = lwip_htonl(seqno);
tcphdr->ackno = htonl(ackno); tcphdr->ackno = lwip_htonl(ackno);
TCPH_HDRLEN_FLAGS_SET(tcphdr, TCP_HLEN/4, TCP_RST | TCP_ACK); TCPH_HDRLEN_FLAGS_SET(tcphdr, TCP_HLEN/4, TCP_RST | TCP_ACK);
#if LWIP_WND_SCALE #if LWIP_WND_SCALE
tcphdr->wnd = PP_HTONS(((TCP_WND >> TCP_RCV_SCALE) & 0xFFFF)); tcphdr->wnd = PP_HTONS(((TCP_WND >> TCP_RCV_SCALE) & 0xFFFF));
@ -1399,7 +1399,7 @@ tcp_rexmit(struct tcp_pcb *pcb)
cur_seg = &(pcb->unsent); cur_seg = &(pcb->unsent);
while (*cur_seg && while (*cur_seg &&
TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) { TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) {
cur_seg = &((*cur_seg)->next ); cur_seg = &((*cur_seg)->next );
} }
seg->next = *cur_seg; seg->next = *cur_seg;
@ -1437,7 +1437,7 @@ tcp_rexmit_fast(struct tcp_pcb *pcb)
("tcp_receive: dupacks %"U16_F" (%"U32_F ("tcp_receive: dupacks %"U16_F" (%"U32_F
"), fast retransmit %"U32_F"\n", "), fast retransmit %"U32_F"\n",
(u16_t)pcb->dupacks, pcb->lastack, (u16_t)pcb->dupacks, pcb->lastack,
ntohl(pcb->unacked->tcphdr->seqno))); lwip_ntohl(pcb->unacked->tcphdr->seqno)));
tcp_rexmit(pcb); tcp_rexmit(pcb);
/* Set ssthresh to half of the minimum of the current /* Set ssthresh to half of the minimum of the current
@ -1488,7 +1488,7 @@ tcp_keepalive(struct tcp_pcb *pcb)
LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent)); tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent));
p = tcp_output_alloc_header(pcb, 0, 0, htonl(pcb->snd_nxt - 1)); p = tcp_output_alloc_header(pcb, 0, 0, lwip_htonl(pcb->snd_nxt - 1));
if (p == NULL) { if (p == NULL) {
LWIP_DEBUGF(TCP_DEBUG, LWIP_DEBUGF(TCP_DEBUG,
("tcp_keepalive: could not allocate memory for pbuf\n")); ("tcp_keepalive: could not allocate memory for pbuf\n"));
@ -1583,7 +1583,7 @@ tcp_zero_window_probe(struct tcp_pcb *pcb)
} }
/* The byte may be acknowledged without the window being opened. */ /* The byte may be acknowledged without the window being opened. */
snd_nxt = ntohl(seg->tcphdr->seqno) + 1; snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + 1;
if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) {
pcb->snd_nxt = snd_nxt; pcb->snd_nxt = snd_nxt;
} }

22
src/core/udp.c
View File

@ -242,17 +242,17 @@ udp_input(struct pbuf *p, struct netif *inp)
LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %"U16_F"\n", p->tot_len)); LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %"U16_F"\n", p->tot_len));
/* convert src and dest ports to host byte order */ /* convert src and dest ports to host byte order */
src = ntohs(udphdr->src); src = lwip_ntohs(udphdr->src);
dest = ntohs(udphdr->dest); dest = lwip_ntohs(udphdr->dest);
udp_debug_print(udphdr); udp_debug_print(udphdr);
/* print the UDP source and destination */ /* print the UDP source and destination */
LWIP_DEBUGF(UDP_DEBUG, ("udp (")); LWIP_DEBUGF(UDP_DEBUG, ("udp ("));
ip_addr_debug_print(UDP_DEBUG, ip_current_dest_addr()); ip_addr_debug_print(UDP_DEBUG, ip_current_dest_addr());
LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", ntohs(udphdr->dest))); LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", lwip_ntohs(udphdr->dest)));
ip_addr_debug_print(UDP_DEBUG, ip_current_src_addr()); ip_addr_debug_print(UDP_DEBUG, ip_current_src_addr());
LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", ntohs(udphdr->src))); LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", lwip_ntohs(udphdr->src)));
pcb = NULL; pcb = NULL;
prev = NULL; prev = NULL;
@ -331,7 +331,7 @@ udp_input(struct pbuf *p, struct netif *inp)
#if LWIP_UDPLITE #if LWIP_UDPLITE
if (ip_current_header_proto() == IP_PROTO_UDPLITE) { if (ip_current_header_proto() == IP_PROTO_UDPLITE) {
/* Do the UDP Lite checksum */ /* Do the UDP Lite checksum */
u16_t chklen = ntohs(udphdr->len); u16_t chklen = lwip_ntohs(udphdr->len);
if (chklen < sizeof(struct udp_hdr)) { if (chklen < sizeof(struct udp_hdr)) {
if (chklen == 0) { if (chklen == 0) {
/* For UDP-Lite, checksum length of 0 means checksum /* For UDP-Lite, checksum length of 0 means checksum
@ -752,8 +752,8 @@ udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *d
(q->len >= sizeof(struct udp_hdr))); (q->len >= sizeof(struct udp_hdr)));
/* q now represents the packet to be sent */ /* q now represents the packet to be sent */
udphdr = (struct udp_hdr *)q->payload; udphdr = (struct udp_hdr *)q->payload;
udphdr->src = htons(pcb->local_port); udphdr->src = lwip_htons(pcb->local_port);
udphdr->dest = htons(dst_port); udphdr->dest = lwip_htons(dst_port);
/* in UDP, 0 checksum means 'no checksum' */ /* in UDP, 0 checksum means 'no checksum' */
udphdr->chksum = 0x0000; udphdr->chksum = 0x0000;
@ -786,7 +786,7 @@ udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *d
chklen_hdr = 0; chklen_hdr = 0;
chklen = q->tot_len; chklen = q->tot_len;
} }
udphdr->len = htons(chklen_hdr); udphdr->len = lwip_htons(chklen_hdr);
/* calculate checksum */ /* calculate checksum */
#if CHECKSUM_GEN_UDP #if CHECKSUM_GEN_UDP
IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) {
@ -817,7 +817,7 @@ udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *d
#endif /* LWIP_UDPLITE */ #endif /* LWIP_UDPLITE */
{ /* UDP */ { /* UDP */
LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %"U16_F"\n", q->tot_len)); LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %"U16_F"\n", q->tot_len));
udphdr->len = htons(q->tot_len); udphdr->len = lwip_htons(q->tot_len);
/* calculate checksum */ /* calculate checksum */
#if CHECKSUM_GEN_UDP #if CHECKSUM_GEN_UDP
IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) {
@ -1200,10 +1200,10 @@ udp_debug_print(struct udp_hdr *udphdr)
LWIP_DEBUGF(UDP_DEBUG, ("UDP header:\n")); LWIP_DEBUGF(UDP_DEBUG, ("UDP header:\n"));
LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n",
ntohs(udphdr->src), ntohs(udphdr->dest))); lwip_ntohs(udphdr->src), lwip_ntohs(udphdr->dest)));
LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n"));
LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | 0x%04"X16_F" | (len, chksum)\n", LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | 0x%04"X16_F" | (len, chksum)\n",
ntohs(udphdr->len), ntohs(udphdr->chksum))); lwip_ntohs(udphdr->len), lwip_ntohs(udphdr->chksum)));
LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n"));
} }
#endif /* UDP_DEBUG */ #endif /* UDP_DEBUG */

42
src/include/lwip/def.h
View File

@ -72,32 +72,6 @@ extern "C" {
#define LWIP_MAKE_U16(a, b) ((b << 8) | a) #define LWIP_MAKE_U16(a, b) ((b << 8) | a)
#endif #endif
#ifndef LWIP_PLATFORM_BYTESWAP
#define LWIP_PLATFORM_BYTESWAP 0
#endif
#ifndef LWIP_PREFIX_BYTEORDER_FUNCS
/* workaround for naming collisions on some platforms */
#ifdef htons
#undef htons
#endif /* htons */
#ifdef htonl
#undef htonl
#endif /* htonl */
#ifdef ntohs
#undef ntohs
#endif /* ntohs */
#ifdef ntohl
#undef ntohl
#endif /* ntohl */
#define htons(x) lwip_htons(x)
#define ntohs(x) lwip_ntohs(x)
#define htonl(x) lwip_htonl(x)
#define ntohl(x) lwip_ntohl(x)
#endif /* LWIP_PREFIX_BYTEORDER_FUNCS */
#if BYTE_ORDER == BIG_ENDIAN #if BYTE_ORDER == BIG_ENDIAN
#define lwip_htons(x) (x) #define lwip_htons(x) (x)
#define lwip_ntohs(x) (x) #define lwip_ntohs(x) (x)
@ -108,17 +82,15 @@ extern "C" {
#define PP_HTONL(x) (x) #define PP_HTONL(x) (x)
#define PP_NTOHL(x) (x) #define PP_NTOHL(x) (x)
#else /* BYTE_ORDER != BIG_ENDIAN */ #else /* BYTE_ORDER != BIG_ENDIAN */
#if LWIP_PLATFORM_BYTESWAP #ifndef lwip_htons
#define lwip_htons(x) LWIP_PLATFORM_HTONS(x)
#define lwip_ntohs(x) LWIP_PLATFORM_HTONS(x)
#define lwip_htonl(x) LWIP_PLATFORM_HTONL(x)
#define lwip_ntohl(x) LWIP_PLATFORM_HTONL(x)
#else /* LWIP_PLATFORM_BYTESWAP */
u16_t lwip_htons(u16_t x); u16_t lwip_htons(u16_t x);
u16_t lwip_ntohs(u16_t x); #endif
#define lwip_ntohs(x) lwip_htons(x)
#ifndef lwip_htonl
u32_t lwip_htonl(u32_t x); u32_t lwip_htonl(u32_t x);
u32_t lwip_ntohl(u32_t x); #endif
#endif /* LWIP_PLATFORM_BYTESWAP */ #define lwip_ntohl(x) lwip_htonl(x)
/* These macros should be calculated by the preprocessor and are used /* These macros should be calculated by the preprocessor and are used
with compile-time constants only (so that there is no little-endian with compile-time constants only (so that there is no little-endian

8
src/include/lwip/inet_chksum.h
View File

@ -42,15 +42,9 @@
#include "lwip/pbuf.h" #include "lwip/pbuf.h"
#include "lwip/ip_addr.h" #include "lwip/ip_addr.h"
/** Swap the bytes in an u16_t: much like htons() for little-endian */ /** Swap the bytes in an u16_t: much like lwip_htons() for little-endian */
#ifndef SWAP_BYTES_IN_WORD #ifndef SWAP_BYTES_IN_WORD
#if LWIP_PLATFORM_BYTESWAP && (BYTE_ORDER == LITTLE_ENDIAN)
/* little endian and PLATFORM_BYTESWAP defined */
#define SWAP_BYTES_IN_WORD(w) LWIP_PLATFORM_HTONS(w)
#else /* LWIP_PLATFORM_BYTESWAP && (BYTE_ORDER == LITTLE_ENDIAN) */
/* can't use htons on big endian (or PLATFORM_BYTESWAP not defined)... */
#define SWAP_BYTES_IN_WORD(w) (((w) & 0xff) << 8) | (((w) & 0xff00) >> 8) #define SWAP_BYTES_IN_WORD(w) (((w) & 0xff) << 8) | (((w) & 0xff00) >> 8)
#endif /* LWIP_PLATFORM_BYTESWAP && (BYTE_ORDER == LITTLE_ENDIAN)*/
#endif /* SWAP_BYTES_IN_WORD */ #endif /* SWAP_BYTES_IN_WORD */
/** Split an u32_t in two u16_ts and add them up */ /** Split an u32_t in two u16_ts and add them up */

6
src/include/lwip/ip4_addr.h
View File

@ -141,7 +141,7 @@ struct netif;
(u32_t)((d) & 0xff) (u32_t)((d) & 0xff)
#else #else
/** Set an IP address given by the four byte-parts. /** Set an IP address given by the four byte-parts.
Little-endian version that prevents the use of htonl. */ Little-endian version that prevents the use of lwip_htonl. */
#define IP4_ADDR(ipaddr, a,b,c,d) \ #define IP4_ADDR(ipaddr, a,b,c,d) \
(ipaddr)->addr = ((u32_t)((d) & 0xff) << 24) | \ (ipaddr)->addr = ((u32_t)((d) & 0xff) << 24) | \
((u32_t)((c) & 0xff) << 16) | \ ((u32_t)((c) & 0xff) << 16) | \
@ -164,7 +164,7 @@ struct netif;
(src)->addr)) (src)->addr))
/** Set complete address to zero */ /** Set complete address to zero */
#define ip4_addr_set_zero(ipaddr) ((ipaddr)->addr = 0) #define ip4_addr_set_zero(ipaddr) ((ipaddr)->addr = 0)
/** Set address to IPADDR_ANY (no need for htonl()) */ /** Set address to IPADDR_ANY (no need for lwip_htonl()) */
#define ip4_addr_set_any(ipaddr) ((ipaddr)->addr = IPADDR_ANY) #define ip4_addr_set_any(ipaddr) ((ipaddr)->addr = IPADDR_ANY)
/** Set address to loopback address */ /** Set address to loopback address */
#define ip4_addr_set_loopback(ipaddr) ((ipaddr)->addr = PP_HTONL(IPADDR_LOOPBACK)) #define ip4_addr_set_loopback(ipaddr) ((ipaddr)->addr = PP_HTONL(IPADDR_LOOPBACK))
@ -174,7 +174,7 @@ struct netif;
* from host- to network-order. */ * from host- to network-order. */
#define ip4_addr_set_hton(dest, src) ((dest)->addr = \ #define ip4_addr_set_hton(dest, src) ((dest)->addr = \
((src) == NULL ? 0:\ ((src) == NULL ? 0:\
htonl((src)->addr))) lwip_htonl((src)->addr)))
/** IPv4 only: set the IP address given as an u32_t */ /** IPv4 only: set the IP address given as an u32_t */
#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32)) #define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32))
/** IPv4 only: get the IP address as an u32_t */ /** IPv4 only: get the IP address as an u32_t */

32
src/include/lwip/ip6_addr.h
View File

@ -86,7 +86,7 @@ typedef struct ip6_addr_packed ip6_addr_p_t;
(u32_t)((d) & 0xff) (u32_t)((d) & 0xff)
#else #else
/** Set an IPv6 partial address given by byte-parts. /** Set an IPv6 partial address given by byte-parts.
Little-endian version, stored in network order (no htonl). */ Little-endian version, stored in network order (no lwip_htonl). */
#define IP6_ADDR_PART(ip6addr, index, a,b,c,d) \ #define IP6_ADDR_PART(ip6addr, index, a,b,c,d) \
(ip6addr)->addr[index] = ((u32_t)((d) & 0xff) << 24) | \ (ip6addr)->addr[index] = ((u32_t)((d) & 0xff) << 24) | \
((u32_t)((c) & 0xff) << 16) | \ ((u32_t)((c) & 0xff) << 16) | \
@ -103,21 +103,21 @@ Little-endian version, stored in network order (no htonl). */
(ip6addr)->addr[3] = idx3; } while(0) (ip6addr)->addr[3] = idx3; } while(0)
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK1(ip6addr) ((u16_t)((htonl((ip6addr)->addr[0]) >> 16) & 0xffff)) #define IP6_ADDR_BLOCK1(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK2(ip6addr) ((u16_t)((htonl((ip6addr)->addr[0])) & 0xffff)) #define IP6_ADDR_BLOCK2(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0])) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK3(ip6addr) ((u16_t)((htonl((ip6addr)->addr[1]) >> 16) & 0xffff)) #define IP6_ADDR_BLOCK3(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1]) >> 16) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK4(ip6addr) ((u16_t)((htonl((ip6addr)->addr[1])) & 0xffff)) #define IP6_ADDR_BLOCK4(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1])) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK5(ip6addr) ((u16_t)((htonl((ip6addr)->addr[2]) >> 16) & 0xffff)) #define IP6_ADDR_BLOCK5(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2]) >> 16) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK6(ip6addr) ((u16_t)((htonl((ip6addr)->addr[2])) & 0xffff)) #define IP6_ADDR_BLOCK6(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2])) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK7(ip6addr) ((u16_t)((htonl((ip6addr)->addr[3]) >> 16) & 0xffff)) #define IP6_ADDR_BLOCK7(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3]) >> 16) & 0xffff))
/** Access address in 16-bit block */ /** Access address in 16-bit block */
#define IP6_ADDR_BLOCK8(ip6addr) ((u16_t)((htonl((ip6addr)->addr[3])) & 0xffff)) #define IP6_ADDR_BLOCK8(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3])) & 0xffff))
/** Copy IPv6 address - faster than ip6_addr_set: no NULL check */ /** Copy IPv6 address - faster than ip6_addr_set: no NULL check */
#define ip6_addr_copy(dest, src) do{(dest).addr[0] = (src).addr[0]; \ #define ip6_addr_copy(dest, src) do{(dest).addr[0] = (src).addr[0]; \
@ -136,7 +136,7 @@ Little-endian version, stored in network order (no htonl). */
(ip6addr)->addr[2] = 0; \ (ip6addr)->addr[2] = 0; \
(ip6addr)->addr[3] = 0;}while(0) (ip6addr)->addr[3] = 0;}while(0)
/** Set address to ipv6 'any' (no need for htonl()) */ /** Set address to ipv6 'any' (no need for lwip_htonl()) */
#define ip6_addr_set_any(ip6addr) ip6_addr_set_zero(ip6addr) #define ip6_addr_set_any(ip6addr) ip6_addr_set_zero(ip6addr)
/** Set address to ipv6 loopback address */ /** Set address to ipv6 loopback address */
#define ip6_addr_set_loopback(ip6addr) do{(ip6addr)->addr[0] = 0; \ #define ip6_addr_set_loopback(ip6addr) do{(ip6addr)->addr[0] = 0; \
@ -145,10 +145,10 @@ Little-endian version, stored in network order (no htonl). */
(ip6addr)->addr[3] = PP_HTONL(0x00000001UL);}while(0) (ip6addr)->addr[3] = PP_HTONL(0x00000001UL);}while(0)
/** Safely copy one IPv6 address to another and change byte order /** Safely copy one IPv6 address to another and change byte order
* from host- to network-order. */ * from host- to network-order. */
#define ip6_addr_set_hton(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : htonl((src)->addr[0]); \ #define ip6_addr_set_hton(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : lwip_htonl((src)->addr[0]); \
(dest)->addr[1] = (src) == NULL ? 0 : htonl((src)->addr[1]); \ (dest)->addr[1] = (src) == NULL ? 0 : lwip_htonl((src)->addr[1]); \
(dest)->addr[2] = (src) == NULL ? 0 : htonl((src)->addr[2]); \ (dest)->addr[2] = (src) == NULL ? 0 : lwip_htonl((src)->addr[2]); \
(dest)->addr[3] = (src) == NULL ? 0 : htonl((src)->addr[3]);}while(0) (dest)->addr[3] = (src) == NULL ? 0 : lwip_htonl((src)->addr[3]);}while(0)
/** /**
@ -166,7 +166,7 @@ Little-endian version, stored in network order (no htonl). */
((addr1)->addr[2] == (addr2)->addr[2]) && \ ((addr1)->addr[2] == (addr2)->addr[2]) && \
((addr1)->addr[3] == (addr2)->addr[3])) ((addr1)->addr[3] == (addr2)->addr[3]))
#define ip6_get_subnet_id(ip6addr) (htonl((ip6addr)->addr[2]) & 0x0000ffffUL) #define ip6_get_subnet_id(ip6addr) (lwip_htonl((ip6addr)->addr[2]) & 0x0000ffffUL)
#define ip6_addr_isany_val(ip6addr) (((ip6addr).addr[0] == 0) && \ #define ip6_addr_isany_val(ip6addr) (((ip6addr).addr[0] == 0) && \
((ip6addr).addr[1] == 0) && \ ((ip6addr).addr[1] == 0) && \
@ -193,7 +193,7 @@ Little-endian version, stored in network order (no htonl). */
#define ip6_addr_multicast_transient_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00100000UL)) #define ip6_addr_multicast_transient_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00100000UL))
#define ip6_addr_multicast_prefix_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00200000UL)) #define ip6_addr_multicast_prefix_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00200000UL))
#define ip6_addr_multicast_rendezvous_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00400000UL)) #define ip6_addr_multicast_rendezvous_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00400000UL))
#define ip6_addr_multicast_scope(ip6addr) ((htonl((ip6addr)->addr[0]) >> 16) & 0xf) #define ip6_addr_multicast_scope(ip6addr) ((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xf)
#define IP6_MULTICAST_SCOPE_RESERVED 0x0 #define IP6_MULTICAST_SCOPE_RESERVED 0x0
#define IP6_MULTICAST_SCOPE_RESERVED0 0x0 #define IP6_MULTICAST_SCOPE_RESERVED0 0x0
#define IP6_MULTICAST_SCOPE_INTERFACE_LOCAL 0x1 #define IP6_MULTICAST_SCOPE_INTERFACE_LOCAL 0x1

2
src/include/lwip/priv/tcp_priv.h
View File

@ -290,7 +290,7 @@ struct tcp_seg {
(flags & TF_SEG_OPTS_WND_SCALE ? LWIP_TCP_OPT_LEN_WS_OUT : 0) (flags & TF_SEG_OPTS_WND_SCALE ? LWIP_TCP_OPT_LEN_WS_OUT : 0)
/** This returns a TCP header option for MSS in an u32_t */ /** This returns a TCP header option for MSS in an u32_t */
#define TCP_BUILD_MSS_OPTION(mss) htonl(0x02040000 | ((mss) & 0xFFFF)) #define TCP_BUILD_MSS_OPTION(mss) lwip_htonl(0x02040000 | ((mss) & 0xFFFF))
#if LWIP_WND_SCALE #if LWIP_WND_SCALE
#define TCPWNDSIZE_F U32_F #define TCPWNDSIZE_F U32_F

2
src/include/lwip/prot/ethernet.h
View File

@ -100,7 +100,7 @@ PACK_STRUCT_END
#endif #endif
#define SIZEOF_VLAN_HDR 4 #define SIZEOF_VLAN_HDR 4
#define VLAN_ID(vlan_hdr) (htons((vlan_hdr)->prio_vid) & 0xFFF) #define VLAN_ID(vlan_hdr) (lwip_htons((vlan_hdr)->prio_vid) & 0xFFF)
/** /**
* @ingroup ethernet * @ingroup ethernet

12
src/include/lwip/prot/ip6.h
View File

@ -134,16 +134,16 @@ PACK_STRUCT_END
# include "arch/epstruct.h" # include "arch/epstruct.h"
#endif #endif
#define IP6H_V(hdr) ((ntohl((hdr)->_v_tc_fl) >> 28) & 0x0f) #define IP6H_V(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 28) & 0x0f)
#define IP6H_TC(hdr) ((ntohl((hdr)->_v_tc_fl) >> 20) & 0xff) #define IP6H_TC(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 20) & 0xff)
#define IP6H_FL(hdr) (ntohl((hdr)->_v_tc_fl) & 0x000fffff) #define IP6H_FL(hdr) (lwip_ntohl((hdr)->_v_tc_fl) & 0x000fffff)
#define IP6H_PLEN(hdr) (ntohs((hdr)->_plen)) #define IP6H_PLEN(hdr) (lwip_ntohs((hdr)->_plen))
#define IP6H_NEXTH(hdr) ((hdr)->_nexth) #define IP6H_NEXTH(hdr) ((hdr)->_nexth)
#define IP6H_NEXTH_P(hdr) ((u8_t *)(hdr) + 6) #define IP6H_NEXTH_P(hdr) ((u8_t *)(hdr) + 6)
#define IP6H_HOPLIM(hdr) ((hdr)->_hoplim) #define IP6H_HOPLIM(hdr) ((hdr)->_hoplim)
#define IP6H_VTCFL_SET(hdr, v, tc, fl) (hdr)->_v_tc_fl = (htonl((((u32_t)(v)) << 28) | (((u32_t)(tc)) << 20) | (fl))) #define IP6H_VTCFL_SET(hdr, v, tc, fl) (hdr)->_v_tc_fl = (lwip_htonl((((u32_t)(v)) << 28) | (((u32_t)(tc)) << 20) | (fl)))
#define IP6H_PLEN_SET(hdr, plen) (hdr)->_plen = htons(plen) #define IP6H_PLEN_SET(hdr, plen) (hdr)->_plen = lwip_htons(plen)
#define IP6H_NEXTH_SET(hdr, nexth) (hdr)->_nexth = (nexth) #define IP6H_NEXTH_SET(hdr, nexth) (hdr)->_nexth = (nexth)
#define IP6H_HOPLIM_SET(hdr, hl) (hdr)->_hoplim = (u8_t)(hl) #define IP6H_HOPLIM_SET(hdr, hl) (hdr)->_hoplim = (u8_t)(hl)

14
src/include/lwip/prot/tcp.h
View File

@ -80,15 +80,15 @@ PACK_STRUCT_END
/* Valid TCP header flags */ /* Valid TCP header flags */
#define TCP_FLAGS 0x3fU #define TCP_FLAGS 0x3fU
#define TCPH_HDRLEN(phdr) ((u16_t)(ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)) #define TCPH_HDRLEN(phdr) ((u16_t)(lwip_ntohs((phdr)->_hdrlen_rsvd_flags) >> 12))
#define TCPH_FLAGS(phdr) ((u16_t)(ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS)) #define TCPH_FLAGS(phdr) ((u16_t)(lwip_ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS))
#define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = htons(((len) << 12) | TCPH_FLAGS(phdr)) #define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = lwip_htons(((len) << 12) | TCPH_FLAGS(phdr))
#define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = (((phdr)->_hdrlen_rsvd_flags & PP_HTONS(~TCP_FLAGS)) | htons(flags)) #define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = (((phdr)->_hdrlen_rsvd_flags & PP_HTONS(~TCP_FLAGS)) | lwip_htons(flags))
#define TCPH_HDRLEN_FLAGS_SET(phdr, len, flags) (phdr)->_hdrlen_rsvd_flags = htons(((len) << 12) | (flags)) #define TCPH_HDRLEN_FLAGS_SET(phdr, len, flags) (phdr)->_hdrlen_rsvd_flags = lwip_htons(((len) << 12) | (flags))
#define TCPH_SET_FLAG(phdr, flags ) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags | htons(flags)) #define TCPH_SET_FLAG(phdr, flags ) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags | lwip_htons(flags))
#define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags & ~htons(flags)) #define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags & ~lwip_htons(flags))
#ifdef __cplusplus #ifdef __cplusplus
} }

2
src/include/netif/ppp/eui64.h
View File

@ -84,7 +84,7 @@ typedef union
#define eui64_set32(e, l) do { \ #define eui64_set32(e, l) do { \
(e).e32[0] = 0; \ (e).e32[0] = 0; \
(e).e32[1] = htonl(l); \ (e).e32[1] = lwip_htonl(l); \
} while (0) } while (0)
#define eui64_setlo32(e, l) eui64_set32(e, l) #define eui64_setlo32(e, l) eui64_set32(e, l)

2
src/include/netif/ppp/mppe.h
View File

@ -59,7 +59,7 @@
* This is not nice ... the alternative is a bitfield struct though. * This is not nice ... the alternative is a bitfield struct though.
* And unfortunately, we cannot share the same bits for the option * And unfortunately, we cannot share the same bits for the option
* names above since C and H are the same bit. We could do a u_int32 * names above since C and H are the same bit. We could do a u_int32
* but then we have to do a htonl() all the time and/or we still need * but then we have to do a lwip_htonl() all the time and/or we still need
* to know which octet is which. * to know which octet is which.
*/ */
#define MPPE_C_BIT 0x01 /* MPPC */ #define MPPE_C_BIT 0x01 /* MPPC */

8
src/netif/ethernet.c
View File

@ -98,7 +98,7 @@ ethernet_input(struct pbuf *p, struct netif *netif)
(unsigned)ethhdr->dest.addr[3], (unsigned)ethhdr->dest.addr[4], (unsigned)ethhdr->dest.addr[5], (unsigned)ethhdr->dest.addr[3], (unsigned)ethhdr->dest.addr[4], (unsigned)ethhdr->dest.addr[5],
(unsigned)ethhdr->src.addr[0], (unsigned)ethhdr->src.addr[1], (unsigned)ethhdr->src.addr[2], (unsigned)ethhdr->src.addr[0], (unsigned)ethhdr->src.addr[1], (unsigned)ethhdr->src.addr[2],
(unsigned)ethhdr->src.addr[3], (unsigned)ethhdr->src.addr[4], (unsigned)ethhdr->src.addr[5], (unsigned)ethhdr->src.addr[3], (unsigned)ethhdr->src.addr[4], (unsigned)ethhdr->src.addr[5],
htons(ethhdr->type))); lwip_htons(ethhdr->type)));
type = ethhdr->type; type = ethhdr->type;
#if ETHARP_SUPPORT_VLAN #if ETHARP_SUPPORT_VLAN
@ -130,7 +130,7 @@ ethernet_input(struct pbuf *p, struct netif *netif)
#endif /* ETHARP_SUPPORT_VLAN */ #endif /* ETHARP_SUPPORT_VLAN */
#if LWIP_ARP_FILTER_NETIF #if LWIP_ARP_FILTER_NETIF
netif = LWIP_ARP_FILTER_NETIF_FN(p, netif, htons(type)); netif = LWIP_ARP_FILTER_NETIF_FN(p, netif, lwip_htons(type));
#endif /* LWIP_ARP_FILTER_NETIF*/ #endif /* LWIP_ARP_FILTER_NETIF*/
if (ethhdr->dest.addr[0] & 1) { if (ethhdr->dest.addr[0] & 1) {
@ -262,7 +262,7 @@ ethernet_output(struct netif* netif, struct pbuf* p,
u16_t eth_type) u16_t eth_type)
{ {
struct eth_hdr* ethhdr; struct eth_hdr* ethhdr;
u16_t eth_type_be = htons(eth_type); u16_t eth_type_be = lwip_htons(eth_type);
#if ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET) #if ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET)
s32_t vlan_prio_vid = LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type); s32_t vlan_prio_vid = LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type);
@ -276,7 +276,7 @@ ethernet_output(struct netif* netif, struct pbuf* p,
} }
vlanhdr = (struct eth_vlan_hdr*)(((u8_t*)p->payload) + SIZEOF_ETH_HDR); vlanhdr = (struct eth_vlan_hdr*)(((u8_t*)p->payload) + SIZEOF_ETH_HDR);
vlanhdr->tpid = eth_type_be; vlanhdr->tpid = eth_type_be;
vlanhdr->prio_vid = htons((u16_t)vlan_prio_vid); vlanhdr->prio_vid = lwip_htons((u16_t)vlan_prio_vid);
eth_type_be = PP_HTONS(ETHTYPE_VLAN); eth_type_be = PP_HTONS(ETHTYPE_VLAN);
} else } else

62
src/netif/lowpan6.c
View File

@ -160,13 +160,13 @@ lowpan6_get_address_mode(const ip6_addr_t *ip6addr, const struct ieee_802154_add
if (mac_addr->addr_len == 2) { if (mac_addr->addr_len == 2) {
if ((ip6addr->addr[2] == (u32_t)PP_HTONL(0x000000ff)) && if ((ip6addr->addr[2] == (u32_t)PP_HTONL(0x000000ff)) &&
((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000))) { ((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000))) {
if ((ip6addr->addr[3] & PP_HTONL(0x0000ffff)) == ntohl((mac_addr->addr[0] << 8) | mac_addr->addr[1])) { if ((ip6addr->addr[3] & PP_HTONL(0x0000ffff)) == lwip_ntohl((mac_addr->addr[0] << 8) | mac_addr->addr[1])) {
return 3; return 3;
} }
} }
} else if (mac_addr->addr_len == 8) { } else if (mac_addr->addr_len == 8) {
if ((ip6addr->addr[2] == ntohl(((mac_addr->addr[0] ^ 2) << 24) | (mac_addr->addr[1] << 16) | mac_addr->addr[2] << 8 | mac_addr->addr[3])) && if ((ip6addr->addr[2] == lwip_ntohl(((mac_addr->addr[0] ^ 2) << 24) | (mac_addr->addr[1] << 16) | mac_addr->addr[2] << 8 | mac_addr->addr[3])) &&
(ip6addr->addr[3] == ntohl((mac_addr->addr[4] << 24) | (mac_addr->addr[5] << 16) | mac_addr->addr[6] << 8 | mac_addr->addr[7]))) { (ip6addr->addr[3] == lwip_ntohl((mac_addr->addr[4] << 24) | (mac_addr->addr[5] << 16) | mac_addr->addr[6] << 8 | mac_addr->addr[7]))) {
return 3; return 3;
} }
} }
@ -768,7 +768,7 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL);
ip6hdr->src.addr[1] = 0; ip6hdr->src.addr[1] = 0;
ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->src.addr[3] = htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) |
lowpan6_buffer[lowpan6_offset+1]); lowpan6_buffer[lowpan6_offset+1]);
lowpan6_offset += 2; lowpan6_offset += 2;
} else if ((lowpan6_buffer[1] & 0x30) == 0x30) { } else if ((lowpan6_buffer[1] & 0x30) == 0x30) {
@ -776,11 +776,11 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
ip6hdr->src.addr[1] = 0; ip6hdr->src.addr[1] = 0;
if (src->addr_len == 2) { if (src->addr_len == 2) {
ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->src.addr[3] = htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]);
} else { } else {
ip6hdr->src.addr[2] = htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) |
(src->addr[2] << 8) | src->addr[3]); (src->addr[2] << 8) | src->addr[3]);
ip6hdr->src.addr[3] = htonl((src->addr[4] << 24) | (src->addr[5] << 16) | ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) |
(src->addr[6] << 8) | src->addr[7]); (src->addr[6] << 8) | src->addr[7]);
} }
} }
@ -815,15 +815,15 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
lowpan6_offset += 8; lowpan6_offset += 8;
} else if ((lowpan6_buffer[1] & 0x30) == 0x20) { } else if ((lowpan6_buffer[1] & 0x30) == 0x20) {
ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->src.addr[3] = htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset+1]); ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset+1]);
lowpan6_offset += 2; lowpan6_offset += 2;
} else if ((lowpan6_buffer[1] & 0x30) == 0x30) { } else if ((lowpan6_buffer[1] & 0x30) == 0x30) {
if (src->addr_len == 2) { if (src->addr_len == 2) {
ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->src.addr[3] = htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]);
} else { } else {
ip6hdr->src.addr[2] = htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | (src->addr[2] << 8) | src->addr[3]); ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | (src->addr[2] << 8) | src->addr[3]);
ip6hdr->src.addr[3] = htonl((src->addr[4] << 24) | (src->addr[5] << 16) | (src->addr[6] << 8) | src->addr[7]); ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) | (src->addr[6] << 8) | src->addr[7]);
} }
} }
} }
@ -843,22 +843,22 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16); MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16);
lowpan6_offset += 16; lowpan6_offset += 16;
} else if ((lowpan6_buffer[1] & 0x03) == 0x01) { } else if ((lowpan6_buffer[1] & 0x03) == 0x01) {
ip6hdr->dest.addr[0] = htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16)); ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16));
ip6hdr->dest.addr[1] = 0; ip6hdr->dest.addr[1] = 0;
ip6hdr->dest.addr[2] = htonl(lowpan6_buffer[lowpan6_offset++]); ip6hdr->dest.addr[2] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]);
ip6hdr->dest.addr[3] = htonl((lowpan6_buffer[lowpan6_offset] << 24) | (lowpan6_buffer[lowpan6_offset + 1] << 16) | (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset + 3]); ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 24) | (lowpan6_buffer[lowpan6_offset + 1] << 16) | (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset + 3]);
lowpan6_offset += 4; lowpan6_offset += 4;
} else if ((lowpan6_buffer[1] & 0x03) == 0x02) { } else if ((lowpan6_buffer[1] & 0x03) == 0x02) {
ip6hdr->dest.addr[0] = htonl(0xff000000UL | lowpan6_buffer[lowpan6_offset++]); ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | lowpan6_buffer[lowpan6_offset++]);
ip6hdr->dest.addr[1] = 0; ip6hdr->dest.addr[1] = 0;
ip6hdr->dest.addr[2] = 0; ip6hdr->dest.addr[2] = 0;
ip6hdr->dest.addr[3] = htonl((lowpan6_buffer[lowpan6_offset] << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset + 2]); ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset + 2]);
lowpan6_offset += 3; lowpan6_offset += 3;
} else if ((lowpan6_buffer[1] & 0x03) == 0x03) { } else if ((lowpan6_buffer[1] & 0x03) == 0x03) {
ip6hdr->dest.addr[0] = PP_HTONL(0xff020000UL); ip6hdr->dest.addr[0] = PP_HTONL(0xff020000UL);
ip6hdr->dest.addr[1] = 0; ip6hdr->dest.addr[1] = 0;
ip6hdr->dest.addr[2] = 0; ip6hdr->dest.addr[2] = 0;
ip6hdr->dest.addr[3] = htonl(lowpan6_buffer[lowpan6_offset++]); ip6hdr->dest.addr[3] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]);
} }
} else { } else {
@ -894,15 +894,15 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
lowpan6_offset += 8; lowpan6_offset += 8;
} else if ((lowpan6_buffer[1] & 0x03) == 0x02) { } else if ((lowpan6_buffer[1] & 0x03) == 0x02) {
ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->dest.addr[3] = htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]); ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]);
lowpan6_offset += 2; lowpan6_offset += 2;
} else if ((lowpan6_buffer[1] & 0x03) == 0x03) { } else if ((lowpan6_buffer[1] & 0x03) == 0x03) {
if (dest->addr_len == 2) { if (dest->addr_len == 2) {
ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL);
ip6hdr->dest.addr[3] = htonl(0xfe000000UL | (dest->addr[0] << 8) | dest->addr[1]); ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (dest->addr[0] << 8) | dest->addr[1]);
} else { } else {
ip6hdr->dest.addr[2] = htonl(((dest->addr[0] ^ 2) << 24) | (dest->addr[1] << 16) | dest->addr[2] << 8 | dest->addr[3]); ip6hdr->dest.addr[2] = lwip_htonl(((dest->addr[0] ^ 2) << 24) | (dest->addr[1] << 16) | dest->addr[2] << 8 | dest->addr[3]);
ip6hdr->dest.addr[3] = htonl((dest->addr[4] << 24) | (dest->addr[5] << 16) | dest->addr[6] << 8 | dest->addr[7]); ip6hdr->dest.addr[3] = lwip_htonl((dest->addr[4] << 24) | (dest->addr[5] << 16) | dest->addr[6] << 8 | dest->addr[7]);
} }
} }
} }
@ -927,26 +927,26 @@ lowpan6_decompress(struct pbuf * p, struct ieee_802154_addr * src, struct ieee_8
/* Decompress ports */ /* Decompress ports */
i = lowpan6_buffer[lowpan6_offset++] & 0x03; i = lowpan6_buffer[lowpan6_offset++] & 0x03;
if (i == 0) { if (i == 0) {
udphdr->src = htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]);
udphdr->dest = htons(lowpan6_buffer[lowpan6_offset + 2] << 8 | lowpan6_buffer[lowpan6_offset + 3]); udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 2] << 8 | lowpan6_buffer[lowpan6_offset + 3]);
lowpan6_offset += 4; lowpan6_offset += 4;
} else if (i == 0x01) { } else if (i == 0x01) {
udphdr->src = htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]);
udphdr->dest = htons(0xf000 | lowpan6_buffer[lowpan6_offset + 2]); udphdr->dest = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset + 2]);
lowpan6_offset += 3; lowpan6_offset += 3;
} else if (i == 0x02) { } else if (i == 0x02) {
udphdr->src = htons(0xf000 | lowpan6_buffer[lowpan6_offset]); udphdr->src = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset]);
udphdr->dest = htons(lowpan6_buffer[lowpan6_offset + 1] << 8 | lowpan6_buffer[lowpan6_offset + 2]); udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 1] << 8 | lowpan6_buffer[lowpan6_offset + 2]);
lowpan6_offset += 3; lowpan6_offset += 3;
} else if (i == 0x03) { } else if (i == 0x03) {
udphdr->src = htons(0xf0b0 | ((lowpan6_buffer[lowpan6_offset] >> 4) & 0x0f)); udphdr->src = lwip_htons(0xf0b0 | ((lowpan6_buffer[lowpan6_offset] >> 4) & 0x0f));
udphdr->dest = htons(0xf0b0 | (lowpan6_buffer[lowpan6_offset] & 0x0f)); udphdr->dest = lwip_htons(0xf0b0 | (lowpan6_buffer[lowpan6_offset] & 0x0f));
lowpan6_offset += 1; lowpan6_offset += 1;
} }
udphdr->chksum = htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); udphdr->chksum = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]);
lowpan6_offset += 2; lowpan6_offset += 2;
udphdr->len = htons(p->tot_len - lowpan6_offset + UDP_HLEN); udphdr->len = lwip_htons(p->tot_len - lowpan6_offset + UDP_HLEN);
ip6_offset += UDP_HLEN; ip6_offset += UDP_HLEN;
} else { } else {

10
src/netif/ppp/auth.c
View File

@ -2121,10 +2121,10 @@ set_allowed_addrs(unit, addrs, opts)
} else { } else {
np = getnetbyname (ptr_word); np = getnetbyname (ptr_word);
if (np != NULL && np->n_addrtype == AF_INET) { if (np != NULL && np->n_addrtype == AF_INET) {
a = htonl ((u32_t)np->n_net); a = lwip_htonl ((u32_t)np->n_net);
if (ptr_mask == NULL) { if (ptr_mask == NULL) {
/* calculate appropriate mask for net */ /* calculate appropriate mask for net */
ah = ntohl(a); ah = lwip_ntohl(a);
if (IN_CLASSA(ah)) if (IN_CLASSA(ah))
mask = IN_CLASSA_NET; mask = IN_CLASSA_NET;
else if (IN_CLASSB(ah)) else if (IN_CLASSB(ah))
@ -2150,10 +2150,10 @@ set_allowed_addrs(unit, addrs, opts)
ifunit, ptr_word); ifunit, ptr_word);
continue; continue;
} }
a = htonl((ntohl(a) & mask) + offset); a = lwip_htonl((lwip_ntohl(a) & mask) + offset);
mask = ~(u32_t)0; mask = ~(u32_t)0;
} }
ip[n].mask = htonl(mask); ip[n].mask = lwip_htonl(mask);
ip[n].base = a & ip[n].mask; ip[n].base = a & ip[n].mask;
++n; ++n;
if (~mask == 0 && suggested_ip == 0) if (~mask == 0 && suggested_ip == 0)
@ -2234,7 +2234,7 @@ int
bad_ip_adrs(addr) bad_ip_adrs(addr)
u32_t addr; u32_t addr;
{ {
addr = ntohl(addr); addr = lwip_ntohl(addr);
return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
|| IN_MULTICAST(addr) || IN_BADCLASS(addr); || IN_MULTICAST(addr) || IN_BADCLASS(addr);
} }

88
src/netif/ppp/ipcp.c
View File

@ -542,7 +542,7 @@ setnetmask(argv)
p = *argv; p = *argv;
n = parse_dotted_ip(p, &mask); n = parse_dotted_ip(p, &mask);
mask = htonl(mask); mask = lwip_htonl(mask);
if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) { if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) {
option_error("invalid netmask value '%s'", *argv); option_error("invalid netmask value '%s'", *argv);
@ -822,9 +822,9 @@ static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) {
u32_t l; \ u32_t l; \
PUTCHAR(opt, ucp); \ PUTCHAR(opt, ucp); \
PUTCHAR(CILEN_ADDRS, ucp); \ PUTCHAR(CILEN_ADDRS, ucp); \
l = ntohl(val1); \ l = lwip_ntohl(val1); \
PUTLONG(l, ucp); \ PUTLONG(l, ucp); \
l = ntohl(val2); \ l = lwip_ntohl(val2); \
PUTLONG(l, ucp); \ PUTLONG(l, ucp); \
len -= CILEN_ADDRS; \ len -= CILEN_ADDRS; \
} else \ } else \
@ -855,7 +855,7 @@ static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) {
u32_t l; \ u32_t l; \
PUTCHAR(opt, ucp); \ PUTCHAR(opt, ucp); \
PUTCHAR(CILEN_ADDR, ucp); \ PUTCHAR(CILEN_ADDR, ucp); \
l = ntohl(val); \ l = lwip_ntohl(val); \
PUTLONG(l, ucp); \ PUTLONG(l, ucp); \
len -= CILEN_ADDR; \ len -= CILEN_ADDR; \
} else \ } else \
@ -869,7 +869,7 @@ static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) {
u32_t l; \ u32_t l; \
PUTCHAR(opt, ucp); \ PUTCHAR(opt, ucp); \
PUTCHAR(CILEN_ADDR, ucp); \ PUTCHAR(CILEN_ADDR, ucp); \
l = ntohl(addr); \ l = lwip_ntohl(addr); \
PUTLONG(l, ucp); \ PUTLONG(l, ucp); \
len -= CILEN_ADDR; \ len -= CILEN_ADDR; \
} else \ } else \
@ -884,7 +884,7 @@ static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) {
u32_t l; \ u32_t l; \
PUTCHAR(opt, ucp); \ PUTCHAR(opt, ucp); \
PUTCHAR(CILEN_ADDR, ucp); \ PUTCHAR(CILEN_ADDR, ucp); \
l = ntohl(addr); \ l = lwip_ntohl(addr); \
PUTLONG(l, ucp); \ PUTLONG(l, ucp); \
len -= CILEN_ADDR; \ len -= CILEN_ADDR; \
} else \ } else \
@ -953,11 +953,11 @@ static int ipcp_ackci(fsm *f, u_char *p, int len) {
citype != opt) \ citype != opt) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
if (val1 != cilong) \ if (val1 != cilong) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
if (val2 != cilong) \ if (val2 != cilong) \
goto bad; \ goto bad; \
} }
@ -998,7 +998,7 @@ static int ipcp_ackci(fsm *f, u_char *p, int len) {
citype != opt) \ citype != opt) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
if (val != cilong) \ if (val != cilong) \
goto bad; \ goto bad; \
} }
@ -1014,7 +1014,7 @@ static int ipcp_ackci(fsm *f, u_char *p, int len) {
if (cilen != CILEN_ADDR || citype != opt) \ if (cilen != CILEN_ADDR || citype != opt) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
if (addr != cilong) \ if (addr != cilong) \
goto bad; \ goto bad; \
} }
@ -1031,7 +1031,7 @@ static int ipcp_ackci(fsm *f, u_char *p, int len) {
if (cilen != CILEN_ADDR || citype != opt) \ if (cilen != CILEN_ADDR || citype != opt) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
if (addr != cilong) \ if (addr != cilong) \
goto bad; \ goto bad; \
} }
@ -1112,9 +1112,9 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
ciaddr1 = htonl(l); \ ciaddr1 = lwip_htonl(l); \
GETLONG(l, p); \ GETLONG(l, p); \
ciaddr2 = htonl(l); \ ciaddr2 = lwip_htonl(l); \
no.old_addrs = 1; \ no.old_addrs = 1; \
code \ code \
} }
@ -1141,7 +1141,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
ciaddr1 = htonl(l); \ ciaddr1 = lwip_htonl(l); \
no.neg = 1; \ no.neg = 1; \
code \ code \
} }
@ -1155,7 +1155,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
cidnsaddr = htonl(l); \ cidnsaddr = lwip_htonl(l); \
no.neg = 1; \ no.neg = 1; \
code \ code \
} }
@ -1271,11 +1271,11 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
goto bad; goto bad;
try_.neg_addr = 0; try_.neg_addr = 0;
GETLONG(l, p); GETLONG(l, p);
ciaddr1 = htonl(l); ciaddr1 = lwip_htonl(l);
if (ciaddr1 && go->accept_local) if (ciaddr1 && go->accept_local)
try_.ouraddr = ciaddr1; try_.ouraddr = ciaddr1;
GETLONG(l, p); GETLONG(l, p);
ciaddr2 = htonl(l); ciaddr2 = lwip_htonl(l);
if (ciaddr2 && go->accept_remote) if (ciaddr2 && go->accept_remote)
try_.hisaddr = ciaddr2; try_.hisaddr = ciaddr2;
no.old_addrs = 1; no.old_addrs = 1;
@ -1285,7 +1285,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
goto bad; goto bad;
try_.old_addrs = 0; try_.old_addrs = 0;
GETLONG(l, p); GETLONG(l, p);
ciaddr1 = htonl(l); ciaddr1 = lwip_htonl(l);
if (ciaddr1 && go->accept_local) if (ciaddr1 && go->accept_local)
try_.ouraddr = ciaddr1; try_.ouraddr = ciaddr1;
if (try_.ouraddr != 0) if (try_.ouraddr != 0)
@ -1297,7 +1297,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
if (go->req_dns1 || no.req_dns1 || cilen != CILEN_ADDR) if (go->req_dns1 || no.req_dns1 || cilen != CILEN_ADDR)
goto bad; goto bad;
GETLONG(l, p); GETLONG(l, p);
try_.dnsaddr[0] = htonl(l); try_.dnsaddr[0] = lwip_htonl(l);
try_.req_dns1 = 1; try_.req_dns1 = 1;
no.req_dns1 = 1; no.req_dns1 = 1;
break; break;
@ -1305,7 +1305,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
if (go->req_dns2 || no.req_dns2 || cilen != CILEN_ADDR) if (go->req_dns2 || no.req_dns2 || cilen != CILEN_ADDR)
goto bad; goto bad;
GETLONG(l, p); GETLONG(l, p);
try_.dnsaddr[1] = htonl(l); try_.dnsaddr[1] = lwip_htonl(l);
try_.req_dns2 = 1; try_.req_dns2 = 1;
no.req_dns2 = 1; no.req_dns2 = 1;
break; break;
@ -1316,7 +1316,7 @@ static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) {
if (cilen != CILEN_ADDR) if (cilen != CILEN_ADDR)
goto bad; goto bad;
GETLONG(l, p); GETLONG(l, p);
ciaddr1 = htonl(l); ciaddr1 = lwip_htonl(l);
if (ciaddr1) if (ciaddr1)
try_.winsaddr[citype == CI_MS_WINS2] = ciaddr1; try_.winsaddr[citype == CI_MS_WINS2] = ciaddr1;
break; break;
@ -1372,12 +1372,12 @@ static int ipcp_rejci(fsm *f, u_char *p, int len) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
/* Check rejected value. */ \ /* Check rejected value. */ \
if (cilong != val1) \ if (cilong != val1) \
goto bad; \ goto bad; \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
/* Check rejected value. */ \ /* Check rejected value. */ \
if (cilong != val2) \ if (cilong != val2) \
goto bad; \ goto bad; \
@ -1417,7 +1417,7 @@ static int ipcp_rejci(fsm *f, u_char *p, int len) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
/* Check rejected value. */ \ /* Check rejected value. */ \
if (cilong != val) \ if (cilong != val) \
goto bad; \ goto bad; \
@ -1434,7 +1434,7 @@ static int ipcp_rejci(fsm *f, u_char *p, int len) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
/* Check rejected value. */ \ /* Check rejected value. */ \
if (cilong != dnsaddr) \ if (cilong != dnsaddr) \
goto bad; \ goto bad; \
@ -1452,7 +1452,7 @@ static int ipcp_rejci(fsm *f, u_char *p, int len) {
len -= cilen; \ len -= cilen; \
INCPTR(2, p); \ INCPTR(2, p); \
GETLONG(l, p); \ GETLONG(l, p); \
cilong = htonl(l); \ cilong = lwip_htonl(l); \
/* Check rejected value. */ \ /* Check rejected value. */ \
if (cilong != addr) \ if (cilong != addr) \
goto bad; \ goto bad; \
@ -1575,13 +1575,13 @@ static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) {
* then accept it. * then accept it.
*/ */
GETLONG(tl, p); /* Parse source address (his) */ GETLONG(tl, p); /* Parse source address (his) */
ciaddr1 = htonl(tl); ciaddr1 = lwip_htonl(tl);
if (ciaddr1 != wo->hisaddr if (ciaddr1 != wo->hisaddr
&& (ciaddr1 == 0 || !wo->accept_remote)) { && (ciaddr1 == 0 || !wo->accept_remote)) {
orc = CONFNAK; orc = CONFNAK;
if (!reject_if_disagree) { if (!reject_if_disagree) {
DECPTR(sizeof(u32_t), p); DECPTR(sizeof(u32_t), p);
tl = ntohl(wo->hisaddr); tl = lwip_ntohl(wo->hisaddr);
PUTLONG(tl, p); PUTLONG(tl, p);
} }
} else if (ciaddr1 == 0 && wo->hisaddr == 0) { } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
@ -1598,13 +1598,13 @@ static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) {
* but disagree about it, then NAK it with our idea. * but disagree about it, then NAK it with our idea.
*/ */
GETLONG(tl, p); /* Parse desination address (ours) */ GETLONG(tl, p); /* Parse desination address (ours) */
ciaddr2 = htonl(tl); ciaddr2 = lwip_htonl(tl);
if (ciaddr2 != wo->ouraddr) { if (ciaddr2 != wo->ouraddr) {
if (ciaddr2 == 0 || !wo->accept_local) { if (ciaddr2 == 0 || !wo->accept_local) {
orc = CONFNAK; orc = CONFNAK;
if (!reject_if_disagree) { if (!reject_if_disagree) {
DECPTR(sizeof(u32_t), p); DECPTR(sizeof(u32_t), p);
tl = ntohl(wo->ouraddr); tl = lwip_ntohl(wo->ouraddr);
PUTLONG(tl, p); PUTLONG(tl, p);
} }
} else { } else {
@ -1631,13 +1631,13 @@ static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) {
* then accept it. * then accept it.
*/ */
GETLONG(tl, p); /* Parse source address (his) */ GETLONG(tl, p); /* Parse source address (his) */
ciaddr1 = htonl(tl); ciaddr1 = lwip_htonl(tl);
if (ciaddr1 != wo->hisaddr if (ciaddr1 != wo->hisaddr
&& (ciaddr1 == 0 || !wo->accept_remote)) { && (ciaddr1 == 0 || !wo->accept_remote)) {
orc = CONFNAK; orc = CONFNAK;
if (!reject_if_disagree) { if (!reject_if_disagree) {
DECPTR(sizeof(u32_t), p); DECPTR(sizeof(u32_t), p);
tl = ntohl(wo->hisaddr); tl = lwip_ntohl(wo->hisaddr);
PUTLONG(tl, p); PUTLONG(tl, p);
} }
} else if (ciaddr1 == 0 && wo->hisaddr == 0) { } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
@ -1666,9 +1666,9 @@ static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) {
break; break;
} }
GETLONG(tl, p); GETLONG(tl, p);
if (htonl(tl) != ao->dnsaddr[d]) { if (lwip_htonl(tl) != ao->dnsaddr[d]) {
DECPTR(sizeof(u32_t), p); DECPTR(sizeof(u32_t), p);
tl = ntohl(ao->dnsaddr[d]); tl = lwip_ntohl(ao->dnsaddr[d]);
PUTLONG(tl, p); PUTLONG(tl, p);
orc = CONFNAK; orc = CONFNAK;
} }
@ -1688,9 +1688,9 @@ static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) {
break; break;
} }
GETLONG(tl, p); GETLONG(tl, p);
if (htonl(tl) != ao->winsaddr[d]) { if (lwip_htonl(tl) != ao->winsaddr[d]) {
DECPTR(sizeof(u32_t), p); DECPTR(sizeof(u32_t), p);
tl = ntohl(ao->winsaddr[d]); tl = lwip_ntohl(ao->winsaddr[d]);
PUTLONG(tl, p); PUTLONG(tl, p);
orc = CONFNAK; orc = CONFNAK;
} }
@ -1793,7 +1793,7 @@ endswitch:
} }
PUTCHAR(CI_ADDR, ucp); PUTCHAR(CI_ADDR, ucp);
PUTCHAR(CILEN_ADDR, ucp); PUTCHAR(CILEN_ADDR, ucp);
tl = ntohl(wo->hisaddr); tl = lwip_ntohl(wo->hisaddr);
PUTLONG(tl, ucp); PUTLONG(tl, ucp);
} }
@ -1850,12 +1850,12 @@ ip_demand_conf(u)
if (wo->hisaddr == 0 && !pcb->settings.noremoteip) { if (wo->hisaddr == 0 && !pcb->settings.noremoteip) {
/* make up an arbitrary address for the peer */ /* make up an arbitrary address for the peer */
wo->hisaddr = htonl(0x0a707070 + ifunit); wo->hisaddr = lwip_htonl(0x0a707070 + ifunit);
wo->accept_remote = 1; wo->accept_remote = 1;
} }
if (wo->ouraddr == 0) { if (wo->ouraddr == 0) {
/* make up an arbitrary address for us */ /* make up an arbitrary address for us */
wo->ouraddr = htonl(0x0a404040 + ifunit); wo->ouraddr = lwip_htonl(0x0a404040 + ifunit);
wo->accept_local = 1; wo->accept_local = 1;
ask_for_local = 0; /* don't tell the peer this address */ ask_for_local = 0; /* don't tell the peer this address */
} }
@ -1917,7 +1917,7 @@ static void ipcp_up(fsm *f) {
return; return;
} }
if (ho->hisaddr == 0 && !pcb->settings.noremoteip) { if (ho->hisaddr == 0 && !pcb->settings.noremoteip) {
ho->hisaddr = htonl(0x0a404040); ho->hisaddr = lwip_htonl(0x0a404040);
ppp_warn("Could not determine remote IP address: defaulting to %I", ppp_warn("Could not determine remote IP address: defaulting to %I",
ho->hisaddr); ho->hisaddr);
} }
@ -2271,9 +2271,9 @@ static int ipcp_printpkt(const u_char *p, int plen,
if (olen == CILEN_ADDRS) { if (olen == CILEN_ADDRS) {
p += 2; p += 2;
GETLONG(cilong, p); GETLONG(cilong, p);
printer(arg, "addrs %I", htonl(cilong)); printer(arg, "addrs %I", lwip_htonl(cilong));
GETLONG(cilong, p); GETLONG(cilong, p);
printer(arg, " %I", htonl(cilong)); printer(arg, " %I", lwip_htonl(cilong));
} }
break; break;
#if VJ_SUPPORT #if VJ_SUPPORT
@ -2299,7 +2299,7 @@ static int ipcp_printpkt(const u_char *p, int plen,
if (olen == CILEN_ADDR) { if (olen == CILEN_ADDR) {
p += 2; p += 2;
GETLONG(cilong, p); GETLONG(cilong, p);
printer(arg, "addr %I", htonl(cilong)); printer(arg, "addr %I", lwip_htonl(cilong));
} }
break; break;
#if LWIP_DNS #if LWIP_DNS
@ -2316,7 +2316,7 @@ static int ipcp_printpkt(const u_char *p, int plen,
case CI_MS_WINS2: case CI_MS_WINS2:
p += 2; p += 2;
GETLONG(cilong, p); GETLONG(cilong, p);
printer(arg, "ms-wins %I", htonl(cilong)); printer(arg, "ms-wins %I", lwip_htonl(cilong));
break; break;
#endif /* UNUSED - WINS */ #endif /* UNUSED - WINS */
default: default:

4
src/netif/ppp/ipv6cp.c
View File

@ -1093,7 +1093,7 @@ static void ipv6_check_options() {
if (!wo->opt_local) { /* init interface identifier */ if (!wo->opt_local) { /* init interface identifier */
if (wo->use_ip && eui64_iszero(wo->ourid)) { if (wo->use_ip && eui64_iszero(wo->ourid)) {
eui64_setlo32(wo->ourid, ntohl(ipcp_wantoptions[0].ouraddr)); eui64_setlo32(wo->ourid, lwip_ntohl(ipcp_wantoptions[0].ouraddr));
if (!eui64_iszero(wo->ourid)) if (!eui64_iszero(wo->ourid))
wo->opt_local = 1; wo->opt_local = 1;
} }
@ -1104,7 +1104,7 @@ static void ipv6_check_options() {
if (!wo->opt_remote) { if (!wo->opt_remote) {
if (wo->use_ip && eui64_iszero(wo->hisid)) { if (wo->use_ip && eui64_iszero(wo->hisid)) {
eui64_setlo32(wo->hisid, ntohl(ipcp_wantoptions[0].hisaddr)); eui64_setlo32(wo->hisid, lwip_ntohl(ipcp_wantoptions[0].hisaddr));
if (!eui64_iszero(wo->hisid)) if (!eui64_iszero(wo->hisid))
wo->opt_remote = 1; wo->opt_remote = 1;
} }

4
src/netif/ppp/multilink.c
View File

@ -469,7 +469,7 @@ get_default_epdisc(ep)
if (hp != NULL) { if (hp != NULL) {
addr = *(u32_t *)hp->h_addr; addr = *(u32_t *)hp->h_addr;
if (!bad_ip_adrs(addr)) { if (!bad_ip_adrs(addr)) {
addr = ntohl(addr); addr = lwip_ntohl(addr);
if (!LOCAL_IP_ADDR(addr)) { if (!LOCAL_IP_ADDR(addr)) {
ep->class = EPD_IP; ep->class = EPD_IP;
set_ip_epdisc(ep, addr); set_ip_epdisc(ep, addr);
@ -504,7 +504,7 @@ epdisc_to_str(ep)
u32_t addr; u32_t addr;
GETLONG(addr, p); GETLONG(addr, p);
slprintf(str, sizeof(str), "IP:%I", htonl(addr)); slprintf(str, sizeof(str), "IP:%I", lwip_htonl(addr));
return str; return str;
} }

4
src/netif/ppp/ppp.c
View File

@ -1219,7 +1219,7 @@ u32_t get_mask(u32_t addr) {
#if 0 #if 0
u32_t mask, nmask; u32_t mask, nmask;
addr = htonl(addr); addr = lwip_htonl(addr);
if (IP_CLASSA(addr)) { /* determine network mask for address class */ if (IP_CLASSA(addr)) { /* determine network mask for address class */
nmask = IP_CLASSA_NET; nmask = IP_CLASSA_NET;
} else if (IP_CLASSB(addr)) { } else if (IP_CLASSB(addr)) {
@ -1229,7 +1229,7 @@ u32_t get_mask(u32_t addr) {
} }
/* class D nets are disallowed by bad_ip_adrs */ /* class D nets are disallowed by bad_ip_adrs */
mask = PP_HTONL(0xffffff00UL) | htonl(nmask); mask = PP_HTONL(0xffffff00UL) | lwip_htonl(nmask);
/* XXX /* XXX
* Scan through the system's network interfaces. * Scan through the system's network interfaces.

14
src/netif/ppp/pppoe.c
View File

@ -419,8 +419,8 @@ pppoe_disc_input(struct netif *netif, struct pbuf *pb)
PPPDEBUG(LOG_DEBUG, ("pppoe: unknown version/type packet: 0x%x\n", ph->vertype)); PPPDEBUG(LOG_DEBUG, ("pppoe: unknown version/type packet: 0x%x\n", ph->vertype));
goto done; goto done;
} }
session = ntohs(ph->session); session = lwip_ntohs(ph->session);
plen = ntohs(ph->plen); plen = lwip_ntohs(ph->plen);
off += sizeof(*ph); off += sizeof(*ph);
if (plen + off > pb->len) { if (plen + off > pb->len) {
@ -436,8 +436,8 @@ pppoe_disc_input(struct netif *netif, struct pbuf *pb)
sc = NULL; sc = NULL;
while (off + sizeof(pt) <= pb->len) { while (off + sizeof(pt) <= pb->len) {
MEMCPY(&pt, (u8_t*)pb->payload + off, sizeof(pt)); MEMCPY(&pt, (u8_t*)pb->payload + off, sizeof(pt));
tag = ntohs(pt.tag); tag = lwip_ntohs(pt.tag);
len = ntohs(pt.len); len = lwip_ntohs(pt.len);
if (off + sizeof(pt) + len > pb->len) { if (off + sizeof(pt) + len > pb->len) {
PPPDEBUG(LOG_DEBUG, ("pppoe: tag 0x%x len 0x%x is too long\n", tag, len)); PPPDEBUG(LOG_DEBUG, ("pppoe: tag 0x%x len 0x%x is too long\n", tag, len));
goto done; goto done;
@ -680,7 +680,7 @@ pppoe_data_input(struct netif *netif, struct pbuf *pb)
goto drop; goto drop;
} }
session = ntohs(ph->session); session = lwip_ntohs(ph->session);
sc = pppoe_find_softc_by_session(session, netif); sc = pppoe_find_softc_by_session(session, netif);
if (sc == NULL) { if (sc == NULL) {
#ifdef PPPOE_TERM_UNKNOWN_SESSIONS #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
@ -690,7 +690,7 @@ pppoe_data_input(struct netif *netif, struct pbuf *pb)
goto drop; goto drop;
} }
plen = ntohs(ph->plen); plen = lwip_ntohs(ph->plen);
if (pbuf_header(pb, -(s16_t)(PPPOE_HEADERLEN)) != 0) { if (pbuf_header(pb, -(s16_t)(PPPOE_HEADERLEN)) != 0) {
/* bail out */ /* bail out */
@ -732,7 +732,7 @@ pppoe_output(struct pppoe_softc *sc, struct pbuf *pb)
} }
ethhdr = (struct eth_hdr *)pb->payload; ethhdr = (struct eth_hdr *)pb->payload;
etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHTYPE_PPPOE : ETHTYPE_PPPOEDISC; etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHTYPE_PPPOE : ETHTYPE_PPPOEDISC;
ethhdr->type = htons(etype); ethhdr->type = lwip_htons(etype);
MEMCPY(&ethhdr->dest.addr, &sc->sc_dest.addr, sizeof(ethhdr->dest.addr)); MEMCPY(&ethhdr->dest.addr, &sc->sc_dest.addr, sizeof(ethhdr->dest.addr));
MEMCPY(&ethhdr->src.addr, &sc->sc_ethif->hwaddr, sizeof(ethhdr->src.addr)); MEMCPY(&ethhdr->src.addr, &sc->sc_ethif->hwaddr, sizeof(ethhdr->src.addr));

2
src/netif/ppp/utils.c
View File

@ -267,7 +267,7 @@ int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args) {
#endif /* do we always have strerror() in embedded ? */ #endif /* do we always have strerror() in embedded ? */
case 'I': case 'I':
ip = va_arg(args, u32_t); ip = va_arg(args, u32_t);
ip = ntohl(ip); ip = lwip_ntohl(ip);
ppp_slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff, ppp_slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff,
(ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff); (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
str = num; str = num;

62
src/netif/ppp/vj.c
View File

@ -95,32 +95,32 @@ vj_compress_init(struct vjcompress *comp)
#define DECODEL(f) { \ #define DECODEL(f) { \
if (*cp == 0) {\ if (*cp == 0) {\
u32_t tmp_ = ntohl(f) + ((cp[1] << 8) | cp[2]); \ u32_t tmp_ = lwip_ntohl(f) + ((cp[1] << 8) | cp[2]); \
(f) = htonl(tmp_); \ (f) = lwip_htonl(tmp_); \
cp += 3; \ cp += 3; \
} else { \ } else { \
u32_t tmp_ = ntohl(f) + (u32_t)*cp++; \ u32_t tmp_ = lwip_ntohl(f) + (u32_t)*cp++; \
(f) = htonl(tmp_); \ (f) = lwip_htonl(tmp_); \
} \ } \
} }
#define DECODES(f) { \ #define DECODES(f) { \
if (*cp == 0) {\ if (*cp == 0) {\
u16_t tmp_ = ntohs(f) + (((u16_t)cp[1] << 8) | cp[2]); \ u16_t tmp_ = lwip_ntohs(f) + (((u16_t)cp[1] << 8) | cp[2]); \
(f) = htons(tmp_); \ (f) = lwip_htons(tmp_); \
cp += 3; \ cp += 3; \
} else { \ } else { \
u16_t tmp_ = ntohs(f) + (u16_t)*cp++; \ u16_t tmp_ = lwip_ntohs(f) + (u16_t)*cp++; \
(f) = htons(tmp_); \ (f) = lwip_htons(tmp_); \
} \ } \
} }
#define DECODEU(f) { \ #define DECODEU(f) { \
if (*cp == 0) {\ if (*cp == 0) {\
(f) = htons(((u16_t)cp[1] << 8) | cp[2]); \ (f) = lwip_htons(((u16_t)cp[1] << 8) | cp[2]); \
cp += 3; \ cp += 3; \
} else { \ } else { \
(f) = htons((u16_t)*cp++); \ (f) = lwip_htons((u16_t)*cp++); \
} \ } \
} }
@ -306,7 +306,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
* needed in this section of code). * needed in this section of code).
*/ */
if (TCPH_FLAGS(th) & TCP_URG) { if (TCPH_FLAGS(th) & TCP_URG) {
deltaS = ntohs(th->urgp); deltaS = lwip_ntohs(th->urgp);
ENCODEZ(deltaS); ENCODEZ(deltaS);
changes |= NEW_U; changes |= NEW_U;
} else if (th->urgp != oth->urgp) { } else if (th->urgp != oth->urgp) {
@ -317,12 +317,12 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
goto uncompressed; goto uncompressed;
} }
if ((deltaS = (u16_t)(ntohs(th->wnd) - ntohs(oth->wnd))) != 0) { if ((deltaS = (u16_t)(lwip_ntohs(th->wnd) - lwip_ntohs(oth->wnd))) != 0) {
ENCODE(deltaS); ENCODE(deltaS);
changes |= NEW_W; changes |= NEW_W;
} }
if ((deltaL = ntohl(th->ackno) - ntohl(oth->ackno)) != 0) { if ((deltaL = lwip_ntohl(th->ackno) - lwip_ntohl(oth->ackno)) != 0) {
if (deltaL > 0xffff) { if (deltaL > 0xffff) {
goto uncompressed; goto uncompressed;
} }
@ -331,7 +331,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
changes |= NEW_A; changes |= NEW_A;
} }
if ((deltaL = ntohl(th->seqno) - ntohl(oth->seqno)) != 0) { if ((deltaL = lwip_ntohl(th->seqno) - lwip_ntohl(oth->seqno)) != 0) {
if (deltaL > 0xffff) { if (deltaL > 0xffff) {
goto uncompressed; goto uncompressed;
} }
@ -351,7 +351,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
* in case the other side missed the compressed version. * in case the other side missed the compressed version.
*/ */
if (IPH_LEN(ip) != IPH_LEN(&cs->cs_ip) && if (IPH_LEN(ip) != IPH_LEN(&cs->cs_ip) &&
ntohs(IPH_LEN(&cs->cs_ip)) == hlen) { lwip_ntohs(IPH_LEN(&cs->cs_ip)) == hlen) {
break; break;
} }
/* no break */ /* no break */
@ -366,7 +366,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
goto uncompressed; goto uncompressed;
case NEW_S|NEW_A: case NEW_S|NEW_A:
if (deltaS == deltaA && deltaS == ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { if (deltaS == deltaA && deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) {
/* special case for echoed terminal traffic */ /* special case for echoed terminal traffic */
changes = SPECIAL_I; changes = SPECIAL_I;
cp = new_seq; cp = new_seq;
@ -374,7 +374,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
break; break;
case NEW_S: case NEW_S:
if (deltaS == ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { if (deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) {
/* special case for data xfer */ /* special case for data xfer */
changes = SPECIAL_D; changes = SPECIAL_D;
cp = new_seq; cp = new_seq;
@ -384,7 +384,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
break; break;
} }
deltaS = (u16_t)(ntohs(IPH_ID(ip)) - ntohs(IPH_ID(&cs->cs_ip))); deltaS = (u16_t)(lwip_ntohs(IPH_ID(ip)) - lwip_ntohs(IPH_ID(&cs->cs_ip)));
if (deltaS != 1) { if (deltaS != 1) {
ENCODEZ(deltaS); ENCODEZ(deltaS);
changes |= NEW_I; changes |= NEW_I;
@ -396,7 +396,7 @@ vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb)
* Grab the cksum before we overwrite it below. Then update our * Grab the cksum before we overwrite it below. Then update our
* state with this packet's header. * state with this packet's header.
*/ */
deltaA = ntohs(th->chksum); deltaA = lwip_ntohs(th->chksum);
MEMCPY(&cs->cs_ip, ip, hlen); MEMCPY(&cs->cs_ip, ip, hlen);
/* /*
@ -538,7 +538,7 @@ vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp)
cs = &comp->rstate[comp->last_recv]; cs = &comp->rstate[comp->last_recv];
hlen = IPH_HL(&cs->cs_ip) << 2; hlen = IPH_HL(&cs->cs_ip) << 2;
th = (struct tcp_hdr *)&((u8_t*)&cs->cs_ip)[hlen]; th = (struct tcp_hdr *)&((u8_t*)&cs->cs_ip)[hlen];
th->chksum = htons((*cp << 8) | cp[1]); th->chksum = lwip_htons((*cp << 8) | cp[1]);
cp += 2; cp += 2;
if (changes & TCP_PUSH_BIT) { if (changes & TCP_PUSH_BIT) {
TCPH_SET_FLAG(th, TCP_PSH); TCPH_SET_FLAG(th, TCP_PSH);
@ -549,19 +549,19 @@ vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp)
switch (changes & SPECIALS_MASK) { switch (changes & SPECIALS_MASK) {
case SPECIAL_I: case SPECIAL_I:
{ {
u32_t i = ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; u32_t i = lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen;
/* some compilers can't nest inline assembler.. */ /* some compilers can't nest inline assembler.. */
tmp = ntohl(th->ackno) + i; tmp = lwip_ntohl(th->ackno) + i;
th->ackno = htonl(tmp); th->ackno = lwip_htonl(tmp);
tmp = ntohl(th->seqno) + i; tmp = lwip_ntohl(th->seqno) + i;
th->seqno = htonl(tmp); th->seqno = lwip_htonl(tmp);
} }
break; break;
case SPECIAL_D: case SPECIAL_D:
/* some compilers can't nest inline assembler.. */ /* some compilers can't nest inline assembler.. */
tmp = ntohl(th->seqno) + ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; tmp = lwip_ntohl(th->seqno) + lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen;
th->seqno = htonl(tmp); th->seqno = lwip_htonl(tmp);
break; break;
default: default:
@ -585,8 +585,8 @@ vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp)
if (changes & NEW_I) { if (changes & NEW_I) {
DECODES(cs->cs_ip._id); DECODES(cs->cs_ip._id);
} else { } else {
IPH_ID_SET(&cs->cs_ip, ntohs(IPH_ID(&cs->cs_ip)) + 1); IPH_ID_SET(&cs->cs_ip, lwip_ntohs(IPH_ID(&cs->cs_ip)) + 1);
IPH_ID_SET(&cs->cs_ip, htons(IPH_ID(&cs->cs_ip))); IPH_ID_SET(&cs->cs_ip, lwip_htons(IPH_ID(&cs->cs_ip)));
} }
/* /*
@ -607,9 +607,9 @@ vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp)
#if BYTE_ORDER == LITTLE_ENDIAN #if BYTE_ORDER == LITTLE_ENDIAN
tmp = n0->tot_len - vjlen + cs->cs_hlen; tmp = n0->tot_len - vjlen + cs->cs_hlen;
IPH_LEN_SET(&cs->cs_ip, htons((u16_t)tmp)); IPH_LEN_SET(&cs->cs_ip, lwip_htons((u16_t)tmp));
#else #else
IPH_LEN_SET(&cs->cs_ip, htons(n0->tot_len - vjlen + cs->cs_hlen)); IPH_LEN_SET(&cs->cs_ip, lwip_htons(n0->tot_len - vjlen + cs->cs_hlen));
#endif #endif
/* recompute the ip header checksum */ /* recompute the ip header checksum */