/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

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

 * All rights reserved.  The Berkeley software License Agreement

 * specifies the terms and conditions for redistribution.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "defs.h"

#include "strings.h"

#include "ifconfig.h"

#include <compat.h>

#include <sys/dlpi.h>

#include <libdlpi.h>

#define	LOOPBACK_IF	"lo0"

#define	NONE_STR	"none"

#ifndef	ARP_MOD_NAME

#define	ARP_MOD_NAME	"arp"

#endif

#define	ADDRBITS_V4	32	/* number of bits in IPv4 address */

#define	ADDRBITS_V6	128	/* number of bits in IPv6 address */

#define	AF_FUNC_STATUS		1	/* af_status func reports status */

#define	AF_FUNC_CONFIGINFO	2	/* af_status func reports configinfo */

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_MIPRUNNING,	"MIP" },

	{ 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"}

};

static struct	lifreq lifr;

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

static char	name[LIFNAMSIZ];

/* foreach interface saved name */

static char	origname[LIFNAMSIZ];

static char savedname[LIFNAMSIZ];	/* For addif */

static int	setaddr;

static char partname[LIFNAMSIZ];

uid_t	euid;

/*

 * 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

/*

 * iface_t

 * used by setifether to create a list of interfaces to mark

 * down-up when changing the ethernet address of an interface

 */

typedef struct iface {

	struct lifreq lifr;

	struct iface *next;	/* pointer to the next list element */

} iface_t;

static	iface_t	*logifs = NULL; /* list of logical interfaces */

static 	iface_t	*phyif	= NULL;	/* physical interface */

int	s;

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

boolean_t	partial = _B_FALSE;

/*

 * Function prototypes for command functions.

 */

static int	addif(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(uint64_t flags);

static void	print_flags(uint64_t flags);

static void	print_ifether(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	setifsrc(char *arg, int64_t param);

#ifdef DEBUG

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

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

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

#endif /* DEBUG */

/*

 * 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 int	devfs_entry(di_node_t node, di_minor_t minor, void *arg);

static void	foreachinterface(void (*func)(), 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 lifreq *lifrp);

static int	ifdad(char *ifname, struct sockaddr_in6 *laddr);

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 int	settaddr(char *, int (*)(icfg_handle_t,

			    const struct sockaddr *, socklen_t));

static void	status(void);

static void	ifstatus(const char *);

static void	usage(void);

static int	strioctl(int s, int cmd, char *buf, int buflen);

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

		    int argc, char *argv[]);

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

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

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

static int	get_lun(char *);

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

			struct lifreq *lifrp);

static int	updownifs(iface_t *ifs, int up);

#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	DHCP_IPC_MAX_WAIT	15	/* max seconds to wait to start agent */

#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 },

	{ "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 },

#ifdef DEBUG

	{ "getnd",	NEXTARG,	getnd,		0,	AF_INET6 },

	{ "setnd",	NEXTARG,	setnd,		0,	AF_INET6 },

	{ "delnd",	NEXTARG,	delnd,		0,	AF_INET6 },

#endif

/* XXX for testing SIOCT* ioctls. Remove */

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

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

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

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

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

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

	{ 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;

	char		*iff_name;

} if_config_cmd_t;

static if_config_cmd_t	if_config_cmd_tbl[] = {

	{ IFF_UP,		"up" },

	{ IFF_NOTRAILERS,	"-trailers" },

	{ IFF_PRIVATE,		"private" },

	{ IFF_NOXMIT,		"-xmit" },

	{ IFF_ANYCAST,		"anycast" },

	{ IFF_NOLOCAL,		"-local" },

	{ IFF_DEPRECATED,	"deprecated" },

	{ IFF_NOFAILOVER,	"-failover" },

	{ IFF_STANDBY,		"standby" },

	{ IFF_FAILED,		"failed" },

	{ IFF_PREFERRED,	"preferred" },

	{ 0,			0 },

};

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[])

{

	/* Include IFF_NOXMIT, IFF_TEMPORARY and all zone interfaces */

	int64_t lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES;

	char *default_ip_str;

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

	euid = geteuid();

	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);

	if (s < 0) {

		Perror0_exit("socket");

	}

	/*

	 * 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(ifconfig, argc, argv, af, onflags, offflags,

		    lifc_flags);

	} else {

		ifconfig(argc, argv, af, (struct lifreq *)NULL);

	}

	return (0);

}

/*

 * For each interface, call (*func)(argc, argv, af, lifrp).

 * Only call function if onflags and offflags are set or clear, respectively,

 * in the interfaces flags field.

 */

static void

foreachinterface(void (*func)(), int argc, char *argv[], int af,

    int64_t onflags, int64_t offflags, int64_t lifc_flags)

{

	int n;

	char *buf;

	struct lifnum lifn;

	struct lifconf lifc;

	struct lifreq *lifrp;

	struct lifreq lifrl;	/* Local lifreq struct */

	int numifs;

	unsigned bufsize;

	ni_t *nip;

	int plumball = 0;

	int save_af = af;

	/*

	 * Special case:

	 * ifconfig -a plumb should find all network interfaces

	 * in the machine by traversing the devinfo tree.

	 * Also, there is no need to  SIOCGLIF* ioctls, since

	 * those interfaces have already been plumbed

	 */

	if (argc > 0 && (strcmp(*argv, "plumb") == 0)) {

		/*

		 * Look through the kernel's devinfo tree for

		 * network devices

		 */