diff --git a/src/bin/network/Jamfile b/src/bin/network/Jamfile
index 05d170aa61..1f2e1d53a7 100644
--- a/src/bin/network/Jamfile
+++ b/src/bin/network/Jamfile
@@ -15,6 +15,7 @@ SubInclude HAIKU_TOP src bin network netstat ;
 #SubInclude HAIKU_TOP src bin network pppconfig ;
 #SubInclude HAIKU_TOP src bin network ppp_up ;
 SubInclude HAIKU_TOP src bin network ping ;
+SubInclude HAIKU_TOP src bin network ping6 ;
 SubInclude HAIKU_TOP src bin network route ;
 SubInclude HAIKU_TOP src bin network setwep ;
 SubInclude HAIKU_TOP src bin network tcpdump ;
diff --git a/src/bin/network/ifconfig/ifconfig.cpp b/src/bin/network/ifconfig/ifconfig.cpp
index 6ae74eb30b..80a8c53160 100644
--- a/src/bin/network/ifconfig/ifconfig.cpp
+++ b/src/bin/network/ifconfig/ifconfig.cpp
@@ -1,10 +1,11 @@
 /*
- * Copyright 2006-2008, Haiku, Inc. All Rights Reserved.
+ * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
  *		Axel Dörfler, axeld@pinc-software.de
  *		Oliver Tappe, zooey@hirschkaefer.de
+ *		Atis Elsts, the.kfx@gmail.com
  */
 
 
@@ -33,30 +34,82 @@ extern const char* __progname;
 const char* kProgramName = __progname;
 
 
+enum preferred_output_format {
+	PREFER_OUTPUT_MASK,
+	PREFER_OUTPUT_PREFIX_LENGTH,
+};
+
+
 struct address_family {
 	int			family;
 	const char*	name;
 	const char*	identifiers[4];
+	preferred_output_format	preferred_format;
 	bool		(*parse_address)(const char* string, sockaddr* _address);
+	bool		(*prefix_length_to_mask)(uint8 prefixLength, sockaddr* mask);
+	uint8		(*mask_to_prefix_length)(sockaddr* mask);
 	void		(*print_address)(sockaddr* address);
 };
 
+
+bool initialize_address_families();
+
 // AF_INET family
 static bool inet_parse_address(const char* string, sockaddr* address);
+static bool inet_prefix_length_to_mask(uint8 prefixLength, sockaddr* mask);
+static uint8 inet_mask_to_prefix_length(sockaddr* mask);
 static void inet_print_address(sockaddr* address);
 
+// AF_INET6 family
+static bool inet6_parse_address(const char* string, sockaddr* address);
+static bool inet6_prefix_length_to_mask(uint8 prefixLength, sockaddr* mask);
+static uint8 inet6_mask_to_prefix_length(sockaddr* mask);
+static void inet6_print_address(sockaddr* address);
+
 static const address_family kFamilies[] = {
 	{
 		AF_INET,
 		"inet",
 		{"AF_INET", "inet", "ipv4", NULL},
+		PREFER_OUTPUT_MASK,
 		inet_parse_address,
+		inet_prefix_length_to_mask,
+		inet_mask_to_prefix_length,
 		inet_print_address
 	},
-	{ -1, NULL, {NULL}, NULL, NULL }
+	{
+		AF_INET6,
+		"inet6",
+		{"AF_INET6", "inet6", "ipv6", NULL},
+		PREFER_OUTPUT_PREFIX_LENGTH,
+		inet6_parse_address,
+		inet6_prefix_length_to_mask,
+		inet6_mask_to_prefix_length,
+		inet6_print_address
+	},
+	{ -1, NULL, {NULL}, PREFER_OUTPUT_MASK, NULL, NULL, NULL, NULL }
 };
 
 
+static int sAddressFamilySockets[sizeof(kFamilies) / sizeof(kFamilies[0])];
+
+
+bool
+initialize_address_families()
+{
+	bool ok = false;
+	for (int32 i = 0; kFamilies[i].family >= 0; i++) {
+		int fd = socket(kFamilies[i].family, SOCK_DGRAM, 0);
+		if (fd != -1) {
+			sAddressFamilySockets[i] = fd;
+			ok = true;
+		}
+	}
+	return ok;
+}
+
+
+
 static bool
 inet_parse_address(const char* string, sockaddr* _address)
 {
@@ -65,9 +118,9 @@ inet_parse_address(const char* string, sockaddr* _address)
 	if (inet_aton(string, &inetAddress) != 1)
 		return false;
 
-	sockaddr_in& address = *(sockaddr_in *)_address;
+	sockaddr_in& address = *(sockaddr_in*)_address;
 	address.sin_family = AF_INET;
-	address.sin_len = sizeof(struct sockaddr_in);
+	address.sin_len = sizeof(sockaddr_in);
 	address.sin_port = 0;
 	address.sin_addr = inetAddress;
 	memset(&address.sin_zero[0], 0, sizeof(address.sin_zero));
@@ -76,10 +129,50 @@ inet_parse_address(const char* string, sockaddr* _address)
 }
 
 
+static bool
+inet_prefix_length_to_mask(uint8 prefixLength, sockaddr* _mask)
+{
+	if (prefixLength > 32)
+		return false;
+
+	sockaddr_in& mask = *(sockaddr_in*)_mask;
+	mask.sin_family = AF_INET;
+	mask.sin_len = sizeof(sockaddr_in);
+	mask.sin_port = 0;
+	memset(&mask.sin_zero[0], 0, sizeof(mask.sin_zero));
+
+	uint32 hostMask = 0;
+	for (uint8 i = 32; i > 32 - prefixLength; i--)
+		hostMask |= 1 << (i - 1);
+	mask.sin_addr.s_addr = htonl(hostMask);
+
+	return true;
+}
+
+
+static uint8
+inet_mask_to_prefix_length(sockaddr* _mask)
+{
+	sockaddr_in& mask = *(sockaddr_in*)_mask;
+	if (mask.sin_family != AF_INET)
+		return (uint8)-1;
+
+	uint8 result = 0;
+	uint32 hostMask = ntohl(mask.sin_addr.s_addr);
+	for (uint8 i = 32; i > 0; i--) {
+		if (hostMask & (1 << (i - 1)) == 0)
+			break;
+		result++;
+	}
+
+	return result;
+}
+
+
 static void
 inet_print_address(sockaddr* _address)
 {
-	sockaddr_in& address = *(sockaddr_in *)_address;
+	sockaddr_in& address = *(sockaddr_in*)_address;
 
 	if (address.sin_family != AF_INET)
 		return;
@@ -88,6 +181,90 @@ inet_print_address(sockaddr* _address)
 }
 
 
+static bool
+inet6_parse_address(const char* string, sockaddr* _address)
+{
+	sockaddr_in6& address = *(sockaddr_in6*)_address;
+
+	if (inet_pton(AF_INET6, string, &address.sin6_addr) != 1)
+		return false;
+
+	address.sin6_family = AF_INET6;
+	address.sin6_len = sizeof(sockaddr_in6);
+	address.sin6_port = 0;
+	address.sin6_flowinfo = 0;
+	address.sin6_scope_id = 0;
+
+	return true;
+}
+
+
+static bool
+inet6_prefix_length_to_mask(uint8 prefixLength, sockaddr* _mask)
+{
+	if (prefixLength > 128)
+		return false;
+
+	sockaddr_in6& mask = *(sockaddr_in6*)_mask;
+	mask.sin6_family = AF_INET6;
+	mask.sin6_len = sizeof(sockaddr_in6);
+	mask.sin6_port = 0;
+	mask.sin6_flowinfo = 0;
+	mask.sin6_scope_id = 0;
+	memset(mask.sin6_addr.s6_addr, 0, sizeof(in6_addr));
+
+	for (uint8 i = 0; i < sizeof(in6_addr); i++, prefixLength -= 8) {
+		if (prefixLength < 8) {
+			const uint8 masks[] = {
+				0x00, 0x80, 0xc0, 0xe0,
+				0xf0, 0xf8, 0xfc, 0xfe
+			};
+			mask.sin6_addr.s6_addr[i] = masks[prefixLength];
+			break;
+		}
+
+		mask.sin6_addr.s6_addr[i] = 0xff;
+	}
+
+	return true;
+}
+
+
+static uint8
+inet6_mask_to_prefix_length(sockaddr* _mask)
+{
+	sockaddr_in6& mask = *(sockaddr_in6*)_mask;
+	if (mask.sin6_family != AF_INET6)
+		return (uint8)~0;
+
+	uint8 result = 0;
+	for (uint8 i = 0; i < sizeof(in6_addr); i++) {
+		for (uint8 j = 0; j < 8; j++) {
+			if (!(mask.sin6_addr.s6_addr[i] & (1 << j)))
+				return result;
+			result++;
+		}
+	}
+
+	return 128;
+}
+
+
+static void
+inet6_print_address(sockaddr* _address)
+{
+	sockaddr_in6& address = *(sockaddr_in6*)_address;
+
+	if (address.sin6_family != AF_INET6)
+		return;
+
+	char buffer[INET6_ADDRSTRLEN];
+
+	printf("%s",
+		inet_ntop(AF_INET6, &address.sin6_addr, buffer, sizeof(buffer)));
+}
+
+
 //	#pragma mark -
 
 
@@ -181,12 +358,13 @@ usage(int status)
 			"auto-config] [<option/flags>...]]\n"
 		"\t%s --delete interface [...]\n\n"
 		"Where <option> can be the following:\n"
