xref: /titanic_50/usr/src/cmd/cmd-inet/usr.sbin/ifconfig/ifconfig.c (revision 10d63b7db37a83b39c7f511cf9426c9d03ea0760)
1 /*
2  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
3  * Copyright 2012, Daniil Lunev. All rights reserved.
4  * Copyright 2014, OmniTI Computer Consulting, Inc. All rights reserved.
5  */
6 /*
7  * Copyright (c) 1983 Regents of the University of California.
8  * All rights reserved.  The Berkeley software License Agreement
9  * specifies the terms and conditions for redistribution.
10  */
11 
12 #include "defs.h"
13 #include "strings.h"
14 #include "ifconfig.h"
15 #include <compat.h>
16 #include <libdlpi.h>
17 #include <libdllink.h>
18 #include <libdliptun.h>
19 #include <libdllink.h>
20 #include <inet/ip.h>
21 #include <inet/ipsec_impl.h>
22 #include <libipadm.h>
23 #include <ifaddrs.h>
24 #include <libsocket_priv.h>
25 
26 #define	LOOPBACK_IF	"lo0"
27 #define	NONE_STR	"none"
28 #define	ARP_MOD_NAME	"arp"
29 #define	LIFC_DEFAULT	(LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES |\
30 			LIFC_UNDER_IPMP)
31 
32 typedef struct if_flags {
33 	uint64_t iff_value;
34 	char	*iff_name;
35 } if_flags_t;
36 
37 static if_flags_t	if_flags_tbl[] = {
38 	{ IFF_UP,		"UP" },
39 	{ IFF_BROADCAST,	"BROADCAST" },
40 	{ IFF_DEBUG,		"DEBUG" },
41 	{ IFF_LOOPBACK,		"LOOPBACK" },
42 	{ IFF_POINTOPOINT,	"POINTOPOINT" },
43 	{ IFF_NOTRAILERS,	"NOTRAILERS" },
44 	{ IFF_RUNNING,		"RUNNING" },
45 	{ IFF_NOARP,		"NOARP" },
46 	{ IFF_PROMISC,		"PROMISC" },
47 	{ IFF_ALLMULTI,		"ALLMULTI" },
48 	{ IFF_INTELLIGENT,	"INTELLIGENT" },
49 	{ IFF_MULTICAST,	"MULTICAST" },
50 	{ IFF_MULTI_BCAST,	"MULTI_BCAST" },
51 	{ IFF_UNNUMBERED,	"UNNUMBERED" },
52 	{ IFF_DHCPRUNNING,	"DHCP" },
53 	{ IFF_PRIVATE,		"PRIVATE" },
54 	{ IFF_NOXMIT,		"NOXMIT" },
55 	{ IFF_NOLOCAL,		"NOLOCAL" },
56 	{ IFF_DEPRECATED,	"DEPRECATED" },
57 	{ IFF_ADDRCONF,		"ADDRCONF" },
58 	{ IFF_ROUTER,		"ROUTER" },
59 	{ IFF_NONUD,		"NONUD" },
60 	{ IFF_ANYCAST,		"ANYCAST" },
61 	{ IFF_NORTEXCH,		"NORTEXCH" },
62 	{ IFF_IPV4,		"IPv4" },
63 	{ IFF_IPV6,		"IPv6" },
64 	{ IFF_NOFAILOVER,	"NOFAILOVER" },
65 	{ IFF_FAILED,		"FAILED" },
66 	{ IFF_STANDBY,		"STANDBY" },
67 	{ IFF_INACTIVE,		"INACTIVE" },
68 	{ IFF_OFFLINE,		"OFFLINE" },
69 	{ IFF_XRESOLV,		"XRESOLV" },
70 	{ IFF_COS_ENABLED,	"CoS" },
71 	{ IFF_PREFERRED,	"PREFERRED" },
72 	{ IFF_TEMPORARY,	"TEMPORARY" },
73 	{ IFF_FIXEDMTU,		"FIXEDMTU" },
74 	{ IFF_VIRTUAL,		"VIRTUAL" },
75 	{ IFF_DUPLICATE,	"DUPLICATE" },
76 	{ IFF_IPMP,		"IPMP"},
77 	{ IFF_VRRP,		"VRRP"},
78 	{ IFF_NOACCEPT,		"NOACCEPT"},
79 	{ IFF_L3PROTECT,	"L3PROTECT"}
80 };
81 
82 typedef struct {
83 	const char		*ia_app;
84 	uint64_t		ia_flag;
85 	uint_t			ia_tries;
86 } if_appflags_t;
87 
88 static const if_appflags_t if_appflags_tbl[] = {
89 	{ "dhcpagent(1M)",	IFF_DHCPRUNNING,	1 },
90 	{ "in.ndpd(1M)",	IFF_ADDRCONF,		3 },
91 	{  NULL,		0,			0 }
92 };
93 
94 static dladm_handle_t	dlh;
95 boolean_t		dlh_opened;
96 static struct		lifreq lifr;
97 /* current interface name a particular function is accessing */
98 static char		name[LIFNAMSIZ];
99 /* foreach interface saved name */
100 static char		origname[LIFNAMSIZ];
101 static int		setaddr;
102 static boolean_t	setaddr_done = _B_FALSE;
103 static boolean_t	ipsec_policy_set;
104 static boolean_t	ipsec_auth_covered;
105 static ipadm_handle_t	iph;
106 static ipadm_addrobj_t	ipaddr;
107 
108 /*
109  * Make sure the algorithm variables hold more than the sizeof an algorithm
110  * in PF_KEY.  (For now, more than a uint8_t.)  The NO_***_?ALG indicates that
111  * there was no algorithm requested, and in the ipsec_req that service should
112  * be disabled.  (E.g. if ah_aalg remains NO_AH_AALG, then AH will be
113  * disabled on that tunnel.)
114  */
115 #define	NO_AH_AALG 256
116 #define	NO_ESP_AALG 256
117 #define	NO_ESP_EALG 256
118 
119 int	s, s4, s6;
120 int	af = AF_INET;	/* default address family */
121 int	debug = 0;
122 int	all = 0;	/* setifdhcp() needs to know this */
123 int	verbose = 0;
124 int	v4compat = 0;	/* Compatible printing format */
125 
126 /*
127  * Function prototypes for command functions.
128  */
129 static int	addif(char *arg, int64_t param);
130 static int	inetipmp(char *arg, int64_t param);
131 static int	inetplumb(char *arg, int64_t param);
132 static int	inetunplumb(char *arg, int64_t param);
133 static int	removeif(char *arg, int64_t param);
134 static int	setdebugflag(char *arg, int64_t param);
135 static int	setifaddr(char *arg, int64_t param);
136 static int	setifbroadaddr(char *arg, int64_t param);
137 static int	setifdstaddr(char *arg, int64_t param);
138 static int	setifether(char *arg, int64_t param);
139 static int	setifflags(char *arg, int64_t param);
140 static int	setifindex(char *arg, int64_t param);
141 static int	setifmetric(char *arg, int64_t param);
142 static int	setifmtu(char *arg, int64_t param);
143 static int	setifnetmask(char *arg, int64_t param);
144 static int	setifprefixlen(char *arg, int64_t param);
145 static int	setifrevarp(char *arg, int64_t param);
146 static int	setifsubnet(char *arg, int64_t param);
147 static int	setiftdst(char *arg, int64_t param);
148 static int	setiftoken(char *arg, int64_t param);
149 static int	setiftsrc(char *arg, int64_t param);
150 static int	setverboseflag(char *arg, int64_t param);
151 static int	set_tun_ah_alg(char *arg, int64_t param);
152 static int	set_tun_esp_auth_alg(char *arg, int64_t param);
153 static int	set_tun_esp_encr_alg(char *arg, int64_t param);
154 static int	modlist(char *arg, int64_t param);
155 static int	modinsert(char *arg, int64_t param);
156 static int	modremove(char *arg, int64_t param);
157 static int	setifgroupname(char *arg, int64_t param);
158 static int	configinfo(char *arg, int64_t param);
159 static void	print_config_flags(int af, uint64_t flags);
160 static void	print_flags(uint64_t flags);
161 static void	print_ifether(const char *ifname);
162 static int	set_tun_encap_limit(char *arg, int64_t param);
163 static int	clr_tun_encap_limit(char *arg, int64_t param);
164 static int	set_tun_hop_limit(char *arg, int64_t param);
165 static int	setzone(char *arg, int64_t param);
166 static int	setallzones(char *arg, int64_t param);
167 static int	setifsrc(char *arg, int64_t param);
168 static int	lifnum(const char *ifname);
169 static void	plumball(int, char **, int64_t, int64_t, int64_t);
170 
171 /*
172  * Address family specific function prototypes.
173  */
174 static void	in_getaddr(char *s, struct sockaddr *saddr, int *plenp);
175 static void	in_status(int force, uint64_t flags);
176 static void	in_configinfo(int force, uint64_t flags);
177 static void	in6_getaddr(char *s, struct sockaddr *saddr, int *plenp);
178 static void	in6_status(int force, uint64_t flags);
179 static void	in6_configinfo(int force, uint64_t flags);
180 
181 /*
182  * Misc support functions
183  */
184 static boolean_t	ni_entry(const char *, void *);
185 static void		foreachinterface(int argc, char *argv[],
186 			    int af, int64_t onflags, int64_t offflags,
187 			    int64_t lifc_flags);
188 static void		ifconfig(int argc, char *argv[], int af,
189 			    struct ifaddrs *ifa);
190 static boolean_t	in_getmask(struct sockaddr_in *saddr,
191 			    boolean_t addr_set);
192 static int		in_getprefixlen(char *addr, boolean_t slash, int plen);
193 static boolean_t	in_prefixlentomask(int prefixlen, int maxlen,
194 			    uchar_t *mask);
195 static void		status(void);
196 static void		ifstatus(const char *ifname);
197 static void		tun_status(datalink_id_t);
198 static void		usage(void);
199 static int		setifdhcp(const char *caller, const char *ifname,
200 			    int argc, char *argv[]);
201 static int		ip_domux2fd(int *, int *, int *, int *, int *);
202 static int		ip_plink(int, int, int, int, int);
203 static int		modop(char *arg, char op);
204 static int		find_all_interfaces(struct lifconf *lifcp, char **buf,
205 			    int64_t lifc_flags);
206 static int		create_ipmp(const char *grname, int af,
207 			    const char *ifname, boolean_t implicit);
208 static void		start_ipmp_daemon(void);
209 static boolean_t 	ifaddr_up(ifaddrlistx_t *ifaddrp);
210 static boolean_t 	ifaddr_down(ifaddrlistx_t *ifaddrp);
211 static dladm_status_t	ifconfig_dladm_open(const char *, datalink_class_t,
212 			    datalink_id_t *);
213 static void		dladmerr_exit(dladm_status_t status, const char *str);
214 static void		ipadmerr_exit(ipadm_status_t status, const char *str);
215 static boolean_t	ifconfig_use_libipadm(int, const char *);
216 
217 #define	max(a, b)	((a) < (b) ? (b) : (a))
218 
219 /*
220  * DHCP_EXIT_IF_FAILURE indicates that the operation failed, but if there
221  * are more interfaces to act on (i.e., ifconfig was invoked with -a), keep
222  * on going rather than exit with an error.
223  */
224 
225 #define	DHCP_EXIT_IF_FAILURE	-1
226 
227 #define	NEXTARG		0xffffff	/* command takes an argument */
228 #define	OPTARG		0xfffffe 	/* command takes an optional argument */
229 #define	AF_ANY		(-1)
230 
231 /* Refer to the comments in ifconfig() on the netmask "hack" */
232 #define	NETMASK_CMD	"netmask"
233 struct sockaddr_storage	g_netmask;
234 enum { G_NETMASK_NIL, G_NETMASK_PENDING, G_NETMASK_SET }
235     g_netmask_set = G_NETMASK_NIL;
236 
237 struct	cmd {
238 	char		*c_name;
239 	int64_t		c_parameter;	/* NEXTARG means next argv */
240 	int		(*c_func)(char *, int64_t);
241 	int		c_abortonfail;	/* don't continue parsing args */
242 					/* for the current interface */
243 	int	c_af;			/* address family restrictions */
244 } cmds[] = {
245 	{ "up",		IFF_UP,		setifflags,	0,	AF_ANY },
246 	{ "down",	-IFF_UP,	setifflags,	0,	AF_ANY },
247 	{ "trailers",	-IFF_NOTRAILERS, setifflags,	0,	AF_ANY },
248 	{ "-trailers",	IFF_NOTRAILERS,	setifflags,	0,	AF_ANY },
249 	{ "arp",	-IFF_NOARP,	setifflags,	0,	AF_INET },
250 	{ "-arp",	IFF_NOARP,	setifflags,	0,	AF_INET },
251 	{ "router",	IFF_ROUTER,	setifflags,	0,	AF_ANY },
252 	{ "-router",	-IFF_ROUTER,	setifflags,	0,	AF_ANY },
253 	{ "private",	IFF_PRIVATE,	setifflags,	0,	AF_ANY },
254 	{ "-private",	-IFF_PRIVATE,	setifflags,	0,	AF_ANY },
255 	{ "xmit",	-IFF_NOXMIT,	setifflags,	0,	AF_ANY },
256 	{ "-xmit",	IFF_NOXMIT,	setifflags,	0,	AF_ANY },
257 	{ "-nud",	IFF_NONUD,	setifflags,	0,	AF_INET6 },
258 	{ "nud",	-IFF_NONUD,	setifflags,	0,	AF_INET6 },
259 	{ "anycast",	IFF_ANYCAST,	setifflags,	0,	AF_ANY },
260 	{ "-anycast",	-IFF_ANYCAST,	setifflags,	0,	AF_ANY },
261 	{ "local",	-IFF_NOLOCAL,	setifflags,	0,	AF_ANY },
262 	{ "-local",	IFF_NOLOCAL,	setifflags,	0,	AF_ANY },
263 	{ "deprecated",	IFF_DEPRECATED,	setifflags,	0,	AF_ANY },
264 	{ "-deprecated", -IFF_DEPRECATED, setifflags,	0,	AF_ANY },
265 	{ "preferred",	IFF_PREFERRED,	setifflags,	0,	AF_INET6 },
266 	{ "-preferred",	-IFF_PREFERRED,	setifflags,	0,	AF_INET6 },
267 	{ "debug",	0,		setdebugflag,	0,	AF_ANY },
268 	{ "verbose",	0,		setverboseflag,	0,	AF_ANY },
269 	{ NETMASK_CMD,	NEXTARG,	setifnetmask,	0,	AF_INET },
270 	{ "metric",	NEXTARG,	setifmetric,	0,	AF_ANY },
271 	{ "mtu",	NEXTARG,	setifmtu,	0,	AF_ANY },
272 	{ "index",	NEXTARG,	setifindex,	0,	AF_ANY },
273 	{ "broadcast",	NEXTARG,	setifbroadaddr,	0,	AF_INET },
274 	{ "auto-revarp", 0,		setifrevarp,	1,	AF_INET },
275 	{ "ipmp",	0,		inetipmp,	1,	AF_ANY },
276 	{ "plumb",	0,		inetplumb,	1,	AF_ANY },
277 	{ "unplumb",	0,		inetunplumb,	0,	AF_ANY },
278 	{ "subnet",	NEXTARG,	setifsubnet,	0,	AF_ANY },
279 	{ "token",	NEXTARG,	setiftoken,	0,	AF_INET6 },
280 	{ "tsrc",	NEXTARG,	setiftsrc,	0,	AF_ANY },
281 	{ "tdst",	NEXTARG,	setiftdst,	0,	AF_ANY },
282 	{ "encr_auth_algs", NEXTARG,	set_tun_esp_auth_alg, 0, AF_ANY },
283 	{ "encr_algs",	NEXTARG,	set_tun_esp_encr_alg, 0, AF_ANY },
284 	{ "auth_algs",	NEXTARG,	set_tun_ah_alg,	0,	AF_ANY },
285 	{ "addif",	NEXTARG,	addif,		1,	AF_ANY },
286 	{ "removeif",	NEXTARG,	removeif,	1,	AF_ANY },
287 	{ "modlist",	0,		modlist,	1,	AF_ANY },
288 	{ "modinsert",	NEXTARG,	modinsert,	1,	AF_ANY },
289 	{ "modremove",	NEXTARG,	modremove,	1,	AF_ANY },
290 	{ "failover",	-IFF_NOFAILOVER, setifflags,	1,	AF_ANY },
291 	{ "-failover",	IFF_NOFAILOVER, setifflags,	1,	AF_ANY },
292 	{ "standby",	IFF_STANDBY,	setifflags,	1,	AF_ANY },
293 	{ "-standby",	-IFF_STANDBY,	setifflags,	1,	AF_ANY },
294 	{ "failed",	IFF_FAILED,	setifflags,	1,	AF_ANY },
295 	{ "-failed",	-IFF_FAILED,	setifflags,	1,	AF_ANY },
296 	{ "group",	NEXTARG,	setifgroupname,	1,	AF_ANY },
297 	{ "configinfo",	0,		configinfo,	1,	AF_ANY },
298 	{ "encaplimit",	NEXTARG,	set_tun_encap_limit,	0, AF_ANY },
299 	{ "-encaplimit", 0,		clr_tun_encap_limit,	0, AF_ANY },
300 	{ "thoplimit",	NEXTARG,	set_tun_hop_limit,	0, AF_ANY },
301 	{ "set",	NEXTARG,	setifaddr,	0,	AF_ANY },
302 	{ "destination", NEXTARG,	setifdstaddr,	0,	AF_ANY },
303 	{ "zone",	NEXTARG,	setzone,	0,	AF_ANY },
304 	{ "-zone",	0,		setzone,	0,	AF_ANY },
305 	{ "all-zones",	0,		setallzones,	0,	AF_ANY },
306 	{ "ether",	OPTARG,		setifether,	0,	AF_ANY },
307 	{ "usesrc",	NEXTARG,	setifsrc,	0,	AF_ANY },
308 
309 	/*
310 	 * NOTE: any additions to this table must also be applied to ifparse
311 	 *	(usr/src/cmd/cmd-inet/sbin/ifparse/ifparse.c)
312 	 */
313 
314 	{ 0,		0,		setifaddr,	0,	AF_ANY },
315 	{ 0,		0,		setifdstaddr,	0,	AF_ANY },
316 	{ 0,		0,		0,		0,	0 },
317 };
318 
319 
320 typedef struct if_config_cmd {
321 	uint64_t	iff_flag;
322 	int		iff_af;
323 	char		*iff_name;
324 } if_config_cmd_t;
325 
326 /*
327  * NOTE: print_config_flags() processes this table in order, so we put "up"
328  * last so that we can be sure "-failover" will take effect first.  Otherwise,
329  * IPMP test addresses will erroneously migrate to the IPMP interface.
330  */
331 static if_config_cmd_t	if_config_cmd_tbl[] = {
332 	{ IFF_NOTRAILERS,	AF_UNSPEC,	"-trailers"	},
333 	{ IFF_PRIVATE,		AF_UNSPEC,	"private"	},
334 	{ IFF_NOXMIT,		AF_UNSPEC,	"-xmit"		},
335 	{ IFF_ANYCAST,		AF_INET6,	"anycast"	},
336 	{ IFF_NOLOCAL,		AF_UNSPEC,	"-local"	},
337 	{ IFF_DEPRECATED,	AF_UNSPEC,	"deprecated"	},
338 	{ IFF_NOFAILOVER,	AF_UNSPEC,	"-failover"	},
339 	{ IFF_STANDBY,		AF_UNSPEC,	"standby"	},
340 	{ IFF_FAILED,		AF_UNSPEC,	"failed"	},
341 	{ IFF_PREFERRED,	AF_UNSPEC,	"preferred"	},
342 	{ IFF_NONUD,		AF_INET6,	"-nud"		},
343 	{ IFF_NOARP,		AF_INET,	"-arp"		},
344 	{ IFF_UP,		AF_UNSPEC, 	"up" 		},
345 	{ 0,			0,		NULL		},
346 };
347 
348 typedef struct ni {
349 	char		ni_name[LIFNAMSIZ];
350 	struct ni	*ni_next;
351 } ni_t;
352 
353 static ni_t	*ni_list = NULL;
354 static int	num_ni = 0;
355 
356 /* End defines and structure definitions for ifconfig -a plumb */
357 
358 /* Known address families */
359 struct afswtch {
360 	char *af_name;
361 	short af_af;
362 	void (*af_status)();
363 	void (*af_getaddr)();
364 	void (*af_configinfo)();
365 } afs[] = {
366 	{ "inet", AF_INET, in_status, in_getaddr, in_configinfo },
367 	{ "inet6", AF_INET6, in6_status, in6_getaddr, in6_configinfo },
368 	{ 0, 0,	0, 0, 0 }
369 };
370 
371 #define	SOCKET_AF(af)	(((af) == AF_UNSPEC) ? AF_INET : (af))
372 
373 struct afswtch *afp;	/* the address family being set or asked about */
374 
375 int
376 main(int argc, char *argv[])
377 {
378 	int64_t		lifc_flags;
379 	char		*default_ip_str;
380 	ipadm_status_t	istatus;
381 
382 	lifc_flags = LIFC_DEFAULT;
383 
384 	if (argc < 2) {
385 		(void) strncpy(name, "-a", sizeof (name));
386 	} else {
387 		argc--, argv++;
388 		if (strlen(*argv) > sizeof (name) - 1) {
389 			(void) fprintf(stderr, "%s: interface name too long\n",
390 			    *argv);
391 			exit(1);
392 		}
393 		(void) strncpy(name, *argv, sizeof (name));
394 	}
395 	name[sizeof (name) - 1] = '\0';
396 	(void) strncpy(origname, name, sizeof (origname));	/* For addif */
397 	default_ip_str = NULL;
398 	v4compat = get_compat_flag(&default_ip_str);
399 	if (v4compat == DEFAULT_PROT_BAD_VALUE) {
400 		(void) fprintf(stderr,
401 		    "ifconfig: %s: Bad value for %s in %s\n", default_ip_str,
402 		    DEFAULT_IP, INET_DEFAULT_FILE);
403 		free(default_ip_str);
404 		exit(2);
405 	}
406 	free(default_ip_str);
407 	argc--, argv++;
408 	if (argc > 0) {
409 		struct afswtch *myafp;
410 
411 		for (myafp = afp = afs; myafp->af_name; myafp++) {
412 			if (strcmp(myafp->af_name, *argv) == 0) {
413 				afp = myafp; argc--; argv++;
414 				break;
415 			}
416 		}
417 		af = lifr.lifr_addr.ss_family = afp->af_af;
418 		if (af == AF_INET6) {
419 			v4compat = 0;
420 		}
421 	}
422 
423 	s = socket(SOCKET_AF(af), SOCK_DGRAM, 0);
424 	s4 = socket(AF_INET, SOCK_DGRAM, 0);
425 	s6 = socket(AF_INET6, SOCK_DGRAM, 0);
426 	if (s == -1 || s4 == -1 || s6 == -1)
427 		Perror0_exit("socket");
428 	/*
429 	 * Open the global libipadm handle. The flag IPH_LEGACY has to
430 	 * be specified to indicate that logical interface names will
431 	 * be used during interface creation and address creation.
432 	 */
433 	if ((istatus = ipadm_open(&iph, IPH_LEGACY)) != IPADM_SUCCESS)
434 		ipadmerr_exit(istatus, "unable to open handle to libipadm");
435 
436 	/*
437 	 * Special interface names is any combination of these flags.
438 	 * Note that due to the ifconfig syntax they have to be combined
439 	 * as a single '-' option.
440 	 *	-a	All interfaces
441 	 *	-u	"up" interfaces
442 	 *	-d	"down" interfaces
443 	 *	-D	Interfaces not controlled by DHCP
444 	 *	-4	IPv4 interfaces
445 	 *	-6	IPv6 interfaces
446 	 *	-X	Turn on debug (not documented)
447 	 *	-v	Turn on verbose
448 	 *	-Z	Only interfaces in caller's zone
449 	 */
450 
451 	if (name[0] == '-') {
452 		/* One or more options */
453 		int64_t onflags = 0;
454 		int64_t offflags = 0;
455 		int c;
456 		char *av[2] = { "ifconfig", name };
457 
458 		while ((c = getopt(2, av, "audhDXZ46v")) != -1) {
459 			switch ((char)c) {
460 			case 'a':
461 				all = 1;
462 				break;
463 			case 'u':
464 				onflags |= IFF_UP;
465 				break;
466 			case 'd':
467 				offflags |= IFF_UP;
468 				break;
469 			case 'D':
470 				offflags |= IFF_DHCPRUNNING;
471 				break;
472 			case 'X':
473 				debug += 3;
474 				break;
475 			case 'Z':
476 				lifc_flags &= ~LIFC_ALLZONES;
477 				break;
478 			case '4':
479 				/*
480 				 * -4 is not a compatable flag, therefore
481 				 * we assume they want v4compat turned off
482 				 */
483 				v4compat = 0;
484 				onflags |= IFF_IPV4;
485 				break;
486 			case '6':
487 				/*
488 				 * If they want IPv6, well then we'll assume
489 				 * they don't want IPv4 compat
490 				 */
491 				v4compat = 0;
492 				onflags |= IFF_IPV6;
493 				break;
494 			case 'v':
495 				verbose = 1;
496 				break;
497 			case 'h':
498 			case '?':
499 				usage();
500 				exit(1);
501 			}
502 		}
503 		if (!all) {
504 			(void) fprintf(stderr,
505 			    "ifconfig: %s: no such interface\n", name);
506 			exit(1);
507 		}
508 		foreachinterface(argc, argv, af, onflags, offflags,
509 		    lifc_flags);
510 	} else {
511 		ifconfig(argc, argv, af, NULL);
512 	}
513 	ipadm_close(iph);
514 	return (0);
515 }
516 
517 /*
518  * For each interface, call ifconfig(argc, argv, af, ifa).
519  * Only call function if onflags and offflags are set or clear, respectively,
520  * in the interfaces flags field.
521  */
522 static void
523 foreachinterface(int argc, char *argv[], int af,
524     int64_t onflags, int64_t offflags, int64_t lifc_flags)
525 {
526 	ipadm_addr_info_t *ainfo, *ainfop;
527 	struct ifaddrs *ifa;
528 	ipadm_status_t istatus;
529 
530 	/*
531 	 * Special case:
532 	 * ifconfig -a plumb should find all network interfaces in the current
533 	 * zone.
534 	 */
535 	if (argc > 0 && (strcmp(*argv, "plumb") == 0)) {
536 		plumball(argc, argv, onflags, offflags, lifc_flags);
537 		return;
538 	}
539 	/* Get all addresses in kernel including addresses that are zero. */
540 	istatus = ipadm_addr_info(iph, NULL, &ainfo, IPADM_OPT_ZEROADDR,
541 	    lifc_flags);
542 	if (istatus != IPADM_SUCCESS)
543 		ipadmerr_exit(istatus, "could not get addresses from kernel");
544 
545 	/*
546 	 * For each logical interface, call ifconfig() with the
547 	 * given arguments.
548 	 */
549 	for (ainfop = ainfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
550 		if (ainfop->ia_state == IFA_DISABLED)
551 			continue;
552 		ifa = &ainfop->ia_ifa;
553 		if (onflags || offflags) {
554 			if ((ifa->ifa_flags & onflags) != onflags)
555 				continue;
556 			if ((~ifa->ifa_flags & offflags) != offflags)
557 				continue;
558 		}
559 		s = (ifa->ifa_addr->sa_family == AF_INET ? s4 : s6);
560 		(void) strncpy(name, ifa->ifa_name, sizeof (name));
561 		(void) strncpy(origname, name, sizeof (origname));
562 		ifconfig(argc, argv, af, ifa);
563 	}
564 	ipadm_free_addr_info(ainfo);
565 }
566 
567 /*
568  * Used for `ifconfig -a plumb'. Finds all datalinks and plumbs the interface.
569  */
570 static void
571 plumball(int argc, char *argv[], int64_t onflags, int64_t offflags,
572     int64_t lifc_flags)
573 {
574 	int n;
575 	struct lifreq *lifrp;
576 	struct lifconf lifc;
577 	char *buf;
578 
579 	if (onflags != 0 || offflags != 0) {
580 		(void) fprintf(stderr, "ifconfig: invalid syntax used to "
581 		    "plumb all interfaces.\n");
582 		exit(1);
583 	}
584 
585 	if (find_all_interfaces(&lifc, &buf, lifc_flags) != 0 ||
586 	    lifc.lifc_len == 0)
587 		return;
588 
589 	lifrp = lifc.lifc_req;
590 	for (n = lifc.lifc_len / sizeof (struct lifreq); n > 0; n--, lifrp++) {
591 		/*
592 		 * Reset global state
593 		 * setaddr: Used by parser to tear apart source and dest
594 		 * name and origname contain the name of the 'current'
595 		 * interface.
596 		 */
597 		setaddr = 0;
598 		(void) strncpy(name, lifrp->lifr_name, sizeof (name));
599 		(void) strncpy(origname, name, sizeof (origname));
600 		ifconfig(argc, argv, af, NULL);
601 	}
602 }
603 
604 /*
605  * Parses the interface name and the command in argv[]. Calls the
606  * appropriate callback function for the given command from `cmds[]'
607  * table.
608  * If there is no command specified, it prints all addresses.
609  */
610 static void
611 ifconfig(int argc, char *argv[], int af, struct ifaddrs *ifa)
612 {
613 	static boolean_t scan_netmask = _B_FALSE;
614 	int ret;
615 	ipadm_status_t istatus;
616 	struct lifreq lifr;
617 
618 	if (argc == 0) {
619 		status();
620 		return;
621 	}
622 
623 	if (strcmp(*argv, "auto-dhcp") == 0 || strcmp(*argv, "dhcp") == 0) {
624 		/*
625 		 * Some errors are ignored in the case where more than one
626 		 * interface is being operated on.
627 		 */
628 		ret = setifdhcp("ifconfig", name, argc, argv);
629 		if (ret == DHCP_EXIT_IF_FAILURE) {
630 			if (!all)
631 				exit(DHCP_EXIT_FAILURE);
632 		} else if (ret != DHCP_EXIT_SUCCESS) {
633 			exit(ret);
634 		}
635 		return;
636 	}
637 
638 	/*
639 	 * The following is a "hack" to get around the existing interface
640 	 * setting mechanism.  Currently, each interface attribute,
641 	 * such as address, netmask, broadcast, ... is set separately.  But
642 	 * sometimes two or more attributes must be set together.  For
643 	 * example, setting an address without a netmask does not make sense.
644 	 * Yet they can be set separately for IPv4 address using the current
645 	 * ifconfig(1M) syntax.  The kernel then "infers" the correct netmask
646 	 * using the deprecated "IP address classes."  This is simply not
647 	 * correct.
648 	 *
649 	 * The "hack" below is to go thru the whole command list looking for
650 	 * the netmask command first.  Then use this netmask to set the
651 	 * address.  This does not provide an extensible way to accommodate
652 	 * future need for setting more than one attributes together.
653 	 *
654 	 * Note that if the "netmask" command argument is a "+", we need
655 	 * to save this info and do the query after we know the address to
656 	 * be set.  The reason is that if "addif" is used, the working
657 	 * interface name will be changed later when the logical interface
658 	 * is created.  In in_getmask(), if an address is not provided,
659 	 * it will use the working interface's address to do the query.
660 	 * It will be wrong now as we don't know the logical interface's name.
661 	 *
662 	 * ifconfig(1M) is too overloaded and the code is so convoluted
663 	 * that it is "safer" not to re-architect the code to fix the above
664 	 * issue, hence this "hack."  We may be better off to have a new
665 	 * command with better syntax for configuring network interface
666 	 * parameters...
667 	 */
668 	if (!scan_netmask && afp->af_af == AF_INET) {
669 		int	largc;
670 		char	**largv;
671 
672 		/* Only go thru the command list once to find the netmask. */
673 		scan_netmask = _B_TRUE;
674 
675 		/*
676 		 * Currently, if multiple netmask commands are specified, the
677 		 * last one will be used as the final netmask.  So we need
678 		 * to scan the whole list to preserve this behavior.
679 		 */
680 		for (largc = argc, largv = argv; largc > 0; largc--, largv++) {
681 			if (strcmp(*largv, NETMASK_CMD) == 0) {
682 				if (--largc == 0)
683 					break;
684 				largv++;
685 				if (strcmp(*largv, "+") == 0) {
686 					g_netmask_set = G_NETMASK_PENDING;
687 				} else {
688 					in_getaddr(*largv, (struct sockaddr *)
689 					    &g_netmask, NULL);
690 					g_netmask_set = G_NETMASK_SET;
691 				}
692 				/* Continue the scan. */
693 			}
694 		}
695 	}
696 
697 	while (argc > 0) {
698 		struct cmd *p;
699 		boolean_t found_cmd;
700 
701 		if (debug)
702 			(void) printf("ifconfig: argv %s\n", *argv);
703 
704 		found_cmd = _B_FALSE;
705 		for (p = cmds; p->c_func; p++) {
706 			if (p->c_name) {
707 				if (strcmp(*argv, p->c_name) == 0) {
708 					/*
709 					 * indicate that the command was
710 					 * found and check to see if
711 					 * the address family is valid
712 					 */
713 					found_cmd = _B_TRUE;
714 					if (p->c_af == AF_ANY ||
715 					    af == p->c_af)
716 						break;
717 				}
718 			} else {
719 				if (p->c_af == AF_ANY ||
720 				    af == p->c_af)
721 					break;
722 			}
723 		}
724 		/*
725 		 * If we found the keyword, but the address family
726 		 * did not match spit out an error
727 		 */
728 		if (found_cmd && p->c_name == 0) {
729 			(void) fprintf(stderr, "ifconfig: Operation %s not"
730 			    " supported for %s\n", *argv, afp->af_name);
731 			exit(1);
732 		}
733 		/*
734 		 * else (no keyword found), we assume it's an address
735 		 * of some sort
736 		 */
737 		if (setaddr && ipaddr != NULL) {
738 			/*
739 			 * We must have already filled in a source address in
740 			 * `ipaddr' and we now got a destination address.
741 			 * Fill it in `ipaddr' and call libipadm to create
742 			 * the static address.
743 			 */
744 			if (p->c_name == 0) {
745 				istatus = ipadm_set_dst_addr(ipaddr, *argv,
746 				    (p->c_af == AF_ANY ? AF_UNSPEC : af));
747 				if (istatus != IPADM_SUCCESS) {
748 					ipadmerr_exit(istatus, "could not "
749 					    "set destination address");
750 				}
751 				/*
752 				 * finished processing dstaddr, so reset setaddr
753 				 */
754 				setaddr = 0;
755 			}
756 			/*
757 			 * Both source and destination address are in `ipaddr'.
758 			 * Add the address by calling libipadm.
759 			 */
760 			istatus = ipadm_create_addr(iph, ipaddr,
761 			    IPADM_OPT_ACTIVE);
762 			if (istatus != IPADM_SUCCESS)
763 				goto createfailed;
764 			ipadm_destroy_addrobj(ipaddr);
765 			ipaddr = NULL;
766 			setaddr_done = _B_TRUE;
767 			if (p->c_name == 0) {
768 				/* move parser along */
769 				argc--, argv++;
770 				continue;
771 			}
772 		}
773 		if (p->c_name == 0 && setaddr_done) {
774 			/*
775 			 * catch odd commands like
776 			 * "ifconfig <intf> addr1 addr2 addr3 addr4 up"
777 			 */
778 			(void) fprintf(stderr, "%s",
779 			    "ifconfig: cannot configure more than two "
780 			    "addresses in one command\n");
781 			exit(1);
782 		}
783 		if (p->c_func) {
784 			if (p->c_af == AF_INET6) {
785 				v4compat = 0;
786 			}
787 			if (p->c_parameter == NEXTARG ||
788 			    p->c_parameter == OPTARG) {
789 				argc--, argv++;
790 				if (argc == 0 && p->c_parameter == NEXTARG) {
791 					(void) fprintf(stderr,
792 					    "ifconfig: no argument for %s\n",
793 					    p->c_name);
794 					exit(1);
795 				}
796 			}
797 			/*
798 			 *	Call the function if:
799 			 *
800 			 *		there's no address family
801 			 *		restriction
802 			 *	OR
803 			 *		we don't know the address yet
804 			 *		(because we were called from
805 			 *		main)
806 			 *	OR
807 			 *		there is a restriction AND
808 			 *		the address families match
809 			 */
810 			if ((p->c_af == AF_ANY)	||
811 			    (ifa == NULL) ||
812 			    (ifa->ifa_addr->sa_family == p->c_af)) {
813 				ret = (*p->c_func)(*argv, p->c_parameter);
814 				/*
815 				 *	If c_func failed and we should
816 				 *	abort processing for this
817 				 *	interface on failure, return
818 				 *	now rather than going on to
819 				 *	process other commands for
820 				 *	the same interface.
821 				 */
822 				if (ret != 0 && p->c_abortonfail)
823 					return;
824 			}
825 		}
826 		argc--, argv++;
827 	}
828 
829 	if (setaddr && ipaddr != NULL) {
830 		/*
831 		 * Only the source address was provided, which was already
832 		 * set in `ipaddr'. Add the address by calling libipadm.
833 		 */
834 		istatus = ipadm_create_addr(iph, ipaddr, IPADM_OPT_ACTIVE);
835 		if (istatus != IPADM_SUCCESS)
836 			goto createfailed;
837 		ipadm_destroy_addrobj(ipaddr);
838 		ipaddr = NULL;
839 		setaddr_done = _B_TRUE;
840 	}
841 
842 	/* Check to see if there's a security hole in the tunnel setup. */
843 	if (ipsec_policy_set && !ipsec_auth_covered) {
844 		(void) fprintf(stderr, "ifconfig: WARNING: tunnel with only "
845 		    "ESP and no authentication.\n");
846 	}
847 	return;
848 
849 createfailed:
850 	(void) fprintf(stderr, "ifconfig: could not create address:% s\n",
851 	    ipadm_status2str(istatus));
852 	/* Remove the newly created logical interface. */
853 	if (strcmp(name, origname) != 0) {
854 		assert(strchr(name, ':') != NULL);
855 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
856 		(void) ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifr);
857 	}
858 	exit(1);
859 }
860 
861 /* ARGSUSED */
862 static int
863 setdebugflag(char *val, int64_t arg)
864 {
865 	debug++;
866 	return (0);
867 }
868 
869 /* ARGSUSED */
870 static int
871 setverboseflag(char *val, int64_t arg)
872 {
873 	verbose++;
874 	return (0);
875 }
876 
877 /*
878  * This function fills in the given lifreq's lifr_addr field based on
879  * g_netmask_set.
880  */
881 static void
882 set_mask_lifreq(struct lifreq *lifr, struct sockaddr_storage *addr,
883     struct sockaddr_storage *mask)
884 {
885 	assert(addr != NULL);
886 	assert(mask != NULL);
887 
888 	switch (g_netmask_set) {
889 	case G_NETMASK_SET:
890 		lifr->lifr_addr = g_netmask;
891 		break;
892 
893 	case G_NETMASK_PENDING:
894 		/*
895 		 * "+" is used as the argument to "netmask" command.  Query
896 		 * the database on the correct netmask based on the address to
897 		 * be set.
898 		 */
899 		assert(afp->af_af == AF_INET);
900 		g_netmask = *addr;
901 		if (!in_getmask((struct sockaddr_in *)&g_netmask, _B_TRUE)) {
902 			lifr->lifr_addr = *mask;
903 			g_netmask_set = G_NETMASK_NIL;
904 		} else {
905 			lifr->lifr_addr = g_netmask;
906 			g_netmask_set = G_NETMASK_SET;
907 		}
908 		break;
909 
910 	case G_NETMASK_NIL:
911 	default:
912 		lifr->lifr_addr = *mask;
913 		break;
914 	}
915 }
916 
917 /*
918  * Set the interface address. Handles <addr>, <addr>/<n> as well as /<n>
919  * syntax for setting the address, the address plus netmask, and just
920  * the netmask respectively.
921  */
922 /* ARGSUSED */
923 static int
924 setifaddr(char *addr, int64_t param)
925 {
926 	ipadm_status_t istatus;
927 	int prefixlen = 0;
928 	struct  lifreq lifr1;
929 	struct	sockaddr_storage laddr;
930 	struct	sockaddr_storage netmask;
931 	struct	sockaddr_in6 *sin6;
932 	struct	sockaddr_in *sin;
933 	struct	sockaddr_storage sav_netmask;
934 	char cidraddr[BUFSIZ];
935 
936 	if (addr[0] == '/')
937 		return (setifprefixlen(addr, 0));
938 
939 	(*afp->af_getaddr)(addr, (struct sockaddr *)&laddr, &prefixlen);
940 
941 	(void) memset(&netmask, 0, sizeof (netmask));
942 	netmask.ss_family = afp->af_af;
943 	switch (prefixlen) {
944 	case NO_PREFIX:
945 		/* Nothing there - ok */
946 		break;
947 	case BAD_ADDR:
948 		(void) fprintf(stderr, "ifconfig: Bad prefix length in %s\n",
949 		    addr);
950 		exit(1);
951 	default:
952 		if (afp->af_af == AF_INET6) {
953 			sin6 = (struct sockaddr_in6 *)&netmask;
954 			if (!in_prefixlentomask(prefixlen, IPV6_ABITS,
955 			    (uchar_t *)&sin6->sin6_addr)) {
956 				(void) fprintf(stderr, "ifconfig: "
957 				    "Bad prefix length: %d\n",
958 				    prefixlen);
959 				exit(1);
960 			}
961 		} else {
962 			sin = (struct sockaddr_in *)&netmask;
963 			if (!in_prefixlentomask(prefixlen, IP_ABITS,
964 			    (uchar_t *)&sin->sin_addr)) {
965 				(void) fprintf(stderr, "ifconfig: "
966 				    "Bad prefix length: %d\n",
967 				    prefixlen);
968 				exit(1);
969 			}
970 		}
971 		/*
972 		 * Just in case of funny setting of both prefix and netmask,
973 		 * prefix should override the netmask command.
974 		 */
975 		g_netmask_set = G_NETMASK_NIL;
976 		break;
977 	}
978 
979 	/*
980 	 * Check and see if any "netmask" command is used and perform the
981 	 * necessary operation.
982 	 */
983 	set_mask_lifreq(&lifr, &laddr, &netmask);
984 
985 	/* This check is temporary until libipadm supports IPMP interfaces. */
986 	if (ifconfig_use_libipadm(s, name)) {
987 		char	addrstr[INET6_ADDRSTRLEN];
988 
989 		if (af == AF_INET) {
990 			sin = (struct sockaddr_in *)&laddr;
991 			(void) inet_ntop(AF_INET, &sin->sin_addr, addrstr,
992 			    sizeof (addrstr));
993 		} else {
994 			sin6 = (struct sockaddr_in6 *)&laddr;
995 			(void) inet_ntop(AF_INET6, &sin6->sin6_addr, addrstr,
996 			    sizeof (addrstr));
997 		}
998 		istatus = ipadm_create_addrobj(IPADM_ADDR_STATIC, name,
999 		    &ipaddr);
1000 		if (istatus != IPADM_SUCCESS)
1001 			ipadmerr_exit(istatus, "setifaddr");
1002 
1003 		/*
1004 		 * lifr.lifr_addr, which is updated by set_mask_lifreq()
1005 		 * will contain the right mask to use.
1006 		 */
1007 		prefixlen = mask2plen((struct sockaddr *)&lifr.lifr_addr);
1008 		(void) snprintf(cidraddr, sizeof (cidraddr), "%s/%d",
1009 		    addrstr, prefixlen);
1010 
1011 		istatus = ipadm_set_addr(ipaddr, cidraddr, af);
1012 		if (istatus != IPADM_SUCCESS)
1013 			ipadmerr_exit(istatus, "could not set address");
1014 		/*
1015 		 * let parser know we got a source.
1016 		 * Next address, if given, should be dest
1017 		 */
1018 		setaddr++;
1019 
1020 		/*
1021 		 * address will be set by the parser after nextarg has
1022 		 * been scanned
1023 		 */
1024 		return (0);
1025 	}
1026 
1027 	/* Tell parser that an address was set */
1028 	setaddr++;
1029 	/* save copy of netmask to restore in case of error */
1030 	(void) strncpy(lifr1.lifr_name, name, sizeof (lifr1.lifr_name));
1031 	if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr1) < 0)
1032 		Perror0_exit("SIOCGLIFNETMASK");
1033 	sav_netmask = lifr1.lifr_addr;
1034 
1035 	/*
1036 	 * If setting the address and not the mask, clear any existing mask
1037 	 * and the kernel will then assign the default (netmask has been set
1038 	 * to 0 in this case).  If setting both (either by using a prefix or
1039 	 * using the netmask command), set the mask first, so the address will
1040 	 * be interpreted correctly.
1041 	 */
1042 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1043 	/* lifr.lifr_addr already contains netmask from set_mask_lifreq() */
1044 	if (ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0)
1045 		Perror0_exit("SIOCSLIFNETMASK");
1046 
1047 	if (debug) {
1048 		char abuf[INET6_ADDRSTRLEN];
1049 		void *addr = (afp->af_af == AF_INET) ?
1050 		    (void *)&((struct sockaddr_in *)&laddr)->sin_addr :
1051 		    (void *)&((struct sockaddr_in6 *)&laddr)->sin6_addr;
1052 
1053 		(void) printf("Setting %s af %d addr %s\n",
1054 		    lifr.lifr_name, afp->af_af,
1055 		    inet_ntop(afp->af_af, addr, abuf, sizeof (abuf)));
1056 	}
1057 	lifr.lifr_addr = laddr;
1058 	lifr.lifr_addr.ss_family = afp->af_af;
1059 	if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0) {
1060 		/*
1061 		 * Restore the netmask
1062 		 */
1063 		int saverr = errno;
1064 
1065 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1066 		lifr.lifr_addr = sav_netmask;
1067 		(void) ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr);
1068 		errno = saverr;
1069 		Perror0_exit("SIOCSLIFADDR");
1070 	}
1071 
1072 	return (0);
1073 }
1074 
1075 /*
1076  * The following functions are stolen from the ipseckey(1m) program.
1077  * Perhaps they should be somewhere common, but for now, we just maintain
1078  * two versions.  We do this because of the different semantics for which
1079  * algorithms we select ("requested" for ifconfig vs. "actual" for key).
1080  */
1081 
1082 static ulong_t
1083 parsenum(char *num)
1084 {
1085 	ulong_t rc;
1086 	char *end = NULL;
1087 
1088 	errno = 0;
1089 	rc = strtoul(num, &end, 0);
1090 	if (errno != 0 || end == num || *end != '\0') {
1091 		rc = (ulong_t)-1;
1092 	}
1093 
1094 	return (rc);
1095 }
1096 
1097 /*
1098  * Parse and reverse parse possible algorithm values, include numbers.
1099  * Mostly stolen from ipseckey.c. See the comments above parsenum() for why
1100  * this isn't common to ipseckey.c.
1101  *
1102  * NOTE: Static buffer in this function for the return value.  Since ifconfig
1103  *       isn't multithreaded, this isn't a huge problem.
1104  */
1105 
1106 #define	NBUF_SIZE 20	/* Enough to print a large integer. */
1107 
1108 static char *
1109 rparsealg(uint8_t alg_value, int proto_num)
1110 {
1111 	struct ipsecalgent *alg;
1112 	static char numprint[128];	/* Enough to hold an algorithm name. */
1113 
1114 	/*
1115 	 * Special cases for "any" and "none"
1116 	 * The kernel needs to be able to distinguish between "any"
1117 	 * and "none" and the APIs are underdefined in this area for auth.
1118 	 */
1119 	if (proto_num == IPSEC_PROTO_AH) {
1120 		if (alg_value == SADB_AALG_NONE)
1121 			return ("none");
1122 		if (alg_value == SADB_AALG_ANY)
1123 			return ("any");
1124 	}
1125 
1126 	alg = getipsecalgbynum(alg_value, proto_num, NULL);
1127 	if (alg != NULL) {
1128 		(void) strlcpy(numprint, alg->a_names[0], sizeof (numprint));
1129 		freeipsecalgent(alg);
1130 	} else {
1131 		(void) snprintf(numprint, sizeof (numprint), "%d", alg_value);
1132 	}
1133 
1134 	return (numprint);
1135 }
1136 
1137 static uint_t
1138 parsealg(char *algname, int proto_num)
1139 {
1140 	struct ipsecalgent *alg;
1141 	ulong_t invalue;
1142 
1143 	if (algname == NULL) {
1144 		(void) fprintf(stderr, "ifconfig: Unexpected end of command "
1145 		    "line.\n");
1146 		exit(1);
1147 	}
1148 
1149 	/*
1150 	 * Special-case "none" and "any".
1151 	 * Use strcasecmp because its length is bounded.
1152 	 */
1153 	if (strcasecmp("none", algname) == 0) {
1154 		return ((proto_num == IPSEC_PROTO_ESP) ?
1155 		    NO_ESP_EALG : NO_ESP_AALG);
1156 	}
1157 	if ((strcasecmp("any", algname) == 0) && (proto_num == IPSEC_PROTO_AH))
1158 		return (SADB_AALG_ANY);
1159 
1160 	alg = getipsecalgbyname(algname, proto_num, NULL);
1161 	if (alg != NULL) {
1162 		invalue = alg->a_alg_num;
1163 		freeipsecalgent(alg);
1164 		return ((uint_t)invalue);
1165 	}
1166 
1167 	/*
1168 	 * Since algorithms can be loaded during kernel run-time, check for
1169 	 * numeric algorithm values too.
1170 	 */
1171 	invalue = parsenum(algname);
1172 	if ((invalue & (ulong_t)0xff) == invalue)
1173 		return ((uint_t)invalue);
1174 
1175 	(void) fprintf(stderr, "ifconfig: %s algorithm type %s unknown.\n",
1176 	    (proto_num == IPSEC_PROTO_ESP) ?
1177 	    "Encryption" : "Authentication", algname);
1178 	exit(1);
1179 	/* NOTREACHED */
1180 }
1181 
1182 /*
1183  * Actual ifconfig functions to set tunnel security properties.
1184  */
1185 
1186 enum ipsec_alg_type { ESP_ENCR_ALG = 1, ESP_AUTH_ALG, AH_AUTH_ALG };
1187 
1188 static int
1189 set_tun_algs(int which_alg, int alg)
1190 {
1191 	boolean_t	encr_alg_set = _B_FALSE;
1192 	iptun_params_t	params;
1193 	dladm_status_t	status;
1194 	ipsec_req_t	*ipsr;
1195 
1196 	if ((status = ifconfig_dladm_open(name, DATALINK_CLASS_IPTUN,
1197 	    &params.iptun_param_linkid)) != DLADM_STATUS_OK)
1198 		goto done;
1199 
1200 	status = dladm_iptun_getparams(dlh, &params, DLADM_OPT_ACTIVE);
1201 	if (status != DLADM_STATUS_OK)
1202 		goto done;
1203 
1204 	ipsr = &params.iptun_param_secinfo;
1205 
1206 	/*
1207 	 * If I'm just starting off this ifconfig, I want a clean slate,
1208 	 * otherwise, I've captured the current tunnel security settings.
1209 	 * In the case of continuation, I merely add to the settings.
1210 	 */
1211 	if (!(params.iptun_param_flags & IPTUN_PARAM_SECINFO))
1212 		(void) memset(ipsr, 0, sizeof (*ipsr));
1213 
1214 	/* We're only modifying the IPsec information */
1215 	params.iptun_param_flags = IPTUN_PARAM_SECINFO;
1216 
1217 	switch (which_alg) {
1218 	case ESP_ENCR_ALG:
1219 		if (alg == NO_ESP_EALG) {
1220 			if (ipsr->ipsr_esp_auth_alg == SADB_AALG_NONE)
1221 				ipsr->ipsr_esp_req = 0;
1222 			ipsr->ipsr_esp_alg = SADB_EALG_NONE;
1223 
1224 			/* Let the user specify NULL encryption implicitly. */
1225 			if (ipsr->ipsr_esp_auth_alg != SADB_AALG_NONE) {
1226 				encr_alg_set = _B_TRUE;
1227 				ipsr->ipsr_esp_alg = SADB_EALG_NULL;
1228 			}
1229 		} else {
1230 			encr_alg_set = _B_TRUE;
1231 			ipsr->ipsr_esp_req =
1232 			    IPSEC_PREF_REQUIRED | IPSEC_PREF_UNIQUE;
1233 			ipsr->ipsr_esp_alg = alg;
1234 		}
1235 		break;
1236 	case ESP_AUTH_ALG:
1237 		if (alg == NO_ESP_AALG) {
1238 			if ((ipsr->ipsr_esp_alg == SADB_EALG_NONE ||
1239 			    ipsr->ipsr_esp_alg == SADB_EALG_NULL) &&
1240 			    !encr_alg_set)
1241 				ipsr->ipsr_esp_req = 0;
1242 			ipsr->ipsr_esp_auth_alg = SADB_AALG_NONE;
1243 		} else {
1244 			ipsr->ipsr_esp_req =
1245 			    IPSEC_PREF_REQUIRED | IPSEC_PREF_UNIQUE;
1246 			ipsr->ipsr_esp_auth_alg = alg;
1247 
1248 			/* Let the user specify NULL encryption implicitly. */
1249 			if (ipsr->ipsr_esp_alg == SADB_EALG_NONE &&
1250 			    !encr_alg_set)
1251 				ipsr->ipsr_esp_alg = SADB_EALG_NULL;
1252 		}
1253 		break;
1254 	case AH_AUTH_ALG:
1255 		if (alg == NO_AH_AALG) {
1256 			ipsr->ipsr_ah_req = 0;
1257 			ipsr->ipsr_auth_alg = SADB_AALG_NONE;
1258 		} else {
1259 			ipsr->ipsr_ah_req =
1260 			    IPSEC_PREF_REQUIRED | IPSEC_PREF_UNIQUE;
1261 			ipsr->ipsr_auth_alg = alg;
1262 		}
1263 		break;
1264 		/* Will never hit DEFAULT */
1265 	}
1266 
1267 	status = dladm_iptun_modify(dlh, &params, DLADM_OPT_ACTIVE);
1268 
1269 done:
1270 	if (status != DLADM_STATUS_OK)
1271 		dladmerr_exit(status, name);
1272 	else {
1273 		ipsec_policy_set = _B_TRUE;
1274 		if ((ipsr->ipsr_esp_req != 0 &&
1275 		    ipsr->ipsr_esp_auth_alg != SADB_AALG_NONE) ||
1276 		    (ipsr->ipsr_ah_req != 0 &&
1277 		    ipsr->ipsr_auth_alg != SADB_AALG_NONE))
1278 			ipsec_auth_covered = _B_TRUE;
1279 	}
1280 	return (0);
1281 }
1282 
1283 /* ARGSUSED */
1284 static int
1285 set_tun_esp_encr_alg(char *addr, int64_t param)
1286 {
1287 	return (set_tun_algs(ESP_ENCR_ALG,
1288 	    parsealg(addr, IPSEC_PROTO_ESP)));
1289 }
1290 
1291 /* ARGSUSED */
1292 static int
1293 set_tun_esp_auth_alg(char *addr, int64_t param)
1294 {
1295 	return (set_tun_algs(ESP_AUTH_ALG,
1296 	    parsealg(addr, IPSEC_PROTO_AH)));
1297 }
1298 
1299 /* ARGSUSED */
1300 static int
1301 set_tun_ah_alg(char *addr, int64_t param)
1302 {
1303 	return (set_tun_algs(AH_AUTH_ALG,
1304 	    parsealg(addr, IPSEC_PROTO_AH)));
1305 }
1306 
1307 /* ARGSUSED */
1308 static int
1309 setifrevarp(char *arg, int64_t param)
1310 {
1311 	struct sockaddr_in	laddr;
1312 
1313 	if (afp->af_af == AF_INET6) {
1314 		(void) fprintf(stderr,
1315 		    "ifconfig: revarp not possible on IPv6 interface %s\n",
1316 		    name);
1317 		exit(1);
1318 	}
1319 	if (doifrevarp(name, &laddr)) {
1320 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1321 		laddr.sin_family = AF_INET;
1322 		(void) memcpy(&lifr.lifr_addr, &laddr, sizeof (laddr));
1323 		if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0)
1324 			Perror0_exit("SIOCSLIFADDR");
1325 	}
1326 	return (0);
1327 }
1328 
1329 /* ARGSUSED */
1330 static int
1331 setifsubnet(char *addr, int64_t param)
1332 {
1333 	int prefixlen = 0;
1334 	struct	sockaddr_storage subnet;
1335 
1336 	(*afp->af_getaddr)(addr, &subnet, &prefixlen);
1337 
1338 	switch (prefixlen) {
1339 	case NO_PREFIX:
1340 		(void) fprintf(stderr,
1341 		    "ifconfig: Missing prefix length in subnet %s\n", addr);
1342 		exit(1);
1343 		/* NOTREACHED */
1344 	case BAD_ADDR:
1345 		(void) fprintf(stderr,
1346 		    "ifconfig: Bad prefix length in %s\n", addr);
1347 		exit(1);
1348 	default:
1349 		break;
1350 	}
1351 
1352 	lifr.lifr_addr = subnet;
1353 	lifr.lifr_addrlen = prefixlen;
1354 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1355 	if (ioctl(s, SIOCSLIFSUBNET, (caddr_t)&lifr) < 0)
1356 		Perror0_exit("SIOCSLIFSUBNET");
1357 
1358 	return (0);
1359 }
1360 
1361 /* ARGSUSED */
1362 static int
1363 setifnetmask(char *addr, int64_t param)
1364 {
1365 	struct sockaddr_in netmask;
1366 
1367 	assert(afp->af_af != AF_INET6);
1368 
1369 	if (strcmp(addr, "+") == 0) {
1370 		if (!in_getmask(&netmask, _B_FALSE))
1371 			return (0);
1372 		(void) printf("Setting netmask of %s to %s\n", name,
1373 		    inet_ntoa(netmask.sin_addr));
1374 	} else {
1375 		in_getaddr(addr, (struct sockaddr *)&netmask, NULL);
1376 	}
1377 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1378 	(void) memcpy(&lifr.lifr_addr, &netmask, sizeof (netmask));
1379 	if (ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0)
1380 		Perror0_exit("SIOCSLIFNETMASK");
1381 	return (0);
1382 }
1383 
1384 /*
1385  * Parse '/<n>' as a netmask.
1386  */
1387 /* ARGSUSED */
1388 static int
1389 setifprefixlen(char *addr, int64_t param)
1390 {
1391 	int prefixlen;
1392 	int af = afp->af_af;
1393 
1394 	prefixlen = in_getprefixlen(addr, _B_TRUE,
1395 	    (af == AF_INET) ? IP_ABITS : IPV6_ABITS);
1396 	if (prefixlen < 0) {
1397 		(void) fprintf(stderr,
1398 		    "ifconfig: Bad prefix length in %s\n", addr);
1399 		exit(1);
1400 	}
1401 	(void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr));
1402 	lifr.lifr_addr.ss_family = af;
1403 	if (af == AF_INET6) {
1404 		struct sockaddr_in6 *sin6;
1405 
1406 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
1407 		if (!in_prefixlentomask(prefixlen, IPV6_ABITS,
1408 		    (uchar_t *)&sin6->sin6_addr)) {
1409 			(void) fprintf(stderr, "ifconfig: "
1410 			    "Bad prefix length: %d\n",
1411 			    prefixlen);
1412 			exit(1);
1413 		}
1414 	} else if (af == AF_INET) {
1415 		struct sockaddr_in *sin;
1416 
1417 		sin = (struct sockaddr_in *)&lifr.lifr_addr;
1418 		if (!in_prefixlentomask(prefixlen, IP_ABITS,
1419 		    (uchar_t *)&sin->sin_addr)) {
1420 			(void) fprintf(stderr, "ifconfig: "
1421 			    "Bad prefix length: %d\n",
1422 			    prefixlen);
1423 			exit(1);
1424 		}
1425 	} else {
1426 		(void) fprintf(stderr, "ifconfig: setting prefix only supported"
1427 		    " for address family inet or inet6\n");
1428 		exit(1);
1429 	}
1430 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1431 	if (ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0)
1432 		Perror0_exit("SIOCSLIFNETMASK");
1433 	return (0);
1434 }
1435 
1436 /* ARGSUSED */
1437 static int
1438 setifbroadaddr(char *addr, int64_t param)
1439 {
1440 	struct	sockaddr_in broadaddr;
1441 
1442 	assert(afp->af_af != AF_INET6);
1443 
1444 	if (strcmp(addr, "+") == 0) {
1445 		/*
1446 		 * This doesn't set the broadcast address at all. Rather, it
1447 		 * gets, then sets the interface's address, relying on the fact
1448 		 * that resetting the address will reset the broadcast address.
1449 		 */
1450 		(void) strncpy(lifr.lifr_name, name,
1451 		    sizeof (lifr.lifr_name));
1452 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
1453 			if (errno != EADDRNOTAVAIL)
1454 				Perror0_exit("SIOCGLIFADDR");
1455 			return (0);
1456 		}
1457 		if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0)
1458 			Perror0_exit("SIOCGLIFADDR");
1459 
1460 		return (0);
1461 	}
1462 	in_getaddr(addr, (struct sockaddr *)&broadaddr, NULL);
1463 
1464 	(void) memcpy(&lifr.lifr_addr, &broadaddr, sizeof (broadaddr));
1465 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1466 	if (ioctl(s, SIOCSLIFBRDADDR, (caddr_t)&lifr) < 0)
1467 		Perror0_exit("SIOCSLIFBRDADDR");
1468 	return (0);
1469 }
1470 
1471 /*
1472  * set interface destination address
1473  */
1474 /* ARGSUSED */
1475 static int
1476 setifdstaddr(char *addr, int64_t param)
1477 {
1478 	(*afp->af_getaddr)(addr, (struct sockaddr *)&lifr.lifr_addr, NULL);
1479 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1480 	if (ioctl(s, SIOCSLIFDSTADDR, (caddr_t)&lifr) < 0)
1481 		Perror0_exit("setifdstaddr: SIOCSLIFDSTADDR");
1482 	return (0);
1483 }
1484 
1485 /* ARGSUSED */
1486 static int
1487 setifflags(char *val, int64_t value)
1488 {
1489 	struct lifreq lifrl;	/* local lifreq struct */
1490 	boolean_t bringup = _B_FALSE;
1491 
1492 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1493 	if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0)
1494 		Perror0_exit("setifflags: SIOCGLIFFLAGS");
1495 
1496 	if (value < 0) {
1497 		value = -value;
1498 
1499 		if ((value & IFF_NOFAILOVER) && (lifr.lifr_flags & IFF_UP)) {
1500 			/*
1501 			 * The kernel does not allow administratively up test
1502 			 * addresses to be converted to data addresses.  Bring
1503 			 * the address down first, then bring it up after it's
1504 			 * been converted to a data address.
1505 			 */
1506 			lifr.lifr_flags &= ~IFF_UP;
1507 			(void) ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr);
1508 			bringup = _B_TRUE;
1509 		}
1510 
1511 		lifr.lifr_flags &= ~value;
1512 		if ((value & (IFF_UP | IFF_NOFAILOVER)) &&
1513 		    (lifr.lifr_flags & IFF_DUPLICATE)) {
1514 			/*
1515 			 * If the user is trying to mark an interface with a
1516 			 * duplicate address as "down," or convert a duplicate
1517 			 * test address to a data address, then fetch the
1518 			 * address and set it.  This will cause IP to clear
1519 			 * the IFF_DUPLICATE flag and stop the automatic
1520 			 * recovery timer.
1521 			 */
1522 			value = lifr.lifr_flags;
1523 			if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) >= 0)
1524 				(void) ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr);
1525 			lifr.lifr_flags = value;
1526 		}
1527 	} else {
1528 		lifr.lifr_flags |= value;
1529 	}
1530 
1531 	/*
1532 	 * If we're about to bring up an underlying physical IPv6 interface in
1533 	 * an IPMP group, ensure the IPv6 IPMP interface is also up.  This is
1534 	 * for backward compatibility with legacy configurations in which
1535 	 * there are no explicit hostname files for IPMP interfaces.  (For
1536 	 * IPv4, this is automatically handled by the kernel when migrating
1537 	 * the underlying interface's data address to the IPMP interface.)
1538 	 */
1539 	(void) strlcpy(lifrl.lifr_name, name, LIFNAMSIZ);
1540 
1541 	if (lifnum(lifr.lifr_name) == 0 &&
1542 	    (lifr.lifr_flags & (IFF_UP|IFF_IPV6)) == (IFF_UP|IFF_IPV6) &&
1543 	    ioctl(s, SIOCGLIFGROUPNAME, &lifrl) == 0 &&
1544 	    lifrl.lifr_groupname[0] != '\0') {
1545 		lifgroupinfo_t lifgr;
1546 
1547 		(void) strlcpy(lifgr.gi_grname, lifrl.lifr_groupname,
1548 		    LIFGRNAMSIZ);
1549 		if (ioctl(s, SIOCGLIFGROUPINFO, &lifgr) == -1)
1550 			Perror0_exit("setifflags: SIOCGLIFGROUPINFO");
1551 
1552 		(void) strlcpy(lifrl.lifr_name, lifgr.gi_grifname, LIFNAMSIZ);
1553 		if (ioctl(s, SIOCGLIFFLAGS, &lifrl) == -1)
1554 			Perror0_exit("setifflags: SIOCGLIFFLAGS");
1555 		if (!(lifrl.lifr_flags & IFF_UP)) {
1556 			lifrl.lifr_flags |= IFF_UP;
1557 			if (ioctl(s, SIOCSLIFFLAGS, &lifrl) == -1)
1558 				Perror0_exit("setifflags: SIOCSLIFFLAGS");
1559 		}
1560 	}
1561 
1562 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1563 	if (ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0)
1564 		Perror0_exit("setifflags: SIOCSLIFFLAGS");
1565 
1566 	if (bringup) {
1567 		lifr.lifr_flags |= IFF_UP;
1568 		if (ioctl(s, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0)
1569 			Perror0_exit("setifflags: SIOCSLIFFLAGS IFF_UP");
1570 	}
1571 
1572 	return (0);
1573 }
1574 
1575 /* ARGSUSED */
1576 static int
1577 setifmetric(char *val, int64_t param)
1578 {
1579 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1580 	lifr.lifr_metric = atoi(val);
1581 	if (ioctl(s, SIOCSLIFMETRIC, (caddr_t)&lifr) < 0)
1582 		Perror0_exit("setifmetric: SIOCSLIFMETRIC");
1583 	return (0);
1584 }
1585 
1586 /* ARGSUSED */
1587 static int
1588 setifmtu(char *val, int64_t param)
1589 {
1590 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1591 	lifr.lifr_mtu = atoi(val);
1592 	if (ioctl(s, SIOCSLIFMTU, (caddr_t)&lifr) < 0)
1593 		Perror0_exit("setifmtu: SIOCSLIFMTU");
1594 	return (0);
1595 }
1596 
1597 /* ARGSUSED */
1598 static int
1599 setifindex(char *val, int64_t param)
1600 {
1601 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1602 	lifr.lifr_index = atoi(val);
1603 	if (ioctl(s, SIOCSLIFINDEX, (caddr_t)&lifr) < 0)
1604 		Perror0_exit("setifindex: SIOCSLIFINDEX");
1605 	return (0);
1606 }
1607 
1608 /* ARGSUSED */
1609 static void
1610 notifycb(dlpi_handle_t dh, dlpi_notifyinfo_t *dnip, void *arg)
1611 {
1612 }
1613 
1614 /* ARGSUSED */
1615 static int
1616 setifether(char *addr, int64_t param)
1617 {
1618 	uchar_t		*hwaddr;
1619 	int		hwaddrlen;
1620 	int		retval;
1621 	ifaddrlistx_t	*ifaddrp, *ifaddrs = NULL;
1622 	dlpi_handle_t	dh;
1623 	dlpi_notifyid_t id;
1624 
1625 	if (addr == NULL) {
1626 		ifstatus(name);
1627 		print_ifether(name);
1628 		return (0);
1629 	}
1630 
1631 	/*
1632 	 * if the IP interface in the arguments is a logical
1633 	 * interface, exit with an error now.
1634 	 */
1635 	if (strchr(name, ':') != NULL) {
1636 		(void) fprintf(stderr, "ifconfig: cannot change"
1637 		    " ethernet address of a logical interface\n");
1638 		exit(1);
1639 	}
1640 
1641 	if ((hwaddr = _link_aton(addr, &hwaddrlen)) == NULL) {
1642 		if (hwaddrlen == -1)
1643 			(void) fprintf(stderr,
1644 			    "ifconfig: bad ethernet address\n");
1645 		else
1646 			(void) fprintf(stderr, "ifconfig: malloc() failed\n");
1647 		exit(1);
1648 	}
1649 
1650 	if ((retval = dlpi_open(name, &dh, 0)) != DLPI_SUCCESS)
1651 		Perrdlpi_exit("cannot dlpi_open() link", name, retval);
1652 
1653 	retval = dlpi_enabnotify(dh, DL_NOTE_PHYS_ADDR, notifycb, NULL, &id);
1654 	if (retval == DLPI_SUCCESS) {
1655 		(void) dlpi_disabnotify(dh, id, NULL);
1656 	} else {
1657 		/*
1658 		 * This link does not support DL_NOTE_PHYS_ADDR: bring down
1659 		 * all of the addresses to flush the old hardware address
1660 		 * information out of IP.
1661 		 *
1662 		 * NOTE: Skipping this when DL_NOTE_PHYS_ADDR is supported is
1663 		 * more than an optimization: in.mpathd will set IFF_OFFLINE
1664 		 * if it's notified and the new address is a duplicate of
1665 		 * another in the group -- but the flags manipulation in
1666 		 * ifaddr_{down,up}() cannot be atomic and thus might clobber
1667 		 * IFF_OFFLINE, confusing in.mpathd.
1668 		 */
1669 		if (ifaddrlistx(name, IFF_UP, 0, &ifaddrs) == -1)
1670 			Perror2_exit(name, "cannot get address list");
1671 
1672 		ifaddrp = ifaddrs;
1673 		for (; ifaddrp != NULL; ifaddrp = ifaddrp->ia_next) {
1674 			if (!ifaddr_down(ifaddrp)) {
1675 				Perror2_exit(ifaddrp->ia_name,
1676 				    "cannot bring down");
1677 			}
1678 		}
1679 	}
1680 
1681 	/*
1682 	 * Change the hardware address.
1683 	 */
1684 	retval = dlpi_set_physaddr(dh, DL_CURR_PHYS_ADDR, hwaddr, hwaddrlen);
1685 	if (retval != DLPI_SUCCESS) {
1686 		(void) fprintf(stderr,
1687 		    "ifconfig: failed setting mac address on %s\n", name);
1688 	}
1689 	dlpi_close(dh);
1690 
1691 	/*
1692 	 * If any addresses were brought down before changing the hardware
1693 	 * address, bring them up again.
1694 	 */
1695 	for (ifaddrp = ifaddrs; ifaddrp != NULL; ifaddrp = ifaddrp->ia_next) {
1696 		if (!ifaddr_up(ifaddrp))
1697 			Perror2_exit(ifaddrp->ia_name, "cannot bring up");
1698 	}
1699 	ifaddrlistx_free(ifaddrs);
1700 
1701 	return (0);
1702 }
1703 
1704 /*
1705  * Print an interface's Ethernet address, if it has one.
1706  */
1707 static void
1708 print_ifether(const char *ifname)
1709 {
1710 	int fd;
1711 
1712 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1713 
1714 	fd = socket(AF_INET, SOCK_DGRAM, 0);
1715 	if (fd == -1 || ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1) {
1716 		/*
1717 		 * It's possible the interface is only configured for
1718 		 * IPv6; check again with AF_INET6.
1719 		 */
1720 		(void) close(fd);
1721 		fd = socket(AF_INET6, SOCK_DGRAM, 0);
1722 		if (fd == -1 || ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1) {
1723 			(void) close(fd);
1724 			return;
1725 		}
1726 	}
1727 	(void) close(fd);
1728 
1729 	/* VNI and IPMP interfaces don't have MAC addresses */
1730 	if (lifr.lifr_flags & (IFF_VIRTUAL|IFF_IPMP))
1731 		return;
1732 
1733 	/* IP tunnels also don't have Ethernet-like MAC addresses */
1734 	if (ifconfig_dladm_open(ifname, DATALINK_CLASS_IPTUN, NULL) ==
1735 	    DLADM_STATUS_OK)
1736 		return;
1737 
1738 	dlpi_print_address(ifname);
1739 }
1740 
1741 /*
1742  * static int find_all_interfaces(struct lifconf *lifcp, char **buf,
1743  *     int64_t lifc_flags)
1744  *
1745  * It finds all active data links.
1746  *
1747  * It takes in input a pointer to struct lifconf to receive interfaces
1748  * informations, a **char to hold allocated buffer, and a lifc_flags.
1749  *
1750  * Return values:
1751  *  0 = everything OK
1752  * -1 = problem
1753  */
1754 static int
1755 find_all_interfaces(struct lifconf *lifcp, char **buf, int64_t lifc_flags)
1756 {
1757 	unsigned bufsize;
1758 	int n;
1759 	ni_t *nip;
1760 	struct lifreq *lifrp;
1761 	dladm_status_t status;
1762 
1763 	if (!dlh_opened) {
1764 		status = ifconfig_dladm_open(NULL, 0, NULL);
1765 		if (status != DLADM_STATUS_OK)
1766 			dladmerr_exit(status, "unable to open dladm handle");
1767 	}
1768 
1769 	(void) dlpi_walk(ni_entry, dlh, 0);
1770 
1771 	/* Now, translate the linked list into a struct lifreq buffer */
1772 	if (num_ni == 0) {
1773 		lifcp->lifc_family = AF_UNSPEC;
1774 		lifcp->lifc_flags = lifc_flags;
1775 		lifcp->lifc_len = 0;
1776 		lifcp->lifc_buf = NULL;
1777 		return (0);
1778 	}
1779 
1780 	bufsize = num_ni * sizeof (struct lifreq);
1781 	if ((*buf = malloc(bufsize)) == NULL)
1782 		Perror0_exit("find_all_interfaces: malloc failed");
1783 
1784 	lifcp->lifc_family = AF_UNSPEC;
1785 	lifcp->lifc_flags = lifc_flags;
1786 	lifcp->lifc_len = bufsize;
1787 	lifcp->lifc_buf = *buf;
1788 
1789 	for (n = 0, lifrp = lifcp->lifc_req; n < num_ni; n++, lifrp++) {
1790 		nip = ni_list;
1791 		(void) strncpy(lifrp->lifr_name, nip->ni_name,
1792 		    sizeof (lifr.lifr_name));
1793 		ni_list = nip->ni_next;
1794 		free(nip);
1795 	}
1796 	return (0);
1797 }
1798 
1799 /*
1800  * Create the next unused logical interface using the original name
1801  * and assign the address (and mask if '/<n>' is part of the address).
1802  * Use the new logical interface for subsequent subcommands by updating
1803  * the name variable.
1804  *
1805  * This allows syntax like:
1806  *	ifconfig le0 addif 109.106.86.130 netmask + up \
1807  *	addif 109.106.86.131 netmask + up
1808  */
1809 /* ARGSUSED */
1810 static int
1811 addif(char *str, int64_t param)
1812 {
1813 	int prefixlen = 0;
1814 	struct sockaddr_storage laddr;
1815 	struct sockaddr_storage mask;
1816 	struct sockaddr_in6 *sin6;
1817 	struct sockaddr_in *sin;
1818 	ipadm_status_t istatus;
1819 	char cidraddr[BUFSIZ];
1820 	char addrstr[INET6_ADDRSTRLEN];
1821 
1822 	(void) strncpy(name, origname, sizeof (name));
1823 
1824 	if (strchr(name, ':') != NULL) {
1825 		(void) fprintf(stderr,
1826 		    "ifconfig: addif: bad physical interface name %s\n",
1827 		    name);
1828 		exit(1);
1829 	}
1830 
1831 	/*
1832 	 * clear so parser will interpret next address as source followed
1833 	 * by possible dest
1834 	 */
1835 	setaddr = 0;
1836 	(*afp->af_getaddr)(str, (struct sockaddr *)&laddr, &prefixlen);
1837 
1838 	(void) memset(&mask, 0, sizeof (mask));
1839 	mask.ss_family = afp->af_af;
1840 
1841 	switch (prefixlen) {
1842 	case NO_PREFIX:
1843 		/* Nothing there - ok */
1844 		break;
1845 	case BAD_ADDR:
1846 		(void) fprintf(stderr,
1847 		    "ifconfig: Bad prefix length in %s\n", str);
1848 		exit(1);
1849 	default:
1850 		(void) memset(&mask, 0, sizeof (mask));
1851 		mask.ss_family = afp->af_af;
1852 		if (afp->af_af == AF_INET6) {
1853 			sin6 = (struct sockaddr_in6 *)&mask;
1854 			if (!in_prefixlentomask(prefixlen, IPV6_ABITS,
1855 			    (uchar_t *)&sin6->sin6_addr)) {
1856 				(void) fprintf(stderr, "ifconfig: "
1857 				    "Bad prefix length: %d\n",
1858 				    prefixlen);
1859 				exit(1);
1860 			}
1861 		} else {
1862 			sin = (struct sockaddr_in *)&mask;
1863 			if (!in_prefixlentomask(prefixlen, IP_ABITS,
1864 			    (uchar_t *)&sin->sin_addr)) {
1865 				(void) fprintf(stderr, "ifconfig: "
1866 				    "Bad prefix length: %d\n",
1867 				    prefixlen);
1868 				exit(1);
1869 			}
1870 		}
1871 		g_netmask_set = G_NETMASK_NIL;
1872 		break;
1873 	}
1874 
1875 	/*
1876 	 * This is a "hack" to get around the problem of SIOCLIFADDIF.  The
1877 	 * problem is that this ioctl does not include the netmask when
1878 	 * adding a logical interface.  This is the same problem described
1879 	 * in the ifconfig() comments.  To get around this problem, we first
1880 	 * add the logical interface with a 0 address.  After that, we set
1881 	 * the netmask if provided.  Finally we set the interface address.
1882 	 */
1883 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
1884 	(void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr));
1885 
1886 	/* Note: no need to do DAD here since the interface isn't up yet. */
1887 
1888 	if (ioctl(s, SIOCLIFADDIF, (caddr_t)&lifr) < 0)
1889 		Perror0_exit("addif: SIOCLIFADDIF");
1890 
1891 	(void) printf("Created new logical interface %s\n",
1892 	    lifr.lifr_name);
1893 	(void) strncpy(name, lifr.lifr_name, sizeof (name));
1894 
1895 	/*
1896 	 * Check and see if any "netmask" command is used and perform the
1897 	 * necessary operation.
1898 	 */
1899 	set_mask_lifreq(&lifr, &laddr, &mask);
1900 
1901 	/* This check is temporary until libipadm supports IPMP interfaces. */
1902 	if (ifconfig_use_libipadm(s, name)) {
1903 		/*
1904 		 * We added the logical interface above before calling
1905 		 * ipadm_create_addr(), because, with IPH_LEGACY, we need
1906 		 * to do an addif for `ifconfig ce0 addif <addr>' but not for
1907 		 * `ifconfig ce0 <addr>'. libipadm does not have a flag to
1908 		 * to differentiate between these two cases. To keep it simple,
1909 		 * we always create the logical interface and pass it to
1910 		 * libipadm instead of requiring libipadm to addif for some
1911 		 * cases and not do addif for other cases.
1912 		 */
1913 		istatus = ipadm_create_addrobj(IPADM_ADDR_STATIC, name,
1914 		    &ipaddr);
1915 		if (istatus != IPADM_SUCCESS)
1916 			ipadmerr_exit(istatus, "addif");
1917 
1918 		if (af == AF_INET) {
1919 			sin = (struct sockaddr_in *)&laddr;
1920 			(void) inet_ntop(AF_INET, &sin->sin_addr, addrstr,
1921 			    sizeof (addrstr));
1922 		} else {
1923 			sin6 = (struct sockaddr_in6 *)&laddr;
1924 			(void) inet_ntop(AF_INET6, &sin6->sin6_addr, addrstr,
1925 			    sizeof (addrstr));
1926 		}
1927 		/*
1928 		 * lifr.lifr_addr, which is updated by set_mask_lifreq()
1929 		 * will contain the right mask to use.
1930 		 */
1931 		prefixlen = mask2plen((struct sockaddr *)&lifr.lifr_addr);
1932 
1933 		(void) snprintf(cidraddr, sizeof (cidraddr), "%s/%d",
1934 		    addrstr, prefixlen);
1935 
1936 		istatus = ipadm_set_addr(ipaddr, cidraddr, af);
1937 
1938 		if (istatus != IPADM_SUCCESS)
1939 			ipadmerr_exit(istatus, "could not set address");
1940 		setaddr++;
1941 		/*
1942 		 * address will be set by the parser after nextarg
1943 		 * has been scanned
1944 		 */
1945 		return (0);
1946 	}
1947 
1948 	/*
1949 	 * Only set the netmask if "netmask" command is used or a prefix is
1950 	 * provided.
1951 	 */
1952 	if (g_netmask_set == G_NETMASK_SET || prefixlen >= 0) {
1953 		/*
1954 		 * lifr.lifr_addr already contains netmask from
1955 		 * set_mask_lifreq().
1956 		 */
1957 		if (ioctl(s, SIOCSLIFNETMASK, (caddr_t)&lifr) < 0)
1958 			Perror0_exit("addif: SIOCSLIFNETMASK");
1959 	}
1960 
1961 	/* Finally, we set the interface address. */
1962 	lifr.lifr_addr = laddr;
1963 	if (ioctl(s, SIOCSLIFADDR, (caddr_t)&lifr) < 0)
1964 		Perror0_exit("SIOCSLIFADDR");
1965 
1966 	/*
1967 	 * let parser know we got a source.
1968 	 * Next address, if given, should be dest
1969 	 */
1970 	setaddr++;
1971 	return (0);
1972 }
1973 
1974 /*
1975  * Remove a logical interface based on its IP address. Unlike addif
1976  * there is no '/<n>' here.
1977  * Verifies that the interface is down before it is removed.
1978  */
1979 /* ARGSUSED */
1980 static int
1981 removeif(char *str, int64_t param)
1982 {
1983 	struct sockaddr_storage laddr;
1984 	ipadm_status_t istatus;
1985 	ipadm_addr_info_t *ainfo, *ainfop;
1986 
1987 	if (strchr(name, ':') != NULL) {
1988 		(void) fprintf(stderr,
1989 		    "ifconfig: removeif: bad physical interface name %s\n",
1990 		    name);
1991 		exit(1);
1992 	}
1993 
1994 	(*afp->af_getaddr)(str, &laddr, NULL);
1995 
1996 	/*
1997 	 * Following check is temporary until libipadm supports
1998 	 * IPMP interfaces.
1999 	 */
2000 	if (!ifconfig_use_libipadm(s, name))
2001 		goto delete;
2002 
2003 	/*
2004 	 * Get all addresses and search this address among the active
2005 	 * addresses. If an address object was found, delete using
2006 	 * ipadm_delete_addr().
2007 	 */
2008 	istatus = ipadm_addr_info(iph, name, &ainfo, 0, LIFC_DEFAULT);
2009 	if (istatus != IPADM_SUCCESS)
2010 		ipadmerr_exit(istatus, "removeif");
2011 
2012 	for (ainfop = ainfo; ainfop != NULL; ainfop = IA_NEXT(ainfop))
2013 		if (sockaddrcmp(
2014 		    (struct sockaddr_storage *)ainfop->ia_ifa.ifa_addr, &laddr))
2015 			break;
2016 
2017 	if (ainfop != NULL) {
2018 		if (strchr(ainfop->ia_ifa.ifa_name, ':') == NULL) {
2019 			(void) fprintf(stderr,
2020 			    "ifconfig: removeif: cannot remove interface: %s\n",
2021 			    name);
2022 			exit(1);
2023 		}
2024 		if (ainfop->ia_aobjname[0] != '\0') {
2025 			istatus = ipadm_delete_addr(iph, ainfop->ia_aobjname,
2026 			    IPADM_OPT_ACTIVE);
2027 			if (istatus != IPADM_SUCCESS) {
2028 				ipadmerr_exit(istatus,
2029 				    "could not delete address");
2030 			}
2031 			ipadm_free_addr_info(ainfo);
2032 			return (0);
2033 		}
2034 	}
2035 	ipadm_free_addr_info(ainfo);
2036 
2037 delete:
2038 	/*
2039 	 * An address object for this address was not found in ipadm.
2040 	 * Delete with SIOCLIFREMOVEIF.
2041 	 */
2042 	lifr.lifr_addr = laddr;
2043 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2044 	if (ioctl(s, SIOCLIFREMOVEIF, (caddr_t)&lifr) < 0) {
2045 		if (errno == EBUSY) {
2046 			/* This can only happen if ipif_id = 0 */
2047 			(void) fprintf(stderr,
2048 			    "ifconfig: removeif: cannot remove interface: %s\n",
2049 			    name);
2050 			exit(1);
2051 		}
2052 		Perror0_exit("removeif: SIOCLIFREMOVEIF");
2053 	}
2054 	return (0);
2055 }
2056 
2057 /*
2058  * Set the address token for IPv6.
2059  */
2060 /* ARGSUSED */
2061 static int
2062 setiftoken(char *addr, int64_t param)
2063 {
2064 	int prefixlen = 0;
2065 	struct sockaddr_in6 token;
2066 
2067 	in6_getaddr(addr, (struct sockaddr *)&token, &prefixlen);
2068 	switch (prefixlen) {
2069 	case NO_PREFIX:
2070 		(void) fprintf(stderr,
2071 		    "ifconfig: Missing prefix length in subnet %s\n", addr);
2072 		exit(1);
2073 		/* NOTREACHED */
2074 	case BAD_ADDR:
2075 		(void) fprintf(stderr,
2076 		    "ifconfig: Bad prefix length in %s\n", addr);
2077 		exit(1);
2078 	default:
2079 		break;
2080 	}
2081 	(void) memcpy(&lifr.lifr_addr, &token, sizeof (token));
2082 	lifr.lifr_addrlen = prefixlen;
2083 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2084 	if (ioctl(s, SIOCSLIFTOKEN, (caddr_t)&lifr) < 0)  {
2085 		Perror0_exit("setiftoken: SIOCSLIFTOKEN");
2086 	}
2087 	return (0);
2088 }
2089 
2090 /* ARGSUSED */
2091 static int
2092 setifgroupname(char *grname, int64_t param)
2093 {
2094 	lifgroupinfo_t		lifgr;
2095 	struct lifreq		lifrl;
2096 	ifaddrlistx_t		*ifaddrp, *nextifaddrp;
2097 	ifaddrlistx_t		*ifaddrs = NULL, *downaddrs = NULL;
2098 	int			af;
2099 
2100 	if (debug) {
2101 		(void) printf("Setting groupname %s on interface %s\n",
2102 		    grname, name);
2103 	}
2104 
2105 	(void) strlcpy(lifrl.lifr_name, name, LIFNAMSIZ);
2106 	(void) strlcpy(lifrl.lifr_groupname, grname, LIFGRNAMSIZ);
2107 
2108 	while (ioctl(s, SIOCSLIFGROUPNAME, &lifrl) == -1) {
2109 		switch (errno) {
2110 		case ENOENT:
2111 			/*
2112 			 * The group doesn't yet exist; create it and repeat.
2113 			 */
2114 			af = afp->af_af;
2115 			if (create_ipmp(grname, af, NULL, _B_TRUE) == -1) {
2116 				if (errno == EEXIST)
2117 					continue;
2118 
2119 				Perror2(grname, "cannot create IPMP group");
2120 				goto fail;
2121 			}
2122 			continue;
2123 
2124 		case EALREADY:
2125 			/*
2126 			 * The interface is already in another group; must
2127 			 * remove existing membership first.
2128 			 */
2129 			lifrl.lifr_groupname[0] = '\0';
2130 			if (ioctl(s, SIOCSLIFGROUPNAME, &lifrl) == -1) {
2131 				Perror2(name, "cannot remove existing "
2132 				    "IPMP group membership");
2133 				goto fail;
2134 			}
2135 			(void) strlcpy(lifrl.lifr_groupname, grname,
2136 			    LIFGRNAMSIZ);
2137 			continue;
2138 
2139 		case EAFNOSUPPORT:
2140 			/*
2141 			 * The group exists, but it's not configured with the
2142 			 * address families the interface needs.  Since only
2143 			 * two address families are currently supported, just
2144 			 * configure the "other" address family.  Note that we
2145 			 * may race with group deletion or creation by another
2146 			 * process (ENOENT or EEXIST); in such cases we repeat
2147 			 * our original SIOCSLIFGROUPNAME.
2148 			 */
2149 			(void) strlcpy(lifgr.gi_grname, grname, LIFGRNAMSIZ);
2150 			if (ioctl(s, SIOCGLIFGROUPINFO, &lifgr) == -1) {
2151 				if (errno == ENOENT)
2152 					continue;
2153 
2154 				Perror2(grname, "SIOCGLIFGROUPINFO");
2155 				goto fail;
2156 			}
2157 
2158 			af = lifgr.gi_v4 ? AF_INET6 : AF_INET;
2159 			if (create_ipmp(grname, af, lifgr.gi_grifname,
2160 			    _B_TRUE) == -1) {
2161 				if (errno == EEXIST)
2162 					continue;
2163 
2164 				Perror2(grname, "cannot configure IPMP group");
2165 				goto fail;
2166 			}
2167 			continue;
2168 
2169 		case EADDRINUSE:
2170 			/*
2171 			 * Some addresses are in-use (or under control of DAD).
2172 			 * Bring them down and retry the group join operation.
2173 			 * We will bring them back up after the interface has
2174 			 * been placed in the group.
2175 			 */
2176 			if (ifaddrlistx(lifrl.lifr_name, IFF_UP|IFF_DUPLICATE,
2177 			    0, &ifaddrs) == -1) {
2178 				Perror2(grname, "cannot get address list");
2179 				goto fail;
2180 			}
2181 
2182 			ifaddrp = ifaddrs;
2183 			for (; ifaddrp != NULL; ifaddrp = nextifaddrp) {
2184 				if (!ifaddr_down(ifaddrp)) {
2185 					ifaddrs = ifaddrp;
2186 					goto fail;
2187 				}
2188 				nextifaddrp = ifaddrp->ia_next;
2189 				ifaddrp->ia_next = downaddrs;
2190 				downaddrs = ifaddrp;
2191 			}
2192 			ifaddrs = NULL;
2193 			continue;
2194 
2195 		case EADDRNOTAVAIL: {
2196 			/*
2197 			 * Some data addresses are under application control.
2198 			 * For some of these (e.g., ADDRCONF), the application
2199 			 * should remove the address, in which case we retry a
2200 			 * few times (since the application's action is not
2201 			 * atomic with respect to us) before bailing out and
2202 			 * informing the user.
2203 			 */
2204 			int ntries, nappaddr = 0;
2205 			const if_appflags_t *iap = if_appflags_tbl;
2206 
2207 			for (; iap->ia_app != NULL; iap++) {
2208 				ntries = 0;
2209 again:
2210 				if (ifaddrlistx(lifrl.lifr_name, iap->ia_flag,
2211 				    IFF_NOFAILOVER, &ifaddrs) == -1) {
2212 					(void) fprintf(stderr, "ifconfig: %s: "
2213 					    "cannot get data addresses managed "
2214 					    "by %s\n", lifrl.lifr_name,
2215 					    iap->ia_app);
2216 					goto fail;
2217 				}
2218 
2219 				if (ifaddrs == NULL)
2220 					continue;
2221 
2222 				ifaddrlistx_free(ifaddrs);
2223 				ifaddrs = NULL;
2224 
2225 				if (++ntries < iap->ia_tries) {
2226 					(void) poll(NULL, 0, 100);
2227 					goto again;
2228 				}
2229 
2230 				(void) fprintf(stderr, "ifconfig: cannot join "
2231 				    "IPMP group: %s has data addresses managed "
2232 				    "by %s\n", lifrl.lifr_name, iap->ia_app);
2233 				nappaddr++;
2234 			}
2235 			if (nappaddr > 0)
2236 				goto fail;
2237 			continue;
2238 		}
2239 		default:
2240 			Perror2(name, "SIOCSLIFGROUPNAME");
2241 			goto fail;
2242 		}
2243 	}
2244 
2245 	/*
2246 	 * If the interface being moved is under the control of `ipmgmtd(1M)'
2247 	 * dameon then we should inform the daemon about this move, so that
2248 	 * the daemon can delete the state associated with this interface.
2249 	 *
2250 	 * This workaround is needed until the IPMP support in ipadm(1M).
2251 	 */
2252 	ipadm_if_move(iph, name);
2253 
2254 	/*
2255 	 * If there were addresses that we had to bring down, it's time to
2256 	 * bring them up again.  As part of bringing them up, the kernel will
2257 	 * automatically move them to the new IPMP interface.
2258 	 */
2259 	for (ifaddrp = downaddrs; ifaddrp != NULL; ifaddrp = ifaddrp->ia_next) {
2260 		if (!ifaddr_up(ifaddrp) && errno != ENXIO) {
2261 			(void) fprintf(stderr, "ifconfig: cannot bring back up "
2262 			    "%s: %s\n", ifaddrp->ia_name, strerror(errno));
2263 		}
2264 	}
2265 	ifaddrlistx_free(downaddrs);
2266 	return (0);
2267 fail:
2268 	/*
2269 	 * Attempt to bring back up any interfaces that we downed.
2270 	 */
2271 	for (ifaddrp = downaddrs; ifaddrp != NULL; ifaddrp = ifaddrp->ia_next) {
2272 		if (!ifaddr_up(ifaddrp) && errno != ENXIO) {
2273 			(void) fprintf(stderr, "ifconfig: cannot bring back up "
2274 			    "%s: %s\n", ifaddrp->ia_name, strerror(errno));
2275 		}
2276 	}
2277 	ifaddrlistx_free(downaddrs);
2278 	ifaddrlistx_free(ifaddrs);
2279 
2280 	/*
2281 	 * We'd return -1, but foreachinterface() doesn't propagate the error
2282 	 * into the exit status, so we're forced to explicitly exit().
2283 	 */
2284 	exit(1);
2285 	/* NOTREACHED */
2286 }
2287 
2288 static boolean_t
2289 modcheck(const char *ifname)
2290 {
2291 	(void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
2292 
2293 	if (ioctl(s, SIOCGLIFFLAGS, &lifr) < 0) {
2294 		Perror0("SIOCGLIFFLAGS");
2295 		return (_B_FALSE);
2296 	}
2297 
2298 	if (lifr.lifr_flags & IFF_IPMP) {
2299 		(void) fprintf(stderr, "ifconfig: %s: module operations not"
2300 		    " supported on IPMP interfaces\n", ifname);
2301 		return (_B_FALSE);
2302 	}
2303 	if (lifr.lifr_flags & IFF_VIRTUAL) {
2304 		(void) fprintf(stderr, "ifconfig: %s: module operations not"
2305 		    " supported on virtual IP interfaces\n", ifname);
2306 		return (_B_FALSE);
2307 	}
2308 	return (_B_TRUE);
2309 }
2310 
2311 /*
2312  * To list all the modules above a given network interface.
2313  */
2314 /* ARGSUSED */
2315 static int
2316 modlist(char *null, int64_t param)
2317 {
2318 	int muxid_fd;
2319 	int muxfd;
2320 	int ipfd_lowstr;
2321 	int arpfd_lowstr;
2322 	int num_mods;
2323 	int i;
2324 	struct str_list strlist;
2325 	int orig_arpid;
2326 
2327 	/*
2328 	 * We'd return -1, but foreachinterface() doesn't propagate the error
2329 	 * into the exit status, so we're forced to explicitly exit().
2330 	 */
2331 	if (!modcheck(name))
2332 		exit(1);
2333 
2334 	if (ip_domux2fd(&muxfd, &muxid_fd, &ipfd_lowstr, &arpfd_lowstr,
2335 	    &orig_arpid) < 0) {
2336 		return (-1);
2337 	}
2338 	if ((num_mods = ioctl(ipfd_lowstr, I_LIST, NULL)) < 0) {
2339 		Perror0("cannot I_LIST to get the number of modules");
2340 	} else {
2341 		if (debug > 0) {
2342 			(void) printf("Listing (%d) modules above %s\n",
2343 			    num_mods, name);
2344 		}
2345 
2346 		strlist.sl_nmods = num_mods;
2347 		strlist.sl_modlist = malloc(sizeof (struct str_mlist) *
2348 		    num_mods);
2349 		if (strlist.sl_modlist == NULL) {
2350 			Perror0("cannot malloc");
2351 		} else {
2352 			if (ioctl(ipfd_lowstr, I_LIST, (caddr_t)&strlist) < 0) {
2353 				Perror0("cannot I_LIST for module names");
2354 			} else {
2355 				for (i = 0; i < strlist.sl_nmods; i++) {
2356 					(void) printf("%d %s\n", i,
2357 					    strlist.sl_modlist[i].l_name);
2358 				}
2359 			}
2360 			free(strlist.sl_modlist);
2361 		}
2362 	}
2363 	return (ip_plink(muxfd, muxid_fd, ipfd_lowstr, arpfd_lowstr,
2364 	    orig_arpid));
2365 }
2366 
2367 #define	MODINSERT_OP	'i'
2368 #define	MODREMOVE_OP	'r'
2369 
2370 /*
2371  * To insert a module to the stream of the interface.  It is just a
2372  * wrapper.  The real function is modop().
2373  */
2374 /* ARGSUSED */
2375 static int
2376 modinsert(char *arg, int64_t param)
2377 {
2378 	return (modop(arg, MODINSERT_OP));
2379 }
2380 
2381 /*
2382  * To remove a module from the stream of the interface.  It is just a
2383  * wrapper.  The real function is modop().
2384  */
2385 /* ARGSUSED */
2386 static int
2387 modremove(char *arg, int64_t param)
2388 {
2389 	return (modop(arg, MODREMOVE_OP));
2390 }
2391 
2392 /*
2393  * Helper function for mod*() functions.  It gets a fd to the lower IP
2394  * stream and I_PUNLINK's the lower stream.  It also initializes the
2395  * global variable lifr.
2396  *
2397  * Param:
2398  *	int *muxfd: fd to /dev/udp{,6} for I_PLINK/I_PUNLINK
2399  *	int *muxid_fd: fd to /dev/udp{,6} for LIFMUXID
2400  *	int *ipfd_lowstr: fd to the lower IP stream.
2401  *	int *arpfd_lowstr: fd to the lower ARP stream.
2402  *
2403  * Return:
2404  *	-1 if operation fails, 0 otherwise.
2405  *
2406  * Please see the big block comment above ifplumb() for the logic of the
2407  * PLINK/PUNLINK
2408  */
2409 static int
2410 ip_domux2fd(int *muxfd, int *muxid_fd, int *ipfd_lowstr, int *arpfd_lowstr,
2411     int *orig_arpid)
2412 {
2413 	uint64_t	flags;
2414 	char		*udp_dev_name;
2415 
2416 	*orig_arpid = 0;
2417 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2418 	if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
2419 		Perror0_exit("status: SIOCGLIFFLAGS");
2420 	}
2421 	flags = lifr.lifr_flags;
2422 	if (flags & IFF_IPV4) {
2423 		udp_dev_name = UDP_DEV_NAME;
2424 	} else if (flags & IFF_IPV6) {
2425 		udp_dev_name = UDP6_DEV_NAME;
2426 	} else {
2427 		return (-1);
2428 	}
2429 
2430 	if ((*muxid_fd = open(udp_dev_name, O_RDWR)) < 0) {
2431 		Perror2("open", udp_dev_name);
2432 		return (-1);
2433 	}
2434 	if (ioctl(*muxid_fd, SIOCGLIFMUXID, (caddr_t)&lifr) < 0) {
2435 		Perror2("SIOCGLIFMUXID", udp_dev_name);
2436 		return (-1);
2437 	}
2438 	if (debug > 0) {
2439 		(void) printf("ARP_muxid %d IP_muxid %d\n",
2440 		    lifr.lifr_arp_muxid, lifr.lifr_ip_muxid);
2441 	}
2442 
2443 	/*
2444 	 * Use /dev/udp{,6} as the mux to avoid linkcycles.
2445 	 */
2446 	if (ipadm_open_arp_on_udp(udp_dev_name, muxfd) != IPADM_SUCCESS)
2447 		return (-1);
2448 
2449 	if (lifr.lifr_arp_muxid != 0) {
2450 		if ((*arpfd_lowstr = ioctl(*muxfd, _I_MUXID2FD,
2451 		    lifr.lifr_arp_muxid)) < 0) {
2452 			if ((errno == EINVAL) &&
2453 			    (flags & (IFF_NOARP | IFF_IPV6))) {
2454 				/*
2455 				 * Some plumbing utilities set the muxid to
2456 				 * -1 or some invalid value to signify that
2457 				 * there is no arp stream. Set the muxid to 0
2458 				 * before trying to unplumb the IP stream.
2459 				 * IP does not allow the IP stream to be
2460 				 * unplumbed if it sees a non-null arp muxid,
2461 				 * for consistency of IP-ARP streams.
2462 				 */
2463 				*orig_arpid = lifr.lifr_arp_muxid;
2464 				lifr.lifr_arp_muxid = 0;
2465 				(void) ioctl(*muxid_fd, SIOCSLIFMUXID,
2466 				    (caddr_t)&lifr);
2467 				*arpfd_lowstr = -1;
2468 			} else {
2469 				Perror0("_I_MUXID2FD");
2470 				return (-1);
2471 			}
2472 		} else if (ioctl(*muxfd, I_PUNLINK,
2473 		    lifr.lifr_arp_muxid) < 0) {
2474 			Perror2("I_PUNLINK", udp_dev_name);
2475 			return (-1);
2476 		}
2477 	} else {
2478 		*arpfd_lowstr = -1;
2479 	}
2480 
2481 	if ((*ipfd_lowstr = ioctl(*muxfd, _I_MUXID2FD,
2482 	    lifr.lifr_ip_muxid)) < 0) {
2483 		Perror0("_I_MUXID2FD");
2484 		/* Undo any changes we made */
2485 		if (*orig_arpid != 0) {
2486 			lifr.lifr_arp_muxid = *orig_arpid;
2487 			(void) ioctl(*muxid_fd, SIOCSLIFMUXID, (caddr_t)&lifr);
2488 		}
2489 		return (-1);
2490 	}
2491 	if (ioctl(*muxfd, I_PUNLINK, lifr.lifr_ip_muxid) < 0) {
2492 		Perror2("I_PUNLINK", udp_dev_name);
2493 		/* Undo any changes we made */
2494 		if (*orig_arpid != 0) {
2495 			lifr.lifr_arp_muxid = *orig_arpid;
2496 			(void) ioctl(*muxid_fd, SIOCSLIFMUXID, (caddr_t)&lifr);
2497 		}
2498 		return (-1);
2499 	}
2500 	return (0);
2501 }
2502 
2503 /*
2504  * Helper function for mod*() functions.  It I_PLINK's back the upper and
2505  * lower IP streams.  Note that this function must be called after
2506  * ip_domux2fd().  In ip_domux2fd(), the global variable lifr is initialized
2507  * and ip_plink() needs information in lifr.  So ip_domux2fd() and ip_plink()
2508  * must be called in pairs.
2509  *
2510  * Param:
2511  *	int muxfd: fd to /dev/udp{,6} for I_PLINK/I_PUNLINK
2512  *	int muxid_fd: fd to /dev/udp{,6} for LIFMUXID
2513  *	int ipfd_lowstr: fd to the lower IP stream.
2514  *	int arpfd_lowstr: fd to the lower ARP stream.
2515  *
2516  * Return:
2517  *	-1 if operation fails, 0 otherwise.
2518  *
2519  * Please see the big block comment above ifplumb() for the logic of the
2520  * PLINK/PUNLINK
2521  */
2522 static int
2523 ip_plink(int muxfd, int muxid_fd, int ipfd_lowstr, int arpfd_lowstr,
2524     int orig_arpid)
2525 {
2526 	int ip_muxid;
2527 
2528 	ip_muxid = ioctl(muxfd, I_PLINK, ipfd_lowstr);
2529 	if (ip_muxid < 0) {
2530 		Perror2("I_PLINK", UDP_DEV_NAME);
2531 		return (-1);
2532 	}
2533 
2534 	/*
2535 	 * If there is an arp stream, plink it. If there is no
2536 	 * arp stream, then it is possible that the plumbing
2537 	 * utility could have stored any value in the arp_muxid.
2538 	 * If so, restore it from orig_arpid.
2539 	 */
2540 	if (arpfd_lowstr != -1) {
2541 		if (ioctl(muxfd, I_PLINK, arpfd_lowstr) < 0) {
2542 			Perror2("I_PLINK", UDP_DEV_NAME);
2543 			return (-1);
2544 		}
2545 	} else if (orig_arpid != 0) {
2546 		/* Undo the changes we did in ip_domux2fd */
2547 		lifr.lifr_arp_muxid = orig_arpid;
2548 		lifr.lifr_ip_muxid = ip_muxid;
2549 		(void) ioctl(muxid_fd, SIOCSLIFMUXID, (caddr_t)&lifr);
2550 	}
2551 
2552 	(void) close(muxfd);
2553 	(void) close(muxid_fd);
2554 	return (0);
2555 }
2556 
2557 /*
2558  * The real function to perform module insertion/removal.
2559  *
2560  * Param:
2561  *	char *arg: the argument string module_name@position
2562  *	char op: operation, either MODINSERT_OP or MODREMOVE_OP.
2563  *
2564  * Return:
2565  *	Before doing ip_domux2fd(), this function calls exit(1) in case of
2566  *	error.  After ip_domux2fd() is done, it returns -1 for error, 0
2567  *	otherwise.
2568  */
2569 static int
2570 modop(char *arg, char op)
2571 {
2572 	char *pos_p;
2573 	int muxfd;
2574 	int muxid_fd;
2575 	int ipfd_lowstr;  /* IP stream (lower stream of mux) to be plinked */
2576 	int arpfd_lowstr; /* ARP stream (lower stream of mux) to be plinked */
2577 	struct strmodconf mod;
2578 	char *at_char = "@";
2579 	char *arg_str;
2580 	int orig_arpid;
2581 
2582 	/*
2583 	 * We'd return -1, but foreachinterface() doesn't propagate the error
2584 	 * into the exit status, so we're forced to explicitly exit().
2585 	 */
2586 	if (!modcheck(name))
2587 		exit(1);
2588 
2589 	/* Need to save the original string for -a option. */
2590 	if ((arg_str = malloc(strlen(arg) + 1)) == NULL) {
2591 		Perror0("cannot malloc");
2592 		return (-1);
2593 	}
2594 	(void) strcpy(arg_str, arg);
2595 
2596 	if (*arg_str == *at_char) {
2597 		(void) fprintf(stderr,
2598 		    "ifconfig: must supply a module name\n");
2599 		exit(1);
2600 	}
2601 	mod.mod_name = strtok(arg_str, at_char);
2602 	if (strlen(mod.mod_name) > FMNAMESZ) {
2603 		(void) fprintf(stderr, "ifconfig: module name too long: %s\n",
2604 		    mod.mod_name);
2605 		exit(1);
2606 	}
2607 
2608 	/*
2609 	 * Need to make sure that the core TCP/IP stack modules are not
2610 	 * removed.  Otherwise, "bad" things can happen.  If a module
2611 	 * is removed and inserted back, it loses its old state.  But
2612 	 * the modules above it still have the old state.  E.g. IP assumes
2613 	 * fast data path while tunnel after re-inserted assumes that it can
2614 	 * receive M_DATA only in fast data path for which it does not have
2615 	 * any state.  This is a general caveat of _I_REMOVE/_I_INSERT.
2616 	 */
2617 	if (op == MODREMOVE_OP &&
2618 	    (strcmp(mod.mod_name, ARP_MOD_NAME) == 0 ||
2619 	    strcmp(mod.mod_name, IP_MOD_NAME) == 0)) {
2620 		(void) fprintf(stderr, "ifconfig: cannot remove %s\n",
2621 		    mod.mod_name);
2622 		exit(1);
2623 	}
2624 
2625 	if ((pos_p = strtok(NULL, at_char)) == NULL) {
2626 		(void) fprintf(stderr, "ifconfig: must supply a position\n");
2627 		exit(1);
2628 	}
2629 	mod.pos = atoi(pos_p);
2630 
2631 	if (ip_domux2fd(&muxfd, &muxid_fd, &ipfd_lowstr, &arpfd_lowstr,
2632 	    &orig_arpid) < 0) {
2633 		free(arg_str);
2634 		return (-1);
2635 	}
2636 	switch (op) {
2637 	case MODINSERT_OP:
2638 		if (debug > 0) {
2639 			(void) printf("Inserting module %s at %d\n",
2640 			    mod.mod_name, mod.pos);
2641 		}
2642 		if (ioctl(ipfd_lowstr, _I_INSERT, (caddr_t)&mod) < 0) {
2643 			Perror2("fail to insert module", mod.mod_name);
2644 		}
2645 		break;
2646 	case MODREMOVE_OP:
2647 		if (debug > 0) {
2648 			(void) printf("Removing module %s at %d\n",
2649 			    mod.mod_name, mod.pos);
2650 		}
2651 		if (ioctl(ipfd_lowstr, _I_REMOVE, (caddr_t)&mod) < 0) {
2652 			Perror2("fail to remove module", mod.mod_name);
2653 		}
2654 		break;
2655 	default:
2656 		/* Should never get to here. */
2657 		(void) fprintf(stderr, "Unknown operation\n");
2658 		break;
2659 	}
2660 	free(arg_str);
2661 	return (ip_plink(muxfd, muxid_fd, ipfd_lowstr, arpfd_lowstr,
2662 	    orig_arpid));
2663 }
2664 
2665 static int
2666 modify_tun(iptun_params_t *params)
2667 {
2668 	dladm_status_t status;
2669 
2670 	if ((status = ifconfig_dladm_open(name, DATALINK_CLASS_IPTUN,
2671 	    &params->iptun_param_linkid)) == DLADM_STATUS_OK)
2672 		status = dladm_iptun_modify(dlh, params, DLADM_OPT_ACTIVE);
2673 	if (status != DLADM_STATUS_OK)
2674 		dladmerr_exit(status, name);
2675 	return (0);
2676 }
2677 
2678 /*
2679  * Set tunnel source address
2680  */
2681 /* ARGSUSED */
2682 static int
2683 setiftsrc(char *addr, int64_t param)
2684 {
2685 	iptun_params_t params;
2686 
2687 	params.iptun_param_flags = IPTUN_PARAM_LADDR;
2688 	(void) strlcpy(params.iptun_param_laddr, addr,
2689 	    sizeof (params.iptun_param_laddr));
2690 	return (modify_tun(&params));
2691 }
2692 
2693 /*
2694  * Set tunnel destination address
2695  */
2696 /* ARGSUSED */
2697 static int
2698 setiftdst(char *addr, int64_t param)
2699 {
2700 	iptun_params_t params;
2701 
2702 	params.iptun_param_flags = IPTUN_PARAM_RADDR;
2703 	(void) strlcpy(params.iptun_param_raddr, addr,
2704 	    sizeof (params.iptun_param_raddr));
2705 	return (modify_tun(&params));
2706 }
2707 
2708 static int
2709 set_tun_prop(const char *propname, char *value)
2710 {
2711 	dladm_status_t	status;
2712 	datalink_id_t	linkid;
2713 
2714 	status = ifconfig_dladm_open(name, DATALINK_CLASS_IPTUN, &linkid);
2715 	if (status == DLADM_STATUS_OK) {
2716 		status = dladm_set_linkprop(dlh, linkid, propname, &value, 1,
2717 		    DLADM_OPT_ACTIVE);
2718 	}
2719 	if (status != DLADM_STATUS_OK)
2720 		dladmerr_exit(status, name);
2721 	return (0);
2722 }
2723 
2724 /* Set tunnel encapsulation limit. */
2725 /* ARGSUSED */
2726 static int
2727 set_tun_encap_limit(char *arg, int64_t param)
2728 {
2729 	return (set_tun_prop("encaplimit", arg));
2730 }
2731 
2732 /* Disable encapsulation limit. */
2733 /* ARGSUSED */
2734 static int
2735 clr_tun_encap_limit(char *arg, int64_t param)
2736 {
2737 	return (set_tun_encap_limit("-1", 0));
2738 }
2739 
2740 /* Set tunnel hop limit. */
2741 /* ARGSUSED */
2742 static int
2743 set_tun_hop_limit(char *arg, int64_t param)
2744 {
2745 	return (set_tun_prop("hoplimit", arg));
2746 }
2747 
2748 /* Set zone ID */
2749 static int
2750 setzone(char *arg, int64_t param)
2751 {
2752 	zoneid_t zoneid = GLOBAL_ZONEID;
2753 
2754 	if (param == NEXTARG) {
2755 		/* zone must be active */
2756 		if ((zoneid = getzoneidbyname(arg)) == -1) {
2757 			(void) fprintf(stderr,
2758 			    "ifconfig: unknown zone '%s'\n", arg);
2759 			exit(1);
2760 		}
2761 	}
2762 	(void) strlcpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2763 	lifr.lifr_zoneid = zoneid;
2764 	if (ioctl(s, SIOCSLIFZONE, (caddr_t)&lifr) == -1)
2765 		Perror0_exit("SIOCSLIFZONE");
2766 	return (0);
2767 }
2768 
2769 /* Put interface into all zones */
2770 /* ARGSUSED */
2771 static int
2772 setallzones(char *arg, int64_t param)
2773 {
2774 	(void) strlcpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2775 	lifr.lifr_zoneid = ALL_ZONES;
2776 	if (ioctl(s, SIOCSLIFZONE, (caddr_t)&lifr) == -1)
2777 		Perror0_exit("SIOCSLIFZONE");
2778 	return (0);
2779 }
2780 
2781 /* Set source address to use */
2782 /* ARGSUSED */
2783 static int
2784 setifsrc(char *arg, int64_t param)
2785 {
2786 	uint_t ifindex = 0;
2787 	int rval;
2788 
2789 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2790 
2791 	/*
2792 	 * Argument can be either an interface name or "none". The latter means
2793 	 * that any previous selection is cleared.
2794 	 */
2795 
2796 	if (strchr(arg, ':') != NULL) {
2797 		(void) fprintf(stderr,
2798 		    "ifconfig: Cannot specify logical interface for usesrc \n");
2799 		exit(1);
2800 	}
2801 
2802 	rval = strcmp(arg, NONE_STR);
2803 	if (rval != 0) {
2804 		if ((ifindex = if_nametoindex(arg)) == 0) {
2805 			(void) strncpy(lifr.lifr_name, arg, LIFNAMSIZ);
2806 			Perror0_exit("Could not get interface index");
2807 		}
2808 		lifr.lifr_index = ifindex;
2809 	} else {
2810 		if (ioctl(s, SIOCGLIFUSESRC, (caddr_t)&lifr) != 0)
2811 			Perror0_exit("Not a valid usesrc consumer");
2812 		lifr.lifr_index = 0;
2813 	}
2814 
2815 	if (debug)
2816 		(void) printf("setifsrc: lifr_name %s, lifr_index %d\n",
2817 		    lifr.lifr_name, lifr.lifr_index);
2818 
2819 	if (ioctl(s, SIOCSLIFUSESRC, (caddr_t)&lifr) == -1) {
2820 		if (rval == 0)
2821 			Perror0_exit("Cannot reset usesrc group");
2822 		else
2823 			Perror0_exit("Could not set source interface");
2824 	}
2825 
2826 	return (0);
2827 }
2828 
2829 /*
2830  * Print the interface status line associated with `ifname'
2831  */
2832 static void
2833 ifstatus(const char *ifname)
2834 {
2835 	uint64_t flags;
2836 	char if_usesrc_name[LIFNAMSIZ];
2837 	char *newbuf;
2838 	int n, numifs, rval = 0;
2839 	struct lifreq *lifrp;
2840 	struct lifsrcof lifs;
2841 
2842 	(void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
2843 	if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
2844 		Perror0_exit("status: SIOCGLIFFLAGS");
2845 	}
2846 	flags = lifr.lifr_flags;
2847 
2848 	/*
2849 	 * In V4 compatibility mode, we don't print the IFF_IPV4 flag or
2850 	 * interfaces with IFF_IPV6 set.
2851 	 */
2852 	if (v4compat) {
2853 		flags &= ~IFF_IPV4;
2854 		if (flags & IFF_IPV6)
2855 			return;
2856 	}
2857 
2858 	(void) printf("%s: ", ifname);
2859 	print_flags(flags);
2860 
2861 	(void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
2862 	if (ioctl(s, SIOCGLIFMETRIC, (caddr_t)&lifr) < 0) {
2863 		Perror0_exit("status: SIOCGLIFMETRIC");
2864 	} else {
2865 		if (lifr.lifr_metric)
2866 			(void) printf(" metric %d", lifr.lifr_metric);
2867 	}
2868 	if (ioctl(s, SIOCGLIFMTU, (caddr_t)&lifr) >= 0)
2869 		(void) printf(" mtu %u", lifr.lifr_mtu);
2870 
2871 	/* don't print index or zone when in compatibility mode */
2872 	if (!v4compat) {
2873 		if (ioctl(s, SIOCGLIFINDEX, (caddr_t)&lifr) >= 0)
2874 			(void) printf(" index %d", lifr.lifr_index);
2875 		/*
2876 		 * Stack instances use GLOBAL_ZONEID for IP data structures
2877 		 * even in the non-global zone.
2878 		 */
2879 		if (ioctl(s, SIOCGLIFZONE, (caddr_t)&lifr) >= 0 &&
2880 		    lifr.lifr_zoneid != getzoneid() &&
2881 		    lifr.lifr_zoneid != GLOBAL_ZONEID) {
2882 			char zone_name[ZONENAME_MAX];
2883 
2884 			if (lifr.lifr_zoneid == ALL_ZONES) {
2885 				(void) printf("\n\tall-zones");
2886 			} else if (getzonenamebyid(lifr.lifr_zoneid, zone_name,
2887 			    sizeof (zone_name)) < 0) {
2888 				(void) printf("\n\tzone %d", lifr.lifr_zoneid);
2889 			} else {
2890 				(void) printf("\n\tzone %s", zone_name);
2891 			}
2892 		}
2893 	}
2894 
2895 	if (ioctl(s, SIOCGLIFINDEX, (caddr_t)&lifr) >= 0) {
2896 		lifs.lifs_ifindex = lifr.lifr_index;
2897 
2898 		/*
2899 		 * Find the number of interfaces that use this interfaces'
2900 		 * address as a source address
2901 		 */
2902 		lifs.lifs_buf = NULL;
2903 		lifs.lifs_maxlen = 0;
2904 		for (;;) {
2905 			/* The first pass will give the bufsize we need */
2906 			rval = ioctl(s, SIOCGLIFSRCOF, (char *)&lifs);
2907 			if (rval < 0) {
2908 				if (lifs.lifs_buf != NULL) {
2909 					free(lifs.lifs_buf);
2910 					lifs.lifs_buf = NULL;
2911 				}
2912 				lifs.lifs_len = 0;
2913 				break;
2914 			}
2915 			if (lifs.lifs_len <= lifs.lifs_maxlen)
2916 				break;
2917 			/* Use kernel's size + a small margin to avoid loops */
2918 			lifs.lifs_maxlen = lifs.lifs_len +
2919 			    5 * sizeof (struct lifreq);
2920 			/* For the first pass, realloc acts like malloc */
2921 			newbuf = realloc(lifs.lifs_buf, lifs.lifs_maxlen);
2922 			if (newbuf == NULL) {
2923 				if (lifs.lifs_buf != NULL) {
2924 					free(lifs.lifs_buf);
2925 					lifs.lifs_buf = NULL;
2926 				}
2927 				lifs.lifs_len = 0;
2928 				break;
2929 			}
2930 			lifs.lifs_buf = newbuf;
2931 		}
2932 
2933 
2934 		numifs = lifs.lifs_len / sizeof (struct lifreq);
2935 		if (numifs > 0) {
2936 			lifrp = lifs.lifs_req;
2937 			(void) printf("\n\tsrcof");
2938 			for (n = numifs; n > 0; n--, lifrp++) {
2939 				(void) printf(" %s", lifrp->lifr_name);
2940 			}
2941 		}
2942 
2943 		if (lifs.lifs_buf != NULL)
2944 			free(lifs.lifs_buf);
2945 	}
2946 
2947 	/* Find the interface whose source address this interface uses */
2948 	if (ioctl(s, SIOCGLIFUSESRC, (caddr_t)&lifr) == 0) {
2949 		if (lifr.lifr_index != 0) {
2950 			if (if_indextoname(lifr.lifr_index,
2951 			    if_usesrc_name) == NULL) {
2952 				(void) printf("\n\tusesrc ifIndex %d",
2953 				    lifr.lifr_index);
2954 			} else {
2955 				(void) printf("\n\tusesrc %s", if_usesrc_name);
2956 			}
2957 		}
2958 	}
2959 
2960 	(void) putchar('\n');
2961 }
2962 
2963 /*
2964  * Print the status of the interface.  If an address family was
2965  * specified, show it and it only; otherwise, show them all.
2966  */
2967 static void
2968 status(void)
2969 {
2970 	struct afswtch	*p = afp;
2971 	uint64_t	flags;
2972 	datalink_id_t	linkid;
2973 
2974 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
2975 	if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
2976 		Perror0_exit("status: SIOCGLIFFLAGS");
2977 	}
2978 
2979 	flags = lifr.lifr_flags;
2980 
2981 	/*
2982 	 * Only print the interface status if the address family matches
2983 	 * the interface family flag.
2984 	 */
2985 	if (p != NULL) {
2986 		if (((p->af_af == AF_INET6) && (flags & IFF_IPV4)) ||
2987 		    ((p->af_af == AF_INET) && (flags & IFF_IPV6)))
2988 			return;
2989 	}
2990 
2991 	/*
2992 	 * In V4 compatibility mode, don't print IFF_IPV6 interfaces.
2993 	 */
2994 	if (v4compat && (flags & IFF_IPV6))
2995 		return;
2996 
2997 	ifstatus(name);
2998 
2999 	if (ifconfig_dladm_open(name, DATALINK_CLASS_IPTUN, &linkid) ==
3000 	    DLADM_STATUS_OK)
3001 		tun_status(linkid);
3002 
3003 	if (p != NULL) {
3004 		(*p->af_status)(1, flags);
3005 	} else {
3006 		for (p = afs; p->af_name; p++) {
3007 			/* set global af for use in p->af_status */
3008 			af = p->af_af;
3009 			(*p->af_status)(0, flags);
3010 		}
3011 
3012 		/*
3013 		 * Historically, 'ether' has been an address family,
3014 		 * so print it here.
3015 		 */
3016 		print_ifether(name);
3017 	}
3018 }
3019 
3020 /*
3021  * Print the status of the interface in a format that can be used to
3022  * reconfigure the interface later. Code stolen from status() above.
3023  */
3024 /* ARGSUSED */
3025 static int
3026 configinfo(char *null, int64_t param)
3027 {
3028 	char *cp;
3029 	struct afswtch *p = afp;
3030 	uint64_t flags;
3031 	char lifname[LIFNAMSIZ];
3032 	char if_usesrc_name[LIFNAMSIZ];
3033 
3034 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3035 
3036 	if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
3037 		Perror0_exit("status: SIOCGLIFFLAGS");
3038 	}
3039 	flags = lifr.lifr_flags;
3040 
3041 	if (debug) {
3042 		(void) printf("configinfo: name %s flags  0x%llx af_af %d\n",
3043 		    name, flags, p != NULL ? p->af_af : -1);
3044 	}
3045 
3046 	/*
3047 	 * Build the interface name to print (we cannot directly use `name'
3048 	 * because one cannot "plumb" ":0" interfaces).
3049 	 */
3050 	(void) strlcpy(lifname, name, LIFNAMSIZ);
3051 	if ((cp = strchr(lifname, ':')) != NULL && atoi(cp + 1) == 0)
3052 		*cp = '\0';
3053 
3054 	/*
3055 	 * if the interface is IPv4
3056 	 *	if we have a IPv6 address family restriction return
3057 	 *		so it won't print
3058 	 *	if we are in IPv4 compatibility mode, clear out IFF_IPV4
3059 	 *		so we don't print it.
3060 	 */
3061 	if (flags & IFF_IPV4) {
3062 		if (p && p->af_af == AF_INET6)
3063 			return (-1);
3064 		if (v4compat)
3065 			flags &= ~IFF_IPV4;
3066 
3067 		(void) printf("%s inet plumb", lifname);
3068 	} else if (flags & IFF_IPV6) {
3069 		/*
3070 		 * else if the interface is IPv6
3071 		 *	if we have a IPv4 address family restriction return
3072 		 *	or we are in IPv4 compatibiltiy mode, return.
3073 		 */
3074 		if (p && p->af_af == AF_INET)
3075 			return (-1);
3076 		if (v4compat)
3077 			return (-1);
3078 
3079 		(void) printf("%s inet6 plumb", lifname);
3080 	}
3081 
3082 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3083 	if (ioctl(s, SIOCGLIFMETRIC, (caddr_t)&lifr) < 0) {
3084 		Perror0_exit("configinfo: SIOCGLIFMETRIC");
3085 	} else {
3086 		if (lifr.lifr_metric)
3087 			(void) printf(" metric %d ", lifr.lifr_metric);
3088 	}
3089 	if (((flags & (IFF_VIRTUAL|IFF_LOOPBACK)) != IFF_VIRTUAL) &&
3090 	    ioctl(s, SIOCGLIFMTU, (caddr_t)&lifr) >= 0)
3091 		(void) printf(" mtu %d", lifr.lifr_metric);
3092 
3093 	/* Index only applies to the zeroth interface */
3094 	if (lifnum(name) == 0) {
3095 		if (ioctl(s, SIOCGLIFINDEX, (caddr_t)&lifr) >= 0)
3096 			(void) printf(" index %d", lifr.lifr_index);
3097 	}
3098 
3099 	if (ioctl(s, SIOCGLIFUSESRC, (caddr_t)&lifr) == 0) {
3100 		if (lifr.lifr_index != 0) {
3101 			if (if_indextoname(lifr.lifr_index,
3102 			    if_usesrc_name) != NULL) {
3103 				(void) printf(" usesrc %s", if_usesrc_name);
3104 			}
3105 		}
3106 	}
3107 
3108 	if (p != NULL) {
3109 		(*p->af_configinfo)(1, flags);
3110 	} else {
3111 		for (p = afs; p->af_name; p++) {
3112 			(void) close(s);
3113 			s = socket(SOCKET_AF(p->af_af), SOCK_DGRAM, 0);
3114 			/* set global af for use in p->af_configinfo */
3115 			af = p->af_af;
3116 			if (s == -1) {
3117 				Perror0_exit("socket");
3118 			}
3119 			(*p->af_configinfo)(0, flags);
3120 		}
3121 	}
3122 
3123 	(void) putchar('\n');
3124 	return (0);
3125 }
3126 
3127 static void
3128 print_tsec(iptun_params_t *params)
3129 {
3130 	ipsec_req_t *ipsr;
3131 
3132 	(void) printf("\ttunnel security settings  ");
3133 	if (!(params->iptun_param_flags & IPTUN_PARAM_SECINFO)) {
3134 		(void) printf("-->  use 'ipsecconf -ln -i %s'", name);
3135 	} else {
3136 		ipsr = &params->iptun_param_secinfo;
3137 		if (ipsr->ipsr_ah_req & IPSEC_PREF_REQUIRED) {
3138 			(void) printf("ah (%s)  ",
3139 			    rparsealg(ipsr->ipsr_auth_alg, IPSEC_PROTO_AH));
3140 		}
3141 		if (ipsr->ipsr_esp_req & IPSEC_PREF_REQUIRED) {
3142 			(void) printf("esp (%s",
3143 			    rparsealg(ipsr->ipsr_esp_alg, IPSEC_PROTO_ESP));
3144 			(void) printf("/%s)",
3145 			    rparsealg(ipsr->ipsr_esp_auth_alg, IPSEC_PROTO_AH));
3146 		}
3147 	}
3148 	(void) printf("\n");
3149 }
3150 
3151 static void
3152 tun_status(datalink_id_t linkid)
3153 {
3154 	iptun_params_t	params;
3155 	char		propval[DLADM_PROP_VAL_MAX];
3156 	char		*valptr[1];
3157 	uint_t		valcnt = 1;
3158 	boolean_t	tabbed = _B_FALSE;
3159 
3160 	params.iptun_param_linkid = linkid;
3161 
3162 	/* If dladm_iptun_getparams() fails, assume we are not a tunnel. */
3163 	assert(dlh_opened);
3164 	if (dladm_iptun_getparams(dlh, &params, DLADM_OPT_ACTIVE) !=
3165 	    DLADM_STATUS_OK)
3166 		return;
3167 
3168 	switch (params.iptun_param_type) {
3169 	case IPTUN_TYPE_IPV4:
3170 	case IPTUN_TYPE_6TO4:
3171 		(void) printf("\tinet");
3172 		break;
3173 	case IPTUN_TYPE_IPV6:
3174 		(void) printf("\tinet6");
3175 		break;
3176 	default:
3177 		dladmerr_exit(DLADM_STATUS_IPTUNTYPE, name);
3178 		break;
3179 	}
3180 
3181 	/*
3182 	 * There is always a source address.  If it hasn't been explicitly
3183 	 * set, the API will pass back a buffer containing the unspecified
3184 	 * address.
3185 	 */
3186 	(void) printf(" tunnel src %s ", params.iptun_param_laddr);
3187 
3188 	if (params.iptun_param_flags & IPTUN_PARAM_RADDR)
3189 		(void) printf("tunnel dst %s\n", params.iptun_param_raddr);
3190 	else
3191 		(void) putchar('\n');
3192 
3193 	if (params.iptun_param_flags & IPTUN_PARAM_IPSECPOL)
3194 		print_tsec(&params);
3195 
3196 	valptr[0] = propval;
3197 	if (dladm_get_linkprop(dlh, linkid, DLADM_PROP_VAL_CURRENT, "hoplimit",
3198 	    (char **)valptr, &valcnt) == DLADM_STATUS_OK) {
3199 		(void) printf("\ttunnel hop limit %s ", propval);
3200 		tabbed = _B_TRUE;
3201 	}
3202 
3203 	if (dladm_get_linkprop(dlh, linkid, DLADM_PROP_VAL_CURRENT,
3204 	    "encaplimit", (char **)valptr, &valcnt) == DLADM_STATUS_OK) {
3205 		uint32_t elim;
3206 
3207 		if (!tabbed) {
3208 			(void) putchar('\t');
3209 			tabbed = _B_TRUE;
3210 		}
3211 		elim = strtol(propval, NULL, 10);
3212 		if (elim > 0)
3213 			(void) printf("tunnel encapsulation limit %s", propval);
3214 		else
3215 			(void) printf("tunnel encapsulation limit disabled");
3216 	}
3217 
3218 	if (tabbed)
3219 		(void) putchar('\n');
3220 }
3221 
3222 static void
3223 in_status(int force, uint64_t flags)
3224 {
3225 	struct sockaddr_in	*sin, *laddr;
3226 	struct sockaddr_in	netmask = { AF_INET };
3227 
3228 	if (debug)
3229 		(void) printf("in_status(%s) flags 0x%llx\n", name, flags);
3230 
3231 	/* only print status for IPv4 interfaces */
3232 	if (!(flags & IFF_IPV4))
3233 		return;
3234 
3235 	if (!(flags & IFF_NOLOCAL)) {
3236 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3237 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
3238 			if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3239 			    errno == ENXIO) {
3240 				if (!force)
3241 					return;
3242 				(void) memset(&lifr.lifr_addr, 0,
3243 				    sizeof (lifr.lifr_addr));
3244 			} else
3245 				Perror0_exit("in_status: SIOCGLIFADDR");
3246 		}
3247 		sin = (struct sockaddr_in *)&lifr.lifr_addr;
3248 		(void) printf("\tinet %s ", inet_ntoa(sin->sin_addr));
3249 		laddr = sin;
3250 	} else {
3251 		(void) printf("\tinet ");
3252 	}
3253 
3254 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3255 	if (ioctl(s, SIOCGLIFSUBNET, (caddr_t)&lifr) < 0) {
3256 		if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3257 		    errno == ENXIO) {
3258 			if (!force)
3259 				return;
3260 			(void) memset(&lifr.lifr_addr, 0,
3261 			    sizeof (lifr.lifr_addr));
3262 		} else {
3263 			Perror0_exit("in_status: SIOCGLIFSUBNET");
3264 		}
3265 	}
3266 	sin = (struct sockaddr_in *)&lifr.lifr_addr;
3267 	if ((flags & IFF_NOLOCAL) ||
3268 	    sin->sin_addr.s_addr != laddr->sin_addr.s_addr) {
3269 		(void) printf("subnet %s/%d ", inet_ntoa(sin->sin_addr),
3270 		    lifr.lifr_addrlen);
3271 	}
3272 	if (sin->sin_family != AF_INET) {
3273 		(void) printf("Wrong family: %d\n", sin->sin_family);
3274 	}
3275 
3276 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3277 	if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0) {
3278 		if (errno != EADDRNOTAVAIL)
3279 			Perror0_exit("in_status: SIOCGLIFNETMASK");
3280 		(void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr));
3281 	} else
3282 		netmask.sin_addr =
3283 		    ((struct sockaddr_in *)&lifr.lifr_addr)->sin_addr;
3284 	if (flags & IFF_POINTOPOINT) {
3285 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3286 		if (ioctl(s, SIOCGLIFDSTADDR, (caddr_t)&lifr) < 0) {
3287 			if (errno == EADDRNOTAVAIL)
3288 				(void) memset(&lifr.lifr_addr, 0,
3289 				    sizeof (lifr.lifr_addr));
3290 			else
3291 				Perror0_exit("in_status: SIOCGLIFDSTADDR");
3292 		}
3293 		sin = (struct sockaddr_in *)&lifr.lifr_dstaddr;
3294 		(void) printf("--> %s ", inet_ntoa(sin->sin_addr));
3295 	}
3296 	(void) printf("netmask %x ", ntohl(netmask.sin_addr.s_addr));
3297 	if (flags & IFF_BROADCAST) {
3298 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3299 		if (ioctl(s, SIOCGLIFBRDADDR, (caddr_t)&lifr) < 0) {
3300 			if (errno == EADDRNOTAVAIL)
3301 				(void) memset(&lifr.lifr_addr, 0,
3302 				    sizeof (lifr.lifr_addr));
3303 			else
3304 				Perror0_exit("in_status: SIOCGLIFBRDADDR");
3305 		}
3306 		sin = (struct sockaddr_in *)&lifr.lifr_addr;
3307 		if (sin->sin_addr.s_addr != 0) {
3308 			(void) printf("broadcast %s",
3309 			    inet_ntoa(sin->sin_addr));
3310 		}
3311 	}
3312 	/* If there is a groupname, print it for only the physical interface */
3313 	if (strchr(name, ':') == NULL) {
3314 		if (ioctl(s, SIOCGLIFGROUPNAME, &lifr) >= 0 &&
3315 		    lifr.lifr_groupname[0] != '\0') {
3316 			(void) printf("\n\tgroupname %s", lifr.lifr_groupname);
3317 		}
3318 	}
3319 	(void) putchar('\n');
3320 }
3321 
3322 static void
3323 in6_status(int force, uint64_t flags)
3324 {
3325 	char			abuf[INET6_ADDRSTRLEN];
3326 	struct sockaddr_in6	*sin6, *laddr6;
3327 
3328 	if (debug)
3329 		(void) printf("in6_status(%s) flags 0x%llx\n", name, flags);
3330 
3331 	if (!(flags & IFF_IPV6))
3332 		return;
3333 
3334 	if (!(flags & IFF_NOLOCAL)) {
3335 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3336 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
3337 			if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3338 			    errno == ENXIO) {
3339 				if (!force)
3340 					return;
3341 				(void) memset(&lifr.lifr_addr, 0,
3342 				    sizeof (lifr.lifr_addr));
3343 			} else
3344 				Perror0_exit("in_status6: SIOCGLIFADDR");
3345 		}
3346 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3347 		(void) printf("\tinet6 %s/%d ",
3348 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3349 		    abuf, sizeof (abuf)),
3350 		    lifr.lifr_addrlen);
3351 		laddr6 = sin6;
3352 	} else {
3353 		(void) printf("\tinet6 ");
3354 	}
3355 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3356 	if (ioctl(s, SIOCGLIFSUBNET, (caddr_t)&lifr) < 0) {
3357 		if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3358 		    errno == ENXIO) {
3359 			if (!force)
3360 				return;
3361 			(void) memset(&lifr.lifr_addr, 0,
3362 			    sizeof (lifr.lifr_addr));
3363 		} else
3364 			Perror0_exit("in_status6: SIOCGLIFSUBNET");
3365 	}
3366 	sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3367 	if ((flags & IFF_NOLOCAL) ||
3368 	    !IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, &laddr6->sin6_addr)) {
3369 		(void) printf("subnet %s/%d ",
3370 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3371 		    abuf, sizeof (abuf)),
3372 		    lifr.lifr_addrlen);
3373 	}
3374 	if (sin6->sin6_family != AF_INET6) {
3375 		(void) printf("Wrong family: %d\n", sin6->sin6_family);
3376 	}
3377 	if (flags & IFF_POINTOPOINT) {
3378 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3379 		if (ioctl(s, SIOCGLIFDSTADDR, (caddr_t)&lifr) < 0) {
3380 			if (errno == EADDRNOTAVAIL)
3381 				(void) memset(&lifr.lifr_addr, 0,
3382 				    sizeof (lifr.lifr_addr));
3383 			else
3384 				Perror0_exit("in_status6: SIOCGLIFDSTADDR");
3385 		}
3386 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_dstaddr;
3387 		(void) printf("--> %s ",
3388 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3389 		    abuf, sizeof (abuf)));
3390 	}
3391 	if (verbose) {
3392 		(void) putchar('\n');
3393 		(void) putchar('\t');
3394 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3395 		if (ioctl(s, SIOCGLIFTOKEN, (caddr_t)&lifr) < 0) {
3396 			if (errno == EADDRNOTAVAIL || errno == EINVAL)
3397 				(void) memset(&lifr.lifr_addr, 0,
3398 				    sizeof (lifr.lifr_addr));
3399 			else
3400 				Perror0_exit("in_status6: SIOCGLIFTOKEN");
3401 		} else {
3402 			sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3403 			(void) printf("token %s/%d ",
3404 			    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3405 			    abuf, sizeof (abuf)),
3406 			    lifr.lifr_addrlen);
3407 		}
3408 		if (ioctl(s, SIOCGLIFLNKINFO, (caddr_t)&lifr) < 0) {
3409 			if (errno != EINVAL) {
3410 				Perror0_exit("in_status6: SIOCGLIFLNKINFO");
3411 			}
3412 		} else {
3413 			(void) printf("maxhops %u, reachtime %u ms, "
3414 			    "reachretrans %u ms, maxmtu %u ",
3415 			    lifr.lifr_ifinfo.lir_maxhops,
3416 			    lifr.lifr_ifinfo.lir_reachtime,
3417 			    lifr.lifr_ifinfo.lir_reachretrans,
3418 			    lifr.lifr_ifinfo.lir_maxmtu);
3419 		}
3420 	}
3421 	/* If there is a groupname, print it for only the physical interface */
3422 	if (strchr(name, ':') == NULL) {
3423 		if (ioctl(s, SIOCGLIFGROUPNAME, &lifr) >= 0 &&
3424 		    lifr.lifr_groupname[0] != '\0') {
3425 			(void) printf("\n\tgroupname %s", lifr.lifr_groupname);
3426 		}
3427 	}
3428 	(void) putchar('\n');
3429 }
3430 
3431 static void
3432 in_configinfo(int force, uint64_t flags)
3433 {
3434 	struct sockaddr_in *sin, *laddr;
3435 	struct	sockaddr_in netmask = { AF_INET };
3436 
3437 	if (debug)
3438 		(void) printf("in_configinfo(%s) flags 0x%llx\n", name, flags);
3439 
3440 	/* only configinfo info for IPv4 interfaces */
3441 	if (!(flags & IFF_IPV4))
3442 		return;
3443 
3444 	if (!(flags & IFF_NOLOCAL)) {
3445 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3446 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
3447 			if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3448 			    errno == ENXIO) {
3449 				if (!force)
3450 					return;
3451 				(void) memset(&lifr.lifr_addr, 0,
3452 				    sizeof (lifr.lifr_addr));
3453 			} else
3454 				Perror0_exit("in_configinfo: SIOCGLIFADDR");
3455 		}
3456 		sin = (struct sockaddr_in *)&lifr.lifr_addr;
3457 		(void) printf(" set %s ", inet_ntoa(sin->sin_addr));
3458 		laddr = sin;
3459 	}
3460 
3461 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3462 	if (ioctl(s, SIOCGLIFSUBNET, (caddr_t)&lifr) < 0) {
3463 		if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3464 		    errno == ENXIO) {
3465 			if (!force)
3466 				return;
3467 			(void) memset(&lifr.lifr_addr, 0,
3468 			    sizeof (lifr.lifr_addr));
3469 		} else {
3470 			Perror0_exit("in_configinfo: SIOCGLIFSUBNET");
3471 		}
3472 	}
3473 	sin = (struct sockaddr_in *)&lifr.lifr_addr;
3474 
3475 	if ((flags & IFF_NOLOCAL) ||
3476 	    sin->sin_addr.s_addr != laddr->sin_addr.s_addr) {
3477 		(void) printf(" subnet %s/%d ", inet_ntoa(sin->sin_addr),
3478 		    lifr.lifr_addrlen);
3479 	}
3480 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3481 	if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifr) < 0) {
3482 		if (errno != EADDRNOTAVAIL)
3483 			Perror0_exit("in_configinfo: SIOCGLIFNETMASK");
3484 		(void) memset(&lifr.lifr_addr, 0, sizeof (lifr.lifr_addr));
3485 	} else
3486 		netmask.sin_addr =
3487 		    ((struct sockaddr_in *)&lifr.lifr_addr)->sin_addr;
3488 	if (flags & IFF_POINTOPOINT) {
3489 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3490 		if (ioctl(s, SIOCGLIFDSTADDR, (caddr_t)&lifr) < 0) {
3491 			if (errno == EADDRNOTAVAIL)
3492 				(void) memset(&lifr.lifr_addr, 0,
3493 				    sizeof (lifr.lifr_addr));
3494 			else
3495 				Perror0_exit("in_configinfo: SIOCGLIFDSTADDR");
3496 		}
3497 		sin = (struct sockaddr_in *)&lifr.lifr_dstaddr;
3498 		(void) printf(" destination %s ", inet_ntoa(sin->sin_addr));
3499 	}
3500 	(void) printf(" netmask 0x%x ", ntohl(netmask.sin_addr.s_addr));
3501 	if (flags & IFF_BROADCAST) {
3502 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3503 		if (ioctl(s, SIOCGLIFBRDADDR, (caddr_t)&lifr) < 0) {
3504 			if (errno == EADDRNOTAVAIL)
3505 				(void) memset(&lifr.lifr_addr, 0,
3506 				    sizeof (lifr.lifr_addr));
3507 			else
3508 				Perror0_exit("in_configinfo: SIOCGLIFBRDADDR");
3509 		}
3510 		sin = (struct sockaddr_in *)&lifr.lifr_addr;
3511 		if (sin->sin_addr.s_addr != 0) {
3512 			(void) printf(" broadcast %s ",
3513 			    inet_ntoa(sin->sin_addr));
3514 		}
3515 	}
3516 
3517 	/* If there is a groupname, print it for only the zeroth interface */
3518 	if (lifnum(name) == 0) {
3519 		if (ioctl(s, SIOCGLIFGROUPNAME, &lifr) >= 0 &&
3520 		    lifr.lifr_groupname[0] != '\0') {
3521 			(void) printf(" group %s ", lifr.lifr_groupname);
3522 		}
3523 	}
3524 
3525 	/* Print flags to configure */
3526 	print_config_flags(AF_INET, flags);
3527 }
3528 
3529 static void
3530 in6_configinfo(int force, uint64_t flags)
3531 {
3532 	char abuf[INET6_ADDRSTRLEN];
3533 	struct sockaddr_in6 *sin6, *laddr6;
3534 
3535 	if (debug)
3536 		(void) printf("in6_configinfo(%s) flags 0x%llx\n", name,
3537 		    flags);
3538 
3539 	if (!(flags & IFF_IPV6))
3540 		return;
3541 
3542 	if (!(flags & IFF_NOLOCAL)) {
3543 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3544 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
3545 			if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3546 			    errno == ENXIO) {
3547 				if (!force)
3548 					return;
3549 				(void) memset(&lifr.lifr_addr, 0,
3550 				    sizeof (lifr.lifr_addr));
3551 			} else
3552 				Perror0_exit("in6_configinfo: SIOCGLIFADDR");
3553 		}
3554 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3555 		(void) printf(" set %s/%d ",
3556 		    inet_ntop(AF_INET6, &sin6->sin6_addr, abuf, sizeof (abuf)),
3557 		    lifr.lifr_addrlen);
3558 		laddr6 = sin6;
3559 	}
3560 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3561 	if (ioctl(s, SIOCGLIFSUBNET, (caddr_t)&lifr) < 0) {
3562 		if (errno == EADDRNOTAVAIL || errno == EAFNOSUPPORT ||
3563 		    errno == ENXIO) {
3564 			if (!force)
3565 				return;
3566 			(void) memset(&lifr.lifr_addr, 0,
3567 			    sizeof (lifr.lifr_addr));
3568 		} else
3569 			Perror0_exit("in6_configinfo: SIOCGLIFSUBNET");
3570 	}
3571 	sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3572 	if ((flags & IFF_NOLOCAL) ||
3573 	    !IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, &laddr6->sin6_addr)) {
3574 		(void) printf(" subnet %s/%d ",
3575 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3576 		    abuf, sizeof (abuf)),
3577 		    lifr.lifr_addrlen);
3578 	}
3579 
3580 	if (flags & IFF_POINTOPOINT) {
3581 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3582 		if (ioctl(s, SIOCGLIFDSTADDR, (caddr_t)&lifr) < 0) {
3583 			if (errno == EADDRNOTAVAIL)
3584 				(void) memset(&lifr.lifr_addr, 0,
3585 				    sizeof (lifr.lifr_addr));
3586 			else
3587 				Perror0_exit("in6_configinfo: SIOCGLIFDSTADDR");
3588 		}
3589 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_dstaddr;
3590 		(void) printf(" destination %s ",
3591 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3592 		    abuf, sizeof (abuf)));
3593 	}
3594 
3595 	(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
3596 	if (ioctl(s, SIOCGLIFTOKEN, (caddr_t)&lifr) < 0) {
3597 		if (errno == EADDRNOTAVAIL || errno == EINVAL)
3598 			(void) memset(&lifr.lifr_addr, 0,
3599 			    sizeof (lifr.lifr_addr));
3600 		else
3601 			Perror0_exit("in6_configinfo: SIOCGLIFTOKEN");
3602 	} else {
3603 		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
3604 		(void) printf(" token %s/%d ",
3605 		    inet_ntop(AF_INET6, (void *)&sin6->sin6_addr,
3606 		    abuf, sizeof (abuf)),
3607 		    lifr.lifr_addrlen);
3608 	}
3609 
3610 	/* If there is a groupname, print it for only the zeroth interface */
3611 	if (lifnum(name) == 0) {
3612 		if (ioctl(s, SIOCGLIFGROUPNAME, &lifr) >= 0 &&
3613 		    lifr.lifr_groupname[0] != '\0') {
3614 			(void) printf(" group %s ", lifr.lifr_groupname);
3615 		}
3616 	}
3617 
3618 	/* Print flags to configure */
3619 	print_config_flags(AF_INET6, flags);
3620 }
3621 
3622 /*
3623  * If this is a physical interface then remove it.
3624  * If it is a logical interface name use SIOCLIFREMOVEIF to
3625  * remove it. In both cases fail if it doesn't exist.
3626  */
3627 /* ARGSUSED */
3628 static int
3629 inetunplumb(char *arg, int64_t param)
3630 {
3631 	ipadm_status_t	istatus;
3632 
3633 	istatus = ipadm_delete_if(iph, name, afp->af_af, IPADM_OPT_ACTIVE);
3634 	if (istatus != IPADM_SUCCESS) {
3635 		(void) fprintf(stderr, "ifconfig: cannot unplumb %s: %s\n",
3636 		    name, ipadm_status2str(istatus));
3637 		exit(1);
3638 	}
3639 
3640 	return (0);
3641 }
3642 
3643 /*
3644  * Create the interface in `name', using ipadm_create_if(). If `name' is a
3645  * logical interface or loopback interface, ipadm_create_if() uses
3646  * SIOCLIFADDIF to create it.
3647  */
3648 /* ARGSUSED */
3649 static int
3650 inetplumb(char *arg, int64_t param)
3651 {
3652 	ipadm_status_t	istatus;
3653 
3654 	istatus = ipadm_create_if(iph, name, afp->af_af, IPADM_OPT_ACTIVE);
3655 	if (istatus != IPADM_SUCCESS) {
3656 		(void) fprintf(stderr, "ifconfig: cannot plumb %s: %s\n",
3657 		    name, ipadm_status2str(istatus));
3658 		if (istatus != IPADM_IF_EXISTS)
3659 			exit(1);
3660 	}
3661 	return (0);
3662 }
3663 
3664 /* ARGSUSED */
3665 static int
3666 inetipmp(char *arg, int64_t param)
3667 {
3668 	int retval;
3669 
3670 	/*
3671 	 * Treat e.g. "ifconfig ipmp0:2 ipmp" as "ifconfig ipmp0:2 plumb".
3672 	 * Otherwise, try to create the requested IPMP interface.
3673 	 */
3674 	if (strchr(name, ':') != NULL)
3675 		retval = inetplumb(arg, param);
3676 	else
3677 		retval = create_ipmp(name, afp->af_af, name, _B_FALSE);
3678 
3679 	/*
3680 	 * We'd return -1, but foreachinterface() doesn't propagate the error
3681 	 * into the exit status, so we're forced to explicitly exit().
3682 	 */
3683 	if (retval == -1)
3684 		exit(1);
3685 	return (0);
3686 }
3687 
3688 /*
3689  * Create an IPMP group `grname' with address family `af'.  If `ifname' is
3690  * non-NULL, it specifies the interface name to use.  Otherwise, use the name
3691  * ipmpN, where N corresponds to the lowest available integer.  If `implicit'
3692  * is set, then the group is being created as a side-effect of placing an
3693  * underlying interface in a group.  Also start in.mpathd if necessary.
3694  */
3695 static int
3696 create_ipmp(const char *grname, int af, const char *ifname, boolean_t implicit)
3697 {
3698 	static int ipmp_daemon_started;
3699 	uint32_t flags = IPADM_OPT_IPMP|IPADM_OPT_ACTIVE;
3700 	ipadm_status_t istatus;
3701 
3702 	if (debug) {
3703 		(void) printf("create_ipmp: ifname %s grname %s af %d\n",
3704 		    ifname != NULL ? ifname : "NULL", grname, af);
3705 	}
3706 
3707 	/*
3708 	 * ipadm_create_if() creates the IPMP interface and fills in the
3709 	 * ppa in lifr.lifr_name, if `ifname'="ipmp".
3710 	 */
3711 	(void) strlcpy(lifr.lifr_name, (ifname ? ifname : "ipmp"),
3712 	    sizeof (lifr.lifr_name));
3713 	if (ifname == NULL)
3714 		flags |= IPADM_OPT_GENPPA;
3715 	istatus = ipadm_create_if(iph, lifr.lifr_name, af, flags);
3716 	if (istatus != IPADM_SUCCESS) {
3717 		(void) fprintf(stderr, "ifconfig: cannot create IPMP interface "
3718 		    "%s: %s\n", grname, ipadm_status2str(istatus));
3719 		return (-1);
3720 	}
3721 
3722 	/*
3723 	 * To preserve backward-compatibility, always bring up the link-local
3724 	 * address for implicitly-created IPv6 IPMP interfaces.
3725 	 */
3726 	if (implicit && af == AF_INET6) {
3727 		if (ioctl(s6, SIOCGLIFFLAGS, &lifr) == 0) {
3728 			lifr.lifr_flags |= IFF_UP;
3729 			(void) ioctl(s6, SIOCSLIFFLAGS, &lifr);
3730 		}
3731 	}
3732 
3733 	/*
3734 	 * If the caller requested a different group name, issue a
3735 	 * SIOCSLIFGROUPNAME on the new IPMP interface.
3736 	 */
3737 	if (strcmp(lifr.lifr_name, grname) != 0) {
3738 		(void) strlcpy(lifr.lifr_groupname, grname, LIFGRNAMSIZ);
3739 		if (ioctl(s, SIOCSLIFGROUPNAME, &lifr) == -1) {
3740 			Perror0("SIOCSLIFGROUPNAME");
3741 			return (-1);
3742 		}
3743 	}
3744 
3745 	/*
3746 	 * If we haven't done so yet, ensure in.mpathd is started.
3747 	 */
3748 	if (ipmp_daemon_started++ == 0)
3749 		start_ipmp_daemon();
3750 
3751 	return (0);
3752 }
3753 
3754 /*
3755  * Start in.mpathd if it's not already running.
3756  */
3757 static void
3758 start_ipmp_daemon(void)
3759 {
3760 	int retval;
3761 	ipmp_handle_t ipmp_handle;
3762 
3763 	/*
3764 	 * Ping in.mpathd to see if it's running already.
3765 	 */
3766 	if ((retval = ipmp_open(&ipmp_handle)) != IPMP_SUCCESS) {
3767 		(void) fprintf(stderr, "ifconfig: cannot create IPMP handle: "
3768 		    "%s\n", ipmp_errmsg(retval));
3769 		return;
3770 	}
3771 
3772 	retval = ipmp_ping_daemon(ipmp_handle);
3773 	ipmp_close(ipmp_handle);
3774 
3775 	switch (retval) {
3776 	case IPMP_ENOMPATHD:
3777 		break;
3778 	case IPMP_SUCCESS:
3779 		return;
3780 	default:
3781 		(void) fprintf(stderr, "ifconfig: cannot ping in.mpathd: %s\n",
3782 		    ipmp_errmsg(retval));
3783 		break;
3784 	}
3785 
3786 	/*
3787 	 * Start in.mpathd.  Note that in.mpathd will handle multiple
3788 	 * incarnations (ipmp_ping_daemon() is just an optimization) so we
3789 	 * don't need to worry about racing with another ifconfig process.
3790 	 */
3791 	switch (fork()) {
3792 	case -1:
3793 		Perror0_exit("start_ipmp_daemon: fork");
3794 		/* NOTREACHED */
3795 	case 0:
3796 		(void) execl(MPATHD_PATH, MPATHD_PATH, NULL);
3797 		_exit(1);
3798 		/* NOTREACHED */
3799 	default:
3800 		break;
3801 	}
3802 }
3803 
3804 /*
3805  * Bring the address named by `ifaddrp' up or down.  Doesn't trust any mutable
3806  * values in ia_flags since they may be stale.
3807  */
3808 static boolean_t
3809 ifaddr_op(ifaddrlistx_t *ifaddrp, boolean_t up)
3810 {
3811 	struct lifreq	lifrl;	/* Local lifreq struct */
3812 	int		fd = (ifaddrp->ia_flags & IFF_IPV4) ? s4 : s6;
3813 
3814 	(void) memset(&lifrl, 0, sizeof (lifrl));
3815 	(void) strlcpy(lifrl.lifr_name, ifaddrp->ia_name, LIFNAMSIZ);
3816 	if (ioctl(fd, SIOCGLIFFLAGS, &lifrl) == -1)
3817 		return (_B_FALSE);
3818 
3819 	if (up)
3820 		lifrl.lifr_flags |= IFF_UP;
3821 	else
3822 		lifrl.lifr_flags &= ~IFF_UP;
3823 
3824 	if (ioctl(fd, SIOCSLIFFLAGS, &lifrl) == -1)
3825 		return (_B_FALSE);
3826 
3827 	/*
3828 	 * If we're trying to bring the address down, ensure that DAD activity
3829 	 * (observable by IFF_DUPLICATE) has also been stopped.
3830 	 */
3831 	if (!up && ioctl(fd, SIOCGLIFFLAGS, &lifrl) != -1 &&
3832 	    lifrl.lifr_flags & IFF_DUPLICATE) {
3833 		if (ioctl(fd, SIOCGLIFADDR, &lifrl) == -1 ||
3834 		    ioctl(fd, SIOCSLIFADDR, &lifrl) == -1) {
3835 			return (_B_FALSE);
3836 		}
3837 	}
3838 	return (_B_TRUE);
3839 }
3840 
3841 static boolean_t
3842 ifaddr_up(ifaddrlistx_t *ifaddrp)
3843 {
3844 	return (ifaddr_op(ifaddrp, _B_TRUE));
3845 }
3846 
3847 static boolean_t
3848 ifaddr_down(ifaddrlistx_t *ifaddrp)
3849 {
3850 	return (ifaddr_op(ifaddrp, _B_FALSE));
3851 }
3852 
3853 /*
3854  * Open the global libdladm handle "dlh" if it isn't already opened.  The
3855  * caller may optionally supply a link name to obtain its linkid.  If a link
3856  * of a specific class or classes is required, reqclass specifies the class
3857  * mask.
3858  */
3859 static dladm_status_t
3860 ifconfig_dladm_open(const char *name, datalink_class_t reqclass,
3861     datalink_id_t *linkid)
3862 {
3863 	dladm_status_t status = DLADM_STATUS_OK;
3864 	datalink_class_t class;
3865 
3866 	if (!dlh_opened) {
3867 		if ((status = dladm_open(&dlh)) != DLADM_STATUS_OK)
3868 			return (status);
3869 		dlh_opened = _B_TRUE;
3870 	}
3871 	if (name != NULL) {
3872 		status = dladm_name2info(dlh, name, linkid, NULL, &class, NULL);
3873 		if (status == DLADM_STATUS_OK) {
3874 			if (!(class & reqclass))
3875 				status = DLADM_STATUS_LINKINVAL;
3876 		}
3877 	}
3878 	return (status);
3879 }
3880 
3881 /*
3882  * This function checks if we can use libipadm API's. We will only
3883  * call libipadm functions for non-IPMP interfaces. This check is
3884  * temporary until libipadm supports IPMP interfaces.
3885  */
3886 static boolean_t
3887 ifconfig_use_libipadm(int s, const char *lifname)
3888 {
3889 	struct lifreq lifr1;
3890 
3891 	(void) strlcpy(lifr1.lifr_name, lifname, sizeof (lifr1.lifr_name));
3892 	if (ioctl(s, SIOCGLIFGROUPNAME, (caddr_t)&lifr1) < 0) {
3893 		(void) strncpy(lifr.lifr_name, lifname,
3894 		    sizeof (lifr.lifr_name));
3895 		Perror0_exit("error");
3896 	}
3897 
3898 	return (lifr1.lifr_groupname[0] == '\0');
3899 }
3900 
3901 static void
3902 ipadmerr_exit(ipadm_status_t status, const char *str)
3903 {
3904 	(void) fprintf(stderr, "ifconfig: %s: %s\n", str,
3905 	    ipadm_status2str(status));
3906 	exit(1);
3907 }
3908 
3909 static void
3910 dladmerr_exit(dladm_status_t status, const char *str)
3911 {
3912 	char errstr[DLADM_STRSIZE];
3913 
3914 	(void) fprintf(stderr, "%s: %s\n", str,
3915 	    dladm_status2str(status, errstr));
3916 	exit(1);
3917 }
3918 
3919 void
3920 Perror0(const char *cmd)
3921 {
3922 	Perror2(cmd, lifr.lifr_name);
3923 }
3924 
3925 void
3926 Perror0_exit(const char *cmd)
3927 {
3928 	Perror0(cmd);
3929 	exit(1);
3930 }
3931 
3932 void
3933 Perror2(const char *cmd, const char *str)
3934 {
3935 	int error = errno;
3936 
3937 	(void) fprintf(stderr, "ifconfig: %s: ", cmd);
3938 
3939 	switch (error) {
3940 	case ENXIO:
3941 		(void) fprintf(stderr, "%s: no such interface\n", str);
3942 		break;
3943 	case EPERM:
3944 		(void) fprintf(stderr, "%s: permission denied\n", str);
3945 		break;
3946 	case EEXIST:
3947 		(void) fprintf(stderr, "%s: already exists\n", str);
3948 		break;
3949 	case ENAMETOOLONG:
3950 		(void) fprintf(stderr, "%s: interface name too long\n", str);
3951 		break;
3952 	case ERANGE:
3953 		(void) fprintf(stderr, "%s: logical interface id is outside "
3954 		    "allowed range\n", str);
3955 		break;
3956 	default:
3957 		errno = error;
3958 		perror(str);
3959 	}
3960 }
3961 
3962 /*
3963  * Print out error message (Perror2()) and exit
3964  */
3965 void
3966 Perror2_exit(const char *cmd, const char *str)
3967 {
3968 	Perror2(cmd, str);
3969 	exit(1);
3970 	/* NOTREACHED */
3971 }
3972 
3973 void
3974 Perrdlpi(const char *cmd, const char *linkname, int err)
3975 {
3976 	(void) fprintf(stderr, "ifconfig: %s \"%s\": %s\n", cmd,
3977 	    linkname, dlpi_strerror(err));
3978 }
3979 
3980 /*
3981  * Print out error message (Perrdlpi()) and exit
3982  */
3983 void
3984 Perrdlpi_exit(const char *cmd, const char *linkname, int err)
3985 {
3986 	Perrdlpi(cmd, linkname, err);
3987 	exit(1);
3988 }
3989 
3990 /*
3991  * If the last argument is non-NULL allow a <addr>/<n> syntax and
3992  * pass out <n> in *plenp.
3993  * If <n> doesn't parse return BAD_ADDR as *plenp.
3994  * If no /<n> is present return NO_PREFIX as *plenp.
3995  */
3996 static void
3997 in_getaddr(char *s, struct sockaddr *saddr, int *plenp)
3998 {
3999 	/* LINTED: alignment */
4000 	struct sockaddr_in *sin = (struct sockaddr_in *)saddr;
4001 	struct hostent *hp;
4002 	struct netent *np;
4003 	char str[BUFSIZ];
4004 	int error_num;
4005 
4006 	(void) strncpy(str, s, sizeof (str));
4007 
4008 	/*
4009 	 * Look for '/'<n> is plenp
4010 	 */
4011 	if (plenp != NULL) {
4012 		char *cp;
4013 
4014 		*plenp = in_getprefixlen(str, _B_TRUE, IP_ABITS);
4015 		if (*plenp == BAD_ADDR)
4016 			return;
4017 		cp = strchr(str, '/');
4018 		if (cp != NULL)
4019 			*cp = '\0';
4020 	} else if (strchr(str, '/') != NULL) {
4021 		(void) fprintf(stderr, "ifconfig: %s: unexpected '/'\n", str);
4022 		exit(1);
4023 	}
4024 
4025 	(void) memset(sin, 0, sizeof (*sin));
4026 
4027 	/*
4028 	 *	Try to catch attempts to set the broadcast address to all 1's.
4029 	 */
4030 	if (strcmp(str, "255.255.255.255") == 0 ||
4031 	    (strtoul(str, (char **)NULL, 0) == 0xffffffffUL)) {
4032 		sin->sin_family = AF_INET;
4033 		sin->sin_addr.s_addr = 0xffffffff;
4034 		return;
4035 	}
4036 
4037 	hp = getipnodebyname(str, AF_INET, 0, &error_num);
4038 	if (hp) {
4039 		sin->sin_family = hp->h_addrtype;
4040 		(void) memcpy(&sin->sin_addr, hp->h_addr, hp->h_length);
4041 		freehostent(hp);
4042 		return;
4043 	}
4044 	np = getnetbyname(str);
4045 	if (np) {
4046 		sin->sin_family = np->n_addrtype;
4047 		sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
4048 		return;
4049 	}
4050 	if (error_num == TRY_AGAIN) {
4051 		(void) fprintf(stderr, "ifconfig: %s: bad address "
4052 		    "(try again later)\n", s);
4053 	} else {
4054 		(void) fprintf(stderr, "ifconfig: %s: bad address\n", s);
4055 	}
4056 	exit(1);
4057 }
4058 
4059 /*
4060  * If the last argument is non-NULL allow a <addr>/<n> syntax and
4061  * pass out <n> in *plenp.
4062  * If <n> doesn't parse return BAD_ADDR as *plenp.
4063  * If no /<n> is present return NO_PREFIX as *plenp.
4064  */
4065 static void
4066 in6_getaddr(char *s, struct sockaddr *saddr, int *plenp)
4067 {
4068 	/* LINTED: alignment */
4069 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)saddr;
4070 	struct hostent *hp;
4071 	char str[BUFSIZ];
4072 	int error_num;
4073 
4074 	(void) strncpy(str, s, sizeof (str));
4075 
4076 	/*
4077 	 * Look for '/'<n> is plenp
4078 	 */
4079 	if (plenp != NULL) {
4080 		char *cp;
4081 
4082 		*plenp = in_getprefixlen(str, _B_TRUE, IPV6_ABITS);
4083 		if (*plenp == BAD_ADDR)
4084 			return;
4085 		cp = strchr(str, '/');
4086 		if (cp != NULL)
4087 			*cp = '\0';
4088 	} else if (strchr(str, '/') != NULL) {
4089 		(void) fprintf(stderr, "ifconfig: %s: unexpected '/'\n", str);
4090 		exit(1);
4091 	}
4092 
4093 	(void) memset(sin6, 0, sizeof (*sin6));
4094 
4095 	hp = getipnodebyname(str, AF_INET6, 0, &error_num);
4096 	if (hp) {
4097 		sin6->sin6_family = hp->h_addrtype;
4098 		(void) memcpy(&sin6->sin6_addr, hp->h_addr, hp->h_length);
4099 		freehostent(hp);
4100 		return;
4101 	}
4102 	if (error_num == TRY_AGAIN) {
4103 		(void) fprintf(stderr, "ifconfig: %s: bad address "
4104 		    "(try again later)\n", s);
4105 	} else {
4106 		(void) fprintf(stderr, "ifconfig: %s: bad address\n", s);
4107 	}
4108 	exit(1);
4109 }
4110 
4111 /*
4112  * If "slash" is zero this parses the whole string as
4113  * an integer. With "slash" non zero it parses the tail part as an integer.
4114  *
4115  * If it is not a valid integer this returns BAD_ADDR.
4116  * If there is /<n> present this returns NO_PREFIX.
4117  */
4118 static int
4119 in_getprefixlen(char *addr, boolean_t slash, int max_plen)
4120 {
4121 	int prefixlen;
4122 	char *str, *end;
4123 
4124 	if (slash) {
4125 		str = strchr(addr, '/');
4126 		if (str == NULL)
4127 			return (NO_PREFIX);
4128 		str++;
4129 	} else
4130 		str = addr;
4131 
4132 	prefixlen = strtol(str, &end, 10);
4133 	if (prefixlen < 0)
4134 		return (BAD_ADDR);
4135 	if (str == end)
4136 		return (BAD_ADDR);
4137 	if (max_plen != 0 && max_plen < prefixlen)
4138 		return (BAD_ADDR);
4139 	return (prefixlen);
4140 }
4141 
4142 /*
4143  * Convert a prefix length to a mask.
4144  * Returns 1 if ok. 0 otherwise.
4145  * Assumes the mask array is zero'ed by the caller.
4146  */
4147 static boolean_t
4148 in_prefixlentomask(int prefixlen, int maxlen, uchar_t *mask)
4149 {
4150 	if (prefixlen < 0 || prefixlen > maxlen)
4151 		return (0);
4152 
4153 	while (prefixlen > 0) {
4154 		if (prefixlen >= 8) {
4155 			*mask++ = 0xFF;
4156 			prefixlen -= 8;
4157 			continue;
4158 		}
4159 		*mask |= 1 << (8 - prefixlen);
4160 		prefixlen--;
4161 	}
4162 	return (1);
4163 }
4164 
4165 static void
4166 print_flags(uint64_t flags)
4167 {
4168 	boolean_t first = _B_TRUE;
4169 	int cnt, i;
4170 
4171 	(void) printf("flags=%llx", flags);
4172 	cnt = sizeof (if_flags_tbl) / sizeof (if_flags_t);
4173 	for (i = 0; i < cnt; i++) {
4174 		if (flags & if_flags_tbl[i].iff_value) {
4175 			if (first) {
4176 				(void) printf("<");
4177 				first = _B_FALSE;
4178 			} else {
4179 				/*
4180 				 * It has to be here and not with the
4181 				 * printf below because for the last one,
4182 				 * we don't want a comma before the ">".
4183 				 */
4184 				(void) printf(",");
4185 			}
4186 			(void) printf("%s", if_flags_tbl[i].iff_name);
4187 		}
4188 	}
4189 	if (!first)
4190 		(void) printf(">");
4191 }
4192 
4193 static void
4194 print_config_flags(int af, uint64_t flags)
4195 {
4196 	if_config_cmd_t *cmdp;
4197 
4198 	for (cmdp = if_config_cmd_tbl; cmdp->iff_flag != 0; cmdp++) {
4199 		if ((flags & cmdp->iff_flag) &&
4200 		    (cmdp->iff_af == AF_UNSPEC || cmdp->iff_af == af)) {
4201 			(void) printf("%s ", cmdp->iff_name);
4202 		}
4203 	}
4204 }
4205 
4206 /*
4207  * Use the configured directory lookup mechanism (e.g. files/NIS/...)
4208  * to find the network mask.  Returns true if we found one to set.
4209  *
4210  * The parameter addr_set controls whether we should get the address of
4211  * the working interface for the netmask query.  If addr_set is true,
4212  * we will use the address provided.  Otherwise, we will find the working
4213  * interface's address and use it instead.
4214  */
4215 static boolean_t
4216 in_getmask(struct sockaddr_in *saddr, boolean_t addr_set)
4217 {
4218 	struct sockaddr_in ifaddr;
4219 
4220 	/*
4221 	 * Read the address from the interface if it is not passed in.
4222 	 */
4223 	if (!addr_set) {
4224 		(void) strncpy(lifr.lifr_name, name, sizeof (lifr.lifr_name));
4225 		if (ioctl(s, SIOCGLIFADDR, (caddr_t)&lifr) < 0) {
4226 			if (errno != EADDRNOTAVAIL) {
4227 				(void) fprintf(stderr, "Need net number for "
4228 				    "mask\n");
4229 			}
4230 			return (_B_FALSE);
4231 		}
4232 		ifaddr = *((struct sockaddr_in *)&lifr.lifr_addr);
4233 	} else {
4234 		ifaddr.sin_addr = saddr->sin_addr;
4235 	}
4236 	if (getnetmaskbyaddr(ifaddr.sin_addr, &saddr->sin_addr) == 0) {
4237 		saddr->sin_family = AF_INET;
4238 		return (_B_TRUE);
4239 	}
4240 	return (_B_FALSE);
4241 }
4242 
4243 static int
4244 lifnum(const char *ifname)
4245 {
4246 	const char *cp;
4247 
4248 	if ((cp = strchr(ifname, ':')) == NULL)
4249 		return (0);
4250 	else
4251 		return (atoi(cp + 1));
4252 }
4253 
4254 static void
4255 add_ni(const char *name)
4256 {
4257 	ni_t **pp;
4258 	ni_t *p;
4259 
4260 	for (pp = &ni_list; (p = *pp) != NULL; pp = &(p->ni_next)) {
4261 		if (strcmp(p->ni_name, name) == 0) {
4262 			if (debug > 2)
4263 				(void) fprintf(stderr, "'%s' is a duplicate\n",
4264 				    name);
4265 			return;
4266 		}
4267 	}
4268 
4269 	if (debug > 2)
4270 		(void) fprintf(stderr, "adding '%s'\n",
4271 		    name);
4272 
4273 	if ((p = malloc(sizeof (ni_t))) == NULL)
4274 		return;
4275 
4276 	(void) strlcpy(p->ni_name, name, sizeof (p->ni_name));
4277 	p->ni_next = NULL;
4278 
4279 	*pp = p;
4280 	num_ni++;
4281 }
4282 
4283 static boolean_t
4284 ni_entry(const char *linkname, void *arg)
4285 {
4286 	dlpi_handle_t	dh;
4287 	datalink_class_t class;
4288 
4289 	(void) dladm_name2info(arg, linkname, NULL, NULL, &class, NULL);
4290 
4291 	if (class == DATALINK_CLASS_ETHERSTUB)
4292 		return (_B_FALSE);
4293 	if (dlpi_open(linkname, &dh, 0) != DLPI_SUCCESS)
4294 		return (_B_FALSE);
4295 
4296 	add_ni(linkname);
4297 
4298 	dlpi_close(dh);
4299 	return (_B_FALSE);
4300 }
4301 
4302 /*
4303  * dhcp-related routines
4304  */
4305 
4306 static int
4307 setifdhcp(const char *caller, const char *ifname, int argc, char *argv[])
4308 {
4309 	dhcp_ipc_request_t	*request;
4310 	dhcp_ipc_reply_t	*reply	= NULL;
4311 	int			timeout = DHCP_IPC_WAIT_DEFAULT;
4312 	dhcp_ipc_type_t		type	= DHCP_START;
4313 	int			error;
4314 	boolean_t		is_primary = _B_FALSE;
4315 	boolean_t		started = _B_FALSE;
4316 
4317 	for (argv++; --argc > 0; argv++) {
4318 
4319 		if (strcmp(*argv, "primary") == 0) {
4320 			is_primary = _B_TRUE;
4321 			continue;
4322 		}
4323 
4324 		if (strcmp(*argv, "wait") == 0) {
4325 			if (--argc <= 0) {
4326 				usage();
4327 				return (DHCP_EXIT_BADARGS);
4328 			}
4329 			argv++;
4330 
4331 			if (strcmp(*argv, "forever") == 0) {
4332 				timeout = DHCP_IPC_WAIT_FOREVER;
4333 				continue;
4334 			}
4335 
4336 			if (sscanf(*argv, "%d", &timeout) != 1) {
4337 				usage();
4338 				return (DHCP_EXIT_BADARGS);
4339 			}
4340 
4341 			if (timeout < 0) {
4342 				usage();
4343 				return (DHCP_EXIT_BADARGS);
4344 			}
4345 			continue;
4346 		}
4347 
4348 		type = dhcp_string_to_request(*argv);
4349 		if (type == -1) {
4350 			usage();
4351 			return (DHCP_EXIT_BADARGS);
4352 		}
4353 	}
4354 
4355 	/*
4356 	 * Only try to start agent on start or inform; in all other cases it
4357 	 * has to already be running for anything to make sense.
4358 	 */
4359 	if (type == DHCP_START || type == DHCP_INFORM) {
4360 		if (dhcp_start_agent(DHCP_IPC_MAX_WAIT) == -1) {
4361 			(void) fprintf(stderr, "%s: unable to start %s\n",
4362 			    caller, DHCP_AGENT_PATH);
4363 			return (DHCP_EXIT_FAILURE);
4364 		}
4365 		started = _B_TRUE;
4366 	}
4367 
4368 	if (is_primary)
4369 		type |= DHCP_PRIMARY;
4370 
4371 	if (af != AF_INET)
4372 		type |= DHCP_V6;
4373 
4374 	request = dhcp_ipc_alloc_request(type, ifname, NULL, 0, DHCP_TYPE_NONE);
4375 	if (request == NULL) {
4376 		(void) fprintf(stderr, "%s: out of memory\n", caller);
4377 		return (DHCP_EXIT_SYSTEM);
4378 	}
4379 
4380 	error = dhcp_ipc_make_request(request, &reply, timeout);
4381 	if (error != 0) {
4382 		free(request);
4383 		/*
4384 		 * Re-map connect error to not under control if we didn't try a
4385 		 * start operation, as this has to be true and results in a
4386 		 * clearer message, not to mention preserving compatibility
4387 		 * with the days when we always started dhcpagent for every
4388 		 * request.
4389 		 */
4390 		if (error == DHCP_IPC_E_CONNECT && !started)
4391 			error = DHCP_IPC_E_UNKIF;
4392 		(void) fprintf(stderr, "%s: %s: %s\n", caller, ifname,
4393 		    dhcp_ipc_strerror(error));
4394 		return (DHCP_EXIT_FAILURE);
4395 	}
4396 
4397 	error = reply->return_code;
4398 	if (error != 0) {
4399 		free(request);
4400 		free(reply);
4401 
4402 		if (error == DHCP_IPC_E_TIMEOUT && timeout == 0)
4403 			return (DHCP_EXIT_SUCCESS);
4404 
4405 		(void) fprintf(stderr, "%s: %s: %s\n", caller, ifname,
4406 		    dhcp_ipc_strerror(error));
4407 
4408 		if (error == DHCP_IPC_E_TIMEOUT)
4409 			return (DHCP_EXIT_TIMEOUT);
4410 		else
4411 			return (DHCP_EXIT_IF_FAILURE);
4412 	}
4413 
4414 	if (DHCP_IPC_CMD(type) == DHCP_STATUS) {
4415 		(void) printf("%s", dhcp_status_hdr_string());
4416 		(void) printf("%s", dhcp_status_reply_to_string(reply));
4417 	}
4418 
4419 	free(request);
4420 	free(reply);
4421 	return (DHCP_EXIT_SUCCESS);
4422 }
4423 
4424 static void
4425 usage(void)
4426 {
4427 	(void) fprintf(stderr,
4428 	    "usage: ifconfig <interface> | -a[ 4 | 6 | D ][ u | d ][ Z ]\n");
4429 
4430 	(void) fprintf(stderr, "%s",
4431 	    "\t[ <addr_family> ]\n"
4432 	    "\t[ <address>[/<prefix_length>] [ <dest_address> ] ]\n"
4433 	    "\t[ set [ <address>][/<prefix_length>] ]"
4434 	    " [ <address>/<prefix_length>] ]\n"
4435 	    "\t[ destination <dest_address> ]\n"
4436 	    "\t[ addif <address>[/<prefix_length>]"
4437 	    "  [ <dest_address> ] ]\n"
4438 	    "\t[ removeif <address>[/<prefix_length>] ]\n"
4439 	    "\t[ arp | -arp ]\n"
4440 	    "\t[ auto-revarp ]\n"
4441 	    "\t[ broadcast <broad_addr> ]\n"
4442 	    "\t[ index <if_index> ]\n"
4443 	    "\t[ metric <n> ] [ mtu <n> ]\n"
4444 	    "\t[ netmask <mask> ]\n"
4445 	    "\t[ plumb ] [ unplumb ]\n"
4446 	    "\t[ preferred | -preferred ]\n"
4447 	    "\t[ private | -private ]\n"
4448 	    "\t[ local | -local ]\n"
4449 	    "\t[ router | -router ]\n"
4450 	    "\t[ subnet <subnet_address>]\n"
4451 	    "\t[ trailers | -trailers ]\n"
4452 	    "\t[ token <address>/<prefix_length> ]\n"
4453 	    "\t[ tsrc <tunnel_src_address> ]\n"
4454 	    "\t[ tdst <tunnel_dest_address> ]\n"
4455 	    "\t[ auth_algs <tunnel_AH_authentication_algorithm> ]\n"
4456 	    "\t[ encr_algs <tunnel_ESP_encryption_algorithm> ]\n"
4457 	    "\t[ encr_auth_algs <tunnel_ESP_authentication_algorithm> ]\n"
4458 	    "\t[ up ] [ down ]\n"
4459 	    "\t[ xmit | -xmit ]\n"
4460 	    "\t[ modlist ]\n"
4461 	    "\t[ modinsert <module_name@position> ]\n"
4462 	    "\t[ modremove <module_name@position> ]\n"
4463 	    "\t[ ipmp ]\n"
4464 	    "\t[ group <groupname>] | [ group \"\"]\n"
4465 	    "\t[ deprecated | -deprecated ]\n"
4466 	    "\t[ standby | -standby ]\n"
4467 	    "\t[ failover | -failover ]\n"
4468 	    "\t[ zone <zonename> | -zone ]\n"
4469 	    "\t[ usesrc <interface> ]\n"
4470 	    "\t[ all-zones ]\n");
4471 
4472 	(void) fprintf(stderr, "or\n");
4473 	(void) fprintf(stderr,
4474 	    "\tifconfig <interface> |  -a[ 4 | 6 | D ] [ u | d ]\n");
4475 
4476 	(void) fprintf(stderr, "%s", "\tauto-dhcp | dhcp\n"
4477 	    "\t[ wait <time> | forever ]\n\t[ primary ]\n"
4478 	    "\tstart | drop | ping | release | status | inform\n");
4479 }
4480