/*

 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * Copyright (c) 1983 Regents of the University of California.

 * All rights reserved.  The Berkeley software License Agreement

 * specifies the terms and conditions for redistribution.

 */

#include "defs.h"

#include "strings.h"

#include "ifconfig.h"

#include <compat.h>

#include <libdlpi.h>

#include <libdllink.h>

#include <libdliptun.h>

#include <libdllink.h>

#include <inet/ip.h>

#include <inet/ipsec_impl.h>

#include <libipadm.h>

#include <ifaddrs.h>

#include <libsocket_priv.h>

#define	LOOPBACK_IF	"lo0"

#define	NONE_STR	"none"

#define	ARP_MOD_NAME	"arp"

#define	LIFC_DEFAULT	(LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES |\

			LIFC_UNDER_IPMP)

typedef struct if_flags {

	uint64_t iff_value;

	char	*iff_name;

} if_flags_t;

static if_flags_t	if_flags_tbl[] = {

	{ IFF_UP,		"UP" },

	{ IFF_BROADCAST,	"BROADCAST" },

	{ IFF_DEBUG,		"DEBUG" },

	{ IFF_LOOPBACK,		"LOOPBACK" },

	{ IFF_POINTOPOINT,	"POINTOPOINT" },

	{ IFF_NOTRAILERS,	"NOTRAILERS" },

	{ IFF_RUNNING,		"RUNNING" },

	{ IFF_NOARP,		"NOARP" },

	{ IFF_PROMISC,		"PROMISC" },

	{ IFF_ALLMULTI,		"ALLMULTI" },

	{ IFF_INTELLIGENT,	"INTELLIGENT" },

	{ IFF_MULTICAST,	"MULTICAST" },

	{ IFF_MULTI_BCAST,	"MULTI_BCAST" },

	{ IFF_UNNUMBERED,	"UNNUMBERED" },

	{ IFF_DHCPRUNNING,	"DHCP" },

	{ IFF_PRIVATE,		"PRIVATE" },

	{ IFF_NOXMIT,		"NOXMIT" },

	{ IFF_NOLOCAL,		"NOLOCAL" },

	{ IFF_DEPRECATED,	"DEPRECATED" },

	{ IFF_ADDRCONF,		"ADDRCONF" },

	{ IFF_ROUTER,		"ROUTER" },

	{ IFF_NONUD,		"NONUD" },

	{ IFF_ANYCAST,		"ANYCAST" },

	{ IFF_NORTEXCH,		"NORTEXCH" },

	{ IFF_IPV4,		"IPv4" },

	{ IFF_IPV6,		"IPv6" },

	{ IFF_NOFAILOVER,	"NOFAILOVER" },

	{ IFF_FAILED,		"FAILED" },

	{ IFF_STANDBY,		"STANDBY" },

	{ IFF_INACTIVE,		"INACTIVE" },

	{ IFF_OFFLINE,		"OFFLINE" },

	{ IFF_XRESOLV,		"XRESOLV" },

	{ IFF_COS_ENABLED,	"CoS" },

	{ IFF_PREFERRED,	"PREFERRED" },

	{ IFF_TEMPORARY,	"TEMPORARY" },

	{ IFF_FIXEDMTU,		"FIXEDMTU" },

	{ IFF_VIRTUAL,		"VIRTUAL" },

	{ IFF_DUPLICATE,	"DUPLICATE" },

	{ IFF_IPMP,		"IPMP"},

	{ IFF_VRRP,		"VRRP"},

};

typedef struct {

	const char		*ia_app;

	uint64_t		ia_flag;

	uint_t			ia_tries;

} if_appflags_t;

static const if_appflags_t if_appflags_tbl[] = {

	{ "dhcpagent(1M)",	IFF_DHCPRUNNING,	1 },

	{ "in.ndpd(1M)",	IFF_ADDRCONF,		3 },

	{  NULL,		0,			0 }

};

static dladm_handle_t	dlh;

