[PATCH v2 00/17] IPv6 support

[PATCH v2 00/17] IPv6 support

[Viacheslav Mitrofanov]

This patch set adds basic IPv6 support to U-boot.
It is based on Chris's Packham patches
(https://lists.denx.de/pipermail/u-boot/2017-January/279366.html)
Chris's patches were taken as base. There were efforts to launch it on HiFive
SiFive Unmatched board but the board didn't work well. The code was refactored,
fixed some bugs as CRC for little-endian, some parts were implemented in our own
way, something was taken from Linux. Finally we did manual tests and the board
worked well.

Testing was done on HiFive SiFive Unmatched board (RISC-V)

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>

---
Changes in v2:
 - Split big patches into smaller
 - If an address in tftpboot is IPv6 than use IPv6 to boot
 - Add tests

Viacheslav Mitrofanov (17):
  net: ipv6: Add IPv6 basic primitives
  net: ipv6: Add IPv6 build options
  net: ipv6: Add callbacks declarations to get access to IPv6 variables
  net: ipv6: Add Neighbor Discovery Protocol (NDP)
  net: ipv6: Add string_to_ip6 converter
  net: ipv6: Enable IPv6 typeconversion specifier
  net: ipv6: Add ip6addr, gatewayip6, serverip6 variables callbacks
  net: ipv6: Add implementation of main IPv6 functions
  net: ipv6: Incorporate IPv6 support into u-boot net subsystem
  net: tftp: Add IPv6 support for tftpboot
  net: ping6: Add ping6 command
  test: dm: eth: Add string_to_ip6 test
  test: dm: eth: Add csum_ipv6_magic test
  test: dm: eth: Add ip6_addr_in_subnet test
  test: dm: eth: Add ip6_make_snma test
  test: dm: eth: Add ip6_make_lladdr test
  test/py: add a ping6 test

 cmd/Kconfig               |   7 +
 cmd/net.c                 |  48 ++++
 include/env_callback.h    |  10 +
 include/env_flags.h       |  10 +
 include/ndisc.h           |  65 +++++
 include/net.h             |   4 +-
 include/net6.h            | 312 ++++++++++++++++++++++++
 lib/net_utils.c           | 122 ++++++++++
 lib/vsprintf.c            |  11 +-
 net/Kconfig               |   4 +
 net/Makefile              |   3 +
 net/ndisc.c               | 276 ++++++++++++++++++++++
 net/net.c                 |  70 +++++-
 net/net6.c                | 484 ++++++++++++++++++++++++++++++++++++++
 net/ping6.c               | 117 +++++++++
 net/tftp.c                |  62 ++++-
 test/dm/eth.c             | 140 +++++++++++
 test/py/tests/test_net.py |  15 ++
 18 files changed, 1741 insertions(+), 19 deletions(-)
 create mode 100644 include/ndisc.h
 create mode 100644 include/net6.h
 create mode 100644 net/ndisc.c
 create mode 100644 net/net6.c
 create mode 100644 net/ping6.c

-- 
2.25.1

[PATCH 01/17] net: ipv6: Add IPv6 basic primitives

[Viacheslav Mitrofanov]

This patch is a collection of basic primitives that are prerequisite for
further IPv6 implementation.

There are structures definition such as IPv6 header, UDP header
(for TFTP), ICMPv6 header. There are auxiliary defines such as protocol
codes, padding, struct size and etc. Also here are functions prototypes
and its empty implementation that will be used as API for further patches.
Here are variables declaration such as IPv6 address of our host,
gateway, ipv6 server.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/net6.h | 256 +++++++++++++++++++++++++++++++++++++++++++++++++
 net/net6.c     |  33 +++++++
 2 files changed, 289 insertions(+)
 create mode 100644 include/net6.h
 create mode 100644 net/net6.c

diff --git a/include/net6.h b/include/net6.h
new file mode 100644
index 0000000000..71072d1416
--- /dev/null
+++ b/include/net6.h
@@ -0,0 +1,256 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (C) 2013 Allied Telesis Labs NZ
+ * Chris Packham, <judge.packham@gmail.com>
+ *
+ * Copyright (C) 2022 YADRO
+ * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
+ */
+
+#ifndef __NET6_H__
+#define __NET6_H__
+
+#include <net.h>
+#include <linux/ctype.h>
+
+struct in6_addr {
+	union {
+		u8	u6_addr8[16];
+		__be16	u6_addr16[8];
+		__be32	u6_addr32[4];
+	} in6_u;
+
+#define s6_addr		in6_u.u6_addr8
+#define s6_addr16	in6_u.u6_addr16
+#define s6_addr32	in6_u.u6_addr32
+};
+
+#define PROT_IP6       0x86DD          /* IPv6 protocol */
+
+#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
+
+#define USE_IP6_CMD_PARAM	"-ipv6"
+
+/**
+ * struct ipv6hdr - Internet Protocol V6 (IPv6) header.
+ *
+ * IPv6 packet header as defined in RFC 2460.
+ */
+struct ip6_hdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+	u8	priority:4,
+		version:4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+	u8	version:4,
+		priority:4;
+#else
+#error  "Please fix <asm/byteorder.h>"
+#endif
+	u8		flow_lbl[3];
+	__be16		payload_len;
+	u8		nexthdr;
+	u8		hop_limit;
+	struct in6_addr	saddr;
+	struct in6_addr	daddr;
+};
+
+struct udp_hdr {
+	u16		udp_src;	/* UDP source port		*/
+	u16		udp_dst;	/* UDP destination port		*/
+	u16		udp_len;	/* Length of UDP packet		*/
+	u16		udp_xsum;	/* Checksum			*/
+} __packed;
+#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
+
+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
+};
+
+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 u32 net_prefix_length;	/* Our prefixlength (0 = unknown) */
+extern struct in6_addr net_server_ip6;	/* Server IPv6 addr (0 = unknown) */
+extern bool use_ip6;
+
+static inline int string_to_ip6(const char *s, struct in6_addr *addr)
+{
+	return -1;
+}
+
+static inline int ip6_is_unspecified_addr(struct in6_addr *addr)
+{
+	return -1;
+}
+
+static inline int ip6_is_our_addr(struct in6_addr *addr)
+{
+	return -1;
+}
+
+static inline int
+ip6_addr_in_subnet(struct in6_addr *our_addr, struct in6_addr *neigh_addr,
+		   u32 prefix_length)
+{
+	return -1;
+}
+
+static inline void
+ip6_make_lladdr(struct in6_addr *lladr, unsigned char const enetaddr[6])
+{
+}
+
+static inline void
+ip6_make_snma(struct in6_addr *mcast_addr, struct in6_addr *ip6_addr)
+{
+}
+
+static inline void
+ip6_make_mult_ethdstaddr(unsigned char enetaddr[6],
+			 struct in6_addr *mcast_addr)
+{
+}
+
+static inline unsigned int
+csum_partial(const unsigned char *buff, int len, unsigned int sum)
+{
+	return 0;
+}
+
+static inline unsigned short
+csum_ipv6_magic(struct in6_addr *saddr,
+		struct in6_addr *daddr, u16 len,
+		unsigned short proto, unsigned int csum)
+{
+	return 0;
+}
+
+static inline unsigned int
+ip6_add_hdr(uchar *xip, struct in6_addr *src, struct in6_addr *dest,
+	    int nextheader, int hoplimit, int payload_len)
+{
+	return 0;
+}
+
+static inline int
+net_send_udp_packet6(uchar *ether, struct in6_addr *dest,
+		     int dport, int sport, int len)
+{
+	return -1;
+}
+
+static inline void
+net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
+		int len)
+{
+}
+
+static inline void net_copy_ip6(void *to, const void *from)
+{
+}
+
+#endif /* __NET6_H__ */
diff --git a/net/net6.c b/net/net6.c
new file mode 100644
index 0000000000..c2569e0e68
--- /dev/null
+++ b/net/net6.c
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2013 Allied Telesis Labs NZ
+ * Chris Packham, <judge.packham@gmail.com>
+ *
+ * Copyright (C) 2022 YADRO
+ * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
+ */
+
+/*
+ * Simple IPv6 network layer implementation.
+ */
+
+#include <common.h>
+#include <env_internal.h>
+#include <malloc.h>
+#include <net.h>
+#include <net6.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 */
+u32 net_prefix_length;
+
+bool use_ip6;
-- 
2.25.1

[PATCH 02/17] net: ipv6: Add IPv6 build options

[Viacheslav Mitrofanov]

Add options to Makefile and Kconfig file to build IPv6

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 net/Kconfig  | 4 ++++
 net/Makefile | 1 +
 2 files changed, 5 insertions(+)

diff --git a/net/Kconfig b/net/Kconfig
index 52e261884d..568e622de8 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -174,6 +174,10 @@ config BOOTP_MAX_ROOT_PATH_LEN
 	help
 	  Select maximal length of option 17 root path.
 
+config IPV6
+	bool "IPv6 support"
+	default n
+
 endif   # if NET
 
 config SYS_RX_ETH_BUFFER
diff --git a/net/Makefile b/net/Makefile
index 6c812502d3..4ea2a14f27 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -21,6 +21,7 @@ obj-$(CONFIG_DM_MDIO_MUX) += mdio-mux-uclass.o
 obj-$(CONFIG_NET)      += eth_common.o
 obj-$(CONFIG_CMD_LINK_LOCAL) += link_local.o
 obj-$(CONFIG_NET)      += net.o
+obj-$(CONFIG_IPV6)     += net6.o
 obj-$(CONFIG_CMD_NFS)  += nfs.o
 obj-$(CONFIG_CMD_PING) += ping.o
 obj-$(CONFIG_CMD_PCAP) += pcap.o
-- 
2.25.1

[PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Viacheslav Mitrofanov]

Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
and set options to them in flag file. These variables are often set up by
users.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/env_callback.h | 10 ++++++++++
 include/env_flags.h    | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/include/env_callback.h b/include/env_callback.h
index d5d2b2fcad..14c6ce0d24 100644
--- a/include/env_callback.h
+++ b/include/env_callback.h
@@ -57,6 +57,15 @@
 #define NET_CALLBACKS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_CALLBACKS \
+	"ip6addr:ip6addr," \
+	"serverip6:serverip6," \
+	"gatewayip6:gatewayip6,"
+#else
+#define NET6_CALLBACKS
+#endif
+
 #ifdef CONFIG_BOOTSTD
 #define BOOTSTD_CALLBACK	"bootmeths:bootmeths,"
 #else
@@ -71,6 +80,7 @@
 	ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
 	"baudrate:baudrate," \
 	NET_CALLBACKS \
+	NET6_CALLBACKS \
 	BOOTSTD_CALLBACK \
 	"loadaddr:loadaddr," \
 	SILENT_CALLBACK \
diff --git a/include/env_flags.h b/include/env_flags.h
index 313cb8c49a..718d72773c 100644
--- a/include/env_flags.h
+++ b/include/env_flags.h
@@ -67,6 +67,15 @@ enum env_flags_varaccess {
 #define NET_FLAGS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_FLAGS \
+	"ip6addr:s," \
+	"serverip6:s," \
+	"gatewayip6:s"
+#else
+#define NET6_FLAGS
+#endif
+
 #ifndef CONFIG_ENV_OVERWRITE
 #define SERIAL_FLAGS "serial#:so,"
 #else
@@ -76,6 +85,7 @@ enum env_flags_varaccess {
 #define ENV_FLAGS_LIST_STATIC \
 	ETHADDR_FLAGS \
 	NET_FLAGS \
+	NET6_FLAGS \
 	SERIAL_FLAGS \
 	CONFIG_ENV_FLAGS_LIST_STATIC
 
-- 
2.25.1

[PATCH 04/17] net: ipv6: Add Neighbor Discovery Protocol (NDP)

[Viacheslav Mitrofanov]

Implement basic of NDP. It doesn't include such things as Router
Solicitation, Router Advertisement and Redirect. It just has Neighbor
Solicitation and Neighbor Advertisement. Only these two features are used
in u-boot IPv6. Implementation of some NDP functions uses API that was
exposed in "net: ipv6: Add IPv6 basic primitives".

Also this patch inlcudes update in Makefile to build NDP.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/ndisc.h |  65 ++++++++++++
 net/Makefile    |   1 +
 net/ndisc.c     | 276 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 342 insertions(+)
 create mode 100644 include/ndisc.h
 create mode 100644 net/ndisc.c

diff --git a/include/ndisc.h b/include/ndisc.h
new file mode 100644
index 0000000000..7debdd79d6
--- /dev/null
+++ b/include/ndisc.h
@@ -0,0 +1,65 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Copyright (C) 2013 Allied Telesis Labs NZ
+ * Chris Packham, <judge.packham@gmail.com>
+ *
+ * Copyright (C) 2022 YADRO
+ * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
+ */
+
+#ifndef __NDISC_H__
+#define __NDISC_H__
+
+#include <ndisc.h>
+
+struct nd_msg {
+	struct icmp6hdr	icmph;
+	struct in6_addr	target;
+	__u8		opt[0];
+};
+
+struct echo_msg {
+	struct icmp6hdr	icmph;
+	__u16		id;
+	__u16		sequence;
+};
+
+/* 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;
+
+#ifdef CONFIG_IPV6
+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);
+#else
+static inline void ndisc_init(void)
+{
+}
+
+static inline void
+ndisc_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
+{
+}
+
+static inline void ndisc_request(void)
+{
+}
+
+static inline int ndisc_timeout_check(void)
+{
+	return 0;
+}
+#endif
+
+#endif /* __NDISC_H__ */
diff --git a/net/Makefile b/net/Makefile
index 4ea2a14f27..766dd04135 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_DM_MDIO)  += mdio-uclass.o
 obj-$(CONFIG_DM_MDIO_MUX) += mdio-mux-uclass.o
 obj-$(CONFIG_NET)      += eth_common.o
 obj-$(CONFIG_CMD_LINK_LOCAL) += link_local.o
+obj-$(CONFIG_IPV6)     += ndisc.o
 obj-$(CONFIG_NET)      += net.o
 obj-$(CONFIG_IPV6)     += net6.o
 obj-$(CONFIG_CMD_NFS)  += nfs.o
diff --git a/net/ndisc.c b/net/ndisc.c
new file mode 100644
index 0000000000..1bd06211f1
--- /dev/null
+++ b/net/ndisc.c
@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2013 Allied Telesis Labs NZ
+ * Chris Packham, <judge.packham@gmail.com>
+ *
+ * Copyright (C) 2022 YADRO
+ * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
+ */
+
+/*
+ * Neighbour Discovery for IPv6
+ */
+
+#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)
+{
+	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 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 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;
+	unsigned short csum;
+	unsigned int pcsum;
+
+	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 */
+	pcsum = csum_partial((__u8 *)msg, len, 0);
+	csum = csum_ipv6_magic(&net_link_local_ip6, &dst_adr,
+			       len, IPPROTO_ICMPV6, pcsum);
+	msg->icmph.icmp6_cksum = csum;
+	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;
+	unsigned short csum;
+
+	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));
+	msg->icmph.icmp6_dataun.u_nd_advt.solicited = 1;
+	msg->icmph.icmp6_dataun.u_nd_advt.override = 1;
+	/* 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 */
+	csum = csum_ipv6_magic(&net_link_local_ip6,
+			       neigh_addr, len, IPPROTO_ICMPV6,
+			       csum_partial((__u8 *)msg, len, 0));
+	msg->icmph.icmp6_cksum = csum;
+	pkt += len;
+
+	/* send it! */
+	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
+}
+
+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");
+			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;
+}
+
+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;
+
+	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)
+				memcpy(net_nd_packet_mac, neigh_eth_addr, 7);
+
+			/* 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);
+	}
+}
-- 
2.25.1

[PATCH 05/17] net: ipv6: Add string_to_ip6 converter

[Viacheslav Mitrofanov]

This functions is used as a converter from IPv6 address string notation
to struct ip6_addr that is used everywhere in IPv6 implementation. For
example it is used to parse and convert IPv6 address from tftpboot
command. Conversion algorithm uses two passes, first to verify syntax and
locate colons and second pass to read the address. In case of valid IPv6
address it returns 0.

Examples of valid strings:
	2001:db8::0:1234:1
	2001:0db8:0000:0000:0000:0000:1234:0001
	::1
	::ffff:192.168.1.1

Examples of invalid strings
	2001:db8::0::0          (:: can only appear once)
	2001:db8:192.168.1.1::1 (v4 part can only appear at the end)
	192.168.1.1             (we don't implicity map v4)

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/net6.h  |   5 ++
 lib/net_utils.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 127 insertions(+)

diff --git a/include/net6.h b/include/net6.h
index 71072d1416..68fa38adbb 100644
--- a/include/net6.h
+++ b/include/net6.h
@@ -177,10 +177,15 @@ extern u32 net_prefix_length;	/* Our prefixlength (0 = unknown) */
 extern struct in6_addr net_server_ip6;	/* Server IPv6 addr (0 = unknown) */
 extern bool use_ip6;
 
