/*

 * iproute.c		"ip route".

 *

 *		This program is free software; you can redistribute it and/or

 *		modify it under the terms of the GNU General Public License

 *		as published by the Free Software Foundation; either version

 *		2 of the License, or (at your option) any later version.

 *

 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <string.h>

#include <time.h>

#include <sys/time.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <arpa/inet.h>

#include <linux/in_route.h>

#include <linux/icmpv6.h>

#include <errno.h>

#include "rt_names.h"

#include "utils.h"

#include "ip_common.h"

#ifndef RTAX_RTTVAR

#define RTAX_RTTVAR RTAX_HOPS

#endif

enum list_action {

	IPROUTE_LIST,

	IPROUTE_FLUSH,

	IPROUTE_SAVE,

};

static const char *mx_names[RTAX_MAX+1] = {

	[RTAX_MTU]			= "mtu",

	[RTAX_WINDOW]			= "window",

	[RTAX_RTT]			= "rtt",

	[RTAX_RTTVAR]			= "rttvar",

	[RTAX_SSTHRESH]			= "ssthresh",

	[RTAX_CWND]			= "cwnd",

	[RTAX_ADVMSS]			= "advmss",

	[RTAX_REORDERING]		= "reordering",

	[RTAX_HOPLIMIT]			= "hoplimit",

	[RTAX_INITCWND]			= "initcwnd",

	[RTAX_FEATURES]			= "features",

	[RTAX_RTO_MIN]			= "rto_min",

	[RTAX_INITRWND]			= "initrwnd",

	[RTAX_QUICKACK]			= "quickack",

	[RTAX_CC_ALGO]			= "congctl",

	[RTAX_FASTOPEN_NO_COOKIE]	= "fastopen_no_cookie"

};

static void usage(void) __attribute__((noreturn));

static void usage(void)

{

	fprintf(stderr,

		"Usage: ip route { list | flush } SELECTOR\n"

		"       ip route save SELECTOR\n"

		"       ip route restore\n"

		"       ip route showdump\n"

		"       ip route get [ ROUTE_GET_FLAGS ] ADDRESS\n"

		"                            [ from ADDRESS iif STRING ]\n"

		"                            [ oif STRING ] [ tos TOS ]\n"

		"                            [ mark NUMBER ] [ vrf NAME ]\n"

		"                            [ uid NUMBER ] [ ipproto PROTOCOL ]\n"

		"                            [ sport NUMBER ] [ dport NUMBER ]\n"

		"       ip route { add | del | change | append | replace } ROUTE\n"

		"SELECTOR := [ root PREFIX ] [ match PREFIX ] [ exact PREFIX ]\n"

		"            [ table TABLE_ID ] [ vrf NAME ] [ proto RTPROTO ]\n"

		"            [ type TYPE ] [ scope SCOPE ]\n"

		"ROUTE := NODE_SPEC [ INFO_SPEC ]\n"

		"NODE_SPEC := [ TYPE ] PREFIX [ tos TOS ]\n"

		"             [ table TABLE_ID ] [ proto RTPROTO ]\n"

		"             [ scope SCOPE ] [ metric METRIC ]\n"

		"             [ ttl-propagate { enabled | disabled } ]\n"

		"INFO_SPEC := { NH | nhid ID } OPTIONS FLAGS [ nexthop NH ]...\n"

		"NH := [ encap ENCAPTYPE ENCAPHDR ] [ via [ FAMILY ] ADDRESS ]\n"

		"	    [ dev STRING ] [ weight NUMBER ] NHFLAGS\n"

		"FAMILY := [ inet | inet6 | mpls | bridge | link ]\n"

		"OPTIONS := FLAGS [ mtu NUMBER ] [ advmss NUMBER ] [ as [ to ] ADDRESS ]\n"

		"           [ rtt TIME ] [ rttvar TIME ] [ reordering NUMBER ]\n"

		"           [ window NUMBER ] [ cwnd NUMBER ] [ initcwnd NUMBER ]\n"

		"           [ ssthresh NUMBER ] [ realms REALM ] [ src ADDRESS ]\n"

		"           [ rto_min TIME ] [ hoplimit NUMBER ] [ initrwnd NUMBER ]\n"

		"           [ features FEATURES ] [ quickack BOOL ] [ congctl NAME ]\n"

		"           [ pref PREF ] [ expires TIME ] [ fastopen_no_cookie BOOL ]\n"

		"TYPE := { unicast | local | broadcast | multicast | throw |\n"

		"          unreachable | prohibit | blackhole | nat }\n"

		"TABLE_ID := [ local | main | default | all | NUMBER ]\n"

		"SCOPE := [ host | link | global | NUMBER ]\n"

		"NHFLAGS := [ onlink | pervasive ]\n"

		"RTPROTO := [ kernel | boot | static | NUMBER ]\n"

		"PREF := [ low | medium | high ]\n"

		"TIME := NUMBER[s|ms]\n"

		"BOOL := [1|0]\n"

		"FEATURES := ecn\n"

		"ENCAPTYPE := [ mpls | ip | ip6 | seg6 | seg6local | rpl ]\n"

		"ENCAPHDR := [ MPLSLABEL | SEG6HDR ]\n"

		"SEG6HDR := [ mode SEGMODE ] segs ADDR1,ADDRi,ADDRn [hmac HMACKEYID] [cleanup]\n"

		"SEGMODE := [ encap | inline ]\n"

		"ROUTE_GET_FLAGS := [ fibmatch ]\n");

	exit(-1);

}

static struct

{

	unsigned int tb;

	int cloned;

	int flushed;

	char *flushb;

	int flushp;

	int flushe;

	int protocol, protocolmask;

	int scope, scopemask;

	__u64 typemask;

	int tos, tosmask;

	int iif, iifmask;

	int oif, oifmask;

	int mark, markmask;

	int realm, realmmask;

	__u32 metric, metricmask;

	inet_prefix rprefsrc;

	inet_prefix rvia;

	inet_prefix rdst;

	inet_prefix mdst;

	inet_prefix rsrc;

	inet_prefix msrc;

} filter;

static int flush_update(void)

{

	if (rtnl_send_check(&rth, filter.flushb, filter.flushp) < 0) {

		perror("Failed to send flush request");

		return -2;

	}

	filter.flushp = 0;

	return 0;

}

static int filter_nlmsg(struct nlmsghdr *n, struct rtattr **tb, int host_len)

{

	struct rtmsg *r = NLMSG_DATA(n);

	inet_prefix dst = { .family = r->rtm_family };

	inet_prefix src = { .family = r->rtm_family };

	inet_prefix via = { .family = r->rtm_family };

	inet_prefix prefsrc = { .family = r->rtm_family };

	__u32 table;

	static int ip6_multiple_tables;

	table = rtm_get_table(r, tb);

	if (preferred_family != AF_UNSPEC && r->rtm_family != preferred_family)

		return 0;

	if (r->rtm_family == AF_INET6 && table != RT_TABLE_MAIN)

		ip6_multiple_tables = 1;

	if (filter.cloned == !(r->rtm_flags & RTM_F_CLONED))

		return 0;

	if (r->rtm_family == AF_INET6 && !ip6_multiple_tables) {

		if (filter.tb) {

			if (filter.tb == RT_TABLE_LOCAL) {

				if (r->rtm_type != RTN_LOCAL)

					return 0;

			} else if (filter.tb == RT_TABLE_MAIN) {

				if (r->rtm_type == RTN_LOCAL)

					return 0;

			} else {

				return 0;

			}

		}

	} else {

		if (filter.tb > 0 && filter.tb != table)

			return 0;

	}

	if ((filter.protocol^r->rtm_protocol)&filter.protocolmask)

		return 0;

	if ((filter.scope^r->rtm_scope)&filter.scopemask)

		return 0;

	if (filter.typemask && !(filter.typemask & (1 << r->rtm_type)))

		return 0;

	if ((filter.tos^r->rtm_tos)&filter.tosmask)

		return 0;

	if (filter.rdst.family) {

		if (r->rtm_family != filter.rdst.family ||

		    filter.rdst.bitlen > r->rtm_dst_len)

			return 0;

	} else if (filter.rdst.flags & PREFIXLEN_SPECIFIED) {

		if (filter.rdst.bitlen > r->rtm_dst_len)

			return 0;

	}

	if (filter.mdst.family) {

		if (r->rtm_family != filter.mdst.family ||

		    (filter.mdst.bitlen >= 0 &&

		     filter.mdst.bitlen < r->rtm_dst_len))

			return 0;

	} else if (filter.mdst.flags & PREFIXLEN_SPECIFIED) {

		if (filter.mdst.bitlen >= 0 &&

		    filter.mdst.bitlen < r->rtm_dst_len)

			return 0;

	}

	if (filter.rsrc.family) {

		if (r->rtm_family != filter.rsrc.family ||

		    filter.rsrc.bitlen > r->rtm_src_len)

			return 0;

	} else if (filter.rsrc.flags & PREFIXLEN_SPECIFIED) {

		if (filter.rsrc.bitlen > r->rtm_src_len)

			return 0;

	}

	if (filter.msrc.family) {

		if (r->rtm_family != filter.msrc.family ||

		    (filter.msrc.bitlen >= 0 &&

		     filter.msrc.bitlen < r->rtm_src_len))

			return 0;

	} else if (filter.msrc.flags & PREFIXLEN_SPECIFIED) {

		if (filter.msrc.bitlen >= 0 &&

		    filter.msrc.bitlen < r->rtm_src_len)

			return 0;

	}

	if (filter.rvia.family) {

		int family = r->rtm_family;

		if (tb[RTA_VIA]) {

			struct rtvia *via = RTA_DATA(tb[RTA_VIA]);

			family = via->rtvia_family;

		}

		if (family != filter.rvia.family)

			return 0;

	}

	if (filter.rprefsrc.family && r->rtm_family != filter.rprefsrc.family)

		return 0;

	if (tb[RTA_DST])

		memcpy(&dst.data, RTA_DATA(tb[RTA_DST]), (r->rtm_dst_len+7)/8);

	if (filter.rsrc.family || filter.msrc.family ||

	    filter.rsrc.flags & PREFIXLEN_SPECIFIED ||

	    filter.msrc.flags & PREFIXLEN_SPECIFIED) {

		if (tb[RTA_SRC])

			memcpy(&src.data, RTA_DATA(tb[RTA_SRC]), (r->rtm_src_len+7)/8);

	}

	if (filter.rvia.bitlen > 0) {

		if (tb[RTA_GATEWAY])

			memcpy(&via.data, RTA_DATA(tb[RTA_GATEWAY]), host_len/8);

		if (tb[RTA_VIA]) {

			size_t len = RTA_PAYLOAD(tb[RTA_VIA]) - 2;

			struct rtvia *rtvia = RTA_DATA(tb[RTA_VIA]);

			via.family = rtvia->rtvia_family;

			memcpy(&via.data, rtvia->rtvia_addr, len);

		}

	}

	if (filter.rprefsrc.bitlen > 0) {

		if (tb[RTA_PREFSRC])

			memcpy(&prefsrc.data, RTA_DATA(tb[RTA_PREFSRC]), host_len/8);

	}

	if ((filter.rdst.family || filter.rdst.flags & PREFIXLEN_SPECIFIED) &&

	    inet_addr_match(&dst, &filter.rdst, filter.rdst.bitlen))

		return 0;

	if ((filter.mdst.family || filter.mdst.flags & PREFIXLEN_SPECIFIED) &&

	    inet_addr_match(&dst, &filter.mdst, r->rtm_dst_len))

		return 0;

	if ((filter.rsrc.family || filter.rsrc.flags & PREFIXLEN_SPECIFIED) &&

	    inet_addr_match(&src, &filter.rsrc, filter.rsrc.bitlen))

		return 0;

	if ((filter.msrc.family || filter.msrc.flags & PREFIXLEN_SPECIFIED) &&

	    filter.msrc.bitlen >= 0 &&

	    inet_addr_match(&src, &filter.msrc, r->rtm_src_len))

		return 0;

	if (filter.rvia.family && inet_addr_match(&via, &filter.rvia, filter.rvia.bitlen))

		return 0;

	if (filter.rprefsrc.family && inet_addr_match(&prefsrc, &filter.rprefsrc, filter.rprefsrc.bitlen))

		return 0;

	if (filter.realmmask) {

		__u32 realms = 0;

		if (tb[RTA_FLOW])

			realms = rta_getattr_u32(tb[RTA_FLOW]);

		if ((realms^filter.realm)&filter.realmmask)

			return 0;

	}

	if (filter.iifmask) {

		int iif = 0;

		if (tb[RTA_IIF])

			iif = rta_getattr_u32(tb[RTA_IIF]);

		if ((iif^filter.iif)&filter.iifmask)

			return 0;

	}

	if (filter.oifmask) {

		int oif = 0;

		if (tb[RTA_OIF])

			oif = rta_getattr_u32(tb[RTA_OIF]);

		if ((oif^filter.oif)&filter.oifmask)

			return 0;

	}

	if (filter.markmask) {

		int mark = 0;

		if (tb[RTA_MARK])

			mark = rta_getattr_u32(tb[RTA_MARK]);

		if ((mark ^ filter.mark) & filter.markmask)

			return 0;

	}

	if (filter.metricmask) {

		__u32 metric = 0;

		if (tb[RTA_PRIORITY])

			metric = rta_getattr_u32(tb[RTA_PRIORITY]);

		if ((metric ^ filter.metric) & filter.metricmask)

			return 0;

	}

	if (filter.flushb &&

	    r->rtm_family == AF_INET6 &&

	    r->rtm_dst_len == 0 &&

	    r->rtm_type == RTN_UNREACHABLE &&

	    tb[RTA_PRIORITY] &&

	    rta_getattr_u32(tb[RTA_PRIORITY]) == -1)

		return 0;

	return 1;

}

static void print_rtax_features(FILE *fp, unsigned int features)

{

	unsigned int of = features;

	if (features & RTAX_FEATURE_ECN) {

		print_null(PRINT_ANY, "ecn", "ecn ", NULL);

		features &= ~RTAX_FEATURE_ECN;

	}

	if (features)

		print_0xhex(PRINT_ANY,

			    "features", "%#llx ", of);

}

void print_rt_flags(FILE *fp, unsigned int flags)

{

	open_json_array(PRINT_JSON,

			is_json_context() ?  "flags" : "");

	if (flags & RTNH_F_DEAD)

		print_string(PRINT_ANY, NULL, "%s ", "dead");

	if (flags & RTNH_F_ONLINK)

		print_string(PRINT_ANY, NULL, "%s ", "onlink");

	if (flags & RTNH_F_PERVASIVE)

		print_string(PRINT_ANY, NULL, "%s ", "pervasive");

	if (flags & RTNH_F_OFFLOAD)

		print_string(PRINT_ANY, NULL, "%s ", "offload");

	if (flags & RTM_F_NOTIFY)

		print_string(PRINT_ANY, NULL, "%s ", "notify");

	if (flags & RTNH_F_LINKDOWN)

		print_string(PRINT_ANY, NULL, "%s ", "linkdown");

	if (flags & RTNH_F_UNRESOLVED)

		print_string(PRINT_ANY, NULL, "%s ", "unresolved");

	if (flags & RTM_F_OFFLOAD)

		print_string(PRINT_ANY, NULL, "%s ", "rt_offload");

	if (flags & RTM_F_TRAP)

		print_string(PRINT_ANY, NULL, "%s ", "rt_trap");

	close_json_array(PRINT_JSON, NULL);

}

static void print_rt_pref(FILE *fp, unsigned int pref)

{

	switch (pref) {

	case ICMPV6_ROUTER_PREF_LOW:

		print_string(PRINT_ANY,

			     "pref", "pref %s", "low");

		break;

	case ICMPV6_ROUTER_PREF_MEDIUM:

		print_string(PRINT_ANY,

			     "pref", "pref %s", "medium");

		break;

	case ICMPV6_ROUTER_PREF_HIGH:

		print_string(PRINT_ANY,

			     "pref", "pref %s", "high");

		break;

	default:

		print_uint(PRINT_ANY,

			   "pref", "%u", pref);

	}

}

void print_rta_if(FILE *fp, const struct rtattr *rta, const char *prefix)

{

	const char *ifname = ll_index_to_name(rta_getattr_u32(rta));

	if (is_json_context())

		print_string(PRINT_JSON, prefix, NULL, ifname);

	else {

		fprintf(fp, "%s ", prefix);

		color_fprintf(fp, COLOR_IFNAME, "%s ", ifname);

	}

}

static void print_cache_flags(FILE *fp, __u32 flags)

{

	json_writer_t *jw = get_json_writer();

	flags &= ~0xFFFF;

	if (jw) {

		jsonw_name(jw, "cache");

		jsonw_start_array(jw);

	} else {

		fprintf(fp, "%s    cache ", _SL_);

		if (flags == 0)

			return;

		putc('<', fp);

	}

#define PRTFL(fl, flname)						\

	if (flags & RTCF_##fl) {					\

		flags &= ~RTCF_##fl;					\

		if (jw)							\

			jsonw_string(jw, flname);			\

		else							\

			fprintf(fp, "%s%s", flname, flags ? "," : "> "); \

	}

	PRTFL(LOCAL, "local");

	PRTFL(REJECT, "reject");

	PRTFL(MULTICAST, "mc");

	PRTFL(BROADCAST, "brd");

	PRTFL(DNAT, "dst-nat");

	PRTFL(SNAT, "src-nat");

	PRTFL(MASQ, "masq");

	PRTFL(DIRECTDST, "dst-direct");

	PRTFL(DIRECTSRC, "src-direct");

	PRTFL(REDIRECTED, "redirected");

	PRTFL(DOREDIRECT, "redirect");

	PRTFL(FAST, "fastroute");

	PRTFL(NOTIFY, "notify");

	PRTFL(TPROXY, "proxy");

#undef PRTFL

	if (flags)

		print_hex(PRINT_ANY, "flags", "%x>", flags);

	if (jw)

		jsonw_end_array(jw);

}

static void print_rta_cacheinfo(FILE *fp, const struct rta_cacheinfo *ci)

{

	static int hz;

	if (!hz)

		hz = get_user_hz();

	if (ci->rta_expires != 0)

		print_int(PRINT_ANY, "expires",

			   "expires %dsec ", ci->rta_expires/hz);

	if (ci->rta_error != 0)

		print_uint(PRINT_ANY, "error",

			   "error %u ", ci->rta_error);

	if (show_stats) {

		if (ci->rta_clntref)

			print_uint(PRINT_ANY, "users",

				   "users %u ", ci->rta_clntref);

		if (ci->rta_used != 0)

			print_uint(PRINT_ANY, "used",

				   "used %u ", ci->rta_used);

		if (ci->rta_lastuse != 0)

			print_uint(PRINT_ANY, "age",

				   "age %usec ", ci->rta_lastuse/hz);

	}

	if (ci->rta_id)

		print_0xhex(PRINT_ANY, "ipid",

			    "ipid 0x%04llx ", ci->rta_id);

	if (ci->rta_ts || ci->rta_tsage) {

		print_0xhex(PRINT_ANY, "ts",

			    "ts 0x%llx", ci->rta_ts);

		print_uint(PRINT_ANY, "tsage",

			   "tsage %usec ", ci->rta_tsage);

	}

}

static void print_rta_flow(FILE *fp, const struct rtattr *rta)

{

	__u32 to = rta_getattr_u32(rta);

	__u32 from = to >> 16;

	SPRINT_BUF(b1);

	to &= 0xFFFF;

	if (is_json_context()) {

		open_json_object("flow");

		if (from)

			print_string(PRINT_JSON, "from", NULL,

				     rtnl_rtrealm_n2a(from, b1, sizeof(b1)));

		print_string(PRINT_JSON, "to", NULL,

			     rtnl_rtrealm_n2a(to, b1, sizeof(b1)));

		close_json_object();

	} else {

		fprintf(fp, "realm%s ", from ? "s" : "");

		if (from)

			print_string(PRINT_FP, NULL, "%s/",

				     rtnl_rtrealm_n2a(from, b1, sizeof(b1)));

		print_string(PRINT_FP, NULL, "%s ",

			     rtnl_rtrealm_n2a(to, b1, sizeof(b1)));

	}

}

static void print_rta_newdst(FILE *fp, const struct rtmsg *r,

			     const struct rtattr *rta)

{

	const char *newdst = format_host_rta(r->rtm_family, rta);

	if (is_json_context())

		print_string(PRINT_JSON, "to", NULL, newdst);

	else {

		fprintf(fp, "as to ");

		print_color_string(PRINT_FP,

				   ifa_family_color(r->rtm_family),

				   NULL, "%s ", newdst);

	}

}

void print_rta_gateway(FILE *fp, unsigned char family, const struct rtattr *rta)

{

	const char *gateway = format_host_rta(family, rta);

	if (is_json_context())

		print_string(PRINT_JSON, "gateway", NULL, gateway);

	else {

		fprintf(fp, "via ");

		print_color_string(PRINT_FP,

				   ifa_family_color(family),

				   NULL, "%s ", gateway);

	}

}

static void print_rta_via(FILE *fp, const struct rtattr *rta)

{

	size_t len = RTA_PAYLOAD(rta) - 2;

	const struct rtvia *via = RTA_DATA(rta);

	if (is_json_context()) {

		open_json_object("via");

		print_string(PRINT_JSON, "family", NULL,

			     family_name(via->rtvia_family));

		print_string(PRINT_JSON, "host", NULL,

			     format_host(via->rtvia_family, len,

					 via->rtvia_addr));

		close_json_object();

	} else {

		print_string(PRINT_FP, NULL, "via %s ",

			     family_name(via->rtvia_family));

		print_color_string(PRINT_FP,

				   ifa_family_color(via->rtvia_family),

				   NULL, "%s ",

				   format_host(via->rtvia_family,

					       len, via->rtvia_addr));

	}

}

static void print_rta_metrics(FILE *fp, const struct rtattr *rta)

{

	struct rtattr *mxrta[RTAX_MAX+1];

	unsigned int mxlock = 0;

	int i;

	open_json_array(PRINT_JSON, "metrics");

	open_json_object(NULL);

	parse_rtattr(mxrta, RTAX_MAX, RTA_DATA(rta), RTA_PAYLOAD(rta));

	if (mxrta[RTAX_LOCK])

		mxlock = rta_getattr_u32(mxrta[RTAX_LOCK]);

	for (i = 2; i <= RTAX_MAX; i++) {

		__u32 val = 0U;

		if (mxrta[i] == NULL && !(mxlock & (1 << i)))

			continue;

		if (mxrta[i] != NULL && i != RTAX_CC_ALGO)

			val = rta_getattr_u32(mxrta[i]);

		if (i == RTAX_HOPLIMIT && (int)val == -1)

			continue;

		if (!is_json_context()) {

			if (i < sizeof(mx_names)/sizeof(char *) && mx_names[i])

				fprintf(fp, "%s ", mx_names[i]);

			else

				fprintf(fp, "metric %d ", i);

			if (mxlock & (1<

				fprintf(fp, "lock ");

		}

		switch (i) {

		case RTAX_FEATURES:

			print_rtax_features(fp, val);

			break;

		default:

			print_uint(PRINT_ANY, mx_names[i], "%u ", val);

			break;

		case RTAX_RTT:

		case RTAX_RTTVAR:

		case RTAX_RTO_MIN:

			if (i == RTAX_RTT)

				val /= 8;

			else if (i == RTAX_RTTVAR)

				val /= 4;

			if (is_json_context())

				print_uint(PRINT_JSON, mx_names[i],

					   NULL, val);

			else {

				if (val >= 1000)

					fprintf(fp, "%gs ", val/1e3);

				else

					fprintf(fp, "%ums ", val);

			}

			break;

		case RTAX_CC_ALGO:

			print_string(PRINT_ANY, "congestion",

				     "%s ", rta_getattr_str(mxrta[i]));

			break;

		}

	}

	close_json_object();

	close_json_array(PRINT_JSON, NULL);

}

static void print_rta_multipath(FILE *fp, const struct rtmsg *r,

				struct rtattr *rta)

{

	const struct rtnexthop *nh = RTA_DATA(rta);

	int len = RTA_PAYLOAD(rta);

	int first = 1;

	open_json_array(PRINT_JSON, "nexthops");

	while (len >= sizeof(*nh)) {

		struct rtattr *tb[RTA_MAX + 1];

		if (nh->rtnh_len > len)

			break;

		open_json_object(NULL);

		if ((r->rtm_flags & RTM_F_CLONED) &&

		    r->rtm_type == RTN_MULTICAST) {

			if (first) {

				print_string(PRINT_FP, NULL, "Oifs: ", NULL);

				first = 0;

			} else {

				print_string(PRINT_FP, NULL, " ", NULL);

			}

		} else

			print_string(PRINT_FP, NULL, "%s\tnexthop ", _SL_);

		if (nh->rtnh_len > sizeof(*nh)) {

			parse_rtattr(tb, RTA_MAX, RTNH_DATA(nh),

				     nh->rtnh_len - sizeof(*nh));

			if (tb[RTA_ENCAP])

				lwt_print_encap(fp,

						tb[RTA_ENCAP_TYPE],

						tb[RTA_ENCAP]);

			if (tb[RTA_NEWDST])

				print_rta_newdst(fp, r, tb[RTA_NEWDST]);

			if (tb[RTA_GATEWAY])

				print_rta_gateway(fp, r->rtm_family,

						  tb[RTA_GATEWAY]);

			if (tb[RTA_VIA])

				print_rta_via(fp, tb[RTA_VIA]);

			if (tb[RTA_FLOW])

				print_rta_flow(fp, tb[RTA_FLOW]);

		}

		if ((r->rtm_flags & RTM_F_CLONED) &&

		    r->rtm_type == RTN_MULTICAST) {

			print_string(PRINT_ANY, "dev",

				     "%s", ll_index_to_name(nh->rtnh_ifindex));

			if (nh->rtnh_hops != 1)

				print_int(PRINT_ANY, "ttl", "(ttl>%d)", nh->rtnh_hops);

			print_string(PRINT_FP, NULL, " ", NULL);

		} else {

			print_string(PRINT_ANY, "dev",

				     "dev %s ", ll_index_to_name(nh->rtnh_ifindex));

			if (r->rtm_family != AF_MPLS)

				print_int(PRINT_ANY, "weight",

					  "weight %d ", nh->rtnh_hops + 1);

		}

		print_rt_flags(fp, nh->rtnh_flags);

		len -= NLMSG_ALIGN(nh->rtnh_len);

		nh = RTNH_NEXT(nh);

		close_json_object();

	}

	close_json_array(PRINT_JSON, NULL);

}

int print_route(struct nlmsghdr *n, void *arg)

{

	FILE *fp = (FILE *)arg;

	struct rtmsg *r = NLMSG_DATA(n);

	int len = n->nlmsg_len;

	struct rtattr *tb[RTA_MAX+1];

	int family, color, host_len;

	__u32 table;

	int ret;

	SPRINT_BUF(b1);

	if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {

		fprintf(stderr, "Not a route: %08x %08x %08x\n",

			n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);

		return -1;

	}

	if (filter.flushb && n->nlmsg_type != RTM_NEWROUTE)

		return 0;

	len -= NLMSG_LENGTH(sizeof(*r));

	if (len < 0) {

		fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);

		return -1;

	}

	host_len = af_bit_len(r->rtm_family);

	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);

	table = rtm_get_table(r, tb);

	if (!filter_nlmsg(n, tb, host_len))

		return 0;

	if (filter.flushb) {

		struct nlmsghdr *fn;

		if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) {

			ret = flush_update();

			if (ret < 0)

				return ret;

		}

		fn = (struct nlmsghdr *)(filter.flushb + NLMSG_ALIGN(filter.flushp));

		memcpy(fn, n, n->nlmsg_len);

		fn->nlmsg_type = RTM_DELROUTE;

		fn->nlmsg_flags = NLM_F_REQUEST;

		fn->nlmsg_seq = ++rth.seq;

		filter.flushp = (((char *)fn) + n->nlmsg_len) - filter.flushb;

		filter.flushed++;

		if (show_stats < 2)

			return 0;

	}

	open_json_object(NULL);

	if (n->nlmsg_type == RTM_DELROUTE)

		print_bool(PRINT_ANY, "deleted", "Deleted ", true);

	if ((r->rtm_type != RTN_UNICAST || show_details > 0) &&

	    (!filter.typemask || (filter.typemask & (1 << r->rtm_type))))

		print_string(PRINT_ANY, "type", "%s ",

			     rtnl_rtntype_n2a(r->rtm_type, b1, sizeof(b1)));

	color = COLOR_NONE;

	if (tb[RTA_DST]) {

		family = get_real_family(r->rtm_type, r->rtm_family);

		color = ifa_family_color(family);

		if (r->rtm_dst_len != host_len) {

			snprintf(b1, sizeof(b1),

				 "%s/%u", rt_addr_n2a_rta(family, tb[RTA_DST]),

				 r->rtm_dst_len);

		} else {

			format_host_rta_r(family, tb[RTA_DST],

					  b1, sizeof(b1));

		}

	} else if (r->rtm_dst_len) {

		snprintf(b1, sizeof(b1), "0/%d ", r->rtm_dst_len);

	} else {

		strncpy(b1, "default", sizeof(b1));

	}

	print_color_string(PRINT_ANY, color,

			   "dst", "%s ", b1);

	if (tb[RTA_SRC]) {

		family = get_real_family(r->rtm_type, r->rtm_family);

		color = ifa_family_color(family);

		if (r->rtm_src_len != host_len) {

			snprintf(b1, sizeof(b1),

				 "%s/%u",

				 rt_addr_n2a_rta(family, tb[RTA_SRC]),

				 r->rtm_src_len);

		} else {

			format_host_rta_r(family, tb[RTA_SRC],

					  b1, sizeof(b1));

		}

		print_color_string(PRINT_ANY, color,

				   "from", "from %s ", b1);

	} else if (r->rtm_src_len) {

		snprintf(b1, sizeof(b1), "0/%u", r->rtm_src_len);

		print_string(PRINT_ANY, "src", "from %s ", b1);

	}

	if (tb[RTA_NH_ID])

		print_uint(PRINT_ANY, "nhid", "nhid %u ",

			   rta_getattr_u32(tb[RTA_NH_ID]));

	if (tb[RTA_NEWDST])

		print_rta_newdst(fp, r, tb[RTA_NEWDST]);

	if (tb[RTA_ENCAP])

		lwt_print_encap(fp, tb[RTA_ENCAP_TYPE], tb[RTA_ENCAP]);

	if (r->rtm_tos && filter.tosmask != -1) {

		print_string(PRINT_ANY, "tos", "tos %s ",

			     rtnl_dsfield_n2a(r->rtm_tos, b1, sizeof(b1)));

	}

	if (tb[RTA_GATEWAY] && filter.rvia.bitlen != host_len)

		print_rta_gateway(fp, r->rtm_family, tb[RTA_GATEWAY]);

	if (tb[RTA_VIA])

		print_rta_via(fp, tb[RTA_VIA]);

	if (tb[RTA_OIF] && filter.oifmask != -1)

		print_rta_if(fp, tb[RTA_OIF], "dev");

	if (table && (table != RT_TABLE_MAIN || show_details > 0) && !filter.tb)

		print_string(PRINT_ANY,

			     "table", "table %s ",

			     rtnl_rttable_n2a(table, b1, sizeof(b1)));

	if (!(r->rtm_flags & RTM_F_CLONED)) {

		if ((r->rtm_protocol != RTPROT_BOOT || show_details > 0) &&

		    filter.protocolmask != -1)

			print_string(PRINT_ANY,

				     "protocol", "proto %s ",

				     rtnl_rtprot_n2a(r->rtm_protocol,

						     b1, sizeof(b1)));

		if ((r->rtm_scope != RT_SCOPE_UNIVERSE || show_details > 0) &&

		    filter.scopemask != -1)

			print_string(PRINT_ANY,

				     "scope", "scope %s ",

				     rtnl_rtscope_n2a(r->rtm_scope,

						      b1, sizeof(b1)));

	}

	if (tb[RTA_PREFSRC] && filter.rprefsrc.bitlen != host_len) {

		const char *psrc

			= rt_addr_n2a_rta(r->rtm_family, tb[RTA_PREFSRC]);

		/* Do not use format_host(). It is our local addr

		   and symbolic name will not be useful.

		*/

		if (is_json_context())