-		"  netmask <addr>   - networking subnet mask\n"
-		"  broadcast <addr> - set broadcast address\n"
-		"  peer <addr>      - ppp-peer address\n"
-		"  mtu <bytes>      - maximal transfer unit\n"
-		"  metric <number>  - metric number to use (defaults to 0)\n"
-		"  media <media>    - media type to use (defaults to auto)\n",
+		"  netmask <addr>     - networking subnet mask\n"
+		"  prefixlen <number> - subnet mask length in bits\n"
+		"  broadcast <addr>   - set broadcast address\n"
+		"  peer <addr>        - ppp-peer address\n"
+		"  mtu <bytes>        - maximal transfer unit\n"
+		"  metric <number>    - metric number to use (defaults to 0)\n"
+		"  media <media>      - media type to use (defaults to auto)\n",
 		kProgramName, kProgramName);
 	for (int32 i = 0; kMediaTypes[i].type >= 0; i++) {
 		printf("For %s <media> can be one of: ", kMediaTypes[i].pretty);
@@ -210,8 +388,8 @@ bool
 prepare_request(struct ifreq& request, const char* name)
 {
 	if (strlen(name) > IF_NAMESIZE) {
-		fprintf(stderr, "%s: interface name \"%s\" is too long.\n", kProgramName,
-			name);
+		fprintf(stderr, "%s: interface name \"%s\" is too long.\n",
+			kProgramName, name);
 		return false;
 	}
 
@@ -249,21 +427,102 @@ parse_address(int32 familyIndex, const char* argument, struct sockaddr& address)
 }
 
 
+bool
+prefix_length_to_mask(int32 familyIndex, const char* argument,
+	struct sockaddr& mask)
+{
+	if (argument == NULL)
+		return false;
+
+	char *end;
+	uint32 prefixLength = strtoul(argument, &end, 10);
+	if (end == argument)
+		return false;
+
+	return kFamilies[familyIndex].prefix_length_to_mask(
+		(uint8)prefixLength, &mask);
+}
+
+
 //	#pragma mark -
 
 
+int
+find_socket(struct ifreq& request, int addressFamily)
+{
+	int socket = -1;
+	bool socketExists = false;
+	bool ok = false;
+
+	for (int32 i = 0; kFamilies[i].family >= 0; i++) {
+		if (addressFamily != -1 && addressFamily != kFamilies[i].family)
+			continue;
+
+		socket = sAddressFamilySockets[i];
+		if (socket == -1)
+			continue;
+
+		socketExists = true;
+
+		if (ioctl(socket, SIOCGIFINDEX, &request, sizeof(request)) >= 0) {
+			ok = true;
+			break;
+		}
+	}
+
+	if (socketExists && !ok) {
+		fprintf(stderr, "%s: Interface \"%s\" does not exist.\n",
+			kProgramName, request.ifr_name);
+		return -1;
+	}
+
+	return socket;
+}
+
+
 void
-list_interface(int socket, const char* name)
+list_interface_address(int socket, const address_family* family,
+	uint32 flags, ifreq* request)
+{
+	if (ioctl(socket, SIOCGIFADDR, request, sizeof(struct ifreq)) < 0)
+		return;
+
+	printf("\t%s addr: ", family->name);
+	family->print_address(&request->ifr_addr);
+
+	if ((flags & IFF_BROADCAST) != 0
+		&& ioctl(socket, SIOCGIFBRDADDR, request, sizeof(struct ifreq)) == 0
+		&& request->ifr_broadaddr.sa_family == family->family) {
+		printf(", Bcast: ");
+		family->print_address(&request->ifr_broadaddr);
+	}
+	if (ioctl(socket, SIOCGIFNETMASK, request, sizeof(struct ifreq)) == 0
+		&& request->ifr_mask.sa_family == family->family) {
+		switch (family->preferred_format) {
+			case PREFER_OUTPUT_MASK:
+				printf(", Mask: ");
+				family->print_address(&request->ifr_mask);
+				break;
+			case PREFER_OUTPUT_PREFIX_LENGTH:
+				printf(", Prefix Length: %u",
+					family->mask_to_prefix_length(&request->ifr_mask));
+				break;
+		}
+	}
+	putchar('\n');
+}
+
+
+bool
+list_interface(const char* name, int addressFamily)
 {
 	ifreq request;
 	if (!prepare_request(request, name))
-		return;
+		return true;
 
-	if (ioctl(socket, SIOCGIFINDEX, &request, sizeof(request)) < 0) {
-		fprintf(stderr, "%s: Interface \"%s\" does not exist.\n", kProgramName,
-			name);
-		return;
-	}
+	int socket = find_socket(request, addressFamily);
+	if (socket == -1)
+		return false;
 
 	printf("%s", name);
 	size_t length = strlen(name);
@@ -286,7 +545,7 @@ list_interface(int socket, const char* name)
 			prepare_request(request, request.ifr_parameter.device);
 			if (ioctl(linkSocket, SIOCGIFADDR, &request, sizeof(struct ifreq))
 					== 0) {
-				sockaddr_dl &link = *(sockaddr_dl *)&request.ifr_addr;
+				sockaddr_dl &link = *(sockaddr_dl*)&request.ifr_addr;
 
 				switch (link.sdl_type) {
 					case IFT_ETHER:
@@ -294,7 +553,7 @@ list_interface(int socket, const char* name)
 						type = "Ethernet";
 
 						if (link.sdl_alen > 0) {
-							uint8 *mac = (uint8 *)LLADDR(&link);
+							uint8 *mac = (uint8*)LLADDR(&link);
 							sprintf(address, "%02x:%02x:%02x:%02x:%02x:%02x",
 								mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 						} else
@@ -348,29 +607,11 @@ list_interface(int socket, const char* name)
 		flags = request.ifr_flags;
 
 	for (int32 i = 0; kFamilies[i].family >= 0; i++) {
-		int familySocket = ::socket(kFamilies[i].family, SOCK_DGRAM, 0);
-		if (familySocket < 0)
-			continue;
-
-		if (ioctl(familySocket, SIOCGIFADDR, &request, sizeof(struct ifreq)) == 0) {
-			printf("\t%s addr: ", kFamilies[i].name);
-			kFamilies[i].print_address(&request.ifr_addr);
-
-			if ((flags & IFF_BROADCAST) != 0
-				&& ioctl(familySocket, SIOCGIFBRDADDR, &request, sizeof(struct ifreq)) == 0
-				&& request.ifr_broadaddr.sa_family == kFamilies[i].family) {
-				printf(", Bcast: ");
-				kFamilies[i].print_address(&request.ifr_broadaddr);
-			}
-			if (ioctl(familySocket, SIOCGIFNETMASK, &request, sizeof(struct ifreq)) == 0
-				&& request.ifr_mask.sa_family == kFamilies[i].family) {
-				printf(", Mask: ");
-				kFamilies[i].print_address(&request.ifr_mask);
-			}
-			putchar('\n');
+		int familySocket = sAddressFamilySockets[i];
+		if (familySocket != -1) {
+			list_interface_address(familySocket, &kFamilies[i],
+				flags, &request);
 		}
-
-		close(familySocket);
 	}
 
 	// Print MTU, metric, flags
@@ -434,19 +675,22 @@ list_interface(int socket, const char* name)
 	}
 
 	putchar('\n');
+	return true;
 }
 
 
 void
-list_interfaces(int socket, const char* name)
+list_interfaces(const char* name)
 {
 	if (name != NULL) {
-		list_interface(socket, name);
+		list_interface(name, -1);
 		return;
 	}
 
 	// get a list of all interfaces
 
+	int socket = sAddressFamilySockets[0];
+
 	ifconf config;
 	config.ifc_len = sizeof(config.ifc_value);
 	if (ioctl(socket, SIOCGIFCOUNT, &config, sizeof(struct ifconf)) < 0)
@@ -469,12 +713,13 @@ list_interfaces(int socket, const char* name)
 	if (ioctl(socket, SIOCGIFCONF, &config, sizeof(struct ifconf)) < 0)
 		return;
 
-	ifreq *interface = (ifreq *)buffer;
+	ifreq* interface = (ifreq*)buffer;
 
 	for (uint32 i = 0; i < count; i++) {
-		list_interface(socket, interface->ifr_name);
+		list_interface(interface->ifr_name, interface->ifr_addr.sa_family);
 
-		interface = (ifreq *)((addr_t)interface + IF_NAMESIZE + interface->ifr_addr.sa_len);
+		interface = (ifreq*)((addr_t)interface + IF_NAMESIZE
+			+ interface->ifr_addr.sa_len);
 	}
 
 	free(buffer);
@@ -482,12 +727,16 @@ list_interfaces(int socket, const char* name)
 
 
 void
-delete_interface(int socket, const char* name)
+delete_interface(const char* name)
 {
 	ifreq request;
 	if (!prepare_request(request, name))
 		return;
 
+	int socket = find_socket(request, -1);
+	if (socket == -1)
+		return;
+
 	if (ioctl(socket, SIOCDIFADDR, &request, sizeof(request)) < 0) {
 		fprintf(stderr, "%s: Could not delete interface %s: %s\n",
 			kProgramName, name, strerror(errno));
@@ -496,13 +745,27 @@ delete_interface(int socket, const char* name)
 
 
 void
-configure_interface(int socket, const char* name, char* const* args,
+configure_interface(const char* name, char* const* args,
 	int32 argCount)
 {
 	ifreq request;
 	if (!prepare_request(request, name))
 		return;
 
+	// try to parse address family
+
+	int32 familyIndex;
+	int32 i = 0;
+	if (get_address_family(args[i], familyIndex))
+		i++;
+
+	int socket = sAddressFamilySockets[familyIndex];
+	if (socket < 0) {
+		fprintf(stderr, "%s: Address family \"%s\" is not available.\n",
+			kProgramName, kFamilies[familyIndex].name);
+		exit(1);
+	}
+
 	uint32 index = 0;
 	if (ioctl(socket, SIOCGIFINDEX, &request, sizeof(request)) >= 0)
 		index = request.ifr_index;
@@ -513,25 +776,6 @@ configure_interface(int socket, const char* name, char* const* args,
 	int mtu = -1, metric = -1, media = -1;
 	int addFlags = 0, currentFlags = 0, removeFlags = 0;
 
-	// try to parse address family
-
-	int32 familyIndex;
-	int32 i = 0;
-	if (get_address_family(args[i], familyIndex))
-		i++;
-
-	if (kFamilies[familyIndex].family != AF_INET) {
-		close(socket);
-
-		// replace socket with one of the correct address family
-		socket = ::socket(kFamilies[familyIndex].family, SOCK_DGRAM, 0);
-		if (socket < 0) {
-			fprintf(stderr, "%s: Address family \"%s\" is not available.\n",
-				kProgramName, kFamilies[familyIndex].name);
-			exit(1);
-		}
-	}
-
 	if (index == 0) {
 		// the interface does not exist yet, we have to add it first
 		request.ifr_parameter.base_name[0] = '\0';
@@ -571,8 +815,8 @@ configure_interface(int socket, const char* name, char* const* args,
 			i++;
 		} else if (!strcmp(args[i], "nm") || !strcmp(args[i], "netmask")) {
 			if (hasMask) {
-				fprintf(stderr, "%s: Netmask is specified twice\n",
-					kProgramName);
+				fprintf(stderr, "%s: Netmask or prefix length is specified "
+					"twice\n", kProgramName);
 				exit(1);
 			}
 			if (!parse_address(familyIndex, args[i + 1], mask)) {
@@ -582,6 +826,20 @@ configure_interface(int socket, const char* name, char* const* args,
 			}
 			hasMask = true;
 			i++;
+		} else if (!strcmp(args[i], "prefixlen") 
+				|| !strcmp(args[i], "plen")) {
+			if (hasMask) {
+				fprintf(stderr, "%s: Netmask or prefix length is specified "
+					"twice\n", kProgramName);
+				exit(1);
+			}
+			if (!prefix_length_to_mask(familyIndex, args[i + 1], mask)) {
+				fprintf(stderr, "%s: Option 'prefixlen' is invalid for this "
+					"address family\n", kProgramName);
+				exit(1);
+			}
+			hasMask = true;
+			i++;
 		} else if (!strcmp(args[i], "bc") || !strcmp(args[i], "broadcast")) {
 			if (hasBroadcast) {
 				fprintf(stderr, "%s: broadcast address is specified twice\n",
@@ -761,6 +1019,7 @@ configure_interface(int socket, const char* name, char* const* args,
 		BMessage message(kMsgConfigureInterface);
 		message.AddString("device", name);
 		BMessage address;
+		// TODO: this is not working for ipv6 yet
 		address.AddString("family", "inet");
 		address.AddBool("auto_config", true);
 		message.AddMessage("address", &address);
@@ -807,9 +1066,7 @@ main(int argc, char** argv)
 		deleteInterfaces = true;
 	}
 
-	// we need a socket to talk to the networking stack
-	int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
-	if (socket < 0) {
+	if (initialize_address_families() == false) {
 		fprintf(stderr, "%s: The networking stack doesn't seem to be "
 			"available.\n", kProgramName);
 		return 1;
@@ -817,7 +1074,7 @@ main(int argc, char** argv)
 
 	if (deleteInterfaces) {
 		for (int i = 2; i < argc; i++) {
-			delete_interface(socket, argv[i]);
+			delete_interface(argv[i]);
 		}
 		return 0;
 	} else if (argc > 1 && !strcmp(argv[1], "-a")) {
@@ -825,7 +1082,7 @@ main(int argc, char** argv)
 		if (argc > 2)
 			usage(1);
 
-		list_interfaces(socket, NULL);
+		list_interfaces(NULL);
 		return 0;
 	}
 
@@ -833,13 +1090,13 @@ main(int argc, char** argv)
 	if (argc > 2) {
 		// add or configure an interface
 
-		configure_interface(socket, name, argv + 2, argc - 2);
+		configure_interface(name, argv + 2, argc - 2);
 		return 0;
 	}
 
 	// list interfaces
 
-	list_interfaces(socket, name);
+	list_interfaces(name);
 	return 0;
 }
 
diff --git a/src/bin/network/ping6/Jamfile b/src/bin/network/ping6/Jamfile
new file mode 100644
index 0000000000..4a9d01d66a
--- /dev/null
+++ b/src/bin/network/ping6/Jamfile
@@ -0,0 +1,29 @@
+SubDir HAIKU_TOP src bin network ping6 ;
+
+SetSubDirSupportedPlatforms $(HAIKU_BONE_COMPATIBLE_PLATFORMS) ;
+
+if ! $(TARGET_PLATFORM_HAIKU_COMPATIBLE) {
+	UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
+		# We need the public network headers also when not compiling for Haiku.
+		# Unfortunately we get more than we want, namely all POSIX headers.
+}
+
+BinCommand ping6 :
+	ping6.c
+	: $(TARGET_NETWORK_LIBS) $(TARGET_SELECT_UNAME_ETC_LIB) ;
+
+# Installation -- in the test directory for the time being
+HaikuInstall install-networking
+	: [ FDirName $(HAIKU_TEST_DIR) kits net ]
+	: ping6 ;
+
+HaikuInstall install-userland-networking 
+	: [ FDirName $(HAIKU_TEST_DIR) kits net userland ]
+	: ping6
+	: installed-userland-networking
+;
+
+Package haiku-networkingkit-cvs :
+	ping6 :
+	boot home Desktop haiku-networkingkit ;
+
diff --git a/src/bin/network/ping6/ping6.c b/src/bin/network/ping6/ping6.c
new file mode 100644
index 0000000000..ee7987c2d7
--- /dev/null
+++ b/src/bin/network/ping6/ping6.c
@@ -0,0 +1,2712 @@
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Mike Muuss.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Using the InterNet Control Message Protocol (ICMP) "ECHO" facility,
+ * measure round-trip-delays and packet loss across network paths.
+ *
+ * Author -
+ *	Mike Muuss
+ *	U. S. Army Ballistic Research Laboratory
+ *	December, 1983
+ *
+ * Status -
+ *	Public Domain.  Distribution Unlimited.
+ * Bugs -
+ *	More statistics could always be gathered.
+ *	This program has to run SUID to ROOT to access the ICMP socket.
+ */
+
+/*
+ * NOTE:
+ * USE_SIN6_SCOPE_ID assumes that sin6_scope_id has the same semantics
+ * as IPV6_PKTINFO.  Some people object it (sin6_scope_id specifies *link*
+ * while IPV6_PKTINFO specifies *interface*.  Link is defined as collection of
+ * network attached to 1 or more interfaces)
+ */
+#define USE_SIN6_SCOPE_ID 1
+
+#define USE_RFC2292BIS 1
+#define HAVE_POLL_H 1
+#define CMSG_SENDING_UNSUPPORTED 1
+#undef IPSEC
+#undef IPV6_OPTIONS
+
+#include <sys/param.h>
+#include <sys/uio.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+
+#include <net/if.h>
+#include <net/route.h>
+
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+#include <netinet/icmp6.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
+
+#ifdef IPSEC
+#include <netipsec/ah.h>
+#include <netipsec/ipsec.h>
+#endif
+
+struct tv32 {
+	u_int32_t tv32_sec;
+	u_int32_t tv32_usec;
+};
+
+#define	IP6LEN			40
+#define MAXPACKETLEN	(IPV6_MAXPACKET - IP6LEN) 
+#define ICMP6ECHOLEN	8	/* icmp echo header len excluding time */
+#define ICMP6ECHOTMLEN	sizeof(struct tv32)
+#define ICMP6_NIQLEN	(ICMP6ECHOLEN + 8)
+# define CONTROLLEN		10240	/* ancillary data buffer size RFC3542 20.1 */
+/* FQDN case, 64 bits of nonce + 32 bits ttl */
+#define ICMP6_NIRLEN	(ICMP6ECHOLEN + 12)
+#define	EXTRA		256	/* for AH and various other headers. weird. */
+#define	DEFDATALEN	ICMP6ECHOTMLEN
+#define MAXDATALEN	MAXPACKETLEN - IP6LEN - ICMP6ECHOLEN
+#define	NROUTES		9		/* number of record route slots */
+
+#define	A(bit)		rcvd_tbl[(bit)>>3]	/* identify byte in array */
+#define	B(bit)		(1 << ((bit) & 0x07))	/* identify bit in byte */
+#define	SET(bit)	(A(bit) |= B(bit))
+#define	CLR(bit)	(A(bit) &= (~B(bit)))
+#define	TST(bit)	(A(bit) & B(bit))
+
+#define	F_FLOOD		0x0001
+#define	F_INTERVAL	0x0002
+#define	F_PINGFILLED	0x0008
+#define	F_QUIET		0x0010
+#define	F_RROUTE	0x0020
+#define	F_SO_DEBUG	0x0040
+#define	F_VERBOSE	0x0100
+#ifdef IPSEC
+#ifdef IPSEC_POLICY_IPSEC
+#define	F_POLICY	0x0400
+#else
+#define F_AUTHHDR	0x0200
+#define F_ENCRYPT	0x0400
+#endif /*IPSEC_POLICY_IPSEC*/
+#endif /*IPSEC*/
+#define F_NODEADDR	0x0800
+#define F_FQDN		0x1000
+#define F_INTERFACE	0x2000
+#define F_SRCADDR	0x4000
+#define F_HOSTNAME	0x10000
+#define F_FQDNOLD	0x20000
+#define F_NIGROUP	0x40000
+#define F_SUPTYPES	0x80000
+#define F_NOMINMTU	0x100000
+#define F_ONCE		0x200000
+#define F_AUDIBLE	0x400000
+#define F_MISSED	0x800000
+#define F_NOUSERDATA	(F_NODEADDR | F_FQDN | F_FQDNOLD | F_SUPTYPES)
+u_int options;
+
+#define IN6LEN		sizeof(struct in6_addr)
+#define SA6LEN		sizeof(struct sockaddr_in6)
+#define DUMMY_PORT	10101
+
+#define SIN6(s)	((struct sockaddr_in6 *)(s))
+
+/*
+ * MAX_DUP_CHK is the number of bits in received table, i.e. the maximum
+ * number of received sequence numbers we can keep track of.  Change 128
+ * to 8192 for complete accuracy...
+ */
+#define	MAX_DUP_CHK	(8 * 8192)
+int mx_dup_ck = MAX_DUP_CHK;
+char rcvd_tbl[MAX_DUP_CHK / 8];
+
+struct addrinfo *res;
+struct sockaddr_in6 dst;	/* who to ping6 */
+struct sockaddr_in6 src;	/* src addr of this packet */
+socklen_t srclen;
+int datalen = DEFDATALEN;
+int s;				/* socket file descriptor */
+u_char outpack[MAXPACKETLEN];
+char BSPACE = '\b';		/* characters written for flood */
+char BBELL = '\a';		/* characters written for AUDIBLE */
+char DOT = '.';
+char *hostname;
+int ident;			/* process id to identify our packets */
+u_int8_t nonce[8];		/* nonce field for node information */
+int hoplimit = -1;		/* hoplimit */
+int pathmtu = 0;		/* path MTU for the destination.  0 = unspec. */
+
+/* counters */
+long nmissedmax;		/* max value of ntransmitted - nreceived - 1 */
+long npackets;			/* max packets to transmit */
+long nreceived;			/* # of packets we got back */
+long nrepeats;			/* number of duplicates */
+long ntransmitted;		/* sequence # for outbound packets = #sent */
+struct timeval interval = {1, 0}; /* interval between packets */
+
+/* timing */
+int timing;			/* flag to do timing */
+double tmin = 999999999.0;	/* minimum round trip time */
+double tmax = 0.0;		/* maximum round trip time */
+double tsum = 0.0;		/* sum of all times, for doing average */
+double tsumsq = 0.0;		/* sum of all times squared, for std. dev. */
+
+/* for node addresses */
+u_short naflags;
+
+/* for ancillary data(advanced API) */
+struct msghdr smsghdr;
+struct iovec smsgiov;
+char *scmsg = 0;
+
+volatile sig_atomic_t seenalrm;
+volatile sig_atomic_t seenint;
+#ifdef SIGINFO
+volatile sig_atomic_t seeninfo;
+#endif
+
+int	 main(int, char *[]);
+void	 fill(char *, char *);
+int	 get_hoplim(struct msghdr *);
+int	 get_pathmtu(struct msghdr *);
+struct in6_pktinfo *get_rcvpktinfo(struct msghdr *);
+void	 onsignal(int);
+void	 retransmit(void);
+void	 onint(int);
+size_t	 pingerlen(void);
+int	 pinger(void);
+const char *pr_addr(struct sockaddr *, int);
+void	 pr_icmph(struct icmp6_hdr *, u_char *);
+void	 pr_iph(struct ip6_hdr *);
+void	 pr_suptypes(struct icmp6_nodeinfo *, size_t);
+void	 pr_nodeaddr(struct icmp6_nodeinfo *, int);
+int	 myechoreply(const struct icmp6_hdr *);
+int	 mynireply(const struct icmp6_nodeinfo *);
+char *dnsdecode(const u_char **, const u_char *, const u_char *,
+	char *, size_t);
+void	 pr_pack(u_char *, int, struct msghdr *);
+void	 pr_exthdrs(struct msghdr *);
+void	 pr_ip6opt(void *, size_t);
+void	 pr_rthdr(void *, size_t);
+int	 pr_bitrange(u_int32_t, int, int);
+void	 pr_retip(struct ip6_hdr *, u_char *);
+void	 summary(void);
+void	 tvsub(struct timeval *, struct timeval *);
+int	 setpolicy(int, char *);
+char	*nigroup(char *);
+void	 usage(void);
+
+
+static void err(int exitval, char *where)
+{
+	printf("error: %s: error %d [%s]\n", where, errno, strerror(errno));
+	exit(exitval);
+}
+
+static void errx(int exitval, char *fmt_string, ...)
+{
+	va_list list;
+	va_start(list, fmt_string);
+	printf("error: ");
+	vprintf(fmt_string, list);
+	printf("\n");
+	va_end(list);
+	exit(exitval);
+}
+
+static void warn(char *where)
+{
+	printf("warning: %s: error %d [%s]\n", where, errno, strerror(errno));
+}
+
+static void warnx(char *fmt_string, ...)
+{
+	va_list list;
+	va_start(list, fmt_string);
+	printf("warning: ");
+	vprintf(fmt_string, list);
+	printf("\n");
+}
+
+
+int
+main(argc, argv)
+	int argc;
+	char *argv[];
+{
+	struct itimerval itimer;
+	struct sockaddr_in6 from;
+#ifndef HAVE_ARC4RANDOM
+	struct timeval seed;
+#endif
+#ifdef HAVE_POLL_H
+	int timeout;
+#else
+	struct timeval timeout, *tv;
+#endif
+	struct addrinfo hints;
+#ifdef HAVE_POLL_H
+	struct pollfd fdmaskp[1];
+#else
+	fd_set *fdmaskp;
+	int fdmasks;
+#endif
+	int cc, i;
+	int ch, hold, packlen, preload, optval, ret_ga;
+	u_char *datap, *packet;
+	char *e, *target, *ifname = NULL;
+	int ip6optlen = 0;
+	struct cmsghdr *scmsgp = NULL;
+	struct cmsghdr *cm;
+#if defined(SO_SNDBUF) && defined(SO_RCVBUF)
+	u_long lsockbufsize;
+	int sockbufsize = 0;
+#endif
+	int usepktinfo = 0;
+	struct in6_pktinfo *pktinfo = NULL;
+#ifdef IPSEC_POLICY_IPSEC
+	char *policy_in = NULL;
+	char *policy_out = NULL;
+#endif
+	double intval;
+#ifdef IPV6_USE_MIN_MTU
+	int mflag = 0;
+#endif
+
+	/* just to be sure */
+	memset(&smsghdr, 0, sizeof(smsghdr));
+	memset(&smsgiov, 0, sizeof(smsgiov));
+
+	preload = 0;
+	datap = &outpack[ICMP6ECHOLEN + ICMP6ECHOTMLEN];
+#ifndef IPSEC
+#define ADDOPTS
+#else
+#ifdef IPSEC_POLICY_IPSEC
+#define ADDOPTS	"P:"
+#else
+#define ADDOPTS	"AE"
+#endif /*IPSEC_POLICY_IPSEC*/
+#endif
+	while ((ch = getopt(argc, argv,
+	    "a:b:c:dfHh:I:i:l:mnop:qrRS:s:tvwW" ADDOPTS)) != -1) {
+#undef ADDOPTS
+		switch (ch) {
+		case 'a':
+		{
+			char *cp;
+
+			options &= ~F_NOUSERDATA;
+			options |= F_NODEADDR;
+			for (cp = optarg; *cp != '\0'; cp++) {
+				switch (*cp) {
+				case 'a':
+					naflags |= NI_NODEADDR_FLAG_ALL;
+					break;
+				case 'c':
+				case 'C':
+					naflags |= NI_NODEADDR_FLAG_COMPAT;
+					break;
+				case 'l':
+				case 'L':
+					naflags |= NI_NODEADDR_FLAG_LINKLOCAL;
+					break;
+				case 's':
+				case 'S':
+					naflags |= NI_NODEADDR_FLAG_SITELOCAL;
+					break;
+				case 'g':
+				case 'G':
+					naflags |= NI_NODEADDR_FLAG_GLOBAL;
+					break;
+				case 'A': /* experimental. not in the spec */
+#ifdef NI_NODEADDR_FLAG_ANYCAST
+					naflags |= NI_NODEADDR_FLAG_ANYCAST;
+					break;
+#else
+					errx(1,
+"-a A is not supported on the platform");
+					/*NOTREACHED*/
+#endif
+				default:
+					usage();
+					/*NOTREACHED*/
+				}
+			}
+			break;
+		}
+		case 'b':
+#if defined(SO_SNDBUF) && defined(SO_RCVBUF)
+			errno = 0;
+			e = NULL;
+			lsockbufsize = strtoul(optarg, &e, 10);
+			sockbufsize = lsockbufsize;
+			if (errno || !*optarg || *e ||
+			    sockbufsize != lsockbufsize)
+				errx(1, "invalid socket buffer size");
+#else
+			errx(1,
+"-b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported");
+#endif
+			break;
+		case 'c':
+			npackets = strtol(optarg, &e, 10);
+			if (npackets <= 0 || *optarg == '\0' || *e != '\0')
+				errx(1,
+				    "illegal number of packets -- %s", optarg);
+			break;
+		case 'd':
+			options |= F_SO_DEBUG;
+			break;
+		case 'f':
+			if (getuid()) {
+				errno = EPERM;
+				errx(1, "Must be superuser to flood ping");
+			}
+			options |= F_FLOOD;
+			setbuf(stdout, (char *)NULL);
+			break;
+#ifdef undefined
+		case 'g':
+			gateway = optarg;
+			break;
+#endif
+		case 'H':
+			options |= F_HOSTNAME;
+			break;
+		case 'h':		/* hoplimit */
+			hoplimit = strtol(optarg, &e, 10);
+			if (*optarg == '\0' || *e != '\0')
+				errx(1, "illegal hoplimit %s", optarg);
+			if (255 < hoplimit || hoplimit < -1)
+				errx(1,
+				    "illegal hoplimit -- %s", optarg);
+			break;
+		case 'I':
+			ifname = optarg;
+			options |= F_INTERFACE;
+#ifndef USE_SIN6_SCOPE_ID
+			usepktinfo++;
+#endif
+			break;
+		case 'i':		/* wait between sending packets */
+			intval = strtod(optarg, &e);
+			if (*optarg == '\0' || *e != '\0')
+				errx(1, "illegal timing interval %s", optarg);
+			if (intval < 1 && getuid()) {
+				errx(1, "%s: only root may use interval < 1s",
+				    strerror(EPERM));
+			}
+			interval.tv_sec = (long)intval;
+			interval.tv_usec =
+			    (long)((intval - interval.tv_sec) * 1000000);
+			if (interval.tv_sec < 0)
+				errx(1, "illegal timing interval %s", optarg);
+			/* less than 1/hz does not make sense */
+			if (interval.tv_sec == 0 && interval.tv_usec < 1) {
+				warnx("too small interval, raised to .000001");
+				interval.tv_usec = 1;
+			}
+			options |= F_INTERVAL;
+			break;
+		case 'l':
+			if (getuid()) {
+				errno = EPERM;
+				errx(1, "Must be superuser to preload");
+			}
+			preload = strtol(optarg, &e, 10);
+			if (preload < 0 || *optarg == '\0' || *e != '\0')
+				errx(1, "illegal preload value -- %s", optarg);
+			break;
+		case 'm':
+#ifdef IPV6_USE_MIN_MTU
+			mflag++;
+			break;
+#else
+			errx(1, "-%c is not supported on this platform", ch);
+			/*NOTREACHED*/
+#endif
+		case 'n':
+			options &= ~F_HOSTNAME;
+			break;
+#ifdef undefined
+		case 'N':
+			options |= F_NIGROUP;
+			break;
+#endif
+		case 'o':
+			options |= F_ONCE;
+			break;
+		case 'p':		/* fill buffer with user pattern */
+			options |= F_PINGFILLED;
+			fill((char *)datap, optarg);
+				break;
+		case 'q':
+			options |= F_QUIET;
+			break;
+		case 'r':
+			options |= F_AUDIBLE;
+			break;
+		case 'R':
+			options |= F_MISSED;
+			break;
+		case 'S':
+			memset(&hints, 0, sizeof(struct addrinfo));
+			hints.ai_flags = AI_NUMERICHOST; /* allow hostname? */
+			hints.ai_family = AF_INET6;
+			hints.ai_socktype = SOCK_RAW;
+			hints.ai_protocol = IPPROTO_ICMPV6;
+
+			ret_ga = getaddrinfo(optarg, NULL, &hints, &res);
+			if (ret_ga) {
+				errx(1, "invalid source address: %s",
+				     gai_strerror(ret_ga));
+			}
+			/*
+			 * res->ai_family must be AF_INET6 and res->ai_addrlen
+			 * must be sizeof(src).
+			 */
+			memcpy(&src, res->ai_addr, res->ai_addrlen);
+			srclen = res->ai_addrlen;
+			freeaddrinfo(res);
+			options |= F_SRCADDR;
+			break;
+		case 's':		/* size of packet to send */
+			datalen = strtol(optarg, &e, 10);
+			if (datalen <= 0 || *optarg == '\0' || *e != '\0')
+				errx(1, "illegal datalen value -- %s", optarg);
+			if (datalen > MAXDATALEN) {
+				errx(1,
+				    "datalen value too large, maximum is %d",
+				    MAXDATALEN);
+			}
+			break;
+		case 't':
+			options &= ~F_NOUSERDATA;
+			options |= F_SUPTYPES;
+			break;
+		case 'v':
+			options |= F_VERBOSE;
+			break;
+		case 'w':
+			options &= ~F_NOUSERDATA;
+			options |= F_FQDN;
+			break;
+		case 'W':
+			options &= ~F_NOUSERDATA;
+			options |= F_FQDNOLD;
+			break;
+#ifdef IPSEC
+#ifdef IPSEC_POLICY_IPSEC
+		case 'P':
+			options |= F_POLICY;
+			if (!strncmp("in", optarg, 2)) {
+				if ((policy_in = strdup(optarg)) == NULL)
+					errx(1, "strdup");
+			} else if (!strncmp("out", optarg, 3)) {
+				if ((policy_out = strdup(optarg)) == NULL)
+					errx(1, "strdup");
+			} else
+				errx(1, "invalid security policy");
+			break;
+#else
+		case 'A':
+			options |= F_AUTHHDR;
+			break;
+		case 'E':
+			options |= F_ENCRYPT;
+			break;
+#endif /*IPSEC_POLICY_IPSEC*/
+#endif /*IPSEC*/
+		default:
+			usage();
+			/*NOTREACHED*/
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc < 1) {
+		usage();
+		/*NOTREACHED*/
+	}
+
+#ifdef undefined
+	if (options & F_NIGROUP) {
+		target = nigroup(argv[argc - 1]);
+		if (target == NULL) {
+			usage();
+			/*NOTREACHED*/
+		}
+	} else
+#endif
+		target = argv[argc - 1];
+
+	/* getaddrinfo */
+	memset(&hints, 0, sizeof(struct addrinfo));
+	hints.ai_flags = AI_CANONNAME;
+	hints.ai_family = AF_INET6;
+	hints.ai_socktype = SOCK_RAW;
+	hints.ai_protocol = IPPROTO_ICMPV6;
+
+	ret_ga = getaddrinfo(target, NULL, &hints, &res);
+	if (ret_ga)
+		errx(1, "%s", gai_strerror(ret_ga));
+	if (res->ai_canonname)
+		hostname = res->ai_canonname;
+	else
+		hostname = target;
+
+	if (!res->ai_addr)
+		errx(1, "getaddrinfo failed");
+
+	(void)memcpy(&dst, res->ai_addr, res->ai_addrlen);
+
+	if ((s = socket(res->ai_family, res->ai_socktype,
+	    res->ai_protocol)) < 0)
+		err(1, "socket");
+
+	/* set the source address if specified. */
+	if ((options & F_SRCADDR) &&
+	    bind(s, (struct sockaddr *)&src, srclen) != 0) {
+		err(1, "bind");
+	}
+
+#ifdef undefined
+	/* set the gateway (next hop) if specified */
+	if (gateway) {
+		struct addrinfo ghints, *gres;
+		int error;
+
+		memset(&ghints, 0, sizeof(ghints));
+		ghints.ai_family = AF_INET6;
+		ghints.ai_socktype = SOCK_RAW;
+		ghints.ai_protocol = IPPROTO_ICMPV6;
+
+		error = getaddrinfo(gateway, NULL, &hints, &gres);
+		if (error) {
+			errx(1, "getaddrinfo for the gateway %s: %s",
+			     gateway, gai_strerror(error));
+		}
+		if (gres->ai_next && (options & F_VERBOSE))
+			warnx("gateway resolves to multiple addresses");
+
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_NEXTHOP,
+			       gres->ai_addr, gres->ai_addrlen)) {
+			err(1, "setsockopt(IPV6_NEXTHOP)");
+		}
+
+		freeaddrinfo(gres);
+	}
+#endif
+
+	/*
+	 * let the kerel pass extension headers of incoming packets,
+	 * for privileged socket options
+	 */
+	if ((options & F_VERBOSE) != 0) {
+		int opton = 1;
+
+#ifdef IPV6_RECVHOPOPTS
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPOPTS, &opton,
+		    sizeof(opton)))
+			err(1, "setsockopt(IPV6_RECVHOPOPTS)");
+#endif
+#ifdef IPV6_RECVDSTOPTS
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVDSTOPTS, &opton,
+		    sizeof(opton)))
+			err(1, "setsockopt(IPV6_RECVDSTOPTS)");
+#endif
+#ifdef IPV6_RECVRTHDRDSTOPTS
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVRTHDRDSTOPTS, &opton,
+		    sizeof(opton)))
+			err(1, "setsockopt(IPV6_RECVRTHDRDSTOPTS)");
+#endif
+	}
+
+	if ((options & F_FLOOD) && (options & F_INTERVAL))
+		errx(1, "-f and -i incompatible options");
+
+	if ((options & F_NOUSERDATA) == 0) {
+		if (datalen >= sizeof(struct tv32)) {
+			/* we can time transfer */
+			timing = 1;
+		} else
+			timing = 0;
+		/* in F_VERBOSE case, we may get non-echoreply packets*/
+		if (options & F_VERBOSE)
+			packlen = 2048 + IP6LEN + ICMP6ECHOLEN + EXTRA;
+		else
+			packlen = datalen + IP6LEN + ICMP6ECHOLEN + EXTRA;
+	} else {
+		/* suppress timing for node information query */
+		timing = 0;
+		datalen = 2048;
+		packlen = 2048 + IP6LEN + ICMP6ECHOLEN + EXTRA;
+	}
+
+	if (!(packet = (u_char *)malloc((u_int)packlen)))
+		err(1, "Unable to allocate packet");
+	if (!(options & F_PINGFILLED))
+		for (i = ICMP6ECHOLEN; i < packlen; ++i)
+			*datap++ = i;
+
+	ident = getpid() & 0xFFFF;
+#ifndef HAVE_ARC4RANDOM
+	gettimeofday(&seed, NULL);
+	srand((unsigned int)(seed.tv_sec ^ seed.tv_usec ^ (long)ident));
+	memset(nonce, 0, sizeof(nonce));
+	for (i = 0; i < sizeof(nonce); i += sizeof(int))
+		*((int *)&nonce[i]) = rand();
+#else
+	memset(nonce, 0, sizeof(nonce));
+	for (i = 0; i < sizeof(nonce); i += sizeof(u_int32_t))
+		*((u_int32_t *)&nonce[i]) = arc4random();
+#endif
+
+	hold = 1;
+
+	if (options & F_SO_DEBUG)
+		(void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&hold,
+		    sizeof(hold));
+	optval = IPV6_DEFHLIM;
+	if (IN6_IS_ADDR_MULTICAST(&dst.sin6_addr))
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "IPV6_MULTICAST_HOPS");
+#ifdef IPV6_USE_MIN_MTU
+	if (mflag != 1) {
+		optval = mflag > 1 ? 0 : 1;
+
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_USE_MIN_MTU,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "setsockopt(IPV6_USE_MIN_MTU)");
+	}
+#ifdef IPV6_RECVPATHMTU
+	else {
+		optval = 1;
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPATHMTU,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "setsockopt(IPV6_RECVPATHMTU)");
+	}
+#endif /* IPV6_RECVPATHMTU */
+#endif /* IPV6_USE_MIN_MTU */
+
+#ifdef IPSEC
+#ifdef IPSEC_POLICY_IPSEC
+	if (options & F_POLICY) {
+		if (setpolicy(s, policy_in) < 0)
+			errx(1, "%s", ipsec_strerror());
+		if (setpolicy(s, policy_out) < 0)
+			errx(1, "%s", ipsec_strerror());
+	}
+#else
+	if (options & F_AUTHHDR) {
+		optval = IPSEC_LEVEL_REQUIRE;
+#ifdef IPV6_AUTH_TRANS_LEVEL
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_AUTH_TRANS_LEVEL,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "setsockopt(IPV6_AUTH_TRANS_LEVEL)");
+#else /* old def */
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_AUTH_LEVEL,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "setsockopt(IPV6_AUTH_LEVEL)");
+#endif
+	}
+	if (options & F_ENCRYPT) {
+		optval = IPSEC_LEVEL_REQUIRE;
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_ESP_TRANS_LEVEL,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "setsockopt(IPV6_ESP_TRANS_LEVEL)");
+	}
+#endif /*IPSEC_POLICY_IPSEC*/
+#endif
+
+#ifdef ICMP6_FILTER
+    {
+	struct icmp6_filter filt;
+	if (!(options & F_VERBOSE)) {
+		ICMP6_FILTER_SETBLOCKALL(&filt);
+		if ((options & F_FQDN) || (options & F_FQDNOLD) ||
+		    (options & F_NODEADDR) || (options & F_SUPTYPES))
+			ICMP6_FILTER_SETPASS(ICMP6_NI_REPLY, &filt);
+		else
+			ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filt);
+	} else {
+		ICMP6_FILTER_SETPASSALL(&filt);
+	}
+	if (setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, &filt,
+	    sizeof(filt)) < 0)
+		err(1, "setsockopt(ICMP6_FILTER)");
+    }
+#endif /*ICMP6_FILTER*/
+
+	/* let the kerel pass extension headers of incoming packets */
+	if ((options & F_VERBOSE) != 0) {
+		int opton = 1;
+
+#ifdef IPV6_RECVRTHDR
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVRTHDR, &opton,
+		    sizeof(opton)))
+			err(1, "setsockopt(IPV6_RECVRTHDR)");
+#endif
+	}
+
+/*
+	optval = 1;
+	if (IN6_IS_ADDR_MULTICAST(&dst.sin6_addr))
+		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+		    &optval, sizeof(optval)) == -1)
+			err(1, "IPV6_MULTICAST_LOOP");
+*/
+
+	/* Specify the outgoing interface and/or the source address */
+	if (usepktinfo)
+		ip6optlen += CMSG_SPACE(sizeof(struct in6_pktinfo));
+
+	if (hoplimit != -1)
+		ip6optlen += CMSG_SPACE(sizeof(int));
+
+	/* set IP6 packet options */
+	if (ip6optlen) {
+		if ((scmsg = (char *)malloc(ip6optlen)) == 0)
+			errx(1, "can't allocate enough memory");
+		smsghdr.msg_control = (caddr_t)scmsg;
+		smsghdr.msg_controllen = ip6optlen;
+		scmsgp = (struct cmsghdr *)scmsg;
+	}
+	if (usepktinfo) {
+		pktinfo = (struct in6_pktinfo *)(CMSG_DATA(scmsgp));
+		memset(pktinfo, 0, sizeof(*pktinfo));
+		scmsgp->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
+		scmsgp->cmsg_level = IPPROTO_IPV6;
+		scmsgp->cmsg_type = IPV6_PKTINFO;
+		scmsgp = CMSG_NXTHDR(&smsghdr, scmsgp);
+	}
+
+	/* set the outgoing interface */
+	if (ifname) {
+#ifndef USE_SIN6_SCOPE_ID
+		/* pktinfo must have already been allocated */
+		if ((pktinfo->ipi6_ifindex = if_nametoindex(ifname)) == 0)
+			errx(1, "%s: invalid interface name", ifname);
+#else
+		if ((dst.sin6_scope_id = if_nametoindex(ifname)) == 0)
+			errx(1, "%s: invalid interface name", ifname);
+#endif
+	}
+	if (hoplimit != -1) {
+		scmsgp->cmsg_len = CMSG_LEN(sizeof(int));
+		scmsgp->cmsg_level = IPPROTO_IPV6;
+		scmsgp->cmsg_type = IPV6_HOPLIMIT;
+		*(int *)(CMSG_DATA(scmsgp)) = hoplimit;
+
+		scmsgp = CMSG_NXTHDR(&smsghdr, scmsgp);
+	}
+
+	if (!(options & F_SRCADDR)) {
+		/*
+		 * get the source address. XXX since we revoked the root
+		 * privilege, we cannot use a raw socket for this.
+		 */
+		int dummy;
+		socklen_t len = sizeof(src);
+
+		if ((dummy = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
+			err(1, "UDP socket");
+
+		src.sin6_family = AF_INET6;
+		src.sin6_addr = dst.sin6_addr;
+		src.sin6_port = ntohs(DUMMY_PORT);
+		src.sin6_scope_id = dst.sin6_scope_id;
+
+#ifdef USE_RFC2292BIS
+		if (pktinfo &&
+		    setsockopt(dummy, IPPROTO_IPV6, IPV6_PKTINFO,
+		    (void *)pktinfo, sizeof(*pktinfo)))
+			err(1, "UDP setsockopt(IPV6_PKTINFO)");
+
+		if (hoplimit != -1 &&
+		    setsockopt(dummy, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
+		    (void *)&hoplimit, sizeof(hoplimit)))
+			err(1, "UDP setsockopt(IPV6_UNICAST_HOPS)");
+
+		if (hoplimit != -1 &&
+		    setsockopt(dummy, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
+		    (void *)&hoplimit, sizeof(hoplimit)))
+			err(1, "UDP setsockopt(IPV6_MULTICAST_HOPS)");
+
+#else  /* old advanced API */
+		if (smsghdr.msg_control &&
+		    setsockopt(dummy, IPPROTO_IPV6, IPV6_PKTOPTIONS,
+		    (void *)smsghdr.msg_control, smsghdr.msg_controllen))
+			err(1, "UDP setsockopt(IPV6_PKTOPTIONS)");
+#endif
+
+		if (connect(dummy, (struct sockaddr *)&src, len) < 0)
+			err(1, "UDP connect");
+
+		if (getsockname(dummy, (struct sockaddr *)&src, &len) < 0)
+			err(1, "getsockname");
+
+		close(dummy);
+	}
+
+#if defined(SO_SNDBUF) && defined(SO_RCVBUF)
+	if (sockbufsize) {
+		if (datalen > sockbufsize)
+			warnx("you need -b to increase socket buffer size");
+		if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sockbufsize,
+		    sizeof(sockbufsize)) < 0)
+			err(1, "setsockopt(SO_SNDBUF)");
+		if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &sockbufsize,
+		    sizeof(sockbufsize)) < 0)
+			err(1, "setsockopt(SO_RCVBUF)");
+	}
+	else {
+		if (datalen > 8 * 1024)	/*XXX*/
+			warnx("you need -b to increase socket buffer size");
+		/*
+		 * When pinging the broadcast address, you can get a lot of
+		 * answers. Doing something so evil is useful if you are trying
+		 * to stress the ethernet, or just want to fill the arp cache
+		 * to get some stuff for /etc/ethers.
+		 */
+		hold = 48 * 1024;
+		setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&hold,
+		    sizeof(hold));
+	}
+#endif
+
+	optval = 1;
+//#ifndef USE_SIN6_SCOPE_ID
+#ifdef IPV6_RECVPKTINFO
+	if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, &optval,
+	    sizeof(optval)) < 0)
+		warn("setsockopt(IPV6_RECVPKTINFO)"); /* XXX err? */
+#else  /* old adv. API */
+	if (setsockopt(s, IPPROTO_IPV6, IPV6_PKTINFO, &optval,
+	    sizeof(optval)) < 0)
+		warn("setsockopt(IPV6_PKTINFO)"); /* XXX err? */
+#endif
+//#endif /* USE_SIN6_SCOPE_ID */
+#ifdef IPV6_RECVHOPLIMIT
+	if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &optval,
+	    sizeof(optval)) < 0)
+		warn("setsockopt(IPV6_RECVHOPLIMIT)"); /* XXX err? */
+#else  /* old adv. API */
+	if (setsockopt(s, IPPROTO_IPV6, IPV6_HOPLIMIT, &optval,
+	    sizeof(optval)) < 0)
+		warn("setsockopt(IPV6_HOPLIMIT)"); /* XXX err? */
+#endif
+
+	if (hoplimit != -1 &&
+		setsockopt(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
+			(void *)&hoplimit, sizeof(hoplimit)))
+		err(1, "setsockopt(IPV6_UNICAST_HOPS)");
+
+	if (hoplimit != -1 &&
+		setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
+			(void *)&hoplimit, sizeof(hoplimit)))
+		err(1, "setsockopt(IPV6_MULTICAST_HOPS)");
+
+
+	printf("PING6(%lu=40+8+%lu bytes) ", (unsigned long)(40 + pingerlen()),
+	    (unsigned long)(pingerlen() - 8));
+	printf("%s --> ", pr_addr((struct sockaddr *)&src, sizeof(src)));
+	printf("%s\n", pr_addr((struct sockaddr *)&dst, sizeof(dst)));
+
+	while (preload--)		/* Fire off them quickies. */
+		(void)pinger();
+
+	(void)signal(SIGINT, onsignal);
+#ifdef SIGINFO
+	(void)signal(SIGINFO, onsignal);
+#endif
+
+	if ((options & F_FLOOD) == 0) {
+		(void)signal(SIGALRM, onsignal);
+		itimer.it_interval = interval;
+		itimer.it_value = interval;
+		(void)setitimer(ITIMER_REAL, &itimer, NULL);
+		if (ntransmitted == 0)
+			retransmit();
+	}
+
+#ifndef HAVE_POLL_H
+	fdmasks = howmany(s + 1, NFDBITS) * sizeof(fd_mask);
+	if ((fdmaskp = malloc(fdmasks)) == NULL)
+		err(1, "malloc");
+#endif
+
+	seenalrm = seenint = 0;
+#ifdef SIGINFO
+	seeninfo = 0;
+#endif
+
+	/* For control (ancillary) data received from recvmsg() */
+	cm = (struct cmsghdr *)malloc(CONTROLLEN);
+	if (cm == NULL)
+		err(1, "malloc");
+
+	for (;;) {
+		struct msghdr m;
+		struct iovec iov[2];
+
+		/* signal handling */
+		if (seenalrm) {
+			/* last packet sent, timeout reached? */
+			if (npackets && ntransmitted >= npackets)
+				break;
+			retransmit();
+			seenalrm = 0;
+			continue;
+		}
+		if (seenint) {
+			onint(SIGINT);
+			seenint = 0;
+			continue;
+		}
+#ifdef SIGINFO
+		if (seeninfo) {
+			summary();
+			seeninfo = 0;
+			continue;
+		}
+#endif
+
+		if (options & F_FLOOD) {
+			(void)pinger();
+#ifdef HAVE_POLL_H
+			timeout = 10;
+#else
+			timeout.tv_sec = 0;
+			timeout.tv_usec = 10000;
+			tv = &timeout;
+#endif
+		} else {
+#ifdef HAVE_POLL_H
+			timeout = -1;
+#else
+			tv = NULL;
+#endif
+		}
+#ifdef HAVE_POLL_H
+		fdmaskp[0].fd = s;
+		fdmaskp[0].events = POLLIN;
+		cc = poll(fdmaskp, 1, timeout);
+#else
+		memset(fdmaskp, 0, fdmasks);
+		FD_SET(s, fdmaskp);
+		cc = select(s + 1, fdmaskp, NULL, NULL, tv);
+#endif
+		if (cc < 0) {
+			if (errno != EINTR) {
+#ifdef HAVE_POLL_H
+				warn("poll");
+#else
+				warn("select");
+#endif
+				sleep(1);
+			}
+			continue;
+		} else if (cc == 0)
+			continue;
+
+		m.msg_name = (caddr_t)&from;
+		m.msg_namelen = sizeof(from);
+		memset(&iov, 0, sizeof(iov));
+		iov[0].iov_base = (caddr_t)packet;
+		iov[0].iov_len = packlen;
+		m.msg_iov = iov;
+		m.msg_iovlen = 1;
+		memset(cm, 0, CONTROLLEN);
+		m.msg_control = (void *)cm;
+		m.msg_controllen = CONTROLLEN;
+
+		cc = recvmsg(s, &m, 0);
+		if (cc < 0) {
+			if (errno != EINTR) {
+				warn("recvmsg");
+				sleep(1);
+			}
+			continue;
+		} else if (cc == 0) {
+			int mtu;
+
+			/*
+			 * receive control messages only. Process the
+			 * exceptions (currently the only possiblity is
+			 * a path MTU notification.)
+			 */
+			if ((mtu = get_pathmtu(&m)) > 0) {
+				if ((options & F_VERBOSE) != 0) {
+					printf("new path MTU (%d) is "
+					    "notified\n", mtu);
+				}
+			}
+			continue;
+		} else {
+			/*
+			 * an ICMPv6 message (probably an echoreply) arrived.
+			 */
+			pr_pack(packet, cc, &m);
+		}
+		if (((options & F_ONCE) != 0 && nreceived > 0) ||
+		    (npackets > 0 && nreceived >= npackets))
+			break;
+		if (ntransmitted - nreceived - 1 > nmissedmax) {
+			nmissedmax = ntransmitted - nreceived - 1;
+			if (options & F_MISSED)
+				(void)write(STDOUT_FILENO, &BBELL, 1);
+		}
+	}
+	summary();
+	exit(nreceived == 0 ? 2 : 0);
+}
+
+void
+onsignal(sig)
+	int sig;
+{
+
+	switch (sig) {
+	case SIGALRM:
+		seenalrm++;
+		break;
+	case SIGINT:
+		seenint++;
+		break;
+#ifdef SIGINFO
+	case SIGINFO:
+		seeninfo++;
+		break;
+#endif
+	}
+}
+
+/*
+ * retransmit --
+ *	This routine transmits another ping6.
+ */
+void
+retransmit()
+{
+	struct itimerval itimer;
+
+	if (pinger() == 0)
+		return;
+
+	/*
+	 * If we're not transmitting any more packets, change the timer
+	 * to wait two round-trip times if we've received any packets or
+	 * ten seconds if we haven't.
+	 */
+#define	MAXWAIT		10
+	if (nreceived) {
+		itimer.it_value.tv_sec =  2 * tmax / 1000;
+		if (itimer.it_value.tv_sec == 0)
+			itimer.it_value.tv_sec = 1;
+	} else
+		itimer.it_value.tv_sec = MAXWAIT;
+	itimer.it_interval.tv_sec = 0;
+	itimer.it_interval.tv_usec = 0;
+	itimer.it_value.tv_usec = 0;
+
+	(void)signal(SIGALRM, onsignal);
+	(void)setitimer(ITIMER_REAL, &itimer, NULL);
+}
+
+/*
+ * pinger --
+ *	Compose and transmit an ICMP ECHO REQUEST packet.  The IP packet
+ * will be added on by the kernel.  The ID field is our UNIX process ID,
+ * and the sequence number is an ascending integer.  The first 8 bytes
+ * of the data portion are used to hold a UNIX "timeval" struct in VAX
+ * byte-order, to compute the round-trip time.
+ */
+size_t
+pingerlen()
+{
+	size_t l;
+
+	if (options & F_FQDN)
+		l = ICMP6_NIQLEN + sizeof(dst.sin6_addr);
+	else if (options & F_FQDNOLD)
+		l = ICMP6_NIQLEN;
+	else if (options & F_NODEADDR)
+		l = ICMP6_NIQLEN + sizeof(dst.sin6_addr);
+	else if (options & F_SUPTYPES)
+		l = ICMP6_NIQLEN;
+	else
+		l = ICMP6ECHOLEN + datalen;
+
+	return l;
+}
+
+int
+pinger()
+{
+	struct icmp6_hdr *icp;
+	struct iovec iov[2];
+	int i, cc;
+	struct icmp6_nodeinfo *nip;
+	int seq;
+
+	if (npackets && ntransmitted >= npackets)
+		return(-1);	/* no more transmission */
+
+	icp = (struct icmp6_hdr *)outpack;
+	nip = (struct icmp6_nodeinfo *)outpack;
+	memset(icp, 0, sizeof(*icp));
+	icp->icmp6_cksum = 0;
+	seq = ntransmitted++;
+	CLR(seq % mx_dup_ck);
+
+	if (options & F_FQDN) {
+		icp->icmp6_type = ICMP6_NI_QUERY;
+		icp->icmp6_code = ICMP6_NI_SUBJ_IPV6;
+		nip->ni_qtype = htons(NI_QTYPE_FQDN);
+		nip->ni_flags = htons(0);
+
+		memcpy(nip->icmp6_ni_nonce, nonce,
+		    sizeof(nip->icmp6_ni_nonce));
+		*(u_int16_t *)nip->icmp6_ni_nonce = ntohs(seq);
+
+		memcpy(&outpack[ICMP6_NIQLEN], &dst.sin6_addr,
+		    sizeof(dst.sin6_addr));
+		cc = ICMP6_NIQLEN + sizeof(dst.sin6_addr);
+		datalen = 0;
+	} else if (options & F_FQDNOLD) {
+		/* packet format in 03 draft - no Subject data on queries */
+		icp->icmp6_type = ICMP6_NI_QUERY;
+		icp->icmp6_code = 0;	/* code field is always 0 */
+		nip->ni_qtype = htons(NI_QTYPE_FQDN);
+		nip->ni_flags = htons(0);
+
+		memcpy(nip->icmp6_ni_nonce, nonce,
+		    sizeof(nip->icmp6_ni_nonce));
+		*(u_int16_t *)nip->icmp6_ni_nonce = ntohs(seq);
+
+		cc = ICMP6_NIQLEN;
+		datalen = 0;
+	} else if (options & F_NODEADDR) {
+		icp->icmp6_type = ICMP6_NI_QUERY;
+		icp->icmp6_code = ICMP6_NI_SUBJ_IPV6;
+		nip->ni_qtype = htons(NI_QTYPE_NODEADDR);
+		nip->ni_flags = naflags;
+
+		memcpy(nip->icmp6_ni_nonce, nonce,
+		    sizeof(nip->icmp6_ni_nonce));
+		*(u_int16_t *)nip->icmp6_ni_nonce = ntohs(seq);
+
+		memcpy(&outpack[ICMP6_NIQLEN], &dst.sin6_addr,
+		    sizeof(dst.sin6_addr));
+		cc = ICMP6_NIQLEN + sizeof(dst.sin6_addr);
+		datalen = 0;
+	} else if (options & F_SUPTYPES) {
+		icp->icmp6_type = ICMP6_NI_QUERY;
+		icp->icmp6_code = ICMP6_NI_SUBJ_FQDN;	/*empty*/
+		nip->ni_qtype = htons(NI_QTYPE_SUPTYPES);
+		/* we support compressed bitmap */
+		nip->ni_flags = NI_SUPTYPE_FLAG_COMPRESS;
+
+		memcpy(nip->icmp6_ni_nonce, nonce,
+		    sizeof(nip->icmp6_ni_nonce));
+		*(u_int16_t *)nip->icmp6_ni_nonce = ntohs(seq);
+		cc = ICMP6_NIQLEN;
+		datalen = 0;
+	} else {
+		icp->icmp6_type = ICMP6_ECHO_REQUEST;
+		icp->icmp6_code = 0;
+		icp->icmp6_id = htons(ident);
+		icp->icmp6_seq = ntohs(seq);
+		if (timing) {
+			struct timeval tv;
+			struct tv32 *tv32;
+			(void)gettimeofday(&tv, NULL);
+			tv32 = (struct tv32 *)&outpack[ICMP6ECHOLEN];
+			tv32->tv32_sec = htonl(tv.tv_sec);
+			tv32->tv32_usec = htonl(tv.tv_usec);
+		}
+		cc = ICMP6ECHOLEN + datalen;
+	}
+
+#ifdef DIAGNOSTIC
+	if (pingerlen() != cc)
+		errx(1, "internal error; length mismatch");
+#endif
+
+	smsghdr.msg_name = (caddr_t)&dst;
+	smsghdr.msg_namelen = sizeof(dst);
+	memset(&iov, 0, sizeof(iov));
+	iov[0].iov_base = (caddr_t)outpack;
+	iov[0].iov_len = cc;
+	smsghdr.msg_iov = iov;
+	smsghdr.msg_iovlen = 1;
+
+#ifdef CMSG_SENDING_UNSUPPORTED
+	smsghdr.msg_control = NULL;
+	smsghdr.msg_controllen = 0;
+#endif
+
+	i = sendmsg(s, &smsghdr, 0);
+
+	if (i < 0 || i != cc)  {
+		if (i < 0)
+			warn("sendmsg");
+		(void)printf("ping6: wrote %s %d chars, ret=%d\n",
+		    hostname, cc, i);
+	}
+	if (!(options & F_QUIET) && options & F_FLOOD)
+		(void)write(STDOUT_FILENO, &DOT, 1);
+
+	return(0);
+}
+
+int
+myechoreply(icp)
+	const struct icmp6_hdr *icp;
+{
+	if (ntohs(icp->icmp6_id) == ident)
+		return 1;
+	else
+		return 0;
+}
+
+int
+mynireply(nip)
+	const struct icmp6_nodeinfo *nip;
+{
+	if (memcmp(nip->icmp6_ni_nonce + sizeof(u_int16_t),
+	    nonce + sizeof(u_int16_t),
+	    sizeof(nonce) - sizeof(u_int16_t)) == 0)
+		return 1;
+	else
+		return 0;
+}
+
+char *
+dnsdecode(sp, ep, base, buf, bufsiz)
+	const u_char **sp;
+	const u_char *ep;
+	const u_char *base;	/*base for compressed name*/
+	char *buf;
+	size_t bufsiz;
+{
+	int i;
+	const u_char *cp;
+	char cresult[MAXDNAME + 1];
+	const u_char *comp;
+	int l;
+
+	cp = *sp;
+	*buf = '\0';
+
+	if (cp >= ep)
+		return NULL;
+	while (cp < ep) {
+		i = *cp;
+		if (i == 0 || cp != *sp) {
+			if (strlcat((char *)buf, ".", bufsiz) >= bufsiz)
+				return NULL;	/*result overrun*/
+		}
+		if (i == 0)
+			break;
+		cp++;
+
+		if ((i & 0xc0) == 0xc0 && cp - base > (i & 0x3f)) {
+			/* DNS compression */
+			if (!base)
+				return NULL;
+
+			comp = base + (i & 0x3f);
+			if (dnsdecode(&comp, cp, base, cresult,
+			    sizeof(cresult)) == NULL)
+				return NULL;
+			if (strlcat(buf, cresult, bufsiz) >= bufsiz)
+				return NULL;	/*result overrun*/
+			break;
+		} else if ((i & 0x3f) == i) {
+			if (i > ep - cp)
+				return NULL;	/*source overrun*/
+			while (i-- > 0 && cp < ep) {
+				l = snprintf(cresult, sizeof(cresult),
+				    isprint(*cp) ? "%c" : "\\%03o", *cp & 0xff);
+				if (l >= sizeof(cresult) || l < 0)
+					return NULL;
+				if (strlcat(buf, cresult, bufsiz) >= bufsiz)
+					return NULL;	/*result overrun*/
+				cp++;
+			}
+		} else
+			return NULL;	/*invalid label*/
+	}
+	if (i != 0)
+		return NULL;	/*not terminated*/
+	cp++;
+	*sp = cp;
+	return buf;
+}
+
+/*
+ * pr_pack --
+ *	Print out the packet, if it came from us.  This logic is necessary
+ * because ALL readers of the ICMP socket get a copy of ALL ICMP packets
+ * which arrive ('tis only fair).  This permits multiple copies of this
+ * program to be run without having intermingled output (or statistics!).
+ */
+void
+pr_pack(buf, cc, mhdr)
+	u_char *buf;
+	int cc;
+	struct msghdr *mhdr;
+{
+#define safeputc(c)	printf((isprint((c)) ? "%c" : "\\%03o"), c)
+	struct icmp6_hdr *icp;
+	struct icmp6_nodeinfo *ni;
+	int i;
+	int hoplim;
+	struct sockaddr *from;
+	int fromlen;
+	u_char *cp = NULL, *dp, *end = buf + cc;
+	struct in6_pktinfo *pktinfo = NULL;
+	struct timeval tv, tp;
+	struct tv32 *tpp;
+	double triptime = 0;
+	int dupflag;
+	size_t off;
+	int oldfqdn;
+	u_int16_t seq;
+	char dnsname[MAXDNAME + 1];
+
+	(void)gettimeofday(&tv, NULL);
+
+	if (!mhdr || !mhdr->msg_name ||
+	    mhdr->msg_namelen != sizeof(struct sockaddr_in6) ||
+	    ((struct sockaddr *)mhdr->msg_name)->sa_family != AF_INET6) {
+		if (options & F_VERBOSE)
+			warnx("invalid peername");
+		return;
+	}
+	from = (struct sockaddr *)mhdr->msg_name;
+	fromlen = mhdr->msg_namelen;
+	if (cc < sizeof(struct icmp6_hdr)) {
+		if (options & F_VERBOSE)
+			warnx("packet too short (%d bytes) from %s", cc,
+			    pr_addr(from, fromlen));
+		return;
+	}
+	if (((mhdr->msg_flags & MSG_CTRUNC) != 0) &&
+	    (options & F_VERBOSE) != 0)
+		warnx("some control data discarded, insufficient buffer size");
+	icp = (struct icmp6_hdr *)buf;
+	ni = (struct icmp6_nodeinfo *)buf;
+	off = 0;
+
+	if ((hoplim = get_hoplim(mhdr)) == -1) {
+		warnx("failed to get receiving hop limit");
+		return;
+	}
+	if ((pktinfo = get_rcvpktinfo(mhdr)) == NULL) {
+		warnx("failed to get receiving packet information");
+		return;
+	}
+
+	if (icp->icmp6_type == ICMP6_ECHO_REPLY && myechoreply(icp)) {
+		seq = ntohs(icp->icmp6_seq);
+		++nreceived;
+		if (timing) {
+			tpp = (struct tv32 *)(icp + 1);
+			tp.tv_sec = ntohl(tpp->tv32_sec);
+			tp.tv_usec = ntohl(tpp->tv32_usec);
+			tvsub(&tv, &tp);
+			triptime = ((double)tv.tv_sec) * 1000.0 +
+			    ((double)tv.tv_usec) / 1000.0;
+			tsum += triptime;
+			tsumsq += triptime * triptime;
+			if (triptime < tmin)
+				tmin = triptime;
+			if (triptime > tmax)
+				tmax = triptime;
+		}
+
+		if (TST(seq % mx_dup_ck)) {
+			++nrepeats;
+			--nreceived;
+			dupflag = 1;
+		} else {
+			SET(seq % mx_dup_ck);
+			dupflag = 0;
+		}
+
+		if (options & F_QUIET)
+			return;
+
+		if (options & F_FLOOD)
+			(void)write(STDOUT_FILENO, &BSPACE, 1);
+		else {
+			if (options & F_AUDIBLE)
+				(void)write(STDOUT_FILENO, &BBELL, 1);
+			(void)printf("%d bytes from %s, icmp_seq=%u", cc,
+			    pr_addr(from, fromlen), seq);
+			(void)printf(" hlim=%d", hoplim);
+			if ((options & F_VERBOSE) != 0) {
+				struct sockaddr_in6 dstsa;
+
+				memset(&dstsa, 0, sizeof(dstsa));
+				dstsa.sin6_family = AF_INET6;
+				dstsa.sin6_len = sizeof(dstsa);
+				dstsa.sin6_scope_id = pktinfo->ipi6_ifindex;
+				dstsa.sin6_addr = pktinfo->ipi6_addr;
+				(void)printf(" dst=%s",
+				    pr_addr((struct sockaddr *)&dstsa,
+				    sizeof(dstsa)));
+			}
+			if (timing)
+				(void)printf(" time=%.3f ms", triptime);
+			if (dupflag)
+				(void)printf("(DUP!)");
+			/* check the data */
+			cp = buf + off + ICMP6ECHOLEN + ICMP6ECHOTMLEN;
+			dp = outpack + ICMP6ECHOLEN + ICMP6ECHOTMLEN;
+			for (i = 8; cp < end; ++i, ++cp, ++dp) {
+				if (*cp != *dp) {
+					(void)printf("\nwrong data byte #%d should be 0x%x but was 0x%x", i, *dp, *cp);
+					break;
+				}
+			}
+		}
+	} else if (icp->icmp6_type == ICMP6_NI_REPLY && mynireply(ni)) {
+		seq = ntohs(*(u_int16_t *)ni->icmp6_ni_nonce);
+		++nreceived;
+		if (TST(seq % mx_dup_ck)) {
+			++nrepeats;
+			--nreceived;
+			dupflag = 1;
+		} else {
+			SET(seq % mx_dup_ck);
+			dupflag = 0;
+		}
+
+		if (options & F_QUIET)
+			return;
+
+		(void)printf("%d bytes from %s: ", cc, pr_addr(from, fromlen));
+
+		switch (ntohs(ni->ni_code)) {
+		case ICMP6_NI_SUCCESS:
+			break;
+		case ICMP6_NI_REFUSED:
+			printf("refused, type 0x%x", ntohs(ni->ni_type));
+			goto fqdnend;
+		case ICMP6_NI_UNKNOWN:
+			printf("unknown, type 0x%x", ntohs(ni->ni_type));
+			goto fqdnend;
+		default:
+			printf("unknown code 0x%x, type 0x%x",
+			    ntohs(ni->ni_code), ntohs(ni->ni_type));
+			goto fqdnend;
+		}
+
+		switch (ntohs(ni->ni_qtype)) {
+		case NI_QTYPE_NOOP:
+			printf("NodeInfo NOOP");
+			break;
+		case NI_QTYPE_SUPTYPES:
+			pr_suptypes(ni, end - (u_char *)ni);
+			break;
+		case NI_QTYPE_NODEADDR:
+			pr_nodeaddr(ni, end - (u_char *)ni);
+			break;
+		case NI_QTYPE_FQDN:
+		default:	/* XXX: for backward compatibility */
+			cp = (u_char *)ni + ICMP6_NIRLEN;
+			if (buf[off + ICMP6_NIRLEN] ==
+			    cc - off - ICMP6_NIRLEN - 1)
+				oldfqdn = 1;
+			else
+				oldfqdn = 0;
+			if (oldfqdn) {
+				cp++;	/* skip length */
+				while (cp < end) {
+					safeputc(*cp & 0xff);
+					cp++;
+				}
+			} else {
+				i = 0;
+				while (cp < end) {
+					if (dnsdecode((const u_char **)&cp, end,
+					    (const u_char *)(ni + 1), dnsname,
+					    sizeof(dnsname)) == NULL) {
+						printf("???");
+						break;
+					}
+					/*
+					 * name-lookup special handling for
+					 * truncated name
+					 */
+					if (cp + 1 <= end && !*cp &&
+					    strlen(dnsname) > 0) {
+						dnsname[strlen(dnsname) - 1] = '\0';
+						cp++;
+					}
+					printf("%s%s", i > 0 ? "," : "",
+					    dnsname);
+				}
+			}
+			if (options & F_VERBOSE) {
+				int32_t ttl;
+				int comma = 0;
+
+				(void)printf(" (");	/*)*/
+
+				switch (ni->ni_code) {
+				case ICMP6_NI_REFUSED:
+					(void)printf("refused");
+					comma++;
+					break;
+				case ICMP6_NI_UNKNOWN:
+					(void)printf("unknown qtype");
+					comma++;
+					break;
+				}
+
+				if ((end - (u_char *)ni) < ICMP6_NIRLEN) {
+					/* case of refusion, unknown */
+					/*(*/
+					putchar(')');
+					goto fqdnend;
+				}
+				ttl = (int32_t)ntohl(*(u_long *)&buf[off+ICMP6ECHOLEN+8]);
+				if (comma)
+					printf(",");
+				if (!(ni->ni_flags & NI_FQDN_FLAG_VALIDTTL)) {
+					(void)printf("TTL=%d:meaningless",
+					    (int)ttl);
+				} else {
+					if (ttl < 0) {
+						(void)printf("TTL=%d:invalid",
+						   ttl);
+					} else
+						(void)printf("TTL=%d", ttl);
+				}
+				comma++;
+
+				if (oldfqdn) {
+					if (comma)
+						printf(",");
+					printf("03 draft");
+					comma++;
+				} else {
+					cp = (u_char *)ni + ICMP6_NIRLEN;
+					if (cp == end) {
+						if (comma)
+							printf(",");
+						printf("no name");
+						comma++;
+					}
+				}
+
+				if (buf[off + ICMP6_NIRLEN] !=
+				    cc - off - ICMP6_NIRLEN - 1 && oldfqdn) {
+					if (comma)
+						printf(",");
+					(void)printf("invalid namelen:%d/%lu",
+					    buf[off + ICMP6_NIRLEN],
+					    (u_long)cc - off - ICMP6_NIRLEN - 1);
+					comma++;
+				}
+				/*(*/
+				putchar(')');
+			}
+		fqdnend:
+			;
+		}
+	} else {
+		/* We've got something other than an ECHOREPLY */
+		if (!(options & F_VERBOSE))
+			return;
+		(void)printf("%d bytes from %s: ", cc, pr_addr(from, fromlen));
+		pr_icmph(icp, end);
+	}
+
+	if (!(options & F_FLOOD)) {
+		(void)putchar('\n');
+		if (options & F_VERBOSE)
+			pr_exthdrs(mhdr);
+		(void)fflush(stdout);
+	}
+#undef safeputc
+}
+
+void
+pr_exthdrs(mhdr)
+	struct msghdr *mhdr;
+{
+	ssize_t	bufsize;
+	void	*bufp;
+	struct cmsghdr *cm;
+
+	bufsize = 0;
+	bufp = mhdr->msg_control;
+	for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
+	     cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
+		if (cm->cmsg_level != IPPROTO_IPV6)
+			continue;
+
+		bufsize = CONTROLLEN - ((caddr_t)CMSG_DATA(cm) - (caddr_t)bufp);
+		if (bufsize <= 0)
+			continue; 
+		switch (cm->cmsg_type) {
+		case IPV6_HOPOPTS:
+			printf("  HbH Options: ");
+			pr_ip6opt(CMSG_DATA(cm), (size_t)bufsize);
+			break;
+		case IPV6_DSTOPTS:
+#ifdef IPV6_RTHDRDSTOPTS
+		case IPV6_RTHDRDSTOPTS:
+#endif
+			printf("  Dst Options: ");
+			pr_ip6opt(CMSG_DATA(cm), (size_t)bufsize);
+			break;
+		case IPV6_RTHDR:
+			printf("  Routing: ");
+			pr_rthdr(CMSG_DATA(cm), (size_t)bufsize);
+			break;
+		}
+	}
+}
+
+#if defined USE_RFC2292BIS && defined IPV6_OPTIONS
+void
+pr_ip6opt(void *extbuf, size_t bufsize)
+{
+	struct ip6_hbh *ext;
+	int currentlen;
+	u_int8_t type;
+	socklen_t extlen, len, origextlen;
+	void *databuf;
+	size_t offset;
+	u_int16_t value2;
+	u_int32_t value4;
+
+	ext = (struct ip6_hbh *)extbuf;
+	extlen = (ext->ip6h_len + 1) * 8;
+	printf("nxt %u, len %u (%lu bytes)\n", ext->ip6h_nxt,
+	    (unsigned int)ext->ip6h_len, (unsigned long)extlen);
+
+	/*
+	 * Bounds checking on the ancillary data buffer:
+	 *     subtract the size of a cmsg structure from the buffer size.
+	 */
+	if (bufsize < (extlen  + CMSG_SPACE(0))) {
+		origextlen = extlen;
+		extlen = bufsize - CMSG_SPACE(0);
+		warnx("options truncated, showing only %u (total=%u)",
+		    (unsigned int)(extlen / 8 - 1),
+		    (unsigned int)(ext->ip6h_len));
+	}
+
+	currentlen = 0;
+	while (1) {
+		currentlen = inet6_opt_next(extbuf, extlen, currentlen,
+		    &type, &len, &databuf);
+		if (currentlen == -1)
+			break;
+		switch (type) {
+		/*
+		 * Note that inet6_opt_next automatically skips any padding
+		 * optins.
+		 */
+		case IP6OPT_JUMBO:
+			offset = 0;
+			offset = inet6_opt_get_val(databuf, offset,
+			    &value4, sizeof(value4));
+			printf("    Jumbo Payload Opt: Length %u\n",
+			    (u_int32_t)ntohl(value4));
+			break;
+		case IP6OPT_ROUTER_ALERT:
+			offset = 0;
+			offset = inet6_opt_get_val(databuf, offset,
+						   &value2, sizeof(value2));
+			printf("    Router Alert Opt: Type %u\n",
+			    ntohs(value2));
+			break;
+		default:
+			printf("    Received Opt %u len %lu\n",
+			    type, (unsigned long)len);
+			break;
+		}
+	}
+	return;
+}
+#else  /* !USE_RFC2292BIS */
+/* ARGSUSED */
+void
+pr_ip6opt(void *extbuf, size_t bufsize)
+{
+	(void)extbuf;
+	(void)bufsize;
+	putchar('\n');
+	return;
+}
+#endif /* USE_RFC2292BIS */
+
+#if defined USE_RFC2292BIS && defined IPV6_OPTIONS
+void
+pr_rthdr(void *extbuf, size_t bufsize)
+{
+	struct in6_addr *in6;
+	char ntopbuf[INET6_ADDRSTRLEN];
+	struct ip6_rthdr *rh = (struct ip6_rthdr *)extbuf;
+	int i, segments, origsegs, rthsize, size0, size1;
+
+	/* print fixed part of the header */
+	printf("nxt %u, len %u (%d bytes), type %u, ", rh->ip6r_nxt,
+	    rh->ip6r_len, (rh->ip6r_len + 1) << 3, rh->ip6r_type);
+	if ((segments = inet6_rth_segments(extbuf)) >= 0) {
+		printf("%d segments, ", segments);
+		printf("%d left\n", rh->ip6r_segleft);
+	} else {
+		printf("segments unknown, ");
+		printf("%d left\n", rh->ip6r_segleft);
+		return;
+	}
+
+	/*
+	 * Bounds checking on the ancillary data buffer. When calculating
+	 * the number of items to show keep in mind:
+	 *	- The size of the cmsg structure
+	 *	- The size of one segment (the size of a Type 0 routing header)
+	 *	- When dividing add a fudge factor of one in case the
+	 *	  dividend is not evenly divisible by the divisor
+	 */
+	rthsize = (rh->ip6r_len + 1) * 8;
+	if (bufsize < (rthsize + CMSG_SPACE(0))) {
+		origsegs = segments;
+		size0 = inet6_rth_space(IPV6_RTHDR_TYPE_0, 0);
+		size1 = inet6_rth_space(IPV6_RTHDR_TYPE_0, 1);
+		segments -= (rthsize - (bufsize - CMSG_SPACE(0))) /
+		    (size1 - size0) + 1;
+		warnx("segments truncated, showing only %d (total=%d)",
+		    segments, origsegs);
+	}
+
+	for (i = 0; i < segments; i++) {
+		in6 = inet6_rth_getaddr(extbuf, i);
+		if (in6 == NULL)
+			printf("   [%d]<NULL>\n", i);
+		else {
+			if (!inet_ntop(AF_INET6, in6, ntopbuf,
+			    sizeof(ntopbuf)))
+				strlcpy(ntopbuf, "?", sizeof(ntopbuf));
+			printf("   [%d]%s\n", i, ntopbuf);
+		}
+	}
+
+	return;
+
+}
+
+#else  /* !USE_RFC2292BIS */
+/* ARGSUSED */
+void
+pr_rthdr(void *extbuf, size_t bufsize)
+{
+	(void)extbuf;
+	(void)bufsize;
+	putchar('\n');
+	return;
+}
+#endif /* USE_RFC2292BIS */
+
+int
+pr_bitrange(v, soff, ii)
+	u_int32_t v;
+	int soff;
+	int ii;
+{
+	int off;
+	int i;
+
+	off = 0;
+	while (off < 32) {
+		/* shift till we have 0x01 */
+		if ((v & 0x01) == 0) {
+			if (ii > 1)
+				printf("-%u", soff + off - 1);
+			ii = 0;
+			switch (v & 0x0f) {
+			case 0x00:
+				v >>= 4;
+				off += 4;
+				continue;
+			case 0x08:
+				v >>= 3;
+				off += 3;
+				continue;
+			case 0x04: case 0x0c:
+				v >>= 2;
+				off += 2;
+				continue;
+			default:
+				v >>= 1;
+				off += 1;
+				continue;
+			}
+		}
+
+		/* we have 0x01 with us */
+		for (i = 0; i < 32 - off; i++) {
+			if ((v & (0x01 << i)) == 0)
+				break;
+		}
+		if (!ii)
+			printf(" %u", soff + off);
+		ii += i;
+		v >>= i; off += i;
+	}
+	return ii;
+}
+
+void
+pr_suptypes(ni, nilen)
+	struct icmp6_nodeinfo *ni; /* ni->qtype must be SUPTYPES */
+	size_t nilen;
+{
+	size_t clen;
+	u_int32_t v;
+	const u_char *cp, *end;
+	u_int16_t cur;
+	struct cbit {
+		u_int16_t words;	/*32bit count*/
+		u_int16_t skip;
+	} cbit;
+#define MAXQTYPES	(1 << 16)
+	size_t off;
+	int b;
+
+	cp = (u_char *)(ni + 1);
+	end = ((u_char *)ni) + nilen;
+	cur = 0;
+	b = 0;
+
+	printf("NodeInfo Supported Qtypes");
+	if (options & F_VERBOSE) {
+		if (ni->ni_flags & NI_SUPTYPE_FLAG_COMPRESS)
+			printf(", compressed bitmap");
+		else
+			printf(", raw bitmap");
+	}
+
+	while (cp < end) {
+		clen = (size_t)(end - cp);
+		if ((ni->ni_flags & NI_SUPTYPE_FLAG_COMPRESS) == 0) {
+			if (clen == 0 || clen > MAXQTYPES / 8 ||
+			    clen % sizeof(v)) {
+				printf("???");
+				return;
+			}
+		} else {
+			if (clen < sizeof(cbit) || clen % sizeof(v))
+				return;
+			memcpy(&cbit, cp, sizeof(cbit));
+			if (sizeof(cbit) + ntohs(cbit.words) * sizeof(v) >
+			    clen)
+				return;
+			cp += sizeof(cbit);
+			clen = ntohs(cbit.words) * sizeof(v);
+			if (cur + clen * 8 + (u_long)ntohs(cbit.skip) * 32 >
+			    MAXQTYPES)
+				return;
+		}
+
+		for (off = 0; off < clen; off += sizeof(v)) {
+			memcpy(&v, cp + off, sizeof(v));
+			v = (u_int32_t)ntohl(v);
+			b = pr_bitrange(v, (int)(cur + off * 8), b);
+		}
+		/* flush the remaining bits */
+		b = pr_bitrange(0, (int)(cur + off * 8), b);
+
+		cp += clen;
+		cur += clen * 8;
+		if ((ni->ni_flags & NI_SUPTYPE_FLAG_COMPRESS) != 0)
+			cur += ntohs(cbit.skip) * 32;
+	}
+}
+
+void
+pr_nodeaddr(ni, nilen)
+	struct icmp6_nodeinfo *ni; /* ni->qtype must be NODEADDR */
+	int nilen;
+{
+	u_char *cp = (u_char *)(ni + 1);
+	char ntop_buf[INET6_ADDRSTRLEN];
+	int withttl = 0;
+
+	nilen -= sizeof(struct icmp6_nodeinfo);
+
+	if (options & F_VERBOSE) {
+		switch (ni->ni_code) {
+		case ICMP6_NI_REFUSED:
+			(void)printf("refused");
+			break;
+		case ICMP6_NI_UNKNOWN:
+			(void)printf("unknown qtype");
+			break;
+		}
+		if (ni->ni_flags & NI_NODEADDR_FLAG_TRUNCATE)
+			(void)printf(" truncated");
+	}
+	putchar('\n');
+	if (nilen <= 0)
+		printf("  no address\n");
+
+	/*
+	 * In icmp-name-lookups 05 and later, TTL of each returned address
+	 * is contained in the resposne. We try to detect the version
+	 * by the length of the data, but note that the detection algorithm
+	 * is incomplete. We assume the latest draft by default.
+	 */
+	if (nilen % (sizeof(u_int32_t) + sizeof(struct in6_addr)) == 0)
+		withttl = 1;
+	while (nilen > 0) {
+		u_int32_t ttl;
+
+		if (withttl) {
+			/* XXX: alignment? */
+			ttl = (u_int32_t)ntohl(*(u_int32_t *)cp);
+			cp += sizeof(u_int32_t);
+			nilen -= sizeof(u_int32_t);
+		}
+
+		if (inet_ntop(AF_INET6, cp, ntop_buf, sizeof(ntop_buf)) ==
+		    NULL)
+			strlcpy(ntop_buf, "?", sizeof(ntop_buf));
+		printf("  %s", ntop_buf);
+		if (withttl) {
+			if (ttl == 0xffffffff) {
+				/*
+				 * XXX: can this convention be applied to all
+				 * type of TTL (i.e. non-ND TTL)?
+				 */
+				printf("(TTL=infty)");
+			}
+			else
+				printf("(TTL=%u)", ttl);
+		}
+		putchar('\n');
+
+		nilen -= sizeof(struct in6_addr);
+		cp += sizeof(struct in6_addr);
+	}
+}
+
+int
+get_hoplim(mhdr)
+	struct msghdr *mhdr;
+{
+	struct cmsghdr *cm;
+
+	for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
+	     cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
+		if (cm->cmsg_len == 0)
+			return(-1);
+
+		if (cm->cmsg_level == IPPROTO_IPV6 &&
+		    cm->cmsg_type == IPV6_HOPLIMIT &&
+		    cm->cmsg_len == CMSG_LEN(sizeof(int)))
+			return(*(int *)CMSG_DATA(cm));
+	}
+
+	return(-1);
+}
+
+struct in6_pktinfo *
+get_rcvpktinfo(mhdr)
+	struct msghdr *mhdr;
+{
+	struct cmsghdr *cm;
+
+	for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
+	     cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
+		if (cm->cmsg_len == 0)
+			return(NULL);
+
+		if (cm->cmsg_level == IPPROTO_IPV6 &&
+		    cm->cmsg_type == IPV6_PKTINFO &&
+		    cm->cmsg_len == CMSG_LEN(sizeof(struct in6_pktinfo)))
+			return((struct in6_pktinfo *)CMSG_DATA(cm));
+	}
+
+	return(NULL);
+}
+
+int
+get_pathmtu(mhdr)
+	struct msghdr *mhdr;
+{
+#ifdef IPV6_RECVPATHMTU
+	struct cmsghdr *cm;
+	struct ip6_mtuinfo *mtuctl = NULL;
+
+	for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(mhdr); cm;
+	     cm = (struct cmsghdr *)CMSG_NXTHDR(mhdr, cm)) {
+		if (cm->cmsg_len == 0)
+			return(0);
+
+		if (cm->cmsg_level == IPPROTO_IPV6 &&
+		    cm->cmsg_type == IPV6_PATHMTU &&
+		    cm->cmsg_len == CMSG_LEN(sizeof(struct ip6_mtuinfo))) {
+			mtuctl = (struct ip6_mtuinfo *)CMSG_DATA(cm);
+
+			/*
+			 * If the notified destination is different from
+			 * the one we are pinging, just ignore the info.
+			 * We check the scope ID only when both notified value
+			 * and our own value have non-0 values, because we may
+			 * have used the default scope zone ID for sending,
+			 * in which case the scope ID value is 0.
+			 */
+			if (!IN6_ARE_ADDR_EQUAL(&mtuctl->ip6m_addr.sin6_addr,
+						&dst.sin6_addr) ||
+			    (mtuctl->ip6m_addr.sin6_scope_id &&
+			     dst.sin6_scope_id &&
+			     mtuctl->ip6m_addr.sin6_scope_id !=
+			     dst.sin6_scope_id)) {
+				if ((options & F_VERBOSE) != 0) {
+					printf("path MTU for %s is notified. "
+					       "(ignored)\n",
+					   pr_addr((struct sockaddr *)&mtuctl->ip6m_addr,
+					   sizeof(mtuctl->ip6m_addr)));
+				}
+				return(0);
+			}
+
+			/*
+			 * Ignore an invalid MTU. XXX: can we just believe
+			 * the kernel check?
+			 */
+			if (mtuctl->ip6m_mtu < IPV6_MMTU)
+				return(0);
+
+			/* notification for our destination. return the MTU. */
+			return((int)mtuctl->ip6m_mtu);
+		}
+	}
+#endif
+	return(0);
+}
+
+/*
+ * tvsub --
+ *	Subtract 2 timeval structs:  out = out - in.  Out is assumed to
+ * be >= in.
+ */
+void
+tvsub(out, in)
+	struct timeval *out, *in;
+{
+	if ((out->tv_usec -= in->tv_usec) < 0) {
+		--out->tv_sec;
+		out->tv_usec += 1000000;
+	}
+	out->tv_sec -= in->tv_sec;
+}
+
+/*
+ * onint --
+ *	SIGINT handler.
+ */
+/* ARGSUSED */
+void
+onint(notused)
+	int notused;
+{
+	summary();
+
+	(void)signal(SIGINT, SIG_DFL);
+	(void)kill(getpid(), SIGINT);
+
+	/* NOTREACHED */
+	exit(1);
+}
+
+/*
+ * summary --
+ *	Print out statistics.
+ */
+void
+summary()
+{
+	(void)printf("\n--- %s ping6 statistics ---\n", hostname);
+	(void)printf("%ld packets transmitted, ", ntransmitted);
+	(void)printf("%ld packets received, ", nreceived);
+	if (nrepeats)
+		(void)printf("+%ld duplicates, ", nrepeats);
+	if (ntransmitted) {
+		if (nreceived > ntransmitted)
+			(void)printf("-- somebody's duplicating packets!");
+		else
+			(void)printf("%.1f%% packet loss",
+			    ((((double)ntransmitted - nreceived) * 100.0) /
+			    ntransmitted));
+	}
+	(void)putchar('\n');
+	if (nreceived && timing) {
+		/* Only display average to microseconds */
+		double num = nreceived + nrepeats;
+		double avg = tsum / num;
+		double dev = sqrt(tsumsq / num - avg * avg);
+		(void)printf(
+		    "round-trip min/avg/max/std-dev = %.3f/%.3f/%.3f/%.3f ms\n",
+		    tmin, avg, tmax, dev);
+		(void)fflush(stdout);
+	}
+	(void)fflush(stdout);
+}
+
+/*subject type*/
+static const char *niqcode[] = {
+	"IPv6 address",
+	"DNS label",	/*or empty*/
+	"IPv4 address",
+};
+
+/*result code*/
+static const char *nircode[] = {
+	"Success", "Refused", "Unknown",
+};
+
+
+/*
+ * pr_icmph --
+ *	Print a descriptive string about an ICMP header.
+ */
+void
+pr_icmph(icp, end)
+	struct icmp6_hdr *icp;
+	u_char *end;
+{
+	char ntop_buf[INET6_ADDRSTRLEN];
+	struct nd_redirect *red;
+	struct icmp6_nodeinfo *ni;
+	char dnsname[MAXDNAME + 1];
+	const u_char *cp;
+	size_t l;
+
+	switch (icp->icmp6_type) {
+	case ICMP6_DST_UNREACH:
+		switch (icp->icmp6_code) {
+		case ICMP6_DST_UNREACH_NOROUTE:
+			(void)printf("No Route to Destination\n");
+			break;
+		case ICMP6_DST_UNREACH_ADMIN:
+			(void)printf("Destination Administratively "
+			    "Unreachable\n");
+			break;
+		case ICMP6_DST_UNREACH_BEYONDSCOPE:
+			(void)printf("Destination Unreachable Beyond Scope\n");
+			break;
+		case ICMP6_DST_UNREACH_ADDR:
+			(void)printf("Destination Host Unreachable\n");
+			break;
+		case ICMP6_DST_UNREACH_NOPORT:
+			(void)printf("Destination Port Unreachable\n");
+			break;
+		default:
+			(void)printf("Destination Unreachable, Bad Code: %d\n",
+			    icp->icmp6_code);
+			break;
+		}
+		/* Print returned IP header information */
+		pr_retip((struct ip6_hdr *)(icp + 1), end);
+		break;
+	case ICMP6_PACKET_TOO_BIG:
+		(void)printf("Packet too big mtu = %d\n",
+		    (int)ntohl(icp->icmp6_mtu));
+		pr_retip((struct ip6_hdr *)(icp + 1), end);
+		break;
+	case ICMP6_TIME_EXCEEDED:
+		switch (icp->icmp6_code) {
+		case ICMP6_TIME_EXCEED_TRANSIT:
+			(void)printf("Time to live exceeded\n");
+			break;
+		case ICMP6_TIME_EXCEED_REASSEMBLY:
+			(void)printf("Frag reassembly time exceeded\n");
+			break;
+		default:
+			(void)printf("Time exceeded, Bad Code: %d\n",
+			    icp->icmp6_code);
+			break;
+		}
+		pr_retip((struct ip6_hdr *)(icp + 1), end);
+		break;
+	case ICMP6_PARAM_PROB:
+		(void)printf("Parameter problem: ");
+		switch (icp->icmp6_code) {
+		case ICMP6_PARAMPROB_HEADER:
+			(void)printf("Erroneous Header ");
+			break;
+		case ICMP6_PARAMPROB_NEXTHEADER:
+			(void)printf("Unknown Nextheader ");
+			break;
+		case ICMP6_PARAMPROB_OPTION:
+			(void)printf("Unrecognized Option ");
+			break;
+		default:
+			(void)printf("Bad code(%d) ", icp->icmp6_code);
+			break;
+		}
+		(void)printf("pointer = 0x%02x\n",
+		    (u_int32_t)ntohl(icp->icmp6_pptr));
+		pr_retip((struct ip6_hdr *)(icp + 1), end);
+		break;
+	case ICMP6_ECHO_REQUEST:
+		(void)printf("Echo Request");
+		/* XXX ID + Seq + Data */
+		break;
+	case ICMP6_ECHO_REPLY:
+		(void)printf("Echo Reply");
+		/* XXX ID + Seq + Data */
+		break;
+	case ICMP6_MEMBERSHIP_QUERY:
+		(void)printf("Listener Query");
+		break;
+	case ICMP6_MEMBERSHIP_REPORT:
+		(void)printf("Listener Report");
+		break;
+	case ICMP6_MEMBERSHIP_REDUCTION:
+		(void)printf("Listener Done");
+		break;
+	case ND_ROUTER_SOLICIT:
+		(void)printf("Router Solicitation");
+		break;
+	case ND_ROUTER_ADVERT:
+		(void)printf("Router Advertisement");
+		break;
+	case ND_NEIGHBOR_SOLICIT:
+		(void)printf("Neighbor Solicitation");
+		break;
+	case ND_NEIGHBOR_ADVERT:
+		(void)printf("Neighbor Advertisement");
+		break;
+	case ND_REDIRECT:
+		red = (struct nd_redirect *)icp;
+		(void)printf("Redirect\n");
+		if (!inet_ntop(AF_INET6, &red->nd_rd_dst, ntop_buf,
+		    sizeof(ntop_buf)))
+			strlcpy(ntop_buf, "?", sizeof(ntop_buf));
+		(void)printf("Destination: %s", ntop_buf);
+		if (!inet_ntop(AF_INET6, &red->nd_rd_target, ntop_buf,
+		    sizeof(ntop_buf)))
+			strlcpy(ntop_buf, "?", sizeof(ntop_buf));
+		(void)printf(" New Target: %s", ntop_buf);
+		break;
+	case ICMP6_NI_QUERY:
+		(void)printf("Node Information Query");
+		/* XXX ID + Seq + Data */
+		ni = (struct icmp6_nodeinfo *)icp;
+		l = end - (u_char *)(ni + 1);
+		printf(", ");
+		switch (ntohs(ni->ni_qtype)) {
+		case NI_QTYPE_NOOP:
+			(void)printf("NOOP");
+			break;
+		case NI_QTYPE_SUPTYPES:
+			(void)printf("Supported qtypes");
+			break;
+		case NI_QTYPE_FQDN:
+			(void)printf("DNS name");
+			break;
+		case NI_QTYPE_NODEADDR:
+			(void)printf("nodeaddr");
+			break;
+		case NI_QTYPE_IPV4ADDR:
+			(void)printf("IPv4 nodeaddr");
+			break;
+		default:
+			(void)printf("unknown qtype");
+			break;
+		}
+		if (options & F_VERBOSE) {
+			switch (ni->ni_code) {
+			case ICMP6_NI_SUBJ_IPV6:
+				if (l == sizeof(struct in6_addr) &&
+				    inet_ntop(AF_INET6, ni + 1, ntop_buf,
+				    sizeof(ntop_buf)) != NULL) {
+					(void)printf(", subject=%s(%s)",
+					    niqcode[ni->ni_code], ntop_buf);
+				} else {
+#if 1
+					/* backward compat to -W */
+					(void)printf(", oldfqdn");
+#else
+					(void)printf(", invalid");
+#endif
+				}
+				break;
+			case ICMP6_NI_SUBJ_FQDN:
+				if (end == (u_char *)(ni + 1)) {
+					(void)printf(", no subject");
+					break;
+				}
+				printf(", subject=%s", niqcode[ni->ni_code]);
+				cp = (const u_char *)(ni + 1);
+				if (dnsdecode(&cp, end, NULL, dnsname,
+				    sizeof(dnsname)) != NULL)
+					printf("(%s)", dnsname);
+				else
+					printf("(invalid)");
+				break;
+			case ICMP6_NI_SUBJ_IPV4:
+				if (l == sizeof(struct in_addr) &&
+				    inet_ntop(AF_INET, ni + 1, ntop_buf,
+				    sizeof(ntop_buf)) != NULL) {
+					(void)printf(", subject=%s(%s)",
+					    niqcode[ni->ni_code], ntop_buf);
+				} else
+					(void)printf(", invalid");
+				break;
+			default:
+				(void)printf(", invalid");
+				break;
+			}
+		}
+		break;
+	case ICMP6_NI_REPLY:
+		(void)printf("Node Information Reply");
+		/* XXX ID + Seq + Data */
+		ni = (struct icmp6_nodeinfo *)icp;
+		printf(", ");
+		switch (ntohs(ni->ni_qtype)) {
+		case NI_QTYPE_NOOP:
+			(void)printf("NOOP");
+			break;
+		case NI_QTYPE_SUPTYPES:
+			(void)printf("Supported qtypes");
+			break;
+		case NI_QTYPE_FQDN:
+			(void)printf("DNS name");
+			break;
+		case NI_QTYPE_NODEADDR:
+			(void)printf("nodeaddr");
+			break;
+		case NI_QTYPE_IPV4ADDR:
+			(void)printf("IPv4 nodeaddr");
+			break;
+		default:
+			(void)printf("unknown qtype");
+			break;
+		}
+		if (options & F_VERBOSE) {
+			if (ni->ni_code > sizeof(nircode) / sizeof(nircode[0]))
+				printf(", invalid");
+			else
+				printf(", %s", nircode[ni->ni_code]);
+		}
+		break;
+	default:
+		(void)printf("Bad ICMP type: %d", icp->icmp6_type);
+	}
+}
+
+/*
+ * pr_iph --
+ *	Print an IP6 header.
+ */
+void
+pr_iph(ip6)
+	struct ip6_hdr *ip6;
+{
+	u_int32_t flow = ip6->ip6_flow & IPV6_FLOWLABEL_MASK;
+	u_int8_t tc;
+	char ntop_buf[INET6_ADDRSTRLEN];
+
+	tc = *(&ip6->ip6_vfc + 1); /* XXX */
+	tc = (tc >> 4) & 0x0f;
+	tc |= (ip6->ip6_vfc << 4);
+
+	printf("Vr TC  Flow Plen Nxt Hlim\n");
+	printf(" %1x %02x %05x %04x  %02x   %02x\n",
+	    (ip6->ip6_vfc & IPV6_VERSION_MASK) >> 4, tc, (u_int32_t)ntohl(flow),
+	    ntohs(ip6->ip6_plen), ip6->ip6_nxt, ip6->ip6_hlim);
+	if (!inet_ntop(AF_INET6, &ip6->ip6_src, ntop_buf, sizeof(ntop_buf)))
+		strlcpy(ntop_buf, "?", sizeof(ntop_buf));
+	printf("%s->", ntop_buf);
+	if (!inet_ntop(AF_INET6, &ip6->ip6_dst, ntop_buf, sizeof(ntop_buf)))
+		strlcpy(ntop_buf, "?", sizeof(ntop_buf));
+	printf("%s\n", ntop_buf);
+}
+
+/*
+ * pr_addr --
+ *	Return an ascii host address as a dotted quad and optionally with
+ * a hostname.
+ */
+const char *
+pr_addr(addr, addrlen)
+	struct sockaddr *addr;
+	int addrlen;
+{
+	static char buf[NI_MAXHOST];
+	int flag = 0;
+
+	if ((options & F_HOSTNAME) == 0)
+		flag |= NI_NUMERICHOST;
+
+	if (getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0, flag) == 0)
+		return (buf);
+	else
+		return "?";
+}
+
+/*
+ * pr_retip --
+ *	Dump some info on a returned (via ICMPv6) IPv6 packet.
+ */
+void
+pr_retip(ip6, end)
+	struct ip6_hdr *ip6;
+	u_char *end;
+{
+	u_char *cp = (u_char *)ip6, nh;
+	int hlen;
+
+	if (end - (u_char *)ip6 < sizeof(*ip6)) {
+		printf("IP6");
+		goto trunc;
+	}
+	pr_iph(ip6);
+	hlen = sizeof(*ip6);
+
+	nh = ip6->ip6_nxt;
+	cp += hlen;
+	while (end - cp >= 8) {
+		switch (nh) {
+		case IPPROTO_HOPOPTS:
+			printf("HBH ");
+			hlen = (((struct ip6_hbh *)cp)->ip6h_len+1) << 3;
+			nh = ((struct ip6_hbh *)cp)->ip6h_nxt;
+			break;
+		case IPPROTO_DSTOPTS:
+			printf("DSTOPT ");
+			hlen = (((struct ip6_dest *)cp)->ip6d_len+1) << 3;
+			nh = ((struct ip6_dest *)cp)->ip6d_nxt;
+			break;
+		case IPPROTO_FRAGMENT:
+			printf("FRAG ");
+			hlen = sizeof(struct ip6_frag);
+			nh = ((struct ip6_frag *)cp)->ip6f_nxt;
+			break;
+		case IPPROTO_ROUTING:
+			printf("RTHDR ");
+			hlen = (((struct ip6_rthdr *)cp)->ip6r_len+1) << 3;
+			nh = ((struct ip6_rthdr *)cp)->ip6r_nxt;
+			break;
+#ifdef IPSEC
+		case IPPROTO_AH:
+			printf("AH ");
+			hlen = (((struct ah *)cp)->ah_len+2) << 2;
+			nh = ((struct ah *)cp)->ah_nxt;
+			break;
+#endif
+		case IPPROTO_ICMPV6:
+			printf("ICMP6: type = %d, code = %d\n",
+			    *cp, *(cp + 1));
+			return;
+		case IPPROTO_ESP:
+			printf("ESP\n");
+			return;
+		case IPPROTO_TCP:
+			printf("TCP: from port %u, to port %u (decimal)\n",
+			    (*cp * 256 + *(cp + 1)),
+			    (*(cp + 2) * 256 + *(cp + 3)));
+			return;
+		case IPPROTO_UDP:
+			printf("UDP: from port %u, to port %u (decimal)\n",
+			    (*cp * 256 + *(cp + 1)),
+			    (*(cp + 2) * 256 + *(cp + 3)));
+			return;
+		default:
+			printf("Unknown Header(%d)\n", nh);
+			return;
+		}
+
+		if ((cp += hlen) >= end)
+			goto trunc;
+	}
+	if (end - cp < 8)
+		goto trunc;
+
+	putchar('\n');
+	return;
+
+  trunc:
+	printf("...\n");
+	return;
+}
+
+void
+fill(bp, patp)
+	char *bp, *patp;
+{
+	int ii, jj, kk;
+	int pat[16];
+	char *cp;
+
+	for (cp = patp; *cp; cp++)
+		if (!isxdigit(*cp))
+			errx(1, "patterns must be specified as hex digits");
+	ii = sscanf(patp,
+	    "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",
+	    &pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6],
+	    &pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12],
+	    &pat[13], &pat[14], &pat[15]);
+
+/* xxx */
+	if (ii > 0)
+		for (kk = 0;
+		    kk <= MAXDATALEN - (8 + sizeof(struct tv32) + ii);
+		    kk += ii)
+			for (jj = 0; jj < ii; ++jj)
+				bp[jj + kk] = pat[jj];
+	if (!(options & F_QUIET)) {
+		(void)printf("PATTERN: 0x");
+		for (jj = 0; jj < ii; ++jj)
+			(void)printf("%02x", bp[jj] & 0xFF);
+		(void)printf("\n");
+	}
+}
+
+#ifdef IPSEC
+#ifdef IPSEC_POLICY_IPSEC
+int
+setpolicy(so, policy)
+	int so;
+	char *policy;
+{
+	char *buf;
+
+	if (policy == NULL)
+		return 0;	/* ignore */
+
+	buf = ipsec_set_policy(policy, strlen(policy));
+	if (buf == NULL)
+		errx(1, "%s", ipsec_strerror());
+	if (setsockopt(s, IPPROTO_IPV6, IPV6_IPSEC_POLICY, buf,
+	    ipsec_get_policylen(buf)) < 0)
+		warnx("Unable to set IPsec policy");
+	free(buf);
+
+	return 0;
+}
+#endif
+#endif
+
+void
+usage()
+{
+	(void)fprintf(stderr,
+#if defined(IPSEC) && !defined(IPSEC_POLICY_IPSEC)
+	    "A"
+#endif
+	    "usage: ping6 [-"
+	    "d"
+#if defined(IPSEC) && !defined(IPSEC_POLICY_IPSEC)
+	    "E"
+#endif
+	    "fH"
+#ifdef IPV6_USE_MIN_MTU
+	    "m"
+#endif
+	    "noqrRtvwW] "
+	    "[-a addrtype] [-b bufsiz] [-c count]\n"
+	    "             [-h hoplimit] [-I interface] [-i wait] [-l preload]"
+#if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
+	    " [-P policy]"
+#endif
+	    "\n"
+	    "             [-p pattern] [-S sourceaddr] [-s packetsize] "
+	    "[hops ...] host\n");
+	exit(1);
+}
diff --git a/src/bin/network/route/route.cpp b/src/bin/network/route/route.cpp
index b558a36abe..b832821d38 100644
--- a/src/bin/network/route/route.cpp
+++ b/src/bin/network/route/route.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2006-2007, Haiku, Inc. All Rights Reserved.
+ * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
  * Distributed under the terms of the MIT License.
  *
  * Authors:
@@ -39,27 +39,56 @@ enum modes {
 	RTM_FLUSH,
 };
 
+enum preferred_output_format {
+	PREFER_OUTPUT_MASK,
+	PREFER_OUTPUT_PREFIX_LENGTH,
+};
+
 struct address_family {
 	int			family;
 	const char*	name;
 	const char*	identifiers[4];
+	preferred_output_format	preferred_format;
 	bool		(*parse_address)(const char* string, sockaddr* _address);
+	bool		(*prefix_length_to_mask)(uint8 prefixLength, sockaddr* mask);
+	uint8		(*mask_to_prefix_length)(sockaddr* mask);
 	const char*	(*address_to_string)(sockaddr* address);
 };
 
 // AF_INET family
 static bool inet_parse_address(const char* string, sockaddr* address);
+static bool inet_prefix_length_to_mask(uint8 prefixLength, sockaddr* mask);
+static uint8 inet_mask_to_prefix_length(sockaddr* mask);
 static const char* inet_address_to_string(sockaddr* address);
 
+// AF_INET6 family
+static bool inet6_parse_address(const char* string, sockaddr* address);
+static bool inet6_prefix_length_to_mask(uint8 prefixLength, sockaddr* mask);
+static uint8 inet6_mask_to_prefix_length(sockaddr* mask);
+static const char* inet6_address_to_string(sockaddr* address);
+
 static const address_family kFamilies[] = {
 	{
 		AF_INET,
 		"inet",
 		{"AF_INET", "inet", "ipv4", NULL},
+		PREFER_OUTPUT_MASK,
 		inet_parse_address,
+		inet_prefix_length_to_mask,
+		inet_mask_to_prefix_length,
 		inet_address_to_string,
 	},
-	{ -1, NULL, {NULL}, NULL, NULL }
+	{
+		AF_INET6,
+		"inet6",
+		{"AF_INET6", "inet6", "ipv6", NULL},
+		PREFER_OUTPUT_PREFIX_LENGTH,
+		inet6_parse_address,
+		inet6_prefix_length_to_mask,
+		inet6_mask_to_prefix_length,
+		inet6_address_to_string,
+	},
+	{ -1, NULL, {NULL}, PREFER_OUTPUT_MASK, NULL, NULL, NULL, NULL }
 };
 
 