+#if IS_ENABLED(CONFIG_IPV6)
+/* Convert a string to an ipv6 address */
+int string_to_ip6(const char *s, struct in6_addr *addr);
+#else
 static inline int string_to_ip6(const char *s, struct in6_addr *addr)
 {
 	return -1;
 }
+#endif
 
 static inline int ip6_is_unspecified_addr(struct in6_addr *addr)
 {
diff --git a/lib/net_utils.c b/lib/net_utils.c
index 72a3b098a7..09554c520b 100644
--- a/lib/net_utils.c
+++ b/lib/net_utils.c
@@ -11,6 +11,7 @@
 
 #include <common.h>
 #include <net.h>
+#include <net6.h>
 
 struct in_addr string_to_ip(const char *s)
 {
@@ -43,6 +44,127 @@ struct in_addr string_to_ip(const char *s)
 	return addr;
 }
 
+/**
+ * Parses an struct in6_addr from the given string. IPv6 address parsing is a
+ * bit more complicated than v4 due to the flexible format and some of the
+ * special cases (e.g. v4 mapped).
+ *
+ * Examples of valid strings:
+ *   2001:db8::0:1234:1
+ *   2001:0db8:0000:0000:0000:0000:1234:0001
+ *   ::1
+ *   ::ffff:192.168.1.1
+ *
+ * Examples of invalid strings
+ *   2001:db8::0::0          (:: can only appear once)
+ *   2001:db8:192.168.1.1::1 (v4 part can only appear at the end)
+ *   192.168.1.1             (we don't implicity map v4)
+ */
+#if IS_ENABLED(CONFIG_IPV6)
+int string_to_ip6(const char *strpt, struct in6_addr *addrpt)
+{
+	int colon_count = 0;
+	int found_double_colon = 0;
+	int xstart = 0;		/* first zero (double colon) */
+	int len = 7;		/* num words the double colon represents */
+	int i;
+	const char *s = strpt;
+	struct in_addr zero_ip = {.s_addr = 0};
+
+	if (!strpt)
+		return -1;
+
+	/* First pass, verify the syntax and locate the double colon */
+	for (;;) {
+		while (isxdigit((int)*s))
+			s++;
+		if (*s == '\0')
+			break;
+		if (*s != ':') {
+			if (*s == '.' && len >= 2) {
+				struct in_addr v4;
+
+				while (s != strpt && *(s - 1) != ':')
+					--s;
+				v4 = string_to_ip(s);
+				if (memcmp(&zero_ip, &v4,
+					   sizeof(struct in_addr) != 0)) {
+					len -= 2;
+					break;
+				}
+			}
+			/* This could be a valid address */
+			break;
+		}
+		if (s == strpt) {
+			/* The address begins with a colon */
+			if (*++s != ':')
+				/* Must start with a double colon or a number */
+				goto out_err;
+		} else {
+			s++;
+			if (found_double_colon)
+				len--;
+			else
+				xstart++;
+		}
+
+		if (*s == ':') {
+			if (found_double_colon)
+				/* Two double colons are not allowed */
+				goto out_err;
+			found_double_colon = 1;
+			len -= xstart;
+			s++;
+		}
+
+		if (++colon_count == 7)
+			/* Found all colons */
+			break;
+	}
+
+	if (colon_count == 0)
+		goto out_err;
+	if (*--s == ':')
+		len++;
+
+	/* Second pass, read the address */
+	s = strpt;
+	for (i = 0; i < 8; i++) {
+		int val = 0;
+		char *end;
+
+		if (found_double_colon && i >= xstart && i < xstart + len) {
+			addrpt->s6_addr16[i] = 0;
+			continue;
+		}
+		while (*s == ':')
+			s++;
+
+		if (i == 6 && isdigit((int)*s)) {
+			struct in_addr v4 = string_to_ip(s);
+
+			if (memcmp(&zero_ip, &v4,
+				   sizeof(struct in_addr)) != 0) {
+				/* Ending with :IPv4-address */
+				addrpt->s6_addr32[3] = v4.s_addr;
+				break;
+			}
+		}
+
+		val = simple_strtoul(s, &end, 16);
+		if (*end != '\0' && *end != ':')
+			goto out_err;
+		addrpt->s6_addr16[i] = htons(val);
+		s = end;
+	}
+	return 0;
+
+out_err:
+	return -1;
+}
+#endif
+
 void string_to_enetaddr(const char *addr, uint8_t *enetaddr)
 {
 	char *end;
-- 
2.25.1

[PATCH 06/17] net: ipv6: Enable IPv6 typeconversion specifier

[Viacheslav Mitrofanov]

Add the possibility to recognize IPv6 address in print function.
To output IPv6 address use %pI6 specifier.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 lib/vsprintf.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index fe06aa2d71..d5856b1cbe 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -346,6 +346,7 @@ static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
 		      flags & ~SPECIAL);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
 			 int precision, int flags)
 {
@@ -365,6 +366,7 @@ static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
 	return string(buf, end, ip6_addr, field_width, precision,
 		      flags & ~SPECIAL);
 }
+#endif
 
 static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
 			 int precision, int flags)
@@ -450,10 +452,6 @@ static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
  *       decimal for v4 and colon separated network-order 16 bit hex for v6)
  * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
  *       currently the same
- *
- * Note: IPv6 support is currently if(0)'ed out. If you ever need
- * %pI6, please add an IPV6 Kconfig knob, make your code select or
- * depend on that, and change the 0 below to CONFIG_IS_ENABLED(IPV6).
  */
 static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
 		int field_width, int precision, int flags)
@@ -498,10 +496,11 @@ static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
 		flags |= SPECIAL;
 		/* Fallthrough */
 	case 'I':
-		/* %pI6 currently unused */
-		if (0 && fmt[1] == '6')
+#if IS_ENABLED(CONFIG_IPV6)
+		if (fmt[1] == '6')
 			return ip6_addr_string(buf, end, ptr, field_width,
 					       precision, flags);
+#endif
 		if (fmt[1] == '4')
 			return ip4_addr_string(buf, end, ptr, field_width,
 					       precision, flags);
-- 
2.25.1

[PATCH 07/17] net: ipv6: Add ip6addr, gatewayip6, serverip6 variables callbacks

[Viacheslav Mitrofanov]

Implement actions on ip6addr, gatewayip6, serverip6 varaibles.
on_ip6addr - convert IPv6 string addr to struct ip6_addr
on_gatewayip6 - convert IPv6 string addr to struct ip6_addr
on_serverip6 - convert IPv6 string addr to struct ip6_addr

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 net/net6.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/net/net6.c b/net/net6.c
index c2569e0e68..a0410ea8ba 100644
--- a/net/net6.c
+++ b/net/net6.c
@@ -31,3 +31,70 @@ struct in6_addr net_server_ip6 = ZERO_IPV6_ADDR;
 u32 net_prefix_length;
 
 bool use_ip6;
+
+static int on_ip6addr(const char *name, const char *value, enum env_op op,
+		      int flags)
+{
+	char *v, *s, *strcopy;
+	int i;
+
+	if (flags & H_PROGRAMMATIC)
+		return 0;
+
+	if (op == env_op_delete) {
+		net_prefix_length = 0;
+		net_copy_ip6(&net_ip6, &net_null_addr_ip6);
+		return 0;
+	}
+
+	strcopy = strdup(value);
+	if (!strcopy)
+		return -1;
+
+	net_prefix_length = 128;
+	i = 0;
+	s = strcopy;
+	while (s) {
+		v = strsep(&s, "/");
+		if (!v)
+			break;
+
+		switch (i++) {
+		case 0:
+			string_to_ip6(v, &net_ip6);
+			break;
+		case 1:
+			net_prefix_length = simple_strtoul(v, NULL, 10);
+			break;
+		default:
+			break;
+		}
+	}
+	free(strcopy);
+
+	return 0;
+}
+
+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_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);
-- 
2.25.1

[PATCH 08/17] net: ipv6: Add implementation of main IPv6 functions

[Viacheslav Mitrofanov]

Functions that were exposed in "net: ipv6: Add IPv6 basic primitives"
had only empty implementations and were exposed as API for futher
patches. This patch add implementation of these functions. Main
functions are: net_ip6_handler() - IPv6 packet handler for incoming
packets; net_send_udp_packet6() - make up and send an UDP packet;
csum_ipv6_magic() - compute checksum of IPv6 "psuedo-header" per RFC2460
section 8.1; ip6_addr_in_subnet() - check if an address is in our
subnet. Other functions are auxiliary.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/net6.h |  36 ++++-
 net/net6.c     | 380 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 415 insertions(+), 1 deletion(-)

diff --git a/include/net6.h b/include/net6.h
index 68fa38adbb..a7be2496d9 100644
--- a/include/net6.h
+++ b/include/net6.h
@@ -180,12 +180,45 @@ extern bool use_ip6;
 #if IS_ENABLED(CONFIG_IPV6)
 /* 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);
+/* 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);
+
+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);
+
+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);
+
+/* Transmit UDP packet using IPv6, performing neighbour discovery if needed */
+int net_send_udp_packet6(uchar *ether, struct in6_addr *dest,
+			 int dport, int sport, int len);
+
+/* handler for incoming IPv6 echo packet */
+void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
+		     int len);
+
+static inline void net_copy_ip6(void *to, const void *from)
+{
+	memcpy((void *)to, from, sizeof(struct in6_addr));
+}
 #else
 static inline int string_to_ip6(const char *s, struct in6_addr *addr)
 {
 	return -1;
 }
-#endif
 
 static inline int ip6_is_unspecified_addr(struct in6_addr *addr)
 {
@@ -257,5 +290,6 @@ net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
 static inline void net_copy_ip6(void *to, const void *from)
 {
 }
+#endif
 
 #endif /* __NET6_H__ */
diff --git a/net/net6.c b/net/net6.c
index a0410ea8ba..0799d411b2 100644
--- a/net/net6.c
+++ b/net/net6.c
@@ -16,6 +16,7 @@
 #include <malloc.h>
 #include <net.h>
 #include <net6.h>
+#include <ndisc.h>
 
 /* NULL IPv6 address */
 struct in6_addr const net_null_addr_ip6 = ZERO_IPV6_ADDR;
@@ -98,3 +99,382 @@ static int on_serverip6(const char *name, const char *value, enum env_op op,
 }
 
 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)) ||