boolean_t		dlh_opened;

static struct		lifreq lifr;

/* current interface name a particular function is accessing */

static char		name[LIFNAMSIZ];

/* foreach interface saved name */

static char		origname[LIFNAMSIZ];

static int		setaddr;

static boolean_t	setaddr_done = _B_FALSE;

static boolean_t	ipsec_policy_set;

static boolean_t	ipsec_auth_covered;

static ipadm_handle_t	iph;

static ipadm_addrobj_t	ipaddr;

/*

 * Make sure the algorithm variables hold more than the sizeof an algorithm

 * in PF_KEY.  (For now, more than a uint8_t.)  The NO_***_?ALG indicates that

 * there was no algorithm requested, and in the ipsec_req that service should

 * be disabled.  (E.g. if ah_aalg remains NO_AH_AALG, then AH will be

 * disabled on that tunnel.)

 */

#define	NO_AH_AALG 256

#define	NO_ESP_AALG 256

#define	NO_ESP_EALG 256

int	s, s4, s6;

int	af = AF_INET;	/* default address family */

int	debug = 0;

int	all = 0;	/* setifdhcp() needs to know this */

int	verbose = 0;

int	v4compat = 0;	/* Compatible printing format */

/*

 * Function prototypes for command functions.

 */

static int	addif(char *arg, int64_t param);

static int	inetipmp(char *arg, int64_t param);

static int	inetplumb(char *arg, int64_t param);

static int	inetunplumb(char *arg, int64_t param);

static int	removeif(char *arg, int64_t param);

static int	setdebugflag(char *arg, int64_t param);

static int	setifaddr(char *arg, int64_t param);

static int	setifbroadaddr(char *arg, int64_t param);

static int	setifdstaddr(char *arg, int64_t param);

static int	setifether(char *arg, int64_t param);

static int	setifflags(char *arg, int64_t param);

static int	setifindex(char *arg, int64_t param);

static int	setifmetric(char *arg, int64_t param);

static int	setifmtu(char *arg, int64_t param);

static int	setifnetmask(char *arg, int64_t param);

static int	setifprefixlen(char *arg, int64_t param);

static int	setifrevarp(char *arg, int64_t param);

static int	setifsubnet(char *arg, int64_t param);

static int	setiftdst(char *arg, int64_t param);

static int	setiftoken(char *arg, int64_t param);

static int	setiftsrc(char *arg, int64_t param);

static int	setverboseflag(char *arg, int64_t param);

static int	set_tun_ah_alg(char *arg, int64_t param);

static int	set_tun_esp_auth_alg(char *arg, int64_t param);

static int	set_tun_esp_encr_alg(char *arg, int64_t param);

static int	modlist(char *arg, int64_t param);

static int	modinsert(char *arg, int64_t param);

static int	modremove(char *arg, int64_t param);

static int	setifgroupname(char *arg, int64_t param);

static int	configinfo(char *arg, int64_t param);

static void	print_config_flags(int af, uint64_t flags);

static void	print_flags(uint64_t flags);

static void	print_ifether(const char *ifname);

static int	set_tun_encap_limit(char *arg, int64_t param);

static int	clr_tun_encap_limit(char *arg, int64_t param);

static int	set_tun_hop_limit(char *arg, int64_t param);

static int	setzone(char *arg, int64_t param);

static int	setallzones(char *arg, int64_t param);

static int	setifsrc(char *arg, int64_t param);

static int	lifnum(const char *ifname);

static void	plumball(int, char **, int64_t, int64_t, int64_t);

/*

 * Address family specific function prototypes.

 */

static void	in_getaddr(char *s, struct sockaddr *saddr, int *plenp);

static void	in_status(int force, uint64_t flags);

static void	in_configinfo(int force, uint64_t flags);

static void	in6_getaddr(char *s, struct sockaddr *saddr, int *plenp);

static void	in6_status(int force, uint64_t flags);

static void	in6_configinfo(int force, uint64_t flags);