@@ -71,7 +100,7 @@ inet_parse_address(const char* string, sockaddr* _address)
 	if (inet_aton(string, &inetAddress) != 1)
 		return false;
 
-	sockaddr_in& address = *(sockaddr_in *)_address;
+	sockaddr_in& address = *(sockaddr_in*)_address;
 	address.sin_family = AF_INET; 
 	address.sin_len = sizeof(struct sockaddr_in);
 	address.sin_port = 0;
@@ -82,13 +111,143 @@ inet_parse_address(const char* string, sockaddr* _address)
 }
 
 
-static const char *
+static bool
+inet_prefix_length_to_mask(uint8 prefixLength, sockaddr* _mask)
+{
+	if (prefixLength > 32)
+		return false;
+
+	sockaddr_in& mask = *(sockaddr_in*)_mask;
+	mask.sin_family = AF_INET;
+        mask.sin_len = sizeof(sockaddr_in);
+	mask.sin_port = 0;
+	memset(&mask.sin_zero[0], 0, sizeof(mask.sin_zero));
+
+	uint32 hostMask = 0;
+	for (uint8 i = 32; i > 32 - prefixLength; i--)
+		hostMask |= 1 << (i - 1);
+	mask.sin_addr.s_addr = htonl(hostMask);
+
+	return true;
+}
+
+
+static uint8
+inet_mask_to_prefix_length(sockaddr* _mask)
+{
+	if (_mask == NULL)
+		return 32;
+
+	sockaddr_in& mask = *(sockaddr_in*)_mask;
+	if (mask.sin_family != AF_INET)
+	    return (uint8)-1;
+
+	uint8 result = 0;
+	uint32 hostMask = ntohl(mask.sin_addr.s_addr);
+	for (uint8 i = 32; i > 0; i--) {
+		if (hostMask & (1 << (i - 1)) == 0)
+			break;
+		result++;
+	}
+
+	return result;
+}
+
+
+static const char*
 inet_address_to_string(sockaddr* address)
 {
 	if (address == NULL || address->sa_family != AF_INET)
 		return "-";
 
-	return inet_ntoa(((sockaddr_in *)address)->sin_addr);
+	return inet_ntoa(((sockaddr_in*)address)->sin_addr);
+}
+
+
+static bool
+inet6_parse_address(const char* string, sockaddr* _address)
+{
+	sockaddr_in6& address = *(sockaddr_in6*)_address;
+
+	if (inet_pton(AF_INET6, string, &address.sin6_addr) != 1)
+		return false;
+
+	address.sin6_family = AF_INET6;
+	address.sin6_len = sizeof(sockaddr_in6);
+	address.sin6_port = 0;
+	address.sin6_flowinfo = 0;
+	address.sin6_scope_id = 0;
+
+	return true;
+}
+
+
+static bool
+inet6_prefix_length_to_mask(uint8 prefixLength, sockaddr* _mask)
+{
+	if (prefixLength > 128)
+		return false;
+
+	sockaddr_in6& mask = *(sockaddr_in6*)_mask;
+	mask.sin6_family = AF_INET6;
+	mask.sin6_len = sizeof(sockaddr_in6);
+	mask.sin6_port = 0;
+	mask.sin6_flowinfo = 0;
+	mask.sin6_scope_id = 0;
+	memset(mask.sin6_addr.s6_addr, 0, sizeof(in6_addr));
+
+	for (uint8 i = 0; i < sizeof(in6_addr); i++, prefixLength -= 8) {
+		if (prefixLength < 8) {
+			const uint8 masks[] = {
+				0x00, 0x80, 0xc0, 0xe0,
+				0xf0, 0xf8, 0xfc, 0xfe
+			};
+			mask.sin6_addr.s6_addr[i] = masks[prefixLength];
+			break;
+		}
+
+		mask.sin6_addr.s6_addr[i] = 0xff;
+	}
+
+	return true;
+}
+
+
+static uint8
+inet6_mask_to_prefix_length(sockaddr* _mask)
+{
+	if (_mask == NULL)
+		return 128;
+
+	sockaddr_in6& mask = *(sockaddr_in6*)_mask;
+	if (mask.sin6_family != AF_INET6)
+	    return (uint8)-1;
+
+	uint8 result = 0;
+	for (uint8 i = 0; i < sizeof(in6_addr); i++) {
+		for (uint8 j = 0; j < 8; j++) {
+			if (!(mask.sin6_addr.s6_addr[i] & (1 << j)))
+				return result;
+			result++;
+		}
+	}
+
+	return 128;
+}
+
+
+static const char*
+inet6_address_to_string(sockaddr* address)
+{
+	if (address == NULL || address->sa_family != AF_INET6)
+		return "-";
+
+	static char buffer[INET6_ADDRSTRLEN];
+
+	inet_ntop(AF_INET6, &((sockaddr_in6*)address)->sin6_addr,
+		buffer, sizeof(buffer));
+
+	return buffer;
 }
 
 
