Hi Chris,
On 25 January 2017 at 01:56, Chris Packham judge.packham@gmail.com wrote:
Adds basic support for IPv6. Neighbor discovery and ping6 are the only things supported at the moment.
Helped-by: Hanna Hawa hannah@marvell.com [endian & alignment fixes] Signed-off-by: Chris Packham judge.packham@gmail.com
Now we have something functional. With this and the next patch you can do something like 'setenv ipaddr6 3ffe::1/64' and 'ping6 3ffe::2' should work.
I seem to have a problem that when you send a ping6 for a non-existent address that ends up stuck and the next non-ipv6 net operation tries to resolve it. I suspect this is because the pending neighbor discovery information isn't cleaned up properly, I need to look into that.
Changes in v3: None Changes in v2:
- split ping6 support into separate patch
- split environment variables into separate patch
- change ip6_ndisc_* to ndisc_*, fix CamelCase
include/net.h | 1 + include/net6.h | 194 +++++++++++++++++++++++++++++++++++++ net/Makefile | 2 + net/ndisc.c | 266 ++++++++++++++++++++++++++++++++++++++++++++++++++ net/ndisc.h | 25 +++++ net/net.c | 37 ++++++- net/net6.c | 299 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 823 insertions(+), 1 deletion(-) create mode 100644 net/ndisc.c create mode 100644 net/ndisc.h
Reviewed-by: Simon Glass sjg@chromium.org
Looks good to me. I've made a few suggestions below.
diff --git a/include/net.h b/include/net.h index 10d98d92535b..b0348adf955e 100644 --- a/include/net.h +++ b/include/net.h
[..]
+struct nd_opt_hdr {
__u8 nd_opt_type;__u8 nd_opt_len;+} __attribute__((__packed__));
Can you use __packed?
+extern struct in6_addr const net_null_addr_ip6; /* NULL IPv6 address */ +extern struct in6_addr net_gateway6; /* Our gateways IPv6 address */ +extern struct in6_addr net_ip6; /* Our IPv6 addr (0 = unknown) */ +extern struct in6_addr net_link_local_ip6; /* Our link local IPv6 addr */ +extern u_int32_t net_prefix_length; /* Our prefixlength (0 = unknown) */ +extern struct in6_addr net_server_ip6; /* Server IPv6 addr (0 = unknown) */
+#ifdef CONFIG_CMD_PING +extern struct in6_addr net_ping_ip6; /* the ipv6 address to ping */ +#endif
Do these need to be external? Perhaps they should be accessed via functions?
/* ::ffff:0:0/96 is reserved for v4 mapped addresses */ static inline int ipv6_addr_v4mapped(const struct in6_addr *a) { @@ -61,4 +210,49 @@ static inline int ipv6_addr_is_isatap(const struct in6_addr *a) /* Convert a string to an ipv6 address */ int string_to_ip6(const char *s, struct in6_addr *addr);
+/* check that an IPv6 address is unspecified (zero) */ +int ip6_is_unspecified_addr(struct in6_addr *addr);
+/* check that an IPv6 address is ours */ +int ip6_is_our_addr(struct in6_addr *addr);
+void ip6_make_lladdr(struct in6_addr *lladr, unsigned char const enetaddr[6]);
+void ip6_make_snma(struct in6_addr *mcast_addr, struct in6_addr *ip6_addr);
+void ip6_make_mult_ethdstaddr(unsigned char enetaddr[6],
struct in6_addr *mcast_addr);+/* check if neighbour is in the same subnet as us */
What does it return in either case? E.g. does 0 mean it does, or does not? Can you beef up the comments on these functions a bit, with arg descriptions and return values?
+int ip6_addr_in_subnet(struct in6_addr *our_addr, struct in6_addr *neigh_addr,
__u32 prefix_length);+unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum);
+unsigned short int csum_ipv6_magic(struct in6_addr *saddr,
struct in6_addr *daddr, __u16 len,unsigned short proto, unsigned int csum);+int ip6_add_hdr(uchar *xip, struct in6_addr *src, struct in6_addr *dest,
int nextheader, int hoplimit, int payload_len);+/* sends an IPv6 echo request to a host */ +int ping6_send(void);
+/* starts a Ping6 process */ +void ping6_start(void);
+/* handles reception of icmpv6 echo request/reply */ +void ping6_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6,
int len);+/* handler for incoming IPv6 echo packet */ +void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
int len);+/* copy IPv6 */ +static inline void net_copy_ip6(void *to, const void *from) +{
memcpy((void *)to, from, sizeof(struct in6_addr));+} #endif /* __NET6_H__ */ diff --git a/net/Makefile b/net/Makefile index b5e8c5c758c9..6967eefffffe 100644 --- a/net/Makefile +++ b/net/Makefile @@ -26,3 +26,5 @@ obj-$(CONFIG_CMD_RARP) += rarp.o obj-$(CONFIG_CMD_SNTP) += sntp.o obj-$(CONFIG_CMD_NET) += tftp.o obj-$(CONFIG_NET6) += net6.o +obj-$(CONFIG_NET6) += ndisc.o +obj-$(CONFIG_CMD_PING6) += ping6.o diff --git a/net/ndisc.c b/net/ndisc.c new file mode 100644 index 000000000000..290eaeeb9465 --- /dev/null +++ b/net/ndisc.c @@ -0,0 +1,266 @@ +/*
- net/ndisc.c
- (C) Copyright 2013 Allied Telesis Labs NZ
- SPDX-License-Identifier: GPL-2.0+
- */
+#include <common.h> +#include <net.h> +#include <net6.h> +#include "ndisc.h"
+/* IPv6 destination address of packet waiting for ND */ +struct in6_addr net_nd_sol_packet_ip6 = ZERO_IPV6_ADDR; +/* IPv6 address we are expecting ND advert from */ +static struct in6_addr net_nd_rep_packet_ip6 = ZERO_IPV6_ADDR; +/* MAC destination address of packet waiting for ND */ +uchar *net_nd_packet_mac; +/* pointer to packet waiting to be transmitted after ND is resolved */ +uchar *net_nd_tx_packet; +static uchar net_nd_packet_buf[PKTSIZE_ALIGN + PKTALIGN]; +/* size of packet waiting to be transmitted */ +int net_nd_tx_packet_size; +/* the timer for ND resolution */ +ulong net_nd_timer_start; +/* the number of requests we have sent so far */ +int net_nd_try;
+#define IP6_NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
+/**
- Insert an option into a neighbor discovery packet.
- Returns the number of bytes inserted (which may be >= len)
- */
+static int +ndisc_insert_option(struct nd_msg *ndisc, int type, u8 *data, int len)
Should join those lines, wrapping the args if needed. Similarly below.
+{
int space = IP6_NDISC_OPT_SPACE(len);ndisc->opt[0] = type;ndisc->opt[1] = space >> 3;memcpy(&ndisc->opt[2], data, len);len += 2;/* fill the remainder with 0 */if ((space - len) > 0)memset(&ndisc->opt[len], 0, space - len);return space;+}
+/**
- Extract the Ethernet address from a neighbor discovery packet.
- Note that the link layer address could be anything but the only networking
- media that u-boot supports is Ethernet so we assume we're extracting a 6
U-Boot
- byte Ethernet MAC address.
- */
+static void ndisc_extract_enetaddr(struct nd_msg *ndisc, uchar enetaddr[6]) +{
memcpy(enetaddr, &ndisc->opt[2], 6);+}
+/**
- Check to see if the neighbor discovery packet has
- the specified option set.
@return ...
Similarly elsewhere
- */
+static int ndisc_has_option(struct ip6_hdr *ip6, __u8 type) +{
struct nd_msg *ndisc = (struct nd_msg *)(((uchar *)ip6) + IP6_HDR_SIZE);if (ip6->payload_len <= sizeof(struct icmp6hdr))return 0;return ndisc->opt[0] == type;+}
+static void ip6_send_ns(struct in6_addr *neigh_addr) +{
struct in6_addr dst_adr;unsigned char enetaddr[6];struct nd_msg *msg;__u16 len;uchar *pkt;debug("sending neighbor solicitation for %pI6c our address %pI6c\n",neigh_addr, &net_link_local_ip6);/* calculate src, dest IPv6 addr and dest Eth addr */ip6_make_snma(&dst_adr, neigh_addr);ip6_make_mult_ethdstaddr(enetaddr, &dst_adr);len = sizeof(struct icmp6hdr) + IN6ADDRSZ +IP6_NDISC_OPT_SPACE(INETHADDRSZ);pkt = (uchar *)net_tx_packet;pkt += net_set_ether(pkt, enetaddr, PROT_IP6);pkt += ip6_add_hdr(pkt, &net_link_local_ip6, &dst_adr, IPPROTO_ICMPV6,IPV6_NDISC_HOPLIMIT, len);/* ICMPv6 - NS */msg = (struct nd_msg *)pkt;msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_SOLICITATION;msg->icmph.icmp6_code = 0;memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));/* Set the target address and llsaddr option */net_copy_ip6(&msg->target, neigh_addr);ndisc_insert_option(msg, ND_OPT_SOURCE_LL_ADDR, net_ethaddr,INETHADDRSZ);/* checksum */msg->icmph.icmp6_cksum = csum_ipv6_magic(&net_link_local_ip6, &dst_adr,len, IPPROTO_ICMPV6,csum_partial((__u8 *)msg, len, 0));pkt += len;/* send it! */net_send_packet(net_tx_packet, (pkt - net_tx_packet));+}
+static void +ip6_send_na(uchar *eth_dst_addr, struct in6_addr *neigh_addr,
struct in6_addr *target)+{
struct nd_msg *msg;__u16 len;uchar *pkt;debug("sending neighbor advertisement for %pI6c to %pI6c (%pM)\n",target, neigh_addr, eth_dst_addr);len = sizeof(struct icmp6hdr) + IN6ADDRSZ +IP6_NDISC_OPT_SPACE(INETHADDRSZ);pkt = (uchar *)net_tx_packet;pkt += net_set_ether(pkt, eth_dst_addr, PROT_IP6);pkt += ip6_add_hdr(pkt, &net_link_local_ip6, neigh_addr,IPPROTO_ICMPV6, IPV6_NDISC_HOPLIMIT, len);/* ICMPv6 - NA */msg = (struct nd_msg *)pkt;msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT;msg->icmph.icmp6_code = 0;memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));/* Set the target address and lltargetaddr option */net_copy_ip6(&msg->target, target);ndisc_insert_option(msg, ND_OPT_TARGET_LL_ADDR, net_ethaddr,INETHADDRSZ);/* checksum */msg->icmph.icmp6_cksum = csum_ipv6_magic(&net_link_local_ip6,neigh_addr, len, IPPROTO_ICMPV6,csum_partial((__u8 *)msg, len, 0));pkt += len;/* send it! */net_send_packet(net_tx_packet, (pkt - net_tx_packet));
This code seems similar to the previous function. Can you see if you can factor out the common code?
+}
+void ndisc_request(void) +{
if (!ip6_addr_in_subnet(&net_ip6, &net_nd_sol_packet_ip6,net_prefix_length)) {if (ip6_is_unspecified_addr(&net_gateway6)) {puts("## Warning: gatewayip6 is needed but not set\n");net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;} else {net_nd_rep_packet_ip6 = net_gateway6;}} else {net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;}ip6_send_ns(&net_nd_rep_packet_ip6);+}
+int ndisc_timeout_check(void) +{
ulong t;if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))return 0;t = get_timer(0);/* check for NDISC timeout */if ((t - net_nd_timer_start) > NDISC_TIMEOUT) {net_nd_try++;if (net_nd_try >= NDISC_TIMEOUT_COUNT) {puts("\nNeighbour discovery retry count exceeded; ""starting again\n");
Use printf() and don't split strings as it makes it hard to grep. A long line is OK in this situation.
net_nd_try = 0;net_set_state(NETLOOP_FAIL);} else {net_nd_timer_start = t;ndisc_request();}}return 1;+}
+void ndisc_init(void) +{
net_nd_packet_mac = NULL;net_nd_tx_packet = NULL;net_nd_sol_packet_ip6 = net_null_addr_ip6;net_nd_rep_packet_ip6 = net_null_addr_ip6;net_nd_tx_packet_size = 0;net_nd_tx_packet = &net_nd_packet_buf[0] + (PKTALIGN - 1);net_nd_tx_packet -= (ulong)net_nd_tx_packet % PKTALIGN;
Can these go in a struct instead of all being individual globals?
+}
+void ndisc_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len) +{
struct icmp6hdr *icmp =(struct icmp6hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);struct nd_msg *ndisc = (struct nd_msg *)icmp;uchar neigh_eth_addr[6];switch (icmp->icmp6_type) {case IPV6_NDISC_NEIGHBOUR_SOLICITATION:debug("received neighbor solicitation for %pI6c from %pI6c\n",&ndisc->target, &ip6->saddr);if (ip6_is_our_addr(&ndisc->target) &&ndisc_has_option(ip6, ND_OPT_SOURCE_LL_ADDR)) {ndisc_extract_enetaddr(ndisc, neigh_eth_addr);ip6_send_na(neigh_eth_addr, &ip6->saddr,&ndisc->target);}break;
Don't need this blank line.
case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:/* are we waiting for a reply ? */if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))break;if ((memcmp(&ndisc->target, &net_nd_rep_packet_ip6,sizeof(struct in6_addr)) == 0) &&ndisc_has_option(ip6, ND_OPT_TARGET_LL_ADDR)) {ndisc_extract_enetaddr(ndisc, neigh_eth_addr);/* save address for later use */if (net_nd_packet_mac != NULL)memcpy(net_nd_packet_mac, neigh_eth_addr, 6);/* modify header, and transmit it */memcpy(((struct ethernet_hdr *)net_nd_tx_packet)->et_dest,neigh_eth_addr, 6);net_send_packet(net_nd_tx_packet,net_nd_tx_packet_size);/* no ND request pending now */net_nd_sol_packet_ip6 = net_null_addr_ip6;net_nd_tx_packet_size = 0;net_nd_packet_mac = NULL;}break;default:debug("Unexpected ICMPv6 type 0x%x\n", icmp->icmp6_type);}+} diff --git a/net/ndisc.h b/net/ndisc.h new file mode 100644 index 000000000000..75138d0a777c --- /dev/null +++ b/net/ndisc.h @@ -0,0 +1,25 @@ +/*
- net/ndisc.h
- (C) Copyright 2013 Allied Telesis Labs NZ
- SPDX-License-Identifier: GPL-2.0+
- */
+/* IPv6 destination address of packet waiting for ND */ +extern struct in6_addr net_nd_sol_packet_ip6; +/* MAC destination address of packet waiting for ND */ +extern uchar *net_nd_packet_mac; +/* pointer to packet waiting to be transmitted after ND is resolved */ +extern uchar *net_nd_tx_packet; +/* size of packet waiting to be transmitted */ +extern int net_nd_tx_packet_size; +/* the timer for ND resolution */ +extern ulong net_nd_timer_start; +/* the number of requests we have sent so far */ +extern int net_nd_try;
+void ndisc_init(void); +void ndisc_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len); +void ndisc_request(void); +int ndisc_timeout_check(void); diff --git a/net/net.c b/net/net.c index 6e678770fa9d..527c99f96f9f 100644 --- a/net/net.c +++ b/net/net.c @@ -87,6 +87,7 @@ #include <environment.h> #include <errno.h> #include <net.h> +#include <net6.h> #include <net/tftp.h> #if defined(CONFIG_LED_STATUS) #include <miiphy.h> @@ -95,6 +96,7 @@ #include <watchdog.h> #include <linux/compiler.h> #include "arp.h" +#include "ndisc.h" #include "bootp.h" #include "cdp.h" #if defined(CONFIG_CMD_DNS) @@ -342,8 +344,12 @@ void net_auto_load(void)
static void net_init_loop(void) {
if (eth_get_dev())
if (eth_get_dev()) { memcpy(net_ethaddr, eth_get_ethaddr(), 6);+#ifdef CONFIG_NET6
ip6_make_lladdr(&net_link_local_ip6, net_ethaddr);+#endif
} return;} @@ -377,6 +383,9 @@ void net_init(void) (i + 1) * PKTSIZE_ALIGN; } arp_init(); +#ifdef CONFIG_NET6
ndisc_init();+#endif net_clear_handlers();
/* Only need to setup buffer pointers once. */@@ -479,6 +488,11 @@ restart: ping_start(); break; #endif +#ifdef CONFIG_CMD_PING6
case PING6:ping6_start();break;+#endif #if defined(CONFIG_CMD_NFS) case NFS: nfs_start(); @@ -544,6 +558,11 @@ restart: #endif if (arp_timeout_check() > 0) time_start = get_timer(0); +#ifdef CONFIG_NET6
else if (ndisc_timeout_check() > 0)time_start = get_timer(0);+#endif
/* * Check the ethernet for a new packet. The ethernet@@ -559,6 +578,9 @@ restart: if (ctrlc()) { /* cancel any ARP that may not have completed */ net_arp_wait_packet_ip.s_addr = 0; +#ifdef CONFIG_NET6
net_nd_sol_packet_ip6 = net_null_addr_ip6;+#endif
net_cleanup_loop(); eth_halt();@@ -1137,6 +1159,11 @@ void net_process_received_packet(uchar *in_packet, int len) rarp_receive(ip, len); break; #endif +#ifdef CONFIG_NET6
case PROT_IP6:net_ip6_handler(et, (struct ip6_hdr *)ip, len);
net_ip6_handler() looks like it should return an error, which can be checked here.
break;+#endif case PROT_IP: debug_cond(DEBUG_NET_PKT, "Got IP\n"); /* Before we start poking the header, make sure it is there */ @@ -1291,6 +1318,14 @@ static int net_check_prereq(enum proto_t protocol) } goto common; #endif +#ifdef CONFIG_CMD_PING6
case PING6:if (ip6_is_unspecified_addr(&net_ping_ip6)) {puts("*** ERROR: ping address not given\n");return 1;}goto common;+#endif #if defined(CONFIG_CMD_SNTP) case SNTP: if (net_ntp_server.s_addr == 0) { diff --git a/net/net6.c b/net/net6.c index f778cef5ada9..955a08987be9 100644 --- a/net/net6.c +++ b/net/net6.c @@ -8,6 +8,34 @@
- SPDX-License-Identifier: GPL-2.0+
*/
+/*
- General Desription:
- The user interface supports commands for TFTP6.
- Also, we support Neighbour discovery internally. Depending on available
- data, these interact as follows:
- Neighbour Discovery:
Prerequisites: - own ethernet address
- own IPv6 address
- TFTP server IPv6 address
We want: - TFTP server ethernet address
Next step: TFTP
- TFTP over IPv6:
Prerequisites: - own ethernet address
- own IPv6 address
- TFTP server IPv6 address
- TFTP server ethernet address
- name of bootfile (if unknown, we use a default name
derived from our own IPv6 address)
We want: - load the boot file
Next step: none
- */
+#define DEBUG
Do you want that?
#include <common.h> #include <environment.h> #include <malloc.h> @@ -15,10 +43,14 @@ #include <net6.h> #include "ndisc.h"
+/* NULL IPv6 address */ +struct in6_addr const net_null_addr_ip6 = ZERO_IPV6_ADDR; /* Our gateway's IPv6 address */ struct in6_addr net_gateway6 = ZERO_IPV6_ADDR; /* Our IPv6 addr (0 = unknown) */ struct in6_addr net_ip6 = ZERO_IPV6_ADDR; +/* Our link local IPv6 addr (0 = unknown) */ +struct in6_addr net_link_local_ip6 = ZERO_IPV6_ADDR; /* set server IPv6 addr (0 = unknown) */ struct in6_addr net_server_ip6 = ZERO_IPV6_ADDR; /* The prefix length of our network */ @@ -87,3 +119,270 @@ static int on_serverip6(const char *name, const char *value, enum env_op op, return string_to_ip6(value, &net_server_ip6); } U_BOOT_ENV_CALLBACK(serverip6, on_serverip6);
+int ip6_is_unspecified_addr(struct in6_addr *addr) +{
return (addr->s6_addr32[0] | addr->s6_addr32[1] |addr->s6_addr32[2] | addr->s6_addr32[3]) == 0;+}
+/**
- We have 2 addresses that we should respond to. A link
- local address and a global address. This returns true
- if the specified address matches either of these.
- */
+int ip6_is_our_addr(struct in6_addr *addr) +{
return memcmp(addr, &net_link_local_ip6, sizeof(struct in6_addr)) == 0 ||memcmp(addr, &net_ip6, sizeof(struct in6_addr)) == 0;+}
+void ip6_make_eui(unsigned char eui[8], unsigned char const enetaddr[6]) +{
memcpy(eui, enetaddr, 3);memcpy(&eui[5], &enetaddr[3], 3);eui[3] = 0xFF;eui[4] = 0xFE;eui[0] ^= 2; /* "u" bit set to indicate global scope */
|= ?
+}
+void ip6_make_lladdr(struct in6_addr *lladr, unsigned char const enetaddr[6]) +{
uchar eui[8];memset(lladr, 0, sizeof(struct in6_addr));lladr->s6_addr16[0] = htons(IPV6_LINK_LOCAL_PREFIX);ip6_make_eui(eui, enetaddr);memcpy(&lladr->s6_addr[8], eui, 8);
What is 8? Is there a sizeof() or #define we could use?
+}
+/*
- Given an IPv6 address generate an equivalent Solicited Node Multicast
- Address (SNMA) as described in RFC2461.
- */
+void ip6_make_snma(struct in6_addr *mcast_addr, struct in6_addr *ip6_addr) +{
memset(mcast_addr, 0, sizeof(struct in6_addr));mcast_addr->s6_addr[0] = 0xff;mcast_addr->s6_addr[1] = IPV6_ADDRSCOPE_LINK;mcast_addr->s6_addr[11] = 0x01;mcast_addr->s6_addr[12] = 0xff;mcast_addr->s6_addr[13] = ip6_addr->s6_addr[13];mcast_addr->s6_addr[14] = ip6_addr->s6_addr[14];mcast_addr->s6_addr[15] = ip6_addr->s6_addr[15];+}
+/*
- Given an IPv6 address generate the multicast MAC address that corresponds to
- it.
- */
+void +ip6_make_mult_ethdstaddr(unsigned char enetaddr[6], struct in6_addr *mcast_addr) +{
enetaddr[0] = 0x33;enetaddr[1] = 0x33;memcpy(&enetaddr[2], &mcast_addr->s6_addr[12], 4);+}
+int +ip6_addr_in_subnet(struct in6_addr *our_addr, struct in6_addr *neigh_addr,
__u32 plen)+{
__be32 *addr_dwords;__be32 *neigh_dwords;addr_dwords = our_addr->s6_addr32;neigh_dwords = neigh_addr->s6_addr32;while (plen > 32) {if (*addr_dwords++ != *neigh_dwords++)return 0;plen -= 32;}/* Check any remaining bits. */if (plen > 0) {if ((*addr_dwords >> (32 - plen)) !=(*neigh_dwords >> (32 - plen))) {return 0;}}return 1;+}
+static inline unsigned int csum_fold(unsigned int sum) +{
sum = (sum & 0xffff) + (sum >> 16);sum = (sum & 0xffff) + (sum >> 16);return ~sum;+}
+static __u32 csum_do_csum(const __u8 *buff, int len)
Function comment. It looks like you are trying to optimise for speed here by doing things a word at a time.
+{
int odd, count;unsigned long result = 0;if (len <= 0)goto out;odd = 1 & (unsigned long)buff;if (odd) {result = *buff;len--;buff++;}count = len >> 1; /* nr of 16-bit words.. */if (count) {if (2 & (unsigned long)buff) {result += *(unsigned short *)buff;count--;len -= 2;buff += 2;}count >>= 1; /* nr of 32-bit words.. */if (count) {unsigned long carry = 0;do {unsigned long w = *(unsigned long *)buff;count--;buff += 4;result += carry;result += w;carry = (w > result);
Perhaps have a ulong *ptr instead using buff. Then you can use ptr++ instead of buff += 4.
} while (count);result += carry;result = (result & 0xffff) + (result >> 16);}if (len & 2) {result += *(unsigned short *)buff;buff += 2;}}if (len & 1)result += (*buff << 8);result = ~csum_fold(result);if (odd)result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);+out:
return result;+}
+unsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum) +{
unsigned int result = csum_do_csum(buff, len);/* add in old sum, and carry.. */result += sum;/* 16+c bits -> 16 bits */result = (result & 0xffff) + (result >> 16);return result;+}
+/*
- Compute checksum of IPv6 "psuedo-header" per RFC2460 section 8.1
- */
+unsigned short int +csum_ipv6_magic(struct in6_addr *saddr, struct in6_addr *daddr,
__u16 len, unsigned short proto, unsigned int csum)+{
int i;int carry;__u32 ulen;__u32 uproto;unsigned int finalsum;for (i = 0; i < 4; i++) {csum += saddr->s6_addr32[i];carry = (csum < saddr->s6_addr32[i]);csum += carry;csum += daddr->s6_addr32[i];carry = (csum < daddr->s6_addr32[i]);csum += carry;}ulen = htonl((__u32)len);csum += ulen;carry = (csum < ulen);csum += carry;uproto = htonl(proto);csum += uproto;carry = (csum < uproto);csum += carry;finalsum = csum_fold(csum);if ((finalsum & 0xffff) == 0x0000)return 0xffff;else if ((finalsum & 0xffff) == 0xffff)return 0x0000;elsereturn finalsum;+}
+int +ip6_add_hdr(uchar *xip, struct in6_addr *src, struct in6_addr *dest,
int nextheader, int hoplimit, int payload_len)+{
struct ip6_hdr *ip6 = (struct ip6_hdr *)xip;ip6->version = 6;ip6->priority = 0;ip6->flow_lbl[0] = 0;ip6->flow_lbl[1] = 0;ip6->flow_lbl[2] = 0;ip6->payload_len = htons(payload_len);ip6->nexthdr = nextheader;ip6->hop_limit = hoplimit;net_copy_ip6(&ip6->saddr, src);net_copy_ip6(&ip6->daddr, dest);return sizeof(struct ip6_hdr);+}
+void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len) +{
struct in_addr zero_ip = {.s_addr = 0 };struct icmp6hdr *icmp;struct udp_hdr *udp;__u16 csum;__u16 hlen;if (len < IP6_HDR_SIZE)return;
Return -EINVAL perhaps?
if (ip6->version != 6)return;switch (ip6->nexthdr) {case IPPROTO_ICMPV6:icmp = (struct icmp6hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);csum = icmp->icmp6_cksum;hlen = ntohs(ip6->payload_len);icmp->icmp6_cksum = 0;/* checksum */icmp->icmp6_cksum = csum_ipv6_magic(&ip6->saddr, &ip6->daddr,hlen, IPPROTO_ICMPV6,csum_partial((__u8 *)icmp, hlen, 0));if (icmp->icmp6_cksum != csum)return;switch (icmp->icmp6_type) {case IPV6_NDISC_NEIGHBOUR_SOLICITATION:case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:ndisc_receive(et, ip6, len);break;default:return;break;}break;default:return;break;}+}
2.11.0.24.ge6920cf
Regards, Simon