[U-Boot] [RFC PATCH 5/8] net: ipv6 support
Joe Hershberger
joe.hershberger at gmail.com
Mon Nov 2 21:43:43 CET 2015
Hi Chris,
On Mon, Oct 12, 2015 at 2:43 AM, Chris Packham <judge.packham at 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 at marvell.com> [endian & alignment fixes]
> Signed-off-by: Chris Packham <judge.packham at gmail.com>
> ---
> Now we have something functional. With this you can do something like
> 'setenv ipaddr6 3ffe::2' and 'ping6 3ffe::1' 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.
>
> The environment variable prefixlength6 is a bit fiddly. No-one uses a
> netmask6 (it'd mean a lot of ffff:ffff:...) it's almost always done by
> including the prefix length in the address (e.g. ip addr add
> 2001:db8::1/64) I'm contemplating adopting that syntax and dropping
> prefixlength6.
>
> This patch is bigger than I'd like it to be but I'm not sure how to
> split it up and keep the parts build able.
It is pretty huge. It's taken me a while to get through it.
> common/Kconfig | 15 ++
> common/cmd_net.c | 28 ++++
> include/env_callback.h | 9 ++
> include/env_flags.h | 10 ++
> include/net.h | 5 +-
> include/net6.h | 212 ++++++++++++++++++++++++++++
> net/Kconfig | 5 +
> net/Makefile | 3 +
> net/ndisc.c | 269 +++++++++++++++++++++++++++++++++++
> net/ndisc.h | 27 ++++
> net/net.c | 36 ++++-
> net/net6.c | 375 +++++++++++++++++++++++++++++++++++++++++++++++++
> net/ping6.c | 111 +++++++++++++++
> 13 files changed, 1102 insertions(+), 3 deletions(-)
> create mode 100644 net/ndisc.c
> create mode 100644 net/ndisc.h
> create mode 100644 net/net6.c
> create mode 100644 net/ping6.c
>
> diff --git a/common/Kconfig b/common/Kconfig
> index 2c42b8e..c72563d 100644
> --- a/common/Kconfig
> +++ b/common/Kconfig
> @@ -389,6 +389,15 @@ config CMD_NET
> bootp - boot image via network using BOOTP/TFTP protocol
> tftpboot - boot image via network using TFTP protocol
>
> +config CMD_NET6
> + bool "ipv6 commands"
> + select NET
> + select NET6
> + default n
> + help
> + IPv6 network commands
> + tftpboot6 - boot image via network using TFTP protocol
This is added in the next patch, so should probably move there.
> +
> config CMD_TFTPPUT
> bool "tftp put"
> help
> @@ -420,6 +429,12 @@ config CMD_PING
> help
> Send ICMP ECHO_REQUEST to network host
>
> +config CMD_PING6
> + bool "ping6"
> + depends on CMD_NET6
> + help
> + Send ICMPv6 ECHO_REQUEST to network host
What makes ping inseparable from the core support?
> +
> config CMD_CDP
> bool "cdp"
> help
> diff --git a/common/cmd_net.c b/common/cmd_net.c
> index b2f3c7b..271f91d 100644
> --- a/common/cmd_net.c
> +++ b/common/cmd_net.c
> @@ -11,6 +11,7 @@
> #include <common.h>
> #include <command.h>
> #include <net.h>
> +#include <net6.h>
>
> static int netboot_common(enum proto_t, cmd_tbl_t *, int, char * const []);
>
> @@ -284,6 +285,33 @@ U_BOOT_CMD(
> );
> #endif
>
> +#ifdef CONFIG_CMD_PING6
> +int do_ping6(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> +{
> + if (argc < 2)
> + return -1;
> +
> + if (string_to_ip6(argv[1], &net_ping_ip6) != 0)
> + return CMD_RET_USAGE;
> +
> + if (net_loop(PING6) < 0) {
> + printf("ping6 failed; host %pI6c is not alive\n",
> + &net_ping_ip6);
> + return 1;
> + }
> +
> + printf("host %pI6c is alive\n", &net_ping_ip6);
> +
> + return 0;
> +}
> +
> +U_BOOT_CMD(
> + ping6, 2, 1, do_ping6,
> + "send ICMPv6 ECHO_REQUEST to network host",
> + "pingAddress"
> +);
> +#endif /* CONFIG_CMD_PING6 */
> +
> #if defined(CONFIG_CMD_CDP)
>
> static void cdp_update_env(void)
> diff --git a/include/env_callback.h b/include/env_callback.h
> index 90b95b5..9027f3f 100644
> --- a/include/env_callback.h
> +++ b/include/env_callback.h
> @@ -60,6 +60,14 @@
> #define NET_CALLBACKS
> #endif
>
> +#ifdef CONFIG_NET6
> +#define NET6_CALLBACKS \
> + "ip6addr:ip6addr," \
> + "serverip6:serverip6," \
> + "prefixlength6:prefixlength6,"
I like the other nomenclature better as well (included in the address).
> +#else
> +#define NET6_CALLBACKS
> +#endif
> /*
> * This list of callback bindings is static, but may be overridden by defining
> * a new association in the ".callbacks" environment variable.
> @@ -68,6 +76,7 @@
> ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
> "baudrate:baudrate," \
> NET_CALLBACKS \
> + NET6_CALLBACKS \
> "loadaddr:loadaddr," \
> SILENT_CALLBACK \
> SPLASHIMAGE_CALLBACK \
> diff --git a/include/env_flags.h b/include/env_flags.h
> index 8823fb9..6e1891d 100644
> --- a/include/env_flags.h
> +++ b/include/env_flags.h
> @@ -65,6 +65,15 @@ enum env_flags_varaccess {
> #define NET_FLAGS
> #endif
>
> +#ifdef CONFIG_CMD_NET6
I think CONFIG_NET6 would be better here.
> +#define NET6_FLAGS \
> + "ip6addr:s," \
> + "serverip6:s," \
> + "prefixlength6:d,"
> +#else
> +#define NET6_FLAGS
> +#endif
> +
> #ifndef CONFIG_ENV_OVERWRITE
> #define SERIAL_FLAGS "serial#:so,"
> #else
> @@ -74,6 +83,7 @@ enum env_flags_varaccess {
> #define ENV_FLAGS_LIST_STATIC \
> ETHADDR_FLAGS \
> NET_FLAGS \
> + NET6_FLAGS \
> SERIAL_FLAGS \
> CONFIG_ENV_FLAGS_LIST_STATIC
>
> diff --git a/include/net.h b/include/net.h
> index 3a787cc..4f59609 100644
> --- a/include/net.h
> +++ b/include/net.h
> @@ -316,6 +316,7 @@ struct vlan_ethernet_hdr {
> #define VLAN_ETHER_HDR_SIZE (sizeof(struct vlan_ethernet_hdr))
>
> #define PROT_IP 0x0800 /* IP protocol */
> +#define PROT_IP6 0x86DD /* IPv6 protocol */
> #define PROT_ARP 0x0806 /* IP ARP protocol */
> #define PROT_RARP 0x8035 /* IP ARP protocol */
> #define PROT_VLAN 0x8100 /* IEEE 802.1q protocol */
> @@ -512,8 +513,8 @@ extern ushort net_native_vlan; /* Our Native VLAN */
> extern int net_restart_wrap; /* Tried all network devices */
>
> enum proto_t {
> - BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
> - TFTPSRV, TFTPPUT, LINKLOCAL
> + BOOTP, RARP, ARP, TFTPGET, DHCP, PING, PING6, DNS, NFS, CDP, NETCONS,
> + SNTP, TFTPSRV, TFTPPUT, TFTP6, LINKLOCAL
These should be added with the patch that adds the feature (TFTP6 for
sure, and probably PING6 when it is a separate patch).
> };
>
> extern char net_boot_file_name[128];/* Boot File name */
> diff --git a/include/net6.h b/include/net6.h
> index a41eb87..a0374df 100644
> --- a/include/net6.h
> +++ b/include/net6.h
> @@ -22,6 +22,16 @@ struct in6_addr {
> #define s6_addr32 in6_u.u6_addr32
> };
>
> +#define IN6ADDRSZ sizeof(struct in6_addr)
> +#define INETHADDRSZ sizeof(net_ethaddr)
> +
> +#define IPV6_ADDRSCOPE_INTF 0x01
> +#define IPV6_ADDRSCOPE_LINK 0x02
> +#define IPV6_ADDRSCOPE_AMDIN 0x04
> +#define IPV6_ADDRSCOPE_SITE 0x05
> +#define IPV6_ADDRSCOPE_ORG 0x08
> +#define IPV6_ADDRSCOPE_GLOBAL 0x0E
> +
> /**
> * struct ipv6hdr - Internet Protocol V6 (IPv6) header.
> *
> @@ -45,6 +55,154 @@ struct ip6_hdr {
> struct in6_addr daddr;
> };
>
> +#define IP6_HDR_SIZE (sizeof(struct ip6_hdr))
> +
> +/* Handy for static initialisations of struct in6_addr, atlhough the
> + * c99 '= { 0 }' idiom might work depending on you compiler. */
> +#define ZERO_IPV6_ADDR { { { 0x00, 0x00, 0x00, 0x00, \
> + 0x00, 0x00, 0x00, 0x00, \
> + 0x00, 0x00, 0x00, 0x00, \
> + 0x00, 0x00, 0x00, 0x00 } } }
> +
> +#define IPV6_LINK_LOCAL_PREFIX 0xfe80
> +
> +struct udp_hdr {
> + __be16 udp_src; /* UDP source port */
> + __be16 udp_dst; /* UDP destination port */
> + __be16 udp_len; /* Length of UDP packet */
> + __be16 udp_xsum; /* Checksum */
> +};
> +
> +#define IP6_UDPHDR_SIZE (sizeof(struct udp_hdr))
UDP is shared between IP and IP6, right? There seems to be no reason
to call it IP6_UDPHDR_SIZE. I would go with UDP_HDR_SIZE, but of
course that is already defined. Seem like a good candidate to combine
with the existing implementation.
Maybe that means that struct ip_udp_hdr goes away or maybe it's
cleaner to keep it as well. Have to dive in to know.
> +enum {
> + __ND_OPT_PREFIX_INFO_END = 0,
> + ND_OPT_SOURCE_LL_ADDR = 1,
> + ND_OPT_TARGET_LL_ADDR = 2,
> + ND_OPT_PREFIX_INFO = 3,
> + ND_OPT_REDIRECT_HDR = 4,
> + ND_OPT_MTU = 5,
> + __ND_OPT_MAX
> +};
> +
> +/* ICMPv6 */
> +#define IPPROTO_ICMPV6 58
> +/* hop limit for neighbour discovery packets */
> +#define IPV6_NDISC_HOPLIMIT 255
> +#define NDISC_TIMEOUT 5000UL
> +#define NDISC_TIMEOUT_COUNT 3
> +
> +struct icmp6hdr {
> + __u8 icmp6_type;
> +#define IPV6_ICMP_ECHO_REQUEST 128
> +#define IPV6_ICMP_ECHO_REPLY 129
> +#define IPV6_NDISC_ROUTER_SOLICITATION 133
> +#define IPV6_NDISC_ROUTER_ADVERTISEMENT 134
> +#define IPV6_NDISC_NEIGHBOUR_SOLICITATION 135
> +#define IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT 136
> +#define IPV6_NDISC_REDIRECT 137
> + __u8 icmp6_code;
> + __be16 icmp6_cksum;
> +
> + union {
> + __be32 un_data32[1];
> + __be16 un_data16[2];
> + __u8 un_data8[4];
> +
> + struct icmpv6_echo {
> + __be16 identifier;
> + __be16 sequence;
> + } u_echo;
> +
> + struct icmpv6_nd_advt {
> +#if defined(__LITTLE_ENDIAN_BITFIELD)
> + __be32 reserved:5,
> + override:1,
> + solicited:1,
> + router:1,
> + reserved2:24;
> +#elif defined(__BIG_ENDIAN_BITFIELD)
> + __be32 router:1,
> + solicited:1,
> + override:1,
> + reserved:29;
> +#else
> +#error "Please fix <asm/byteorder.h>"
> +#endif
> + } u_nd_advt;
> +
> + struct icmpv6_nd_ra {
> + __u8 hop_limit;
> +#if defined(__LITTLE_ENDIAN_BITFIELD)
> + __u8 reserved:6,
> + other:1,
> + managed:1;
> +
> +#elif defined(__BIG_ENDIAN_BITFIELD)
> + __u8 managed:1,
> + other:1,
> + reserved:6;
> +#else
> +#error "Please fix <asm/byteorder.h>"
> +#endif
> + __be16 rt_lifetime;
> + } u_nd_ra;
> + } icmp6_dataun;
> +#define icmp6_identifier icmp6_dataun.u_echo.identifier
> +#define icmp6_sequence icmp6_dataun.u_echo.sequence
> +#define icmp6_pointer icmp6_dataun.un_data32[0]
> +#define icmp6_mtu icmp6_dataun.un_data32[0]
> +#define icmp6_unused icmp6_dataun.un_data32[0]
> +#define icmp6_maxdelay icmp6_dataun.un_data16[0]
> +#define icmp6_router icmp6_dataun.u_nd_advt.router
> +#define icmp6_solicited icmp6_dataun.u_nd_advt.solicited
> +#define icmp6_override icmp6_dataun.u_nd_advt.override
> +#define icmp6_ndiscreserved icmp6_dataun.u_nd_advt.reserved
> +#define icmp6_hop_limit icmp6_dataun.u_nd_ra.hop_limit
> +#define icmp6_addrconf_managed icmp6_dataun.u_nd_ra.managed
> +#define icmp6_addrconf_other icmp6_dataun.u_nd_ra.other
> +#define icmp6_rt_lifetime icmp6_dataun.u_nd_ra.rt_lifetime
> +};
> +
> +struct nd_msg {
> + struct icmp6hdr icmph;
> + struct in6_addr target;
> + __u8 opt[0];
> +};
> +
> +struct rs_msg {
> + struct icmp6hdr icmph;
> + __u8 opt[0];
> +};
> +
> +struct ra_msg {
> + struct icmp6hdr icmph;
> + __u32 reachable_time;
> + __u32 retrans_timer;
> +};
> +
> +struct echo_msg {
> + struct icmp6hdr icmph;
> + __u16 id;
> + __u16 sequence;
> +};
> +
> +struct nd_opt_hdr {
> + __u8 nd_opt_type;
> + __u8 nd_opt_len;
> +} __attribute__((__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
> +
> /* ::ffff:0:0/96 is reserved for v4 mapped addresses */
> static inline int ipv6_addr_v4mapped(const struct in6_addr *a)
> {
> @@ -61,4 +219,58 @@ 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 */
> +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);
> +
> +/* send a neighbour discovery solicitation message */
> +void ip6_NDISC_Request(void);
> +
> +/* call back routine when ND timer has gone off */
> +void ip6_NDISC_TimeoutCheck(void);
> +
> +/* initialises the ND data */
> +void ip6_NDISC_init(void);
> +
> +/* 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, void *from)
> +{
> + memcpy((void *)to, from, sizeof(struct in6_addr));
> +}
> #endif /* __NET6_H__ */
> diff --git a/net/Kconfig b/net/Kconfig
> index 77a2f7e..ee198c1 100644
> --- a/net/Kconfig
> +++ b/net/Kconfig
> @@ -22,4 +22,9 @@ config NETCONSOLE
> Support the 'nc' input/output device for networked console.
> See README.NetConsole for details.
>
> +config NET6
> + bool "IPv6 support"
> + help
> + Support for IPv6
> +
> endif # if NET
> diff --git a/net/Makefile b/net/Makefile
> index e9cc8ad..a85a5c6 100644
> --- a/net/Makefile
> +++ b/net/Makefile
> @@ -20,3 +20,6 @@ obj-$(CONFIG_CMD_PING) += ping.o
> obj-$(CONFIG_CMD_RARP) += rarp.o
> obj-$(CONFIG_CMD_SNTP) += sntp.o
> obj-$(CONFIG_CMD_NET) += tftp.o
> +obj-$(CONFIG_CMD_NET6) += net6.o
> +obj-$(CONFIG_CMD_NET6) += ndisc.o
I'd like to see the stuff that is net core (not a command) start using
CONFIG_NET6 instead of CONFIG_CMD_NET6.
> +obj-$(CONFIG_CMD_PING6) += ping6.o
> diff --git a/net/ndisc.c b/net/ndisc.c
> new file mode 100644
> index 0000000..41883d7
> --- /dev/null
> +++ b/net/ndisc.c
> @@ -0,0 +1,269 @@
> +/*
> + * net/ndisc.c
> + *
> + * (C) Copyright 2013 Allied Telesis Labs NZ
> + *
> + * SPDX-License-Identifier: GPL-2.0+
> + */
> +#define DEBUG
> +#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 */
> +struct in6_addr net_nd_rep_packet_ip6 = ZERO_IPV6_ADDR;
static. The same goes for any others that are not needed outside of this file.
> +/* 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;
> +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 iption into a neighbor discovery packet.
iption -> option
> + * Returns the number of bytes inserted (which may be >= len)
> + */
> +static int
> +ip6_ndisc_insert_option(struct nd_msg *ndisc, int type, u8 *data, int len)
> +{
> + 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
> + * byte Ethernet MAC address.
> + */
> +static void ip6_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.
> + */
> +static int ip6_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);
> + ip6_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 - NS */
Probably mean to say "ICMPv6 - NA" here, right?
> + 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);
> + ip6_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));
> +}
> +
> +void ip6_NDISC_Request(void)
Please don't use CamelCase looking stuff. All lower case is usually appropriate.
> +{
> + 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;
Is this just assuming that since there is no gateway that the device
might be on the local segment even though the address is not on our
subnet?
> + } 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);
> +}
> +
> +void ip6_NDISC_TimeoutCheck(void)
Lowercase.
> +{
> + ulong t;
> +
> + if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))
> + return;
> +
> + 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");
> + net_nd_try = 0;
> + net_start_again();
> + } else {
> + net_nd_timer_start = t;
> + ip6_NDISC_Request();
> + }
> + }
> +}
> +
> +void ip6_NDISC_init(void)
Lowercase.
> +{
> + 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 = NULL;
> +
> + if (!net_nd_tx_packet) {
> + net_nd_tx_packet = &net_nd_packet_buf[0] + (PKTALIGN - 1);
> + net_nd_tx_packet -= (ulong)net_nd_tx_packet % PKTALIGN;
> + net_nd_tx_packet_size = 0;
> + }
> +}
> +
> +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) &&
> + ip6_ndisc_has_option(ip6, ND_OPT_SOURCE_LL_ADDR)) {
> + ip6_ndisc_extract_enetaddr(ndisc, neigh_eth_addr);
> + ip6_send_na(neigh_eth_addr, &ip6->saddr,
> + &ndisc->target);
> + }
> + break;
> +
> + 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) &&
> + ip6_ndisc_has_option(ip6, ND_OPT_TARGET_LL_ADDR)) {
> + ip6_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 0000000..7ade0fc
> --- /dev/null
> +++ b/net/ndisc.h
> @@ -0,0 +1,27 @@
> +/*
> + * 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;
> +/* IPv6 address we are expecting ND advert from */
> +extern struct in6_addr net_nd_rep_packet_ip6;
This is not used outside of ndisc.c so remove it from this header.
The same goes for any others in here that are not needed outside.
> +/* 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;
> +extern uchar net_nd_packet_buf[PKTSIZE_ALIGN + PKTALIGN];
> +/* 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_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len);
> +void ip6_NDISC_Request(void);
> +void ip6_NDISC_TimeoutCheck(void);
> diff --git a/net/net.c b/net/net.c
> index a115ce2..349a18e 100644
> --- a/net/net.c
> +++ b/net/net.c
> @@ -86,6 +86,7 @@
> #include <environment.h>
> #include <errno.h>
> #include <net.h>
> +#include <net6.h>
> #include <net/tftp.h>
> #if defined(CONFIG_STATUS_LED)
> #include <miiphy.h>
> @@ -94,6 +95,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)
> @@ -311,6 +313,7 @@ static int on_dnsip(const char *name, const char *value, enum env_op op,
> U_BOOT_ENV_CALLBACK(dnsip, on_dnsip);
> #endif
>
> +
No need to add white space here.
> /*
> * Check if autoload is enabled. If so, use either NFS or TFTP to download
> * the boot file.
> @@ -341,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_CMD_NET6
> + ip6_make_lladdr(&net_link_local_ip6, net_ethaddr);
> +#endif
> + }
>
> return;
> }
> @@ -376,6 +383,9 @@ void net_init(void)
> (i + 1) * PKTSIZE_ALIGN;
> }
> arp_init();
> +#ifdef CONFIG_CMD_NET6
> + ip6_NDISC_init();
> +#endif
> net_clear_handlers();
>
> /* Only need to setup buffer pointers once. */
> @@ -478,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();
> @@ -555,6 +570,9 @@ restart:
> if (ctrlc()) {
> /* cancel any ARP that may not have completed */
> net_arp_wait_packet_ip.s_addr = 0;
> +#ifdef CONFIG_CMD_NET6
> + net_nd_sol_packet_ip6 = net_null_addr_ip6;
> +#endif
>
> net_cleanup_loop();
> eth_halt();
> @@ -570,6 +588,9 @@ restart:
> }
>
> arp_timeout_check();
> +#ifdef CONFIG_CMD_NET6
> + ip6_NDISC_TimeoutCheck();
> +#endif
>
> /*
> * Check for a timeout, and run the timeout handler
> @@ -1141,6 +1162,11 @@ void net_process_received_packet(uchar *in_packet, int len)
> rarp_receive(ip, len);
> break;
> #endif
> +#ifdef CONFIG_CMD_NET6
> + case PROT_IP6:
> + net_ip6_handler(et, (struct ip6_hdr *)ip, len);
> + break;
> +#endif
> case PROT_IP:
> debug_cond(DEBUG_NET_PKT, "Got IP\n");
> /* Before we start poking the header, make sure it is there */
> @@ -1295,6 +1321,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
All the ping stuff seems like it could come out into a separate patch.
> #if defined(CONFIG_CMD_SNTP)
> case SNTP:
> if (net_ntp_server.s_addr == 0) {
> diff --git a/net/net6.c b/net/net6.c
> new file mode 100644
> index 0000000..2315704
> --- /dev/null
> +++ b/net/net6.c
> @@ -0,0 +1,375 @@
> +/*
> + * Simple IPv6 network layer implementation.
> + *
> + * Based and/or adapted from the IPv4 network layer in net.[hc]
> + *
> + * (C) Copyright 2013 Allied Telesis Labs NZ
> + *
> + * 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
> +#include <common.h>
> +#include <environment.h>
> +#include <net.h>
> +#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 */
> +u_int32_t net_prefix_length;
> +
> +static int on_ip6addr(const char *name, const char *value, enum env_op op,
> + int flags)
> +{
> + if (flags & H_PROGRAMMATIC)
> + return 0;
> +
> + return string_to_ip6(value, &net_ip6);
> +}
> +
> +U_BOOT_ENV_CALLBACK(ip6addr, on_ip6addr);
> +
> +static int on_gatewayip6(const char *name, const char *value, enum env_op op,
> + int flags)
> +{
> + if (flags & H_PROGRAMMATIC)
> + return 0;
> +
> + return string_to_ip6(value, &net_gateway6);
> +}
> +
> +U_BOOT_ENV_CALLBACK(gatewayip6, on_gatewayip6);
> +
> +static int on_prefixlength6(const char *name, const char *value, enum env_op op,
> + int flags)
> +{
> + if (flags & H_PROGRAMMATIC)
> + return 0;
> +
> + net_prefix_length = simple_strtoul(value, NULL, 10);
> +
> + return 0;
> +}
> +
> +U_BOOT_ENV_CALLBACK(prefixlength6, on_prefixlength6);
> +
> +static int on_serverip6(const char *name, const char *value, enum env_op op,
> + int flags)
> +{
> + if (flags & H_PROGRAMMATIC)
> + return 0;
> +
> + 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);
> +}
> +
> +/*
> + * 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)
Lowercase.
> +{
> + 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) {
> + /* parameters are in network byte order.
> + Does this work on a LE host? */
So is this still an outstanding question? Probably worth testing on a
LE target, but it should work I believe.
> + 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)
> +{
> + 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);
> + } 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;
> +}
> +
> +unsigned short int
> +csum_ipv6_magic(struct in6_addr *saddr, struct in6_addr *daddr,
> + __u16 len, unsigned short proto, unsigned int csum)
> +{
Please add some comments to this to make it less magic. :)
> + 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;
> + else
> + return 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;
> +
> + 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) {
> +#ifdef CONFIG_CMD_PING6
> + case IPV6_ICMP_ECHO_REQUEST:
> + case IPV6_ICMP_ECHO_REPLY:
> + ping6_receive(et, ip6, len);
> + break;
> +#endif /* CONFIG_CMD_PING6 */
> +
> + case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
> + case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
> + ndisc_receive(et, ip6, len);
> + break;
> +
> + default:
> + return;
> + break;
> + }
> + break;
> +
> + default:
> + return;
> + break;
> + }
> +}
> diff --git a/net/ping6.c b/net/ping6.c
> new file mode 100644
> index 0000000..aa93dfa
> --- /dev/null
> +++ b/net/ping6.c
> @@ -0,0 +1,111 @@
> +/*
> + * net/ping6.c
> + *
> + * (C) Copyright 2013 Allied Telesis Labs NZ
> + *
> + * SPDX-License-Identifier: GPL-2.0+
> + */
> +#define DEBUG
> +#include <common.h>
> +#include <net.h>
> +#include <net6.h>
> +#include "ndisc.h"
> +
> +static ushort seq_no;
> +
> +/* the ipv6 address to ping */
> +struct in6_addr net_ping_ip6;
> +
> +int
> +ip6_make_ping(uchar *eth_dst_addr, struct in6_addr *neigh_addr, uchar *pkt)
> +{
> + struct echo_msg *msg;
> + __u16 len;
> + uchar *pkt_old = pkt;
> +
> + len = sizeof(struct echo_msg);
> +
> + pkt += net_set_ether(pkt, eth_dst_addr, PROT_IP6);
> + pkt += ip6_add_hdr(pkt, &net_ip6, neigh_addr, IPPROTO_ICMPV6,
> + IPV6_NDISC_HOPLIMIT, len);
> +
> + /* ICMPv6 - Echo */
> + msg = (struct echo_msg *)pkt;
> + msg->icmph.icmp6_type = IPV6_ICMP_ECHO_REQUEST;
> + msg->icmph.icmp6_code = 0;
> + msg->icmph.icmp6_cksum = 0;
> + msg->icmph.icmp6_identifier = 0;
> + msg->icmph.icmp6_sequence = htons(seq_no++);
> + msg->id = msg->icmph.icmp6_identifier; /* these seem redundant */
> + msg->sequence = msg->icmph.icmp6_sequence;
> +
> + /* checksum */
> + msg->icmph.icmp6_cksum = csum_ipv6_magic(&net_ip6, neigh_addr, len,
> + IPPROTO_ICMPV6,
> + csum_partial((__u8 *)msg, len, 0));
> +
> + pkt += len;
> +
> + return pkt - pkt_old;
> +}
> +
> +int ping6_send(void)
> +{
> + uchar *pkt;
> + static uchar mac[6];
> +
> + /* always send neighbor solicit */
> +
> + memcpy(mac, net_null_ethaddr, 6);
> +
> + net_nd_sol_packet_ip6 = net_ping_ip6;
> + net_nd_packet_mac = mac;
> +
> + pkt = net_nd_tx_packet;
> + pkt += ip6_make_ping(mac, &net_ping_ip6, pkt);
> +
> + /* size of the waiting packet */
> + net_nd_tx_packet_size = (pkt - net_nd_tx_packet);
> +
> + /* and do the ARP request */
> + net_nd_try = 1;
> + net_nd_timer_start = get_timer(0);
> + ip6_NDISC_Request();
> + return 1; /* waiting */
> +}
> +
> +static void ping6_timeout(void)
> +{
> + eth_halt();
> + net_set_state(NETLOOP_FAIL); /* we did not get the reply */
> +}
> +
> +void ping6_start(void)
> +{
> + printf("Using %s device\n", eth_get_name());
> + net_set_timeout_handler(10000UL, ping6_timeout);
> +
> + ping6_send();
> +}
> +
> +void ping6_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
> +{
> + struct icmp6hdr *icmp =
> + (struct icmp6hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);
> + struct in6_addr src_ip;
> +
> + switch (icmp->icmp6_type) {
> + case IPV6_ICMP_ECHO_REPLY:
> + src_ip = ip6->saddr;
> + if (memcmp(&net_ping_ip6, &src_ip, sizeof(struct in6_addr)) != 0)
> + return;
> + net_set_state(NETLOOP_SUCCESS);
> + break;
> + case IPV6_ICMP_ECHO_REQUEST:
> + debug("Got ICMPv6 ECHO REQUEST from %pI6c\n", &ip6->saddr);
> + /* ignore for now.... */
> + break;
> + default:
> + debug("Unexpected ICMPv6 type 0x%x\n", icmp->icmp6_type);
> + }
> +}
> --
> 2.5.3
>
>
> _______________________________________________
> U-Boot mailing list
> U-Boot at lists.denx.de
> http://lists.denx.de/mailman/listinfo/u-boot
>
More information about the U-Boot
mailing list