/*

 * Misc support functions

 */

static boolean_t	ni_entry(const char *, void *);

static void		foreachinterface(int argc, char *argv[],

			    int af, int64_t onflags, int64_t offflags,

			    int64_t lifc_flags);

static void		ifconfig(int argc, char *argv[], int af,

			    struct ifaddrs *ifa);

static boolean_t	in_getmask(struct sockaddr_in *saddr,

			    boolean_t addr_set);

static int		in_getprefixlen(char *addr, boolean_t slash, int plen);

static boolean_t	in_prefixlentomask(int prefixlen, int maxlen,

			    uchar_t *mask);

static void		status(void);

static void		ifstatus(const char *ifname);

static void		tun_status(datalink_id_t);

static void		usage(void);

static int		setifdhcp(const char *caller, const char *ifname,

			    int argc, char *argv[]);

static int		ip_domux2fd(int *, int *, int *, int *, int *);

static int		ip_plink(int, int, int, int, int);

static int		modop(char *arg, char op);

static int		find_all_interfaces(struct lifconf *lifcp, char **buf,

			    int64_t lifc_flags);

static int		create_ipmp(const char *grname, int af,

			    const char *ifname, boolean_t implicit);

static void		start_ipmp_daemon(void);

static boolean_t 	ifaddr_up(ifaddrlistx_t *ifaddrp);

static boolean_t 	ifaddr_down(ifaddrlistx_t *ifaddrp);

static dladm_status_t	ifconfig_dladm_open(const char *, datalink_class_t,

			    datalink_id_t *);

static void		dladmerr_exit(dladm_status_t status, const char *str);

static void		ipadmerr_exit(ipadm_status_t status, const char *str);

static boolean_t	ifconfig_use_libipadm(int, const char *);

#define	max(a, b)	((a) < (b) ? (b) : (a))

/*

 * DHCP_EXIT_IF_FAILURE indicates that the operation failed, but if there

 * are more interfaces to act on (i.e., ifconfig was invoked with -a), keep

 * on going rather than exit with an error.

 */

#define	DHCP_EXIT_IF_FAILURE	-1

#define	NEXTARG		0xffffff	/* command takes an argument */

#define	OPTARG		0xfffffe 	/* command takes an optional argument */

#define	AF_ANY		(-1)

/* Refer to the comments in ifconfig() on the netmask "hack" */

#define	NETMASK_CMD	"netmask"

struct sockaddr_storage	g_netmask;

enum { G_NETMASK_NIL, G_NETMASK_PENDING, G_NETMASK_SET }

    g_netmask_set = G_NETMASK_NIL;

struct	cmd {

	char		*c_name;

	int64_t		c_parameter;	/* NEXTARG means next argv */

	int		(*c_func)(char *, int64_t);

	int		c_abortonfail;	/* don't continue parsing args */

					/* for the current interface */