+	       !memcmp(addr, &net_ip6, sizeof(struct in6_addr));
+}
+
+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)
+{
+	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);
+
+	/* Opaque moment. If reverse it to zero it will
+	 * not be checked on receiver's side. It leads to
+	 * bad negibour advertisement for some reason.
+	 */
+	if (sum == 0xffff)
+		return sum;
+
+	return ~sum;
+}
+
+static inline unsigned short from32to16(unsigned int x)
+{
+	/* add up 16-bit and 16-bit for 16+c bit */
+	x = (x & 0xffff) + (x >> 16);
+	/* add up carry.. */
+	x = (x & 0xffff) + (x >> 16);
+	return x;
+}
+
+static u32 csum_do_csum(const u8 *buff, int len)
+{
+	int odd;
+	unsigned int result = 0;
+
+	if (len <= 0)
+		goto out;
+	odd = 1 & (unsigned long)buff;
+	if (odd) {
+#ifdef __LITTLE_ENDIAN
+		result += (*buff << 8);
+#else
+		result = *buff;
+#endif
+		len--;
+		buff++;
+	}
+	if (len >= 2) {
+		if (2 & (unsigned long)buff) {
+			result += *(unsigned short *)buff;
+			len -= 2;
+			buff += 2;
+		}
+		if (len >= 4) {
+			const unsigned char *end = buff + ((u32)len & ~3);
+			unsigned int carry = 0;
+
+			do {
+				unsigned int w = *(unsigned int *)buff;
+
+				buff += 4;
+				result += carry;
+				result += w;
+				carry = (w > result);
+			} while (buff < end);
+			result += carry;
+			result = (result & 0xffff) + (result >> 16);
+		}
+		if (len & 2) {
+			result += *(unsigned short *)buff;
+			buff += 2;
+		}
+	}
+	if (len & 1)
+#ifdef __LITTLE_ENDIAN
+		result += *buff;
+#else
+		result += (*buff << 8);
+#endif
+	result = from32to16(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 carry;
+	u32 ulen;
+	u32 uproto;
+	u32 sum = csum;
+
+	sum += saddr->s6_addr32[0];
+	carry = (sum < saddr->s6_addr32[0]);
+	sum += carry;
+
+	sum += saddr->s6_addr32[1];
+	carry = (sum < saddr->s6_addr32[1]);
+	sum += carry;
+
+	sum += saddr->s6_addr32[2];
+	carry = (sum < saddr->s6_addr32[2]);
+	sum += carry;
+
+	sum += saddr->s6_addr32[3];
+	carry = (sum < saddr->s6_addr32[3]);
+	sum += carry;
+
+	sum += daddr->s6_addr32[0];
+	carry = (sum < daddr->s6_addr32[0]);
+	sum += carry;
+
+	sum += daddr->s6_addr32[1];
+	carry = (sum < daddr->s6_addr32[1]);
+	sum += carry;
+
+	sum += daddr->s6_addr32[2];
+	carry = (sum < daddr->s6_addr32[2]);
+	sum += carry;
+
+	sum += daddr->s6_addr32[3];
+	carry = (sum < daddr->s6_addr32[3]);
+	sum += carry;
+
+	ulen = htonl((u32)len);
+	sum += ulen;
+	carry = (sum < ulen);
+	sum += carry;
+
+	uproto = htonl(proto);
+	sum += uproto;
+	carry = (sum < uproto);
+	sum += carry;
+
+	return csum_fold(sum);
+}
+
+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);
+}
+
+int
+net_send_udp_packet6(uchar *ether, struct in6_addr *dest, int dport, int sport, int len)
+{
+	uchar *pkt;
+	struct udp_hdr *udp;
+
+	udp = (struct udp_hdr *)((uchar *)net_tx_packet + net_eth_hdr_size() +
+			IP6_HDR_SIZE);
+
+	udp->udp_dst = htons(dport);
+	udp->udp_src = htons(sport);
+	udp->udp_len = htons(len + UDP_HDR_SIZE);
+
+	/* checksum */
+	udp->udp_xsum = 0;
+	udp->udp_xsum = csum_ipv6_magic(&net_ip6, dest, len + UDP_HDR_SIZE,
+					IPPROTO_UDP,
+					csum_partial((u8 *)udp,
+						     len + UDP_HDR_SIZE,
+						     0));
+
+	/* if MAC address was not discovered yet, save the packet and do
+	 * neighbour discovery
+	 */
+	if (memcmp(ether, net_null_ethaddr, 6) == 0) {
+		net_copy_ip6(&net_nd_sol_packet_ip6, dest);
+		net_nd_packet_mac = ether;
+
+		pkt = net_nd_tx_packet;
+		pkt += net_set_ether(pkt, net_nd_packet_mac, PROT_IP6);
+		pkt += ip6_add_hdr(pkt, &net_ip6, dest, IPPROTO_UDP, 64,
+				len + UDP_HDR_SIZE);
+		memcpy(pkt, (uchar *)udp, len + UDP_HDR_SIZE);
+
+		/* size of the waiting packet */
+		net_nd_tx_packet_size = (pkt - net_nd_tx_packet) +
+			UDP_HDR_SIZE + len;
+
+		/* and do the neighbor solicitation */
+		net_nd_try = 1;
+		net_nd_timer_start = get_timer(0);
+		ndisc_request();
+		return 1;	/* waiting */
+	}
+
+	pkt = (uchar *)net_tx_packet;
+	pkt += net_set_ether(pkt, ether, PROT_IP6);
+	pkt += ip6_add_hdr(pkt, &net_ip6, dest, IPPROTO_UDP, 64,
+			len + UDP_HDR_SIZE);
+	(void)eth_send(net_tx_packet, pkt - net_tx_packet + UDP_HDR_SIZE + len);
+
+	return 0;	/* transmitted */
+}
+
+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) {
+		case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
+		case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
+			ndisc_receive(et, ip6, len);
+			break;
+		default:
+			break;
+		}
+		break;
+	case IPPROTO_UDP:
+		udp = (struct udp_hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);
+		csum = udp->udp_xsum;
+		hlen = ntohs(ip6->payload_len);
+		udp->udp_xsum = 0;
+		/* checksum */
+		udp->udp_xsum = csum_ipv6_magic(&ip6->saddr, &ip6->daddr,
+						hlen, IPPROTO_UDP,
+						csum_partial((u8 *)udp,
+							     hlen, 0));
+
+		if (csum != udp->udp_xsum)
+			return;
+
+		/* IP header OK.  Pass the packet to the current handler. */
+		net_get_udp_handler()((uchar *)ip6 + IP6_HDR_SIZE +
+					UDP_HDR_SIZE,
+				ntohs(udp->udp_dst),
+				zero_ip,
+				ntohs(udp->udp_src),
+				ntohs(udp->udp_len) - 8);
+		break;
+	default:
+		break;
+	}
+}
-- 
2.25.1

[PATCH 09/17] net: ipv6: Incorporate IPv6 support into u-boot net subsystem

[Viacheslav Mitrofanov]

Add net_ip6_handler (an IPv6 packet handler) into net_loop. Add
neighbor discovery mechanism into network init process. That is the
main step to run IPv6 in u-boot. Now u-boot is capable to use NDP and
handle IPv6 packets.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 net/net.c | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/net/net.c b/net/net.c
index 81905f6315..f818170930 100644
--- a/net/net.c
+++ b/net/net.c
@@ -91,6 +91,8 @@
 #include <image.h>
 #include <log.h>
 #include <net.h>
+#include <net6.h>
+#include <ndisc.h>
 #include <net/fastboot.h>
 #include <net/tftp.h>
 #if defined(CONFIG_CMD_PCAP)
@@ -340,8 +342,17 @@ void net_auto_load(void)
 
 static int net_init_loop(void)
 {
-	if (eth_get_dev())
+	if (eth_get_dev()) {
 		memcpy(net_ethaddr, eth_get_ethaddr(), 6);
+
+		if (IS_ENABLED(CONFIG_IPV6)) {
+			ip6_make_lladdr(&net_link_local_ip6, net_ethaddr);
+			if (!memcmp(&net_ip6, &net_null_addr_ip6,
+				    sizeof(struct in6_addr)))
+				memcpy(&net_ip6, &net_link_local_ip6,
+				       sizeof(struct in6_addr));
+		}
+	}
 	else
 		/*
 		 * Not ideal, but there's no way to get the actual error, and I
@@ -382,6 +393,7 @@ int net_init(void)
 				(i + 1) * PKTSIZE_ALIGN;
 		}
 		arp_init();
+		ndisc_init();
 		net_clear_handlers();
 
 		/* Only need to setup buffer pointers once. */
@@ -563,6 +575,10 @@ restart:
 		if (arp_timeout_check() > 0)
 			time_start = get_timer(0);
 
+		if (IS_ENABLED(CONFIG_IPV6)) {
+			if (use_ip6 && (ndisc_timeout_check() > 0))
+				time_start = get_timer(0);
+		}
 		/*
 		 *	Check the ethernet for a new packet.  The ethernet
 		 *	receive routine will process it.
@@ -1187,6 +1203,11 @@ void net_process_received_packet(uchar *in_packet, int len)
 	case PROT_RARP:
 		rarp_receive(ip, len);
 		break;
+#endif
+#if IS_ENABLED(CONFIG_IPV6)
+	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");
-- 
2.25.1

[PATCH 10/17] net: tftp: Add IPv6 support for tftpboot

[Viacheslav Mitrofanov]

The command tftpboot uses IPv4 by default. Add the possibility to use IPv6
instead. If an address in the command is an IPv6 address it will use IPv6
to boot or if there is a suffix -ipv6 in the end of the command it also
force using IPv6. All other tftpboot features and parameters are left
the same.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 cmd/net.c  | 22 +++++++++++++++++++
 net/net.c  | 34 ++++++++++++++++++++++++++++--
 net/tftp.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 108 insertions(+), 10 deletions(-)

diff --git a/cmd/net.c b/cmd/net.c
index 3619c843d8..0225f9ce3e 100644
--- a/cmd/net.c
+++ b/cmd/net.c
@@ -14,6 +14,7 @@
 #include <env.h>
 #include <image.h>
 #include <net.h>
+#include <net6.h>
 #include <net/udp.h>
 #include <net/sntp.h>
 
@@ -44,12 +45,22 @@ int do_tftpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 	return ret;
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
+U_BOOT_CMD(
+	tftpboot,	4,	1,	do_tftpb,
+	"boot image via network using TFTP protocol\n"
+	"To use IPv6 add -ipv6 parameter or use IPv6 hostIPaddr framed "
+	"with [] brackets",
+	"[loadAddress] [[hostIPaddr:]bootfilename] [" USE_IP6_CMD_PARAM "]"
+);
+#else
 U_BOOT_CMD(
 	tftpboot,	3,	1,	do_tftpb,
 	"boot image via network using TFTP protocol",
 	"[loadAddress] [[hostIPaddr:]bootfilename]"
 );
 #endif
+#endif
 
 #ifdef CONFIG_CMD_TFTPPUT
 static int do_tftpput(struct cmd_tbl *cmdtp, int flag, int argc,
@@ -205,6 +216,17 @@ static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc,
 	if (s != NULL)
 		image_load_addr = hextoul(s, NULL);
 
+	if (IS_ENABLED(CONFIG_IPV6)) {
+		use_ip6 = false;
+
+		/* IPv6 parameter has to be always *last* */
+		if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) {
+			use_ip6 = true;
+			/* It is a hack not to break switch/case code */
+			--argc;
+		}
+	}
+
 	switch (argc) {
 	case 1:
 		/* refresh bootfile name from env */
diff --git a/net/net.c b/net/net.c
index f818170930..77f42d1d59 100644
--- a/net/net.c
+++ b/net/net.c
@@ -449,6 +449,23 @@ restart:
 	debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n");
 	net_init_loop();
 
+	/* Find out what protocol to use */
+	if (IS_ENABLED(CONFIG_IPV6) && !use_ip6) {
+		char *s, *e;
+		char str_ip6[16];
+
+		s = strchr(net_boot_file_name, '[');
+		e = strchr(net_boot_file_name, ']');
+		if (s && e) {
+			size_t len = e - s;
+
+			memcpy(str_ip6, s + 1, len);
+			str_ip6[len - 1] = '\0';
+			if (!string_to_ip6(str_ip6, &net_server_ip6))
+				use_ip6 = true;
+		}
+	}
+
 	switch (net_check_prereq(protocol)) {
 	case 1:
 		/* network not configured */
@@ -1381,7 +1398,14 @@ static int net_check_prereq(enum proto_t protocol)
 		/* Fall through */
 	case TFTPGET:
 	case TFTPPUT:
-		if (net_server_ip.s_addr == 0 && !is_serverip_in_cmd()) {
+		if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
+			if (!memcmp(&net_server_ip6, &net_null_addr_ip6,
+				    sizeof(struct in6_addr)) &&
+				    !strchr(net_boot_file_name, '[')) {
+				puts("*** ERROR: `serverip6' not set\n");
+				return 1;
+			}
+		} else if (net_server_ip.s_addr == 0 && !is_serverip_in_cmd()) {
 			puts("*** ERROR: `serverip' not set\n");
 			return 1;
 		}
@@ -1394,7 +1418,13 @@ common:
 	case NETCONS:
 	case FASTBOOT:
 	case TFTPSRV:
-		if (net_ip.s_addr == 0) {
+		if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
+			if (!memcmp(&net_link_local_ip6, &net_null_addr_ip6,
+				    sizeof(struct in6_addr))) {
+				puts("*** ERROR: `ip6addr` not set\n");
+				return 1;
+			}
+		} else if (net_ip.s_addr == 0) {
 			puts("*** ERROR: `ipaddr' not set\n");
 			return 1;
 		}
diff --git a/net/tftp.c b/net/tftp.c
index dea9c25ffd..52ff1a846d 100644
--- a/net/tftp.c
+++ b/net/tftp.c
@@ -15,6 +15,7 @@
 #include <log.h>
 #include <mapmem.h>
 #include <net.h>
+#include <net6.h>
 #include <asm/global_data.h>
 #include <net/tftp.h>
 #include "bootp.h"
@@ -41,6 +42,7 @@ DECLARE_GLOBAL_DATA_PTR;
 static ulong timeout_ms = TIMEOUT;
 static int timeout_count_max = (CONFIG_NET_RETRY_COUNT * 2);
 static ulong time_start;   /* Record time we started tftp */
+static struct in6_addr tftp_remote_ip6;
 
 /*
  * These globals govern the timeout behavior when attempting a connection to a
@@ -116,6 +118,7 @@ static int	tftp_put_final_block_sent;
 
 /* default TFTP block size */
 #define TFTP_BLOCK_SIZE		512
+#define TFTP_MTU_BLOCKSIZE6 (CONFIG_TFTP_BLOCKSIZE - 20)
 /* sequence number is 16 bit */
 #define TFTP_SEQUENCE_SIZE	((ulong)(1<<16))
 
@@ -320,7 +323,11 @@ static void tftp_send(void)
 	 *	We will always be sending some sort of packet, so
 	 *	cobble together the packet headers now.
 	 */
-	pkt = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
+	if (IS_ENABLED(CONFIG_IPV6) && use_ip6)
+		pkt = net_tx_packet + net_eth_hdr_size() +
+		      IP6_HDR_SIZE + UDP_HDR_SIZE;
+	else
+		pkt = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
 
 	switch (tftp_state) {
 	case STATE_SEND_RRQ:
@@ -422,8 +429,14 @@ static void tftp_send(void)
 		break;
 	}
 
-	net_send_udp_packet(net_server_ethaddr, tftp_remote_ip,
-			    tftp_remote_port, tftp_our_port, len);
+	if (IS_ENABLED(CONFIG_IPV6) && use_ip6)
+		net_send_udp_packet6(net_server_ethaddr,
+				     &tftp_remote_ip6,
+				     tftp_remote_port,
+				     tftp_our_port, len);
+	else
+		net_send_udp_packet(net_server_ethaddr, tftp_remote_ip,
+				    tftp_remote_port, tftp_our_port, len);
 
 	if (err_pkt)
 		net_set_state(NETLOOP_FAIL);
@@ -750,6 +763,9 @@ void tftp_start(enum proto_t protocol)
 	debug("TFTP blocksize = %i, TFTP windowsize = %d timeout = %ld ms\n",
 	      tftp_block_size_option, tftp_window_size_option, timeout_ms);
 
+	if (IS_ENABLED(CONFIG_IPV6))
+		tftp_remote_ip6 = net_server_ip6;
+
 	tftp_remote_ip = net_server_ip;
 	if (!net_parse_bootfile(&tftp_remote_ip, tftp_filename, MAX_LEN)) {
 		sprintf(default_filename, "%02X%02X%02X%02X.img",
@@ -764,18 +780,48 @@ void tftp_start(enum proto_t protocol)
 		printf("*** Warning: no boot file name; using '%s'\n",
 		       tftp_filename);
 	}
+	if (IS_ENABLED(CONFIG_IPV6)) {
+		if (use_ip6) {
+			char *s, *e;
+
+			s = strchr(net_boot_file_name, '[');
+			e = strchr(net_boot_file_name, ']');
+			if (s && e) {
+				*e++ = 0;
+				string_to_ip6(s + 1, &tftp_remote_ip6);
+				strlcpy(tftp_filename, e + 1, MAX_LEN);
+			} else {
+				strlcpy(tftp_filename, net_boot_file_name, MAX_LEN);
+				tftp_filename[MAX_LEN - 1] = 0;
+			}
+		}
+	}
 
 	printf("Using %s device\n", eth_get_name());
-	printf("TFTP %s server %pI4; our IP address is %pI4",
+
+	if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
+		printf("TFTP from server %pI6c; our IP address is %pI6c",
+		       &tftp_remote_ip6, &net_ip6);
+
+		if (tftp_block_size_option > TFTP_MTU_BLOCKSIZE6)
+			tftp_block_size_option = TFTP_MTU_BLOCKSIZE6;
+	} else {
+		printf("TFTP %s server %pI4; our IP address is %pI4",
 #ifdef CONFIG_CMD_TFTPPUT
-	       protocol == TFTPPUT ? "to" : "from",
+		       protocol == TFTPPUT ? "to" : "from",
 #else
-	       "from",
+		       "from",
 #endif
-	       &tftp_remote_ip, &net_ip);
+		       &tftp_remote_ip, &net_ip);
+	}
 
 	/* Check if we need to send across this subnet */
-	if (net_gateway.s_addr && net_netmask.s_addr) {
+	if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
+		if (!ip6_addr_in_subnet(&net_ip6, &tftp_remote_ip6,
+					net_prefix_length))
+			printf("; sending through gateway %pI6c",
+			       &net_gateway6);
+	} else if (net_gateway.s_addr && net_netmask.s_addr) {
 		struct in_addr our_net;
 		struct in_addr remote_net;
 
-- 
2.25.1

[PATCH 11/17] net: ping6: Add ping6 command

[Viacheslav Mitrofanov]

Implement ping6 command to ping hosts using IPv6. It works the same way as
an ordinary ping command. There is no ICMP request so it is not possible
to ping our host. This patch adds options in Kconfig and Makefile to
build ping6 command.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 cmd/Kconfig    |   7 +++
 cmd/net.c      |  26 +++++++++++
 include/net.h  |   4 +-
 include/net6.h |  17 +++++++
 net/Makefile   |   1 +
 net/net.c      |  13 ++++++
 net/net6.c     |   4 ++
 net/ping6.c    | 117 +++++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 187 insertions(+), 2 deletions(-)
 create mode 100644 net/ping6.c

diff --git a/cmd/Kconfig b/cmd/Kconfig
index 8ea064b8d2..4c95c6fd9b 100644
--- a/cmd/Kconfig
+++ b/cmd/Kconfig
@@ -1801,6 +1801,13 @@ config CMD_PING
 	help
 	  Send ICMP ECHO_REQUEST to network host
 
+config CMD_PING6
+	bool "ping6"
+	depends on IPV6
+	default y if (CMD_PING && IPV6)
+	help
+	  Send ICMPv6 ECHO_REQUEST to network host
+
 config CMD_CDP
 	bool "cdp"
 	help
diff --git a/cmd/net.c b/cmd/net.c
index 0225f9ce3e..cd24813bcd 100644
--- a/cmd/net.c
+++ b/cmd/net.c
@@ -334,6 +334,32 @@ U_BOOT_CMD(
 );
 #endif
 
+#if IS_ENABLED(CONFIG_CMD_PING6)
+int do_ping6(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
+{
+	if (string_to_ip6(argv[1], &net_ping_ip6) != 0)
+		return CMD_RET_USAGE;
+
+	use_ip6 = true;
+	if (net_loop(PING6) < 0) {
+		use_ip6 = false;
+		printf("ping6 failed; host %pI6c is not alive\n",
+		       &net_ping_ip6);
+		return 1;
+	}
+
+	use_ip6 = false;
+	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/net.h b/include/net.h
index c06b577808..72d32d358a 100644
--- a/include/net.h
+++ b/include/net.h
@@ -559,8 +559,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, FASTBOOT, WOL, UDP
+	BOOTP, RARP, ARP, TFTPGET, DHCP, PING, PING6, DNS, NFS, CDP, NETCONS,
+	SNTP, TFTPSRV, TFTPPUT, LINKLOCAL, FASTBOOT, WOL, UDP
 };
 
 extern char	net_boot_file_name[1024];/* Boot File name */
diff --git a/include/net6.h b/include/net6.h
index a7be2496d9..08d31b8197 100644
--- a/include/net6.h
+++ b/include/net6.h
@@ -175,6 +175,7 @@ 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 u32 net_prefix_length;	/* Our prefixlength (0 = unknown) */
 extern struct in6_addr net_server_ip6;	/* Server IPv6 addr (0 = unknown) */
+extern struct in6_addr net_ping_ip6; /* the ipv6 address to ping */
 extern bool use_ip6;
 
 #if IS_ENABLED(CONFIG_IPV6)
@@ -292,4 +293,20 @@ static inline void net_copy_ip6(void *to, const void *from)
 }
 #endif
 
+#if IS_ENABLED(CONFIG_CMD_PING6)
+/* 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);
+#else
+static inline void ping6_start(void)
+{
+}
+
+static inline
+void ping6_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
+{
+}
+#endif /* CONFIG_CMD_PING6 */
+
 #endif /* __NET6_H__ */
diff --git a/net/Makefile b/net/Makefile
index 766dd04135..e32e913d68 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_NET)      += net.o
 obj-$(CONFIG_IPV6)     += net6.o
 obj-$(CONFIG_CMD_NFS)  += nfs.o
 obj-$(CONFIG_CMD_PING) += ping.o
+obj-$(CONFIG_CMD_PING6) += ping6.o
 obj-$(CONFIG_CMD_PCAP) += pcap.o
 obj-$(CONFIG_CMD_RARP) += rarp.o
 obj-$(CONFIG_CMD_SNTP) += sntp.o
diff --git a/net/net.c b/net/net.c
index 77f42d1d59..babc4e2c17 100644
--- a/net/net.c
+++ b/net/net.c
@@ -526,6 +526,11 @@ restart:
 			ping_start();
 			break;
 #endif
+#if defined(CONFIG_CMD_PING6)
+		case PING6:
+			ping6_start();
+			break;
+#endif
 #if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD)
 		case NFS:
 			nfs_start();
@@ -1377,6 +1382,14 @@ static int net_check_prereq(enum proto_t protocol)
 		}
 		goto common;
 #endif
+#if defined(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_DNS)
 	case DNS:
 		if (net_dns_server.s_addr == 0) {
diff --git a/net/net6.c b/net/net6.c
index 0799d411b2..a3b89ded24 100644
--- a/net/net6.c
+++ b/net/net6.c
@@ -444,6 +444,10 @@ void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
 			return;
 
 		switch (icmp->icmp6_type) {
+		case IPV6_ICMP_ECHO_REQUEST:
+		case IPV6_ICMP_ECHO_REPLY:
+			ping6_receive(et, ip6, len);
+			break;
 		case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
 		case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
 			ndisc_receive(et, ip6, len);
diff --git a/net/ping6.c b/net/ping6.c
new file mode 100644
index 0000000000..3284e314ae
--- /dev/null
+++ b/net/ping6.c
@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2013 Allied Telesis Labs NZ
+ * Chris Packham, <judge.packham@gmail.com>
+ *
+ * Copyright (C) 2022 YADRO
+ * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
+ */
+
+/*
+ * Simple ping6 implementation
+ */
+
+#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);
+	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)))
+			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.25.1