@@ -98,15 +257,17 @@ inet_address_to_string(sockaddr* address)
 void
 usage(int status)
 {
-	printf("usage: %s [command] [<interface>] [<address family>] <address|default> [<option/flags>...]\n"
+	printf("usage: %s [command] [<interface>] [<address family>] "
+			"<address|default> [<option/flags>...]\n"
 		"Where <command> can be the one of:\n"
-		"  add             - add a route for the specified interface\n"
-		"  delete          - deletes the specified route\n"
-		"  list            - list with filters [default]\n"
+		"  add                - add a route for the specified interface\n"
+		"  delete             - deletes the specified route\n"
+		"  list               - list with filters [default]\n"
 		"<option> can be the following:\n"
-		"  netmask <addr>  - networking subnet mask\n"
-		"  gw <addr>       - gateway address\n"
-		"  mtu <bytes>     - maximal transfer unit\n"
+		"  netmask <addr>     - networking subnet mask\n"
+		"  prefixlen <number> - subnet mask length in bits\n"
+		"  gw <addr>          - gateway address\n"
+		"  mtu <bytes>        - maximal transfer unit\n"
 		"And <flags> can be: reject, local, host\n\n"
 		"Example:\n"
 		"\t%s add /dev/net/ipro1000/0 default gw 192.168.0.254\n",
@@ -120,7 +281,8 @@ bool
 prepare_request(struct ifreq& request, const char* name)
 {
 	if (strlen(name) > IF_NAMESIZE) {
-		fprintf(stderr, "%s: interface name \"%s\" is too long.\n", kProgramName, name);
+		fprintf(stderr, "%s: interface name \"%s\" is too long.\n",
+			kProgramName, name);
 		return false;
 	}
 
@@ -149,12 +311,30 @@ get_address_family(const char* argument, int32& familyIndex)
 
 
 bool
-parse_address(int32 familyIndex, const char* argument, struct sockaddr_storage& address)
+parse_address(int32 familyIndex, const char* argument,
+	struct sockaddr_storage& address)
 {
 	if (argument == NULL)
 		return false;
 
-	return kFamilies[familyIndex].parse_address(argument, (sockaddr *)&address);
+	return kFamilies[familyIndex].parse_address(argument, (sockaddr*)&address);
+}
+
+
+bool
+prefix_length_to_mask(int32 familyIndex, const char* argument,
+	struct sockaddr_storage& mask)
+{
+	if (argument == NULL)
+		return false;
+
+	char *end;
+	uint32 prefixLength = strtoul(argument, &end, 10);
+	if (end == argument)
+		return false;
+
+	return kFamilies[familyIndex].prefix_length_to_mask(
+		(uint8)prefixLength, (sockaddr*)&mask);
 }
 
 
@@ -172,10 +352,8 @@ list_routes(int socket, const char *interfaceName, route_entry &route)
 		return;
 
 	uint32 size = (uint32)config.ifc_value;
-	if (size == 0) {
-		fprintf(stderr, "%s: There are no routes!\n", kProgramName);
+	if (size == 0)
 		return;
-	}
 
 	void *buffer = malloc(size);
 	if (buffer == NULL) {
@@ -188,14 +366,15 @@ list_routes(int socket, const char *interfaceName, route_entry &route)
 	if (ioctl(socket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
 		return;
 
-	ifreq *interface = (ifreq *)buffer;
-	ifreq *end = (ifreq *)((uint8 *)buffer + size);
+	ifreq *interface = (ifreq*)buffer;
+	ifreq *end = (ifreq*)((uint8*)buffer + size);
 
 	while (interface < end) {
 		route_entry& route = interface->ifr_route;
 
 		// apply filters
-		if (interfaceName == NULL || !strcmp(interfaceName, interface->ifr_name)) {
+		if (interfaceName == NULL
+			|| !strcmp(interfaceName, interface->ifr_name)) {
 			// find family
 			const address_family *family = NULL;
 			for (int32 i = 0; kFamilies[i].family >= 0; i++) {
@@ -206,11 +385,22 @@ list_routes(int socket, const char *interfaceName, route_entry &route)
 			}
 
 			if (family != NULL) {
-				printf("%15s ", family->address_to_string(route.destination));
-				printf("mask %-15s ", family->address_to_string(route.mask));
-	
-				if (route.flags & RTF_GATEWAY)
-					printf("gateway %-15s ", family->address_to_string(route.gateway));
+				// TODO: is the %15s format OK for IPv6?
+				printf("%15s", family->address_to_string(route.destination));
+				switch (family->preferred_format) {
+					case PREFER_OUTPUT_MASK:
+						printf(" mask %-15s ",
+							family->address_to_string(route.mask));
+						break;
+					case PREFER_OUTPUT_PREFIX_LENGTH:
+						printf("/%u ",
+							family->mask_to_prefix_length(route.mask));
+						break;
+				}
+				if ((route.flags & RTF_GATEWAY) != 0) {
+					printf("gateway %-15s ",
+						family->address_to_string(route.gateway));
+				}
 			} else {
 				printf("unknown family ");
 			}
@@ -254,7 +444,7 @@ list_routes(int socket, const char *interfaceName, route_entry &route)
 		if (route.gateway != NULL)
 			addressSize += route.gateway->sa_len;
 
-		interface = (ifreq *)((addr_t)interface + IF_NAMESIZE + sizeof(route_entry)
+		interface = (ifreq*)((addr_t)interface + IF_NAMESIZE + sizeof(route_entry)
 			+ addressSize);
 	}
 
@@ -321,8 +511,17 @@ get_route(int socket, route_entry &route)
 	}
 
 	if (family != NULL) {
-		printf("%s ", family->address_to_string(request.destination));
-		printf("mask %s ", family->address_to_string(request.mask));
+		printf("%s", family->address_to_string(request.destination));
+		switch (family->preferred_format) {
+			case PREFER_OUTPUT_MASK:
+				printf(" mask %s ",
+					family->address_to_string(request.mask));
+				break;
+			case PREFER_OUTPUT_PREFIX_LENGTH:
+				printf("/%u ",
+					family->mask_to_prefix_length(request.mask));
+				break;
+		}
 
 		if (request.flags & RTF_GATEWAY)
 			printf("gateway %s ", family->address_to_string(request.gateway));
@@ -386,7 +585,8 @@ main(int argc, char** argv)
 
 	while (i < argc && i < 5) {
 		// try to parse address family
-		if (i <= 3 && familyIndex == -1 && get_address_family(argv[i], familyIndex)) {
+		if (i <= 3 && familySpecified == false
+				&& get_address_family(argv[i], familyIndex)) {
 			familySpecified = true;
 			if (i == 2)
 				interfaceIndex = -1;
@@ -432,7 +632,7 @@ main(int argc, char** argv)
 			i++;
 		} else if (!strcmp(argv[i], "nm") || !strcmp(argv[i], "netmask")) {
 			if (hasMask) {
-				fprintf(stderr, "%s: Netmask is specified twice\n",
+				fprintf(stderr, "%s: Netmask or prefix length is specified twice\n",
 					kProgramName);
 				exit(1);
 			}
@@ -443,6 +643,19 @@ main(int argc, char** argv)
 			}
 			hasMask = true;
 			i++;
+		} else if (!strcmp(argv[i], "plen") || !strcmp(argv[i], "prefixlen")) {
+			if (hasMask) {
+				fprintf(stderr, "%s: Netmask or prefix length is specified twice\n",
+					kProgramName);
+				exit(1);
+			}
+			if (!prefix_length_to_mask(familyIndex, argv[i + 1], mask)) {
+				fprintf(stderr, "%s: Option 'prefixlen' is invalid for this "
+					"address family\n", kProgramName);
+				exit(1);
+			}
+			hasMask = true;
+			i++;
 		} else if (!strcmp(argv[i], "mtu")) {
 			route.mtu = argv[i + 1] ? strtol(argv[i + 1], NULL, 0) : 0;
 			if (route.mtu <= 500) {
@@ -464,11 +677,11 @@ main(int argc, char** argv)
 	}
 
 	if (hasDestination)
-		route.destination = (sockaddr *)&destination;
+		route.destination = (sockaddr*)&destination;
 	if (hasMask)
-		route.mask = (sockaddr *)&mask;
+		route.mask = (sockaddr*)&mask;
 	if (hasGateway) {
-		route.gateway = (sockaddr *)&gateway;
+		route.gateway = (sockaddr*)&gateway;
 		route.flags |= RTF_GATEWAY;
 	}
 
@@ -505,7 +718,7 @@ main(int argc, char** argv)
 				list_routes(socket, interface, route);
 			else {
 				for (int32 i = 0; kFamilies[i].family >= 0; i++) {
-					int socket = ::socket(kFamilies[familyIndex].family, SOCK_DGRAM, 0);
+					int socket = ::socket(kFamilies[i].family, SOCK_DGRAM, 0);
 					if (socket < 0)
 						continue;
 
diff --git a/src/bin/network/tcpdump/Jamfile b/src/bin/network/tcpdump/Jamfile
index b0c67c0197..6fb6008a8c 100644
--- a/src/bin/network/tcpdump/Jamfile
+++ b/src/bin/network/tcpdump/Jamfile
@@ -4,7 +4,7 @@ UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
 UseHeaders [ FDirName $(SUBDIR) ] : true ;
 UseHeaders [ FDirName $(SUBDIR) libpcap ] : true ;
 
-local defines = [ FDefines HAVE_CONFIG_H=1 _U_=\"__attribute__((unused))\" ] ;
+local defines = [ FDefines HAVE_CONFIG_H=1 _U_=\"__attribute__((unused))\" INET6=1 HAVE_SOCKADDR_STORAGE=1 ] ;
 
 SubDirCcFlags $(defines) ;
 SubDirC++Flags $(defines) ;
@@ -39,7 +39,7 @@ BinCommand tcpdump :
 	print-cnfp.c
 	print-dccp.c
 	print-decnet.c
-	#print-dhcp6.c
+	print-dhcp6.c
 	print-domain.c
 	print-dvmrp.c
 	print-eap.c
@@ -50,16 +50,16 @@ BinCommand tcpdump :
 	print-ether.c
 	print-fddi.c
 	print-fr.c
-	#print-frag6.c
+	print-frag6.c
 	print-gre.c
 	print-hsrp.c
 	print-icmp.c
-	#print-icmp6.c
+	print-icmp6.c
 	print-igmp.c
 	print-igrp.c
 	print-ip.c
-	#print-ip6.c
-	#print-ip6opts.c
+	print-ip6.c
+	print-ip6opts.c
 	print-ipcomp.c
 	print-ipfc.c
 	print-ipx.c
@@ -83,7 +83,7 @@ BinCommand tcpdump :
 	print-ntp.c
 	print-null.c
 	print-ospf.c
-	#print-ospf6.c
+	print-ospf6.c
 	print-pflog.c
 	print-pgm.c
 	print-pim.c
@@ -95,7 +95,7 @@ BinCommand tcpdump :
 	print-rip.c
 	print-ripng.c
 	print-rsvp.c
-	#print-rt6.c
+	print-rt6.c
 	print-rx.c
 	print-sctp.c
 	print-sip.c