	int	c_af;			/* address family restrictions */

} cmds[] = {

	{ "up",		IFF_UP,		setifflags,	0,	AF_ANY },

	{ "down",	-IFF_UP,	setifflags,	0,	AF_ANY },

	{ "trailers",	-IFF_NOTRAILERS, setifflags,	0,	AF_ANY },

	{ "-trailers",	IFF_NOTRAILERS,	setifflags,	0,	AF_ANY },

	{ "arp",	-IFF_NOARP,	setifflags,	0,	AF_INET },

	{ "-arp",	IFF_NOARP,	setifflags,	0,	AF_INET },

	{ "router",	IFF_ROUTER,	setifflags,	0,	AF_ANY },

	{ "-router",	-IFF_ROUTER,	setifflags,	0,	AF_ANY },

	{ "private",	IFF_PRIVATE,	setifflags,	0,	AF_ANY },

	{ "-private",	-IFF_PRIVATE,	setifflags,	0,	AF_ANY },

	{ "xmit",	-IFF_NOXMIT,	setifflags,	0,	AF_ANY },

	{ "-xmit",	IFF_NOXMIT,	setifflags,	0,	AF_ANY },

	{ "-nud",	IFF_NONUD,	setifflags,	0,	AF_INET6 },

	{ "nud",	-IFF_NONUD,	setifflags,	0,	AF_INET6 },

	{ "anycast",	IFF_ANYCAST,	setifflags,	0,	AF_ANY },

	{ "-anycast",	-IFF_ANYCAST,	setifflags,	0,	AF_ANY },

	{ "local",	-IFF_NOLOCAL,	setifflags,	0,	AF_ANY },

	{ "-local",	IFF_NOLOCAL,	setifflags,	0,	AF_ANY },

	{ "deprecated",	IFF_DEPRECATED,	setifflags,	0,	AF_ANY },

	{ "-deprecated", -IFF_DEPRECATED, setifflags,	0,	AF_ANY },

	{ "preferred",	IFF_PREFERRED,	setifflags,	0,	AF_INET6 },

	{ "-preferred",	-IFF_PREFERRED,	setifflags,	0,	AF_INET6 },

	{ "debug",	0,		setdebugflag,	0,	AF_ANY },

	{ "verbose",	0,		setverboseflag,	0,	AF_ANY },

	{ NETMASK_CMD,	NEXTARG,	setifnetmask,	0,	AF_INET },

	{ "metric",	NEXTARG,	setifmetric,	0,	AF_ANY },

	{ "mtu",	NEXTARG,	setifmtu,	0,	AF_ANY },

	{ "index",	NEXTARG,	setifindex,	0,	AF_ANY },

	{ "broadcast",	NEXTARG,	setifbroadaddr,	0,	AF_INET },

	{ "auto-revarp", 0,		setifrevarp,	1,	AF_INET },

	{ "ipmp",	0,		inetipmp,	1,	AF_ANY },

	{ "plumb",	0,		inetplumb,	1,	AF_ANY },

	{ "unplumb",	0,		inetunplumb,	0,	AF_ANY },

	{ "subnet",	NEXTARG,	setifsubnet,	0,	AF_ANY },

	{ "token",	NEXTARG,	setiftoken,	0,	AF_INET6 },

	{ "tsrc",	NEXTARG,	setiftsrc,	0,	AF_ANY },

	{ "tdst",	NEXTARG,	setiftdst,	0,	AF_ANY },

	{ "encr_auth_algs", NEXTARG,	set_tun_esp_auth_alg, 0, AF_ANY },

	{ "encr_algs",	NEXTARG,	set_tun_esp_encr_alg, 0, AF_ANY },

	{ "auth_algs",	NEXTARG,	set_tun_ah_alg,	0,	AF_ANY },

	{ "addif",	NEXTARG,	addif,		1,	AF_ANY },

	{ "removeif",	NEXTARG,	removeif,	1,	AF_ANY },

	{ "modlist",	0,		modlist,	1,	AF_ANY },

	{ "modinsert",	NEXTARG,	modinsert,	1,	AF_ANY },

	{ "modremove",	NEXTARG,	modremove,	1,	AF_ANY },

	{ "failover",	-IFF_NOFAILOVER, setifflags,	1,	AF_ANY },

	{ "-failover",	IFF_NOFAILOVER, setifflags,	1,	AF_ANY },

	{ "standby",	IFF_STANDBY,	setifflags,	1,	AF_ANY },

	{ "-standby",	-IFF_STANDBY,	setifflags,	1,	AF_ANY },

	{ "failed",	IFF_FAILED,	setifflags,	1,	AF_ANY },

	{ "-failed",	-IFF_FAILED,	setifflags,	1,	AF_ANY },

	{ "group",	NEXTARG,	setifgroupname,	1,	AF_ANY },

	{ "configinfo",	0,		configinfo,	1,	AF_ANY },

	{ "encaplimit",	NEXTARG,	set_tun_encap_limit,	0, AF_ANY },

	{ "-encaplimit", 0,		clr_tun_encap_limit,	0, AF_ANY },

	{ "thoplimit",	NEXTARG,	set_tun_hop_limit,	0, AF_ANY },

	{ "set",	NEXTARG,	setifaddr,	0,	AF_ANY },

	{ "destination", NEXTARG,	setifdstaddr,	0,	AF_ANY },

	{ "zone",	NEXTARG,	setzone,	0,	AF_ANY },

	{ "-zone",	0,		setzone,	0,	AF_ANY },

	{ "all-zones",	0,		setallzones,	0,	AF_ANY },

	{ "ether",	OPTARG,		setifether,	0,	AF_ANY },

	{ "usesrc",	NEXTARG,	setifsrc,	0,	AF_ANY },

	/*

	 * NOTE: any additions to this table must also be applied to ifparse

	 *	(usr/src/cmd/cmd-inet/sbin/ifparse/ifparse.c)

	 */

	{ 0,		0,		setifaddr,	0,	AF_ANY },

	{ 0,		0,		setifdstaddr,	0,	AF_ANY },

	{ 0,		0,		0,		0,	0 },

};