[PATCH 12/17] test: dm: eth: Add string_to_ip6 test

[Viacheslav Mitrofanov]

Add a test to check convertation from char* to struct in6_addr.
Use in sandbox

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/dm/eth.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/test/dm/eth.c b/test/dm/eth.c
index 5437f9ea4a..4cc90cf514 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -13,6 +13,7 @@
 #include <log.h>
 #include <malloc.h>
 #include <net.h>
+#include <net6.h>
 #include <asm/eth.h>
 #include <dm/test.h>
 #include <dm/device-internal.h>
@@ -22,6 +23,53 @@
 
 #define DM_TEST_ETH_NUM		4
 
+static int dm_test_string_to_ip6(struct unit_test_state *uts)
+{
+	struct test_ip6_pair
+	{
+		char 		*string_addr;
+		struct in6_addr ip6_addr;
+	};
+
+	struct in6_addr ip6 = {0};
+
+	/* Correct statements */
+	struct test_ip6_pair test_suite[] = {
+		{"2001:db8::0:1234:1", {.s6_addr32[0] = 0xb80d0120,
+					.s6_addr32[1] = 0x00000000,
+					.s6_addr32[2] = 0x00000000,
+					.s6_addr32[3] = 0x01003412}},
+		{"2001:0db8:0000:0000:0000:0000:1234:0001",
+				       {.s6_addr32[0] = 0xb80d0120,
+					.s6_addr32[1] = 0x00000000,
+					.s6_addr32[2] = 0x00000000,
+					.s6_addr32[3] = 0x01003412}},
+		{"::1", 	       {.s6_addr32[0] = 0x00000000,
+					.s6_addr32[1] = 0x00000000,
+					.s6_addr32[2] = 0x00000000,
+					.s6_addr32[3] = 0x01000000}},
+		{"::ffff:192.168.1.1", {.s6_addr32[0] = 0x00000000,
+					.s6_addr32[1] = 0x00000000,
+					.s6_addr32[2] = 0xffff0000,
+					.s6_addr32[3] = 0x0101a8c0}},
+	};
+
+	for (int i = 0; i < ARRAY_SIZE(test_suite); ++i) {
+		ut_assertok(string_to_ip6(test_suite[i].string_addr, &ip6));
+		ut_asserteq_mem(&ip6, &test_suite[i].ip6_addr,
+				sizeof(struct in6_addr));
+	}
+
+	/* Incorrect statements */
+	ut_assertok(!string_to_ip6("hello:world", &ip6));
+	ut_assertok(!string_to_ip6("2001:db8::0::0", &ip6));
+	ut_assertok(!string_to_ip6("2001:db8:192.168.1.1::1", &ip6));
+	ut_assertok(!string_to_ip6("192.168.1.1", &ip6));
+
+	return 0;
+}
+DM_TEST(dm_test_string_to_ip6, 0);
+
 static int dm_test_eth(struct unit_test_state *uts)
 {
 	net_ping_ip = string_to_ip("1.1.2.2");
-- 
2.25.1

[PATCH 13/17] test: dm: eth: Add csum_ipv6_magic test

[Viacheslav Mitrofanov]

Test checksum computation. csum_ipv6_magic() uses in upper layer
protocols as TCP/UDP/ICMPv6/etc to calculate payload checksum.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/dm/eth.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/test/dm/eth.c b/test/dm/eth.c
index 4cc90cf514..bbfa14ef6d 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -70,6 +70,35 @@ static int dm_test_string_to_ip6(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_string_to_ip6, 0);
 
+static int dm_test_csum_ipv6_magic(struct unit_test_state *uts)
+{
+	unsigned short csum = 0xBEEF;
+	/* Predefined correct parameters */
+	unsigned short correct_csum = 0xD8AC;
+	struct in6_addr saddr = {.s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffe9f242,
+				 .s6_addr32[3] = 0xe8f66dfe};
+	struct in6_addr daddr = {.s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffd5b372,
+				 .s6_addr32[3] = 0x3ef692fe};
+	u16 len = 1460;
+	unsigned short proto = 17;
+	unsigned int head_csum = 0x91f0;
+
+	csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
+	ut_assert(csum == correct_csum);
+
+	/* Broke a parameter */
+	proto--;
+	csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
+	ut_assert(csum != correct_csum);
+
+	return 0;
+}
+DM_TEST(dm_test_csum_ipv6_magic, 0);
+
 static int dm_test_eth(struct unit_test_state *uts)
 {
 	net_ping_ip = string_to_ip("1.1.2.2");
-- 
2.25.1

[PATCH 14/17] test: dm: eth: Add ip6_addr_in_subnet test

[Viacheslav Mitrofanov]

Add a test if two address are in the same subnet. Use in sandbox

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/dm/eth.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/test/dm/eth.c b/test/dm/eth.c
index bbfa14ef6d..d4a39e53d9 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -99,6 +99,31 @@ static int dm_test_csum_ipv6_magic(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_csum_ipv6_magic, 0);
 
+static int dm_test_ip6_addr_in_subnet(struct unit_test_state *uts)
+{
+	struct in6_addr our = {.s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffe9f242,
+				 .s6_addr32[3] = 0xe8f66dfe};
+	struct in6_addr neigh1 = {.s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffd5b372,
+				 .s6_addr32[3] = 0x3ef692fe};
+	struct in6_addr neigh2 = {.s6_addr32[0] = 0x60480120,
+				 .s6_addr32[1] = 0x00006048,
+				 .s6_addr32[2] = 0x00000000,
+				 .s6_addr32[3] = 0x00008888};
+
+	/* in */
+	ut_assert(ip6_addr_in_subnet(&our, &neigh1, 64));
+	/* outside */
+	ut_assert(!ip6_addr_in_subnet(&our, &neigh2, 64));
+	ut_assert(!ip6_addr_in_subnet(&our, &neigh1, 128));
+
+	return 0;
+}
+DM_TEST(dm_test_ip6_addr_in_subnet, 0);
+
 static int dm_test_eth(struct unit_test_state *uts)
 {
 	net_ping_ip = string_to_ip("1.1.2.2");
-- 
2.25.1

[PATCH 15/17] test: dm: eth: Add ip6_make_snma test

[Viacheslav Mitrofanov]

Add a test that checks generated Solicited Node Multicast Address from our
ipv6 address. Use in sandbox

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/dm/eth.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/dm/eth.c b/test/dm/eth.c
index d4a39e53d9..c892c68523 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -124,6 +124,26 @@ static int dm_test_ip6_addr_in_subnet(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_ip6_addr_in_subnet, 0);
 
+static int dm_test_ip6_make_snma(struct unit_test_state *uts)
+{
+	struct in6_addr mult = {0};
+	struct in6_addr correct_addr = {
+				 .s6_addr32[0] = 0x000002ff,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0x01000000,
+				 .s6_addr32[3] = 0xe8f66dff};
+	struct in6_addr addr = { .s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffe9f242,
+				 .s6_addr32[3] = 0xe8f66dfe};
+
+	ip6_make_snma(&mult, &addr);
+	ut_asserteq_mem(&mult, &correct_addr, sizeof(struct in6_addr));
+
+	return 0;
+}
+DM_TEST(dm_test_ip6_make_snma, 0);
+
 static int dm_test_eth(struct unit_test_state *uts)
 {
 	net_ping_ip = string_to_ip("1.1.2.2");
-- 
2.25.1

[PATCH 16/17] test: dm: eth: Add ip6_make_lladdr test

[Viacheslav Mitrofanov]

Add a test that checks generated Link Local Address. Use in sandbox

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/dm/eth.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/dm/eth.c b/test/dm/eth.c
index c892c68523..f84714b735 100644
--- a/test/dm/eth.c
+++ b/test/dm/eth.c
@@ -144,6 +144,24 @@ static int dm_test_ip6_make_snma(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_ip6_make_snma, 0);
 
+static int dm_test_ip6_make_lladdr(struct unit_test_state *uts)
+{
+	struct in6_addr generated_lladdr = {0};
+	struct in6_addr correct_lladdr = {
+				 .s6_addr32[0] = 0x000080fe,
+				 .s6_addr32[1] = 0x00000000,
+				 .s6_addr32[2] = 0xffabf33a,
+				 .s6_addr32[3] = 0xfbb352fe};
+	const unsigned char mac[6] = {0x38, 0xf3, 0xab, 0x52, 0xb3, 0xfb};
+
+	ip6_make_lladdr(&generated_lladdr, mac);
+	ut_asserteq_mem(&generated_lladdr, &correct_lladdr,
+			sizeof(struct in6_addr));
+
+	return 0;
+}
+DM_TEST(dm_test_ip6_make_lladdr, UT_TESTF_SCAN_FDT);
+
 static int dm_test_eth(struct unit_test_state *uts)
 {
 	net_ping_ip = string_to_ip("1.1.2.2");
-- 
2.25.1

[PATCH 17/17] test/py: add a ping6 test

[Viacheslav Mitrofanov]

Add a simple ICMPv6 echo request test

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 test/py/tests/test_net.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/py/tests/test_net.py b/test/py/tests/test_net.py
index 9ca6743afd..bd3d60774b 100644
--- a/test/py/tests/test_net.py
+++ b/test/py/tests/test_net.py
@@ -126,6 +126,21 @@ def test_net_ping(u_boot_console):
     output = u_boot_console.run_command('ping $serverip')
     assert 'is alive' in output
 
+@pytest.mark.buildconfigspec('cmd_ping6')
+def test_net_ping6(u_boot_console):
+    """Test the ping6 command.
+
+    The $serverip6 (as set up by test_net_setup_static) is pinged.
+    The test validates that the host is alive, as reported by the
+    ping6 command's output.
+    """
+
+    if not net_set_up:
+        pytest.skip('Network not initialized')
+
+    output = u_boot_console.run_command('ping6 $serverip6')
+    assert 'is alive' in output
+
 @pytest.mark.buildconfigspec('cmd_net')
 def test_net_tftpboot(u_boot_console):
     """Test the tftpboot command.
-- 
2.25.1

Re: [PATCH 02/17] net: ipv6: Add IPv6 build options

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:01, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add options to Makefile and Kconfig file to build IPv6
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  net/Kconfig  | 4 ++++
>  net/Makefile | 1 +
>  2 files changed, 5 insertions(+)
>
> diff --git a/net/Kconfig b/net/Kconfig
> index 52e261884d..568e622de8 100644
> --- a/net/Kconfig
> +++ b/net/Kconfig
> @@ -174,6 +174,10 @@ config BOOTP_MAX_ROOT_PATH_LEN
>         help
>           Select maximal length of option 17 root path.
>
> +config IPV6
> +       bool "IPv6 support"
> +       default n

drop that (n is already the default)

also please add lots of help!

> +
>  endif   # if NET
>
>  config SYS_RX_ETH_BUFFER
> diff --git a/net/Makefile b/net/Makefile
> index 6c812502d3..4ea2a14f27 100644
> --- a/net/Makefile
> +++ b/net/Makefile
> @@ -21,6 +21,7 @@ obj-$(CONFIG_DM_MDIO_MUX) += mdio-mux-uclass.o
>  obj-$(CONFIG_NET)      += eth_common.o
>  obj-$(CONFIG_CMD_LINK_LOCAL) += link_local.o
>  obj-$(CONFIG_NET)      += net.o
> +obj-$(CONFIG_IPV6)     += net6.o
>  obj-$(CONFIG_CMD_NFS)  += nfs.o
>  obj-$(CONFIG_CMD_PING) += ping.o
>  obj-$(CONFIG_CMD_PCAP) += pcap.o
> --
> 2.25.1
>

Regards,
Simon

Re: [PATCH 01/17] net: ipv6: Add IPv6 basic primitives

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:00, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> This patch is a collection of basic primitives that are prerequisite for
> further IPv6 implementation.
>
> There are structures definition such as IPv6 header, UDP header
> (for TFTP), ICMPv6 header. There are auxiliary defines such as protocol
> codes, padding, struct size and etc. Also here are functions prototypes
> and its empty implementation that will be used as API for further patches.
> Here are variables declaration such as IPv6 address of our host,
> gateway, ipv6 server.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/net6.h | 256 +++++++++++++++++++++++++++++++++++++++++++++++++
>  net/net6.c     |  33 +++++++
>  2 files changed, 289 insertions(+)
>  create mode 100644 include/net6.h
>  create mode 100644 net/net6.c

Please comment structs and functions.

Regards,
Simon

Re: [PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Simon Glass]

On Tue, 30 Aug 2022 at 07:00, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
> and set options to them in flag file. These variables are often set up by
> users.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/env_callback.h | 10 ++++++++++
>  include/env_flags.h    | 10 ++++++++++
>  2 files changed, 20 insertions(+)

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH 04/17] net: ipv6: Add Neighbor Discovery Protocol (NDP)

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:01, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Implement basic of NDP. It doesn't include such things as Router
> Solicitation, Router Advertisement and Redirect. It just has Neighbor
> Solicitation and Neighbor Advertisement. Only these two features are used
> in u-boot IPv6. Implementation of some NDP functions uses API that was
> exposed in "net: ipv6: Add IPv6 basic primitives".
>
> Also this patch inlcudes update in Makefile to build NDP.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/ndisc.h |  65 ++++++++++++
>  net/Makefile    |   1 +
>  net/ndisc.c     | 276 ++++++++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 342 insertions(+)
>  create mode 100644 include/ndisc.h
>  create mode 100644 net/ndisc.c
>
> diff --git a/include/ndisc.h b/include/ndisc.h
> new file mode 100644
> index 0000000000..7debdd79d6
> --- /dev/null
> +++ b/include/ndisc.h
> @@ -0,0 +1,65 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright (C) 2013 Allied Telesis Labs NZ
> + * Chris Packham, <judge.packham@gmail.com>
> + *
> + * Copyright (C) 2022 YADRO
> + * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> + */
> +
> +#ifndef __NDISC_H__
> +#define __NDISC_H__
> +
> +#include <ndisc.h>
> +
> +struct nd_msg {

comment

> +       struct icmp6hdr icmph;
> +       struct in6_addr target;
> +       __u8            opt[0];
> +};
> +
> +struct echo_msg {

comment

> +       struct icmp6hdr icmph;
> +       __u16           id;
> +       __u16           sequence;
> +};
> +
> +/* 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;
> +
> +#ifdef CONFIG_IPV6
> +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);

comments

> +#else
> +static inline void ndisc_init(void)
> +{
> +}
> +
> +static inline void
> +ndisc_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
> +{
> +}
> +
> +static inline void ndisc_request(void)
> +{
> +}
> +
> +static inline int ndisc_timeout_check(void)
> +{
> +       return 0;
> +}
> +#endif
> +
> +#endif /* __NDISC_H__ */
> diff --git a/net/Makefile b/net/Makefile
> index 4ea2a14f27..766dd04135 100644
> --- a/net/Makefile
> +++ b/net/Makefile
> @@ -20,6 +20,7 @@ obj-$(CONFIG_DM_MDIO)  += mdio-uclass.o
>  obj-$(CONFIG_DM_MDIO_MUX) += mdio-mux-uclass.o
>  obj-$(CONFIG_NET)      += eth_common.o
>  obj-$(CONFIG_CMD_LINK_LOCAL) += link_local.o
> +obj-$(CONFIG_IPV6)     += ndisc.o
>  obj-$(CONFIG_NET)      += net.o
>  obj-$(CONFIG_IPV6)     += net6.o
>  obj-$(CONFIG_CMD_NFS)  += nfs.o
> diff --git a/net/ndisc.c b/net/ndisc.c
> new file mode 100644
> index 0000000000..1bd06211f1
> --- /dev/null
> +++ b/net/ndisc.c
> @@ -0,0 +1,276 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2013 Allied Telesis Labs NZ
> + * Chris Packham, <judge.packham@gmail.com>
> + *
> + * Copyright (C) 2022 YADRO
> + * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> + */
> +
> +/*
> + * Neighbour Discovery for IPv6
> + */

Single-line comment style is /* ... */

> +
> +#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;

Should these be static? Can we put them in a struct and attach them to
the uclass or driver?

> +/* 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)

Need to document args and use sphinx format (please fix globally)

> + */
> +static int
> +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)

(drop extra brackets?)

> +               memset(&ndisc->opt[len], 0, space - len);

'\0'

> +
> +       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 ndisc_extract_enetaddr(struct nd_msg *ndisc, uchar enetaddr[6])
> +{
> +       memcpy(enetaddr, &ndisc->opt[2], 6);
> +}

[..]

Regards,
Simon

Re: [PATCH 06/17] net: ipv6: Enable IPv6 typeconversion specifier

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:01, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add the possibility to recognize IPv6 address in print function.
> To output IPv6 address use %pI6 specifier.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  lib/vsprintf.c | 11 +++++------
>  1 file changed, 5 insertions(+), 6 deletions(-)
>
> diff --git a/lib/vsprintf.c b/lib/vsprintf.c
> index fe06aa2d71..d5856b1cbe 100644
> --- a/lib/vsprintf.c
> +++ b/lib/vsprintf.c
> @@ -346,6 +346,7 @@ static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
>                       flags & ~SPECIAL);
>  }
>
> +#if IS_ENABLED(CONFIG_IPV6)
>  static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
>                          int precision, int flags)
>  {
> @@ -365,6 +366,7 @@ static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
>         return string(buf, end, ip6_addr, field_width, precision,
>                       flags & ~SPECIAL);
>  }
> +#endif
>
>  static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
>                          int precision, int flags)
> @@ -450,10 +452,6 @@ static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
>   *       decimal for v4 and colon separated network-order 16 bit hex for v6)
>   * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
>   *       currently the same
> - *
> - * Note: IPv6 support is currently if(0)'ed out. If you ever need
> - * %pI6, please add an IPV6 Kconfig knob, make your code select or
> - * depend on that, and change the 0 below to CONFIG_IS_ENABLED(IPV6).
>   */
>  static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
>                 int field_width, int precision, int flags)
> @@ -498,10 +496,11 @@ static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
>                 flags |= SPECIAL;
>                 /* Fallthrough */
>         case 'I':
> -               /* %pI6 currently unused */
> -               if (0 && fmt[1] == '6')
> +#if IS_ENABLED(CONFIG_IPV6)
> +               if (fmt[1] == '6')

Can you do:

if (CONFIG_ IS_ENABLED(IPV6) && fmt[1] == '6')

and drop the #if of the function above?


>                         return ip6_addr_string(buf, end, ptr, field_width,
>                                                precision, flags);
> +#endif
>                 if (fmt[1] == '4')
>                         return ip4_addr_string(buf, end, ptr, field_width,
>                                                precision, flags);
> --
> 2.25.1
>

Regards,
Simon

Re: [PATCH 07/17] net: ipv6: Add ip6addr, gatewayip6, serverip6 variables callbacks

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:01, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Implement actions on ip6addr, gatewayip6, serverip6 varaibles.
> on_ip6addr - convert IPv6 string addr to struct ip6_addr
> on_gatewayip6 - convert IPv6 string addr to struct ip6_addr
> on_serverip6 - convert IPv6 string addr to struct ip6_addr
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  net/net6.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 67 insertions(+)
>
> diff --git a/net/net6.c b/net/net6.c
> index c2569e0e68..a0410ea8ba 100644
> --- a/net/net6.c
> +++ b/net/net6.c
> @@ -31,3 +31,70 @@ struct in6_addr net_server_ip6 = ZERO_IPV6_ADDR;
>  u32 net_prefix_length;
>
>  bool use_ip6;
> +
> +static int on_ip6addr(const char *name, const char *value, enum env_op op,
> +                     int flags)
> +{
> +       char *v, *s, *strcopy;
> +       int i;
> +
> +       if (flags & H_PROGRAMMATIC)
> +               return 0;
> +
> +       if (op == env_op_delete) {
> +               net_prefix_length = 0;
> +               net_copy_ip6(&net_ip6, &net_null_addr_ip6);
> +               return 0;
> +       }
> +
> +       strcopy = strdup(value);
> +       if (!strcopy)
> +               return -1;

-ENOMEM

But is it possible to avoid memory allocation here? Perhaps just use
strchr() below instead?

> +
> +       net_prefix_length = 128;
> +       i = 0;
> +       s = strcopy;
> +       while (s) {
> +               v = strsep(&s, "/");
> +               if (!v)
> +                       break;
> +
> +               switch (i++) {
> +               case 0:
> +                       string_to_ip6(v, &net_ip6);
> +                       break;
> +               case 1:
> +                       net_prefix_length = simple_strtoul(v, NULL, 10);
> +                       break;
> +               default:
> +                       break;
> +               }
> +       }

Can the above code go into a function and get a unit test?

> +       free(strcopy);
> +
> +       return 0;
> +}
> +
> +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_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);
> --
> 2.25.1
>

Regards,
Simon

Re: [PATCH 10/17] net: tftp: Add IPv6 support for tftpboot

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:02, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> The command tftpboot uses IPv4 by default. Add the possibility to use IPv6
> instead. If an address in the command is an IPv6 address it will use IPv6
> to boot or if there is a suffix -ipv6 in the end of the command it also
> force using IPv6. All other tftpboot features and parameters are left
> the same.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  cmd/net.c  | 22 +++++++++++++++++++
>  net/net.c  | 34 ++++++++++++++++++++++++++++--
>  net/tftp.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++-------
>  3 files changed, 108 insertions(+), 10 deletions(-)
>
> diff --git a/cmd/net.c b/cmd/net.c
> index 3619c843d8..0225f9ce3e 100644
> --- a/cmd/net.c
> +++ b/cmd/net.c
> @@ -14,6 +14,7 @@
>  #include <env.h>
>  #include <image.h>
>  #include <net.h>
> +#include <net6.h>
>  #include <net/udp.h>
>  #include <net/sntp.h>
>
> @@ -44,12 +45,22 @@ int do_tftpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
>         return ret;
>  }
>
> +#if IS_ENABLED(CONFIG_IPV6)
> +U_BOOT_CMD(
> +       tftpboot,       4,      1,      do_tftpb,
> +       "boot image via network using TFTP protocol\n"
> +       "To use IPv6 add -ipv6 parameter or use IPv6 hostIPaddr framed "
> +       "with [] brackets",
> +       "[loadAddress] [[hostIPaddr:]bootfilename] [" USE_IP6_CMD_PARAM "]"
> +);
> +#else
>  U_BOOT_CMD(
>         tftpboot,       3,      1,      do_tftpb,
>         "boot image via network using TFTP protocol",
>         "[loadAddress] [[hostIPaddr:]bootfilename]"
>  );
>  #endif
> +#endif
>
>  #ifdef CONFIG_CMD_TFTPPUT
>  static int do_tftpput(struct cmd_tbl *cmdtp, int flag, int argc,
> @@ -205,6 +216,17 @@ static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc,
>         if (s != NULL)
>                 image_load_addr = hextoul(s, NULL);
>
> +       if (IS_ENABLED(CONFIG_IPV6)) {
> +               use_ip6 = false;
> +
> +               /* IPv6 parameter has to be always *last* */
> +               if (!strcmp(argv[argc - 1], USE_IP6_CMD_PARAM)) {
> +                       use_ip6 = true;
> +                       /* It is a hack not to break switch/case code */
> +                       --argc;
> +               }
> +       }
> +
>         switch (argc) {
>         case 1:
>                 /* refresh bootfile name from env */
> diff --git a/net/net.c b/net/net.c
> index f818170930..77f42d1d59 100644
> --- a/net/net.c
> +++ b/net/net.c
> @@ -449,6 +449,23 @@ restart:
>         debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n");
>         net_init_loop();
>
> +       /* Find out what protocol to use */
> +       if (IS_ENABLED(CONFIG_IPV6) && !use_ip6) {
> +               char *s, *e;
> +               char str_ip6[16];
> +
> +               s = strchr(net_boot_file_name, '[');
> +               e = strchr(net_boot_file_name, ']');
> +               if (s && e) {
> +                       size_t len = e - s;
> +
> +                       memcpy(str_ip6, s + 1, len);
> +                       str_ip6[len - 1] = '\0';
> +                       if (!string_to_ip6(str_ip6, &net_server_ip6))

Should string_to_ip6 take a length param so the string does not need
to be nul-terminated?

> +                               use_ip6 = true;
> +               }
> +       }
> +

[..]

Regards,
Simon

Re: [PATCH 11/17] net: ping6: Add ping6 command

[Simon Glass]

On Tue, 30 Aug 2022 at 07:02, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Implement ping6 command to ping hosts using IPv6. It works the same way as
> an ordinary ping command. There is no ICMP request so it is not possible
> to ping our host. This patch adds options in Kconfig and Makefile to
> build ping6 command.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  cmd/Kconfig    |   7 +++
>  cmd/net.c      |  26 +++++++++++
>  include/net.h  |   4 +-
>  include/net6.h |  17 +++++++
>  net/Makefile   |   1 +
>  net/net.c      |  13 ++++++
>  net/net6.c     |   4 ++
>  net/ping6.c    | 117 +++++++++++++++++++++++++++++++++++++++++++++++++
>  8 files changed, 187 insertions(+), 2 deletions(-)
>  create mode 100644 net/ping6.c
>
> diff --git a/cmd/Kconfig b/cmd/Kconfig
> index 8ea064b8d2..4c95c6fd9b 100644
> --- a/cmd/Kconfig
> +++ b/cmd/Kconfig
> @@ -1801,6 +1801,13 @@ config CMD_PING
>         help
>           Send ICMP ECHO_REQUEST to network host
>
> +config CMD_PING6
> +       bool "ping6"
> +       depends on IPV6
> +       default y if (CMD_PING && IPV6)
> +       help
> +         Send ICMPv6 ECHO_REQUEST to network host
> +
>  config CMD_CDP
>         bool "cdp"
>         help
> diff --git a/cmd/net.c b/cmd/net.c
> index 0225f9ce3e..cd24813bcd 100644
> --- a/cmd/net.c
> +++ b/cmd/net.c
> @@ -334,6 +334,32 @@ U_BOOT_CMD(
>  );
>  #endif
>
> +#if IS_ENABLED(CONFIG_CMD_PING6)
> +int do_ping6(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
> +{
> +       if (string_to_ip6(argv[1], &net_ping_ip6) != 0)
> +               return CMD_RET_USAGE;
> +
> +       use_ip6 = true;
> +       if (net_loop(PING6) < 0) {
> +               use_ip6 = false;
> +               printf("ping6 failed; host %pI6c is not alive\n",
> +                      &net_ping_ip6);
> +               return 1;
> +       }
> +
> +       use_ip6 = false;
> +       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/net.h b/include/net.h
> index c06b577808..72d32d358a 100644
> --- a/include/net.h
> +++ b/include/net.h
> @@ -559,8 +559,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, FASTBOOT, WOL, UDP
> +       BOOTP, RARP, ARP, TFTPGET, DHCP, PING, PING6, DNS, NFS, CDP, NETCONS,
> +       SNTP, TFTPSRV, TFTPPUT, LINKLOCAL, FASTBOOT, WOL, UDP
>  };
>
>  extern char    net_boot_file_name[1024];/* Boot File name */
> diff --git a/include/net6.h b/include/net6.h
> index a7be2496d9..08d31b8197 100644
> --- a/include/net6.h
> +++ b/include/net6.h
> @@ -175,6 +175,7 @@ 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 u32 net_prefix_length;  /* Our prefixlength (0 = unknown) */
>  extern struct in6_addr net_server_ip6; /* Server IPv6 addr (0 = unknown) */
> +extern struct in6_addr net_ping_ip6; /* the ipv6 address to ping */
>  extern bool use_ip6;
>
>  #if IS_ENABLED(CONFIG_IPV6)
> @@ -292,4 +293,20 @@ static inline void net_copy_ip6(void *to, const void *from)
>  }
>  #endif
>
> +#if IS_ENABLED(CONFIG_CMD_PING6)
> +/* 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);

Proper comments again. Also It seems that this one can fail?

> +#else
> +static inline void ping6_start(void)
> +{
> +}
> +
> +static inline
> +void ping6_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
> +{
> +}
> +#endif /* CONFIG_CMD_PING6 */
> +

[..]

Regards,
Simon

Re: [PATCH 12/17] test: dm: eth: Add string_to_ip6 test

[Simon Glass]

On Tue, 30 Aug 2022 at 07:02, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add a test to check convertation from char* to struct in6_addr.
> Use in sandbox
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/dm/eth.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 48 insertions(+)

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH 05/17] net: ipv6: Add string_to_ip6 converter

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:01, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> This functions is used as a converter from IPv6 address string notation
> to struct ip6_addr that is used everywhere in IPv6 implementation. For
> example it is used to parse and convert IPv6 address from tftpboot
> command. Conversion algorithm uses two passes, first to verify syntax and
> locate colons and second pass to read the address. In case of valid IPv6
> address it returns 0.
>
> Examples of valid strings:
>         2001:db8::0:1234:1
>         2001:0db8:0000:0000:0000:0000:1234:0001
>         ::1
>         ::ffff:192.168.1.1
>
> Examples of invalid strings
>         2001:db8::0::0          (:: can only appear once)
>         2001:db8:192.168.1.1::1 (v4 part can only appear at the end)
>         192.168.1.1             (we don't implicity map v4)
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/net6.h  |   5 ++
>  lib/net_utils.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 127 insertions(+)
>
> diff --git a/include/net6.h b/include/net6.h
> index 71072d1416..68fa38adbb 100644
> --- a/include/net6.h
> +++ b/include/net6.h
> @@ -177,10 +177,15 @@ extern u32 net_prefix_length;     /* Our prefixlength (0 = unknown) */
>  extern struct in6_addr net_server_ip6; /* Server IPv6 addr (0 = unknown) */
>  extern bool use_ip6;
>
> +#if IS_ENABLED(CONFIG_IPV6)
> +/* Convert a string to an ipv6 address */
> +int string_to_ip6(const char *s, struct in6_addr *addr);
> +#else
>  static inline int string_to_ip6(const char *s, struct in6_addr *addr)
>  {
>         return -1;
>  }
> +#endif
>
>  static inline int ip6_is_unspecified_addr(struct in6_addr *addr)
>  {
> diff --git a/lib/net_utils.c b/lib/net_utils.c
> index 72a3b098a7..09554c520b 100644
> --- a/lib/net_utils.c
> +++ b/lib/net_utils.c
> @@ -11,6 +11,7 @@
>
>  #include <common.h>
>  #include <net.h>
> +#include <net6.h>
>
>  struct in_addr string_to_ip(const char *s)
>  {
> @@ -43,6 +44,127 @@ struct in_addr string_to_ip(const char *s)
>         return addr;
>  }
>
> +/**
> + * Parses an struct in6_addr from the given string. IPv6 address parsing is a
> + * bit more complicated than v4 due to the flexible format and some of the
> + * special cases (e.g. v4 mapped).
> + *
> + * Examples of valid strings:
> + *   2001:db8::0:1234:1
> + *   2001:0db8:0000:0000:0000:0000:1234:0001
> + *   ::1
> + *   ::ffff:192.168.1.1
> + *
> + * Examples of invalid strings
> + *   2001:db8::0::0          (:: can only appear once)
> + *   2001:db8:192.168.1.1::1 (v4 part can only appear at the end)
> + *   192.168.1.1             (we don't implicity map v4)
> + */
> +#if IS_ENABLED(CONFIG_IPV6)
> +int string_to_ip6(const char *strpt, struct in6_addr *addrpt)
> +{
> +       int colon_count = 0;
> +       int found_double_colon = 0;
> +       int xstart = 0;         /* first zero (double colon) */
> +       int len = 7;            /* num words the double colon represents */
> +       int i;
> +       const char *s = strpt;
> +       struct in_addr zero_ip = {.s_addr = 0};
> +
> +       if (!strpt)
> +               return -1;
> +
> +       /* First pass, verify the syntax and locate the double colon */
> +       for (;;) {
> +               while (isxdigit((int)*s))
> +                       s++;
> +               if (*s == '\0')
> +                       break;
> +               if (*s != ':') {
> +                       if (*s == '.' && len >= 2) {
> +                               struct in_addr v4;
> +
> +                               while (s != strpt && *(s - 1) != ':')
> +                                       --s;
> +                               v4 = string_to_ip(s);
> +                               if (memcmp(&zero_ip, &v4,
> +                                          sizeof(struct in_addr) != 0)) {
> +                                       len -= 2;
> +                                       break;
> +                               }
> +                       }
> +                       /* This could be a valid address */
> +                       break;
> +               }
> +               if (s == strpt) {
> +                       /* The address begins with a colon */
> +                       if (*++s != ':')
> +                               /* Must start with a double colon or a number */
> +                               goto out_err;
> +               } else {
> +                       s++;
> +                       if (found_double_colon)
> +                               len--;
> +                       else
> +                               xstart++;
> +               }
> +
> +               if (*s == ':') {
> +                       if (found_double_colon)
> +                               /* Two double colons are not allowed */
> +                               goto out_err;
> +                       found_double_colon = 1;
> +                       len -= xstart;
> +                       s++;
> +               }
> +
> +               if (++colon_count == 7)
> +                       /* Found all colons */
> +                       break;
> +       }
> +
> +       if (colon_count == 0)
> +               goto out_err;
> +       if (*--s == ':')
> +               len++;
> +
> +       /* Second pass, read the address */
> +       s = strpt;
> +       for (i = 0; i < 8; i++) {
> +               int val = 0;
> +               char *end;
> +
> +               if (found_double_colon && i >= xstart && i < xstart + len) {
> +                       addrpt->s6_addr16[i] = 0;
> +                       continue;
> +               }
> +               while (*s == ':')
> +                       s++;
> +
> +               if (i == 6 && isdigit((int)*s)) {
> +                       struct in_addr v4 = string_to_ip(s);
> +
> +                       if (memcmp(&zero_ip, &v4,
> +                                  sizeof(struct in_addr)) != 0) {
> +                               /* Ending with :IPv4-address */
> +                               addrpt->s6_addr32[3] = v4.s_addr;
> +                               break;
> +                       }
> +               }
> +
> +               val = simple_strtoul(s, &end, 16);
> +               if (*end != '\0' && *end != ':')
> +                       goto out_err;
> +               addrpt->s6_addr16[i] = htons(val);
> +               s = end;
> +       }
> +       return 0;
> +
> +out_err:
> +       return -1;
> +}
> +#endif
> +
>  void string_to_enetaddr(const char *addr, uint8_t *enetaddr)
>  {
>         char *end;
> --
> 2.25.1
>

I won't mention the function/struct comments again, but please check
this for the whole series.

Regards,
Simon

Re: [PATCH 13/17] test: dm: eth: Add csum_ipv6_magic test

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:03, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Test checksum computation. csum_ipv6_magic() uses in upper layer
> protocols as TCP/UDP/ICMPv6/etc to calculate payload checksum.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/dm/eth.c | 29 +++++++++++++++++++++++++++++
>  1 file changed, 29 insertions(+)

Reviewed-by: Simon Glass <sjg@chromium.org>

>
> diff --git a/test/dm/eth.c b/test/dm/eth.c
> index 4cc90cf514..bbfa14ef6d 100644
> --- a/test/dm/eth.c
> +++ b/test/dm/eth.c
> @@ -70,6 +70,35 @@ static int dm_test_string_to_ip6(struct unit_test_state *uts)
>  }
>  DM_TEST(dm_test_string_to_ip6, 0);
>
> +static int dm_test_csum_ipv6_magic(struct unit_test_state *uts)
> +{
> +       unsigned short csum = 0xBEEF;

lower-case hex consistently

> +       /* Predefined correct parameters */
> +       unsigned short correct_csum = 0xD8AC;
> +       struct in6_addr saddr = {.s6_addr32[0] = 0x000080fe,
> +                                .s6_addr32[1] = 0x00000000,
> +                                .s6_addr32[2] = 0xffe9f242,
> +                                .s6_addr32[3] = 0xe8f66dfe};
> +       struct in6_addr daddr = {.s6_addr32[0] = 0x000080fe,
> +                                .s6_addr32[1] = 0x00000000,
> +                                .s6_addr32[2] = 0xffd5b372,
> +                                .s6_addr32[3] = 0x3ef692fe};
> +       u16 len = 1460;
> +       unsigned short proto = 17;
> +       unsigned int head_csum = 0x91f0;
> +
> +       csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
> +       ut_assert(csum == correct_csum);

ut_asserteq

> +
> +       /* Broke a parameter */
> +       proto--;
> +       csum = csum_ipv6_magic(&saddr, &daddr, len, proto, head_csum);
> +       ut_assert(csum != correct_csum);
> +
> +       return 0;
> +}
> +DM_TEST(dm_test_csum_ipv6_magic, 0);
> +
>  static int dm_test_eth(struct unit_test_state *uts)
>  {
>         net_ping_ip = string_to_ip("1.1.2.2");
> --
> 2.25.1
>

Regards,
Simon

Re: [PATCH 15/17] test: dm: eth: Add ip6_make_snma test

[Simon Glass]

On Tue, 30 Aug 2022 at 07:03, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add a test that checks generated Solicited Node Multicast Address from our
> ipv6 address. Use in sandbox
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/dm/eth.c | 20 ++++++++++++++++++++
>  1 file changed, 20 insertions(+)
>

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH 16/17] test: dm: eth: Add ip6_make_lladdr test

[Simon Glass]

On Tue, 30 Aug 2022 at 07:03, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add a test that checks generated Link Local Address. Use in sandbox
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/dm/eth.c | 18 ++++++++++++++++++
>  1 file changed, 18 insertions(+)
>

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH 14/17] test: dm: eth: Add ip6_addr_in_subnet test

[Simon Glass]

On Tue, 30 Aug 2022 at 07:03, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add a test if two address are in the same subnet. Use in sandbox
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/dm/eth.c | 25 +++++++++++++++++++++++++
>  1 file changed, 25 insertions(+)
>

Reviewed-by: Simon Glass <sjg@chromium.org>

Re: [PATCH 17/17] test/py: add a ping6 test

[Simon Glass]

On Tue, 30 Aug 2022 at 07:04, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Add a simple ICMPv6 echo request test
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  test/py/tests/test_net.py | 15 +++++++++++++++
>  1 file changed, 15 insertions(+)

Reviewed-by: Simon Glass <sjg@chromium.org>


>
> diff --git a/test/py/tests/test_net.py b/test/py/tests/test_net.py
> index 9ca6743afd..bd3d60774b 100644
> --- a/test/py/tests/test_net.py
> +++ b/test/py/tests/test_net.py
> @@ -126,6 +126,21 @@ def test_net_ping(u_boot_console):
>      output = u_boot_console.run_command('ping $serverip')
>      assert 'is alive' in output
>
> +@pytest.mark.buildconfigspec('cmd_ping6')
> +def test_net_ping6(u_boot_console):
> +    """Test the ping6 command.
> +
> +    The $serverip6 (as set up by test_net_setup_static) is pinged.
> +    The test validates that the host is alive, as reported by the
> +    ping6 command's output.
> +    """
> +
> +    if not net_set_up:
> +        pytest.skip('Network not initialized')
> +
> +    output = u_boot_console.run_command('ping6 $serverip6')
> +    assert 'is alive' in output
> +
>  @pytest.mark.buildconfigspec('cmd_net')
>  def test_net_tftpboot(u_boot_console):
>      """Test the tftpboot command.
> --
> 2.25.1
>

Re: [PATCH 08/17] net: ipv6: Add implementation of main IPv6 functions

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:02, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Functions that were exposed in "net: ipv6: Add IPv6 basic primitives"
> had only empty implementations and were exposed as API for futher
> patches. This patch add implementation of these functions. Main
> functions are: net_ip6_handler() - IPv6 packet handler for incoming
> packets; net_send_udp_packet6() - make up and send an UDP packet;
> csum_ipv6_magic() - compute checksum of IPv6 "psuedo-header" per RFC2460
> section 8.1; ip6_addr_in_subnet() - check if an address is in our
> subnet. Other functions are auxiliary.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/net6.h |  36 ++++-
>  net/net6.c     | 380 +++++++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 415 insertions(+), 1 deletion(-)
>
> diff --git a/include/net6.h b/include/net6.h
> index 68fa38adbb..a7be2496d9 100644
> --- a/include/net6.h
> +++ b/include/net6.h
> @@ -180,12 +180,45 @@ extern bool use_ip6;
>  #if IS_ENABLED(CONFIG_IPV6)
>  /* 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);
> +/* 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);
> +
> +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);
> +
> +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);

Full comments on functions here please

> +
> +int ip6_add_hdr(uchar *xip, struct in6_addr *src, struct in6_addr *dest,
> +               int nextheader, int hoplimit, int payload_len);
> +
> +/* Transmit UDP packet using IPv6, performing neighbour discovery if needed */
> +int net_send_udp_packet6(uchar *ether, struct in6_addr *dest,
> +                        int dport, int sport, int len);
> +
> +/* handler for incoming IPv6 echo packet */
> +void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
> +                    int len);
> +
> +static inline void net_copy_ip6(void *to, const void *from)
> +{
> +       memcpy((void *)to, from, sizeof(struct in6_addr));
> +}
>  #else
>  static inline int string_to_ip6(const char *s, struct in6_addr *addr)
>  {
>         return -1;

Make sure that error codes use -EINVAL etc.

>  }
> -#endif
>
>  static inline int ip6_is_unspecified_addr(struct in6_addr *addr)
>  {
> @@ -257,5 +290,6 @@ net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6,
>  static inline void net_copy_ip6(void *to, const void *from)
>  {
>  }
> +#endif
>
>  #endif /* __NET6_H__ */
> diff --git a/net/net6.c b/net/net6.c
> index a0410ea8ba..0799d411b2 100644
> --- a/net/net6.c
> +++ b/net/net6.c
> @@ -16,6 +16,7 @@
>  #include <malloc.h>
>  #include <net.h>
>  #include <net6.h>
> +#include <ndisc.h>
>
>  /* NULL IPv6 address */
>  struct in6_addr const net_null_addr_ip6 = ZERO_IPV6_ADDR;
> @@ -98,3 +99,382 @@ static int on_serverip6(const char *name, const char *value, enum env_op op,
>  }
>
>  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;

return !(...)

> +}
> +
> +/**
> + * 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)) ||
> +              !memcmp(addr, &net_ip6, sizeof(struct in6_addr));
> +}
> +
> +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;

lower-case hex

> +       eui[0] ^= 2;            /* "u" bit set to indicate global scope */
> +}
> +
> +void ip6_make_lladdr(struct in6_addr *lladr, unsigned char const enetaddr[6])

const unsigned char

> +{
> +       uchar eui[8];
> +
> +       memset(lladr, 0, sizeof(struct in6_addr));

'\0'

> +       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)
> +{
> +       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.
> + */

comment should go in header file if this is exported. Otherwise please
make static

> +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. */

Drop .

> +       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);
> +
> +       /* Opaque moment. If reverse it to zero it will
> +        * not be checked on receiver's side. It leads to
> +        * bad negibour advertisement for some reason.

Can you word wrap to 80cols? This seems a little short

> +        */
> +       if (sum == 0xffff)
> +               return sum;
> +
> +       return ~sum;
> +}
> +
> +static inline unsigned short from32to16(unsigned int x)
> +{
> +       /* add up 16-bit and 16-bit for 16+c bit */
> +       x = (x & 0xffff) + (x >> 16);
> +       /* add up carry.. */
> +       x = (x & 0xffff) + (x >> 16);
> +       return x;
> +}
> +
> +static u32 csum_do_csum(const u8 *buff, int len)
> +{
> +       int odd;
> +       unsigned int result = 0;
> +
> +       if (len <= 0)
> +               goto out;
> +       odd = 1 & (unsigned long)buff;
> +       if (odd) {
> +#ifdef __LITTLE_ENDIAN
> +               result += (*buff << 8);
> +#else
> +               result = *buff;
> +#endif
> +               len--;
> +               buff++;
> +       }
> +       if (len >= 2) {
> +               if (2 & (unsigned long)buff) {

swap operands?

> +                       result += *(unsigned short *)buff;
> +                       len -= 2;
> +                       buff += 2;
> +               }
> +               if (len >= 4) {
> +                       const unsigned char *end = buff + ((u32)len & ~3);
> +                       unsigned int carry = 0;
> +
> +                       do {
> +                               unsigned int w = *(unsigned int *)buff;
> +
> +                               buff += 4;
> +                               result += carry;
> +                               result += w;
> +                               carry = (w > result);
> +                       } while (buff < end);
> +                       result += carry;
> +                       result = (result & 0xffff) + (result >> 16);
> +               }
> +               if (len & 2) {
> +                       result += *(unsigned short *)buff;
> +                       buff += 2;
> +               }
> +       }
> +       if (len & 1)
> +#ifdef __LITTLE_ENDIAN
> +               result += *buff;
> +#else
> +               result += (*buff << 8);
> +#endif
> +       result = from32to16(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 carry;
> +       u32 ulen;
> +       u32 uproto;
> +       u32 sum = csum;
> +
> +       sum += saddr->s6_addr32[0];
> +       carry = (sum < saddr->s6_addr32[0]);
> +       sum += carry;
> +
> +       sum += saddr->s6_addr32[1];
> +       carry = (sum < saddr->s6_addr32[1]);
> +       sum += carry;
> +
> +       sum += saddr->s6_addr32[2];
> +       carry = (sum < saddr->s6_addr32[2]);
> +       sum += carry;
> +
> +       sum += saddr->s6_addr32[3];
> +       carry = (sum < saddr->s6_addr32[3]);
> +       sum += carry;
> +
> +       sum += daddr->s6_addr32[0];
> +       carry = (sum < daddr->s6_addr32[0]);
> +       sum += carry;
> +
> +       sum += daddr->s6_addr32[1];
> +       carry = (sum < daddr->s6_addr32[1]);
> +       sum += carry;
> +
> +       sum += daddr->s6_addr32[2];
> +       carry = (sum < daddr->s6_addr32[2]);
> +       sum += carry;
> +
> +       sum += daddr->s6_addr32[3];
> +       carry = (sum < daddr->s6_addr32[3]);
> +       sum += carry;
> +
> +       ulen = htonl((u32)len);
> +       sum += ulen;
> +       carry = (sum < ulen);
> +       sum += carry;
> +
> +       uproto = htonl(proto);
> +       sum += uproto;
> +       carry = (sum < uproto);
> +       sum += carry;
> +
> +       return csum_fold(sum);
> +}
> +
> +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);
> +}
> +
> +int
> +net_send_udp_packet6(uchar *ether, struct in6_addr *dest, int dport, int sport, int len)
> +{
> +       uchar *pkt;
> +       struct udp_hdr *udp;
> +
> +       udp = (struct udp_hdr *)((uchar *)net_tx_packet + net_eth_hdr_size() +
> +                       IP6_HDR_SIZE);
> +
> +       udp->udp_dst = htons(dport);
> +       udp->udp_src = htons(sport);
> +       udp->udp_len = htons(len + UDP_HDR_SIZE);
> +
> +       /* checksum */
> +       udp->udp_xsum = 0;
> +       udp->udp_xsum = csum_ipv6_magic(&net_ip6, dest, len + UDP_HDR_SIZE,
> +                                       IPPROTO_UDP,
> +                                       csum_partial((u8 *)udp,
> +                                                    len + UDP_HDR_SIZE,
> +                                                    0));
> +
> +       /* if MAC address was not discovered yet, save the packet and do
> +        * neighbour discovery
> +        */
> +       if (memcmp(ether, net_null_ethaddr, 6) == 0) {

!memcpy

> +               net_copy_ip6(&net_nd_sol_packet_ip6, dest);
> +               net_nd_packet_mac = ether;
> +
> +               pkt = net_nd_tx_packet;
> +               pkt += net_set_ether(pkt, net_nd_packet_mac, PROT_IP6);
> +               pkt += ip6_add_hdr(pkt, &net_ip6, dest, IPPROTO_UDP, 64,
> +                               len + UDP_HDR_SIZE);
> +               memcpy(pkt, (uchar *)udp, len + UDP_HDR_SIZE);
> +
> +               /* size of the waiting packet */
> +               net_nd_tx_packet_size = (pkt - net_nd_tx_packet) +
> +                       UDP_HDR_SIZE + len;
> +
> +               /* and do the neighbor solicitation */
> +               net_nd_try = 1;
> +               net_nd_timer_start = get_timer(0);
> +               ndisc_request();
> +               return 1;       /* waiting */
> +       }
> +
> +       pkt = (uchar *)net_tx_packet;
> +       pkt += net_set_ether(pkt, ether, PROT_IP6);
> +       pkt += ip6_add_hdr(pkt, &net_ip6, dest, IPPROTO_UDP, 64,
> +                       len + UDP_HDR_SIZE);
> +       (void)eth_send(net_tx_packet, pkt - net_tx_packet + UDP_HDR_SIZE + len);
> +
> +       return 0;       /* transmitted */
> +}
> +
> +void net_ip6_handler(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)

return an error code?

> +{
> +       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) {
> +               case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
> +               case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
> +                       ndisc_receive(et, ip6, len);
> +                       break;
> +               default:
> +                       break;
> +               }
> +               break;
> +       case IPPROTO_UDP:
> +               udp = (struct udp_hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);
> +               csum = udp->udp_xsum;
> +               hlen = ntohs(ip6->payload_len);
> +               udp->udp_xsum = 0;
> +               /* checksum */
> +               udp->udp_xsum = csum_ipv6_magic(&ip6->saddr, &ip6->daddr,
> +                                               hlen, IPPROTO_UDP,
> +                                               csum_partial((u8 *)udp,
> +                                                            hlen, 0));

can the csum_partial() call be done on the line before and put in a var?

> +
> +               if (csum != udp->udp_xsum)
> +                       return;
> +
> +               /* IP header OK.  Pass the packet to the current handler. */
> +               net_get_udp_handler()((uchar *)ip6 + IP6_HDR_SIZE +
> +                                       UDP_HDR_SIZE,
> +                               ntohs(udp->udp_dst),
> +                               zero_ip,
> +                               ntohs(udp->udp_src),
> +                               ntohs(udp->udp_len) - 8);
> +               break;
> +       default:
> +               break;
> +       }
> +}
> --
> 2.25.1
>