typedef struct if_config_cmd {

	uint64_t	iff_flag;

	int		iff_af;

	char		*iff_name;

} if_config_cmd_t;

/*

 * NOTE: print_config_flags() processes this table in order, so we put "up"

 * last so that we can be sure "-failover" will take effect first.  Otherwise,

 * IPMP test addresses will erroneously migrate to the IPMP interface.

 */

static if_config_cmd_t	if_config_cmd_tbl[] = {

	{ IFF_NOTRAILERS,	AF_UNSPEC,	"-trailers"	},

	{ IFF_PRIVATE,		AF_UNSPEC,	"private"	},

	{ IFF_NOXMIT,		AF_UNSPEC,	"-xmit"		},

	{ IFF_ANYCAST,		AF_INET6,	"anycast"	},

	{ IFF_NOLOCAL,		AF_UNSPEC,	"-local"	},

	{ IFF_DEPRECATED,	AF_UNSPEC,	"deprecated"	},

	{ IFF_NOFAILOVER,	AF_UNSPEC,	"-failover"	},

	{ IFF_STANDBY,		AF_UNSPEC,	"standby"	},

	{ IFF_FAILED,		AF_UNSPEC,	"failed"	},

	{ IFF_PREFERRED,	AF_UNSPEC,	"preferred"	},

	{ IFF_NONUD,		AF_INET6,	"-nud"		},

	{ IFF_NOARP,		AF_INET,	"-arp"		},

	{ IFF_UP,		AF_UNSPEC, 	"up" 		},

	{ 0,			0,		NULL		},

};

typedef struct ni {

	char		ni_name[LIFNAMSIZ];

	struct ni	*ni_next;

} ni_t;

static ni_t	*ni_list = NULL;

static int	num_ni = 0;

/* End defines and structure definitions for ifconfig -a plumb */

/* Known address families */

struct afswtch {

	char *af_name;

	short af_af;

	void (*af_status)();

	void (*af_getaddr)();

	void (*af_configinfo)();

} afs[] = {

	{ "inet", AF_INET, in_status, in_getaddr, in_configinfo },

	{ "inet6", AF_INET6, in6_status, in6_getaddr, in6_configinfo },

	{ 0, 0,	0, 0, 0 }

};

#define	SOCKET_AF(af)	(((af) == AF_UNSPEC) ? AF_INET : (af))

struct afswtch *afp;	/* the address family being set or asked about */

int

main(int argc, char *argv[])

{

	int64_t		lifc_flags;

	char		*default_ip_str;

	ipadm_status_t	istatus;

	lifc_flags = LIFC_DEFAULT;

	if (argc < 2) {

		usage();

		exit(1);

	}

	argc--, argv++;

	if (strlen(*argv) > sizeof (name) - 1) {

		(void) fprintf(stderr, "%s: interface name too long\n", *argv);

		exit(1);

	}

	(void) strncpy(name, *argv, sizeof (name));

	name[sizeof (name) - 1] = '\0';

	(void) strncpy(origname, name, sizeof (origname));	/* For addif */

	default_ip_str = NULL;

	v4compat = get_compat_flag(&default_ip_str);

	if (v4compat == DEFAULT_PROT_BAD_VALUE) {

		(void) fprintf(stderr,

		    "ifconfig: %s: Bad value for %s in %s\n", default_ip_str,

		    DEFAULT_IP, INET_DEFAULT_FILE);

		free(default_ip_str);

		exit(2);

	}

	free(default_ip_str);

	argc--, argv++;

	if (argc > 0) {

		struct afswtch *myafp;

		for (myafp = afp = afs; myafp->af_name; myafp++) {

			if (strcmp(myafp->af_name, *argv) == 0) {

				afp = myafp; argc--; argv++;

				break;

			}

		}

		af = lifr.lifr_addr.ss_family = afp->af_af;

		if (af == AF_INET6) {

			v4compat = 0;

		}

	}

	s = socket(SOCKET_AF(af), SOCK_DGRAM, 0);

	s4 = socket(AF_INET, SOCK_DGRAM, 0);

	s6 = socket(AF_INET6, SOCK_DGRAM, 0);

	if (s == -1 || s4 == -1 || s6 == -1)

		Perror0_exit("socket");

	/*

	 * Open the global libipadm handle. The flag IPH_LEGACY has to

	 * be specified to indicate that logical interface names will

	 * be used during interface creation and address creation.

	 */

	if ((istatus = ipadm_open(&iph, IPH_LEGACY)) != IPADM_SUCCESS)

		ipadmerr_exit(istatus, "unable to open handle to libipadm");

	/*

	 * Special interface names is any combination of these flags.

	 * Note that due to the ifconfig syntax they have to be combined

	 * as a single '-' option.

	 *	-a	All interfaces

	 *	-u	"up" interfaces

	 *	-d	"down" interfaces

	 *	-D	Interfaces not controlled by DHCP

	 *	-4	IPv4 interfaces

	 *	-6	IPv6 interfaces

	 *	-X	Turn on debug (not documented)

	 *	-v	Turn on verbose

	 *	-Z	Only interfaces in caller's zone

	 */

	if (name[0] == '-') {

		/* One or more options */

		int64_t onflags = 0;

		int64_t offflags = 0;

		int c;

		char *av[2] = { "ifconfig", name };

		while ((c = getopt(2, av, "audDXZ46v")) != -1) {

			switch ((char)c) {

			case 'a':

				all = 1;

				break;

			case 'u':

				onflags |= IFF_UP;

				break;

			case 'd':

				offflags |= IFF_UP;

				break;

			case 'D':

				offflags |= IFF_DHCPRUNNING;

				break;

			case 'X':

				debug += 3;

				break;

			case 'Z':

				lifc_flags &= ~LIFC_ALLZONES;

				break;

			case '4':

				/*

				 * -4 is not a compatable flag, therefore

				 * we assume they want v4compat turned off

				 */

				v4compat = 0;

				onflags |= IFF_IPV4;

				break;

			case '6':

				/*

				 * If they want IPv6, well then we'll assume

				 * they don't want IPv4 compat

				 */

				v4compat = 0;

				onflags |= IFF_IPV6;

				break;

			case 'v':

				verbose = 1;

				break;

			case '?':

				usage();

				exit(1);

			}

		}

		if (!all) {

			(void) fprintf(stderr,

			    "ifconfig: %s: no such interface\n", name);

			exit(1);

		}

		foreachinterface(argc, argv, af, onflags, offflags,

		    lifc_flags);

	} else {

		ifconfig(argc, argv, af, NULL);

	}

	ipadm_close(iph);

	return (0);

}

/*

 * For each interface, call ifconfig(argc, argv, af, ifa).