Regards,
Simon

Re: [PATCH v2 00/17] IPv6 support

[Simon Glass]

Hi Viacheslav,

On Tue, 30 Aug 2022 at 07:00, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> This patch set adds basic IPv6 support to U-boot.
> It is based on Chris's Packham patches
> (https://lists.denx.de/pipermail/u-boot/2017-January/279366.html)
> Chris's patches were taken as base. There were efforts to launch it on HiFive
> SiFive Unmatched board but the board didn't work well. The code was refactored,
> fixed some bugs as CRC for little-endian, some parts were implemented in our own
> way, something was taken from Linux. Finally we did manual tests and the board
> worked well.
>
> Testing was done on HiFive SiFive Unmatched board (RISC-V)
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
>
> ---
> Changes in v2:
>  - Split big patches into smaller
>  - If an address in tftpboot is IPv6 than use IPv6 to boot
>  - Add tests
>
> Viacheslav Mitrofanov (17):
>   net: ipv6: Add IPv6 basic primitives
>   net: ipv6: Add IPv6 build options
>   net: ipv6: Add callbacks declarations to get access to IPv6 variables
>   net: ipv6: Add Neighbor Discovery Protocol (NDP)
>   net: ipv6: Add string_to_ip6 converter
>   net: ipv6: Enable IPv6 typeconversion specifier
>   net: ipv6: Add ip6addr, gatewayip6, serverip6 variables callbacks
>   net: ipv6: Add implementation of main IPv6 functions
>   net: ipv6: Incorporate IPv6 support into u-boot net subsystem
>   net: tftp: Add IPv6 support for tftpboot
>   net: ping6: Add ping6 command
>   test: dm: eth: Add string_to_ip6 test
>   test: dm: eth: Add csum_ipv6_magic test
>   test: dm: eth: Add ip6_addr_in_subnet test
>   test: dm: eth: Add ip6_make_snma test
>   test: dm: eth: Add ip6_make_lladdr test
>   test/py: add a ping6 test
>
>  cmd/Kconfig               |   7 +
>  cmd/net.c                 |  48 ++++
>  include/env_callback.h    |  10 +
>  include/env_flags.h       |  10 +
>  include/ndisc.h           |  65 +++++
>  include/net.h             |   4 +-
>  include/net6.h            | 312 ++++++++++++++++++++++++
>  lib/net_utils.c           | 122 ++++++++++
>  lib/vsprintf.c            |  11 +-
>  net/Kconfig               |   4 +
>  net/Makefile              |   3 +
>  net/ndisc.c               | 276 ++++++++++++++++++++++
>  net/net.c                 |  70 +++++-
>  net/net6.c                | 484 ++++++++++++++++++++++++++++++++++++++
>  net/ping6.c               | 117 +++++++++
>  net/tftp.c                |  62 ++++-
>  test/dm/eth.c             | 140 +++++++++++
>  test/py/tests/test_net.py |  15 ++
>  18 files changed, 1741 insertions(+), 19 deletions(-)
>  create mode 100644 include/ndisc.h
>  create mode 100644 include/net6.h
>  create mode 100644 net/ndisc.c
>  create mode 100644 net/net6.c
>  create mode 100644 net/ping6.c

This is very nicely put together. I added some comments about missing
comments and other minor things.

I didn't try the ping6 test - does it need any special environment to work?

Regards,
Simon

Re: [PATCH v2 00/17] IPv6 support

[Vyacheslav Mitrofanov V]

On Wed, 2022-08-31 at 20:27 -0600, Simon Glass wrote:
> «Внимание! Данное письмо от внешнего адресата!»
> 
> Hi Viacheslav,
> 
> On Tue, 30 Aug 2022 at 07:00, Viacheslav Mitrofanov
> <v.v.mitrofanov@yadro.com> wrote:
> > This patch set adds basic IPv6 support to U-boot.
> > It is based on Chris's Packham patches
> > (https://lists.denx.de/pipermail/u-boot/2017-January/279366.html)
> > Chris's patches were taken as base. There were efforts to launch it
> > on HiFive
> > SiFive Unmatched board but the board didn't work well. The code was
> > refactored,
> > fixed some bugs as CRC for little-endian, some parts were
> > implemented in our own
> > way, something was taken from Linux. Finally we did manual tests
> > and the board
> > worked well.
> > 
> > Testing was done on HiFive SiFive Unmatched board (RISC-V)
> > 
> > Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> > 
> > ---
> > Changes in v2:
> >  - Split big patches into smaller
> >  - If an address in tftpboot is IPv6 than use IPv6 to boot
> >  - Add tests
> > 
> > Viacheslav Mitrofanov (17):
> >   net: ipv6: Add IPv6 basic primitives
> >   net: ipv6: Add IPv6 build options
> >   net: ipv6: Add callbacks declarations to get access to IPv6
> > variables
> >   net: ipv6: Add Neighbor Discovery Protocol (NDP)
> >   net: ipv6: Add string_to_ip6 converter
> >   net: ipv6: Enable IPv6 typeconversion specifier
> >   net: ipv6: Add ip6addr, gatewayip6, serverip6 variables callbacks
> >   net: ipv6: Add implementation of main IPv6 functions
> >   net: ipv6: Incorporate IPv6 support into u-boot net subsystem
> >   net: tftp: Add IPv6 support for tftpboot
> >   net: ping6: Add ping6 command
> >   test: dm: eth: Add string_to_ip6 test
> >   test: dm: eth: Add csum_ipv6_magic test
> >   test: dm: eth: Add ip6_addr_in_subnet test
> >   test: dm: eth: Add ip6_make_snma test
> >   test: dm: eth: Add ip6_make_lladdr test
> >   test/py: add a ping6 test
> > 
> >  cmd/Kconfig               |   7 +
> >  cmd/net.c                 |  48 ++++
> >  include/env_callback.h    |  10 +
> >  include/env_flags.h       |  10 +
> >  include/ndisc.h           |  65 +++++
> >  include/net.h             |   4 +-
> >  include/net6.h            | 312 ++++++++++++++++++++++++
> >  lib/net_utils.c           | 122 ++++++++++
> >  lib/vsprintf.c            |  11 +-
> >  net/Kconfig               |   4 +
> >  net/Makefile              |   3 +
> >  net/ndisc.c               | 276 ++++++++++++++++++++++
> >  net/net.c                 |  70 +++++-
> >  net/net6.c                | 484
> > ++++++++++++++++++++++++++++++++++++++
> >  net/ping6.c               | 117 +++++++++
> >  net/tftp.c                |  62 ++++-
> >  test/dm/eth.c             | 140 +++++++++++
> >  test/py/tests/test_net.py |  15 ++
> >  18 files changed, 1741 insertions(+), 19 deletions(-)
> >  create mode 100644 include/ndisc.h
> >  create mode 100644 include/net6.h
> >  create mode 100644 net/ndisc.c
> >  create mode 100644 net/net6.c
> >  create mode 100644 net/ping6.c
> 
> This is very nicely put together. I added some comments about missing
> comments and other minor things.
> 
> I didn't try the ping6 test - does it need any special environment to
> work?
> 
> Regards,
> Simon

Hello, Simon!
Many thanks for your response! I do agree with your notes. I'm going to
follow them, so sooner I'll send new patch series.

Thanks!

Re: [PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Ramon Fried]

On Thu, Sep 8, 2022 at 2:59 PM Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
> and set options to them in flag file. These variables are often set up by
> users.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> Reviewed-by: Simon Glass <sjg@chromium.org>
> ---
>  include/env_callback.h | 10 ++++++++++
>  include/env_flags.h    | 10 ++++++++++
>  2 files changed, 20 insertions(+)
>
> diff --git a/include/env_callback.h b/include/env_callback.h
> index d5d2b2fcad..14c6ce0d24 100644
> --- a/include/env_callback.h
> +++ b/include/env_callback.h
> @@ -57,6 +57,15 @@
>  #define NET_CALLBACKS
>  #endif
>
> +#ifdef CONFIG_IPV6
> +#define NET6_CALLBACKS \
> +       "ip6addr:ip6addr," \
> +       "serverip6:serverip6," \
> +       "gatewayip6:gatewayip6,"
> +#else
> +#define NET6_CALLBACKS
> +#endif
> +
>  #ifdef CONFIG_BOOTSTD
>  #define BOOTSTD_CALLBACK       "bootmeths:bootmeths,"
>  #else
> @@ -71,6 +80,7 @@
>         ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
>         "baudrate:baudrate," \
>         NET_CALLBACKS \
> +       NET6_CALLBACKS \
>         BOOTSTD_CALLBACK \
>         "loadaddr:loadaddr," \
>         SILENT_CALLBACK \
> diff --git a/include/env_flags.h b/include/env_flags.h
> index 313cb8c49a..718d72773c 100644
> --- a/include/env_flags.h
> +++ b/include/env_flags.h
> @@ -67,6 +67,15 @@ enum env_flags_varaccess {
>  #define NET_FLAGS
>  #endif
>
> +#ifdef CONFIG_IPV6
> +#define NET6_FLAGS \
> +       "ip6addr:s," \
> +       "serverip6:s," \
> +       "gatewayip6:s"
> +#else
> +#define NET6_FLAGS
> +#endif
> +
>  #ifndef CONFIG_ENV_OVERWRITE
>  #define SERIAL_FLAGS "serial#:so,"
>  #else
> @@ -76,6 +85,7 @@ enum env_flags_varaccess {
>  #define ENV_FLAGS_LIST_STATIC \
>         ETHADDR_FLAGS \
>         NET_FLAGS \
> +       NET6_FLAGS \
>         SERIAL_FLAGS \
>         CONFIG_ENV_FLAGS_LIST_STATIC
>
> --
> 2.25.1
>
Reviewed-by: Ramon Fried <rfried.dev@gmail.com>

Re: [PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Ramon Fried]

On Tue, Sep 6, 2022 at 6:10 PM Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
> and set options to them in flag file. These variables are often set up by
> users.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/env_callback.h | 10 ++++++++++
>  include/env_flags.h    | 10 ++++++++++
>  2 files changed, 20 insertions(+)
>
> diff --git a/include/env_callback.h b/include/env_callback.h
> index d5d2b2fcad..14c6ce0d24 100644
> --- a/include/env_callback.h
> +++ b/include/env_callback.h
> @@ -57,6 +57,15 @@
>  #define NET_CALLBACKS
>  #endif
>
> +#ifdef CONFIG_IPV6
> +#define NET6_CALLBACKS \
> +       "ip6addr:ip6addr," \
> +       "serverip6:serverip6," \
> +       "gatewayip6:gatewayip6,"
> +#else
> +#define NET6_CALLBACKS
> +#endif
> +
>  #ifdef CONFIG_BOOTSTD
>  #define BOOTSTD_CALLBACK       "bootmeths:bootmeths,"
>  #else
> @@ -71,6 +80,7 @@
>         ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
>         "baudrate:baudrate," \
>         NET_CALLBACKS \
> +       NET6_CALLBACKS \
>         BOOTSTD_CALLBACK \
>         "loadaddr:loadaddr," \
>         SILENT_CALLBACK \
> diff --git a/include/env_flags.h b/include/env_flags.h
> index 313cb8c49a..718d72773c 100644
> --- a/include/env_flags.h
> +++ b/include/env_flags.h
> @@ -67,6 +67,15 @@ enum env_flags_varaccess {
>  #define NET_FLAGS
>  #endif
>
> +#ifdef CONFIG_IPV6
> +#define NET6_FLAGS \
> +       "ip6addr:s," \
> +       "serverip6:s," \
> +       "gatewayip6:s"
> +#else
> +#define NET6_FLAGS
> +#endif
> +
>  #ifndef CONFIG_ENV_OVERWRITE
>  #define SERIAL_FLAGS "serial#:so,"
>  #else
> @@ -76,6 +85,7 @@ enum env_flags_varaccess {
>  #define ENV_FLAGS_LIST_STATIC \
>         ETHADDR_FLAGS \
>         NET_FLAGS \
> +       NET6_FLAGS \
>         SERIAL_FLAGS \
>         CONFIG_ENV_FLAGS_LIST_STATIC
>
> --
> 2.25.1
>
Reviewed-by: Ramon Fried <rfried.dev@gmail.com>

[PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Viacheslav Mitrofanov]

Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
and set options to them in flag file. These variables are often set up by
users.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
---
 include/env_callback.h | 10 ++++++++++
 include/env_flags.h    | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/include/env_callback.h b/include/env_callback.h
index d5d2b2fcad..14c6ce0d24 100644
--- a/include/env_callback.h
+++ b/include/env_callback.h
@@ -57,6 +57,15 @@
 #define NET_CALLBACKS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_CALLBACKS \
+	"ip6addr:ip6addr," \
+	"serverip6:serverip6," \
+	"gatewayip6:gatewayip6,"
+#else
+#define NET6_CALLBACKS
+#endif
+
 #ifdef CONFIG_BOOTSTD
 #define BOOTSTD_CALLBACK	"bootmeths:bootmeths,"
 #else
@@ -71,6 +80,7 @@
 	ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
 	"baudrate:baudrate," \
 	NET_CALLBACKS \
+	NET6_CALLBACKS \
 	BOOTSTD_CALLBACK \
 	"loadaddr:loadaddr," \
 	SILENT_CALLBACK \
diff --git a/include/env_flags.h b/include/env_flags.h
index 313cb8c49a..718d72773c 100644
--- a/include/env_flags.h
+++ b/include/env_flags.h
@@ -67,6 +67,15 @@ enum env_flags_varaccess {
 #define NET_FLAGS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_FLAGS \
+	"ip6addr:s," \
+	"serverip6:s," \
+	"gatewayip6:s"
+#else
+#define NET6_FLAGS
+#endif
+
 #ifndef CONFIG_ENV_OVERWRITE
 #define SERIAL_FLAGS "serial#:so,"
 #else
@@ -76,6 +85,7 @@ enum env_flags_varaccess {
 #define ENV_FLAGS_LIST_STATIC \
 	ETHADDR_FLAGS \
 	NET_FLAGS \
+	NET6_FLAGS \
 	SERIAL_FLAGS \
 	CONFIG_ENV_FLAGS_LIST_STATIC
 
-- 
2.25.1

Re: [PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Simon Glass]

Hi Viacheslav,

On Tue, 6 Sept 2022 at 09:10, Viacheslav Mitrofanov
<v.v.mitrofanov@yadro.com> wrote:
>
> Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
> and set options to them in flag file. These variables are often set up by
> users.
>
> Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
> ---
>  include/env_callback.h | 10 ++++++++++
>  include/env_flags.h    | 10 ++++++++++
>  2 files changed, 20 insertions(+)

This seems to have lost my review tag. Can you please resend the
series with these at some point? I'll hold off reviewing the rest for
now.

Note also that your change log is missing in the patches. If you use
patman you can have per-patch change lists for each version, along
with an automatically generated cover-letter change list.

Also 'patman status' can collect tags from patchwork so you don't have
to do that manually.

Regards,
Simon

[PATCH 03/17] net: ipv6: Add callbacks declarations to get access to IPv6 variables

[Viacheslav Mitrofanov]

Set up callbacks for main IPv6 variables ip6add, serverip6, gatewayip6
and set options to them in flag file. These variables are often set up by
users.

Signed-off-by: Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
---
 include/env_callback.h | 10 ++++++++++
 include/env_flags.h    | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/include/env_callback.h b/include/env_callback.h
index d5d2b2fcad..14c6ce0d24 100644
--- a/include/env_callback.h
+++ b/include/env_callback.h
@@ -57,6 +57,15 @@
 #define NET_CALLBACKS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_CALLBACKS \
+	"ip6addr:ip6addr," \
+	"serverip6:serverip6," \
+	"gatewayip6:gatewayip6,"
+#else
+#define NET6_CALLBACKS
+#endif
+
 #ifdef CONFIG_BOOTSTD
 #define BOOTSTD_CALLBACK	"bootmeths:bootmeths,"
 #else
@@ -71,6 +80,7 @@
 	ENV_DOT_ESCAPE ENV_FLAGS_VAR ":flags," \
 	"baudrate:baudrate," \
 	NET_CALLBACKS \
+	NET6_CALLBACKS \
 	BOOTSTD_CALLBACK \
 	"loadaddr:loadaddr," \
 	SILENT_CALLBACK \
diff --git a/include/env_flags.h b/include/env_flags.h
index 313cb8c49a..718d72773c 100644
--- a/include/env_flags.h
+++ b/include/env_flags.h
@@ -67,6 +67,15 @@ enum env_flags_varaccess {
 #define NET_FLAGS
 #endif
 
+#ifdef CONFIG_IPV6
+#define NET6_FLAGS \
+	"ip6addr:s," \
+	"serverip6:s," \
+	"gatewayip6:s"
+#else
+#define NET6_FLAGS
+#endif
+
 #ifndef CONFIG_ENV_OVERWRITE
 #define SERIAL_FLAGS "serial#:so,"
 #else
@@ -76,6 +85,7 @@ enum env_flags_varaccess {
 #define ENV_FLAGS_LIST_STATIC \
 	ETHADDR_FLAGS \
 	NET_FLAGS \
+	NET6_FLAGS \
 	SERIAL_FLAGS \
 	CONFIG_ENV_FLAGS_LIST_STATIC
 
-- 
2.25.1