1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2016 Nexenta Systems, Inc.
25 * Copyright (c) 2015 Joyent, Inc. All rights reserved.
26 * Copyright 2020 Peter Tribble.
27 * Copyright 2021 OmniOS Community Edition (OmniOSce) Association.
28 * Copyright 2021 RackTop Systems, Inc.
29 */
30
31 #include <stdio.h>
32 #include <ctype.h>
33 #include <dlfcn.h>
34 #include <locale.h>
35 #include <signal.h>
36 #include <stdarg.h>
37 #include <stdlib.h>
38 #include <fcntl.h>
39 #include <string.h>
40 #include <stropts.h>
41 #include <sys/stat.h>
42 #include <errno.h>
43 #include <kstat.h>
44 #include <strings.h>
45 #include <getopt.h>
46 #include <unistd.h>
47 #include <priv.h>
48 #include <limits.h>
49 #include <termios.h>
50 #include <pwd.h>
51 #include <auth_attr.h>
52 #include <auth_list.h>
53 #include <libintl.h>
54 #include <libdevinfo.h>
55 #include <libdlpi.h>
56 #include <libdladm.h>
57 #include <libdllink.h>
58 #include <libdlstat.h>
59 #include <libdlaggr.h>
60 #include <libdlwlan.h>
61 #include <libdlvlan.h>
62 #include <libdlvnic.h>
63 #include <libdlib.h>
64 #include <libdlether.h>
65 #include <libdliptun.h>
66 #include <libdlsim.h>
67 #include <libdlbridge.h>
68 #include <libdloverlay.h>
69 #include <libinetutil.h>
70 #include <libvrrpadm.h>
71 #include <bsm/adt.h>
72 #include <bsm/adt_event.h>
73 #include <libdlvnic.h>
74 #include <sys/types.h>
75 #include <sys/socket.h>
76 #include <sys/ib/ib_types.h>
77 #include <sys/processor.h>
78 #include <netinet/in.h>
79 #include <arpa/inet.h>
80 #include <net/if_types.h>
81 #include <stddef.h>
82 #include <stp_in.h>
83 #include <ofmt.h>
84 #include <libcustr.h>
85
86 #define MAXPORT 256
87 #define MAXVNIC 256
88 #define BUFLEN(lim, ptr) (((lim) > (ptr)) ? ((lim) - (ptr)) : 0)
89 #define MAXLINELEN 1024
90 #define SMF_UPGRADE_FILE "/var/svc/profile/upgrade"
91 #define SMF_UPGRADEDATALINK_FILE "/var/svc/profile/upgrade_datalink"
92 #define SMF_DLADM_UPGRADE_MSG " # added by dladm(8)"
93 #define DLADM_DEFAULT_COL 80
94
95 /*
96 * used by the wifi show-* commands to set up ofmt_field_t structures.
97 */
98 #define WIFI_CMD_SCAN 0x00000001
99 #define WIFI_CMD_SHOW 0x00000002
100 #define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)
101
102 /* No larger than pktsum_t */
103 typedef struct brsum_s {
104 uint64_t drops;
105 uint64_t forward_dir;
106 uint64_t forward_mb;
107 uint64_t forward_unk;
108 uint64_t recv;
109 uint64_t sent;
110 } brsum_t;
111
112 /* No larger than pktsum_t */
113 typedef struct brlsum_s {
114 uint32_t cfgbpdu;
115 uint32_t tcnbpdu;
116 uint32_t rstpbpdu;
117 uint32_t txbpdu;
118 uint64_t drops;
119 uint64_t recv;
120 uint64_t xmit;
121 } brlsum_t;
122
123 typedef struct show_state {
124 boolean_t ls_firstonly;
125 boolean_t ls_donefirst;
126 pktsum_t ls_prevstats;
127 uint32_t ls_flags;
128 dladm_status_t ls_status;
129 ofmt_handle_t ls_ofmt;
130 boolean_t ls_parsable;
131 boolean_t ls_mac;
132 boolean_t ls_hwgrp;
133 } show_state_t;
134
135 typedef struct show_grp_state {
136 pktsum_t gs_prevstats[MAXPORT];
137 uint32_t gs_flags;
138 dladm_status_t gs_status;
139 boolean_t gs_parsable;
140 boolean_t gs_lacp;
141 boolean_t gs_extended;
142 boolean_t gs_stats;
143 boolean_t gs_firstonly;
144 boolean_t gs_donefirst;
145 ofmt_handle_t gs_ofmt;
146 } show_grp_state_t;
147
148 typedef struct show_vnic_state {
149 datalink_id_t vs_vnic_id;
150 datalink_id_t vs_link_id;
151 char vs_vnic[MAXLINKNAMELEN];
152 char vs_link[MAXLINKNAMELEN];
153 boolean_t vs_parsable;
154 boolean_t vs_found;
155 boolean_t vs_firstonly;
156 boolean_t vs_donefirst;
157 boolean_t vs_stats;
158 boolean_t vs_printstats;
159 pktsum_t vs_totalstats;
160 pktsum_t vs_prevstats[MAXVNIC];
161 boolean_t vs_etherstub;
162 dladm_status_t vs_status;
163 uint32_t vs_flags;
164 ofmt_handle_t vs_ofmt;
165 } show_vnic_state_t;
166
167 typedef struct show_part_state {
168 datalink_id_t ps_over_id;
169 char ps_part[MAXLINKNAMELEN];
170 boolean_t ps_parsable;
171 boolean_t ps_found;
172 dladm_status_t ps_status;
173 uint32_t ps_flags;
174 ofmt_handle_t ps_ofmt;
175 } show_part_state_t;
176
177 typedef struct show_ib_state {
178 datalink_id_t is_link_id;
179 char is_link[MAXLINKNAMELEN];
180 boolean_t is_parsable;
181 dladm_status_t is_status;
182 uint32_t is_flags;
183 ofmt_handle_t is_ofmt;
184 } show_ib_state_t;
185
186 typedef struct show_usage_state_s {
187 boolean_t us_plot;
188 boolean_t us_parsable;
189 boolean_t us_printheader;
190 boolean_t us_first;
191 boolean_t us_showall;
192 ofmt_handle_t us_ofmt;
193 } show_usage_state_t;
194
195 typedef struct show_overlay_request_s {
196 boolean_t sor_failed;
197 ofmt_handle_t sor_ofmt;
198 } show_overlay_request_t;
199
200 /*
201 * callback functions for printing output and error diagnostics.
202 */
203 static ofmt_cb_t print_default_cb, print_link_stats_cb, print_linkprop_cb;
204 static ofmt_cb_t print_lacp_cb, print_phys_one_mac_cb;
205 static ofmt_cb_t print_xaggr_cb, print_aggr_stats_cb;
206 static ofmt_cb_t print_phys_one_hwgrp_cb, print_wlan_attr_cb;
207 static ofmt_cb_t print_wifi_status_cb, print_link_attr_cb;
208 static ofmt_cb_t print_overlay_cb, print_overlay_fma_cb, print_overlay_targ_cb;
209
210 typedef void cmdfunc_t(int, char **, const char *);
211
212 static cmdfunc_t do_help;
213 static cmdfunc_t do_show_link, do_show_wifi, do_show_phys;
214 static cmdfunc_t do_create_aggr, do_delete_aggr, do_add_aggr, do_remove_aggr;
215 static cmdfunc_t do_modify_aggr, do_show_aggr, do_up_aggr;
216 static cmdfunc_t do_scan_wifi, do_connect_wifi, do_disconnect_wifi;
217 static cmdfunc_t do_show_linkprop, do_set_linkprop, do_reset_linkprop;
218 static cmdfunc_t do_create_secobj, do_delete_secobj, do_show_secobj;
219 static cmdfunc_t do_init_linkprop, do_init_secobj;
220 static cmdfunc_t do_create_vlan, do_delete_vlan, do_up_vlan, do_show_vlan;
221 static cmdfunc_t do_rename_link, do_delete_phys, do_init_phys;
222 static cmdfunc_t do_show_linkmap;
223 static cmdfunc_t do_show_ether;
224 static cmdfunc_t do_create_vnic, do_delete_vnic, do_show_vnic;
225 static cmdfunc_t do_up_vnic;
226 static cmdfunc_t do_create_part, do_delete_part, do_show_part, do_show_ib;
227 static cmdfunc_t do_up_part;
228 static cmdfunc_t do_create_etherstub, do_delete_etherstub, do_show_etherstub;
229 static cmdfunc_t do_create_simnet, do_modify_simnet;
230 static cmdfunc_t do_delete_simnet, do_show_simnet, do_up_simnet;
231 static cmdfunc_t do_show_usage;
232 static cmdfunc_t do_create_bridge, do_modify_bridge, do_delete_bridge;
233 static cmdfunc_t do_add_bridge, do_remove_bridge, do_show_bridge;
234 static cmdfunc_t do_create_iptun, do_modify_iptun, do_delete_iptun;
235 static cmdfunc_t do_show_iptun, do_up_iptun, do_down_iptun;
236 static cmdfunc_t do_create_overlay, do_delete_overlay, do_modify_overlay;
237 static cmdfunc_t do_show_overlay, do_up_overlay;
238
239 static void do_up_vnic_common(int, char **, const char *, boolean_t);
240
241 static int show_part(dladm_handle_t, datalink_id_t, void *);
242
243 static void altroot_cmd(char *, int, char **);
244 static int show_linkprop_onelink(dladm_handle_t, datalink_id_t, void *);
245
246 static void link_stats(datalink_id_t, uint_t, char *, show_state_t *);
247 static void aggr_stats(datalink_id_t, show_grp_state_t *, uint_t);
248 static void vnic_stats(show_vnic_state_t *, uint32_t);
249
250 static int get_one_kstat(const char *, const char *, uint8_t,
251 void *, boolean_t);
252 static void get_mac_stats(const char *, pktsum_t *);
253 static void get_link_stats(const char *, pktsum_t *);
254 static uint64_t get_ifspeed(const char *, boolean_t);
255 static const char *get_linkstate(const char *, boolean_t, char *);
256 static const char *get_linkduplex(const char *, boolean_t, char *);
257
258 static iptun_type_t iptun_gettypebyname(char *);
259 static const char *iptun_gettypebyvalue(iptun_type_t);
260 static dladm_status_t print_iptun(dladm_handle_t, datalink_id_t,
261 show_state_t *);
262 static int print_iptun_walker(dladm_handle_t, datalink_id_t, void *);
263
264 static int show_etherprop(dladm_handle_t, datalink_id_t, void *);
265 static void show_ether_xprop(void *, dladm_ether_info_t *);
266 static boolean_t link_is_ether(const char *, datalink_id_t *);
267
268 static boolean_t str2int(const char *, int *);
269 static void die(const char *, ...);
270 static void die_optdup(int);
271 static void die_opterr(int, int, const char *);
272 static void die_dlerr(dladm_status_t, const char *, ...);
273 static void die_dlerrlist(dladm_status_t, dladm_errlist_t *,
274 const char *, ...);
275 static void warn(const char *, ...);
276 static void warn_dlerr(dladm_status_t, const char *, ...);
277 static void warn_dlerrlist(dladm_errlist_t *);
278
279 typedef struct cmd {
280 char *c_name;
281 cmdfunc_t *c_fn;
282 const char *c_usage;
283 } cmd_t;
284
285 static cmd_t cmds[] = {
286 { "help", do_help, NULL },
287 { "rename-link", do_rename_link,
288 " rename-link <oldlink> <newlink>" },
289 { "show-link", do_show_link,
290 " show-link [-pP] [-o <field>,..] [-s [-i <interval>]] "
291 "[<link>]\n" },
292 { "create-aggr", do_create_aggr,
293 " create-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "
294 "[-u <address>]\n"
295 "\t\t -l <link> [-l <link>...] <link>" },
296 { "delete-aggr", do_delete_aggr,
297 " delete-aggr [-t] <link>" },
298 { "add-aggr", do_add_aggr,
299 " add-aggr [-t] -l <link> [-l <link>...] <link>" },
300 { "remove-aggr", do_remove_aggr,
301 " remove-aggr [-t] -l <link> [-l <link>...] <link>" },
302 { "modify-aggr", do_modify_aggr,
303 " modify-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "
304 "[-u <address>]\n"
305 "\t\t <link>" },
306 { "show-aggr", do_show_aggr,
307 " show-aggr [-pPLx] [-o <field>,..] [-s [-i <interval>]] "
308 "[<link>]\n" },
309 { "up-aggr", do_up_aggr, NULL },
310 { "scan-wifi", do_scan_wifi,
311 " scan-wifi [-p] [-o <field>,...] [<link>]" },
312 { "connect-wifi", do_connect_wifi,
313 " connect-wifi [-e <essid>] [-i <bssid>] [-k <key>,...] "
314 "[-s wep|wpa]\n"
315 "\t\t [-a open|shared] [-b bss|ibss] [-c] [-m a|b|g] "
316 "[-T <time>]\n"
317 "\t\t [<link>]" },
318 { "disconnect-wifi", do_disconnect_wifi,
319 " disconnect-wifi [-a] [<link>]" },
320 { "show-wifi", do_show_wifi,
321 " show-wifi [-p] [-o <field>,...] [<link>]\n" },
322 { "set-linkprop", do_set_linkprop,
323 " set-linkprop [-t] -p <prop>=<value>[,...] <name>" },
324 { "reset-linkprop", do_reset_linkprop,
325 " reset-linkprop [-t] [-p <prop>,...] <name>" },
326 { "show-linkprop", do_show_linkprop,
327 " show-linkprop [-cP] [-o <field>,...] [-p <prop>,...] "
328 "<name>\n" },
329 { "show-ether", do_show_ether,
330 " show-ether [-px][-o <field>,...] <link>\n" },
331 { "create-secobj", do_create_secobj,
332 " create-secobj [-t] [-f <file>] -c <class> <secobj>" },
333 { "delete-secobj", do_delete_secobj,
334 " delete-secobj [-t] <secobj>[,...]" },
335 { "show-secobj", do_show_secobj,
336 " show-secobj [-pP] [-o <field>,...] [<secobj>,...]\n" },
337 { "init-linkprop", do_init_linkprop, NULL },
338 { "init-secobj", do_init_secobj, NULL },
339 { "create-vlan", do_create_vlan,
340 " create-vlan [-ft] -l <link> -v <vid> [link]" },
341 { "delete-vlan", do_delete_vlan,
342 " delete-vlan [-t] <link>" },
343 { "show-vlan", do_show_vlan,
344 " show-vlan [-pP] [-o <field>,..] [<link>]\n" },
345 { "up-vlan", do_up_vlan, NULL },
346 { "create-iptun", do_create_iptun,
347 " create-iptun [-t] -T <type> "
348 "[-a {local|remote}=<addr>,...] <link>]" },
349 { "delete-iptun", do_delete_iptun,
350 " delete-iptun [-t] <link>" },
351 { "modify-iptun", do_modify_iptun,
352 " modify-iptun [-t] -a {local|remote}=<addr>,... <link>" },
353 { "show-iptun", do_show_iptun,
354 " show-iptun [-pP] [-o <field>,..] [<link>]\n" },
355 { "up-iptun", do_up_iptun, NULL },
356 { "down-iptun", do_down_iptun, NULL },
357 { "delete-phys", do_delete_phys,
358 " delete-phys <link>" },
359 { "show-phys", do_show_phys,
360 " show-phys [-m | -H | -P] [[-p] [-o <field>[,...]] "
361 "[<link>]\n" },
362 { "init-phys", do_init_phys, NULL },
363 { "show-linkmap", do_show_linkmap, NULL },
364 { "create-vnic", do_create_vnic,
365 " create-vnic [-t] -l <link> [-m <value> | auto |\n"
366 "\t\t {factory [-n <slot-id>]} | {random [-r <prefix>]} |\n"
367 "\t\t {vrrp -V <vrid> -A {inet | inet6}} [-v <vid> [-f]]\n"
368 "\t\t [-p <prop>=<value>[,...]] <vnic-link>" },
369 { "delete-vnic", do_delete_vnic,
370 " delete-vnic [-t] <vnic-link>" },
371 { "show-vnic", do_show_vnic,
372 " show-vnic [-pP] [-l <link>] [-s [-i <interval>]] "
373 "[<link>]\n" },
374 { "up-vnic", do_up_vnic, NULL },
375 { "create-part", do_create_part,
376 " create-part [-t] [-f] -l <link> [-P <pkey>]\n"
377 "\t\t [-R <root-dir>] <part-link>" },
378 { "delete-part", do_delete_part,
379 " delete-part [-t] [-R <root-dir>] <part-link>"},
380 { "show-part", do_show_part,
381 " show-part [-pP] [-o <field>,...][-l <linkover>]\n"
382 "\t\t [<part-link>]" },
383 { "show-ib", do_show_ib,
384 " show-ib [-p] [-o <field>,...] [<link>]\n" },
385 { "up-part", do_up_part, NULL },
386 { "create-etherstub", do_create_etherstub,
387 " create-etherstub [-t] <link>" },
388 { "delete-etherstub", do_delete_etherstub,
389 " delete-etherstub [-t] <link>" },
390 { "show-etherstub", do_show_etherstub,
391 " show-etherstub [-t] [<link>]\n" },
392 { "create-simnet", do_create_simnet, NULL },
393 { "modify-simnet", do_modify_simnet, NULL },
394 { "delete-simnet", do_delete_simnet, NULL },
395 { "show-simnet", do_show_simnet, NULL },
396 { "up-simnet", do_up_simnet, NULL },
397 { "create-bridge", do_create_bridge,
398 " create-bridge [-R <root-dir>] [-P <protect>] "
399 "[-p <priority>]\n"
400 "\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"
401 "\t\t [-f <force-protocol>] [-l <link>]... <bridge>" },
402 { "modify-bridge", do_modify_bridge,
403 " modify-bridge [-R <root-dir>] [-P <protect>] "
404 "[-p <priority>]\n"
405 "\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"
406 "\t\t [-f <force-protocol>] <bridge>" },
407 { "delete-bridge", do_delete_bridge,
408 " delete-bridge [-R <root-dir>] <bridge>" },
409 { "add-bridge", do_add_bridge,
410 " add-bridge [-R <root-dir>] -l <link> [-l <link>]... "
411 "<bridge>" },
412 { "remove-bridge", do_remove_bridge,
413 " remove-bridge [-R <root-dir>] -l <link> [-l <link>]... "
414 "<bridge>" },
415 { "show-bridge", do_show_bridge,
416 " show-bridge [-p] [-o <field>,...] [-s [-i <interval>]] "
417 "[<bridge>]\n"
418 " show-bridge -l [-p] [-o <field>,...] [-s [-i <interval>]]"
419 " <bridge>\n"
420 " show-bridge -f [-p] [-o <field>,...] [-s [-i <interval>]]"
421 " <bridge>\n"
422 " show-bridge -t [-p] [-o <field>,...] [-s [-i <interval>]]"
423 " <bridge>\n" },
424 { "create-overlay", do_create_overlay,
425 " create-overlay [-t] -e <encap> -s <search> -v <vnetid>\n"
426 "\t\t [ -p <prop>=<value>[,...]] <overlay>" },
427 { "delete-overlay", do_delete_overlay,
428 " delete-overlay [-t] <overlay>" },
429 { "modify-overlay", do_modify_overlay,
430 " modify-overlay -d mac | -f | -s mac=ip:port "
431 "<overlay>" },
432 { "show-overlay", do_show_overlay,
433 " show-overlay [-f | -t] [[-p] -o <field>,...] "
434 "[<overlay>]\n" },
435 { "up-overlay", do_up_overlay, NULL },
436 { "show-usage", do_show_usage,
437 " show-usage [-a] [-d | -F <format>] "
438 "[-s <DD/MM/YYYY,HH:MM:SS>]\n"
439 "\t\t [-e <DD/MM/YYYY,HH:MM:SS>] -f <logfile> [<link>]" }
440 };
441
442 static const struct option lopts[] = {
443 {"vlan-id", required_argument, 0, 'v'},
444 {"output", required_argument, 0, 'o'},
445 {"dev", required_argument, 0, 'd'},
446 {"policy", required_argument, 0, 'P'},
447 {"lacp-mode", required_argument, 0, 'L'},
448 {"lacp-timer", required_argument, 0, 'T'},
449 {"unicast", required_argument, 0, 'u'},
450 {"temporary", no_argument, 0, 't'},
451 {"root-dir", required_argument, 0, 'R'},
452 {"link", required_argument, 0, 'l'},
453 {"forcible", no_argument, 0, 'f'},
454 {"bw-limit", required_argument, 0, 'b'},
455 {"mac-address", required_argument, 0, 'm'},
456 {"slot", required_argument, 0, 'n'},
457 { NULL, 0, NULL, 0 }
458 };
459
460 static const struct option show_lopts[] = {
461 {"statistics", no_argument, 0, 's'},
462 {"continuous", no_argument, 0, 'S'},
463 {"interval", required_argument, 0, 'i'},
464 {"parsable", no_argument, 0, 'p'},
465 {"parseable", no_argument, 0, 'p'},
466 {"extended", no_argument, 0, 'x'},
467 {"output", required_argument, 0, 'o'},
468 {"persistent", no_argument, 0, 'P'},
469 {"lacp", no_argument, 0, 'L'},
470 { NULL, 0, NULL, 0 }
471 };
472
473 static const struct option iptun_lopts[] = {
474 {"output", required_argument, 0, 'o'},
475 {"tunnel-type", required_argument, 0, 'T'},
476 {"address", required_argument, 0, 'a'},
477 {"root-dir", required_argument, 0, 'R'},
478 {"parsable", no_argument, 0, 'p'},
479 {"parseable", no_argument, 0, 'p'},
480 {"persistent", no_argument, 0, 'P'},
481 { NULL, 0, NULL, 0 }
482 };
483
484 static char * const iptun_addropts[] = {
485 #define IPTUN_LOCAL 0
486 "local",
487 #define IPTUN_REMOTE 1
488 "remote",
489 NULL};
490
491 static const struct {
492 const char *type_name;
493 iptun_type_t type_value;
494 } iptun_types[] = {
495 {"ipv4", IPTUN_TYPE_IPV4},
496 {"ipv6", IPTUN_TYPE_IPV6},
497 {"6to4", IPTUN_TYPE_6TO4},
498 {NULL, 0}
499 };
500
501 static const struct option prop_longopts[] = {
502 {"temporary", no_argument, 0, 't' },
503 {"output", required_argument, 0, 'o' },
504 {"root-dir", required_argument, 0, 'R' },
505 {"prop", required_argument, 0, 'p' },
506 {"parsable", no_argument, 0, 'c' },
507 {"parseable", no_argument, 0, 'c' },
508 {"persistent", no_argument, 0, 'P' },
509 { NULL, 0, NULL, 0 }
510 };
511
512 static const struct option wifi_longopts[] = {
513 {"parsable", no_argument, 0, 'p' },
514 {"parseable", no_argument, 0, 'p' },
515 {"output", required_argument, 0, 'o' },
516 {"essid", required_argument, 0, 'e' },
517 {"bsstype", required_argument, 0, 'b' },
518 {"mode", required_argument, 0, 'm' },
519 {"key", required_argument, 0, 'k' },
520 {"sec", required_argument, 0, 's' },
521 {"auth", required_argument, 0, 'a' },
522 {"create-ibss", required_argument, 0, 'c' },
523 {"timeout", required_argument, 0, 'T' },
524 {"all-links", no_argument, 0, 'a' },
525 {"temporary", no_argument, 0, 't' },
526 {"root-dir", required_argument, 0, 'R' },
527 {"persistent", no_argument, 0, 'P' },
528 {"file", required_argument, 0, 'f' },
529 { NULL, 0, NULL, 0 }
530 };
531
532 static const struct option showeth_lopts[] = {
533 {"parsable", no_argument, 0, 'p' },
534 {"parseable", no_argument, 0, 'p' },
535 {"extended", no_argument, 0, 'x' },
536 {"output", required_argument, 0, 'o' },
537 { NULL, 0, NULL, 0 }
538 };
539
540 static const struct option vnic_lopts[] = {
541 {"temporary", no_argument, 0, 't' },
542 {"root-dir", required_argument, 0, 'R' },
543 {"dev", required_argument, 0, 'd' },
544 {"mac-address", required_argument, 0, 'm' },
545 {"cpus", required_argument, 0, 'c' },
546 {"bw-limit", required_argument, 0, 'b' },
547 {"slot", required_argument, 0, 'n' },
548 {"mac-prefix", required_argument, 0, 'r' },
549 {"vrid", required_argument, 0, 'V' },
550 {"address-family", required_argument, 0, 'A' },
551 { NULL, 0, NULL, 0 }
552 };
553
554 static const struct option part_lopts[] = {
555 {"temporary", no_argument, 0, 't' },
556 {"pkey", required_argument, 0, 'P' },
557 {"link", required_argument, 0, 'l' },
558 {"force", no_argument, 0, 'f' },
559 {"root-dir", required_argument, 0, 'R' },
560 {"prop", required_argument, 0, 'p' },
561 { NULL, 0, NULL, 0 }
562 };
563
564 static const struct option show_part_lopts[] = {
565 {"parsable", no_argument, 0, 'p' },
566 {"parseable", no_argument, 0, 'p' },
567 {"link", required_argument, 0, 'l' },
568 {"persistent", no_argument, 0, 'P' },
569 {"output", required_argument, 0, 'o' },
570 { NULL, 0, NULL, 0 }
571 };
572
573 static const struct option etherstub_lopts[] = {
574 {"temporary", no_argument, 0, 't' },
575 {"root-dir", required_argument, 0, 'R' },
576 { NULL, 0, NULL, 0 }
577 };
578
579 static const struct option usage_opts[] = {
580 {"file", required_argument, 0, 'f' },
581 {"format", required_argument, 0, 'F' },
582 {"start", required_argument, 0, 's' },
583 {"stop", required_argument, 0, 'e' },
584 { NULL, 0, NULL, 0 }
585 };
586
587 static const struct option simnet_lopts[] = {
588 {"temporary", no_argument, 0, 't' },
589 {"root-dir", required_argument, 0, 'R' },
590 {"media", required_argument, 0, 'm' },
591 {"peer", required_argument, 0, 'p' },
592 { NULL, 0, NULL, 0 }
593 };
594
595 static const struct option bridge_lopts[] = {
596 { "protect", required_argument, 0, 'P' },
597 { "root-dir", required_argument, 0, 'R' },
598 { "forward-delay", required_argument, 0, 'd' },
599 { "force-protocol", required_argument, 0, 'f' },
600 { "hello-time", required_argument, 0, 'h' },
601 { "link", required_argument, 0, 'l' },
602 { "max-age", required_argument, 0, 'm' },
603 { "priority", required_argument, 0, 'p' },
604 { NULL, 0, NULL, 0 }
605 };
606
607 static const struct option bridge_show_lopts[] = {
608 { "forwarding", no_argument, 0, 'f' },
609 { "interval", required_argument, 0, 'i' },
610 { "link", no_argument, 0, 'l' },
611 { "output", required_argument, 0, 'o' },
612 { "parsable", no_argument, 0, 'p' },
613 { "parseable", no_argument, 0, 'p' },
614 { "statistics", no_argument, 0, 's' },
615 { "trill", no_argument, 0, 't' },
616 { NULL, 0, NULL, 0 }
617 };
618
619 /*
620 * structures for 'dladm show-ether'
621 */
622 static const char *ptype[] = {LEI_ATTR_NAMES};
623
624 typedef struct ether_fields_buf_s
625 {
626 char eth_link[15];
627 char eth_ptype[8];
628 char eth_state[8];
629 char eth_autoneg[5];
630 char eth_spdx[31];
631 char eth_pause[6];
632 char eth_rem_fault[16];
633 } ether_fields_buf_t;
634
635 static const ofmt_field_t ether_fields[] = {
636 /* name, field width, offset callback */
637 { "LINK", 16,
638 offsetof(ether_fields_buf_t, eth_link), print_default_cb},
639 { "PTYPE", 9,
640 offsetof(ether_fields_buf_t, eth_ptype), print_default_cb},
641 { "STATE", 9,
642 offsetof(ether_fields_buf_t, eth_state),
643 print_default_cb},
644 { "AUTO", 6,
645 offsetof(ether_fields_buf_t, eth_autoneg), print_default_cb},
646 { "SPEED-DUPLEX", 32,
647 offsetof(ether_fields_buf_t, eth_spdx), print_default_cb},
648 { "PAUSE", 7,
649 offsetof(ether_fields_buf_t, eth_pause), print_default_cb},
650 { "REM_FAULT", 17,
651 offsetof(ether_fields_buf_t, eth_rem_fault), print_default_cb},
652 {NULL, 0,
653 0, NULL}}
654 ;
655
656 typedef struct print_ether_state {
657 const char *es_link;
658 boolean_t es_parsable;
659 boolean_t es_header;
660 boolean_t es_extended;
661 ofmt_handle_t es_ofmt;
662 } print_ether_state_t;
663
664 /*
665 * structures for 'dladm show-link -s' (print statistics)
666 */
667 typedef enum {
668 LINK_S_LINK,
669 LINK_S_IPKTS,
670 LINK_S_RBYTES,
671 LINK_S_IERRORS,
672 LINK_S_OPKTS,
673 LINK_S_OBYTES,
674 LINK_S_OERRORS
675 } link_s_field_index_t;
676
677 static const ofmt_field_t link_s_fields[] = {
678 /* name, field width, index, callback */
679 { "LINK", 15, LINK_S_LINK, print_link_stats_cb},
680 { "IPACKETS", 10, LINK_S_IPKTS, print_link_stats_cb},
681 { "RBYTES", 8, LINK_S_RBYTES, print_link_stats_cb},
682 { "IERRORS", 10, LINK_S_IERRORS, print_link_stats_cb},
683 { "OPACKETS", 12, LINK_S_OPKTS, print_link_stats_cb},
684 { "OBYTES", 12, LINK_S_OBYTES, print_link_stats_cb},
685 { "OERRORS", 8, LINK_S_OERRORS, print_link_stats_cb},
686 { NULL, 0, 0, NULL}};
687
688 typedef struct link_args_s {
689 char *link_s_link;
690 pktsum_t *link_s_psum;
691 } link_args_t;
692
693 /*
694 * buffer used by print functions for show-{link,phys,vlan} commands.
695 */
696 typedef struct link_fields_buf_s {
697 char link_name[MAXLINKNAMELEN];
698 char link_class[DLADM_STRSIZE];
699 char link_mtu[11];
700 char link_state[DLADM_STRSIZE];
701 char link_bridge[MAXLINKNAMELEN * MAXPORT];
702 char link_over[MAXLINKNAMELEN * MAXPORT];
703 char link_phys_state[DLADM_STRSIZE];
704 char link_phys_media[DLADM_STRSIZE];
705 char link_phys_speed[DLADM_STRSIZE];
706 char link_phys_duplex[DLPI_LINKNAME_MAX];
707 char link_phys_device[DLPI_LINKNAME_MAX];
708 char link_flags[6];
709 char link_vlan_vid[6];
710 } link_fields_buf_t;
711
712 /*
713 * structures for 'dladm show-link'
714 */
715 static const ofmt_field_t link_fields[] = {
716 /* name, field width, index, callback */
717 { "LINK", 12,
718 offsetof(link_fields_buf_t, link_name), print_default_cb},
719 { "CLASS", 10,
720 offsetof(link_fields_buf_t, link_class), print_default_cb},
721 { "MTU", 7,
722 offsetof(link_fields_buf_t, link_mtu), print_default_cb},
723 { "STATE", 9,
724 offsetof(link_fields_buf_t, link_state), print_default_cb},
725 { "BRIDGE", 11,
726 offsetof(link_fields_buf_t, link_bridge), print_default_cb},
727 { "OVER", 30,
728 offsetof(link_fields_buf_t, link_over), print_default_cb},
729 { NULL, 0, 0, NULL}}
730 ;
731
732 /*
733 * structures for 'dladm show-aggr'
734 */
735 typedef struct laggr_fields_buf_s {
736 char laggr_name[DLPI_LINKNAME_MAX];
737 char laggr_policy[9];
738 char laggr_addrpolicy[ETHERADDRL * 3 + 3];
739 char laggr_lacpactivity[14];
740 char laggr_lacptimer[DLADM_STRSIZE];
741 char laggr_flags[7];
742 } laggr_fields_buf_t;
743
744 typedef struct laggr_args_s {
745 int laggr_lport; /* -1 indicates the aggr itself */
746 const char *laggr_link;
747 dladm_aggr_grp_attr_t *laggr_ginfop;
748 dladm_status_t *laggr_status;
749 pktsum_t *laggr_pktsumtot; /* -s only */
750 pktsum_t *laggr_diffstats; /* -s only */
751 boolean_t laggr_parsable;
752 } laggr_args_t;
753
754 static const ofmt_field_t laggr_fields[] = {
755 /* name, field width, offset, callback */
756 { "LINK", 16,
757 offsetof(laggr_fields_buf_t, laggr_name), print_default_cb},
758 { "POLICY", 9,
759 offsetof(laggr_fields_buf_t, laggr_policy), print_default_cb},
760 { "ADDRPOLICY", ETHERADDRL * 3 + 3,
761 offsetof(laggr_fields_buf_t, laggr_addrpolicy), print_default_cb},
762 { "LACPACTIVITY", 14,
763 offsetof(laggr_fields_buf_t, laggr_lacpactivity), print_default_cb},
764 { "LACPTIMER", 12,
765 offsetof(laggr_fields_buf_t, laggr_lacptimer), print_default_cb},
766 { "FLAGS", 8,
767 offsetof(laggr_fields_buf_t, laggr_flags), print_default_cb},
768 { NULL, 0, 0, NULL}}
769 ;
770
771 /*
772 * structures for 'dladm show-aggr -x'.
773 */
774 typedef enum {
775 AGGR_X_LINK,
776 AGGR_X_PORT,
777 AGGR_X_SPEED,
778 AGGR_X_DUPLEX,
779 AGGR_X_STATE,
780 AGGR_X_ADDRESS,
781 AGGR_X_PORTSTATE
782 } aggr_x_field_index_t;
783
784 static const ofmt_field_t aggr_x_fields[] = {
785 /* name, field width, index callback */
786 { "LINK", 12, AGGR_X_LINK, print_xaggr_cb},
787 { "PORT", 15, AGGR_X_PORT, print_xaggr_cb},
788 { "SPEED", 9, AGGR_X_SPEED, print_xaggr_cb},
789 { "DUPLEX", 9, AGGR_X_DUPLEX, print_xaggr_cb},
790 { "STATE", 9, AGGR_X_STATE, print_xaggr_cb},
791 { "ADDRESS", 19, AGGR_X_ADDRESS, print_xaggr_cb},
792 { "PORTSTATE", 16, AGGR_X_PORTSTATE, print_xaggr_cb},
793 { NULL, 0, 0, NULL}}
794 ;
795
796 /*
797 * structures for 'dladm show-aggr -s'.
798 */
799 typedef enum {
800 AGGR_S_LINK,
801 AGGR_S_PORT,
802 AGGR_S_IPKTS,
803 AGGR_S_RBYTES,
804 AGGR_S_OPKTS,
805 AGGR_S_OBYTES,
806 AGGR_S_IPKTDIST,
807 AGGR_S_OPKTDIST
808 } aggr_s_field_index_t;
809
810 static const ofmt_field_t aggr_s_fields[] = {
811 { "LINK", 12, AGGR_S_LINK, print_aggr_stats_cb},
812 { "PORT", 10, AGGR_S_PORT, print_aggr_stats_cb},
813 { "IPACKETS", 8, AGGR_S_IPKTS, print_aggr_stats_cb},
814 { "RBYTES", 8, AGGR_S_RBYTES, print_aggr_stats_cb},
815 { "OPACKETS", 8, AGGR_S_OPKTS, print_aggr_stats_cb},
816 { "OBYTES", 8, AGGR_S_OBYTES, print_aggr_stats_cb},
817 { "IPKTDIST", 9, AGGR_S_IPKTDIST, print_aggr_stats_cb},
818 { "OPKTDIST", 15, AGGR_S_OPKTDIST, print_aggr_stats_cb},
819 { NULL, 0, 0, NULL}}
820 ;
821
822 /*
823 * structures for 'dladm show-aggr -L'.
824 */
825 typedef enum {
826 AGGR_L_LINK,
827 AGGR_L_PORT,
828 AGGR_L_AGGREGATABLE,
829 AGGR_L_SYNC,
830 AGGR_L_COLL,
831 AGGR_L_DIST,
832 AGGR_L_DEFAULTED,
833 AGGR_L_EXPIRED
834 } aggr_l_field_index_t;
835
836 static const ofmt_field_t aggr_l_fields[] = {
837 /* name, field width, index */
838 { "LINK", 12, AGGR_L_LINK, print_lacp_cb},
839 { "PORT", 13, AGGR_L_PORT, print_lacp_cb},
840 { "AGGREGATABLE", 13, AGGR_L_AGGREGATABLE, print_lacp_cb},
841 { "SYNC", 5, AGGR_L_SYNC, print_lacp_cb},
842 { "COLL", 5, AGGR_L_COLL, print_lacp_cb},
843 { "DIST", 5, AGGR_L_DIST, print_lacp_cb},
844 { "DEFAULTED", 10, AGGR_L_DEFAULTED, print_lacp_cb},
845 { "EXPIRED", 15, AGGR_L_EXPIRED, print_lacp_cb},
846 { NULL, 0, 0, NULL}}
847 ;
848
849 /*
850 * structures for 'dladm show-phys'
851 */
852
853 static const ofmt_field_t phys_fields[] = {
854 /* name, field width, offset */
855 { "LINK", 13,
856 offsetof(link_fields_buf_t, link_name), print_default_cb},
857 { "MEDIA", 21,
858 offsetof(link_fields_buf_t, link_phys_media), print_default_cb},
859 { "STATE", 11,
860 offsetof(link_fields_buf_t, link_phys_state), print_default_cb},
861 { "SPEED", 9,
862 offsetof(link_fields_buf_t, link_phys_speed), print_default_cb},
863 { "DUPLEX", 9,
864 offsetof(link_fields_buf_t, link_phys_duplex), print_default_cb},
865 { "DEVICE", 13,
866 offsetof(link_fields_buf_t, link_phys_device), print_default_cb},
867 { "FLAGS", 7,
868 offsetof(link_fields_buf_t, link_flags), print_default_cb},
869 { NULL, 0, 0, NULL}}
870 ;
871
872 /*
873 * structures for 'dladm show-phys -m'
874 */
875
876 typedef enum {
877 PHYS_M_LINK,
878 PHYS_M_SLOT,
879 PHYS_M_ADDRESS,
880 PHYS_M_INUSE,
881 PHYS_M_CLIENT
882 } phys_m_field_index_t;
883
884 static const ofmt_field_t phys_m_fields[] = {
885 /* name, field width, offset */
886 { "LINK", 13, PHYS_M_LINK, print_phys_one_mac_cb},
887 { "SLOT", 9, PHYS_M_SLOT, print_phys_one_mac_cb},
888 { "ADDRESS", 19, PHYS_M_ADDRESS, print_phys_one_mac_cb},
889 { "INUSE", 5, PHYS_M_INUSE, print_phys_one_mac_cb},
890 { "CLIENT", 13, PHYS_M_CLIENT, print_phys_one_mac_cb},
891 { NULL, 0, 0, NULL}}
892 ;
893
894 /*
895 * structures for 'dladm show-phys -H'
896 */
897
898 typedef enum {
899 PHYS_H_LINK,
900 PHYS_H_RINGTYPE,
901 PHYS_H_RINGS,
902 PHYS_H_CLIENTS
903 } phys_h_field_index_t;
904
905 #define RINGSTRLEN 21
906
907 static const ofmt_field_t phys_h_fields[] = {
908 { "LINK", 13, PHYS_H_LINK, print_phys_one_hwgrp_cb},
909 { "RINGTYPE", 9, PHYS_H_RINGTYPE, print_phys_one_hwgrp_cb},
910 { "RINGS", RINGSTRLEN, PHYS_H_RINGS, print_phys_one_hwgrp_cb},
911 { "CLIENTS", 24, PHYS_H_CLIENTS, print_phys_one_hwgrp_cb},
912 { NULL, 0, 0, NULL}}
913 ;
914
915 /*
916 * structures for 'dladm show-vlan'
917 */
918 static const ofmt_field_t vlan_fields[] = {
919 { "LINK", 16,
920 offsetof(link_fields_buf_t, link_name), print_default_cb},
921 { "VID", 9,
922 offsetof(link_fields_buf_t, link_vlan_vid), print_default_cb},
923 { "OVER", 13,
924 offsetof(link_fields_buf_t, link_over), print_default_cb},
925 { "FLAGS", 7,
926 offsetof(link_fields_buf_t, link_flags), print_default_cb},
927 { NULL, 0, 0, NULL}}
928 ;
929
930 /*
931 * structures common to 'dladm scan-wifi' and 'dladm show-wifi'
932 * callback will be determined in parse_wifi_fields.
933 */
934 static ofmt_field_t wifi_common_fields[] = {
935 { "LINK", 11, 0, NULL},
936 { "ESSID", 20, DLADM_WLAN_ATTR_ESSID, NULL},
937 { "BSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},
938 { "IBSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},
939 { "MODE", 7, DLADM_WLAN_ATTR_MODE, NULL},
940 { "SPEED", 7, DLADM_WLAN_ATTR_SPEED, NULL},
941 { "BSSTYPE", 9, DLADM_WLAN_ATTR_BSSTYPE, NULL},
942 { "SEC", 7, DLADM_WLAN_ATTR_SECMODE, NULL},
943 { "STRENGTH", 11, DLADM_WLAN_ATTR_STRENGTH, NULL},
944 { NULL, 0, 0, NULL}};
945
946 /*
947 * the 'show-wifi' command supports all the fields in wifi_common_fields
948 * plus the AUTH and STATUS fields.
949 */
950 static ofmt_field_t wifi_show_fields[A_CNT(wifi_common_fields) + 2] = {
951 { "AUTH", 9, DLADM_WLAN_ATTR_AUTH, NULL},
952 { "STATUS", 18, DLADM_WLAN_LINKATTR_STATUS, print_wifi_status_cb},
953 /* copy wifi_common_fields here */
954 };
955
956 static char *all_scan_wifi_fields =
957 "link,essid,bssid,sec,strength,mode,speed,bsstype";
958 static char *all_show_wifi_fields =
959 "link,status,essid,sec,strength,mode,speed,auth,bssid,bsstype";
960 static char *def_scan_wifi_fields =
961 "link,essid,bssid,sec,strength,mode,speed";
962 static char *def_show_wifi_fields =
963 "link,status,essid,sec,strength,mode,speed";
964
965 /*
966 * structures for 'dladm show-linkprop'
967 */
968 typedef enum {
969 LINKPROP_LINK,
970 LINKPROP_PROPERTY,
971 LINKPROP_PERM,
972 LINKPROP_VALUE,
973 LINKPROP_DEFAULT,
974 LINKPROP_POSSIBLE
975 } linkprop_field_index_t;
976
977 static const ofmt_field_t linkprop_fields[] = {
978 /* name, field width, index */
979 { "LINK", 13, LINKPROP_LINK, print_linkprop_cb},
980 { "PROPERTY", 16, LINKPROP_PROPERTY, print_linkprop_cb},
981 { "PERM", 5, LINKPROP_PERM, print_linkprop_cb},
982 { "VALUE", 15, LINKPROP_VALUE, print_linkprop_cb},
983 { "DEFAULT", 15, LINKPROP_DEFAULT, print_linkprop_cb},
984 { "POSSIBLE", 20, LINKPROP_POSSIBLE, print_linkprop_cb},
985 { NULL, 0, 0, NULL}}
986 ;
987
988 #define MAX_PROP_LINE 512
989
990 typedef struct show_linkprop_state {
991 char ls_link[MAXLINKNAMELEN];
992 char *ls_line;
993 char **ls_propvals;
994 dladm_arg_list_t *ls_proplist;
995 boolean_t ls_parsable;
996 boolean_t ls_persist;
997 boolean_t ls_header;
998 dladm_status_t ls_status;
999 dladm_status_t ls_retstatus;
1000 ofmt_handle_t ls_ofmt;
1001 } show_linkprop_state_t;
1002
1003 typedef struct set_linkprop_state {
1004 const char *ls_name;
1005 boolean_t ls_reset;
1006 boolean_t ls_temp;
1007 dladm_status_t ls_status;
1008 } set_linkprop_state_t;
1009
1010 typedef struct linkprop_args_s {
1011 show_linkprop_state_t *ls_state;
1012 char *ls_propname;
1013 datalink_id_t ls_linkid;
1014 } linkprop_args_t;
1015
1016 /*
1017 * structures for 'dladm show-secobj'
1018 */
1019 typedef struct secobj_fields_buf_s {
1020 char ss_obj_name[DLADM_SECOBJ_VAL_MAX];
1021 char ss_class[20];
1022 char ss_val[30];
1023 } secobj_fields_buf_t;
1024
1025 static const ofmt_field_t secobj_fields[] = {
1026 { "OBJECT", 21,
1027 offsetof(secobj_fields_buf_t, ss_obj_name), print_default_cb},
1028 { "CLASS", 21,
1029 offsetof(secobj_fields_buf_t, ss_class), print_default_cb},
1030 { "VALUE", 31,
1031 offsetof(secobj_fields_buf_t, ss_val), print_default_cb},
1032 { NULL, 0, 0, NULL}}
1033 ;
1034
1035 /*
1036 * structures for 'dladm show-vnic'
1037 */
1038 typedef struct vnic_fields_buf_s
1039 {
1040 char vnic_link[DLPI_LINKNAME_MAX];
1041 char vnic_over[DLPI_LINKNAME_MAX];
1042 char vnic_speed[10];
1043 char vnic_macaddr[18];
1044 char vnic_macaddrtype[19];
1045 char vnic_vid[6];
1046 } vnic_fields_buf_t;
1047
1048 static const ofmt_field_t vnic_fields[] = {
1049 { "LINK", 13,
1050 offsetof(vnic_fields_buf_t, vnic_link), print_default_cb},
1051 { "OVER", 13,
1052 offsetof(vnic_fields_buf_t, vnic_over), print_default_cb},
1053 { "SPEED", 9,
1054 offsetof(vnic_fields_buf_t, vnic_speed), print_default_cb},
1055 { "MACADDRESS", 18,
1056 offsetof(vnic_fields_buf_t, vnic_macaddr), print_default_cb},
1057 { "MACADDRTYPE", 20,
1058 offsetof(vnic_fields_buf_t, vnic_macaddrtype), print_default_cb},
1059 { "VID", 7,
1060 offsetof(vnic_fields_buf_t, vnic_vid), print_default_cb},
1061 { NULL, 0, 0, NULL}}
1062 ;
1063
1064 /*
1065 * structures for 'dladm show-ib'
1066 */
1067 typedef struct ib_fields_buf_s
1068 {
1069 char ib_link[DLPI_LINKNAME_MAX];
1070 char ib_hcaguid[17];
1071 char ib_portguid[17];
1072 char ib_portnum[4];
1073 char ib_state[6];
1074 char ib_pkeys[MAXPKEYSTRSZ];
1075 } ib_fields_buf_t;
1076
1077 static const ofmt_field_t ib_fields[] = {
1078 { "LINK", 13,
1079 offsetof(ib_fields_buf_t, ib_link), print_default_cb},
1080 { "HCAGUID", IBGUIDSTRLEN,
1081 offsetof(ib_fields_buf_t, ib_hcaguid), print_default_cb},
1082 { "PORTGUID", IBGUIDSTRLEN,
1083 offsetof(ib_fields_buf_t, ib_portguid), print_default_cb},
1084 { "PORT", IBPORTSTRLEN,
1085 offsetof(ib_fields_buf_t, ib_portnum), print_default_cb},
1086 { "STATE", 7,
1087 offsetof(ib_fields_buf_t, ib_state), print_default_cb},
1088 { "PKEYS", 18,
1089 offsetof(ib_fields_buf_t, ib_pkeys), print_default_cb},
1090 { NULL, 0, 0, NULL}};
1091
1092 /*
1093 * structures for 'dladm show-part'
1094 */
1095 typedef struct part_fields_buf_s
1096 {
1097 char part_link[DLPI_LINKNAME_MAX];
1098 char part_pkey[5];
1099 char part_over[DLPI_LINKNAME_MAX];
1100 char part_state[8];
1101 char part_flags[5];
1102 } part_fields_buf_t;
1103
1104 static const ofmt_field_t part_fields[] = {
1105 { "LINK", 13,
1106 offsetof(part_fields_buf_t, part_link), print_default_cb},
1107 { "PKEY", MAXPKEYLEN,
1108 offsetof(part_fields_buf_t, part_pkey), print_default_cb},
1109 { "OVER", 13,
1110 offsetof(part_fields_buf_t, part_over), print_default_cb},
1111 { "STATE", 9,
1112 offsetof(part_fields_buf_t, part_state), print_default_cb},
1113 { "FLAGS", 5,
1114 offsetof(part_fields_buf_t, part_flags), print_default_cb},
1115 { NULL, 0, 0, NULL}};
1116
1117 /*
1118 * structures for 'dladm show-simnet'
1119 */
1120 typedef struct simnet_fields_buf_s
1121 {
1122 char simnet_name[DLPI_LINKNAME_MAX];
1123 char simnet_media[DLADM_STRSIZE];
1124 char simnet_macaddr[18];
1125 char simnet_otherlink[DLPI_LINKNAME_MAX];
1126 } simnet_fields_buf_t;
1127
1128 static const ofmt_field_t simnet_fields[] = {
1129 { "LINK", 12,
1130 offsetof(simnet_fields_buf_t, simnet_name), print_default_cb},
1131 { "MEDIA", 20,
1132 offsetof(simnet_fields_buf_t, simnet_media), print_default_cb},
1133 { "MACADDRESS", 18,
1134 offsetof(simnet_fields_buf_t, simnet_macaddr), print_default_cb},
1135 { "OTHERLINK", 12,
1136 offsetof(simnet_fields_buf_t, simnet_otherlink), print_default_cb},
1137 { NULL, 0, 0, NULL}}
1138 ;
1139
1140 /*
1141 * structures for 'dladm show-usage'
1142 */
1143
1144 typedef struct usage_fields_buf_s {
1145 char usage_link[12];
1146 char usage_duration[10];
1147 char usage_ipackets[9];
1148 char usage_rbytes[10];
1149 char usage_opackets[9];
1150 char usage_obytes[10];
1151 char usage_bandwidth[15];
1152 } usage_fields_buf_t;
1153
1154 static const ofmt_field_t usage_fields[] = {
1155 { "LINK", 13,
1156 offsetof(usage_fields_buf_t, usage_link), print_default_cb},
1157 { "DURATION", 11,
1158 offsetof(usage_fields_buf_t, usage_duration), print_default_cb},
1159 { "IPACKETS", 10,
1160 offsetof(usage_fields_buf_t, usage_ipackets), print_default_cb},
1161 { "RBYTES", 11,
1162 offsetof(usage_fields_buf_t, usage_rbytes), print_default_cb},
1163 { "OPACKETS", 10,
1164 offsetof(usage_fields_buf_t, usage_opackets), print_default_cb},
1165 { "OBYTES", 11,
1166 offsetof(usage_fields_buf_t, usage_obytes), print_default_cb},
1167 { "BANDWIDTH", 16,
1168 offsetof(usage_fields_buf_t, usage_bandwidth), print_default_cb},
1169 { NULL, 0, 0, NULL}}
1170 ;
1171
1172
1173 /*
1174 * structures for 'dladm show-usage link'
1175 */
1176
1177 typedef struct usage_l_fields_buf_s {
1178 char usage_l_link[12];
1179 char usage_l_stime[13];
1180 char usage_l_etime[13];
1181 char usage_l_rbytes[8];
1182 char usage_l_obytes[8];
1183 char usage_l_bandwidth[15];
1184 } usage_l_fields_buf_t;
1185
1186 static const ofmt_field_t usage_l_fields[] = {
1187 /* name, field width, offset */
1188 { "LINK", 13,
1189 offsetof(usage_l_fields_buf_t, usage_l_link), print_default_cb},
1190 { "START", 14,
1191 offsetof(usage_l_fields_buf_t, usage_l_stime), print_default_cb},
1192 { "END", 14,
1193 offsetof(usage_l_fields_buf_t, usage_l_etime), print_default_cb},
1194 { "RBYTES", 9,
1195 offsetof(usage_l_fields_buf_t, usage_l_rbytes), print_default_cb},
1196 { "OBYTES", 9,
1197 offsetof(usage_l_fields_buf_t, usage_l_obytes), print_default_cb},
1198 { "BANDWIDTH", 16,
1199 offsetof(usage_l_fields_buf_t, usage_l_bandwidth), print_default_cb},
1200 { NULL, 0, 0, NULL}}
1201 ;
1202
1203 /* IPTUN_*FLAG_INDEX values are indices into iptun_flags below. */
1204 enum { IPTUN_SFLAG_INDEX, IPTUN_IFLAG_INDEX, IPTUN_NUM_FLAGS };
1205
1206 /*
1207 * structures for 'dladm show-iptun'
1208 */
1209 typedef struct iptun_fields_buf_s {
1210 char iptun_name[MAXLINKNAMELEN];
1211 char iptun_type[5];
1212 char iptun_laddr[NI_MAXHOST];
1213 char iptun_raddr[NI_MAXHOST];
1214 char iptun_flags[IPTUN_NUM_FLAGS + 1];
1215 } iptun_fields_buf_t;
1216
1217 static const ofmt_field_t iptun_fields[] = {
1218 { "LINK", 16,
1219 offsetof(iptun_fields_buf_t, iptun_name), print_default_cb },
1220 { "TYPE", 6,
1221 offsetof(iptun_fields_buf_t, iptun_type), print_default_cb },
1222 { "FLAGS", 7,
1223 offsetof(iptun_fields_buf_t, iptun_flags), print_default_cb },
1224 { "LOCAL", 20,
1225 offsetof(iptun_fields_buf_t, iptun_laddr), print_default_cb },
1226 { "REMOTE", 20,
1227 offsetof(iptun_fields_buf_t, iptun_raddr), print_default_cb },
1228 { NULL, 0, 0, NULL}
1229 };
1230
1231 /*
1232 * structures for 'dladm show-bridge'. These are based on sections 14.8.1.1.3
1233 * and 14.8.1.2.2 of IEEE 802.1D-2004.
1234 */
1235 typedef struct bridge_fields_buf_s {
1236 char bridge_name[MAXLINKNAMELEN]; /* 14.4.1.2.3(b) */
1237 char bridge_protect[7]; /* stp or trill */
1238 char bridge_address[24]; /* 17.18.3, 7.12.5, 14.4.1.2.3(a) */
1239 char bridge_priority[7]; /* 17.18.3 9.2.5 - only upper 4 bits */
1240 char bridge_bmaxage[7]; /* 17.18.4 configured */
1241 char bridge_bhellotime[7]; /* 17.18.4 configured */
1242 char bridge_bfwddelay[7]; /* 17.18.4 configured */
1243 char bridge_forceproto[3]; /* 17.13.4 configured */
1244 char bridge_tctime[12]; /* 14.8.1.1.3(b) */
1245 char bridge_tccount[12]; /* 17.17.8 */
1246 char bridge_tchange[12]; /* 17.17.8 */
1247 char bridge_desroot[24]; /* 17.18.6 priority "/" MAC */
1248 char bridge_rootcost[12]; /* 17.18.6 */
1249 char bridge_rootport[12]; /* 17.18.6 */
1250 char bridge_maxage[7]; /* 17.18.7 for root */
1251 char bridge_hellotime[7]; /* 17.13.6 for root */
1252 char bridge_fwddelay[7]; /* 17.13.5 for root */
1253 char bridge_holdtime[12]; /* 17.13.12 for root */
1254 } bridge_fields_buf_t;
1255
1256 static ofmt_field_t bridge_fields[] = {
1257 /* name, field width, offset, callback */
1258 { "BRIDGE", 12,
1259 offsetof(bridge_fields_buf_t, bridge_name), print_default_cb },
1260 { "PROTECT", 8,
1261 offsetof(bridge_fields_buf_t, bridge_protect), print_default_cb },
1262 { "ADDRESS", 19,
1263 offsetof(bridge_fields_buf_t, bridge_address), print_default_cb },
1264 { "PRIORITY", 9,
1265 offsetof(bridge_fields_buf_t, bridge_priority), print_default_cb },
1266 { "BMAXAGE", 8,
1267 offsetof(bridge_fields_buf_t, bridge_bmaxage), print_default_cb },
1268 { "BHELLOTIME", 11,
1269 offsetof(bridge_fields_buf_t, bridge_bhellotime), print_default_cb },
1270 { "BFWDDELAY", 10,
1271 offsetof(bridge_fields_buf_t, bridge_bfwddelay), print_default_cb },
1272 { "FORCEPROTO", 11,
1273 offsetof(bridge_fields_buf_t, bridge_forceproto), print_default_cb },
1274 { "TCTIME", 10,
1275 offsetof(bridge_fields_buf_t, bridge_tctime), print_default_cb },
1276 { "TCCOUNT", 10,
1277 offsetof(bridge_fields_buf_t, bridge_tccount), print_default_cb },
1278 { "TCHANGE", 10,
1279 offsetof(bridge_fields_buf_t, bridge_tchange), print_default_cb },
1280 { "DESROOT", 23,
1281 offsetof(bridge_fields_buf_t, bridge_desroot), print_default_cb },
1282 { "ROOTCOST", 11,
1283 offsetof(bridge_fields_buf_t, bridge_rootcost), print_default_cb },
1284 { "ROOTPORT", 11,
1285 offsetof(bridge_fields_buf_t, bridge_rootport), print_default_cb },
1286 { "MAXAGE", 8,
1287 offsetof(bridge_fields_buf_t, bridge_maxage), print_default_cb },
1288 { "HELLOTIME", 10,
1289 offsetof(bridge_fields_buf_t, bridge_hellotime), print_default_cb },
1290 { "FWDDELAY", 9,
1291 offsetof(bridge_fields_buf_t, bridge_fwddelay), print_default_cb },
1292 { "HOLDTIME", 9,
1293 offsetof(bridge_fields_buf_t, bridge_holdtime), print_default_cb },
1294 { NULL, 0, 0, NULL}};
1295
1296 /*
1297 * structures for 'dladm show-bridge -l'. These are based on 14.4.1.2.3 and
1298 * 14.8.2.1.3 of IEEE 802.1D-2004.
1299 */
1300 typedef struct bridge_link_fields_buf_s {
1301 char bridgel_link[MAXLINKNAMELEN];
1302 char bridgel_index[7]; /* 14.4.1.2.3(d1) */
1303 char bridgel_state[11]; /* 14.8.2.1.3(b) */
1304 char bridgel_uptime[7]; /* 14.8.2.1.3(a) */
1305 char bridgel_opercost[7] /* 14.8.2.1.3(d) */;
1306 char bridgel_operp2p[4]; /* 14.8.2.1.3(p) */
1307 char bridgel_operedge[4]; /* 14.8.2.1.3(k) */
1308 char bridgel_desroot[23]; /* 14.8.2.1.3(e) */
1309 char bridgel_descost[12]; /* 14.8.2.1.3(f) */
1310 char bridgel_desbridge[23]; /* 14.8.2.1.3(g) */
1311 char bridgel_desport[7]; /* 14.8.2.1.3(h) */
1312 char bridgel_tcack[4]; /* 14.8.2.1.3(i) */
1313 } bridge_link_fields_buf_t;
1314
1315 static ofmt_field_t bridge_link_fields[] = {
1316 /* name, field width, offset, callback */
1317 { "LINK", 12,
1318 offsetof(bridge_link_fields_buf_t, bridgel_link), print_default_cb },
1319 { "INDEX", 8,
1320 offsetof(bridge_link_fields_buf_t, bridgel_index), print_default_cb },
1321 { "STATE", 12,
1322 offsetof(bridge_link_fields_buf_t, bridgel_state), print_default_cb },
1323 { "UPTIME", 8,
1324 offsetof(bridge_link_fields_buf_t, bridgel_uptime), print_default_cb },
1325 { "OPERCOST", 9,
1326 offsetof(bridge_link_fields_buf_t, bridgel_opercost), print_default_cb },
1327 { "OPERP2P", 8,
1328 offsetof(bridge_link_fields_buf_t, bridgel_operp2p), print_default_cb },
1329 { "OPEREDGE", 9,
1330 offsetof(bridge_link_fields_buf_t, bridgel_operedge), print_default_cb },
1331 { "DESROOT", 22,
1332 offsetof(bridge_link_fields_buf_t, bridgel_desroot), print_default_cb },
1333 { "DESCOST", 11,
1334 offsetof(bridge_link_fields_buf_t, bridgel_descost), print_default_cb },
1335 { "DESBRIDGE", 22,
1336 offsetof(bridge_link_fields_buf_t, bridgel_desbridge), print_default_cb },
1337 { "DESPORT", 8,
1338 offsetof(bridge_link_fields_buf_t, bridgel_desport), print_default_cb },
1339 { "TCACK", 6,
1340 offsetof(bridge_link_fields_buf_t, bridgel_tcack), print_default_cb },
1341 { NULL, 0, 0, NULL}};
1342
1343 /*
1344 * structures for 'dladm show-bridge -s'. These are not based on IEEE
1345 * 802.1D-2004.
1346 */
1347 #define ULONG_DIG (((sizeof (ulong_t) * NBBY) * 3 / 10) + 1)
1348 #define UINT64_DIG (((sizeof (uint64_t) * NBBY) * 3 / 10) + 1)
1349 typedef struct bridge_statfields_buf_s {
1350 char bridges_name[MAXLINKNAMELEN];
1351 char bridges_drops[UINT64_DIG];
1352 char bridges_forwards[UINT64_DIG];
1353 char bridges_mbcast[UINT64_DIG];
1354 char bridges_unknown[UINT64_DIG];
1355 char bridges_recv[UINT64_DIG];
1356 char bridges_sent[UINT64_DIG];
1357 } bridge_statfields_buf_t;
1358
1359 static ofmt_field_t bridge_statfields[] = {
1360 /* name, field width, offset, callback */
1361 { "BRIDGE", 12,
1362 offsetof(bridge_statfields_buf_t, bridges_name), print_default_cb },
1363 { "DROPS", 12,
1364 offsetof(bridge_statfields_buf_t, bridges_drops), print_default_cb },
1365 { "FORWARDS", 12,
1366 offsetof(bridge_statfields_buf_t, bridges_forwards), print_default_cb },
1367 { "MBCAST", 12,
1368 offsetof(bridge_statfields_buf_t, bridges_mbcast), print_default_cb },
1369 { "UNKNOWN", 12,
1370 offsetof(bridge_statfields_buf_t, bridges_unknown), print_default_cb },
1371 { "RECV", 12,
1372 offsetof(bridge_statfields_buf_t, bridges_recv), print_default_cb },
1373 { "SENT", 12,
1374 offsetof(bridge_statfields_buf_t, bridges_sent), print_default_cb },
1375 { NULL, 0, 0, NULL}};
1376
1377 /*
1378 * structures for 'dladm show-bridge -s -l'. These are based in part on
1379 * section 14.6.1.1.3 of IEEE 802.1D-2004.
1380 */
1381 typedef struct bridge_link_statfields_buf_s {
1382 char bridgels_link[MAXLINKNAMELEN];
1383 char bridgels_cfgbpdu[ULONG_DIG];
1384 char bridgels_tcnbpdu[ULONG_DIG];
1385 char bridgels_rstpbpdu[ULONG_DIG];
1386 char bridgels_txbpdu[ULONG_DIG];
1387 char bridgels_drops[UINT64_DIG]; /* 14.6.1.1.3(d) */
1388 char bridgels_recv[UINT64_DIG]; /* 14.6.1.1.3(a) */
1389 char bridgels_xmit[UINT64_DIG]; /* 14.6.1.1.3(c) */
1390 } bridge_link_statfields_buf_t;
1391
1392 static ofmt_field_t bridge_link_statfields[] = {
1393 /* name, field width, offset, callback */
1394 { "LINK", 12,
1395 offsetof(bridge_link_statfields_buf_t, bridgels_link), print_default_cb },
1396 { "CFGBPDU", 9,
1397 offsetof(bridge_link_statfields_buf_t, bridgels_cfgbpdu),
1398 print_default_cb },
1399 { "TCNBPDU", 9,
1400 offsetof(bridge_link_statfields_buf_t, bridgels_tcnbpdu),
1401 print_default_cb },
1402 { "RSTPBPDU", 9,
1403 offsetof(bridge_link_statfields_buf_t, bridgels_rstpbpdu),
1404 print_default_cb },
1405 { "TXBPDU", 9,
1406 offsetof(bridge_link_statfields_buf_t, bridgels_txbpdu), print_default_cb },
1407 { "DROPS", 9,
1408 offsetof(bridge_link_statfields_buf_t, bridgels_drops), print_default_cb },
1409 { "RECV", 9,
1410 offsetof(bridge_link_statfields_buf_t, bridgels_recv), print_default_cb },
1411 { "XMIT", 9,
1412 offsetof(bridge_link_statfields_buf_t, bridgels_xmit), print_default_cb },
1413 { NULL, 0, 0, NULL}};
1414
1415 /*
1416 * structures for 'dladm show-bridge -f'. These are based in part on
1417 * section 14.7.6.3.3 of IEEE 802.1D-2004.
1418 */
1419 typedef struct bridge_fwd_fields_buf_s {
1420 char bridgef_dest[18]; /* 14.7.6.3.3(a) */
1421 char bridgef_age[8];
1422 char bridgef_flags[6];
1423 char bridgef_output[MAXLINKNAMELEN]; /* 14.7.6.3.3(c) */
1424 } bridge_fwd_fields_buf_t;
1425
1426 static ofmt_field_t bridge_fwd_fields[] = {
1427 /* name, field width, offset, callback */
1428 { "DEST", 17,
1429 offsetof(bridge_fwd_fields_buf_t, bridgef_dest), print_default_cb },
1430 { "AGE", 7,
1431 offsetof(bridge_fwd_fields_buf_t, bridgef_age), print_default_cb },
1432 { "FLAGS", 6,
1433 offsetof(bridge_fwd_fields_buf_t, bridgef_flags), print_default_cb },
1434 { "OUTPUT", 12,
1435 offsetof(bridge_fwd_fields_buf_t, bridgef_output), print_default_cb },
1436 { NULL, 0, 0, NULL}};
1437
1438 /*
1439 * structures for 'dladm show-bridge -t'.
1440 */
1441 typedef struct bridge_trill_fields_buf_s {
1442 char bridget_nick[6];
1443 char bridget_flags[6];
1444 char bridget_link[MAXLINKNAMELEN];
1445 char bridget_nexthop[18];
1446 } bridge_trill_fields_buf_t;
1447
1448 static ofmt_field_t bridge_trill_fields[] = {
1449 /* name, field width, offset, callback */
1450 { "NICK", 5,
1451 offsetof(bridge_trill_fields_buf_t, bridget_nick), print_default_cb },
1452 { "FLAGS", 6,
1453 offsetof(bridge_trill_fields_buf_t, bridget_flags), print_default_cb },
1454 { "LINK", 12,
1455 offsetof(bridge_trill_fields_buf_t, bridget_link), print_default_cb },
1456 { "NEXTHOP", 17,
1457 offsetof(bridge_trill_fields_buf_t, bridget_nexthop), print_default_cb },
1458 { NULL, 0, 0, NULL}};
1459
1460 static const struct option overlay_create_lopts[] = {
1461 { "encap", required_argument, NULL, 'e' },
1462 { "prop", required_argument, NULL, 'p' },
1463 { "search", required_argument, NULL, 's' },
1464 { "temporary", no_argument, NULL, 't' },
1465 { "vnetid", required_argument, NULL, 'v' },
1466 { NULL, 0, NULL, 0 }
1467 };
1468
1469 static const struct option overlay_modify_lopts[] = {
1470 { "delete-entry", required_argument, NULL, 'd' },
1471 { "flush-table", no_argument, NULL, 'f' },
1472 { "set-entry", required_argument, NULL, 's' },
1473 { NULL, 0, NULL, 0 }
1474 };
1475
1476 static const struct option overlay_show_lopts[] = {
1477 { "fma", no_argument, NULL, 'f' },
1478 { "target", no_argument, NULL, 't' },
1479 { "parsable", no_argument, NULL, 'p' },
1480 { "parseable", no_argument, NULL, 'p' },
1481 { "output", required_argument, NULL, 'o' },
1482 { NULL, 0, NULL, 0 }
1483 };
1484
1485 /*
1486 * Structures for dladm show-overlay
1487 */
1488 typedef enum {
1489 OVERLAY_LINK,
1490 OVERLAY_PROPERTY,
1491 OVERLAY_PERM,
1492 OVERLAY_REQ,
1493 OVERLAY_VALUE,
1494 OVERLAY_DEFAULT,
1495 OVERLAY_POSSIBLE
1496 } overlay_field_index_t;
1497
1498 static const ofmt_field_t overlay_fields[] = {
1499 /* name, field width, index */
1500 { "LINK", 19, OVERLAY_LINK, print_overlay_cb },
1501 { "PROPERTY", 19, OVERLAY_PROPERTY, print_overlay_cb },
1502 { "PERM", 5, OVERLAY_PERM, print_overlay_cb },
1503 { "REQ", 4, OVERLAY_REQ, print_overlay_cb },
1504 { "VALUE", 11, OVERLAY_VALUE, print_overlay_cb },
1505 { "DEFAULT", 10, OVERLAY_DEFAULT, print_overlay_cb },
1506 { "POSSIBLE", 10, OVERLAY_POSSIBLE, print_overlay_cb },
1507 { NULL, 0, 0, NULL }
1508 };
1509
1510 typedef enum {
1511 OVERLAY_FMA_LINK,
1512 OVERLAY_FMA_STATUS,
1513 OVERLAY_FMA_DETAILS
1514 } overlay_fma_field_index_t;
1515
1516 static const ofmt_field_t overlay_fma_fields[] = {
1517 { "LINK", 20, OVERLAY_FMA_LINK, print_overlay_fma_cb },
1518 { "STATUS", 8, OVERLAY_FMA_STATUS, print_overlay_fma_cb },
1519 { "DETAILS", 52, OVERLAY_FMA_DETAILS, print_overlay_fma_cb },
1520 { NULL, 0, 0, NULL }
1521 };
1522
1523 typedef enum {
1524 OVERLAY_TARG_LINK,
1525 OVERLAY_TARG_TARGET,
1526 OVERLAY_TARG_DEST
1527 } overlay_targ_field_index_t;
1528
1529 static const ofmt_field_t overlay_targ_fields[] = {
1530 { "LINK", 20, OVERLAY_TARG_LINK, print_overlay_targ_cb },
1531 { "TARGET", 18, OVERLAY_TARG_TARGET, print_overlay_targ_cb },
1532 { "DESTINATION", 42, OVERLAY_TARG_DEST, print_overlay_targ_cb },
1533 { NULL, 0, 0, NULL }
1534 };
1535
1536 static char *progname;
1537 static sig_atomic_t signalled;
1538
1539 /*
1540 * Handle to libdladm. Opened in main() before the sub-command
1541 * specific function is called.
1542 */
1543 static dladm_handle_t handle = NULL;
1544
1545 /*
1546 * Global error list that all routines can use. It's initialized by the main
1547 * code.
1548 */
1549 static dladm_errlist_t errlist;
1550
1551 #define DLADM_ETHERSTUB_NAME "etherstub"
1552 #define DLADM_IS_ETHERSTUB(id) (id == DATALINK_INVALID_LINKID)
1553
1554 static void
usage_text(void)1555 usage_text(void)
1556 {
1557 int i;
1558 cmd_t *cmdp;
1559 (void) fprintf(stderr, gettext("usage: dladm <subcommand> <args> ..."
1560 "\n"));
1561 for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {
1562 cmdp = &cmds[i];
1563 if (cmdp->c_usage != NULL)
1564 (void) fprintf(stderr, "%s\n", gettext(cmdp->c_usage));
1565 }
1566 }
1567
1568 static void
usage(void)1569 usage(void)
1570 {
1571 usage_text();
1572
1573 /* close dladm handle if it was opened */
1574 if (handle != NULL)
1575 dladm_close(handle);
1576
1577 exit(EXIT_FAILURE);
1578 }
1579
1580 static void
do_help(int argc __unused,char * argv[]__unused,const char * use __unused)1581 do_help(int argc __unused, char *argv[] __unused, const char *use __unused)
1582 {
1583 usage_text();
1584 }
1585
1586 int
main(int argc,char * argv[])1587 main(int argc, char *argv[])
1588 {
1589 int i;
1590 cmd_t *cmdp;
1591 dladm_status_t status;
1592
1593 (void) setlocale(LC_ALL, "");
1594 #if !defined(TEXT_DOMAIN)
1595 #define TEXT_DOMAIN "SYS_TEST"
1596 #endif
1597 (void) textdomain(TEXT_DOMAIN);
1598
1599 if ((progname = strrchr(argv[0], '/')) == NULL)
1600 progname = argv[0];
1601 else
1602 progname++;
1603
1604 if (argc < 2) {
1605 argv[1] = "show-link";
1606 argc = 2;
1607 }
1608
1609 for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {
1610 cmdp = &cmds[i];
1611 if (strcmp(argv[1], cmdp->c_name) == 0) {
1612 /* Open the libdladm handle */
1613 if ((status = dladm_open(&handle)) != DLADM_STATUS_OK) {
1614 die_dlerr(status,
1615 "could not open /dev/dld");
1616 }
1617
1618 dladm_errlist_init(&errlist);
1619
1620 cmdp->c_fn(argc - 1, &argv[1], cmdp->c_usage);
1621
1622 dladm_close(handle);
1623 return (EXIT_SUCCESS);
1624 }
1625 }
1626
1627 (void) fprintf(stderr, gettext("%s: unknown subcommand '%s'\n"),
1628 progname, argv[1]);
1629 usage();
1630 return (EXIT_FAILURE);
1631 }
1632
1633 /*ARGSUSED*/
1634 static int
show_usage_date(dladm_usage_t * usage,void * arg)1635 show_usage_date(dladm_usage_t *usage, void *arg)
1636 {
1637 show_usage_state_t *state = (show_usage_state_t *)arg;
1638 time_t stime;
1639 char timebuf[20];
1640 dladm_status_t status;
1641 uint32_t flags;
1642
1643 /*
1644 * Only show usage information for existing links unless '-a'
1645 * is specified.
1646 */
1647 if (!state->us_showall) {
1648 if ((status = dladm_name2info(handle, usage->du_name,
1649 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1650 return (status);
1651 }
1652 if ((flags & DLADM_OPT_ACTIVE) == 0)
1653 return (DLADM_STATUS_LINKINVAL);
1654 }
1655
1656 stime = usage->du_stime;
1657 (void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",
1658 localtime(&stime));
1659 (void) printf("%s\n", timebuf);
1660
1661 return (DLADM_STATUS_OK);
1662 }
1663
1664 static int
show_usage_time(dladm_usage_t * usage,void * arg)1665 show_usage_time(dladm_usage_t *usage, void *arg)
1666 {
1667 show_usage_state_t *state = (show_usage_state_t *)arg;
1668 char buf[DLADM_STRSIZE];
1669 usage_l_fields_buf_t ubuf;
1670 time_t time;
1671 double bw;
1672 dladm_status_t status;
1673 uint32_t flags;
1674
1675 /*
1676 * Only show usage information for existing links unless '-a'
1677 * is specified.
1678 */
1679 if (!state->us_showall) {
1680 if ((status = dladm_name2info(handle, usage->du_name,
1681 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1682 return (status);
1683 }
1684 if ((flags & DLADM_OPT_ACTIVE) == 0)
1685 return (DLADM_STATUS_LINKINVAL);
1686 }
1687
1688 if (state->us_plot) {
1689 if (!state->us_printheader) {
1690 if (state->us_first) {
1691 (void) printf("# Time");
1692 state->us_first = B_FALSE;
1693 }
1694 (void) printf(" %s", usage->du_name);
1695 if (usage->du_last) {
1696 (void) printf("\n");
1697 state->us_first = B_TRUE;
1698 state->us_printheader = B_TRUE;
1699 }
1700 } else {
1701 if (state->us_first) {
1702 time = usage->du_etime;
1703 (void) strftime(buf, sizeof (buf), "%T",
1704 localtime(&time));
1705 state->us_first = B_FALSE;
1706 (void) printf("%s", buf);
1707 }
1708 bw = (double)usage->du_bandwidth/1000;
1709 (void) printf(" %.2f", bw);
1710 if (usage->du_last) {
1711 (void) printf("\n");
1712 state->us_first = B_TRUE;
1713 }
1714 }
1715 return (DLADM_STATUS_OK);
1716 }
1717
1718 bzero(&ubuf, sizeof (ubuf));
1719
1720 (void) snprintf(ubuf.usage_l_link, sizeof (ubuf.usage_l_link), "%s",
1721 usage->du_name);
1722 time = usage->du_stime;
1723 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
1724 (void) snprintf(ubuf.usage_l_stime, sizeof (ubuf.usage_l_stime), "%s",
1725 buf);
1726 time = usage->du_etime;
1727 (void) strftime(buf, sizeof (buf), "%T", localtime(&time));
1728 (void) snprintf(ubuf.usage_l_etime, sizeof (ubuf.usage_l_etime), "%s",
1729 buf);
1730 (void) snprintf(ubuf.usage_l_rbytes, sizeof (ubuf.usage_l_rbytes),
1731 "%llu", usage->du_rbytes);
1732 (void) snprintf(ubuf.usage_l_obytes, sizeof (ubuf.usage_l_obytes),
1733 "%llu", usage->du_obytes);
1734 (void) snprintf(ubuf.usage_l_bandwidth, sizeof (ubuf.usage_l_bandwidth),
1735 "%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));
1736
1737 ofmt_print(state->us_ofmt, &ubuf);
1738 return (DLADM_STATUS_OK);
1739 }
1740
1741 static int
show_usage_res(dladm_usage_t * usage,void * arg)1742 show_usage_res(dladm_usage_t *usage, void *arg)
1743 {
1744 show_usage_state_t *state = (show_usage_state_t *)arg;
1745 char buf[DLADM_STRSIZE];
1746 usage_fields_buf_t ubuf;
1747 dladm_status_t status;
1748 uint32_t flags;
1749
1750 /*
1751 * Only show usage information for existing links unless '-a'
1752 * is specified.
1753 */
1754 if (!state->us_showall) {
1755 if ((status = dladm_name2info(handle, usage->du_name,
1756 NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {
1757 return (status);
1758 }
1759 if ((flags & DLADM_OPT_ACTIVE) == 0)
1760 return (DLADM_STATUS_LINKINVAL);
1761 }
1762
1763 bzero(&ubuf, sizeof (ubuf));
1764
1765 (void) snprintf(ubuf.usage_link, sizeof (ubuf.usage_link), "%s",
1766 usage->du_name);
1767 (void) snprintf(ubuf.usage_duration, sizeof (ubuf.usage_duration),
1768 "%llu", usage->du_duration);
1769 (void) snprintf(ubuf.usage_ipackets, sizeof (ubuf.usage_ipackets),
1770 "%llu", usage->du_ipackets);
1771 (void) snprintf(ubuf.usage_rbytes, sizeof (ubuf.usage_rbytes),
1772 "%llu", usage->du_rbytes);
1773 (void) snprintf(ubuf.usage_opackets, sizeof (ubuf.usage_opackets),
1774 "%llu", usage->du_opackets);
1775 (void) snprintf(ubuf.usage_obytes, sizeof (ubuf.usage_obytes),
1776 "%llu", usage->du_obytes);
1777 (void) snprintf(ubuf.usage_bandwidth, sizeof (ubuf.usage_bandwidth),
1778 "%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));
1779
1780 ofmt_print(state->us_ofmt, &ubuf);
1781
1782 return (DLADM_STATUS_OK);
1783 }
1784
1785 static boolean_t
valid_formatspec(char * formatspec_str)1786 valid_formatspec(char *formatspec_str)
1787 {
1788 if (strcmp(formatspec_str, "gnuplot") == 0)
1789 return (B_TRUE);
1790 return (B_FALSE);
1791
1792 }
1793
1794 /*ARGSUSED*/
1795 static void
do_show_usage(int argc,char * argv[],const char * use)1796 do_show_usage(int argc, char *argv[], const char *use)
1797 {
1798 char *file = NULL;
1799 int opt;
1800 dladm_status_t status;
1801 boolean_t d_arg = B_FALSE;
1802 char *stime = NULL;
1803 char *etime = NULL;
1804 char *resource = NULL;
1805 show_usage_state_t state;
1806 boolean_t o_arg = B_FALSE;
1807 boolean_t F_arg = B_FALSE;
1808 char *fields_str = NULL;
1809 char *formatspec_str = NULL;
1810 char *all_l_fields =
1811 "link,start,end,rbytes,obytes,bandwidth";
1812 ofmt_handle_t ofmt;
1813 ofmt_status_t oferr;
1814 uint_t ofmtflags = 0;
1815
1816 bzero(&state, sizeof (show_usage_state_t));
1817 state.us_parsable = B_FALSE;
1818 state.us_printheader = B_FALSE;
1819 state.us_plot = B_FALSE;
1820 state.us_first = B_TRUE;
1821
1822 while ((opt = getopt_long(argc, argv, "das:e:o:f:F:",
1823 usage_opts, NULL)) != -1) {
1824 switch (opt) {
1825 case 'd':
1826 d_arg = B_TRUE;
1827 break;
1828 case 'a':
1829 state.us_showall = B_TRUE;
1830 break;
1831 case 'f':
1832 file = optarg;
1833 break;
1834 case 's':
1835 stime = optarg;
1836 break;
1837 case 'e':
1838 etime = optarg;
1839 break;
1840 case 'o':
1841 o_arg = B_TRUE;
1842 fields_str = optarg;
1843 break;
1844 case 'F':
1845 state.us_plot = F_arg = B_TRUE;
1846 formatspec_str = optarg;
1847 break;
1848 default:
1849 die_opterr(optopt, opt, use);
1850 break;
1851 }
1852 }
1853
1854 if (file == NULL)
1855 die("show-usage requires a file");
1856
1857 if (optind == (argc-1)) {
1858 uint32_t flags;
1859
1860 resource = argv[optind];
1861 if (!state.us_showall &&
1862 (((status = dladm_name2info(handle, resource, NULL, &flags,
1863 NULL, NULL)) != DLADM_STATUS_OK) ||
1864 ((flags & DLADM_OPT_ACTIVE) == 0))) {
1865 die("invalid link: '%s'", resource);
1866 }
1867 }
1868
1869 if (F_arg && d_arg)
1870 die("incompatible -d and -F options");
1871
1872 if (F_arg && valid_formatspec(formatspec_str) == B_FALSE)
1873 die("Format specifier %s not supported", formatspec_str);
1874
1875 if (state.us_parsable)
1876 ofmtflags |= OFMT_PARSABLE;
1877
1878 if (resource == NULL && stime == NULL && etime == NULL) {
1879 oferr = ofmt_open(fields_str, usage_fields, ofmtflags, 0,
1880 &ofmt);
1881 } else {
1882 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
1883 fields_str = all_l_fields;
1884 oferr = ofmt_open(fields_str, usage_l_fields, ofmtflags, 0,
1885 &ofmt);
1886
1887 }
1888 ofmt_check(oferr, state.us_parsable, ofmt, die, warn);
1889 state.us_ofmt = ofmt;
1890
1891 if (d_arg) {
1892 /* Print log dates */
1893 status = dladm_usage_dates(show_usage_date,
1894 DLADM_LOGTYPE_LINK, file, resource, &state);
1895 } else if (resource == NULL && stime == NULL && etime == NULL &&
1896 !F_arg) {
1897 /* Print summary */
1898 status = dladm_usage_summary(show_usage_res,
1899 DLADM_LOGTYPE_LINK, file, &state);
1900 } else if (resource != NULL) {
1901 /* Print log entries for named resource */
1902 status = dladm_walk_usage_res(show_usage_time,
1903 DLADM_LOGTYPE_LINK, file, resource, stime, etime, &state);
1904 } else {
1905 /* Print time and information for each link */
1906 status = dladm_walk_usage_time(show_usage_time,
1907 DLADM_LOGTYPE_LINK, file, stime, etime, &state);
1908 }
1909
1910 if (status != DLADM_STATUS_OK)
1911 die_dlerr(status, "show-usage");
1912 ofmt_close(ofmt);
1913 }
1914
1915 static void
do_create_aggr(int argc,char * argv[],const char * use)1916 do_create_aggr(int argc, char *argv[], const char *use)
1917 {
1918 int option;
1919 int key = 0;
1920 uint32_t policy = AGGR_POLICY_L4;
1921 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
1922 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
1923 dladm_aggr_port_attr_db_t port[MAXPORT];
1924 uint_t n, ndev, nlink;
1925 uint8_t mac_addr[ETHERADDRL];
1926 boolean_t mac_addr_fixed = B_FALSE;
1927 boolean_t P_arg = B_FALSE;
1928 boolean_t l_arg = B_FALSE;
1929 boolean_t u_arg = B_FALSE;
1930 boolean_t T_arg = B_FALSE;
1931 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
1932 char *altroot = NULL;
1933 char name[MAXLINKNAMELEN];
1934 char *devs[MAXPORT];
1935 char *links[MAXPORT];
1936 dladm_status_t status;
1937 dladm_status_t pstatus;
1938 char propstr[DLADM_STRSIZE];
1939 dladm_arg_list_t *proplist = NULL;
1940 int i;
1941 datalink_id_t linkid;
1942
1943 ndev = nlink = opterr = 0;
1944 bzero(propstr, DLADM_STRSIZE);
1945
1946 while ((option = getopt_long(argc, argv, ":d:l:L:P:R:tfu:T:p:",
1947 lopts, NULL)) != -1) {
1948 switch (option) {
1949 case 'd':
1950 if (ndev + nlink >= MAXPORT)
1951 die("too many ports specified");
1952
1953 devs[ndev++] = optarg;
1954 break;
1955 case 'P':
1956 if (P_arg)
1957 die_optdup(option);
1958
1959 P_arg = B_TRUE;
1960 if (!dladm_aggr_str2policy(optarg, &policy))
1961 die("invalid policy '%s'", optarg);
1962 break;
1963 case 'u':
1964 if (u_arg)
1965 die_optdup(option);
1966
1967 u_arg = B_TRUE;
1968 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
1969 mac_addr))
1970 die("invalid MAC address '%s'", optarg);
1971 break;
1972 case 'l':
1973 if (isdigit(optarg[strlen(optarg) - 1])) {
1974
1975 /*
1976 * Ended with digit, possibly a link name.
1977 */
1978 if (ndev + nlink >= MAXPORT)
1979 die("too many ports specified");
1980
1981 links[nlink++] = optarg;
1982 break;
1983 }
1984 /* FALLTHROUGH */
1985 case 'L':
1986 if (l_arg)
1987 die_optdup(option);
1988
1989 l_arg = B_TRUE;
1990 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
1991 die("invalid LACP mode '%s'", optarg);
1992 break;
1993 case 'T':
1994 if (T_arg)
1995 die_optdup(option);
1996
1997 T_arg = B_TRUE;
1998 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
1999 die("invalid LACP timer value '%s'", optarg);
2000 break;
2001 case 't':
2002 flags &= ~DLADM_OPT_PERSIST;
2003 break;
2004 case 'f':
2005 flags |= DLADM_OPT_FORCE;
2006 break;
2007 case 'R':
2008 altroot = optarg;
2009 break;
2010 case 'p':
2011 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
2012 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
2013 DLADM_STRSIZE)
2014 die("property list too long '%s'", propstr);
2015 break;
2016
2017 default:
2018 die_opterr(optopt, option, use);
2019 break;
2020 }
2021 }
2022
2023 if (ndev + nlink == 0)
2024 usage();
2025
2026 /* get key value or the aggregation name (required last argument) */
2027 if (optind != (argc-1))
2028 usage();
2029
2030 if (!str2int(argv[optind], &key)) {
2031 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >=
2032 MAXLINKNAMELEN) {
2033 die("link name too long '%s'", argv[optind]);
2034 }
2035
2036 if (!dladm_valid_linkname(name))
2037 die("invalid link name '%s'", argv[optind]);
2038 } else {
2039 (void) snprintf(name, MAXLINKNAMELEN, "aggr%d", key);
2040 }
2041
2042 if (altroot != NULL)
2043 altroot_cmd(altroot, argc, argv);
2044
2045 for (n = 0; n < ndev; n++) {
2046 if ((status = dladm_dev2linkid(handle, devs[n],
2047 &port[n].lp_linkid)) != DLADM_STATUS_OK) {
2048 die_dlerr(status, "invalid dev name '%s'", devs[n]);
2049 }
2050 }
2051
2052 for (n = 0; n < nlink; n++) {
2053 if ((status = dladm_name2info(handle, links[n],
2054 &port[ndev + n].lp_linkid, NULL, NULL, NULL)) !=
2055 DLADM_STATUS_OK) {
2056 die_dlerr(status, "invalid link name '%s'", links[n]);
2057 }
2058 }
2059
2060 status = dladm_aggr_create(handle, name, key, ndev + nlink, port,
2061 policy, mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode,
2062 lacp_timer, flags);
2063 if (status != DLADM_STATUS_OK)
2064 goto done;
2065
2066 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
2067 != DLADM_STATUS_OK)
2068 die("invalid aggregation property");
2069
2070 if (proplist == NULL)
2071 return;
2072
2073 status = dladm_name2info(handle, name, &linkid, NULL, NULL, NULL);
2074 if (status != DLADM_STATUS_OK)
2075 goto done;
2076
2077 for (i = 0; i < proplist->al_count; i++) {
2078 dladm_arg_info_t *aip = &proplist->al_info[i];
2079
2080 pstatus = dladm_set_linkprop(handle, linkid, aip->ai_name,
2081 aip->ai_val, aip->ai_count, flags);
2082
2083 if (pstatus != DLADM_STATUS_OK) {
2084 die_dlerr(pstatus,
2085 "aggr creation succeeded but "
2086 "could not set property '%s'", aip->ai_name);
2087 }
2088 }
2089 done:
2090 dladm_free_props(proplist);
2091 if (status != DLADM_STATUS_OK) {
2092 if (status == DLADM_STATUS_NONOTIF) {
2093 die("not all links have link up/down detection; must "
2094 "use -f (see dladm(8))");
2095 } else {
2096 die_dlerr(status, "create operation failed");
2097 }
2098 }
2099 }
2100
2101 /*
2102 * arg is either the key or the aggr name. Validate it and convert it to
2103 * the linkid if altroot is NULL.
2104 */
2105 static dladm_status_t
i_dladm_aggr_get_linkid(const char * altroot,const char * arg,datalink_id_t * linkidp,uint32_t flags)2106 i_dladm_aggr_get_linkid(const char *altroot, const char *arg,
2107 datalink_id_t *linkidp, uint32_t flags)
2108 {
2109 int key = 0;
2110 char *aggr = NULL;
2111 dladm_status_t status;
2112
2113 if (!str2int(arg, &key))
2114 aggr = (char *)arg;
2115
2116 if (aggr == NULL && key == 0)
2117 return (DLADM_STATUS_LINKINVAL);
2118
2119 if (altroot != NULL)
2120 return (DLADM_STATUS_OK);
2121
2122 if (aggr != NULL) {
2123 status = dladm_name2info(handle, aggr, linkidp, NULL, NULL,
2124 NULL);
2125 } else {
2126 status = dladm_key2linkid(handle, key, linkidp, flags);
2127 }
2128
2129 return (status);
2130 }
2131
2132 static void
do_delete_aggr(int argc,char * argv[],const char * use)2133 do_delete_aggr(int argc, char *argv[], const char *use)
2134 {
2135 int option;
2136 char *altroot = NULL;
2137 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2138 dladm_status_t status;
2139 datalink_id_t linkid;
2140
2141 opterr = 0;
2142 while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {
2143 switch (option) {
2144 case 't':
2145 flags &= ~DLADM_OPT_PERSIST;
2146 break;
2147 case 'R':
2148 altroot = optarg;
2149 break;
2150 default:
2151 die_opterr(optopt, option, use);
2152 break;
2153 }
2154 }
2155
2156 /* get key value or the aggregation name (required last argument) */
2157 if (optind != (argc-1))
2158 usage();
2159
2160 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2161 if (status != DLADM_STATUS_OK)
2162 goto done;
2163
2164 if (altroot != NULL)
2165 altroot_cmd(altroot, argc, argv);
2166
2167 status = dladm_aggr_delete(handle, linkid, flags);
2168 done:
2169 if (status != DLADM_STATUS_OK)
2170 die_dlerr(status, "delete operation failed");
2171 }
2172
2173 static void
do_add_aggr(int argc,char * argv[],const char * use)2174 do_add_aggr(int argc, char *argv[], const char *use)
2175 {
2176 int option;
2177 uint_t n, ndev, nlink;
2178 char *altroot = NULL;
2179 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2180 datalink_id_t linkid;
2181 dladm_status_t status;
2182 dladm_aggr_port_attr_db_t port[MAXPORT];
2183 char *devs[MAXPORT];
2184 char *links[MAXPORT];
2185
2186 ndev = nlink = opterr = 0;
2187 while ((option = getopt_long(argc, argv, ":d:l:R:tf", lopts,
2188 NULL)) != -1) {
2189 switch (option) {
2190 case 'd':
2191 if (ndev + nlink >= MAXPORT)
2192 die("too many ports specified");
2193
2194 devs[ndev++] = optarg;
2195 break;
2196 case 'l':
2197 if (ndev + nlink >= MAXPORT)
2198 die("too many ports specified");
2199
2200 links[nlink++] = optarg;
2201 break;
2202 case 't':
2203 flags &= ~DLADM_OPT_PERSIST;
2204 break;
2205 case 'f':
2206 flags |= DLADM_OPT_FORCE;
2207 break;
2208 case 'R':
2209 altroot = optarg;
2210 break;
2211 default:
2212 die_opterr(optopt, option, use);
2213 break;
2214 }
2215 }
2216
2217 if (ndev + nlink == 0)
2218 usage();
2219
2220 /* get key value or the aggregation name (required last argument) */
2221 if (optind != (argc-1))
2222 usage();
2223
2224 if ((status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid,
2225 flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST))) !=
2226 DLADM_STATUS_OK) {
2227 goto done;
2228 }
2229
2230 if (altroot != NULL)
2231 altroot_cmd(altroot, argc, argv);
2232
2233 for (n = 0; n < ndev; n++) {
2234 if ((status = dladm_dev2linkid(handle, devs[n],
2235 &(port[n].lp_linkid))) != DLADM_STATUS_OK) {
2236 die_dlerr(status, "invalid <dev> '%s'", devs[n]);
2237 }
2238 }
2239
2240 for (n = 0; n < nlink; n++) {
2241 if ((status = dladm_name2info(handle, links[n],
2242 &port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=
2243 DLADM_STATUS_OK) {
2244 die_dlerr(status, "invalid <link> '%s'", links[n]);
2245 }
2246 }
2247
2248 status = dladm_aggr_add(handle, linkid, ndev + nlink, port, flags);
2249 done:
2250 if (status != DLADM_STATUS_OK) {
2251 /*
2252 * checking DLADM_STATUS_NOTSUP is a temporary workaround
2253 * and should be removed once 6399681 is fixed.
2254 */
2255 if (status == DLADM_STATUS_NOTSUP) {
2256 die("add operation failed: link capabilities don't "
2257 "match");
2258 } else if (status == DLADM_STATUS_NONOTIF) {
2259 die("not all links have link up/down detection; must "
2260 "use -f (see dladm(8))");
2261 } else {
2262 die_dlerr(status, "add operation failed");
2263 }
2264 }
2265 }
2266
2267 static void
do_remove_aggr(int argc,char * argv[],const char * use)2268 do_remove_aggr(int argc, char *argv[], const char *use)
2269 {
2270 int option;
2271 dladm_aggr_port_attr_db_t port[MAXPORT];
2272 uint_t n, ndev, nlink;
2273 char *devs[MAXPORT];
2274 char *links[MAXPORT];
2275 char *altroot = NULL;
2276 uint32_t flags;
2277 datalink_id_t linkid;
2278 dladm_status_t status;
2279
2280 flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2281 ndev = nlink = opterr = 0;
2282 while ((option = getopt_long(argc, argv, ":d:l:R:t",
2283 lopts, NULL)) != -1) {
2284 switch (option) {
2285 case 'd':
2286 if (ndev + nlink >= MAXPORT)
2287 die("too many ports specified");
2288
2289 devs[ndev++] = optarg;
2290 break;
2291 case 'l':
2292 if (ndev + nlink >= MAXPORT)
2293 die("too many ports specified");
2294
2295 links[nlink++] = optarg;
2296 break;
2297 case 't':
2298 flags &= ~DLADM_OPT_PERSIST;
2299 break;
2300 case 'R':
2301 altroot = optarg;
2302 break;
2303 default:
2304 die_opterr(optopt, option, use);
2305 break;
2306 }
2307 }
2308
2309 if (ndev + nlink == 0)
2310 usage();
2311
2312 /* get key value or the aggregation name (required last argument) */
2313 if (optind != (argc-1))
2314 usage();
2315
2316 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2317 if (status != DLADM_STATUS_OK)
2318 goto done;
2319
2320 if (altroot != NULL)
2321 altroot_cmd(altroot, argc, argv);
2322
2323 for (n = 0; n < ndev; n++) {
2324 if ((status = dladm_dev2linkid(handle, devs[n],
2325 &(port[n].lp_linkid))) != DLADM_STATUS_OK) {
2326 die_dlerr(status, "invalid <dev> '%s'", devs[n]);
2327 }
2328 }
2329
2330 for (n = 0; n < nlink; n++) {
2331 if ((status = dladm_name2info(handle, links[n],
2332 &port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=
2333 DLADM_STATUS_OK) {
2334 die_dlerr(status, "invalid <link> '%s'", links[n]);
2335 }
2336 }
2337
2338 status = dladm_aggr_remove(handle, linkid, ndev + nlink, port, flags);
2339 done:
2340 if (status != DLADM_STATUS_OK)
2341 die_dlerr(status, "remove operation failed");
2342 }
2343
2344 static void
do_modify_aggr(int argc,char * argv[],const char * use)2345 do_modify_aggr(int argc, char *argv[], const char *use)
2346 {
2347 int option;
2348 uint32_t policy = AGGR_POLICY_L4;
2349 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
2350 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
2351 uint8_t mac_addr[ETHERADDRL];
2352 boolean_t mac_addr_fixed = B_FALSE;
2353 uint8_t modify_mask = 0;
2354 char *altroot = NULL;
2355 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
2356 datalink_id_t linkid;
2357 dladm_status_t status;
2358
2359 opterr = 0;
2360 while ((option = getopt_long(argc, argv, ":L:l:P:R:tu:T:", lopts,
2361 NULL)) != -1) {
2362 switch (option) {
2363 case 'P':
2364 if (modify_mask & DLADM_AGGR_MODIFY_POLICY)
2365 die_optdup(option);
2366
2367 modify_mask |= DLADM_AGGR_MODIFY_POLICY;
2368
2369 if (!dladm_aggr_str2policy(optarg, &policy))
2370 die("invalid policy '%s'", optarg);
2371 break;
2372 case 'u':
2373 if (modify_mask & DLADM_AGGR_MODIFY_MAC)
2374 die_optdup(option);
2375
2376 modify_mask |= DLADM_AGGR_MODIFY_MAC;
2377
2378 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
2379 mac_addr))
2380 die("invalid MAC address '%s'", optarg);
2381 break;
2382 case 'l':
2383 case 'L':
2384 if (modify_mask & DLADM_AGGR_MODIFY_LACP_MODE)
2385 die_optdup(option);
2386
2387 modify_mask |= DLADM_AGGR_MODIFY_LACP_MODE;
2388
2389 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
2390 die("invalid LACP mode '%s'", optarg);
2391 break;
2392 case 'T':
2393 if (modify_mask & DLADM_AGGR_MODIFY_LACP_TIMER)
2394 die_optdup(option);
2395
2396 modify_mask |= DLADM_AGGR_MODIFY_LACP_TIMER;
2397
2398 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
2399 die("invalid LACP timer value '%s'", optarg);
2400 break;
2401 case 't':
2402 flags &= ~DLADM_OPT_PERSIST;
2403 break;
2404 case 'R':
2405 altroot = optarg;
2406 break;
2407 default:
2408 die_opterr(optopt, option, use);
2409 break;
2410 }
2411 }
2412
2413 if (modify_mask == 0)
2414 die("at least one of the -PulT options must be specified");
2415
2416 /* get key value or the aggregation name (required last argument) */
2417 if (optind != (argc-1))
2418 usage();
2419
2420 status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);
2421 if (status != DLADM_STATUS_OK)
2422 goto done;
2423
2424 if (altroot != NULL)
2425 altroot_cmd(altroot, argc, argv);
2426
2427 status = dladm_aggr_modify(handle, linkid, modify_mask, policy,
2428 mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode, lacp_timer,
2429 flags);
2430
2431 done:
2432 if (status != DLADM_STATUS_OK)
2433 die_dlerr(status, "modify operation failed");
2434 }
2435
2436 /*ARGSUSED*/
2437 static void
do_up_aggr(int argc,char * argv[],const char * use)2438 do_up_aggr(int argc, char *argv[], const char *use)
2439 {
2440 datalink_id_t linkid = DATALINK_ALL_LINKID;
2441 dladm_status_t status;
2442
2443 /*
2444 * get the key or the name of the aggregation (optional last argument)
2445 */
2446 if (argc == 2) {
2447 if ((status = i_dladm_aggr_get_linkid(NULL, argv[1], &linkid,
2448 DLADM_OPT_PERSIST)) != DLADM_STATUS_OK)
2449 goto done;
2450 } else if (argc > 2) {
2451 usage();
2452 }
2453
2454 status = dladm_aggr_up(handle, linkid);
2455 done:
2456 if (status != DLADM_STATUS_OK) {
2457 if (argc == 2) {
2458 die_dlerr(status,
2459 "could not bring up aggregation '%s'", argv[1]);
2460 } else {
2461 die_dlerr(status, "could not bring aggregations up");
2462 }
2463 }
2464 }
2465
2466 static void
do_create_vlan(int argc,char * argv[],const char * use)2467 do_create_vlan(int argc, char *argv[], const char *use)
2468 {
2469 char *link = NULL;
2470 char drv[DLPI_LINKNAME_MAX];
2471 uint_t ppa;
2472 datalink_id_t linkid;
2473 datalink_id_t dev_linkid;
2474 int vid = 0;
2475 int option;
2476 uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2477 char *altroot = NULL;
2478 char vlan[MAXLINKNAMELEN];
2479 char propstr[DLADM_STRSIZE];
2480 dladm_arg_list_t *proplist = NULL;
2481 dladm_status_t status;
2482
2483 opterr = 0;
2484 bzero(propstr, DLADM_STRSIZE);
2485
2486 while ((option = getopt_long(argc, argv, ":tfR:l:v:p:",
2487 lopts, NULL)) != -1) {
2488 switch (option) {
2489 case 'v':
2490 if (vid != 0)
2491 die_optdup(option);
2492
2493 if (!str2int(optarg, &vid) || vid < 1 || vid > 4094)
2494 die("invalid VLAN identifier '%s'", optarg);
2495
2496 break;
2497 case 'l':
2498 if (link != NULL)
2499 die_optdup(option);
2500
2501 link = optarg;
2502 break;
2503 case 't':
2504 flags &= ~DLADM_OPT_PERSIST;
2505 break;
2506 case 'R':
2507 altroot = optarg;
2508 break;
2509 case 'p':
2510 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
2511 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
2512 DLADM_STRSIZE)
2513 die("property list too long '%s'", propstr);
2514 break;
2515 case 'f':
2516 flags |= DLADM_OPT_FORCE;
2517 break;
2518 default:
2519 die_opterr(optopt, option, use);
2520 break;
2521 }
2522 }
2523
2524 /* get vlan name if there is any */
2525 if ((vid == 0) || (link == NULL) || (argc - optind > 1))
2526 usage();
2527
2528 if (optind == (argc - 1)) {
2529 if (strlcpy(vlan, argv[optind], MAXLINKNAMELEN) >=
2530 MAXLINKNAMELEN) {
2531 die("vlan name too long '%s'", argv[optind]);
2532 }
2533 } else {
2534 if ((dlpi_parselink(link, drv, &ppa) != DLPI_SUCCESS) ||
2535 (ppa >= 1000) ||
2536 (dlpi_makelink(vlan, drv, vid * 1000 + ppa) !=
2537 DLPI_SUCCESS)) {
2538 die("invalid link name '%s'", link);
2539 }
2540 }
2541
2542 if (altroot != NULL)
2543 altroot_cmd(altroot, argc, argv);
2544
2545 if (dladm_name2info(handle, link, &dev_linkid, NULL, NULL, NULL) !=
2546 DLADM_STATUS_OK) {
2547 die("invalid link name '%s'", link);
2548 }
2549
2550 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
2551 != DLADM_STATUS_OK)
2552 die("invalid vlan property");
2553
2554 status = dladm_vlan_create(handle, vlan, dev_linkid, vid, proplist,
2555 flags, &linkid);
2556 switch (status) {
2557 case DLADM_STATUS_OK:
2558 break;
2559
2560 case DLADM_STATUS_NOTSUP:
2561 die("VLAN over '%s' may require lowered MTU; must use -f (see "
2562 "dladm(8))", link);
2563 break;
2564
2565 case DLADM_STATUS_LINKBUSY:
2566 die("VLAN over '%s' may not use default_tag ID "
2567 "(see dladm(8))", link);
2568 break;
2569
2570 default:
2571 die_dlerr(status, "create operation failed");
2572 }
2573 }
2574
2575 static void
do_delete_vlan(int argc,char * argv[],const char * use)2576 do_delete_vlan(int argc, char *argv[], const char *use)
2577 {
2578 int option;
2579 uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2580 char *altroot = NULL;
2581 datalink_id_t linkid;
2582 dladm_status_t status;
2583
2584 opterr = 0;
2585 while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {
2586 switch (option) {
2587 case 't':
2588 flags &= ~DLADM_OPT_PERSIST;
2589 break;
2590 case 'R':
2591 altroot = optarg;
2592 break;
2593 default:
2594 die_opterr(optopt, option, use);
2595 break;
2596 }
2597 }
2598
2599 /* get VLAN link name (required last argument) */
2600 if (optind != (argc - 1))
2601 usage();
2602
2603 if (altroot != NULL)
2604 altroot_cmd(altroot, argc, argv);
2605
2606 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
2607 NULL);
2608 if (status != DLADM_STATUS_OK)
2609 goto done;
2610
2611 status = dladm_vlan_delete(handle, linkid, flags);
2612 done:
2613 if (status != DLADM_STATUS_OK)
2614 die_dlerr(status, "delete operation failed");
2615 }
2616
2617 /*ARGSUSED*/
2618 static void
do_up_vlan(int argc,char * argv[],const char * use)2619 do_up_vlan(int argc, char *argv[], const char *use)
2620 {
2621 do_up_vnic_common(argc, argv, use, B_TRUE);
2622 }
2623
2624 static void
do_rename_link(int argc,char * argv[],const char * use)2625 do_rename_link(int argc, char *argv[], const char *use)
2626 {
2627 int option;
2628 char *link1, *link2;
2629 char *altroot = NULL;
2630 dladm_status_t status;
2631
2632 opterr = 0;
2633 while ((option = getopt_long(argc, argv, ":R:", lopts, NULL)) != -1) {
2634 switch (option) {
2635 case 'R':
2636 altroot = optarg;
2637 break;
2638 default:
2639 die_opterr(optopt, option, use);
2640 break;
2641 }
2642 }
2643
2644 /* get link1 and link2 name (required the last 2 arguments) */
2645 if (optind != (argc - 2))
2646 usage();
2647
2648 if (altroot != NULL)
2649 altroot_cmd(altroot, argc, argv);
2650
2651 link1 = argv[optind++];
2652 link2 = argv[optind];
2653 if ((status = dladm_rename_link(handle, link1, link2)) !=
2654 DLADM_STATUS_OK)
2655 die_dlerr(status, "rename operation failed");
2656 }
2657
2658 /*ARGSUSED*/
2659 static void
do_delete_phys(int argc,char * argv[],const char * use)2660 do_delete_phys(int argc, char *argv[], const char *use)
2661 {
2662 datalink_id_t linkid = DATALINK_ALL_LINKID;
2663 dladm_status_t status;
2664
2665 /* get link name (required the last argument) */
2666 if (argc > 2)
2667 usage();
2668
2669 if (argc == 2) {
2670 if ((status = dladm_name2info(handle, argv[1], &linkid, NULL,
2671 NULL, NULL)) != DLADM_STATUS_OK)
2672 die_dlerr(status, "cannot delete '%s'", argv[1]);
2673 }
2674
2675 if ((status = dladm_phys_delete(handle, linkid)) != DLADM_STATUS_OK) {
2676 if (argc == 2)
2677 die_dlerr(status, "cannot delete '%s'", argv[1]);
2678 else
2679 die_dlerr(status, "delete operation failed");
2680 }
2681 }
2682
2683 /*ARGSUSED*/
2684 static int
i_dladm_walk_linkmap(dladm_handle_t dh,datalink_id_t linkid,void * arg)2685 i_dladm_walk_linkmap(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2686 {
2687 char name[MAXLINKNAMELEN];
2688 char mediabuf[DLADM_STRSIZE];
2689 char classbuf[DLADM_STRSIZE];
2690 datalink_class_t class;
2691 uint32_t media;
2692 uint32_t flags;
2693
2694 if (dladm_datalink_id2info(dh, linkid, &flags, &class, &media, name,
2695 MAXLINKNAMELEN) == DLADM_STATUS_OK) {
2696 (void) dladm_class2str(class, classbuf);
2697 (void) dladm_media2str(media, mediabuf);
2698 (void) printf("%-12s%8d %-12s%-20s %6d\n", name,
2699 linkid, classbuf, mediabuf, flags);
2700 }
2701 return (DLADM_WALK_CONTINUE);
2702 }
2703
2704 /*ARGSUSED*/
2705 static void
do_show_linkmap(int argc,char * argv[],const char * use)2706 do_show_linkmap(int argc, char *argv[], const char *use)
2707 {
2708 if (argc != 1)
2709 die("invalid arguments");
2710
2711 (void) printf("%-12s%8s %-12s%-20s %6s\n", "NAME", "LINKID",
2712 "CLASS", "MEDIA", "FLAGS");
2713
2714 (void) dladm_walk_datalink_id(i_dladm_walk_linkmap, handle, NULL,
2715 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
2716 DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);
2717 }
2718
2719 /*
2720 * Delete inactive physical links.
2721 */
2722 /*ARGSUSED*/
2723 static int
purge_phys(dladm_handle_t dh,datalink_id_t linkid,void * arg)2724 purge_phys(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2725 {
2726 datalink_class_t class;
2727 uint32_t flags;
2728
2729 if (dladm_datalink_id2info(dh, linkid, &flags, &class, NULL, NULL, 0)
2730 != DLADM_STATUS_OK) {
2731 return (DLADM_WALK_CONTINUE);
2732 }
2733
2734 if (class == DATALINK_CLASS_PHYS && !(flags & DLADM_OPT_ACTIVE))
2735 (void) dladm_phys_delete(dh, linkid);
2736
2737 return (DLADM_WALK_CONTINUE);
2738 }
2739
2740 /*ARGSUSED*/
2741 static void
do_init_phys(int argc,char * argv[],const char * use)2742 do_init_phys(int argc, char *argv[], const char *use)
2743 {
2744 di_node_t devtree;
2745
2746 if (argc > 1)
2747 usage();
2748
2749 /*
2750 * Force all the devices to attach, therefore all the network physical
2751 * devices can be known to the dlmgmtd daemon.
2752 */
2753 if ((devtree = di_init("/", DINFOFORCE | DINFOSUBTREE)) != DI_NODE_NIL)
2754 di_fini(devtree);
2755
2756 (void) dladm_walk_datalink_id(purge_phys, handle, NULL,
2757 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST);
2758 }
2759
2760 /*
2761 * Print the active topology information.
2762 */
2763 void
print_link_topology(show_state_t * state,datalink_id_t linkid,datalink_class_t class,link_fields_buf_t * lbuf)2764 print_link_topology(show_state_t *state, datalink_id_t linkid,
2765 datalink_class_t class, link_fields_buf_t *lbuf)
2766 {
2767 uint32_t flags = state->ls_flags;
2768 dladm_status_t status;
2769 char tmpbuf[MAXLINKNAMELEN];
2770
2771 lbuf->link_over[0] = '\0';
2772 lbuf->link_bridge[0] = '\0';
2773
2774 switch (class) {
2775 case DATALINK_CLASS_AGGR:
2776 case DATALINK_CLASS_PHYS:
2777 case DATALINK_CLASS_ETHERSTUB:
2778 status = dladm_bridge_getlink(handle, linkid, lbuf->link_bridge,
2779 sizeof (lbuf->link_bridge));
2780 if (status != DLADM_STATUS_OK &&
2781 status != DLADM_STATUS_NOTFOUND)
2782 (void) strcpy(lbuf->link_bridge, "?");
2783 break;
2784 }
2785
2786 switch (class) {
2787 case DATALINK_CLASS_VLAN: {
2788 dladm_vlan_attr_t vinfo;
2789
2790 if (dladm_vlan_info(handle, linkid, &vinfo, flags) !=
2791 DLADM_STATUS_OK) {
2792 (void) strcpy(lbuf->link_over, "?");
2793 break;
2794 }
2795 if (dladm_datalink_id2info(handle, vinfo.dv_linkid, NULL, NULL,
2796 NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2797 DLADM_STATUS_OK)
2798 (void) strcpy(lbuf->link_over, "?");
2799 break;
2800 }
2801 case DATALINK_CLASS_AGGR: {
2802 dladm_aggr_grp_attr_t ginfo;
2803 int i;
2804
2805 if (dladm_aggr_info(handle, linkid, &ginfo, flags) !=
2806 DLADM_STATUS_OK || ginfo.lg_nports == 0) {
2807 (void) strcpy(lbuf->link_over, "?");
2808 break;
2809 }
2810 for (i = 0; i < ginfo.lg_nports; i++) {
2811 if (dladm_datalink_id2info(handle,
2812 ginfo.lg_ports[i].lp_linkid, NULL, NULL, NULL,
2813 tmpbuf, sizeof (tmpbuf)) != DLADM_STATUS_OK) {
2814 (void) strcpy(lbuf->link_over, "?");
2815 break;
2816 }
2817 (void) strlcat(lbuf->link_over, tmpbuf,
2818 sizeof (lbuf->link_over));
2819 if (i != (ginfo.lg_nports - 1)) {
2820 (void) strlcat(lbuf->link_over, ",",
2821 sizeof (lbuf->link_over));
2822 }
2823 }
2824 free(ginfo.lg_ports);
2825 break;
2826 }
2827 case DATALINK_CLASS_VNIC: {
2828 dladm_vnic_attr_t vinfo;
2829
2830 if (dladm_vnic_info(handle, linkid, &vinfo, flags) !=
2831 DLADM_STATUS_OK) {
2832 (void) strcpy(lbuf->link_over, "?");
2833 break;
2834 }
2835 if (dladm_datalink_id2info(handle, vinfo.va_link_id, NULL, NULL,
2836 NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2837 DLADM_STATUS_OK)
2838 (void) strcpy(lbuf->link_over, "?");
2839 break;
2840 }
2841
2842 case DATALINK_CLASS_PART: {
2843 dladm_part_attr_t pinfo;
2844
2845 if (dladm_part_info(handle, linkid, &pinfo, flags) !=
2846 DLADM_STATUS_OK) {
2847 (void) strcpy(lbuf->link_over, "?");
2848 break;
2849 }
2850 if (dladm_datalink_id2info(handle, pinfo.dia_physlinkid, NULL,
2851 NULL, NULL, lbuf->link_over, sizeof (lbuf->link_over)) !=
2852 DLADM_STATUS_OK)
2853 (void) strcpy(lbuf->link_over, "?");
2854 break;
2855 }
2856
2857 case DATALINK_CLASS_BRIDGE: {
2858 datalink_id_t *dlp;
2859 uint_t i, nports;
2860
2861 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
2862 NULL, tmpbuf, sizeof (tmpbuf)) != DLADM_STATUS_OK) {
2863 (void) strcpy(lbuf->link_over, "?");
2864 break;
2865 }
2866 if (tmpbuf[0] != '\0')
2867 tmpbuf[strlen(tmpbuf) - 1] = '\0';
2868 dlp = dladm_bridge_get_portlist(tmpbuf, &nports);
2869 if (dlp == NULL) {
2870 (void) strcpy(lbuf->link_over, "?");
2871 break;
2872 }
2873 for (i = 0; i < nports; i++) {
2874 if (dladm_datalink_id2info(handle, dlp[i], NULL,
2875 NULL, NULL, tmpbuf, sizeof (tmpbuf)) !=
2876 DLADM_STATUS_OK) {
2877 (void) strcpy(lbuf->link_over, "?");
2878 break;
2879 }
2880 (void) strlcat(lbuf->link_over, tmpbuf,
2881 sizeof (lbuf->link_over));
2882 if (i != nports - 1) {
2883 (void) strlcat(lbuf->link_over, ",",
2884 sizeof (lbuf->link_over));
2885 }
2886 }
2887 dladm_bridge_free_portlist(dlp);
2888 break;
2889 }
2890
2891 case DATALINK_CLASS_SIMNET: {
2892 dladm_simnet_attr_t slinfo;
2893
2894 if (dladm_simnet_info(handle, linkid, &slinfo, flags) !=
2895 DLADM_STATUS_OK) {
2896 (void) strcpy(lbuf->link_over, "?");
2897 break;
2898 }
2899 if (slinfo.sna_peer_link_id != DATALINK_INVALID_LINKID) {
2900 if (dladm_datalink_id2info(handle,
2901 slinfo.sna_peer_link_id, NULL, NULL, NULL,
2902 lbuf->link_over, sizeof (lbuf->link_over)) !=
2903 DLADM_STATUS_OK)
2904 (void) strcpy(lbuf->link_over, "?");
2905 }
2906 break;
2907 }
2908 }
2909 }
2910
2911 static dladm_status_t
print_link(show_state_t * state,datalink_id_t linkid,link_fields_buf_t * lbuf)2912 print_link(show_state_t *state, datalink_id_t linkid, link_fields_buf_t *lbuf)
2913 {
2914 char link[MAXLINKNAMELEN];
2915 datalink_class_t class;
2916 uint_t mtu;
2917 uint32_t flags;
2918 dladm_status_t status;
2919
2920 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
2921 NULL, link, sizeof (link))) != DLADM_STATUS_OK) {
2922 goto done;
2923 }
2924
2925 if (!(state->ls_flags & flags)) {
2926 status = DLADM_STATUS_NOTFOUND;
2927 goto done;
2928 }
2929
2930 (void) snprintf(lbuf->link_name, sizeof (lbuf->link_name),
2931 "%s", link);
2932 (void) dladm_class2str(class, lbuf->link_class);
2933
2934 if (state->ls_flags == DLADM_OPT_ACTIVE) {
2935 dladm_attr_t dlattr;
2936
2937 if (class == DATALINK_CLASS_PHYS) {
2938 dladm_phys_attr_t dpa;
2939 dlpi_handle_t dh;
2940 dlpi_info_t dlinfo;
2941
2942 if ((status = dladm_phys_info(handle, linkid, &dpa,
2943 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {
2944 goto done;
2945 }
2946
2947 if (!dpa.dp_novanity)
2948 goto link_mtu;
2949
2950 /*
2951 * This is a physical link that does not have
2952 * vanity naming support.
2953 */
2954 if (dlpi_open(dpa.dp_dev, &dh, DLPI_DEVONLY) !=
2955 DLPI_SUCCESS) {
2956 status = DLADM_STATUS_NOTFOUND;
2957 goto done;
2958 }
2959
2960 if (dlpi_info(dh, &dlinfo, 0) != DLPI_SUCCESS) {
2961 dlpi_close(dh);
2962 status = DLADM_STATUS_BADARG;
2963 goto done;
2964 }
2965
2966 dlpi_close(dh);
2967 mtu = dlinfo.di_max_sdu;
2968 } else {
2969 link_mtu:
2970 status = dladm_info(handle, linkid, &dlattr);
2971 if (status != DLADM_STATUS_OK)
2972 goto done;
2973 mtu = dlattr.da_max_sdu;
2974 }
2975
2976 (void) snprintf(lbuf->link_mtu, sizeof (lbuf->link_mtu),
2977 "%u", mtu);
2978 (void) get_linkstate(link, B_TRUE, lbuf->link_state);
2979 }
2980
2981 print_link_topology(state, linkid, class, lbuf);
2982 done:
2983 return (status);
2984 }
2985
2986 /* ARGSUSED */
2987 static int
show_link(dladm_handle_t dh,datalink_id_t linkid,void * arg)2988 show_link(dladm_handle_t dh, datalink_id_t linkid, void *arg)
2989 {
2990 show_state_t *state = (show_state_t *)arg;
2991 dladm_status_t status;
2992 link_fields_buf_t lbuf;
2993
2994 /*
2995 * first get all the link attributes into lbuf;
2996 */
2997 bzero(&lbuf, sizeof (link_fields_buf_t));
2998 if ((status = print_link(state, linkid, &lbuf)) == DLADM_STATUS_OK)
2999 ofmt_print(state->ls_ofmt, &lbuf);
3000 state->ls_status = status;
3001 return (DLADM_WALK_CONTINUE);
3002 }
3003
3004 static boolean_t
print_link_stats_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3005 print_link_stats_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3006 {
3007 link_args_t *largs = ofarg->ofmt_cbarg;
3008 pktsum_t *diff_stats = largs->link_s_psum;
3009
3010 switch (ofarg->ofmt_id) {
3011 case LINK_S_LINK:
3012 (void) snprintf(buf, bufsize, "%s", largs->link_s_link);
3013 break;
3014 case LINK_S_IPKTS:
3015 (void) snprintf(buf, bufsize, "%llu", diff_stats->ipackets);
3016 break;
3017 case LINK_S_RBYTES:
3018 (void) snprintf(buf, bufsize, "%llu", diff_stats->rbytes);
3019 break;
3020 case LINK_S_IERRORS:
3021 (void) snprintf(buf, bufsize, "%u", diff_stats->ierrors);
3022 break;
3023 case LINK_S_OPKTS:
3024 (void) snprintf(buf, bufsize, "%llu", diff_stats->opackets);
3025 break;
3026 case LINK_S_OBYTES:
3027 (void) snprintf(buf, bufsize, "%llu", diff_stats->obytes);
3028 break;
3029 case LINK_S_OERRORS:
3030 (void) snprintf(buf, bufsize, "%u", diff_stats->oerrors);
3031 break;
3032 default:
3033 die("invalid input");
3034 break;
3035 }
3036 return (B_TRUE);
3037 }
3038
3039 static int
show_link_stats(dladm_handle_t dh,datalink_id_t linkid,void * arg)3040 show_link_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)
3041 {
3042 char link[DLPI_LINKNAME_MAX];
3043 datalink_class_t class;
3044 show_state_t *state = arg;
3045 pktsum_t stats, diff_stats;
3046 dladm_phys_attr_t dpa;
3047 link_args_t largs;
3048
3049 if (state->ls_firstonly) {
3050 if (state->ls_donefirst)
3051 return (DLADM_WALK_CONTINUE);
3052 state->ls_donefirst = B_TRUE;
3053 } else {
3054 bzero(&state->ls_prevstats, sizeof (state->ls_prevstats));
3055 }
3056
3057 if (dladm_datalink_id2info(dh, linkid, NULL, &class, NULL, link,
3058 DLPI_LINKNAME_MAX) != DLADM_STATUS_OK) {
3059 return (DLADM_WALK_CONTINUE);
3060 }
3061
3062 if (class == DATALINK_CLASS_PHYS) {
3063 if (dladm_phys_info(dh, linkid, &dpa, DLADM_OPT_ACTIVE) !=
3064 DLADM_STATUS_OK) {
3065 return (DLADM_WALK_CONTINUE);
3066 }
3067 if (dpa.dp_novanity)
3068 get_mac_stats(dpa.dp_dev, &stats);
3069 else
3070 get_link_stats(link, &stats);
3071 } else {
3072 get_link_stats(link, &stats);
3073 }
3074 dladm_stats_diff(&diff_stats, &stats, &state->ls_prevstats);
3075
3076 largs.link_s_link = link;
3077 largs.link_s_psum = &diff_stats;
3078 ofmt_print(state->ls_ofmt, &largs);
3079
3080 state->ls_prevstats = stats;
3081 return (DLADM_WALK_CONTINUE);
3082 }
3083
3084
3085 static dladm_status_t
print_aggr_info(show_grp_state_t * state,const char * link,dladm_aggr_grp_attr_t * ginfop)3086 print_aggr_info(show_grp_state_t *state, const char *link,
3087 dladm_aggr_grp_attr_t *ginfop)
3088 {
3089 char addr_str[ETHERADDRL * 3];
3090 laggr_fields_buf_t lbuf;
3091
3092 (void) snprintf(lbuf.laggr_name, sizeof (lbuf.laggr_name),
3093 "%s", link);
3094
3095 (void) dladm_aggr_policy2str(ginfop->lg_policy,
3096 lbuf.laggr_policy);
3097
3098 if (ginfop->lg_mac_fixed) {
3099 (void) dladm_aggr_macaddr2str(ginfop->lg_mac, addr_str);
3100 (void) snprintf(lbuf.laggr_addrpolicy,
3101 sizeof (lbuf.laggr_addrpolicy), "fixed (%s)", addr_str);
3102 } else {
3103 (void) snprintf(lbuf.laggr_addrpolicy,
3104 sizeof (lbuf.laggr_addrpolicy), "auto");
3105 }
3106
3107 (void) dladm_aggr_lacpmode2str(ginfop->lg_lacp_mode,
3108 lbuf.laggr_lacpactivity);
3109 (void) dladm_aggr_lacptimer2str(ginfop->lg_lacp_timer,
3110 lbuf.laggr_lacptimer);
3111 (void) snprintf(lbuf.laggr_flags, sizeof (lbuf.laggr_flags), "%c----",
3112 ginfop->lg_force ? 'f' : '-');
3113
3114 ofmt_print(state->gs_ofmt, &lbuf);
3115
3116 return (DLADM_STATUS_OK);
3117 }
3118
3119 static boolean_t
print_xaggr_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3120 print_xaggr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3121 {
3122 const laggr_args_t *l = ofarg->ofmt_cbarg;
3123 boolean_t is_port = (l->laggr_lport >= 0);
3124 char tmpbuf[DLADM_STRSIZE];
3125 const char *objname;
3126 dladm_aggr_port_attr_t *portp = NULL;
3127 dladm_phys_attr_t dpa;
3128
3129 if (is_port) {
3130 portp = &(l->laggr_ginfop->lg_ports[l->laggr_lport]);
3131 if (dladm_phys_info(handle, portp->lp_linkid, &dpa,
3132 DLADM_OPT_ACTIVE) != DLADM_STATUS_OK)
3133 objname = "?";
3134 else
3135 objname = dpa.dp_dev;
3136 } else {
3137 objname = l->laggr_link;
3138 }
3139
3140 switch (ofarg->ofmt_id) {
3141 case AGGR_X_LINK:
3142 (void) snprintf(buf, bufsize, "%s",
3143 (is_port && !l->laggr_parsable ? " " : l->laggr_link));
3144 break;
3145 case AGGR_X_PORT:
3146 if (is_port) {
3147 if (dladm_datalink_id2info(handle, portp->lp_linkid,
3148 NULL, NULL, NULL, buf, bufsize) != DLADM_STATUS_OK)
3149 (void) sprintf(buf, "?");
3150 }
3151 break;
3152
3153 case AGGR_X_SPEED:
3154 (void) snprintf(buf, bufsize, "%uMb",
3155 (uint_t)((get_ifspeed(objname, !is_port)) / 1000000ull));
3156 break;
3157
3158 case AGGR_X_DUPLEX:
3159 (void) get_linkduplex(objname, !is_port, tmpbuf);
3160 (void) strlcpy(buf, tmpbuf, bufsize);
3161 break;
3162
3163 case AGGR_X_STATE:
3164 (void) get_linkstate(objname, !is_port, tmpbuf);
3165 (void) strlcpy(buf, tmpbuf, bufsize);
3166 break;
3167 case AGGR_X_ADDRESS:
3168 (void) dladm_aggr_macaddr2str(
3169 (is_port ? portp->lp_mac : l->laggr_ginfop->lg_mac),
3170 tmpbuf);
3171 (void) strlcpy(buf, tmpbuf, bufsize);
3172 break;
3173 case AGGR_X_PORTSTATE:
3174 if (is_port) {
3175 (void) dladm_aggr_portstate2str(portp->lp_state,
3176 tmpbuf);
3177 (void) strlcpy(buf, tmpbuf, bufsize);
3178 }
3179 break;
3180 }
3181 err:
3182 *(l->laggr_status) = DLADM_STATUS_OK;
3183 return (B_TRUE);
3184 }
3185
3186 static dladm_status_t
print_aggr_extended(show_grp_state_t * state,const char * link,dladm_aggr_grp_attr_t * ginfop)3187 print_aggr_extended(show_grp_state_t *state, const char *link,
3188 dladm_aggr_grp_attr_t *ginfop)
3189 {
3190 int i;
3191 dladm_status_t status;
3192 laggr_args_t largs;
3193
3194 largs.laggr_lport = -1;
3195 largs.laggr_link = link;
3196 largs.laggr_ginfop = ginfop;
3197 largs.laggr_status = &status;
3198 largs.laggr_parsable = state->gs_parsable;
3199
3200 ofmt_print(state->gs_ofmt, &largs);
3201
3202 if (status != DLADM_STATUS_OK)
3203 goto done;
3204
3205 for (i = 0; i < ginfop->lg_nports; i++) {
3206 largs.laggr_lport = i;
3207 ofmt_print(state->gs_ofmt, &largs);
3208 if (status != DLADM_STATUS_OK)
3209 goto done;
3210 }
3211
3212 status = DLADM_STATUS_OK;
3213 done:
3214 return (status);
3215 }
3216
3217 static boolean_t
print_lacp_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3218 print_lacp_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3219 {
3220 const laggr_args_t *l = ofarg->ofmt_cbarg;
3221 int portnum;
3222 boolean_t is_port = (l->laggr_lport >= 0);
3223 dladm_aggr_port_attr_t *portp;
3224 aggr_lacp_state_t *lstate;
3225
3226 if (!is_port)
3227 return (B_FALSE); /* cannot happen! */
3228
3229 portnum = l->laggr_lport;
3230 portp = &(l->laggr_ginfop->lg_ports[portnum]);
3231 lstate = &(portp->lp_lacp_state);
3232
3233 switch (ofarg->ofmt_id) {
3234 case AGGR_L_LINK:
3235 (void) snprintf(buf, bufsize, "%s",
3236 (portnum > 0 ? "" : l->laggr_link));
3237 break;
3238
3239 case AGGR_L_PORT:
3240 if (dladm_datalink_id2info(handle, portp->lp_linkid, NULL, NULL,
3241 NULL, buf, bufsize) != DLADM_STATUS_OK)
3242 (void) sprintf(buf, "?");
3243 break;
3244
3245 case AGGR_L_AGGREGATABLE:
3246 (void) snprintf(buf, bufsize, "%s",
3247 (lstate->bit.aggregation ? "yes" : "no"));
3248 break;
3249
3250 case AGGR_L_SYNC:
3251 (void) snprintf(buf, bufsize, "%s",
3252 (lstate->bit.sync ? "yes" : "no"));
3253 break;
3254
3255 case AGGR_L_COLL:
3256 (void) snprintf(buf, bufsize, "%s",
3257 (lstate->bit.collecting ? "yes" : "no"));
3258 break;
3259
3260 case AGGR_L_DIST:
3261 (void) snprintf(buf, bufsize, "%s",
3262 (lstate->bit.distributing ? "yes" : "no"));
3263 break;
3264
3265 case AGGR_L_DEFAULTED:
3266 (void) snprintf(buf, bufsize, "%s",
3267 (lstate->bit.defaulted ? "yes" : "no"));
3268 break;
3269
3270 case AGGR_L_EXPIRED:
3271 (void) snprintf(buf, bufsize, "%s",
3272 (lstate->bit.expired ? "yes" : "no"));
3273 break;
3274 }
3275
3276 *(l->laggr_status) = DLADM_STATUS_OK;
3277 return (B_TRUE);
3278 }
3279
3280 static dladm_status_t
print_aggr_lacp(show_grp_state_t * state,const char * link,dladm_aggr_grp_attr_t * ginfop)3281 print_aggr_lacp(show_grp_state_t *state, const char *link,
3282 dladm_aggr_grp_attr_t *ginfop)
3283 {
3284 int i;
3285 dladm_status_t status;
3286 laggr_args_t largs;
3287
3288 largs.laggr_link = link;
3289 largs.laggr_ginfop = ginfop;
3290 largs.laggr_status = &status;
3291
3292 for (i = 0; i < ginfop->lg_nports; i++) {
3293 largs.laggr_lport = i;
3294 ofmt_print(state->gs_ofmt, &largs);
3295 if (status != DLADM_STATUS_OK)
3296 goto done;
3297 }
3298
3299 status = DLADM_STATUS_OK;
3300 done:
3301 return (status);
3302 }
3303
3304 static boolean_t
print_aggr_stats_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3305 print_aggr_stats_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3306 {
3307 const laggr_args_t *l = ofarg->ofmt_cbarg;
3308 int portnum;
3309 boolean_t is_port = (l->laggr_lport >= 0);
3310 dladm_aggr_port_attr_t *portp;
3311 dladm_status_t *stat, status;
3312 pktsum_t *diff_stats = NULL;
3313
3314 stat = l->laggr_status;
3315 *stat = DLADM_STATUS_OK;
3316
3317 if (is_port) {
3318 portnum = l->laggr_lport;
3319 portp = &(l->laggr_ginfop->lg_ports[portnum]);
3320
3321 if ((status = dladm_datalink_id2info(handle,
3322 portp->lp_linkid, NULL, NULL, NULL, buf, bufsize)) !=
3323 DLADM_STATUS_OK) {
3324 goto err;
3325 }
3326 diff_stats = l->laggr_diffstats;
3327 if (diff_stats == NULL) {
3328 status = DLADM_STATUS_BADVAL;
3329 goto err;
3330 }
3331 }
3332
3333 switch (ofarg->ofmt_id) {
3334 case AGGR_S_LINK:
3335 (void) snprintf(buf, bufsize, "%s",
3336 (is_port ? "" : l->laggr_link));
3337 break;
3338 case AGGR_S_PORT:
3339 /*
3340 * if (is_port), buf has port name. Otherwise we print
3341 * STR_UNDEF_VAL
3342 */
3343 break;
3344
3345 case AGGR_S_IPKTS:
3346 if (is_port) {
3347 (void) snprintf(buf, bufsize, "%llu",
3348 diff_stats->ipackets);
3349 } else {
3350 (void) snprintf(buf, bufsize, "%llu",
3351 l->laggr_pktsumtot->ipackets);
3352 }
3353 break;
3354
3355 case AGGR_S_RBYTES:
3356 if (is_port) {
3357 (void) snprintf(buf, bufsize, "%llu",
3358 diff_stats->rbytes);
3359 } else {
3360 (void) snprintf(buf, bufsize, "%llu",
3361 l->laggr_pktsumtot->rbytes);
3362 }
3363 break;
3364
3365 case AGGR_S_OPKTS:
3366 if (is_port) {
3367 (void) snprintf(buf, bufsize, "%llu",
3368 diff_stats->opackets);
3369 } else {
3370 (void) snprintf(buf, bufsize, "%llu",
3371 l->laggr_pktsumtot->opackets);
3372 }
3373 break;
3374 case AGGR_S_OBYTES:
3375 if (is_port) {
3376 (void) snprintf(buf, bufsize, "%llu",
3377 diff_stats->obytes);
3378 } else {
3379 (void) snprintf(buf, bufsize, "%llu",
3380 l->laggr_pktsumtot->obytes);
3381 }
3382 break;
3383
3384 case AGGR_S_IPKTDIST:
3385 if (is_port) {
3386 (void) snprintf(buf, bufsize, "%-6.1f",
3387 (double)diff_stats->ipackets/
3388 (double)l->laggr_pktsumtot->ipackets * 100);
3389 }
3390 break;
3391 case AGGR_S_OPKTDIST:
3392 if (is_port) {
3393 (void) snprintf(buf, bufsize, "%-6.1f",
3394 (double)diff_stats->opackets/
3395 (double)l->laggr_pktsumtot->opackets * 100);
3396 }
3397 break;
3398 }
3399 return (B_TRUE);
3400
3401 err:
3402 *stat = status;
3403 return (B_TRUE);
3404 }
3405
3406 static dladm_status_t
print_aggr_stats(show_grp_state_t * state,const char * link,dladm_aggr_grp_attr_t * ginfop)3407 print_aggr_stats(show_grp_state_t *state, const char *link,
3408 dladm_aggr_grp_attr_t *ginfop)
3409 {
3410 dladm_phys_attr_t dpa;
3411 dladm_aggr_port_attr_t *portp;
3412 pktsum_t pktsumtot, *port_stat;
3413 dladm_status_t status;
3414 int i;
3415 laggr_args_t largs;
3416
3417 /* sum the ports statistics */
3418 bzero(&pktsumtot, sizeof (pktsumtot));
3419
3420 /* Allocate memory to keep stats of each port */
3421 port_stat = malloc(ginfop->lg_nports * sizeof (pktsum_t));
3422 if (port_stat == NULL) {
3423 /* Bail out; no memory */
3424 return (DLADM_STATUS_NOMEM);
3425 }
3426
3427
3428 for (i = 0; i < ginfop->lg_nports; i++) {
3429
3430 portp = &(ginfop->lg_ports[i]);
3431 if ((status = dladm_phys_info(handle, portp->lp_linkid, &dpa,
3432 DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {
3433 goto done;
3434 }
3435
3436 get_mac_stats(dpa.dp_dev, &port_stat[i]);
3437
3438 /*
3439 * Let's re-use gs_prevstats[] to store the difference of the
3440 * counters since last use. We will store the new stats from
3441 * port_stat[] once we have the stats displayed.
3442 */
3443
3444 dladm_stats_diff(&state->gs_prevstats[i], &port_stat[i],
3445 &state->gs_prevstats[i]);
3446 dladm_stats_total(&pktsumtot, &pktsumtot,
3447 &state->gs_prevstats[i]);
3448 }
3449
3450 largs.laggr_lport = -1;
3451 largs.laggr_link = link;
3452 largs.laggr_ginfop = ginfop;
3453 largs.laggr_status = &status;
3454 largs.laggr_pktsumtot = &pktsumtot;
3455
3456 ofmt_print(state->gs_ofmt, &largs);
3457
3458 if (status != DLADM_STATUS_OK)
3459 goto done;
3460
3461 for (i = 0; i < ginfop->lg_nports; i++) {
3462 largs.laggr_lport = i;
3463 largs.laggr_diffstats = &state->gs_prevstats[i];
3464 ofmt_print(state->gs_ofmt, &largs);
3465 if (status != DLADM_STATUS_OK)
3466 goto done;
3467 }
3468
3469 status = DLADM_STATUS_OK;
3470 for (i = 0; i < ginfop->lg_nports; i++)
3471 state->gs_prevstats[i] = port_stat[i];
3472
3473 done:
3474 free(port_stat);
3475 return (status);
3476 }
3477
3478 static dladm_status_t
print_aggr(show_grp_state_t * state,datalink_id_t linkid)3479 print_aggr(show_grp_state_t *state, datalink_id_t linkid)
3480 {
3481 char link[MAXLINKNAMELEN];
3482 dladm_aggr_grp_attr_t ginfo;
3483 uint32_t flags;
3484 dladm_status_t status;
3485
3486 bzero(&ginfo, sizeof (dladm_aggr_grp_attr_t));
3487 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL,
3488 NULL, link, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
3489 return (status);
3490 }
3491
3492 if (!(state->gs_flags & flags))
3493 return (DLADM_STATUS_NOTFOUND);
3494
3495 status = dladm_aggr_info(handle, linkid, &ginfo, state->gs_flags);
3496 if (status != DLADM_STATUS_OK)
3497 return (status);
3498
3499 if (state->gs_lacp)
3500 status = print_aggr_lacp(state, link, &ginfo);
3501 else if (state->gs_extended)
3502 status = print_aggr_extended(state, link, &ginfo);
3503 else if (state->gs_stats)
3504 status = print_aggr_stats(state, link, &ginfo);
3505 else
3506 status = print_aggr_info(state, link, &ginfo);
3507
3508 done:
3509 free(ginfo.lg_ports);
3510 return (status);
3511 }
3512
3513 /* ARGSUSED */
3514 static int
show_aggr(dladm_handle_t dh,datalink_id_t linkid,void * arg)3515 show_aggr(dladm_handle_t dh, datalink_id_t linkid, void *arg)
3516 {
3517 show_grp_state_t *state = arg;
3518
3519 state->gs_status = print_aggr(state, linkid);
3520 return (DLADM_WALK_CONTINUE);
3521 }
3522
3523 static void
do_show_link(int argc,char * argv[],const char * use)3524 do_show_link(int argc, char *argv[], const char *use)
3525 {
3526 int option;
3527 boolean_t s_arg = B_FALSE;
3528 boolean_t i_arg = B_FALSE;
3529 uint32_t flags = DLADM_OPT_ACTIVE;
3530 boolean_t p_arg = B_FALSE;
3531 datalink_id_t linkid = DATALINK_ALL_LINKID;
3532 char linkname[MAXLINKNAMELEN];
3533 uint32_t interval = 0;
3534 show_state_t state;
3535 dladm_status_t status;
3536 boolean_t o_arg = B_FALSE;
3537 char *fields_str = NULL;
3538 char *all_active_fields = "link,class,mtu,state,bridge,over";
3539 char *all_inactive_fields = "link,class,bridge,over";
3540 char *allstat_fields =
3541 "link,ipackets,rbytes,ierrors,opackets,obytes,oerrors";
3542 ofmt_handle_t ofmt;
3543 ofmt_status_t oferr;
3544 uint_t ofmtflags = 0;
3545
3546 bzero(&state, sizeof (state));
3547
3548 opterr = 0;
3549 while ((option = getopt_long(argc, argv, ":pPsi:o:",
3550 show_lopts, NULL)) != -1) {
3551 switch (option) {
3552 case 'p':
3553 if (p_arg)
3554 die_optdup(option);
3555
3556 p_arg = B_TRUE;
3557 break;
3558 case 's':
3559 if (s_arg)
3560 die_optdup(option);
3561
3562 s_arg = B_TRUE;
3563 break;
3564 case 'P':
3565 if (flags != DLADM_OPT_ACTIVE)
3566 die_optdup(option);
3567
3568 flags = DLADM_OPT_PERSIST;
3569 break;
3570 case 'o':
3571 o_arg = B_TRUE;
3572 fields_str = optarg;
3573 break;
3574 case 'i':
3575 if (i_arg)
3576 die_optdup(option);
3577
3578 i_arg = B_TRUE;
3579 if (!dladm_str2interval(optarg, &interval))
3580 die("invalid interval value '%s'", optarg);
3581 break;
3582 default:
3583 die_opterr(optopt, option, use);
3584 break;
3585 }
3586 }
3587
3588 if (i_arg && !s_arg)
3589 die("the option -i can be used only with -s");
3590
3591 if (s_arg && flags != DLADM_OPT_ACTIVE)
3592 die("the option -P cannot be used with -s");
3593
3594 /* get link name (optional last argument) */
3595 if (optind == (argc-1)) {
3596 uint32_t f;
3597
3598 if (strlcpy(linkname, argv[optind], MAXLINKNAMELEN) >=
3599 MAXLINKNAMELEN)
3600 die("link name too long");
3601 if ((status = dladm_name2info(handle, linkname, &linkid, &f,
3602 NULL, NULL)) != DLADM_STATUS_OK) {
3603 die_dlerr(status, "link %s is not valid", linkname);
3604 }
3605
3606 if (!(f & flags)) {
3607 die_dlerr(DLADM_STATUS_BADARG, "link %s is %s",
3608 argv[optind], flags == DLADM_OPT_PERSIST ?
3609 "a temporary link" : "temporarily removed");
3610 }
3611 } else if (optind != argc) {
3612 usage();
3613 }
3614
3615 if (p_arg && !o_arg)
3616 die("-p requires -o");
3617
3618 if (p_arg && strcasecmp(fields_str, "all") == 0)
3619 die("\"-o all\" is invalid with -p");
3620
3621 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
3622 if (s_arg)
3623 fields_str = allstat_fields;
3624 else if (flags & DLADM_OPT_ACTIVE)
3625 fields_str = all_active_fields;
3626 else
3627 fields_str = all_inactive_fields;
3628 }
3629
3630 state.ls_parsable = p_arg;
3631 state.ls_flags = flags;
3632 state.ls_donefirst = B_FALSE;
3633
3634 if (s_arg) {
3635 link_stats(linkid, interval, fields_str, &state);
3636 return;
3637 }
3638 if (state.ls_parsable)
3639 ofmtflags |= OFMT_PARSABLE;
3640 else
3641 ofmtflags |= OFMT_WRAP;
3642
3643 oferr = ofmt_open(fields_str, link_fields, ofmtflags, 0, &ofmt);
3644 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
3645 state.ls_ofmt = ofmt;
3646
3647 if (linkid == DATALINK_ALL_LINKID) {
3648 (void) dladm_walk_datalink_id(show_link, handle, &state,
3649 DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE, flags);
3650 } else {
3651 (void) show_link(handle, linkid, &state);
3652 if (state.ls_status != DLADM_STATUS_OK) {
3653 die_dlerr(state.ls_status, "failed to show link %s",
3654 argv[optind]);
3655 }
3656 }
3657 ofmt_close(ofmt);
3658 }
3659
3660 static void
do_show_aggr(int argc,char * argv[],const char * use)3661 do_show_aggr(int argc, char *argv[], const char *use)
3662 {
3663 boolean_t L_arg = B_FALSE;
3664 boolean_t s_arg = B_FALSE;
3665 boolean_t i_arg = B_FALSE;
3666 boolean_t p_arg = B_FALSE;
3667 boolean_t x_arg = B_FALSE;
3668 show_grp_state_t state;
3669 uint32_t flags = DLADM_OPT_ACTIVE;
3670 datalink_id_t linkid = DATALINK_ALL_LINKID;
3671 int option;
3672 uint32_t interval = 0;
3673 int key;
3674 dladm_status_t status;
3675 boolean_t o_arg = B_FALSE;
3676 char *fields_str = NULL;
3677 char *all_fields =
3678 "link,policy,addrpolicy,lacpactivity,lacptimer,flags";
3679 char *all_lacp_fields =
3680 "link,port,aggregatable,sync,coll,dist,defaulted,expired";
3681 char *all_stats_fields =
3682 "link,port,ipackets,rbytes,opackets,obytes,ipktdist,opktdist";
3683 char *all_extended_fields =
3684 "link,port,speed,duplex,state,address,portstate";
3685 const ofmt_field_t *pf;
3686 ofmt_handle_t ofmt;
3687 ofmt_status_t oferr;
3688 uint_t ofmtflags = 0;
3689
3690 opterr = 0;
3691 while ((option = getopt_long(argc, argv, ":LpPxsi:o:",
3692 show_lopts, NULL)) != -1) {
3693 switch (option) {
3694 case 'L':
3695 if (L_arg)
3696 die_optdup(option);
3697
3698 L_arg = B_TRUE;
3699 break;
3700 case 'p':
3701 if (p_arg)
3702 die_optdup(option);
3703
3704 p_arg = B_TRUE;
3705 break;
3706 case 'x':
3707 if (x_arg)
3708 die_optdup(option);
3709
3710 x_arg = B_TRUE;
3711 break;
3712 case 'P':
3713 if (flags != DLADM_OPT_ACTIVE)
3714 die_optdup(option);
3715
3716 flags = DLADM_OPT_PERSIST;
3717 break;
3718 case 's':
3719 if (s_arg)
3720 die_optdup(option);
3721
3722 s_arg = B_TRUE;
3723 break;
3724 case 'o':
3725 o_arg = B_TRUE;
3726 fields_str = optarg;
3727 break;
3728 case 'i':
3729 if (i_arg)
3730 die_optdup(option);
3731
3732 i_arg = B_TRUE;
3733 if (!dladm_str2interval(optarg, &interval))
3734 die("invalid interval value '%s'", optarg);
3735 break;
3736 default:
3737 die_opterr(optopt, option, use);
3738 break;
3739 }
3740 }
3741
3742 if (p_arg && !o_arg)
3743 die("-p requires -o");
3744
3745 if (p_arg && strcasecmp(fields_str, "all") == 0)
3746 die("\"-o all\" is invalid with -p");
3747
3748 if (i_arg && !s_arg)
3749 die("the option -i can be used only with -s");
3750
3751 if (s_arg && (L_arg || p_arg || x_arg || flags != DLADM_OPT_ACTIVE)) {
3752 die("the option -%c cannot be used with -s",
3753 L_arg ? 'L' : (p_arg ? 'p' : (x_arg ? 'x' : 'P')));
3754 }
3755
3756 if (L_arg && flags != DLADM_OPT_ACTIVE)
3757 die("the option -P cannot be used with -L");
3758
3759 if (x_arg && (L_arg || flags != DLADM_OPT_ACTIVE))
3760 die("the option -%c cannot be used with -x", L_arg ? 'L' : 'P');
3761
3762 /* get aggregation key or aggrname (optional last argument) */
3763 if (optind == (argc-1)) {
3764 if (!str2int(argv[optind], &key)) {
3765 status = dladm_name2info(handle, argv[optind],
3766 &linkid, NULL, NULL, NULL);
3767 } else {
3768 status = dladm_key2linkid(handle, (uint16_t)key,
3769 &linkid, DLADM_OPT_ACTIVE);
3770 }
3771
3772 if (status != DLADM_STATUS_OK)
3773 die("non-existent aggregation '%s'", argv[optind]);
3774
3775 } else if (optind != argc) {
3776 usage();
3777 }
3778
3779 bzero(&state, sizeof (state));
3780 state.gs_lacp = L_arg;
3781 state.gs_stats = s_arg;
3782 state.gs_flags = flags;
3783 state.gs_parsable = p_arg;
3784 state.gs_extended = x_arg;
3785
3786 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
3787 if (state.gs_lacp)
3788 fields_str = all_lacp_fields;
3789 else if (state.gs_stats)
3790 fields_str = all_stats_fields;
3791 else if (state.gs_extended)
3792 fields_str = all_extended_fields;
3793 else
3794 fields_str = all_fields;
3795 }
3796
3797 if (state.gs_lacp) {
3798 pf = aggr_l_fields;
3799 } else if (state.gs_stats) {
3800 pf = aggr_s_fields;
3801 } else if (state.gs_extended) {
3802 pf = aggr_x_fields;
3803 } else {
3804 pf = laggr_fields;
3805 }
3806
3807 if (state.gs_parsable)
3808 ofmtflags |= OFMT_PARSABLE;
3809 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
3810 ofmt_check(oferr, state.gs_parsable, ofmt, die, warn);
3811 state.gs_ofmt = ofmt;
3812
3813 if (s_arg) {
3814 aggr_stats(linkid, &state, interval);
3815 ofmt_close(ofmt);
3816 return;
3817 }
3818
3819 if (linkid == DATALINK_ALL_LINKID) {
3820 (void) dladm_walk_datalink_id(show_aggr, handle, &state,
3821 DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE, flags);
3822 } else {
3823 (void) show_aggr(handle, linkid, &state);
3824 if (state.gs_status != DLADM_STATUS_OK) {
3825 die_dlerr(state.gs_status, "failed to show aggr %s",
3826 argv[optind]);
3827 }
3828 }
3829 ofmt_close(ofmt);
3830 }
3831
3832 static dladm_status_t
print_phys_default(show_state_t * state,datalink_id_t linkid,const char * link,uint32_t flags,uint32_t media)3833 print_phys_default(show_state_t *state, datalink_id_t linkid,
3834 const char *link, uint32_t flags, uint32_t media)
3835 {
3836 dladm_phys_attr_t dpa;
3837 dladm_status_t status;
3838 link_fields_buf_t pattr;
3839
3840 status = dladm_phys_info(handle, linkid, &dpa, state->ls_flags);
3841 if (status != DLADM_STATUS_OK)
3842 goto done;
3843
3844 bzero(&pattr, sizeof (pattr));
3845 (void) snprintf(pattr.link_phys_device,
3846 sizeof (pattr.link_phys_device), "%s", dpa.dp_dev);
3847 (void) dladm_media2str(media, pattr.link_phys_media);
3848 if (state->ls_flags == DLADM_OPT_ACTIVE) {
3849 boolean_t islink;
3850
3851 if (!dpa.dp_novanity) {
3852 (void) strlcpy(pattr.link_name, link,
3853 sizeof (pattr.link_name));
3854 islink = B_TRUE;
3855 } else {
3856 /*
3857 * This is a physical link that does not have
3858 * vanity naming support.
3859 */
3860 (void) strlcpy(pattr.link_name, dpa.dp_dev,
3861 sizeof (pattr.link_name));
3862 islink = B_FALSE;
3863 }
3864
3865 (void) get_linkstate(pattr.link_name, islink,
3866 pattr.link_phys_state);
3867 (void) snprintf(pattr.link_phys_speed,
3868 sizeof (pattr.link_phys_speed), "%u",
3869 (uint_t)((get_ifspeed(pattr.link_name,
3870 islink)) / 1000000ull));
3871 (void) get_linkduplex(pattr.link_name, islink,
3872 pattr.link_phys_duplex);
3873 } else {
3874 (void) snprintf(pattr.link_name, sizeof (pattr.link_name),
3875 "%s", link);
3876 (void) snprintf(pattr.link_flags, sizeof (pattr.link_flags),
3877 "%c----", flags & DLADM_OPT_ACTIVE ? '-' : 'r');
3878 }
3879
3880 ofmt_print(state->ls_ofmt, &pattr);
3881
3882 done:
3883 return (status);
3884 }
3885
3886 typedef struct {
3887 show_state_t *ms_state;
3888 char *ms_link;
3889 dladm_macaddr_attr_t *ms_mac_attr;
3890 } print_phys_mac_state_t;
3891
3892 /*
3893 * callback for ofmt_print()
3894 */
3895 static boolean_t
print_phys_one_mac_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3896 print_phys_one_mac_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3897 {
3898 print_phys_mac_state_t *mac_state = ofarg->ofmt_cbarg;
3899 dladm_macaddr_attr_t *attr = mac_state->ms_mac_attr;
3900 boolean_t is_primary = (attr->ma_slot == 0);
3901 boolean_t is_parsable = mac_state->ms_state->ls_parsable;
3902
3903 switch (ofarg->ofmt_id) {
3904 case PHYS_M_LINK:
3905 (void) snprintf(buf, bufsize, "%s",
3906 (is_primary || is_parsable) ? mac_state->ms_link : " ");
3907 break;
3908 case PHYS_M_SLOT:
3909 if (is_primary)
3910 (void) snprintf(buf, bufsize, gettext("primary"));
3911 else
3912 (void) snprintf(buf, bufsize, "%d", attr->ma_slot);
3913 break;
3914 case PHYS_M_ADDRESS:
3915 (void) dladm_aggr_macaddr2str(attr->ma_addr, buf);
3916 break;
3917 case PHYS_M_INUSE:
3918 (void) snprintf(buf, bufsize, "%s",
3919 attr->ma_flags & DLADM_MACADDR_USED ? gettext("yes") :
3920 gettext("no"));
3921 break;
3922 case PHYS_M_CLIENT:
3923 /*
3924 * CR 6678526: resolve link id to actual link name if
3925 * it is valid.
3926 */
3927 (void) snprintf(buf, bufsize, "%s", attr->ma_client_name);
3928 break;
3929 }
3930
3931 return (B_TRUE);
3932 }
3933
3934 typedef struct {
3935 show_state_t *hs_state;
3936 char *hs_link;
3937 dladm_hwgrp_attr_t *hs_grp_attr;
3938 } print_phys_hwgrp_state_t;
3939
3940 static boolean_t
print_phys_one_hwgrp_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)3941 print_phys_one_hwgrp_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
3942 {
3943 int i;
3944 boolean_t first = B_TRUE;
3945 int start = -1;
3946 int end = -1;
3947 char ringstr[RINGSTRLEN];
3948 char ringsubstr[RINGSTRLEN];
3949
3950 print_phys_hwgrp_state_t *hg_state = ofarg->ofmt_cbarg;
3951 dladm_hwgrp_attr_t *attr = hg_state->hs_grp_attr;
3952
3953 switch (ofarg->ofmt_id) {
3954 case PHYS_H_LINK:
3955 (void) snprintf(buf, bufsize, "%s", attr->hg_link_name);
3956 break;
3957 case PHYS_H_RINGTYPE:
3958 (void) snprintf(buf, bufsize, "%s",
3959 attr->hg_grp_type == DLADM_HWGRP_TYPE_RX ? "RX" : "TX");
3960 break;
3961 case PHYS_H_RINGS:
3962 ringstr[0] = '\0';
3963 for (i = 0; i < attr->hg_n_rings; i++) {
3964 uint_t index = attr->hg_rings[i];
3965
3966 if (start == -1) {
3967 start = index;
3968 end = index;
3969 } else if (index == end + 1) {
3970 end = index;
3971 } else {
3972 if (start == end) {
3973 if (first) {
3974 (void) snprintf(
3975 ringsubstr,
3976 RINGSTRLEN, "%d",
3977 start);
3978 first = B_FALSE;
3979 } else {
3980 (void) snprintf(
3981 ringsubstr,
3982 RINGSTRLEN, ",%d",
3983 start);
3984 }
3985 } else {
3986 if (first) {
3987 (void) snprintf(
3988 ringsubstr,
3989 RINGSTRLEN,
3990 "%d-%d",
3991 start, end);
3992 first = B_FALSE;
3993 } else {
3994 (void) snprintf(
3995 ringsubstr,
3996 RINGSTRLEN,
3997 ",%d-%d",
3998 start, end);
3999 }
4000 }
4001 (void) strlcat(ringstr, ringsubstr,
4002 RINGSTRLEN);
4003 start = index;
4004 end = index;
4005 }
4006 }
4007 /* The last one */
4008 if (start != -1) {
4009 if (first) {
4010 if (start == end) {
4011 (void) snprintf(buf, bufsize, "%d",
4012 start);
4013 } else {
4014 (void) snprintf(buf, bufsize, "%d-%d",
4015 start, end);
4016 }
4017 } else {
4018 if (start == end) {
4019 (void) snprintf(ringsubstr, RINGSTRLEN,
4020 ",%d", start);
4021 } else {
4022 (void) snprintf(ringsubstr, RINGSTRLEN,
4023 ",%d-%d", start, end);
4024 }
4025 (void) strlcat(ringstr, ringsubstr, RINGSTRLEN);
4026 (void) snprintf(buf, bufsize, "%s", ringstr);
4027 }
4028 }
4029 break;
4030 case PHYS_H_CLIENTS:
4031 if (attr->hg_client_names[0] == '\0') {
4032 (void) snprintf(buf, bufsize, "--");
4033 } else {
4034 (void) snprintf(buf, bufsize, "%s ",
4035 attr->hg_client_names);
4036 }
4037 break;
4038 }
4039
4040 return (B_TRUE);
4041 }
4042
4043 /*
4044 * callback for dladm_walk_macaddr, invoked for each MAC address slot
4045 */
4046 static boolean_t
print_phys_mac_callback(void * arg,dladm_macaddr_attr_t * attr)4047 print_phys_mac_callback(void *arg, dladm_macaddr_attr_t *attr)
4048 {
4049 print_phys_mac_state_t *mac_state = arg;
4050 show_state_t *state = mac_state->ms_state;
4051
4052 mac_state->ms_mac_attr = attr;
4053 ofmt_print(state->ls_ofmt, mac_state);
4054
4055 return (B_TRUE);
4056 }
4057
4058 /*
4059 * invoked by show-phys -m for each physical data-link
4060 */
4061 static dladm_status_t
print_phys_mac(show_state_t * state,datalink_id_t linkid,char * link)4062 print_phys_mac(show_state_t *state, datalink_id_t linkid, char *link)
4063 {
4064 print_phys_mac_state_t mac_state;
4065
4066 mac_state.ms_state = state;
4067 mac_state.ms_link = link;
4068
4069 return (dladm_walk_macaddr(handle, linkid, &mac_state,
4070 print_phys_mac_callback));
4071 }
4072
4073 /*
4074 * callback for dladm_walk_hwgrp, invoked for each MAC hwgrp
4075 */
4076 static boolean_t
print_phys_hwgrp_callback(void * arg,dladm_hwgrp_attr_t * attr)4077 print_phys_hwgrp_callback(void *arg, dladm_hwgrp_attr_t *attr)
4078 {
4079 print_phys_hwgrp_state_t *hwgrp_state = arg;
4080 show_state_t *state = hwgrp_state->hs_state;
4081
4082 hwgrp_state->hs_grp_attr = attr;
4083 ofmt_print(state->ls_ofmt, hwgrp_state);
4084
4085 return (B_TRUE);
4086 }
4087
4088 /* invoked by show-phys -H for each physical data-link */
4089 static dladm_status_t
print_phys_hwgrp(show_state_t * state,datalink_id_t linkid,char * link)4090 print_phys_hwgrp(show_state_t *state, datalink_id_t linkid, char *link)
4091 {
4092 print_phys_hwgrp_state_t hwgrp_state;
4093
4094 hwgrp_state.hs_state = state;
4095 hwgrp_state.hs_link = link;
4096 return (dladm_walk_hwgrp(handle, linkid, &hwgrp_state,
4097 print_phys_hwgrp_callback));
4098 }
4099
4100 /*
4101 * Parse the "local=<laddr>,remote=<raddr>" sub-options for the -a option of
4102 * *-iptun subcommands.
4103 */
4104 static void
iptun_process_addrarg(char * addrarg,iptun_params_t * params)4105 iptun_process_addrarg(char *addrarg, iptun_params_t *params)
4106 {
4107 char *addrval;
4108
4109 while (*addrarg != '\0') {
4110 switch (getsubopt(&addrarg, iptun_addropts, &addrval)) {
4111 case IPTUN_LOCAL:
4112 if (addrval == NULL)
4113 die("tunnel source address value is missing");
4114 params->iptun_param_flags |= IPTUN_PARAM_LADDR;
4115 if (strlcpy(params->iptun_param_laddr, addrval,
4116 sizeof (params->iptun_param_laddr)) >=
4117 sizeof (params->iptun_param_laddr))
4118 die("tunnel source address is too long");
4119 break;
4120 case IPTUN_REMOTE:
4121 if (addrval == NULL)
4122 die("tunnel destination address value "
4123 "is missing");
4124 params->iptun_param_flags |= IPTUN_PARAM_RADDR;
4125 if (strlcpy(params->iptun_param_raddr, addrval,
4126 sizeof (params->iptun_param_raddr)) >=
4127 sizeof (params->iptun_param_raddr))
4128 die("tunnel destination address is too long");
4129 break;
4130 default:
4131 die("invalid address type: %s", addrval);
4132 break;
4133 }
4134 }
4135 }
4136
4137 /*
4138 * Convenience routine to process iptun-create/modify/delete subcommand
4139 * arguments.
4140 */
4141 static void
iptun_process_args(int argc,char * argv[],const char * opts,iptun_params_t * params,uint32_t * flags,char * name,const char * use)4142 iptun_process_args(int argc, char *argv[], const char *opts,
4143 iptun_params_t *params, uint32_t *flags, char *name, const char *use)
4144 {
4145 int option;
4146 char *altroot = NULL;
4147
4148 if (params != NULL)
4149 bzero(params, sizeof (*params));
4150 *flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4151
4152 opterr = 0;
4153 while ((option = getopt_long(argc, argv, opts, iptun_lopts, NULL)) !=
4154 -1) {
4155 switch (option) {
4156 case 'a':
4157 iptun_process_addrarg(optarg, params);
4158 break;
4159 case 'R':
4160 altroot = optarg;
4161 break;
4162 case 't':
4163 *flags &= ~DLADM_OPT_PERSIST;
4164 break;
4165 case 'T':
4166 params->iptun_param_type = iptun_gettypebyname(optarg);
4167 if (params->iptun_param_type == IPTUN_TYPE_UNKNOWN)
4168 die("unknown tunnel type: %s", optarg);
4169 params->iptun_param_flags |= IPTUN_PARAM_TYPE;
4170 break;
4171 default:
4172 die_opterr(optopt, option, use);
4173 break;
4174 }
4175 }
4176
4177 /* Get the required tunnel name argument. */
4178 if (argc - optind != 1)
4179 usage();
4180
4181 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
4182 die("tunnel name is too long");
4183
4184 if (altroot != NULL)
4185 altroot_cmd(altroot, argc, argv);
4186 }
4187
4188 static void
do_create_iptun(int argc,char * argv[],const char * use)4189 do_create_iptun(int argc, char *argv[], const char *use)
4190 {
4191 iptun_params_t params;
4192 dladm_status_t status;
4193 uint32_t flags;
4194 char name[MAXLINKNAMELEN];
4195
4196 iptun_process_args(argc, argv, ":a:R:tT:", ¶ms, &flags, name,
4197 use);
4198
4199 status = dladm_iptun_create(handle, name, ¶ms, flags);
4200 if (status != DLADM_STATUS_OK)
4201 die_dlerr(status, "could not create tunnel");
4202 }
4203
4204 static void
do_delete_iptun(int argc,char * argv[],const char * use)4205 do_delete_iptun(int argc, char *argv[], const char *use)
4206 {
4207 uint32_t flags;
4208 datalink_id_t linkid;
4209 dladm_status_t status;
4210 char name[MAXLINKNAMELEN];
4211
4212 iptun_process_args(argc, argv, ":R:t", NULL, &flags, name, use);
4213
4214 status = dladm_name2info(handle, name, &linkid, NULL, NULL, NULL);
4215 if (status != DLADM_STATUS_OK)
4216 die_dlerr(status, "could not delete tunnel");
4217 status = dladm_iptun_delete(handle, linkid, flags);
4218 if (status != DLADM_STATUS_OK)
4219 die_dlerr(status, "could not delete tunnel");
4220 }
4221
4222 static void
do_modify_iptun(int argc,char * argv[],const char * use)4223 do_modify_iptun(int argc, char *argv[], const char *use)
4224 {
4225 iptun_params_t params;
4226 uint32_t flags;
4227 dladm_status_t status;
4228 char name[MAXLINKNAMELEN];
4229
4230 iptun_process_args(argc, argv, ":a:R:t", ¶ms, &flags, name, use);
4231
4232 if ((status = dladm_name2info(handle, name, ¶ms.iptun_param_linkid,
4233 NULL, NULL, NULL)) != DLADM_STATUS_OK)
4234 die_dlerr(status, "could not modify tunnel");
4235 status = dladm_iptun_modify(handle, ¶ms, flags);
4236 if (status != DLADM_STATUS_OK)
4237 die_dlerr(status, "could not modify tunnel");
4238 }
4239
4240 static void
do_show_iptun(int argc,char * argv[],const char * use)4241 do_show_iptun(int argc, char *argv[], const char *use)
4242 {
4243 int option;
4244 datalink_id_t linkid;
4245 uint32_t flags = DLADM_OPT_ACTIVE;
4246 char *name = NULL;
4247 dladm_status_t status;
4248 const char *fields_str = NULL;
4249 show_state_t state;
4250 ofmt_handle_t ofmt;
4251 ofmt_status_t oferr;
4252 uint_t ofmtflags = 0;
4253
4254 bzero(&state, sizeof (state));
4255 opterr = 0;
4256 while ((option = getopt_long(argc, argv, ":pPo:",
4257 iptun_lopts, NULL)) != -1) {
4258 switch (option) {
4259 case 'o':
4260 fields_str = optarg;
4261 break;
4262 case 'p':
4263 state.ls_parsable = B_TRUE;
4264 ofmtflags = OFMT_PARSABLE;
4265 break;
4266 case 'P':
4267 flags = DLADM_OPT_PERSIST;
4268 break;
4269 default:
4270 die_opterr(optopt, option, use);
4271 break;
4272 }
4273 }
4274
4275 /*
4276 * Get the optional tunnel name argument. If there is one, it must
4277 * be the last thing remaining on the command-line.
4278 */
4279 if (argc - optind > 1)
4280 die(gettext(use));
4281 if (argc - optind == 1)
4282 name = argv[optind];
4283
4284 oferr = ofmt_open(fields_str, iptun_fields, ofmtflags,
4285 DLADM_DEFAULT_COL, &ofmt);
4286 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4287
4288 state.ls_ofmt = ofmt;
4289 state.ls_flags = flags;
4290
4291 if (name == NULL) {
4292 (void) dladm_walk_datalink_id(print_iptun_walker, handle,
4293 &state, DATALINK_CLASS_IPTUN, DATALINK_ANY_MEDIATYPE,
4294 flags);
4295 status = state.ls_status;
4296 } else {
4297 if ((status = dladm_name2info(handle, name, &linkid, NULL, NULL,
4298 NULL)) == DLADM_STATUS_OK)
4299 status = print_iptun(handle, linkid, &state);
4300 }
4301
4302 if (status != DLADM_STATUS_OK)
4303 die_dlerr(status, "unable to obtain tunnel status");
4304 }
4305
4306 /* ARGSUSED */
4307 static void
do_up_iptun(int argc,char * argv[],const char * use)4308 do_up_iptun(int argc, char *argv[], const char *use)
4309 {
4310 datalink_id_t linkid = DATALINK_ALL_LINKID;
4311 dladm_status_t status = DLADM_STATUS_OK;
4312
4313 /*
4314 * Get the optional tunnel name argument. If there is one, it must
4315 * be the last thing remaining on the command-line.
4316 */
4317 if (argc - optind > 1)
4318 usage();
4319 if (argc - optind == 1) {
4320 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
4321 NULL, NULL);
4322 }
4323 if (status == DLADM_STATUS_OK)
4324 status = dladm_iptun_up(handle, linkid);
4325 if (status != DLADM_STATUS_OK)
4326 die_dlerr(status, "unable to configure IP tunnel links");
4327 }
4328
4329 /* ARGSUSED */
4330 static void
do_down_iptun(int argc,char * argv[],const char * use)4331 do_down_iptun(int argc, char *argv[], const char *use)
4332 {
4333 datalink_id_t linkid = DATALINK_ALL_LINKID;
4334 dladm_status_t status = DLADM_STATUS_OK;
4335
4336 /*
4337 * Get the optional tunnel name argument. If there is one, it must
4338 * be the last thing remaining on the command-line.
4339 */
4340 if (argc - optind > 1)
4341 usage();
4342 if (argc - optind == 1) {
4343 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
4344 NULL, NULL);
4345 }
4346 if (status == DLADM_STATUS_OK)
4347 status = dladm_iptun_down(handle, linkid);
4348 if (status != DLADM_STATUS_OK)
4349 die_dlerr(status, "unable to bring down IP tunnel links");
4350 }
4351
4352 static iptun_type_t
iptun_gettypebyname(char * typestr)4353 iptun_gettypebyname(char *typestr)
4354 {
4355 int i;
4356
4357 for (i = 0; iptun_types[i].type_name != NULL; i++) {
4358 if (strncmp(iptun_types[i].type_name, typestr,
4359 strlen(iptun_types[i].type_name)) == 0) {
4360 return (iptun_types[i].type_value);
4361 }
4362 }
4363 return (IPTUN_TYPE_UNKNOWN);
4364 }
4365
4366 static const char *
iptun_gettypebyvalue(iptun_type_t type)4367 iptun_gettypebyvalue(iptun_type_t type)
4368 {
4369 int i;
4370
4371 for (i = 0; iptun_types[i].type_name != NULL; i++) {
4372 if (iptun_types[i].type_value == type)
4373 return (iptun_types[i].type_name);
4374 }
4375 return (NULL);
4376 }
4377
4378 static dladm_status_t
print_iptun(dladm_handle_t dh,datalink_id_t linkid,show_state_t * state)4379 print_iptun(dladm_handle_t dh, datalink_id_t linkid, show_state_t *state)
4380 {
4381 dladm_status_t status;
4382 iptun_params_t params;
4383 iptun_fields_buf_t lbuf;
4384 const char *laddr;
4385 const char *raddr;
4386
4387 params.iptun_param_linkid = linkid;
4388 status = dladm_iptun_getparams(dh, ¶ms, state->ls_flags);
4389 if (status != DLADM_STATUS_OK)
4390 return (status);
4391
4392 /* LINK */
4393 status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL,
4394 lbuf.iptun_name, sizeof (lbuf.iptun_name));
4395 if (status != DLADM_STATUS_OK)
4396 return (status);
4397
4398 /* TYPE */
4399 (void) strlcpy(lbuf.iptun_type,
4400 iptun_gettypebyvalue(params.iptun_param_type),
4401 sizeof (lbuf.iptun_type));
4402
4403 /* FLAGS */
4404 (void) memset(lbuf.iptun_flags, '-', IPTUN_NUM_FLAGS);
4405 lbuf.iptun_flags[IPTUN_NUM_FLAGS] = '\0';
4406 if (params.iptun_param_flags & IPTUN_PARAM_IPSECPOL)
4407 lbuf.iptun_flags[IPTUN_SFLAG_INDEX] = 's';
4408 if (params.iptun_param_flags & IPTUN_PARAM_IMPLICIT)
4409 lbuf.iptun_flags[IPTUN_IFLAG_INDEX] = 'i';
4410
4411 /* LOCAL */
4412 if (params.iptun_param_flags & IPTUN_PARAM_LADDR)
4413 laddr = params.iptun_param_laddr;
4414 else
4415 laddr = (state->ls_parsable) ? "" : "--";
4416 (void) strlcpy(lbuf.iptun_laddr, laddr, sizeof (lbuf.iptun_laddr));
4417
4418 /* REMOTE */
4419 if (params.iptun_param_flags & IPTUN_PARAM_RADDR)
4420 raddr = params.iptun_param_raddr;
4421 else
4422 raddr = (state->ls_parsable) ? "" : "--";
4423 (void) strlcpy(lbuf.iptun_raddr, raddr, sizeof (lbuf.iptun_raddr));
4424
4425 ofmt_print(state->ls_ofmt, &lbuf);
4426
4427 return (DLADM_STATUS_OK);
4428 }
4429
4430 static int
print_iptun_walker(dladm_handle_t dh,datalink_id_t linkid,void * arg)4431 print_iptun_walker(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4432 {
4433 ((show_state_t *)arg)->ls_status = print_iptun(dh, linkid, arg);
4434 return (DLADM_WALK_CONTINUE);
4435 }
4436
4437 static dladm_status_t
print_phys(show_state_t * state,datalink_id_t linkid)4438 print_phys(show_state_t *state, datalink_id_t linkid)
4439 {
4440 char link[MAXLINKNAMELEN];
4441 uint32_t flags;
4442 dladm_status_t status;
4443 datalink_class_t class;
4444 uint32_t media;
4445
4446 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
4447 &media, link, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
4448 goto done;
4449 }
4450
4451 if (class != DATALINK_CLASS_PHYS) {
4452 status = DLADM_STATUS_BADARG;
4453 goto done;
4454 }
4455
4456 if (!(state->ls_flags & flags)) {
4457 status = DLADM_STATUS_NOTFOUND;
4458 goto done;
4459 }
4460
4461 if (state->ls_mac)
4462 status = print_phys_mac(state, linkid, link);
4463 else if (state->ls_hwgrp)
4464 status = print_phys_hwgrp(state, linkid, link);
4465 else
4466 status = print_phys_default(state, linkid, link, flags, media);
4467
4468 done:
4469 return (status);
4470 }
4471
4472 /* ARGSUSED */
4473 static int
show_phys(dladm_handle_t dh,datalink_id_t linkid,void * arg)4474 show_phys(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4475 {
4476 show_state_t *state = arg;
4477
4478 state->ls_status = print_phys(state, linkid);
4479 return (DLADM_WALK_CONTINUE);
4480 }
4481
4482 /*
4483 * Print the active topology information.
4484 */
4485 static dladm_status_t
print_vlan(show_state_t * state,datalink_id_t linkid,link_fields_buf_t * l)4486 print_vlan(show_state_t *state, datalink_id_t linkid, link_fields_buf_t *l)
4487 {
4488 dladm_vlan_attr_t vinfo;
4489 uint32_t flags;
4490 dladm_status_t status;
4491
4492 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL, NULL,
4493 l->link_name, sizeof (l->link_name))) != DLADM_STATUS_OK) {
4494 goto done;
4495 }
4496
4497 if (!(state->ls_flags & flags)) {
4498 status = DLADM_STATUS_NOTFOUND;
4499 goto done;
4500 }
4501
4502 if ((status = dladm_vlan_info(handle, linkid, &vinfo,
4503 state->ls_flags)) != DLADM_STATUS_OK ||
4504 (status = dladm_datalink_id2info(handle, vinfo.dv_linkid, NULL,
4505 NULL, NULL, l->link_over, sizeof (l->link_over))) !=
4506 DLADM_STATUS_OK) {
4507 goto done;
4508 }
4509
4510 (void) snprintf(l->link_vlan_vid, sizeof (l->link_vlan_vid), "%d",
4511 vinfo.dv_vid);
4512 (void) snprintf(l->link_flags, sizeof (l->link_flags), "%c----",
4513 vinfo.dv_force ? 'f' : '-');
4514
4515 done:
4516 return (status);
4517 }
4518
4519 /* ARGSUSED */
4520 static int
show_vlan(dladm_handle_t dh,datalink_id_t linkid,void * arg)4521 show_vlan(dladm_handle_t dh, datalink_id_t linkid, void *arg)
4522 {
4523 show_state_t *state = arg;
4524 dladm_status_t status;
4525 link_fields_buf_t lbuf;
4526
4527 bzero(&lbuf, sizeof (link_fields_buf_t));
4528 status = print_vlan(state, linkid, &lbuf);
4529 if (status != DLADM_STATUS_OK)
4530 goto done;
4531
4532 ofmt_print(state->ls_ofmt, &lbuf);
4533
4534 done:
4535 state->ls_status = status;
4536 return (DLADM_WALK_CONTINUE);
4537 }
4538
4539 static void
do_show_phys(int argc,char * argv[],const char * use)4540 do_show_phys(int argc, char *argv[], const char *use)
4541 {
4542 int option;
4543 uint32_t flags = DLADM_OPT_ACTIVE;
4544 boolean_t p_arg = B_FALSE;
4545 boolean_t o_arg = B_FALSE;
4546 boolean_t m_arg = B_FALSE;
4547 boolean_t H_arg = B_FALSE;
4548 datalink_id_t linkid = DATALINK_ALL_LINKID;
4549 show_state_t state;
4550 dladm_status_t status;
4551 char *fields_str = NULL;
4552 char *all_active_fields =
4553 "link,media,state,speed,duplex,device";
4554 char *all_inactive_fields = "link,device,media,flags";
4555 char *all_mac_fields = "link,slot,address,inuse,client";
4556 char *all_hwgrp_fields = "link,ringtype,rings,clients";
4557 const ofmt_field_t *pf;
4558 ofmt_handle_t ofmt;
4559 ofmt_status_t oferr;
4560 uint_t ofmtflags = 0;
4561
4562 bzero(&state, sizeof (state));
4563 opterr = 0;
4564 while ((option = getopt_long(argc, argv, ":pPo:mH",
4565 show_lopts, NULL)) != -1) {
4566 switch (option) {
4567 case 'p':
4568 if (p_arg)
4569 die_optdup(option);
4570
4571 p_arg = B_TRUE;
4572 break;
4573 case 'P':
4574 if (flags != DLADM_OPT_ACTIVE)
4575 die_optdup(option);
4576
4577 flags = DLADM_OPT_PERSIST;
4578 break;
4579 case 'o':
4580 o_arg = B_TRUE;
4581 fields_str = optarg;
4582 break;
4583 case 'm':
4584 m_arg = B_TRUE;
4585 break;
4586 case 'H':
4587 H_arg = B_TRUE;
4588 break;
4589 default:
4590 die_opterr(optopt, option, use);
4591 break;
4592 }
4593 }
4594
4595 if (p_arg && !o_arg)
4596 die("-p requires -o");
4597
4598 if (m_arg && H_arg)
4599 die("-m cannot combine with -H");
4600
4601 if (p_arg && strcasecmp(fields_str, "all") == 0)
4602 die("\"-o all\" is invalid with -p");
4603
4604 /* get link name (optional last argument) */
4605 if (optind == (argc-1)) {
4606 if ((status = dladm_name2info(handle, argv[optind], &linkid,
4607 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
4608 die_dlerr(status, "link %s is not valid", argv[optind]);
4609 }
4610 } else if (optind != argc) {
4611 usage();
4612 }
4613
4614 state.ls_parsable = p_arg;
4615 state.ls_flags = flags;
4616 state.ls_donefirst = B_FALSE;
4617 state.ls_mac = m_arg;
4618 state.ls_hwgrp = H_arg;
4619
4620 if (m_arg && !(flags & DLADM_OPT_ACTIVE)) {
4621 /*
4622 * We can only display the factory MAC addresses of
4623 * active data-links.
4624 */
4625 die("-m not compatible with -P");
4626 }
4627
4628 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
4629 if (state.ls_mac)
4630 fields_str = all_mac_fields;
4631 else if (state.ls_hwgrp)
4632 fields_str = all_hwgrp_fields;
4633 else if (state.ls_flags & DLADM_OPT_ACTIVE) {
4634 fields_str = all_active_fields;
4635 } else {
4636 fields_str = all_inactive_fields;
4637 }
4638 }
4639
4640 if (state.ls_mac) {
4641 pf = phys_m_fields;
4642 } else if (state.ls_hwgrp) {
4643 pf = phys_h_fields;
4644 } else {
4645 pf = phys_fields;
4646 }
4647
4648 if (state.ls_parsable)
4649 ofmtflags |= OFMT_PARSABLE;
4650 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
4651 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4652 state.ls_ofmt = ofmt;
4653
4654 if (linkid == DATALINK_ALL_LINKID) {
4655 (void) dladm_walk_datalink_id(show_phys, handle, &state,
4656 DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, flags);
4657 } else {
4658 (void) show_phys(handle, linkid, &state);
4659 if (state.ls_status != DLADM_STATUS_OK) {
4660 die_dlerr(state.ls_status,
4661 "failed to show physical link %s", argv[optind]);
4662 }
4663 }
4664 ofmt_close(ofmt);
4665 }
4666
4667 static void
do_show_vlan(int argc,char * argv[],const char * use)4668 do_show_vlan(int argc, char *argv[], const char *use)
4669 {
4670 int option;
4671 uint32_t flags = DLADM_OPT_ACTIVE;
4672 boolean_t p_arg = B_FALSE;
4673 datalink_id_t linkid = DATALINK_ALL_LINKID;
4674 show_state_t state;
4675 dladm_status_t status;
4676 boolean_t o_arg = B_FALSE;
4677 char *fields_str = NULL;
4678 ofmt_handle_t ofmt;
4679 ofmt_status_t oferr;
4680 uint_t ofmtflags = 0;
4681
4682 bzero(&state, sizeof (state));
4683
4684 opterr = 0;
4685 while ((option = getopt_long(argc, argv, ":pPo:",
4686 show_lopts, NULL)) != -1) {
4687 switch (option) {
4688 case 'p':
4689 if (p_arg)
4690 die_optdup(option);
4691
4692 p_arg = B_TRUE;
4693 break;
4694 case 'P':
4695 if (flags != DLADM_OPT_ACTIVE)
4696 die_optdup(option);
4697
4698 flags = DLADM_OPT_PERSIST;
4699 break;
4700 case 'o':
4701 o_arg = B_TRUE;
4702 fields_str = optarg;
4703 break;
4704 default:
4705 die_opterr(optopt, option, use);
4706 break;
4707 }
4708 }
4709
4710 /* get link name (optional last argument) */
4711 if (optind == (argc-1)) {
4712 if ((status = dladm_name2info(handle, argv[optind], &linkid,
4713 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
4714 die_dlerr(status, "link %s is not valid", argv[optind]);
4715 }
4716 } else if (optind != argc) {
4717 usage();
4718 }
4719
4720 state.ls_parsable = p_arg;
4721 state.ls_flags = flags;
4722 state.ls_donefirst = B_FALSE;
4723
4724 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))
4725 fields_str = NULL;
4726
4727 if (state.ls_parsable)
4728 ofmtflags |= OFMT_PARSABLE;
4729 oferr = ofmt_open(fields_str, vlan_fields, ofmtflags, 0, &ofmt);
4730 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
4731 state.ls_ofmt = ofmt;
4732
4733 if (linkid == DATALINK_ALL_LINKID) {
4734 (void) dladm_walk_datalink_id(show_vlan, handle, &state,
4735 DATALINK_CLASS_VLAN, DATALINK_ANY_MEDIATYPE, flags);
4736 } else {
4737 (void) show_vlan(handle, linkid, &state);
4738 if (state.ls_status != DLADM_STATUS_OK) {
4739 die_dlerr(state.ls_status, "failed to show vlan %s",
4740 argv[optind]);
4741 }
4742 }
4743 ofmt_close(ofmt);
4744 }
4745
4746 static void
do_create_vnic(int argc,char * argv[],const char * use)4747 do_create_vnic(int argc, char *argv[], const char *use)
4748 {
4749 datalink_id_t linkid, dev_linkid;
4750 char devname[MAXLINKNAMELEN];
4751 char name[MAXLINKNAMELEN];
4752 boolean_t l_arg = B_FALSE;
4753 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4754 char *altroot = NULL;
4755 int option;
4756 char *endp = NULL;
4757 dladm_status_t status;
4758 vnic_mac_addr_type_t mac_addr_type = VNIC_MAC_ADDR_TYPE_UNKNOWN;
4759 uchar_t *mac_addr = NULL;
4760 int mac_slot = -1;
4761 uint_t maclen = 0, mac_prefix_len = 0;
4762 char propstr[DLADM_STRSIZE];
4763 dladm_arg_list_t *proplist = NULL;
4764 int vid = 0;
4765 int af = AF_UNSPEC;
4766 vrid_t vrid = VRRP_VRID_NONE;
4767
4768 opterr = 0;
4769 bzero(propstr, DLADM_STRSIZE);
4770
4771 while ((option = getopt_long(argc, argv, ":tfR:l:m:n:p:r:v:V:A:H",
4772 vnic_lopts, NULL)) != -1) {
4773 switch (option) {
4774 case 't':
4775 flags &= ~DLADM_OPT_PERSIST;
4776 break;
4777 case 'R':
4778 altroot = optarg;
4779 break;
4780 case 'l':
4781 if (strlcpy(devname, optarg, MAXLINKNAMELEN) >=
4782 MAXLINKNAMELEN)
4783 die("link name too long");
4784 l_arg = B_TRUE;
4785 break;
4786 case 'm':
4787 if (mac_addr_type != VNIC_MAC_ADDR_TYPE_UNKNOWN)
4788 die("cannot specify -m option twice");
4789
4790 if (strcmp(optarg, "fixed") == 0) {
4791 /*
4792 * A fixed MAC address must be specified
4793 * by its value, not by the keyword 'fixed'.
4794 */
4795 die("'fixed' is not a valid MAC address");
4796 }
4797 if (dladm_vnic_str2macaddrtype(optarg,
4798 &mac_addr_type) != DLADM_STATUS_OK) {
4799 mac_addr_type = VNIC_MAC_ADDR_TYPE_FIXED;
4800 /* MAC address specified by value */
4801 mac_addr = _link_aton(optarg, (int *)&maclen);
4802 if (mac_addr == NULL) {
4803 if (maclen == (uint_t)-1)
4804 die("invalid MAC address");
4805 else
4806 die("out of memory");
4807 }
4808 }
4809 break;
4810 case 'n':
4811 errno = 0;
4812 mac_slot = (int)strtol(optarg, &endp, 10);
4813 if (errno != 0 || *endp != '\0')
4814 die("invalid slot number");
4815 break;
4816 case 'p':
4817 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
4818 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
4819 DLADM_STRSIZE)
4820 die("property list too long '%s'", propstr);
4821 break;
4822 case 'r':
4823 mac_addr = _link_aton(optarg, (int *)&mac_prefix_len);
4824 if (mac_addr == NULL) {
4825 if (mac_prefix_len == (uint_t)-1)
4826 die("invalid MAC address");
4827 else
4828 die("out of memory");
4829 }
4830 break;
4831 case 'V':
4832 if (!str2int(optarg, (int *)&vrid) ||
4833 vrid < VRRP_VRID_MIN || vrid > VRRP_VRID_MAX) {
4834 die("invalid VRRP identifier '%s'", optarg);
4835 }
4836
4837 break;
4838 case 'A':
4839 if (strcmp(optarg, "inet") == 0)
4840 af = AF_INET;
4841 else if (strcmp(optarg, "inet6") == 0)
4842 af = AF_INET6;
4843 else
4844 die("invalid address family '%s'", optarg);
4845 break;
4846 case 'v':
4847 if (vid != 0)
4848 die_optdup(option);
4849
4850 if (!str2int(optarg, &vid) || vid < 1 || vid > 4094)
4851 die("invalid VLAN identifier '%s'", optarg);
4852
4853 break;
4854 case 'f':
4855 flags |= DLADM_OPT_FORCE;
4856 break;
4857 default:
4858 die_opterr(optopt, option, use);
4859 }
4860 }
4861
4862 if (mac_addr_type == VNIC_MAC_ADDR_TYPE_UNKNOWN)
4863 mac_addr_type = VNIC_MAC_ADDR_TYPE_AUTO;
4864
4865 /*
4866 * 'f' - force, flag can be specified only with 'v' - vlan.
4867 */
4868 if ((flags & DLADM_OPT_FORCE) != 0 && vid == 0)
4869 die("-f option can only be used with -v");
4870
4871 if (mac_prefix_len != 0 && mac_addr_type != VNIC_MAC_ADDR_TYPE_RANDOM &&
4872 mac_addr_type != VNIC_MAC_ADDR_TYPE_FIXED)
4873 usage();
4874
4875 if (mac_addr_type == VNIC_MAC_ADDR_TYPE_VRID) {
4876 if (vrid == VRRP_VRID_NONE || af == AF_UNSPEC ||
4877 mac_addr != NULL || maclen != 0 || mac_slot != -1 ||
4878 mac_prefix_len != 0) {
4879 usage();
4880 }
4881 } else if ((af != AF_UNSPEC || vrid != VRRP_VRID_NONE)) {
4882 usage();
4883 }
4884
4885 /* check required options */
4886 if (!l_arg)
4887 usage();
4888
4889 if (mac_slot != -1 && mac_addr_type != VNIC_MAC_ADDR_TYPE_FACTORY)
4890 usage();
4891
4892 /* the VNIC id is the required operand */
4893 if (optind != (argc - 1))
4894 usage();
4895
4896 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
4897 die("link name too long '%s'", argv[optind]);
4898
4899 if (!dladm_valid_linkname(name))
4900 die("invalid link name '%s'", argv[optind]);
4901
4902 if (altroot != NULL)
4903 altroot_cmd(altroot, argc, argv);
4904
4905 if (dladm_name2info(handle, devname, &dev_linkid, NULL, NULL, NULL) !=
4906 DLADM_STATUS_OK)
4907 die("invalid link name '%s'", devname);
4908
4909 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
4910 != DLADM_STATUS_OK)
4911 die("invalid vnic property");
4912
4913 status = dladm_vnic_create(handle, name, dev_linkid, mac_addr_type,
4914 mac_addr, maclen, &mac_slot, mac_prefix_len, vid, vrid, af,
4915 &linkid, proplist, &errlist, flags);
4916 switch (status) {
4917 case DLADM_STATUS_OK:
4918 break;
4919
4920 case DLADM_STATUS_LINKBUSY:
4921 die("VLAN over '%s' may not use default_tag ID "
4922 "(see dladm(8))", devname);
4923 break;
4924
4925 default:
4926 die_dlerrlist(status, &errlist, "vnic creation over %s failed",
4927 devname);
4928 }
4929
4930 dladm_free_props(proplist);
4931 free(mac_addr);
4932 }
4933
4934 static void
do_etherstub_check(const char * name,datalink_id_t linkid,boolean_t etherstub,uint32_t flags)4935 do_etherstub_check(const char *name, datalink_id_t linkid, boolean_t etherstub,
4936 uint32_t flags)
4937 {
4938 boolean_t is_etherstub;
4939 dladm_vnic_attr_t attr;
4940
4941 if (dladm_vnic_info(handle, linkid, &attr, flags) != DLADM_STATUS_OK) {
4942 /*
4943 * Let the delete continue anyway.
4944 */
4945 return;
4946 }
4947 is_etherstub = (attr.va_link_id == DATALINK_INVALID_LINKID);
4948 if (is_etherstub != etherstub) {
4949 die("'%s' is not %s", name,
4950 (is_etherstub ? "a vnic" : "an etherstub"));
4951 }
4952 }
4953
4954 static void
do_delete_vnic_common(int argc,char * argv[],const char * use,boolean_t etherstub)4955 do_delete_vnic_common(int argc, char *argv[], const char *use,
4956 boolean_t etherstub)
4957 {
4958 int option;
4959 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
4960 datalink_id_t linkid;
4961 char *altroot = NULL;
4962 dladm_status_t status;
4963
4964 opterr = 0;
4965 while ((option = getopt_long(argc, argv, ":R:t", lopts,
4966 NULL)) != -1) {
4967 switch (option) {
4968 case 't':
4969 flags &= ~DLADM_OPT_PERSIST;
4970 break;
4971 case 'R':
4972 altroot = optarg;
4973 break;
4974 default:
4975 die_opterr(optopt, option, use);
4976 }
4977 }
4978
4979 /* get vnic name (required last argument) */
4980 if (optind != (argc - 1))
4981 usage();
4982
4983 if (altroot != NULL)
4984 altroot_cmd(altroot, argc, argv);
4985
4986 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
4987 NULL);
4988 if (status != DLADM_STATUS_OK)
4989 die("invalid link name '%s'", argv[optind]);
4990
4991 if ((flags & DLADM_OPT_ACTIVE) != 0) {
4992 do_etherstub_check(argv[optind], linkid, etherstub,
4993 DLADM_OPT_ACTIVE);
4994 }
4995 if ((flags & DLADM_OPT_PERSIST) != 0) {
4996 do_etherstub_check(argv[optind], linkid, etherstub,
4997 DLADM_OPT_PERSIST);
4998 }
4999
5000 status = dladm_vnic_delete(handle, linkid, flags);
5001 if (status != DLADM_STATUS_OK)
5002 die_dlerr(status, "vnic deletion failed");
5003 }
5004
5005 static void
do_delete_vnic(int argc,char * argv[],const char * use)5006 do_delete_vnic(int argc, char *argv[], const char *use)
5007 {
5008 do_delete_vnic_common(argc, argv, use, B_FALSE);
5009 }
5010
5011 /* ARGSUSED */
5012 static void
do_up_vnic_common(int argc,char * argv[],const char * use,boolean_t vlan)5013 do_up_vnic_common(int argc, char *argv[], const char *use, boolean_t vlan)
5014 {
5015 datalink_id_t linkid = DATALINK_ALL_LINKID;
5016 dladm_status_t status;
5017 char *type;
5018
5019 type = vlan ? "vlan" : "vnic";
5020
5021 /*
5022 * get the id or the name of the vnic/vlan (optional last argument)
5023 */
5024 if (argc == 2) {
5025 status = dladm_name2info(handle, argv[1], &linkid, NULL, NULL,
5026 NULL);
5027 if (status != DLADM_STATUS_OK)
5028 goto done;
5029
5030 } else if (argc > 2) {
5031 usage();
5032 }
5033
5034 if (vlan)
5035 status = dladm_vlan_up(handle, linkid);
5036 else
5037 status = dladm_vnic_up(handle, linkid, 0);
5038
5039 done:
5040 if (status != DLADM_STATUS_OK) {
5041 if (argc == 2) {
5042 die_dlerr(status,
5043 "could not bring up %s '%s'", type, argv[1]);
5044 } else {
5045 die_dlerr(status, "could not bring %ss up", type);
5046 }
5047 }
5048 }
5049
5050 static void
do_up_vnic(int argc,char * argv[],const char * use)5051 do_up_vnic(int argc, char *argv[], const char *use)
5052 {
5053 do_up_vnic_common(argc, argv, use, B_FALSE);
5054 }
5055
5056 static void
dump_vnics_head(const char * dev)5057 dump_vnics_head(const char *dev)
5058 {
5059 if (strlen(dev))
5060 (void) printf("%s", dev);
5061
5062 (void) printf("\tipackets rbytes opackets obytes ");
5063
5064 if (strlen(dev))
5065 (void) printf("%%ipkts %%opkts\n");
5066 else
5067 (void) printf("\n");
5068 }
5069
5070 static void
dump_vnic_stat(const char * name,datalink_id_t vnic_id,show_vnic_state_t * state,pktsum_t * vnic_stats,pktsum_t * tot_stats)5071 dump_vnic_stat(const char *name, datalink_id_t vnic_id,
5072 show_vnic_state_t *state, pktsum_t *vnic_stats, pktsum_t *tot_stats)
5073 {
5074 pktsum_t diff_stats;
5075 pktsum_t *old_stats = &state->vs_prevstats[vnic_id];
5076
5077 dladm_stats_diff(&diff_stats, vnic_stats, old_stats);
5078
5079 (void) printf("%s", name);
5080
5081 (void) printf("\t%-10llu", diff_stats.ipackets);
5082 (void) printf("%-12llu", diff_stats.rbytes);
5083 (void) printf("%-10llu", diff_stats.opackets);
5084 (void) printf("%-12llu", diff_stats.obytes);
5085
5086 if (tot_stats) {
5087 if (tot_stats->ipackets == 0) {
5088 (void) printf("\t-");
5089 } else {
5090 (void) printf("\t%-6.1f", (double)diff_stats.ipackets/
5091 (double)tot_stats->ipackets * 100);
5092 }
5093 if (tot_stats->opackets == 0) {
5094 (void) printf("\t-");
5095 } else {
5096 (void) printf("\t%-6.1f", (double)diff_stats.opackets/
5097 (double)tot_stats->opackets * 100);
5098 }
5099 }
5100 (void) printf("\n");
5101
5102 *old_stats = *vnic_stats;
5103 }
5104
5105 /*
5106 * Called from the walker dladm_vnic_walk_sys() for each vnic to display
5107 * vnic information or statistics.
5108 */
5109 static dladm_status_t
print_vnic(show_vnic_state_t * state,datalink_id_t linkid)5110 print_vnic(show_vnic_state_t *state, datalink_id_t linkid)
5111 {
5112 dladm_vnic_attr_t attr, *vnic = &attr;
5113 dladm_status_t status;
5114 boolean_t is_etherstub;
5115 char devname[MAXLINKNAMELEN];
5116 char vnic_name[MAXLINKNAMELEN];
5117 char mstr[MAXMACADDRLEN * 3];
5118 vnic_fields_buf_t vbuf;
5119
5120 if ((status = dladm_vnic_info(handle, linkid, vnic, state->vs_flags)) !=
5121 DLADM_STATUS_OK)
5122 return (status);
5123
5124 is_etherstub = (vnic->va_link_id == DATALINK_INVALID_LINKID);
5125 if (state->vs_etherstub != is_etherstub) {
5126 /*
5127 * Want all etherstub but it's not one, or want
5128 * non-etherstub and it's one.
5129 */
5130 return (DLADM_STATUS_OK);
5131 }
5132
5133 if (state->vs_link_id != DATALINK_ALL_LINKID) {
5134 if (state->vs_link_id != vnic->va_link_id)
5135 return (DLADM_STATUS_OK);
5136 }
5137
5138 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
5139 NULL, vnic_name, sizeof (vnic_name)) != DLADM_STATUS_OK)
5140 return (DLADM_STATUS_BADARG);
5141
5142 bzero(devname, sizeof (devname));
5143 if (!is_etherstub &&
5144 dladm_datalink_id2info(handle, vnic->va_link_id, NULL, NULL,
5145 NULL, devname, sizeof (devname)) != DLADM_STATUS_OK)
5146 (void) sprintf(devname, "?");
5147
5148 state->vs_found = B_TRUE;
5149 if (state->vs_stats) {
5150 /* print vnic statistics */
5151 pktsum_t vnic_stats;
5152
5153 if (state->vs_firstonly) {
5154 if (state->vs_donefirst)
5155 return (0);
5156 state->vs_donefirst = B_TRUE;
5157 }
5158
5159 if (!state->vs_printstats) {
5160 /*
5161 * get vnic statistics and add to the sum for the
5162 * named device.
5163 */
5164 get_link_stats(vnic_name, &vnic_stats);
5165 dladm_stats_total(&state->vs_totalstats, &vnic_stats,
5166 &state->vs_prevstats[vnic->va_vnic_id]);
5167 } else {
5168 /* get and print vnic statistics */
5169 get_link_stats(vnic_name, &vnic_stats);
5170 dump_vnic_stat(vnic_name, linkid, state, &vnic_stats,
5171 &state->vs_totalstats);
5172 }
5173 return (DLADM_STATUS_OK);
5174 } else {
5175 (void) snprintf(vbuf.vnic_link, sizeof (vbuf.vnic_link),
5176 "%s", vnic_name);
5177
5178 if (!is_etherstub) {
5179
5180 (void) snprintf(vbuf.vnic_over, sizeof (vbuf.vnic_over),
5181 "%s", devname);
5182 (void) snprintf(vbuf.vnic_speed,
5183 sizeof (vbuf.vnic_speed), "%u",
5184 (uint_t)((get_ifspeed(vnic_name, B_TRUE))
5185 / 1000000ull));
5186
5187 switch (vnic->va_mac_addr_type) {
5188 case VNIC_MAC_ADDR_TYPE_FIXED:
5189 case VNIC_MAC_ADDR_TYPE_PRIMARY:
5190 (void) snprintf(vbuf.vnic_macaddrtype,
5191 sizeof (vbuf.vnic_macaddrtype),
5192 gettext("fixed"));
5193 break;
5194 case VNIC_MAC_ADDR_TYPE_RANDOM:
5195 (void) snprintf(vbuf.vnic_macaddrtype,
5196 sizeof (vbuf.vnic_macaddrtype),
5197 gettext("random"));
5198 break;
5199 case VNIC_MAC_ADDR_TYPE_FACTORY:
5200 (void) snprintf(vbuf.vnic_macaddrtype,
5201 sizeof (vbuf.vnic_macaddrtype),
5202 gettext("factory, slot %d"),
5203 vnic->va_mac_slot);
5204 break;
5205 case VNIC_MAC_ADDR_TYPE_VRID:
5206 (void) snprintf(vbuf.vnic_macaddrtype,
5207 sizeof (vbuf.vnic_macaddrtype),
5208 gettext("vrrp, %d/%s"),
5209 vnic->va_vrid, vnic->va_af == AF_INET ?
5210 "inet" : "inet6");
5211 break;
5212 }
5213
5214 if (strlen(vbuf.vnic_macaddrtype) > 0) {
5215 (void) snprintf(vbuf.vnic_macaddr,
5216 sizeof (vbuf.vnic_macaddr), "%s",
5217 dladm_aggr_macaddr2str(vnic->va_mac_addr,
5218 mstr));
5219 }
5220
5221 (void) snprintf(vbuf.vnic_vid, sizeof (vbuf.vnic_vid),
5222 "%d", vnic->va_vid);
5223 }
5224
5225 ofmt_print(state->vs_ofmt, &vbuf);
5226
5227 return (DLADM_STATUS_OK);
5228 }
5229 }
5230
5231 /* ARGSUSED */
5232 static int
show_vnic(dladm_handle_t dh,datalink_id_t linkid,void * arg)5233 show_vnic(dladm_handle_t dh, datalink_id_t linkid, void *arg)
5234 {
5235 show_vnic_state_t *state = arg;
5236
5237 state->vs_status = print_vnic(state, linkid);
5238 return (DLADM_WALK_CONTINUE);
5239 }
5240
5241 static void
do_show_vnic_common(int argc,char * argv[],const char * use,boolean_t etherstub)5242 do_show_vnic_common(int argc, char *argv[], const char *use,
5243 boolean_t etherstub)
5244 {
5245 int option;
5246 boolean_t s_arg = B_FALSE;
5247 boolean_t i_arg = B_FALSE;
5248 boolean_t l_arg = B_FALSE;
5249 uint32_t interval = 0, flags = DLADM_OPT_ACTIVE;
5250 datalink_id_t linkid = DATALINK_ALL_LINKID;
5251 datalink_id_t dev_linkid = DATALINK_ALL_LINKID;
5252 show_vnic_state_t state;
5253 dladm_status_t status;
5254 boolean_t o_arg = B_FALSE;
5255 char *fields_str = NULL;
5256 const ofmt_field_t *pf;
5257 char *all_e_fields = "link";
5258 ofmt_handle_t ofmt;
5259 ofmt_status_t oferr;
5260 uint_t ofmtflags = 0;
5261
5262 bzero(&state, sizeof (state));
5263 opterr = 0;
5264 while ((option = getopt_long(argc, argv, ":pPl:si:o:", lopts,
5265 NULL)) != -1) {
5266 switch (option) {
5267 case 'p':
5268 state.vs_parsable = B_TRUE;
5269 break;
5270 case 'P':
5271 flags = DLADM_OPT_PERSIST;
5272 break;
5273 case 'l':
5274 if (etherstub)
5275 die("option not supported for this command");
5276
5277 if (strlcpy(state.vs_link, optarg, MAXLINKNAMELEN) >=
5278 MAXLINKNAMELEN)
5279 die("link name too long");
5280
5281 l_arg = B_TRUE;
5282 break;
5283 case 's':
5284 if (s_arg) {
5285 die("the option -s cannot be specified "
5286 "more than once");
5287 }
5288 s_arg = B_TRUE;
5289 break;
5290 case 'i':
5291 if (i_arg) {
5292 die("the option -i cannot be specified "
5293 "more than once");
5294 }
5295 i_arg = B_TRUE;
5296 if (!dladm_str2interval(optarg, &interval))
5297 die("invalid interval value '%s'", optarg);
5298 break;
5299 case 'o':
5300 o_arg = B_TRUE;
5301 fields_str = optarg;
5302 break;
5303 default:
5304 die_opterr(optopt, option, use);
5305 }
5306 }
5307
5308 if (i_arg && !s_arg)
5309 die("the option -i can be used only with -s");
5310
5311 /* get vnic ID (optional last argument) */
5312 if (optind == (argc - 1)) {
5313 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
5314 NULL, NULL);
5315 if (status != DLADM_STATUS_OK) {
5316 die_dlerr(status, "invalid vnic name '%s'",
5317 argv[optind]);
5318 }
5319 (void) strlcpy(state.vs_vnic, argv[optind], MAXLINKNAMELEN);
5320 } else if (optind != argc) {
5321 usage();
5322 }
5323
5324 if (l_arg) {
5325 status = dladm_name2info(handle, state.vs_link, &dev_linkid,
5326 NULL, NULL, NULL);
5327 if (status != DLADM_STATUS_OK) {
5328 die_dlerr(status, "invalid link name '%s'",
5329 state.vs_link);
5330 }
5331 }
5332
5333 state.vs_vnic_id = linkid;
5334 state.vs_link_id = dev_linkid;
5335 state.vs_etherstub = etherstub;
5336 state.vs_found = B_FALSE;
5337 state.vs_flags = flags;
5338
5339 if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0)) {
5340 if (etherstub)
5341 fields_str = all_e_fields;
5342 }
5343 pf = vnic_fields;
5344
5345 if (state.vs_parsable)
5346 ofmtflags |= OFMT_PARSABLE;
5347 oferr = ofmt_open(fields_str, pf, ofmtflags, 0, &ofmt);
5348 ofmt_check(oferr, state.vs_parsable, ofmt, die, warn);
5349 state.vs_ofmt = ofmt;
5350
5351 if (s_arg) {
5352 /* Display vnic statistics */
5353 vnic_stats(&state, interval);
5354 ofmt_close(ofmt);
5355 return;
5356 }
5357
5358 /* Display vnic information */
5359 state.vs_donefirst = B_FALSE;
5360
5361 if (linkid == DATALINK_ALL_LINKID) {
5362 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5363 DATALINK_CLASS_VNIC | DATALINK_CLASS_ETHERSTUB,
5364 DATALINK_ANY_MEDIATYPE, flags);
5365 } else {
5366 (void) show_vnic(handle, linkid, &state);
5367 if (state.vs_status != DLADM_STATUS_OK) {
5368 ofmt_close(ofmt);
5369 die_dlerr(state.vs_status, "failed to show vnic '%s'",
5370 state.vs_vnic);
5371 }
5372 }
5373 ofmt_close(ofmt);
5374 }
5375
5376 static void
do_show_vnic(int argc,char * argv[],const char * use)5377 do_show_vnic(int argc, char *argv[], const char *use)
5378 {
5379 do_show_vnic_common(argc, argv, use, B_FALSE);
5380 }
5381
5382 static void
do_create_etherstub(int argc,char * argv[],const char * use)5383 do_create_etherstub(int argc, char *argv[], const char *use)
5384 {
5385 uint32_t flags;
5386 char *altroot = NULL;
5387 int option;
5388 dladm_status_t status;
5389 char name[MAXLINKNAMELEN];
5390 uchar_t mac_addr[ETHERADDRL];
5391
5392 name[0] = '\0';
5393 bzero(mac_addr, sizeof (mac_addr));
5394 flags = DLADM_OPT_ANCHOR | DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5395
5396 opterr = 0;
5397 while ((option = getopt_long(argc, argv, "tR:",
5398 etherstub_lopts, NULL)) != -1) {
5399 switch (option) {
5400 case 't':
5401 flags &= ~DLADM_OPT_PERSIST;
5402 break;
5403 case 'R':
5404 altroot = optarg;
5405 break;
5406 default:
5407 die_opterr(optopt, option, use);
5408 }
5409 }
5410
5411 /* the etherstub id is the required operand */
5412 if (optind != (argc - 1))
5413 usage();
5414
5415 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
5416 die("link name too long '%s'", argv[optind]);
5417
5418 if (!dladm_valid_linkname(name))
5419 die("invalid link name '%s'", argv[optind]);
5420
5421 if (altroot != NULL)
5422 altroot_cmd(altroot, argc, argv);
5423
5424 status = dladm_vnic_create(handle, name, DATALINK_INVALID_LINKID,
5425 VNIC_MAC_ADDR_TYPE_AUTO, mac_addr, ETHERADDRL, NULL, 0, 0,
5426 VRRP_VRID_NONE, AF_UNSPEC, NULL, NULL, &errlist, flags);
5427 if (status != DLADM_STATUS_OK)
5428 die_dlerr(status, "etherstub creation failed");
5429 }
5430
5431 static void
do_delete_etherstub(int argc,char * argv[],const char * use)5432 do_delete_etherstub(int argc, char *argv[], const char *use)
5433 {
5434 do_delete_vnic_common(argc, argv, use, B_TRUE);
5435 }
5436
5437 /* ARGSUSED */
5438 static void
do_show_etherstub(int argc,char * argv[],const char * use)5439 do_show_etherstub(int argc, char *argv[], const char *use)
5440 {
5441 do_show_vnic_common(argc, argv, use, B_TRUE);
5442 }
5443
5444 /* ARGSUSED */
5445 static void
do_up_simnet(int argc,char * argv[],const char * use)5446 do_up_simnet(int argc, char *argv[], const char *use)
5447 {
5448 (void) dladm_simnet_up(handle, DATALINK_ALL_LINKID, 0);
5449 }
5450
5451 static void
do_create_simnet(int argc,char * argv[],const char * use)5452 do_create_simnet(int argc, char *argv[], const char *use)
5453 {
5454 uint32_t flags;
5455 char *altroot = NULL;
5456 char *media = NULL;
5457 uint32_t mtype = DL_ETHER;
5458 int option;
5459 dladm_status_t status;
5460 char name[MAXLINKNAMELEN];
5461
5462 name[0] = '\0';
5463 flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5464
5465 opterr = 0;
5466 while ((option = getopt_long(argc, argv, ":tR:m:",
5467 simnet_lopts, NULL)) != -1) {
5468 switch (option) {
5469 case 't':
5470 flags &= ~DLADM_OPT_PERSIST;
5471 break;
5472 case 'R':
5473 altroot = optarg;
5474 break;
5475 case 'm':
5476 media = optarg;
5477 break;
5478 default:
5479 die_opterr(optopt, option, use);
5480 }
5481 }
5482
5483 /* the simnet id is the required operand */
5484 if (optind != (argc - 1))
5485 usage();
5486
5487 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
5488 die("link name too long '%s'", argv[optind]);
5489
5490 if (!dladm_valid_linkname(name))
5491 die("invalid link name '%s'", name);
5492
5493 if (media != NULL) {
5494 mtype = dladm_str2media(media);
5495 if (mtype != DL_ETHER && mtype != DL_WIFI)
5496 die("media type '%s' is not supported", media);
5497 }
5498
5499 if (altroot != NULL)
5500 altroot_cmd(altroot, argc, argv);
5501
5502 status = dladm_simnet_create(handle, name, mtype, flags);
5503 if (status != DLADM_STATUS_OK)
5504 die_dlerr(status, "simnet creation failed");
5505 }
5506
5507 static void
do_delete_simnet(int argc,char * argv[],const char * use)5508 do_delete_simnet(int argc, char *argv[], const char *use)
5509 {
5510 int option;
5511 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5512 datalink_id_t linkid;
5513 char *altroot = NULL;
5514 dladm_status_t status;
5515 dladm_simnet_attr_t slinfo;
5516
5517 opterr = 0;
5518 while ((option = getopt_long(argc, argv, ":tR:", simnet_lopts,
5519 NULL)) != -1) {
5520 switch (option) {
5521 case 't':
5522 flags &= ~DLADM_OPT_PERSIST;
5523 break;
5524 case 'R':
5525 altroot = optarg;
5526 break;
5527 default:
5528 die_opterr(optopt, option, use);
5529 }
5530 }
5531
5532 /* get simnet name (required last argument) */
5533 if (optind != (argc - 1))
5534 usage();
5535
5536 if (!dladm_valid_linkname(argv[optind]))
5537 die("invalid link name '%s'", argv[optind]);
5538
5539 if (altroot != NULL)
5540 altroot_cmd(altroot, argc, argv);
5541
5542 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
5543 NULL);
5544 if (status != DLADM_STATUS_OK)
5545 die("simnet '%s' not found", argv[optind]);
5546
5547 if ((status = dladm_simnet_info(handle, linkid, &slinfo,
5548 flags)) != DLADM_STATUS_OK)
5549 die_dlerr(status, "failed to retrieve simnet information");
5550
5551 status = dladm_simnet_delete(handle, linkid, flags);
5552 if (status != DLADM_STATUS_OK)
5553 die_dlerr(status, "simnet deletion failed");
5554 }
5555
5556 static void
do_modify_simnet(int argc,char * argv[],const char * use)5557 do_modify_simnet(int argc, char *argv[], const char *use)
5558 {
5559 int option;
5560 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
5561 datalink_id_t linkid;
5562 datalink_id_t peer_linkid;
5563 char *altroot = NULL;
5564 dladm_status_t status;
5565 boolean_t p_arg = B_FALSE;
5566
5567 opterr = 0;
5568 while ((option = getopt_long(argc, argv, ":tR:p:", simnet_lopts,
5569 NULL)) != -1) {
5570 switch (option) {
5571 case 't':
5572 flags &= ~DLADM_OPT_PERSIST;
5573 break;
5574 case 'R':
5575 altroot = optarg;
5576 break;
5577 case 'p':
5578 if (p_arg)
5579 die_optdup(option);
5580 p_arg = B_TRUE;
5581 if (strcasecmp(optarg, "none") == 0)
5582 peer_linkid = DATALINK_INVALID_LINKID;
5583 else if (dladm_name2info(handle, optarg, &peer_linkid,
5584 NULL, NULL, NULL) != DLADM_STATUS_OK)
5585 die("invalid peer link name '%s'", optarg);
5586 break;
5587 default:
5588 die_opterr(optopt, option, use);
5589 }
5590 }
5591
5592 /* get simnet name (required last argument) */
5593 if (optind != (argc - 1))
5594 usage();
5595
5596 /* Nothing to do if no peer link argument */
5597 if (!p_arg)
5598 return;
5599
5600 if (altroot != NULL)
5601 altroot_cmd(altroot, argc, argv);
5602
5603 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
5604 NULL);
5605 if (status != DLADM_STATUS_OK)
5606 die("invalid link name '%s'", argv[optind]);
5607
5608 status = dladm_simnet_modify(handle, linkid, peer_linkid, flags);
5609 if (status != DLADM_STATUS_OK)
5610 die_dlerr(status, "simnet modification failed");
5611 }
5612
5613 static dladm_status_t
print_simnet(show_state_t * state,datalink_id_t linkid)5614 print_simnet(show_state_t *state, datalink_id_t linkid)
5615 {
5616 dladm_simnet_attr_t slinfo;
5617 uint32_t flags;
5618 dladm_status_t status;
5619 simnet_fields_buf_t slbuf;
5620 char mstr[ETHERADDRL * 3];
5621
5622 bzero(&slbuf, sizeof (slbuf));
5623 if ((status = dladm_datalink_id2info(handle, linkid, &flags, NULL, NULL,
5624 slbuf.simnet_name, sizeof (slbuf.simnet_name)))
5625 != DLADM_STATUS_OK)
5626 return (status);
5627
5628 if (!(state->ls_flags & flags))
5629 return (DLADM_STATUS_NOTFOUND);
5630
5631 if ((status = dladm_simnet_info(handle, linkid, &slinfo,
5632 state->ls_flags)) != DLADM_STATUS_OK)
5633 return (status);
5634
5635 if (slinfo.sna_peer_link_id != DATALINK_INVALID_LINKID &&
5636 (status = dladm_datalink_id2info(handle, slinfo.sna_peer_link_id,
5637 NULL, NULL, NULL, slbuf.simnet_otherlink,
5638 sizeof (slbuf.simnet_otherlink))) !=
5639 DLADM_STATUS_OK)
5640 return (status);
5641
5642 if (slinfo.sna_mac_len > sizeof (slbuf.simnet_macaddr))
5643 return (DLADM_STATUS_BADVAL);
5644
5645 (void) strlcpy(slbuf.simnet_macaddr,
5646 dladm_aggr_macaddr2str(slinfo.sna_mac_addr, mstr),
5647 sizeof (slbuf.simnet_macaddr));
5648 (void) dladm_media2str(slinfo.sna_type, slbuf.simnet_media);
5649
5650 ofmt_print(state->ls_ofmt, &slbuf);
5651 return (status);
5652 }
5653
5654 /* ARGSUSED */
5655 static int
show_simnet(dladm_handle_t dh,datalink_id_t linkid,void * arg)5656 show_simnet(dladm_handle_t dh, datalink_id_t linkid, void *arg)
5657 {
5658 show_state_t *state = arg;
5659
5660 state->ls_status = print_simnet(state, linkid);
5661 return (DLADM_WALK_CONTINUE);
5662 }
5663
5664 static void
do_show_simnet(int argc,char * argv[],const char * use)5665 do_show_simnet(int argc, char *argv[], const char *use)
5666 {
5667 int option;
5668 uint32_t flags = DLADM_OPT_ACTIVE;
5669 boolean_t p_arg = B_FALSE;
5670 datalink_id_t linkid = DATALINK_ALL_LINKID;
5671 show_state_t state;
5672 dladm_status_t status;
5673 boolean_t o_arg = B_FALSE;
5674 ofmt_handle_t ofmt;
5675 ofmt_status_t oferr;
5676 char *all_fields = "link,media,macaddress,otherlink";
5677 char *fields_str = all_fields;
5678 uint_t ofmtflags = 0;
5679
5680 bzero(&state, sizeof (state));
5681
5682 opterr = 0;
5683 while ((option = getopt_long(argc, argv, ":pPo:",
5684 show_lopts, NULL)) != -1) {
5685 switch (option) {
5686 case 'p':
5687 if (p_arg)
5688 die_optdup(option);
5689
5690 p_arg = B_TRUE;
5691 state.ls_parsable = p_arg;
5692 break;
5693 case 'P':
5694 if (flags != DLADM_OPT_ACTIVE)
5695 die_optdup(option);
5696
5697 flags = DLADM_OPT_PERSIST;
5698 break;
5699 case 'o':
5700 o_arg = B_TRUE;
5701 fields_str = optarg;
5702 break;
5703 default:
5704 die_opterr(optopt, option, use);
5705 break;
5706 }
5707 }
5708
5709 if (p_arg && !o_arg)
5710 die("-p requires -o");
5711
5712 if (strcasecmp(fields_str, "all") == 0) {
5713 if (p_arg)
5714 die("\"-o all\" is invalid with -p");
5715 fields_str = all_fields;
5716 }
5717
5718 /* get link name (optional last argument) */
5719 if (optind == (argc-1)) {
5720 if ((status = dladm_name2info(handle, argv[optind], &linkid,
5721 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
5722 die_dlerr(status, "link %s is not valid", argv[optind]);
5723 }
5724 } else if (optind != argc) {
5725 usage();
5726 }
5727
5728 state.ls_flags = flags;
5729 state.ls_donefirst = B_FALSE;
5730 if (state.ls_parsable)
5731 ofmtflags |= OFMT_PARSABLE;
5732 oferr = ofmt_open(fields_str, simnet_fields, ofmtflags, 0, &ofmt);
5733 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
5734 state.ls_ofmt = ofmt;
5735
5736 if (linkid == DATALINK_ALL_LINKID) {
5737 (void) dladm_walk_datalink_id(show_simnet, handle, &state,
5738 DATALINK_CLASS_SIMNET, DATALINK_ANY_MEDIATYPE, flags);
5739 } else {
5740 (void) show_simnet(handle, linkid, &state);
5741 if (state.ls_status != DLADM_STATUS_OK) {
5742 ofmt_close(ofmt);
5743 die_dlerr(state.ls_status, "failed to show simnet %s",
5744 argv[optind]);
5745 }
5746 }
5747 ofmt_close(ofmt);
5748 }
5749
5750 static void
link_stats(datalink_id_t linkid,uint_t interval,char * fields_str,show_state_t * state)5751 link_stats(datalink_id_t linkid, uint_t interval, char *fields_str,
5752 show_state_t *state)
5753 {
5754 ofmt_handle_t ofmt;
5755 ofmt_status_t oferr;
5756 uint_t ofmtflags = 0;
5757
5758 if (state->ls_parsable)
5759 ofmtflags |= OFMT_PARSABLE;
5760 oferr = ofmt_open(fields_str, link_s_fields, ofmtflags, 0, &ofmt);
5761 ofmt_check(oferr, state->ls_parsable, ofmt, die, warn);
5762 state->ls_ofmt = ofmt;
5763
5764 /*
5765 * If an interval is specified, continuously show the stats
5766 * only for the first MAC port.
5767 */
5768 state->ls_firstonly = (interval != 0);
5769
5770 for (;;) {
5771 state->ls_donefirst = B_FALSE;
5772 if (linkid == DATALINK_ALL_LINKID) {
5773 (void) dladm_walk_datalink_id(show_link_stats, handle,
5774 state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
5775 DLADM_OPT_ACTIVE);
5776 } else {
5777 (void) show_link_stats(handle, linkid, state);
5778 }
5779
5780 if (interval == 0)
5781 break;
5782
5783 (void) fflush(stdout);
5784 (void) sleep(interval);
5785 }
5786 ofmt_close(ofmt);
5787 }
5788
5789 static void
aggr_stats(datalink_id_t linkid,show_grp_state_t * state,uint_t interval)5790 aggr_stats(datalink_id_t linkid, show_grp_state_t *state, uint_t interval)
5791 {
5792 /*
5793 * If an interval is specified, continuously show the stats
5794 * only for the first group.
5795 */
5796 state->gs_firstonly = (interval != 0);
5797
5798 for (;;) {
5799 state->gs_donefirst = B_FALSE;
5800 if (linkid == DATALINK_ALL_LINKID)
5801 (void) dladm_walk_datalink_id(show_aggr, handle, state,
5802 DATALINK_CLASS_AGGR, DATALINK_ANY_MEDIATYPE,
5803 DLADM_OPT_ACTIVE);
5804 else
5805 (void) show_aggr(handle, linkid, state);
5806
5807 if (interval == 0)
5808 break;
5809
5810 (void) fflush(stdout);
5811 (void) sleep(interval);
5812 }
5813 }
5814
5815 /* ARGSUSED */
5816 static void
vnic_stats(show_vnic_state_t * sp,uint32_t interval)5817 vnic_stats(show_vnic_state_t *sp, uint32_t interval)
5818 {
5819 show_vnic_state_t state;
5820 boolean_t specific_link, specific_dev;
5821
5822 /* Display vnic statistics */
5823 dump_vnics_head(sp->vs_link);
5824
5825 bzero(&state, sizeof (state));
5826 state.vs_stats = B_TRUE;
5827 state.vs_vnic_id = sp->vs_vnic_id;
5828 state.vs_link_id = sp->vs_link_id;
5829
5830 /*
5831 * If an interval is specified, and a vnic ID is not specified,
5832 * continuously show the stats only for the first vnic.
5833 */
5834 specific_link = (sp->vs_vnic_id != DATALINK_ALL_LINKID);
5835 specific_dev = (sp->vs_link_id != DATALINK_ALL_LINKID);
5836
5837 for (;;) {
5838 /* Get stats for each vnic */
5839 state.vs_found = B_FALSE;
5840 state.vs_donefirst = B_FALSE;
5841 state.vs_printstats = B_FALSE;
5842 state.vs_flags = DLADM_OPT_ACTIVE;
5843
5844 if (!specific_link) {
5845 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5846 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE,
5847 DLADM_OPT_ACTIVE);
5848 } else {
5849 (void) show_vnic(handle, sp->vs_vnic_id, &state);
5850 if (state.vs_status != DLADM_STATUS_OK) {
5851 die_dlerr(state.vs_status,
5852 "failed to show vnic '%s'", sp->vs_vnic);
5853 }
5854 }
5855
5856 if (specific_link && !state.vs_found)
5857 die("non-existent vnic '%s'", sp->vs_vnic);
5858 if (specific_dev && !state.vs_found)
5859 die("device %s has no vnics", sp->vs_link);
5860
5861 /* Show totals */
5862 if ((specific_link | specific_dev) && !interval) {
5863 (void) printf("Total");
5864 (void) printf("\t%-10llu",
5865 state.vs_totalstats.ipackets);
5866 (void) printf("%-12llu",
5867 state.vs_totalstats.rbytes);
5868 (void) printf("%-10llu",
5869 state.vs_totalstats.opackets);
5870 (void) printf("%-12llu\n",
5871 state.vs_totalstats.obytes);
5872 }
5873
5874 /* Show stats for each vnic */
5875 state.vs_donefirst = B_FALSE;
5876 state.vs_printstats = B_TRUE;
5877
5878 if (!specific_link) {
5879 (void) dladm_walk_datalink_id(show_vnic, handle, &state,
5880 DATALINK_CLASS_VNIC, DATALINK_ANY_MEDIATYPE,
5881 DLADM_OPT_ACTIVE);
5882 } else {
5883 (void) show_vnic(handle, sp->vs_vnic_id, &state);
5884 if (state.vs_status != DLADM_STATUS_OK) {
5885 die_dlerr(state.vs_status,
5886 "failed to show vnic '%s'", sp->vs_vnic);
5887 }
5888 }
5889
5890 if (interval == 0)
5891 break;
5892
5893 (void) fflush(stdout);
5894 (void) sleep(interval);
5895 }
5896 }
5897
5898 static void
get_mac_stats(const char * dev,pktsum_t * stats)5899 get_mac_stats(const char *dev, pktsum_t *stats)
5900 {
5901 kstat_ctl_t *kcp;
5902 kstat_t *ksp;
5903 char module[DLPI_LINKNAME_MAX];
5904 uint_t instance;
5905
5906
5907 bzero(stats, sizeof (*stats));
5908
5909 if (dlpi_parselink(dev, module, &instance) != DLPI_SUCCESS)
5910 return;
5911
5912 if ((kcp = kstat_open()) == NULL) {
5913 warn("kstat open operation failed");
5914 return;
5915 }
5916
5917 ksp = dladm_kstat_lookup(kcp, module, instance, "mac", NULL);
5918 if (ksp != NULL)
5919 dladm_get_stats(kcp, ksp, stats);
5920
5921 (void) kstat_close(kcp);
5922
5923 }
5924
5925 static void
get_link_stats(const char * link,pktsum_t * stats)5926 get_link_stats(const char *link, pktsum_t *stats)
5927 {
5928 kstat_ctl_t *kcp;
5929 kstat_t *ksp;
5930
5931 bzero(stats, sizeof (*stats));
5932
5933 if ((kcp = kstat_open()) == NULL) {
5934 warn("kstat_open operation failed");
5935 return;
5936 }
5937
5938 ksp = dladm_kstat_lookup(kcp, "link", 0, link, NULL);
5939
5940 if (ksp != NULL)
5941 dladm_get_stats(kcp, ksp, stats);
5942
5943 (void) kstat_close(kcp);
5944 }
5945
5946 static int
query_kstat(char * module,int instance,const char * name,const char * stat,uint8_t type,void * val)5947 query_kstat(char *module, int instance, const char *name, const char *stat,
5948 uint8_t type, void *val)
5949 {
5950 kstat_ctl_t *kcp;
5951 kstat_t *ksp;
5952
5953 if ((kcp = kstat_open()) == NULL) {
5954 warn("kstat open operation failed");
5955 return (-1);
5956 }
5957
5958 if ((ksp = kstat_lookup(kcp, module, instance, (char *)name)) == NULL) {
5959 /*
5960 * The kstat query could fail if the underlying MAC
5961 * driver was already detached.
5962 */
5963 goto bail;
5964 }
5965
5966 if (kstat_read(kcp, ksp, NULL) == -1) {
5967 warn("kstat read failed");
5968 goto bail;
5969 }
5970
5971 if (dladm_kstat_value(ksp, stat, type, val) < 0)
5972 goto bail;
5973
5974 (void) kstat_close(kcp);
5975 return (0);
5976
5977 bail:
5978 (void) kstat_close(kcp);
5979 return (-1);
5980 }
5981
5982 static int
get_one_kstat(const char * name,const char * stat,uint8_t type,void * val,boolean_t islink)5983 get_one_kstat(const char *name, const char *stat, uint8_t type,
5984 void *val, boolean_t islink)
5985 {
5986 char module[DLPI_LINKNAME_MAX];
5987 uint_t instance;
5988
5989 if (islink) {
5990 return (query_kstat("link", 0, name, stat, type, val));
5991 } else {
5992 if (dlpi_parselink(name, module, &instance) != DLPI_SUCCESS)
5993 return (-1);
5994
5995 return (query_kstat(module, instance, "mac", stat, type, val));
5996 }
5997 }
5998
5999 static uint64_t
get_ifspeed(const char * name,boolean_t islink)6000 get_ifspeed(const char *name, boolean_t islink)
6001 {
6002 uint64_t ifspeed = 0;
6003
6004 (void) get_one_kstat(name, "ifspeed", KSTAT_DATA_UINT64,
6005 &ifspeed, islink);
6006
6007 return (ifspeed);
6008 }
6009
6010 static const char *
get_linkstate(const char * name,boolean_t islink,char * buf)6011 get_linkstate(const char *name, boolean_t islink, char *buf)
6012 {
6013 link_state_t linkstate;
6014
6015 if (get_one_kstat(name, "link_state", KSTAT_DATA_UINT32,
6016 &linkstate, islink) != 0) {
6017 (void) strlcpy(buf, "?", DLADM_STRSIZE);
6018 return (buf);
6019 }
6020 return (dladm_linkstate2str(linkstate, buf));
6021 }
6022
6023 static const char *
get_linkduplex(const char * name,boolean_t islink,char * buf)6024 get_linkduplex(const char *name, boolean_t islink, char *buf)
6025 {
6026 link_duplex_t linkduplex;
6027
6028 if (get_one_kstat(name, "link_duplex", KSTAT_DATA_UINT32,
6029 &linkduplex, islink) != 0) {
6030 (void) strlcpy(buf, "unknown", DLADM_STRSIZE);
6031 return (buf);
6032 }
6033
6034 return (dladm_linkduplex2str(linkduplex, buf));
6035 }
6036
6037 static int
parse_wifi_fields(char * str,ofmt_handle_t * ofmt,uint_t cmdtype,boolean_t parsable)6038 parse_wifi_fields(char *str, ofmt_handle_t *ofmt, uint_t cmdtype,
6039 boolean_t parsable)
6040 {
6041 ofmt_field_t *template, *of;
6042 ofmt_cb_t *fn;
6043 ofmt_status_t oferr;
6044
6045 if (cmdtype == WIFI_CMD_SCAN) {
6046 template = wifi_common_fields;
6047 if (str == NULL)
6048 str = def_scan_wifi_fields;
6049 if (strcasecmp(str, "all") == 0)
6050 str = all_scan_wifi_fields;
6051 fn = print_wlan_attr_cb;
6052 } else if (cmdtype == WIFI_CMD_SHOW) {
6053 bcopy(wifi_common_fields, &wifi_show_fields[2],
6054 sizeof (wifi_common_fields));
6055 template = wifi_show_fields;
6056 if (str == NULL)
6057 str = def_show_wifi_fields;
6058 if (strcasecmp(str, "all") == 0)
6059 str = all_show_wifi_fields;
6060 fn = print_link_attr_cb;
6061 } else {
6062 return (-1);
6063 }
6064
6065 for (of = template; of->of_name != NULL; of++) {
6066 if (of->of_cb == NULL)
6067 of->of_cb = fn;
6068 }
6069
6070 oferr = ofmt_open(str, template, (parsable ? OFMT_PARSABLE : 0),
6071 0, ofmt);
6072 ofmt_check(oferr, parsable, *ofmt, die, warn);
6073 return (0);
6074 }
6075
6076 typedef struct print_wifi_state {
6077 char *ws_link;
6078 boolean_t ws_parsable;
6079 boolean_t ws_header;
6080 ofmt_handle_t ws_ofmt;
6081 } print_wifi_state_t;
6082
6083 typedef struct wlan_scan_args_s {
6084 print_wifi_state_t *ws_state;
6085 void *ws_attr;
6086 } wlan_scan_args_t;
6087
6088 static boolean_t
print_wlan_attr_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)6089 print_wlan_attr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6090 {
6091 wlan_scan_args_t *w = ofarg->ofmt_cbarg;
6092 print_wifi_state_t *statep = w->ws_state;
6093 dladm_wlan_attr_t *attrp = w->ws_attr;
6094 char tmpbuf[DLADM_STRSIZE];
6095
6096 if (ofarg->ofmt_id == 0) {
6097 (void) strlcpy(buf, (char *)statep->ws_link, bufsize);
6098 return (B_TRUE);
6099 }
6100
6101 if ((ofarg->ofmt_id & attrp->wa_valid) == 0)
6102 return (B_TRUE);
6103
6104 switch (ofarg->ofmt_id) {
6105 case DLADM_WLAN_ATTR_ESSID:
6106 (void) dladm_wlan_essid2str(&attrp->wa_essid, tmpbuf);
6107 break;
6108 case DLADM_WLAN_ATTR_BSSID:
6109 (void) dladm_wlan_bssid2str(&attrp->wa_bssid, tmpbuf);
6110 break;
6111 case DLADM_WLAN_ATTR_SECMODE:
6112 (void) dladm_wlan_secmode2str(&attrp->wa_secmode, tmpbuf);
6113 break;
6114 case DLADM_WLAN_ATTR_STRENGTH:
6115 (void) dladm_wlan_strength2str(&attrp->wa_strength, tmpbuf);
6116 break;
6117 case DLADM_WLAN_ATTR_MODE:
6118 (void) dladm_wlan_mode2str(&attrp->wa_mode, tmpbuf);
6119 break;
6120 case DLADM_WLAN_ATTR_SPEED:
6121 (void) dladm_wlan_speed2str(&attrp->wa_speed, tmpbuf);
6122 (void) strlcat(tmpbuf, "Mb", sizeof (tmpbuf));
6123 break;
6124 case DLADM_WLAN_ATTR_AUTH:
6125 (void) dladm_wlan_auth2str(&attrp->wa_auth, tmpbuf);
6126 break;
6127 case DLADM_WLAN_ATTR_BSSTYPE:
6128 (void) dladm_wlan_bsstype2str(&attrp->wa_bsstype, tmpbuf);
6129 break;
6130 }
6131 (void) strlcpy(buf, tmpbuf, bufsize);
6132
6133 return (B_TRUE);
6134 }
6135
6136 static boolean_t
print_scan_results(void * arg,dladm_wlan_attr_t * attrp)6137 print_scan_results(void *arg, dladm_wlan_attr_t *attrp)
6138 {
6139 print_wifi_state_t *statep = arg;
6140 wlan_scan_args_t warg;
6141
6142 bzero(&warg, sizeof (warg));
6143 warg.ws_state = statep;
6144 warg.ws_attr = attrp;
6145 ofmt_print(statep->ws_ofmt, &warg);
6146 return (B_TRUE);
6147 }
6148
6149 static int
scan_wifi(dladm_handle_t dh,datalink_id_t linkid,void * arg)6150 scan_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6151 {
6152 print_wifi_state_t *statep = arg;
6153 dladm_status_t status;
6154 char link[MAXLINKNAMELEN];
6155
6156 if ((status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, link,
6157 sizeof (link))) != DLADM_STATUS_OK) {
6158 return (DLADM_WALK_CONTINUE);
6159 }
6160
6161 statep->ws_link = link;
6162 status = dladm_wlan_scan(dh, linkid, statep, print_scan_results);
6163 if (status != DLADM_STATUS_OK)
6164 die_dlerr(status, "cannot scan link '%s'", statep->ws_link);
6165
6166 return (DLADM_WALK_CONTINUE);
6167 }
6168
6169 static boolean_t
print_wifi_status_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)6170 print_wifi_status_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6171 {
6172 static char tmpbuf[DLADM_STRSIZE];
6173 wlan_scan_args_t *w = ofarg->ofmt_cbarg;
6174 dladm_wlan_linkattr_t *attrp = w->ws_attr;
6175
6176 if ((ofarg->ofmt_id & attrp->la_valid) != 0) {
6177 (void) dladm_wlan_linkstatus2str(&attrp->la_status, tmpbuf);
6178 (void) strlcpy(buf, tmpbuf, bufsize);
6179 }
6180 return (B_TRUE);
6181 }
6182
6183 static boolean_t
print_link_attr_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)6184 print_link_attr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6185 {
6186 wlan_scan_args_t *w = ofarg->ofmt_cbarg, w1;
6187 print_wifi_state_t *statep = w->ws_state;
6188 dladm_wlan_linkattr_t *attrp = w->ws_attr;
6189
6190 bzero(&w1, sizeof (w1));
6191 w1.ws_state = statep;
6192 w1.ws_attr = &attrp->la_wlan_attr;
6193 ofarg->ofmt_cbarg = &w1;
6194 return (print_wlan_attr_cb(ofarg, buf, bufsize));
6195 }
6196
6197 static int
show_wifi(dladm_handle_t dh,datalink_id_t linkid,void * arg)6198 show_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6199 {
6200 print_wifi_state_t *statep = arg;
6201 dladm_wlan_linkattr_t attr;
6202 dladm_status_t status;
6203 char link[MAXLINKNAMELEN];
6204 wlan_scan_args_t warg;
6205
6206 if ((status = dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, link,
6207 sizeof (link))) != DLADM_STATUS_OK) {
6208 return (DLADM_WALK_CONTINUE);
6209 }
6210
6211 /* dladm_wlan_get_linkattr() memsets attr with 0 */
6212 status = dladm_wlan_get_linkattr(dh, linkid, &attr);
6213 if (status != DLADM_STATUS_OK)
6214 die_dlerr(status, "cannot get link attributes for %s", link);
6215
6216 statep->ws_link = link;
6217
6218 bzero(&warg, sizeof (warg));
6219 warg.ws_state = statep;
6220 warg.ws_attr = &attr;
6221 ofmt_print(statep->ws_ofmt, &warg);
6222 return (DLADM_WALK_CONTINUE);
6223 }
6224
6225 static void
do_display_wifi(int argc,char ** argv,int cmd,const char * use)6226 do_display_wifi(int argc, char **argv, int cmd, const char *use)
6227 {
6228 int option;
6229 char *fields_str = NULL;
6230 int (*callback)(dladm_handle_t, datalink_id_t, void *);
6231 print_wifi_state_t state;
6232 datalink_id_t linkid = DATALINK_ALL_LINKID;
6233 dladm_status_t status;
6234
6235 if (cmd == WIFI_CMD_SCAN)
6236 callback = scan_wifi;
6237 else if (cmd == WIFI_CMD_SHOW)
6238 callback = show_wifi;
6239 else
6240 return;
6241
6242 state.ws_parsable = B_FALSE;
6243 state.ws_header = B_TRUE;
6244 opterr = 0;
6245 while ((option = getopt_long(argc, argv, ":o:p",
6246 wifi_longopts, NULL)) != -1) {
6247 switch (option) {
6248 case 'o':
6249 fields_str = optarg;
6250 break;
6251 case 'p':
6252 state.ws_parsable = B_TRUE;
6253 break;
6254 default:
6255 die_opterr(optopt, option, use);
6256 }
6257 }
6258
6259 if (state.ws_parsable && fields_str == NULL)
6260 die("-p requires -o");
6261
6262 if (state.ws_parsable && strcasecmp(fields_str, "all") == 0)
6263 die("\"-o all\" is invalid with -p");
6264
6265 if (optind == (argc - 1)) {
6266 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6267 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6268 die_dlerr(status, "link %s is not valid", argv[optind]);
6269 }
6270 } else if (optind != argc) {
6271 usage();
6272 }
6273
6274 if (parse_wifi_fields(fields_str, &state.ws_ofmt, cmd,
6275 state.ws_parsable) < 0)
6276 die("invalid field(s) specified");
6277
6278 if (linkid == DATALINK_ALL_LINKID) {
6279 (void) dladm_walk_datalink_id(callback, handle, &state,
6280 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6281 DL_WIFI, DLADM_OPT_ACTIVE);
6282 } else {
6283 (void) (*callback)(handle, linkid, &state);
6284 }
6285 ofmt_close(state.ws_ofmt);
6286 }
6287
6288 static void
do_scan_wifi(int argc,char ** argv,const char * use)6289 do_scan_wifi(int argc, char **argv, const char *use)
6290 {
6291 do_display_wifi(argc, argv, WIFI_CMD_SCAN, use);
6292 }
6293
6294 static void
do_show_wifi(int argc,char ** argv,const char * use)6295 do_show_wifi(int argc, char **argv, const char *use)
6296 {
6297 do_display_wifi(argc, argv, WIFI_CMD_SHOW, use);
6298 }
6299
6300 typedef struct wlan_count_attr {
6301 uint_t wc_count;
6302 datalink_id_t wc_linkid;
6303 } wlan_count_attr_t;
6304
6305 /* ARGSUSED */
6306 static int
do_count_wlan(dladm_handle_t dh,datalink_id_t linkid,void * arg)6307 do_count_wlan(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6308 {
6309 wlan_count_attr_t *cp = arg;
6310
6311 if (cp->wc_count == 0)
6312 cp->wc_linkid = linkid;
6313 cp->wc_count++;
6314 return (DLADM_WALK_CONTINUE);
6315 }
6316
6317 static int
parse_wlan_keys(char * str,dladm_wlan_key_t ** keys,uint_t * key_countp)6318 parse_wlan_keys(char *str, dladm_wlan_key_t **keys, uint_t *key_countp)
6319 {
6320 uint_t i;
6321 dladm_wlan_key_t *wk;
6322 int nfields = 1;
6323 char *field, *token, *lasts = NULL, c;
6324
6325 token = str;
6326 while ((c = *token++) != '\0') {
6327 if (c == ',')
6328 nfields++;
6329 }
6330 token = strdup(str);
6331 if (token == NULL)
6332 return (-1);
6333
6334 wk = malloc(nfields * sizeof (dladm_wlan_key_t));
6335 if (wk == NULL)
6336 goto fail;
6337
6338 token = str;
6339 for (i = 0; i < nfields; i++) {
6340 char *s;
6341 dladm_secobj_class_t class;
6342 dladm_status_t status;
6343
6344 field = strtok_r(token, ",", &lasts);
6345 token = NULL;
6346
6347 (void) strlcpy(wk[i].wk_name, field,
6348 DLADM_WLAN_MAX_KEYNAME_LEN);
6349
6350 wk[i].wk_idx = 1;
6351 if ((s = strrchr(wk[i].wk_name, ':')) != NULL) {
6352 if (s[1] == '\0' || s[2] != '\0' || !isdigit(s[1]))
6353 goto fail;
6354
6355 wk[i].wk_idx = (uint_t)(s[1] - '0');
6356 *s = '\0';
6357 }
6358 wk[i].wk_len = DLADM_WLAN_MAX_KEY_LEN;
6359
6360 status = dladm_get_secobj(handle, wk[i].wk_name, &class,
6361 wk[i].wk_val, &wk[i].wk_len, 0);
6362 if (status != DLADM_STATUS_OK) {
6363 if (status == DLADM_STATUS_NOTFOUND) {
6364 status = dladm_get_secobj(handle, wk[i].wk_name,
6365 &class, wk[i].wk_val, &wk[i].wk_len,
6366 DLADM_OPT_PERSIST);
6367 }
6368 if (status != DLADM_STATUS_OK)
6369 goto fail;
6370 }
6371 wk[i].wk_class = class;
6372 }
6373 *keys = wk;
6374 *key_countp = i;
6375 free(token);
6376 return (0);
6377 fail:
6378 free(wk);
6379 free(token);
6380 return (-1);
6381 }
6382
6383 static void
do_connect_wifi(int argc,char ** argv,const char * use)6384 do_connect_wifi(int argc, char **argv, const char *use)
6385 {
6386 int option;
6387 dladm_wlan_attr_t attr, *attrp;
6388 dladm_status_t status = DLADM_STATUS_OK;
6389 int timeout = DLADM_WLAN_CONNECT_TIMEOUT_DEFAULT;
6390 datalink_id_t linkid = DATALINK_ALL_LINKID;
6391 dladm_wlan_key_t *keys = NULL;
6392 uint_t key_count = 0;
6393 uint_t flags = 0;
6394 dladm_wlan_secmode_t keysecmode = DLADM_WLAN_SECMODE_NONE;
6395 char buf[DLADM_STRSIZE];
6396
6397 opterr = 0;
6398 (void) memset(&attr, 0, sizeof (attr));
6399 while ((option = getopt_long(argc, argv, ":e:i:a:m:b:s:k:T:c",
6400 wifi_longopts, NULL)) != -1) {
6401 switch (option) {
6402 case 'e':
6403 status = dladm_wlan_str2essid(optarg, &attr.wa_essid);
6404 if (status != DLADM_STATUS_OK)
6405 die("invalid ESSID '%s'", optarg);
6406
6407 attr.wa_valid |= DLADM_WLAN_ATTR_ESSID;
6408 /*
6409 * Try to connect without doing a scan.
6410 */
6411 flags |= DLADM_WLAN_CONNECT_NOSCAN;
6412 break;
6413 case 'i':
6414 status = dladm_wlan_str2bssid(optarg, &attr.wa_bssid);
6415 if (status != DLADM_STATUS_OK)
6416 die("invalid BSSID %s", optarg);
6417
6418 attr.wa_valid |= DLADM_WLAN_ATTR_BSSID;
6419 break;
6420 case 'a':
6421 status = dladm_wlan_str2auth(optarg, &attr.wa_auth);
6422 if (status != DLADM_STATUS_OK)
6423 die("invalid authentication mode '%s'", optarg);
6424
6425 attr.wa_valid |= DLADM_WLAN_ATTR_AUTH;
6426 break;
6427 case 'm':
6428 status = dladm_wlan_str2mode(optarg, &attr.wa_mode);
6429 if (status != DLADM_STATUS_OK)
6430 die("invalid mode '%s'", optarg);
6431
6432 attr.wa_valid |= DLADM_WLAN_ATTR_MODE;
6433 break;
6434 case 'b':
6435 if ((status = dladm_wlan_str2bsstype(optarg,
6436 &attr.wa_bsstype)) != DLADM_STATUS_OK) {
6437 die("invalid bsstype '%s'", optarg);
6438 }
6439
6440 attr.wa_valid |= DLADM_WLAN_ATTR_BSSTYPE;
6441 break;
6442 case 's':
6443 if ((status = dladm_wlan_str2secmode(optarg,
6444 &attr.wa_secmode)) != DLADM_STATUS_OK) {
6445 die("invalid security mode '%s'", optarg);
6446 }
6447
6448 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
6449 break;
6450 case 'k':
6451 if (parse_wlan_keys(optarg, &keys, &key_count) < 0)
6452 die("invalid key(s) '%s'", optarg);
6453
6454 if (keys[0].wk_class == DLADM_SECOBJ_CLASS_WEP)
6455 keysecmode = DLADM_WLAN_SECMODE_WEP;
6456 else
6457 keysecmode = DLADM_WLAN_SECMODE_WPA;
6458 break;
6459 case 'T':
6460 if (strcasecmp(optarg, "forever") == 0) {
6461 timeout = -1;
6462 break;
6463 }
6464 if (!str2int(optarg, &timeout) || timeout < 0)
6465 die("invalid timeout value '%s'", optarg);
6466 break;
6467 case 'c':
6468 flags |= DLADM_WLAN_CONNECT_CREATEIBSS;
6469 flags |= DLADM_WLAN_CONNECT_CREATEIBSS;
6470 break;
6471 default:
6472 die_opterr(optopt, option, use);
6473 break;
6474 }
6475 }
6476
6477 if (keysecmode == DLADM_WLAN_SECMODE_NONE) {
6478 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0) {
6479 die("key required for security mode '%s'",
6480 dladm_wlan_secmode2str(&attr.wa_secmode, buf));
6481 }
6482 } else {
6483 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0 &&
6484 attr.wa_secmode != keysecmode)
6485 die("incompatible -s and -k options");
6486 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
6487 attr.wa_secmode = keysecmode;
6488 }
6489
6490 if (optind == (argc - 1)) {
6491 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6492 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6493 die_dlerr(status, "link %s is not valid", argv[optind]);
6494 }
6495 } else if (optind != argc) {
6496 usage();
6497 }
6498
6499 if (linkid == DATALINK_ALL_LINKID) {
6500 wlan_count_attr_t wcattr;
6501
6502 wcattr.wc_linkid = DATALINK_INVALID_LINKID;
6503 wcattr.wc_count = 0;
6504 (void) dladm_walk_datalink_id(do_count_wlan, handle, &wcattr,
6505 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6506 DL_WIFI, DLADM_OPT_ACTIVE);
6507 if (wcattr.wc_count == 0) {
6508 die("no wifi links are available");
6509 } else if (wcattr.wc_count > 1) {
6510 die("link name is required when more than one wifi "
6511 "link is available");
6512 }
6513 linkid = wcattr.wc_linkid;
6514 }
6515 attrp = (attr.wa_valid == 0) ? NULL : &attr;
6516 again:
6517 if ((status = dladm_wlan_connect(handle, linkid, attrp, timeout, keys,
6518 key_count, flags)) != DLADM_STATUS_OK) {
6519 if ((flags & DLADM_WLAN_CONNECT_NOSCAN) != 0) {
6520 /*
6521 * Try again with scanning and filtering.
6522 */
6523 flags &= ~DLADM_WLAN_CONNECT_NOSCAN;
6524 goto again;
6525 }
6526
6527 if (status == DLADM_STATUS_NOTFOUND) {
6528 if (attr.wa_valid == 0) {
6529 die("no wifi networks are available");
6530 } else {
6531 die("no wifi networks with the specified "
6532 "criteria are available");
6533 }
6534 }
6535 die_dlerr(status, "cannot connect");
6536 }
6537 free(keys);
6538 }
6539
6540 /* ARGSUSED */
6541 static int
do_all_disconnect_wifi(dladm_handle_t dh,datalink_id_t linkid,void * arg)6542 do_all_disconnect_wifi(dladm_handle_t dh, datalink_id_t linkid, void *arg)
6543 {
6544 dladm_status_t status;
6545
6546 status = dladm_wlan_disconnect(dh, linkid);
6547 if (status != DLADM_STATUS_OK)
6548 warn_dlerr(status, "cannot disconnect link");
6549
6550 return (DLADM_WALK_CONTINUE);
6551 }
6552
6553 static void
do_disconnect_wifi(int argc,char ** argv,const char * use)6554 do_disconnect_wifi(int argc, char **argv, const char *use)
6555 {
6556 int option;
6557 datalink_id_t linkid = DATALINK_ALL_LINKID;
6558 boolean_t all_links = B_FALSE;
6559 dladm_status_t status;
6560 wlan_count_attr_t wcattr;
6561
6562 opterr = 0;
6563 while ((option = getopt_long(argc, argv, ":a",
6564 wifi_longopts, NULL)) != -1) {
6565 switch (option) {
6566 case 'a':
6567 all_links = B_TRUE;
6568 break;
6569 default:
6570 die_opterr(optopt, option, use);
6571 break;
6572 }
6573 }
6574
6575 if (optind == (argc - 1)) {
6576 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6577 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6578 die_dlerr(status, "link %s is not valid", argv[optind]);
6579 }
6580 } else if (optind != argc) {
6581 usage();
6582 }
6583
6584 if (linkid == DATALINK_ALL_LINKID) {
6585 if (!all_links) {
6586 wcattr.wc_linkid = linkid;
6587 wcattr.wc_count = 0;
6588 (void) dladm_walk_datalink_id(do_count_wlan, handle,
6589 &wcattr,
6590 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6591 DL_WIFI, DLADM_OPT_ACTIVE);
6592 if (wcattr.wc_count == 0) {
6593 die("no wifi links are available");
6594 } else if (wcattr.wc_count > 1) {
6595 die("link name is required when more than "
6596 "one wifi link is available");
6597 }
6598 linkid = wcattr.wc_linkid;
6599 } else {
6600 (void) dladm_walk_datalink_id(do_all_disconnect_wifi,
6601 handle, NULL,
6602 DATALINK_CLASS_PHYS | DATALINK_CLASS_SIMNET,
6603 DL_WIFI, DLADM_OPT_ACTIVE);
6604 return;
6605 }
6606 }
6607 status = dladm_wlan_disconnect(handle, linkid);
6608 if (status != DLADM_STATUS_OK)
6609 die_dlerr(status, "cannot disconnect");
6610 }
6611
6612 static void
print_linkprop(datalink_id_t linkid,show_linkprop_state_t * statep,const char * propname,dladm_prop_type_t type,const char * format,char ** pptr)6613 print_linkprop(datalink_id_t linkid, show_linkprop_state_t *statep,
6614 const char *propname, dladm_prop_type_t type, const char *format,
6615 char **pptr)
6616 {
6617 int i;
6618 char *ptr, *lim;
6619 char buf[DLADM_STRSIZE];
6620 char *unknown = "--", *notsup = "";
6621 char **propvals = statep->ls_propvals;
6622 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
6623 dladm_status_t status;
6624
6625 status = dladm_get_linkprop(handle, linkid, type, propname, propvals,
6626 &valcnt);
6627 if (status != DLADM_STATUS_OK) {
6628 if (status == DLADM_STATUS_TEMPONLY) {
6629 if (type == DLADM_PROP_VAL_MODIFIABLE &&
6630 statep->ls_persist) {
6631 valcnt = 1;
6632 propvals = &unknown;
6633 } else {
6634 statep->ls_status = status;
6635 statep->ls_retstatus = status;
6636 return;
6637 }
6638 } else if (status == DLADM_STATUS_NOTSUP ||
6639 statep->ls_persist) {
6640 valcnt = 1;
6641 if (type == DLADM_PROP_VAL_CURRENT ||
6642 type == DLADM_PROP_VAL_PERM)
6643 propvals = &unknown;
6644 else
6645 propvals = ¬sup;
6646 } else if (status == DLADM_STATUS_NOTDEFINED) {
6647 propvals = ¬sup; /* STR_UNDEF_VAL */
6648 } else {
6649 if (statep->ls_proplist &&
6650 statep->ls_status == DLADM_STATUS_OK) {
6651 warn_dlerr(status,
6652 "cannot get link property '%s' for %s",
6653 propname, statep->ls_link);
6654 }
6655 statep->ls_status = status;
6656 statep->ls_retstatus = status;
6657 return;
6658 }
6659 }
6660
6661 statep->ls_status = DLADM_STATUS_OK;
6662
6663 buf[0] = '\0';
6664 ptr = buf;
6665 lim = buf + DLADM_STRSIZE;
6666 for (i = 0; i < valcnt; i++) {
6667 if (propvals[i][0] == '\0' && !statep->ls_parsable)
6668 ptr += snprintf(ptr, lim - ptr, "--,");
6669 else
6670 ptr += snprintf(ptr, lim - ptr, "%s,", propvals[i]);
6671 if (ptr >= lim)
6672 break;
6673 }
6674 if (valcnt > 0)
6675 buf[strlen(buf) - 1] = '\0';
6676
6677 lim = statep->ls_line + MAX_PROP_LINE;
6678 if (statep->ls_parsable) {
6679 *pptr += snprintf(*pptr, lim - *pptr,
6680 "%s", buf);
6681 } else {
6682 *pptr += snprintf(*pptr, lim - *pptr, format, buf);
6683 }
6684 }
6685
6686 static boolean_t
print_linkprop_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)6687 print_linkprop_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
6688 {
6689 linkprop_args_t *arg = ofarg->ofmt_cbarg;
6690 char *propname = arg->ls_propname;
6691 show_linkprop_state_t *statep = arg->ls_state;
6692 char *ptr = statep->ls_line;
6693 char *lim = ptr + MAX_PROP_LINE;
6694 datalink_id_t linkid = arg->ls_linkid;
6695
6696 switch (ofarg->ofmt_id) {
6697 case LINKPROP_LINK:
6698 (void) snprintf(ptr, lim - ptr, "%s", statep->ls_link);
6699 break;
6700 case LINKPROP_PROPERTY:
6701 (void) snprintf(ptr, lim - ptr, "%s", propname);
6702 break;
6703 case LINKPROP_VALUE:
6704 print_linkprop(linkid, statep, propname,
6705 statep->ls_persist ? DLADM_PROP_VAL_PERSISTENT :
6706 DLADM_PROP_VAL_CURRENT, "%s", &ptr);
6707 /*
6708 * If we failed to query the link property, for example, query
6709 * the persistent value of a non-persistable link property,
6710 * simply skip the output.
6711 */
6712 if (statep->ls_status != DLADM_STATUS_OK) {
6713 /*
6714 * Ignore the temponly error when we skip printing
6715 * link properties to avoid returning failure on exit.
6716 */
6717 if (statep->ls_retstatus == DLADM_STATUS_TEMPONLY)
6718 statep->ls_retstatus = DLADM_STATUS_OK;
6719 goto skip;
6720 }
6721 ptr = statep->ls_line;
6722 break;
6723 case LINKPROP_PERM:
6724 print_linkprop(linkid, statep, propname,
6725 DLADM_PROP_VAL_PERM, "%s", &ptr);
6726 if (statep->ls_status != DLADM_STATUS_OK)
6727 goto skip;
6728 ptr = statep->ls_line;
6729 break;
6730 case LINKPROP_DEFAULT:
6731 print_linkprop(linkid, statep, propname,
6732 DLADM_PROP_VAL_DEFAULT, "%s", &ptr);
6733 if (statep->ls_status != DLADM_STATUS_OK)
6734 goto skip;
6735 ptr = statep->ls_line;
6736 break;
6737 case LINKPROP_POSSIBLE:
6738 print_linkprop(linkid, statep, propname,
6739 DLADM_PROP_VAL_MODIFIABLE, "%s ", &ptr);
6740 if (statep->ls_status != DLADM_STATUS_OK)
6741 goto skip;
6742 ptr = statep->ls_line;
6743 break;
6744 default:
6745 die("invalid input");
6746 break;
6747 }
6748 (void) strlcpy(buf, ptr, bufsize);
6749 return (B_TRUE);
6750 skip:
6751 return ((statep->ls_status == DLADM_STATUS_OK) ?
6752 B_TRUE : B_FALSE);
6753 }
6754
6755 static boolean_t
linkprop_is_supported(datalink_id_t linkid,const char * propname,show_linkprop_state_t * statep)6756 linkprop_is_supported(datalink_id_t linkid, const char *propname,
6757 show_linkprop_state_t *statep)
6758 {
6759 dladm_status_t status;
6760 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
6761
6762 /* if used with -p flag, always print output */
6763 if (statep->ls_proplist != NULL)
6764 return (B_TRUE);
6765
6766 status = dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_DEFAULT,
6767 propname, statep->ls_propvals, &valcnt);
6768
6769 if (status == DLADM_STATUS_OK)
6770 return (B_TRUE);
6771
6772 /*
6773 * A system wide default value is not available for the
6774 * property. Check if current value can be retrieved.
6775 */
6776 status = dladm_get_linkprop(handle, linkid, DLADM_PROP_VAL_CURRENT,
6777 propname, statep->ls_propvals, &valcnt);
6778
6779 return (status == DLADM_STATUS_OK);
6780 }
6781
6782 /* ARGSUSED */
6783 static int
show_linkprop(dladm_handle_t dh,datalink_id_t linkid,const char * propname,void * arg)6784 show_linkprop(dladm_handle_t dh, datalink_id_t linkid, const char *propname,
6785 void *arg)
6786 {
6787 show_linkprop_state_t *statep = arg;
6788 linkprop_args_t ls_arg;
6789
6790 bzero(&ls_arg, sizeof (ls_arg));
6791 ls_arg.ls_state = statep;
6792 ls_arg.ls_propname = (char *)propname;
6793 ls_arg.ls_linkid = linkid;
6794
6795 /*
6796 * This will need to be fixed when kernel interfaces are added
6797 * to enable walking of all known private properties. For now,
6798 * we are limited to walking persistent private properties only.
6799 */
6800 if ((propname[0] == '_') && !statep->ls_persist &&
6801 (statep->ls_proplist == NULL))
6802 return (DLADM_WALK_CONTINUE);
6803 if (!statep->ls_parsable &&
6804 !linkprop_is_supported(linkid, propname, statep))
6805 return (DLADM_WALK_CONTINUE);
6806
6807 ofmt_print(statep->ls_ofmt, &ls_arg);
6808
6809 return (DLADM_WALK_CONTINUE);
6810 }
6811
6812 static void
do_show_linkprop(int argc,char ** argv,const char * use)6813 do_show_linkprop(int argc, char **argv, const char *use)
6814 {
6815 int option;
6816 char propstr[DLADM_STRSIZE];
6817 dladm_arg_list_t *proplist = NULL;
6818 datalink_id_t linkid = DATALINK_ALL_LINKID;
6819 show_linkprop_state_t state;
6820 uint32_t flags = DLADM_OPT_ACTIVE;
6821 dladm_status_t status;
6822 char *fields_str = NULL;
6823 ofmt_handle_t ofmt;
6824 ofmt_status_t oferr;
6825 uint_t ofmtflags = 0;
6826
6827 bzero(propstr, DLADM_STRSIZE);
6828 opterr = 0;
6829 state.ls_propvals = NULL;
6830 state.ls_line = NULL;
6831 state.ls_parsable = B_FALSE;
6832 state.ls_persist = B_FALSE;
6833 state.ls_header = B_TRUE;
6834 state.ls_retstatus = DLADM_STATUS_OK;
6835
6836 while ((option = getopt_long(argc, argv, ":p:cPo:",
6837 prop_longopts, NULL)) != -1) {
6838 switch (option) {
6839 case 'p':
6840 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
6841 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
6842 DLADM_STRSIZE)
6843 die("property list too long '%s'", propstr);
6844 break;
6845 case 'c':
6846 state.ls_parsable = B_TRUE;
6847 break;
6848 case 'P':
6849 state.ls_persist = B_TRUE;
6850 flags = DLADM_OPT_PERSIST;
6851 break;
6852 case 'o':
6853 fields_str = optarg;
6854 break;
6855 default:
6856 die_opterr(optopt, option, use);
6857 break;
6858 }
6859 }
6860
6861 if (optind == (argc - 1)) {
6862 if ((status = dladm_name2info(handle, argv[optind], &linkid,
6863 NULL, NULL, NULL)) != DLADM_STATUS_OK) {
6864 die_dlerr(status, "link %s is not valid", argv[optind]);
6865 }
6866 } else if (optind != argc) {
6867 usage();
6868 }
6869
6870 if (dladm_parse_link_props(propstr, &proplist, B_TRUE)
6871 != DLADM_STATUS_OK)
6872 die("invalid link properties specified");
6873 state.ls_proplist = proplist;
6874 state.ls_status = DLADM_STATUS_OK;
6875
6876 if (state.ls_parsable)
6877 ofmtflags |= OFMT_PARSABLE;
6878 else
6879 ofmtflags |= OFMT_WRAP;
6880
6881 oferr = ofmt_open(fields_str, linkprop_fields, ofmtflags, 0, &ofmt);
6882 ofmt_check(oferr, state.ls_parsable, ofmt, die, warn);
6883 state.ls_ofmt = ofmt;
6884
6885 if (linkid == DATALINK_ALL_LINKID) {
6886 (void) dladm_walk_datalink_id(show_linkprop_onelink, handle,
6887 &state, DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE, flags);
6888 } else {
6889 (void) show_linkprop_onelink(handle, linkid, &state);
6890 }
6891 ofmt_close(ofmt);
6892 dladm_free_props(proplist);
6893
6894 if (state.ls_retstatus != DLADM_STATUS_OK) {
6895 dladm_close(handle);
6896 exit(EXIT_FAILURE);
6897 }
6898 }
6899
6900 static int
show_linkprop_onelink(dladm_handle_t hdl,datalink_id_t linkid,void * arg)6901 show_linkprop_onelink(dladm_handle_t hdl, datalink_id_t linkid, void *arg)
6902 {
6903 int i;
6904 char *buf;
6905 uint32_t flags;
6906 dladm_arg_list_t *proplist = NULL;
6907 show_linkprop_state_t *statep = arg;
6908 dlpi_handle_t dh = NULL;
6909
6910 statep->ls_status = DLADM_STATUS_OK;
6911
6912 if (dladm_datalink_id2info(hdl, linkid, &flags, NULL, NULL,
6913 statep->ls_link, MAXLINKNAMELEN) != DLADM_STATUS_OK) {
6914 statep->ls_status = DLADM_STATUS_NOTFOUND;
6915 return (DLADM_WALK_CONTINUE);
6916 }
6917
6918 if ((statep->ls_persist && !(flags & DLADM_OPT_PERSIST)) ||
6919 (!statep->ls_persist && !(flags & DLADM_OPT_ACTIVE))) {
6920 statep->ls_status = DLADM_STATUS_BADARG;
6921 return (DLADM_WALK_CONTINUE);
6922 }
6923
6924 proplist = statep->ls_proplist;
6925
6926 /*
6927 * When some WiFi links are opened for the first time, their hardware
6928 * automatically scans for APs and does other slow operations. Thus,
6929 * if there are no open links, the retrieval of link properties
6930 * (below) will proceed slowly unless we hold the link open.
6931 *
6932 * Note that failure of dlpi_open() does not necessarily mean invalid
6933 * link properties, because dlpi_open() may fail because of incorrect
6934 * autopush configuration. Therefore, we ingore the return value of
6935 * dlpi_open().
6936 */
6937 if (!statep->ls_persist)
6938 (void) dlpi_open(statep->ls_link, &dh, 0);
6939
6940 buf = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) *
6941 DLADM_MAX_PROP_VALCNT + MAX_PROP_LINE);
6942 if (buf == NULL)
6943 die("insufficient memory");
6944
6945 statep->ls_propvals = (char **)(void *)buf;
6946 for (i = 0; i < DLADM_MAX_PROP_VALCNT; i++) {
6947 statep->ls_propvals[i] = buf +
6948 sizeof (char *) * DLADM_MAX_PROP_VALCNT +
6949 i * DLADM_PROP_VAL_MAX;
6950 }
6951 statep->ls_line = buf +
6952 (sizeof (char *) + DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT;
6953
6954 if (proplist != NULL) {
6955 for (i = 0; i < proplist->al_count; i++) {
6956 (void) show_linkprop(hdl, linkid,
6957 proplist->al_info[i].ai_name, statep);
6958 }
6959 } else {
6960 (void) dladm_walk_linkprop(hdl, linkid, statep,
6961 show_linkprop);
6962 }
6963 if (dh != NULL)
6964 dlpi_close(dh);
6965 free(buf);
6966 return (DLADM_WALK_CONTINUE);
6967 }
6968
6969 static int
reset_one_linkprop(dladm_handle_t dh,datalink_id_t linkid,const char * propname,void * arg)6970 reset_one_linkprop(dladm_handle_t dh, datalink_id_t linkid,
6971 const char *propname, void *arg)
6972 {
6973 set_linkprop_state_t *statep = arg;
6974 dladm_status_t status;
6975
6976 status = dladm_set_linkprop(dh, linkid, propname, NULL, 0,
6977 DLADM_OPT_ACTIVE | (statep->ls_temp ? 0 : DLADM_OPT_PERSIST));
6978 if (status != DLADM_STATUS_OK &&
6979 status != DLADM_STATUS_PROPRDONLY &&
6980 status != DLADM_STATUS_NOTSUP) {
6981 warn_dlerr(status, "cannot reset link property '%s' on '%s'",
6982 propname, statep->ls_name);
6983 statep->ls_status = status;
6984 }
6985
6986 return (DLADM_WALK_CONTINUE);
6987 }
6988
6989 static void
set_linkprop(int argc,char ** argv,boolean_t reset,const char * use)6990 set_linkprop(int argc, char **argv, boolean_t reset, const char *use)
6991 {
6992 int i, option;
6993 char errmsg[DLADM_STRSIZE];
6994 char *altroot = NULL;
6995 datalink_id_t linkid;
6996 boolean_t temp = B_FALSE;
6997 dladm_status_t status = DLADM_STATUS_OK;
6998 char propstr[DLADM_STRSIZE];
6999 dladm_arg_list_t *proplist = NULL;
7000
7001 opterr = 0;
7002 bzero(propstr, DLADM_STRSIZE);
7003
7004 while ((option = getopt_long(argc, argv, ":p:R:t",
7005 prop_longopts, NULL)) != -1) {
7006 switch (option) {
7007 case 'p':
7008 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
7009 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
7010 DLADM_STRSIZE)
7011 die("property list too long '%s'", propstr);
7012 break;
7013 case 't':
7014 temp = B_TRUE;
7015 break;
7016 case 'R':
7017 altroot = optarg;
7018 break;
7019 default:
7020 die_opterr(optopt, option, use);
7021
7022 }
7023 }
7024
7025 /* get link name (required last argument) */
7026 if (optind != (argc - 1))
7027 usage();
7028
7029 if (dladm_parse_link_props(propstr, &proplist, reset) !=
7030 DLADM_STATUS_OK)
7031 die("invalid link properties specified");
7032
7033 if (proplist == NULL && !reset)
7034 die("link property must be specified");
7035
7036 if (altroot != NULL) {
7037 dladm_free_props(proplist);
7038 altroot_cmd(altroot, argc, argv);
7039 }
7040
7041 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
7042 NULL);
7043 if (status != DLADM_STATUS_OK)
7044 die_dlerr(status, "link %s is not valid", argv[optind]);
7045
7046 if (proplist == NULL) {
7047 set_linkprop_state_t state;
7048
7049 state.ls_name = argv[optind];
7050 state.ls_reset = reset;
7051 state.ls_temp = temp;
7052 state.ls_status = DLADM_STATUS_OK;
7053
7054 (void) dladm_walk_linkprop(handle, linkid, &state,
7055 reset_one_linkprop);
7056
7057 status = state.ls_status;
7058 goto done;
7059 }
7060
7061 for (i = 0; i < proplist->al_count; i++) {
7062 dladm_arg_info_t *aip = &proplist->al_info[i];
7063 char **val;
7064 uint_t count;
7065
7066 if (reset) {
7067 val = NULL;
7068 count = 0;
7069 } else {
7070 val = aip->ai_val;
7071 count = aip->ai_count;
7072 if (count == 0) {
7073 warn("no value specified for '%s'",
7074 aip->ai_name);
7075 status = DLADM_STATUS_BADARG;
7076 continue;
7077 }
7078 }
7079 status = dladm_set_linkprop(handle, linkid, aip->ai_name, val,
7080 count, DLADM_OPT_ACTIVE | (temp ? 0 : DLADM_OPT_PERSIST));
7081 switch (status) {
7082 case DLADM_STATUS_OK:
7083 break;
7084 case DLADM_STATUS_NOTFOUND:
7085 warn("invalid link property '%s'", aip->ai_name);
7086 break;
7087 case DLADM_STATUS_BADVAL: {
7088 int j;
7089 char *ptr, *lim;
7090 char **propvals = NULL;
7091 uint_t valcnt = DLADM_MAX_PROP_VALCNT;
7092 dladm_status_t s;
7093
7094 ptr = malloc((sizeof (char *) +
7095 DLADM_PROP_VAL_MAX) * DLADM_MAX_PROP_VALCNT +
7096 MAX_PROP_LINE);
7097
7098 propvals = (char **)(void *)ptr;
7099 if (propvals == NULL)
7100 die("insufficient memory");
7101
7102 for (j = 0; j < DLADM_MAX_PROP_VALCNT; j++) {
7103 propvals[j] = ptr + sizeof (char *) *
7104 DLADM_MAX_PROP_VALCNT +
7105 j * DLADM_PROP_VAL_MAX;
7106 }
7107 s = dladm_get_linkprop(handle, linkid,
7108 DLADM_PROP_VAL_MODIFIABLE, aip->ai_name, propvals,
7109 &valcnt);
7110
7111 if (s != DLADM_STATUS_OK) {
7112 warn_dlerr(status, "cannot set link property "
7113 "'%s' on '%s'", aip->ai_name, argv[optind]);
7114 free(propvals);
7115 break;
7116 }
7117
7118 ptr = errmsg;
7119 lim = ptr + DLADM_STRSIZE;
7120 *ptr = '\0';
7121 for (j = 0; j < valcnt; j++) {
7122 ptr += snprintf(ptr, lim - ptr, "%s,",
7123 propvals[j]);
7124 if (ptr >= lim)
7125 break;
7126 }
7127 if (ptr > errmsg) {
7128 *(ptr - 1) = '\0';
7129 warn("link property '%s' must be one of: %s",
7130 aip->ai_name, errmsg);
7131 } else
7132 warn("invalid link property '%s'", *val);
7133 free(propvals);
7134 break;
7135 }
7136 default:
7137 if (reset) {
7138 warn_dlerr(status, "cannot reset link property "
7139 "'%s' on '%s'", aip->ai_name, argv[optind]);
7140 } else {
7141 warn_dlerr(status, "cannot set link property "
7142 "'%s' on '%s'", aip->ai_name, argv[optind]);
7143 }
7144 break;
7145 }
7146 }
7147 done:
7148 dladm_free_props(proplist);
7149 if (status != DLADM_STATUS_OK) {
7150 dladm_close(handle);
7151 exit(EXIT_FAILURE);
7152 }
7153 }
7154
7155 static void
do_set_linkprop(int argc,char ** argv,const char * use)7156 do_set_linkprop(int argc, char **argv, const char *use)
7157 {
7158 set_linkprop(argc, argv, B_FALSE, use);
7159 }
7160
7161 static void
do_reset_linkprop(int argc,char ** argv,const char * use)7162 do_reset_linkprop(int argc, char **argv, const char *use)
7163 {
7164 set_linkprop(argc, argv, B_TRUE, use);
7165 }
7166
7167 static int
convert_secobj(char * buf,uint_t len,uint8_t * obj_val,uint_t * obj_lenp,dladm_secobj_class_t class)7168 convert_secobj(char *buf, uint_t len, uint8_t *obj_val, uint_t *obj_lenp,
7169 dladm_secobj_class_t class)
7170 {
7171 int error = 0;
7172
7173 if (class == DLADM_SECOBJ_CLASS_WPA) {
7174 if (len < 8 || len > 63)
7175 return (EINVAL);
7176 (void) memcpy(obj_val, buf, len);
7177 *obj_lenp = len;
7178 return (error);
7179 }
7180
7181 if (class == DLADM_SECOBJ_CLASS_WEP) {
7182 switch (len) {
7183 case 5: /* ASCII key sizes */
7184 case 13:
7185 (void) memcpy(obj_val, buf, len);
7186 *obj_lenp = len;
7187 break;
7188 case 10: /* Hex key sizes, not preceded by 0x */
7189 case 26:
7190 error = hexascii_to_octet(buf, len, obj_val, obj_lenp);
7191 break;
7192 case 12: /* Hex key sizes, preceded by 0x */
7193 case 28:
7194 if (strncmp(buf, "0x", 2) != 0)
7195 return (EINVAL);
7196 error = hexascii_to_octet(buf + 2, len - 2,
7197 obj_val, obj_lenp);
7198 break;
7199 default:
7200 return (EINVAL);
7201 }
7202 return (error);
7203 }
7204
7205 return (ENOENT);
7206 }
7207
7208 static void
defersig(int sig)7209 defersig(int sig)
7210 {
7211 signalled = sig;
7212 }
7213
7214 static int
get_secobj_from_tty(uint_t try,const char * objname,char * buf)7215 get_secobj_from_tty(uint_t try, const char *objname, char *buf)
7216 {
7217 uint_t len = 0;
7218 int c;
7219 struct termios stored, current;
7220 void (*sigfunc)(int);
7221
7222 /*
7223 * Turn off echo -- but before we do so, defer SIGINT handling
7224 * so that a ^C doesn't leave the terminal corrupted.
7225 */
7226 sigfunc = signal(SIGINT, defersig);
7227 (void) fflush(stdin);
7228 (void) tcgetattr(0, &stored);
7229 current = stored;
7230 current.c_lflag &= ~(ICANON|ECHO);
7231 current.c_cc[VTIME] = 0;
7232 current.c_cc[VMIN] = 1;
7233 (void) tcsetattr(0, TCSANOW, ¤t);
7234 again:
7235 if (try == 1)
7236 (void) printf(gettext("provide value for '%s': "), objname);
7237 else
7238 (void) printf(gettext("confirm value for '%s': "), objname);
7239
7240 (void) fflush(stdout);
7241 while (signalled == 0) {
7242 c = getchar();
7243 if (c == '\n' || c == '\r') {
7244 if (len != 0)
7245 break;
7246 (void) putchar('\n');
7247 goto again;
7248 }
7249
7250 buf[len++] = c;
7251 if (len >= DLADM_SECOBJ_VAL_MAX - 1)
7252 break;
7253 (void) putchar('*');
7254 }
7255
7256 (void) putchar('\n');
7257 (void) fflush(stdin);
7258
7259 /*
7260 * Restore terminal setting and handle deferred signals.
7261 */
7262 (void) tcsetattr(0, TCSANOW, &stored);
7263
7264 (void) signal(SIGINT, sigfunc);
7265 if (signalled != 0)
7266 (void) kill(getpid(), signalled);
7267
7268 return (len);
7269 }
7270
7271 static int
get_secobj_val(char * obj_name,uint8_t * obj_val,uint_t * obj_lenp,dladm_secobj_class_t class,FILE * filep)7272 get_secobj_val(char *obj_name, uint8_t *obj_val, uint_t *obj_lenp,
7273 dladm_secobj_class_t class, FILE *filep)
7274 {
7275 int rval;
7276 uint_t len = 0, len2;
7277 char buf[DLADM_SECOBJ_VAL_MAX], buf2[DLADM_SECOBJ_VAL_MAX];
7278
7279 if (filep == NULL) {
7280 len = get_secobj_from_tty(1, obj_name, buf);
7281 rval = convert_secobj(buf, len, obj_val, obj_lenp, class);
7282 if (rval == 0) {
7283 len2 = get_secobj_from_tty(2, obj_name, buf2);
7284 if (len != len2 || memcmp(buf, buf2, len) != 0)
7285 rval = ENOTSUP;
7286 }
7287 return (rval);
7288 } else {
7289 for (;;) {
7290 if (fgets(buf, sizeof (buf), filep) == NULL)
7291 break;
7292 if (isspace(buf[0]))
7293 continue;
7294
7295 len = strlen(buf);
7296 if (buf[len - 1] == '\n') {
7297 buf[len - 1] = '\0';
7298 len--;
7299 }
7300 break;
7301 }
7302 (void) fclose(filep);
7303 }
7304 return (convert_secobj(buf, len, obj_val, obj_lenp, class));
7305 }
7306
7307 static boolean_t
check_auth(const char * auth)7308 check_auth(const char *auth)
7309 {
7310 struct passwd *pw;
7311
7312 if ((pw = getpwuid(getuid())) == NULL)
7313 return (B_FALSE);
7314
7315 return (chkauthattr(auth, pw->pw_name) != 0);
7316 }
7317
7318 static void
audit_secobj(char * auth,char * class,char * obj,boolean_t success,boolean_t create)7319 audit_secobj(char *auth, char *class, char *obj,
7320 boolean_t success, boolean_t create)
7321 {
7322 adt_session_data_t *ah;
7323 adt_event_data_t *event;
7324 au_event_t flag;
7325 char *errstr;
7326
7327 if (create) {
7328 flag = ADT_dladm_create_secobj;
7329 errstr = "ADT_dladm_create_secobj";
7330 } else {
7331 flag = ADT_dladm_delete_secobj;
7332 errstr = "ADT_dladm_delete_secobj";
7333 }
7334
7335 if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0)
7336 die("adt_start_session: %s", strerror(errno));
7337
7338 if ((event = adt_alloc_event(ah, flag)) == NULL)
7339 die("adt_alloc_event (%s): %s", errstr, strerror(errno));
7340
7341 /* fill in audit info */
7342 if (create) {
7343 event->adt_dladm_create_secobj.auth_used = auth;
7344 event->adt_dladm_create_secobj.obj_class = class;
7345 event->adt_dladm_create_secobj.obj_name = obj;
7346 } else {
7347 event->adt_dladm_delete_secobj.auth_used = auth;
7348 event->adt_dladm_delete_secobj.obj_class = class;
7349 event->adt_dladm_delete_secobj.obj_name = obj;
7350 }
7351
7352 if (success) {
7353 if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0) {
7354 die("adt_put_event (%s, success): %s", errstr,
7355 strerror(errno));
7356 }
7357 } else {
7358 if (adt_put_event(event, ADT_FAILURE,
7359 ADT_FAIL_VALUE_AUTH) != 0) {
7360 die("adt_put_event: (%s, failure): %s", errstr,
7361 strerror(errno));
7362 }
7363 }
7364
7365 adt_free_event(event);
7366 (void) adt_end_session(ah);
7367 }
7368
7369 static void
do_create_secobj(int argc,char ** argv,const char * use)7370 do_create_secobj(int argc, char **argv, const char *use)
7371 {
7372 int option, rval;
7373 FILE *filep = NULL;
7374 char *obj_name = NULL;
7375 char *class_name = NULL;
7376 uint8_t obj_val[DLADM_SECOBJ_VAL_MAX];
7377 uint_t obj_len;
7378 boolean_t success, temp = B_FALSE;
7379 dladm_status_t status;
7380 dladm_secobj_class_t class = -1;
7381 uid_t euid;
7382
7383 opterr = 0;
7384 (void) memset(obj_val, 0, DLADM_SECOBJ_VAL_MAX);
7385 while ((option = getopt_long(argc, argv, ":f:c:R:t",
7386 wifi_longopts, NULL)) != -1) {
7387 switch (option) {
7388 case 'f':
7389 euid = geteuid();
7390 (void) seteuid(getuid());
7391 filep = fopen(optarg, "r");
7392 if (filep == NULL) {
7393 die("cannot open %s: %s", optarg,
7394 strerror(errno));
7395 }
7396 (void) seteuid(euid);
7397 break;
7398 case 'c':
7399 class_name = optarg;
7400 status = dladm_str2secobjclass(optarg, &class);
7401 if (status != DLADM_STATUS_OK) {
7402 die("invalid secure object class '%s', "
7403 "valid values are: wep, wpa", optarg);
7404 }
7405 break;
7406 case 't':
7407 temp = B_TRUE;
7408 break;
7409 case 'R':
7410 status = dladm_set_rootdir(optarg);
7411 if (status != DLADM_STATUS_OK) {
7412 die_dlerr(status, "invalid directory "
7413 "specified");
7414 }
7415 break;
7416 default:
7417 die_opterr(optopt, option, use);
7418 break;
7419 }
7420 }
7421
7422 if (optind == (argc - 1))
7423 obj_name = argv[optind];
7424 else if (optind != argc)
7425 usage();
7426
7427 if (class == -1)
7428 die("secure object class required");
7429
7430 if (obj_name == NULL)
7431 die("secure object name required");
7432
7433 if (!dladm_valid_secobj_name(obj_name))
7434 die("invalid secure object name '%s'", obj_name);
7435
7436 success = check_auth(LINK_SEC_AUTH);
7437 audit_secobj(LINK_SEC_AUTH, class_name, obj_name, success, B_TRUE);
7438 if (!success)
7439 die("authorization '%s' is required", LINK_SEC_AUTH);
7440
7441 rval = get_secobj_val(obj_name, obj_val, &obj_len, class, filep);
7442 if (rval != 0) {
7443 switch (rval) {
7444 case ENOENT:
7445 die("invalid secure object class");
7446 break;
7447 case EINVAL:
7448 die("invalid secure object value");
7449 break;
7450 case ENOTSUP:
7451 die("verification failed");
7452 break;
7453 default:
7454 die("invalid secure object: %s", strerror(rval));
7455 break;
7456 }
7457 }
7458
7459 status = dladm_set_secobj(handle, obj_name, class, obj_val, obj_len,
7460 DLADM_OPT_CREATE | DLADM_OPT_ACTIVE);
7461 if (status != DLADM_STATUS_OK) {
7462 die_dlerr(status, "could not create secure object '%s'",
7463 obj_name);
7464 }
7465 if (temp)
7466 return;
7467
7468 status = dladm_set_secobj(handle, obj_name, class, obj_val, obj_len,
7469 DLADM_OPT_PERSIST);
7470 if (status != DLADM_STATUS_OK) {
7471 warn_dlerr(status, "could not persistently create secure "
7472 "object '%s'", obj_name);
7473 }
7474 }
7475
7476 static void
do_delete_secobj(int argc,char ** argv,const char * use)7477 do_delete_secobj(int argc, char **argv, const char *use)
7478 {
7479 int i, option;
7480 boolean_t temp = B_FALSE;
7481 boolean_t success;
7482 dladm_status_t status, pstatus;
7483 int nfields = 1;
7484 char *field, *token, *lasts = NULL, c;
7485
7486 opterr = 0;
7487 status = pstatus = DLADM_STATUS_OK;
7488 while ((option = getopt_long(argc, argv, ":R:t",
7489 wifi_longopts, NULL)) != -1) {
7490 switch (option) {
7491 case 't':
7492 temp = B_TRUE;
7493 break;
7494 case 'R':
7495 status = dladm_set_rootdir(optarg);
7496 if (status != DLADM_STATUS_OK) {
7497 die_dlerr(status, "invalid directory "
7498 "specified");
7499 }
7500 break;
7501 default:
7502 die_opterr(optopt, option, use);
7503 break;
7504 }
7505 }
7506
7507 if (optind != (argc - 1))
7508 die("secure object name required");
7509
7510 token = argv[optind];
7511 while ((c = *token++) != '\0') {
7512 if (c == ',')
7513 nfields++;
7514 }
7515 token = strdup(argv[optind]);
7516 if (token == NULL)
7517 die("no memory");
7518
7519 success = check_auth(LINK_SEC_AUTH);
7520 audit_secobj(LINK_SEC_AUTH, "unknown", argv[optind], success, B_FALSE);
7521 if (!success)
7522 die("authorization '%s' is required", LINK_SEC_AUTH);
7523
7524 for (i = 0; i < nfields; i++) {
7525
7526 field = strtok_r(token, ",", &lasts);
7527 token = NULL;
7528 status = dladm_unset_secobj(handle, field, DLADM_OPT_ACTIVE);
7529 if (!temp) {
7530 pstatus = dladm_unset_secobj(handle, field,
7531 DLADM_OPT_PERSIST);
7532 } else {
7533 pstatus = DLADM_STATUS_OK;
7534 }
7535
7536 if (status != DLADM_STATUS_OK) {
7537 warn_dlerr(status, "could not delete secure object "
7538 "'%s'", field);
7539 }
7540 if (pstatus != DLADM_STATUS_OK) {
7541 warn_dlerr(pstatus, "could not persistently delete "
7542 "secure object '%s'", field);
7543 }
7544 }
7545 free(token);
7546
7547 if (status != DLADM_STATUS_OK || pstatus != DLADM_STATUS_OK) {
7548 dladm_close(handle);
7549 exit(EXIT_FAILURE);
7550 }
7551 }
7552
7553 typedef struct show_secobj_state {
7554 boolean_t ss_persist;
7555 boolean_t ss_parsable;
7556 boolean_t ss_header;
7557 ofmt_handle_t ss_ofmt;
7558 } show_secobj_state_t;
7559
7560
7561 static boolean_t
show_secobj(dladm_handle_t dh,void * arg,const char * obj_name)7562 show_secobj(dladm_handle_t dh, void *arg, const char *obj_name)
7563 {
7564 uint_t obj_len = DLADM_SECOBJ_VAL_MAX;
7565 uint8_t obj_val[DLADM_SECOBJ_VAL_MAX];
7566 char buf[DLADM_STRSIZE];
7567 uint_t flags = 0;
7568 dladm_secobj_class_t class;
7569 show_secobj_state_t *statep = arg;
7570 dladm_status_t status;
7571 secobj_fields_buf_t sbuf;
7572
7573 bzero(&sbuf, sizeof (secobj_fields_buf_t));
7574 if (statep->ss_persist)
7575 flags |= DLADM_OPT_PERSIST;
7576
7577 status = dladm_get_secobj(dh, obj_name, &class, obj_val, &obj_len,
7578 flags);
7579 if (status != DLADM_STATUS_OK)
7580 die_dlerr(status, "cannot get secure object '%s'", obj_name);
7581
7582 (void) snprintf(sbuf.ss_obj_name, sizeof (sbuf.ss_obj_name),
7583 obj_name);
7584 (void) dladm_secobjclass2str(class, buf);
7585 (void) snprintf(sbuf.ss_class, sizeof (sbuf.ss_class), "%s", buf);
7586 if (getuid() == 0) {
7587 char val[DLADM_SECOBJ_VAL_MAX * 2];
7588 uint_t len = sizeof (val);
7589
7590 if (octet_to_hexascii(obj_val, obj_len, val, &len) == 0)
7591 (void) snprintf(sbuf.ss_val,
7592 sizeof (sbuf.ss_val), "%s", val);
7593 }
7594 ofmt_print(statep->ss_ofmt, &sbuf);
7595 return (B_TRUE);
7596 }
7597
7598 static void
do_show_secobj(int argc,char ** argv,const char * use)7599 do_show_secobj(int argc, char **argv, const char *use)
7600 {
7601 int option;
7602 show_secobj_state_t state;
7603 dladm_status_t status;
7604 boolean_t o_arg = B_FALSE;
7605 uint_t i;
7606 uint_t flags;
7607 char *fields_str = NULL;
7608 char *def_fields = "object,class";
7609 char *all_fields = "object,class,value";
7610 char *field, *token, *lasts = NULL, c;
7611 ofmt_handle_t ofmt;
7612 ofmt_status_t oferr;
7613 uint_t ofmtflags = 0;
7614
7615 opterr = 0;
7616 bzero(&state, sizeof (state));
7617 state.ss_parsable = B_FALSE;
7618 fields_str = def_fields;
7619 state.ss_persist = B_FALSE;
7620 state.ss_parsable = B_FALSE;
7621 state.ss_header = B_TRUE;
7622 while ((option = getopt_long(argc, argv, ":pPo:",
7623 wifi_longopts, NULL)) != -1) {
7624 switch (option) {
7625 case 'p':
7626 state.ss_parsable = B_TRUE;
7627 break;
7628 case 'P':
7629 state.ss_persist = B_TRUE;
7630 break;
7631 case 'o':
7632 o_arg = B_TRUE;
7633 if (strcasecmp(optarg, "all") == 0)
7634 fields_str = all_fields;
7635 else
7636 fields_str = optarg;
7637 break;
7638 default:
7639 die_opterr(optopt, option, use);
7640 break;
7641 }
7642 }
7643
7644 if (state.ss_parsable && !o_arg)
7645 die("option -c requires -o");
7646
7647 if (state.ss_parsable && fields_str == all_fields)
7648 die("\"-o all\" is invalid with -p");
7649
7650 if (state.ss_parsable)
7651 ofmtflags |= OFMT_PARSABLE;
7652 oferr = ofmt_open(fields_str, secobj_fields, ofmtflags, 0, &ofmt);
7653 ofmt_check(oferr, state.ss_parsable, ofmt, die, warn);
7654 state.ss_ofmt = ofmt;
7655
7656 flags = state.ss_persist ? DLADM_OPT_PERSIST : 0;
7657
7658 if (optind == (argc - 1)) {
7659 uint_t obj_fields = 1;
7660
7661 token = argv[optind];
7662 if (token == NULL)
7663 die("secure object name required");
7664 while ((c = *token++) != '\0') {
7665 if (c == ',')
7666 obj_fields++;
7667 }
7668 token = strdup(argv[optind]);
7669 if (token == NULL)
7670 die("no memory");
7671 for (i = 0; i < obj_fields; i++) {
7672 field = strtok_r(token, ",", &lasts);
7673 token = NULL;
7674 if (!show_secobj(handle, &state, field))
7675 break;
7676 }
7677 free(token);
7678 ofmt_close(ofmt);
7679 return;
7680 } else if (optind != argc)
7681 usage();
7682
7683 status = dladm_walk_secobj(handle, &state, show_secobj, flags);
7684
7685 if (status != DLADM_STATUS_OK)
7686 die_dlerr(status, "show-secobj");
7687 ofmt_close(ofmt);
7688 }
7689
7690 /*ARGSUSED*/
7691 static int
i_dladm_init_linkprop(dladm_handle_t dh,datalink_id_t linkid,void * arg)7692 i_dladm_init_linkprop(dladm_handle_t dh, datalink_id_t linkid, void *arg)
7693 {
7694 (void) dladm_init_linkprop(dh, linkid, B_TRUE);
7695 return (DLADM_WALK_CONTINUE);
7696 }
7697
7698 /*ARGSUSED*/
7699 void
do_init_linkprop(int argc,char ** argv,const char * use)7700 do_init_linkprop(int argc, char **argv, const char *use)
7701 {
7702 int option;
7703 dladm_status_t status;
7704 datalink_id_t linkid = DATALINK_ALL_LINKID;
7705 datalink_media_t media = DATALINK_ANY_MEDIATYPE;
7706 uint_t any_media = B_TRUE;
7707
7708 opterr = 0;
7709 while ((option = getopt(argc, argv, ":w")) != -1) {
7710 switch (option) {
7711 case 'w':
7712 media = DL_WIFI;
7713 any_media = B_FALSE;
7714 break;
7715 default:
7716 /*
7717 * Because init-linkprop is not a public command,
7718 * print the usage instead.
7719 */
7720 usage();
7721 break;
7722 }
7723 }
7724
7725 if (optind == (argc - 1)) {
7726 if ((status = dladm_name2info(handle, argv[optind], &linkid,
7727 NULL, NULL, NULL)) != DLADM_STATUS_OK)
7728 die_dlerr(status, "link %s is not valid", argv[optind]);
7729 } else if (optind != argc) {
7730 usage();
7731 }
7732
7733 if (linkid == DATALINK_ALL_LINKID) {
7734 /*
7735 * linkprops of links of other classes have been initialized as
7736 * part of the dladm up-xxx operation.
7737 */
7738 (void) dladm_walk_datalink_id(i_dladm_init_linkprop, handle,
7739 NULL, DATALINK_CLASS_PHYS, media, DLADM_OPT_PERSIST);
7740 } else {
7741 (void) dladm_init_linkprop(handle, linkid, any_media);
7742 }
7743 }
7744
7745 static void
do_show_ether(int argc,char ** argv,const char * use)7746 do_show_ether(int argc, char **argv, const char *use)
7747 {
7748 int option;
7749 datalink_id_t linkid;
7750 print_ether_state_t state;
7751 char *fields_str = NULL;
7752 ofmt_handle_t ofmt;
7753 ofmt_status_t oferr;
7754 uint_t ofmtflags = 0;
7755
7756 bzero(&state, sizeof (state));
7757 state.es_link = NULL;
7758 state.es_parsable = B_FALSE;
7759
7760 while ((option = getopt_long(argc, argv, "o:px",
7761 showeth_lopts, NULL)) != -1) {
7762 switch (option) {
7763 case 'x':
7764 state.es_extended = B_TRUE;
7765 break;
7766 case 'p':
7767 state.es_parsable = B_TRUE;
7768 break;
7769 case 'o':
7770 fields_str = optarg;
7771 break;
7772 default:
7773 die_opterr(optopt, option, use);
7774 break;
7775 }
7776 }
7777
7778 if (optind == (argc - 1))
7779 state.es_link = argv[optind];
7780
7781 if (state.es_parsable)
7782 ofmtflags |= OFMT_PARSABLE;
7783 oferr = ofmt_open(fields_str, ether_fields, ofmtflags,
7784 DLADM_DEFAULT_COL, &ofmt);
7785 ofmt_check(oferr, state.es_parsable, ofmt, die, warn);
7786 state.es_ofmt = ofmt;
7787
7788 if (state.es_link == NULL) {
7789 (void) dladm_walk_datalink_id(show_etherprop, handle, &state,
7790 DATALINK_CLASS_PHYS, DL_ETHER, DLADM_OPT_ACTIVE);
7791 } else {
7792 if (!link_is_ether(state.es_link, &linkid))
7793 die("invalid link specified");
7794 (void) show_etherprop(handle, linkid, &state);
7795 }
7796 ofmt_close(ofmt);
7797 }
7798
7799 static int
show_etherprop(dladm_handle_t dh,datalink_id_t linkid,void * arg)7800 show_etherprop(dladm_handle_t dh, datalink_id_t linkid, void *arg)
7801 {
7802 print_ether_state_t *statep = arg;
7803 ether_fields_buf_t ebuf;
7804 dladm_ether_info_t eattr;
7805 dladm_status_t status;
7806
7807 bzero(&ebuf, sizeof (ether_fields_buf_t));
7808 if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL,
7809 ebuf.eth_link, sizeof (ebuf.eth_link)) != DLADM_STATUS_OK) {
7810 return (DLADM_WALK_CONTINUE);
7811 }
7812
7813 status = dladm_ether_info(dh, linkid, &eattr);
7814 if (status != DLADM_STATUS_OK) {
7815 return (DLADM_WALK_CONTINUE);
7816 }
7817
7818 (void) strlcpy(ebuf.eth_ptype, "current", sizeof (ebuf.eth_ptype));
7819
7820 (void) dladm_ether_autoneg2str(ebuf.eth_autoneg,
7821 sizeof (ebuf.eth_autoneg), &eattr, CURRENT);
7822 (void) dladm_ether_pause2str(ebuf.eth_pause,
7823 sizeof (ebuf.eth_pause), &eattr, CURRENT);
7824 (void) dladm_ether_spdx2str(ebuf.eth_spdx,
7825 sizeof (ebuf.eth_spdx), &eattr, CURRENT);
7826 (void) strlcpy(ebuf.eth_state,
7827 dladm_linkstate2str(eattr.lei_state, ebuf.eth_state),
7828 sizeof (ebuf.eth_state));
7829 (void) strlcpy(ebuf.eth_rem_fault,
7830 (eattr.lei_attr[CURRENT].le_fault ? "fault" : "none"),
7831 sizeof (ebuf.eth_rem_fault));
7832
7833 ofmt_print(statep->es_ofmt, &ebuf);
7834
7835 if (statep->es_extended)
7836 show_ether_xprop(arg, &eattr);
7837
7838 dladm_ether_info_done(&eattr);
7839 return (DLADM_WALK_CONTINUE);
7840 }
7841
7842 /* ARGSUSED */
7843 static void
do_init_secobj(int argc,char ** argv,const char * use)7844 do_init_secobj(int argc, char **argv, const char *use)
7845 {
7846 dladm_status_t status;
7847
7848 status = dladm_init_secobj(handle);
7849 if (status != DLADM_STATUS_OK)
7850 die_dlerr(status, "secure object initialization failed");
7851 }
7852
7853 enum bridge_func {
7854 brCreate, brAdd, brModify
7855 };
7856
7857 static void
create_modify_add_bridge(int argc,char ** argv,const char * use,enum bridge_func func)7858 create_modify_add_bridge(int argc, char **argv, const char *use,
7859 enum bridge_func func)
7860 {
7861 int option;
7862 uint_t n, i, nlink;
7863 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
7864 char *altroot = NULL;
7865 char *links[MAXPORT];
7866 datalink_id_t linkids[MAXPORT];
7867 dladm_status_t status;
7868 const char *bridge;
7869 UID_STP_CFG_T cfg, cfg_old;
7870 dladm_bridge_prot_t brprot = DLADM_BRIDGE_PROT_UNKNOWN;
7871 dladm_bridge_prot_t brprot_old;
7872
7873 /* Set up the default configuration values */
7874 cfg.field_mask = 0;
7875 cfg.bridge_priority = DEF_BR_PRIO;
7876 cfg.max_age = DEF_BR_MAXAGE;
7877 cfg.hello_time = DEF_BR_HELLOT;
7878 cfg.forward_delay = DEF_BR_FWDELAY;
7879 cfg.force_version = DEF_FORCE_VERS;
7880
7881 nlink = opterr = 0;
7882 while ((option = getopt_long(argc, argv, ":P:R:d:f:h:l:m:p:",
7883 bridge_lopts, NULL)) != -1) {
7884 switch (option) {
7885 case 'P':
7886 if (func == brAdd)
7887 die_opterr(optopt, option, use);
7888 status = dladm_bridge_str2prot(optarg, &brprot);
7889 if (status != DLADM_STATUS_OK)
7890 die_dlerr(status, "protection %s", optarg);
7891 break;
7892 case 'R':
7893 altroot = optarg;
7894 break;
7895 case 'd':
7896 if (func == brAdd)
7897 die_opterr(optopt, option, use);
7898 if (cfg.field_mask & BR_CFG_DELAY)
7899 die("forwarding delay set more than once");
7900 if (!str2int(optarg, &cfg.forward_delay) ||
7901 cfg.forward_delay < MIN_BR_FWDELAY ||
7902 cfg.forward_delay > MAX_BR_FWDELAY)
7903 die("incorrect forwarding delay");
7904 cfg.field_mask |= BR_CFG_DELAY;
7905 break;
7906 case 'f':
7907 if (func == brAdd)
7908 die_opterr(optopt, option, use);
7909 if (cfg.field_mask & BR_CFG_FORCE_VER)
7910 die("force protocol set more than once");
7911 if (!str2int(optarg, &cfg.force_version) ||
7912 cfg.force_version < 0)
7913 die("incorrect force protocol");
7914 cfg.field_mask |= BR_CFG_FORCE_VER;
7915 break;
7916 case 'h':
7917 if (func == brAdd)
7918 die_opterr(optopt, option, use);
7919 if (cfg.field_mask & BR_CFG_HELLO)
7920 die("hello time set more than once");
7921 if (!str2int(optarg, &cfg.hello_time) ||
7922 cfg.hello_time < MIN_BR_HELLOT ||
7923 cfg.hello_time > MAX_BR_HELLOT)
7924 die("incorrect hello time");
7925 cfg.field_mask |= BR_CFG_HELLO;
7926 break;
7927 case 'l':
7928 if (func == brModify)
7929 die_opterr(optopt, option, use);
7930 if (nlink >= MAXPORT)
7931 die("too many links specified");
7932 links[nlink++] = optarg;
7933 break;
7934 case 'm':
7935 if (func == brAdd)
7936 die_opterr(optopt, option, use);
7937 if (cfg.field_mask & BR_CFG_AGE)
7938 die("max age set more than once");
7939 if (!str2int(optarg, &cfg.max_age) ||
7940 cfg.max_age < MIN_BR_MAXAGE ||
7941 cfg.max_age > MAX_BR_MAXAGE)
7942 die("incorrect max age");
7943 cfg.field_mask |= BR_CFG_AGE;
7944 break;
7945 case 'p':
7946 if (func == brAdd)
7947 die_opterr(optopt, option, use);
7948 if (cfg.field_mask & BR_CFG_PRIO)
7949 die("priority set more than once");
7950 if (!str2int(optarg, &cfg.bridge_priority) ||
7951 cfg.bridge_priority < MIN_BR_PRIO ||
7952 cfg.bridge_priority > MAX_BR_PRIO)
7953 die("incorrect priority");
7954 cfg.bridge_priority &= 0xF000;
7955 cfg.field_mask |= BR_CFG_PRIO;
7956 break;
7957 default:
7958 die_opterr(optopt, option, use);
7959 break;
7960 }
7961 }
7962
7963 /* get the bridge name (required last argument) */
7964 if (optind != (argc-1))
7965 usage();
7966
7967 bridge = argv[optind];
7968 if (!dladm_valid_bridgename(bridge))
7969 die("invalid bridge name '%s'", bridge);
7970
7971 /*
7972 * Get the current properties, if any, and merge in with changes. This
7973 * is necessary (even with the field_mask feature) so that the
7974 * value-checking macros will produce the right results with proposed
7975 * changes to existing configuration. We only need it for those
7976 * parameters, though.
7977 */
7978 (void) dladm_bridge_get_properties(bridge, &cfg_old, &brprot_old);
7979 if (brprot == DLADM_BRIDGE_PROT_UNKNOWN)
7980 brprot = brprot_old;
7981 if (!(cfg.field_mask & BR_CFG_AGE))
7982 cfg.max_age = cfg_old.max_age;
7983 if (!(cfg.field_mask & BR_CFG_HELLO))
7984 cfg.hello_time = cfg_old.hello_time;
7985 if (!(cfg.field_mask & BR_CFG_DELAY))
7986 cfg.forward_delay = cfg_old.forward_delay;
7987
7988 if (!CHECK_BRIDGE_CONFIG(cfg)) {
7989 warn("illegal forward delay / max age / hello time "
7990 "combination");
7991 if (NO_MAXAGE(cfg)) {
7992 die("no max age possible: need forward delay >= %d or "
7993 "hello time <= %d", MIN_FWDELAY_NOM(cfg),
7994 MAX_HELLOTIME_NOM(cfg));
7995 } else if (SMALL_MAXAGE(cfg)) {
7996 if (CAPPED_MAXAGE(cfg))
7997 die("max age too small: need age >= %d and "
7998 "<= %d or hello time <= %d",
7999 MIN_MAXAGE(cfg), MAX_MAXAGE(cfg),
8000 MAX_HELLOTIME(cfg));
8001 else
8002 die("max age too small: need age >= %d or "
8003 "hello time <= %d",
8004 MIN_MAXAGE(cfg), MAX_HELLOTIME(cfg));
8005 } else if (FLOORED_MAXAGE(cfg)) {
8006 die("max age too large: need age >= %d and <= %d or "
8007 "forward delay >= %d",
8008 MIN_MAXAGE(cfg), MAX_MAXAGE(cfg),
8009 MIN_FWDELAY(cfg));
8010 } else {
8011 die("max age too large: need age <= %d or forward "
8012 "delay >= %d",
8013 MAX_MAXAGE(cfg), MIN_FWDELAY(cfg));
8014 }
8015 }
8016
8017 if (altroot != NULL)
8018 altroot_cmd(altroot, argc, argv);
8019
8020 for (n = 0; n < nlink; n++) {
8021 datalink_class_t class;
8022 uint32_t media;
8023 char pointless[DLADM_STRSIZE];
8024
8025 if (dladm_name2info(handle, links[n], &linkids[n], NULL, &class,
8026 &media) != DLADM_STATUS_OK)
8027 die("invalid link name '%s'", links[n]);
8028 if (class & ~(DATALINK_CLASS_PHYS | DATALINK_CLASS_AGGR |
8029 DATALINK_CLASS_ETHERSTUB | DATALINK_CLASS_SIMNET))
8030 die("%s %s cannot be bridged",
8031 dladm_class2str(class, pointless), links[n]);
8032 if (media != DL_ETHER && media != DL_100VG &&
8033 media != DL_ETH_CSMA && media != DL_100BT)
8034 die("%s interface %s cannot be bridged",
8035 dladm_media2str(media, pointless), links[n]);
8036 }
8037
8038 if (func == brCreate)
8039 flags |= DLADM_OPT_CREATE;
8040
8041 if (func != brAdd) {
8042 status = dladm_bridge_configure(handle, bridge, &cfg, brprot,
8043 flags);
8044 if (status != DLADM_STATUS_OK)
8045 die_dlerr(status, "create operation failed");
8046 }
8047
8048 status = DLADM_STATUS_OK;
8049 for (n = 0; n < nlink; n++) {
8050 status = dladm_bridge_setlink(handle, linkids[n], bridge);
8051 if (status != DLADM_STATUS_OK)
8052 break;
8053 }
8054
8055 if (n >= nlink) {
8056 /*
8057 * We were successful. If we're creating a new bridge, then
8058 * there's just one more step: enabling. If we're modifying or
8059 * just adding links, then we're done.
8060 */
8061 if (func != brCreate ||
8062 (status = dladm_bridge_enable(bridge)) == DLADM_STATUS_OK)
8063 return;
8064 }
8065
8066 /* clean up the partial configuration */
8067 for (i = 0; i < n; i++)
8068 (void) dladm_bridge_setlink(handle, linkids[i], "");
8069
8070 /* if failure for brCreate, then delete the bridge */
8071 if (func == brCreate)
8072 (void) dladm_bridge_delete(handle, bridge, flags);
8073
8074 if (n < nlink)
8075 die_dlerr(status, "unable to add link %s to bridge %s",
8076 links[n], bridge);
8077 else
8078 die_dlerr(status, "unable to enable bridge %s", bridge);
8079 }
8080
8081 static void
do_create_bridge(int argc,char ** argv,const char * use)8082 do_create_bridge(int argc, char **argv, const char *use)
8083 {
8084 create_modify_add_bridge(argc, argv, use, brCreate);
8085 }
8086
8087 static void
do_modify_bridge(int argc,char ** argv,const char * use)8088 do_modify_bridge(int argc, char **argv, const char *use)
8089 {
8090 create_modify_add_bridge(argc, argv, use, brModify);
8091 }
8092
8093 static void
do_add_bridge(int argc,char ** argv,const char * use)8094 do_add_bridge(int argc, char **argv, const char *use)
8095 {
8096 create_modify_add_bridge(argc, argv, use, brAdd);
8097 }
8098
8099 static void
do_delete_bridge(int argc,char ** argv,const char * use)8100 do_delete_bridge(int argc, char **argv, const char *use)
8101 {
8102 int option;
8103 char *altroot = NULL;
8104 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
8105 dladm_status_t status;
8106
8107 opterr = 0;
8108 while ((option = getopt_long(argc, argv, ":R:", bridge_lopts, NULL)) !=
8109 -1) {
8110 switch (option) {
8111 case 'R':
8112 altroot = optarg;
8113 break;
8114 default:
8115 die_opterr(optopt, option, use);
8116 break;
8117 }
8118 }
8119
8120 /* get the bridge name (required last argument) */
8121 if (optind != (argc-1))
8122 usage();
8123
8124 if (altroot != NULL)
8125 altroot_cmd(altroot, argc, argv);
8126
8127 status = dladm_bridge_delete(handle, argv[optind], flags);
8128 if (status != DLADM_STATUS_OK)
8129 die_dlerr(status, "delete operation failed");
8130 }
8131
8132 static void
do_remove_bridge(int argc,char ** argv,const char * use)8133 do_remove_bridge(int argc, char **argv, const char *use)
8134 {
8135 int option;
8136 uint_t n, nlink;
8137 char *links[MAXPORT];
8138 datalink_id_t linkids[MAXPORT];
8139 char *altroot = NULL;
8140 dladm_status_t status;
8141 boolean_t removed_one;
8142
8143 nlink = opterr = 0;
8144 while ((option = getopt_long(argc, argv, ":R:l:", bridge_lopts,
8145 NULL)) != -1) {
8146 switch (option) {
8147 case 'R':
8148 altroot = optarg;
8149 break;
8150 case 'l':
8151 if (nlink >= MAXPORT)
8152 die("too many links specified");
8153 links[nlink++] = optarg;
8154 break;
8155 default:
8156 die_opterr(optopt, option, use);
8157 break;
8158 }
8159 }
8160
8161 if (nlink == 0)
8162 usage();
8163
8164 /* get the bridge name (required last argument) */
8165 if (optind != (argc-1))
8166 usage();
8167
8168 if (altroot != NULL)
8169 altroot_cmd(altroot, argc, argv);
8170
8171 for (n = 0; n < nlink; n++) {
8172 char bridge[MAXLINKNAMELEN];
8173
8174 if (dladm_name2info(handle, links[n], &linkids[n], NULL, NULL,
8175 NULL) != DLADM_STATUS_OK)
8176 die("invalid link name '%s'", links[n]);
8177 status = dladm_bridge_getlink(handle, linkids[n], bridge,
8178 sizeof (bridge));
8179 if (status != DLADM_STATUS_OK &&
8180 status != DLADM_STATUS_NOTFOUND) {
8181 die_dlerr(status, "cannot get bridge status on %s",
8182 links[n]);
8183 }
8184 if (status == DLADM_STATUS_NOTFOUND ||
8185 strcmp(bridge, argv[optind]) != 0)
8186 die("link %s is not on bridge %s", links[n],
8187 argv[optind]);
8188 }
8189
8190 removed_one = B_FALSE;
8191 for (n = 0; n < nlink; n++) {
8192 status = dladm_bridge_setlink(handle, linkids[n], "");
8193 if (status == DLADM_STATUS_OK) {
8194 removed_one = B_TRUE;
8195 } else {
8196 warn_dlerr(status,
8197 "cannot remove link %s from bridge %s",
8198 links[n], argv[optind]);
8199 }
8200 }
8201 if (!removed_one)
8202 die("unable to remove any links from bridge %s", argv[optind]);
8203 }
8204
8205 static void
fmt_int(char * buf,size_t buflen,int value,int runvalue,boolean_t printstar)8206 fmt_int(char *buf, size_t buflen, int value, int runvalue,
8207 boolean_t printstar)
8208 {
8209 (void) snprintf(buf, buflen, "%d", value);
8210 if (value != runvalue && printstar)
8211 (void) strlcat(buf, "*", buflen);
8212 }
8213
8214 static void
fmt_bridge_id(char * buf,size_t buflen,UID_BRIDGE_ID_T * bid)8215 fmt_bridge_id(char *buf, size_t buflen, UID_BRIDGE_ID_T *bid)
8216 {
8217 (void) snprintf(buf, buflen, "%u/%x:%x:%x:%x:%x:%x", bid->prio,
8218 bid->addr[0], bid->addr[1], bid->addr[2], bid->addr[3],
8219 bid->addr[4], bid->addr[5]);
8220 }
8221
8222 static dladm_status_t
print_bridge(show_state_t * state,datalink_id_t linkid,bridge_fields_buf_t * bbuf)8223 print_bridge(show_state_t *state, datalink_id_t linkid,
8224 bridge_fields_buf_t *bbuf)
8225 {
8226 char link[MAXLINKNAMELEN];
8227 datalink_class_t class;
8228 uint32_t flags;
8229 dladm_status_t status;
8230 UID_STP_CFG_T smfcfg, runcfg;
8231 UID_STP_STATE_T stpstate;
8232 dladm_bridge_prot_t smfprot, runprot;
8233
8234 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
8235 NULL, link, sizeof (link))) != DLADM_STATUS_OK)
8236 return (status);
8237
8238 if (!(state->ls_flags & flags))
8239 return (DLADM_STATUS_NOTFOUND);
8240
8241 /* Convert observability node name back to bridge name */
8242 if (!dladm_observe_to_bridge(link))
8243 return (DLADM_STATUS_NOTFOUND);
8244 (void) strlcpy(bbuf->bridge_name, link, sizeof (bbuf->bridge_name));
8245
8246 /*
8247 * If the running value differs from the one in SMF, and parsable
8248 * output is not requested, then we show the running value with an
8249 * asterisk.
8250 */
8251 (void) dladm_bridge_get_properties(bbuf->bridge_name, &smfcfg,
8252 &smfprot);
8253 (void) dladm_bridge_run_properties(bbuf->bridge_name, &runcfg,
8254 &runprot);
8255 (void) snprintf(bbuf->bridge_protect, sizeof (bbuf->bridge_protect),
8256 "%s%s", state->ls_parsable || smfprot == runprot ? "" : "*",
8257 dladm_bridge_prot2str(runprot));
8258 fmt_int(bbuf->bridge_priority, sizeof (bbuf->bridge_priority),
8259 smfcfg.bridge_priority, runcfg.bridge_priority,
8260 !state->ls_parsable && (runcfg.field_mask & BR_CFG_AGE));
8261 fmt_int(bbuf->bridge_bmaxage, sizeof (bbuf->bridge_bmaxage),
8262 smfcfg.max_age, runcfg.max_age,
8263 !state->ls_parsable && (runcfg.field_mask & BR_CFG_AGE));
8264 fmt_int(bbuf->bridge_bhellotime,
8265 sizeof (bbuf->bridge_bhellotime), smfcfg.hello_time,
8266 runcfg.hello_time,
8267 !state->ls_parsable && (runcfg.field_mask & BR_CFG_HELLO));
8268 fmt_int(bbuf->bridge_bfwddelay, sizeof (bbuf->bridge_bfwddelay),
8269 smfcfg.forward_delay, runcfg.forward_delay,
8270 !state->ls_parsable && (runcfg.field_mask & BR_CFG_DELAY));
8271 fmt_int(bbuf->bridge_forceproto, sizeof (bbuf->bridge_forceproto),
8272 smfcfg.force_version, runcfg.force_version,
8273 !state->ls_parsable && (runcfg.field_mask & BR_CFG_FORCE_VER));
8274 fmt_int(bbuf->bridge_holdtime, sizeof (bbuf->bridge_holdtime),
8275 smfcfg.hold_time, runcfg.hold_time,
8276 !state->ls_parsable && (runcfg.field_mask & BR_CFG_HOLD_TIME));
8277
8278 if (dladm_bridge_state(bbuf->bridge_name, &stpstate) ==
8279 DLADM_STATUS_OK) {
8280 fmt_bridge_id(bbuf->bridge_address,
8281 sizeof (bbuf->bridge_address), &stpstate.bridge_id);
8282 (void) snprintf(bbuf->bridge_tctime,
8283 sizeof (bbuf->bridge_tctime), "%lu",
8284 stpstate.timeSince_Topo_Change);
8285 (void) snprintf(bbuf->bridge_tccount,
8286 sizeof (bbuf->bridge_tccount), "%lu",
8287 stpstate.Topo_Change_Count);
8288 (void) snprintf(bbuf->bridge_tchange,
8289 sizeof (bbuf->bridge_tchange), "%u", stpstate.Topo_Change);
8290 fmt_bridge_id(bbuf->bridge_desroot,
8291 sizeof (bbuf->bridge_desroot), &stpstate.designated_root);
8292 (void) snprintf(bbuf->bridge_rootcost,
8293 sizeof (bbuf->bridge_rootcost), "%lu",
8294 stpstate.root_path_cost);
8295 (void) snprintf(bbuf->bridge_rootport,
8296 sizeof (bbuf->bridge_rootport), "%u", stpstate.root_port);
8297 (void) snprintf(bbuf->bridge_maxage,
8298 sizeof (bbuf->bridge_maxage), "%d", stpstate.max_age);
8299 (void) snprintf(bbuf->bridge_hellotime,
8300 sizeof (bbuf->bridge_hellotime), "%d", stpstate.hello_time);
8301 (void) snprintf(bbuf->bridge_fwddelay,
8302 sizeof (bbuf->bridge_fwddelay), "%d",
8303 stpstate.forward_delay);
8304 }
8305 return (DLADM_STATUS_OK);
8306 }
8307
8308 static dladm_status_t
print_bridge_stats(show_state_t * state,datalink_id_t linkid,bridge_statfields_buf_t * bbuf)8309 print_bridge_stats(show_state_t *state, datalink_id_t linkid,
8310 bridge_statfields_buf_t *bbuf)
8311 {
8312 char link[MAXLINKNAMELEN];
8313 datalink_class_t class;
8314 uint32_t flags;
8315 dladm_status_t status;
8316 kstat_ctl_t *kcp;
8317 kstat_t *ksp;
8318 brsum_t *brsum = (brsum_t *)&state->ls_prevstats;
8319 brsum_t newval;
8320
8321 #ifndef lint
8322 /* This is a compile-time assertion; optimizer normally fixes this */
8323 extern void brsum_t_is_too_large(void);
8324
8325 if (sizeof (*brsum) > sizeof (state->ls_prevstats))
8326 brsum_t_is_too_large();
8327 #endif
8328
8329 if (state->ls_firstonly) {
8330 if (state->ls_donefirst)
8331 return (DLADM_WALK_CONTINUE);
8332 state->ls_donefirst = B_TRUE;
8333 } else {
8334 bzero(brsum, sizeof (*brsum));
8335 }
8336 bzero(&newval, sizeof (newval));
8337
8338 if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,
8339 NULL, link, sizeof (link))) != DLADM_STATUS_OK)
8340 return (status);
8341
8342 if (!(state->ls_flags & flags))
8343 return (DLADM_STATUS_NOTFOUND);
8344
8345 if ((kcp = kstat_open()) == NULL) {
8346 warn("kstat open operation failed");
8347 return (DLADM_STATUS_OK);
8348 }
8349 if ((ksp = kstat_lookup(kcp, "bridge", 0, link)) != NULL &&
8350 kstat_read(kcp, ksp, NULL) != -1) {
8351 if (dladm_kstat_value(ksp, "drops", KSTAT_DATA_UINT64,
8352 &newval.drops) == DLADM_STATUS_OK) {
8353 (void) snprintf(bbuf->bridges_drops,
8354 sizeof (bbuf->bridges_drops), "%llu",
8355 newval.drops - brsum->drops);
8356 }
8357 if (dladm_kstat_value(ksp, "forward_direct", KSTAT_DATA_UINT64,
8358 &newval.forward_dir) == DLADM_STATUS_OK) {
8359 (void) snprintf(bbuf->bridges_forwards,
8360 sizeof (bbuf->bridges_forwards), "%llu",
8361 newval.forward_dir - brsum->forward_dir);
8362 }
8363 if (dladm_kstat_value(ksp, "forward_mbcast", KSTAT_DATA_UINT64,
8364 &newval.forward_mb) == DLADM_STATUS_OK) {
8365 (void) snprintf(bbuf->bridges_mbcast,
8366 sizeof (bbuf->bridges_mbcast), "%llu",
8367 newval.forward_mb - brsum->forward_mb);
8368 }
8369 if (dladm_kstat_value(ksp, "forward_unknown", KSTAT_DATA_UINT64,
8370 &newval.forward_unk) == DLADM_STATUS_OK) {
8371 (void) snprintf(bbuf->bridges_unknown,
8372 sizeof (bbuf->bridges_unknown), "%llu",
8373 newval.forward_unk - brsum->forward_unk);
8374 }
8375 if (dladm_kstat_value(ksp, "recv", KSTAT_DATA_UINT64,
8376 &newval.recv) == DLADM_STATUS_OK) {
8377 (void) snprintf(bbuf->bridges_recv,
8378 sizeof (bbuf->bridges_recv), "%llu",
8379 newval.recv - brsum->recv);
8380 }
8381 if (dladm_kstat_value(ksp, "sent", KSTAT_DATA_UINT64,
8382 &newval.sent) == DLADM_STATUS_OK) {
8383 (void) snprintf(bbuf->bridges_sent,
8384 sizeof (bbuf->bridges_sent), "%llu",
8385 newval.sent - brsum->sent);
8386 }
8387 }
8388 (void) kstat_close(kcp);
8389
8390 /* Convert observability node name back to bridge name */
8391 if (!dladm_observe_to_bridge(link))
8392 return (DLADM_STATUS_NOTFOUND);
8393 (void) strlcpy(bbuf->bridges_name, link, sizeof (bbuf->bridges_name));
8394
8395 *brsum = newval;
8396
8397 return (DLADM_STATUS_OK);
8398 }
8399
8400 /*
8401 * This structure carries around extra state information for the show-bridge
8402 * command and allows us to use common support functions.
8403 */
8404 typedef struct {
8405 show_state_t state;
8406 boolean_t show_stats;
8407 const char *bridge;
8408 } show_brstate_t;
8409
8410 /* ARGSUSED */
8411 static int
show_bridge(dladm_handle_t handle,datalink_id_t linkid,void * arg)8412 show_bridge(dladm_handle_t handle, datalink_id_t linkid, void *arg)
8413 {
8414 show_brstate_t *brstate = arg;
8415 void *buf;
8416
8417 if (brstate->show_stats) {
8418 bridge_statfields_buf_t bbuf;
8419
8420 bzero(&bbuf, sizeof (bbuf));
8421 brstate->state.ls_status = print_bridge_stats(&brstate->state,
8422 linkid, &bbuf);
8423 buf = &bbuf;
8424 } else {
8425 bridge_fields_buf_t bbuf;
8426
8427 bzero(&bbuf, sizeof (bbuf));
8428 brstate->state.ls_status = print_bridge(&brstate->state, linkid,
8429 &bbuf);
8430 buf = &bbuf;
8431 }
8432 if (brstate->state.ls_status == DLADM_STATUS_OK)
8433 ofmt_print(brstate->state.ls_ofmt, buf);
8434 return (DLADM_WALK_CONTINUE);
8435 }
8436
8437 static void
fmt_bool(char * buf,size_t buflen,int val)8438 fmt_bool(char *buf, size_t buflen, int val)
8439 {
8440 (void) strlcpy(buf, val ? "yes" : "no", buflen);
8441 }
8442
8443 static dladm_status_t
print_bridge_link(show_state_t * state,datalink_id_t linkid,bridge_link_fields_buf_t * bbuf)8444 print_bridge_link(show_state_t *state, datalink_id_t linkid,
8445 bridge_link_fields_buf_t *bbuf)
8446 {
8447 datalink_class_t class;
8448 uint32_t flags;
8449 dladm_status_t status;
8450 UID_STP_PORT_STATE_T stpstate;
8451
8452 status = dladm_datalink_id2info(handle, linkid, &flags, &class, NULL,
8453 bbuf->bridgel_link, sizeof (bbuf->bridgel_link));
8454 if (status != DLADM_STATUS_OK)
8455 return (status);
8456
8457 if (!(state->ls_flags & flags))
8458 return (DLADM_STATUS_NOTFOUND);
8459
8460 if (dladm_bridge_link_state(handle, linkid, &stpstate) ==
8461 DLADM_STATUS_OK) {
8462 (void) snprintf(bbuf->bridgel_index,
8463 sizeof (bbuf->bridgel_index), "%u", stpstate.port_no);
8464 if (dlsym(RTLD_PROBE, "STP_IN_state2str")) {
8465 (void) strlcpy(bbuf->bridgel_state,
8466 STP_IN_state2str(stpstate.state),
8467 sizeof (bbuf->bridgel_state));
8468 } else {
8469 (void) snprintf(bbuf->bridgel_state,
8470 sizeof (bbuf->bridgel_state), "%u",
8471 stpstate.state);
8472 }
8473 (void) snprintf(bbuf->bridgel_uptime,
8474 sizeof (bbuf->bridgel_uptime), "%lu", stpstate.uptime);
8475 (void) snprintf(bbuf->bridgel_opercost,
8476 sizeof (bbuf->bridgel_opercost), "%lu",
8477 stpstate.oper_port_path_cost);
8478 fmt_bool(bbuf->bridgel_operp2p, sizeof (bbuf->bridgel_operp2p),
8479 stpstate.oper_point2point);
8480 fmt_bool(bbuf->bridgel_operedge,
8481 sizeof (bbuf->bridgel_operedge), stpstate.oper_edge);
8482 fmt_bridge_id(bbuf->bridgel_desroot,
8483 sizeof (bbuf->bridgel_desroot), &stpstate.designated_root);
8484 (void) snprintf(bbuf->bridgel_descost,
8485 sizeof (bbuf->bridgel_descost), "%lu",
8486 stpstate.designated_cost);
8487 fmt_bridge_id(bbuf->bridgel_desbridge,
8488 sizeof (bbuf->bridgel_desbridge),
8489 &stpstate.designated_bridge);
8490 (void) snprintf(bbuf->bridgel_desport,
8491 sizeof (bbuf->bridgel_desport), "%u",
8492 stpstate.designated_port);
8493 fmt_bool(bbuf->bridgel_tcack, sizeof (bbuf->bridgel_tcack),
8494 stpstate.top_change_ack);
8495 }
8496 return (DLADM_STATUS_OK);
8497 }
8498
8499 static dladm_status_t
print_bridge_link_stats(show_state_t * state,datalink_id_t linkid,bridge_link_statfields_buf_t * bbuf)8500 print_bridge_link_stats(show_state_t *state, datalink_id_t linkid,
8501 bridge_link_statfields_buf_t *bbuf)
8502 {
8503 datalink_class_t class;
8504 uint32_t flags;
8505 dladm_status_t status;
8506 UID_STP_PORT_STATE_T stpstate;
8507 kstat_ctl_t *kcp;
8508 kstat_t *ksp;
8509 char bridge[MAXLINKNAMELEN];
8510 char kstatname[MAXLINKNAMELEN*2 + 1];
8511 brlsum_t *brlsum = (brlsum_t *)&state->ls_prevstats;
8512 brlsum_t newval;
8513
8514 #ifndef lint
8515 /* This is a compile-time assertion; optimizer normally fixes this */
8516 extern void brlsum_t_is_too_large(void);
8517
8518 if (sizeof (*brlsum) > sizeof (state->ls_prevstats))
8519 brlsum_t_is_too_large();
8520 #endif
8521
8522 if (state->ls_firstonly) {
8523 if (state->ls_donefirst)
8524 return (DLADM_WALK_CONTINUE);
8525 state->ls_donefirst = B_TRUE;
8526 } else {
8527 bzero(brlsum, sizeof (*brlsum));
8528 }
8529 bzero(&newval, sizeof (newval));
8530
8531 status = dladm_datalink_id2info(handle, linkid, &flags, &class, NULL,
8532 bbuf->bridgels_link, sizeof (bbuf->bridgels_link));
8533 if (status != DLADM_STATUS_OK)
8534 return (status);
8535
8536 if (!(state->ls_flags & flags))
8537 return (DLADM_STATUS_NOTFOUND);
8538
8539 if (dladm_bridge_link_state(handle, linkid, &stpstate) ==
8540 DLADM_STATUS_OK) {
8541 newval.cfgbpdu = stpstate.rx_cfg_bpdu_cnt;
8542 newval.tcnbpdu = stpstate.rx_tcn_bpdu_cnt;
8543 newval.rstpbpdu = stpstate.rx_rstp_bpdu_cnt;
8544 newval.txbpdu = stpstate.txCount;
8545
8546 (void) snprintf(bbuf->bridgels_cfgbpdu,
8547 sizeof (bbuf->bridgels_cfgbpdu), "%lu",
8548 newval.cfgbpdu - brlsum->cfgbpdu);
8549 (void) snprintf(bbuf->bridgels_tcnbpdu,
8550 sizeof (bbuf->bridgels_tcnbpdu), "%lu",
8551 newval.tcnbpdu - brlsum->tcnbpdu);
8552 (void) snprintf(bbuf->bridgels_rstpbpdu,
8553 sizeof (bbuf->bridgels_rstpbpdu), "%lu",
8554 newval.rstpbpdu - brlsum->rstpbpdu);
8555 (void) snprintf(bbuf->bridgels_txbpdu,
8556 sizeof (bbuf->bridgels_txbpdu), "%lu",
8557 newval.txbpdu - brlsum->txbpdu);
8558 }
8559
8560 if ((status = dladm_bridge_getlink(handle, linkid, bridge,
8561 sizeof (bridge))) != DLADM_STATUS_OK)
8562 goto bls_out;
8563 (void) snprintf(kstatname, sizeof (kstatname), "%s0-%s", bridge,
8564 bbuf->bridgels_link);
8565 if ((kcp = kstat_open()) == NULL) {
8566 warn("kstat open operation failed");
8567 goto bls_out;
8568 }
8569 if ((ksp = kstat_lookup(kcp, "bridge", 0, kstatname)) != NULL &&
8570 kstat_read(kcp, ksp, NULL) != -1) {
8571 if (dladm_kstat_value(ksp, "drops", KSTAT_DATA_UINT64,
8572 &newval.drops) != -1) {
8573 (void) snprintf(bbuf->bridgels_drops,
8574 sizeof (bbuf->bridgels_drops), "%llu",
8575 newval.drops - brlsum->drops);
8576 }
8577 if (dladm_kstat_value(ksp, "recv", KSTAT_DATA_UINT64,
8578 &newval.recv) != -1) {
8579 (void) snprintf(bbuf->bridgels_recv,
8580 sizeof (bbuf->bridgels_recv), "%llu",
8581 newval.recv - brlsum->recv);
8582 }
8583 if (dladm_kstat_value(ksp, "xmit", KSTAT_DATA_UINT64,
8584 &newval.xmit) != -1) {
8585 (void) snprintf(bbuf->bridgels_xmit,
8586 sizeof (bbuf->bridgels_xmit), "%llu",
8587 newval.xmit - brlsum->xmit);
8588 }
8589 }
8590 (void) kstat_close(kcp);
8591 bls_out:
8592 *brlsum = newval;
8593
8594 return (status);
8595 }
8596
8597 static void
show_bridge_link(datalink_id_t linkid,show_brstate_t * brstate)8598 show_bridge_link(datalink_id_t linkid, show_brstate_t *brstate)
8599 {
8600 void *buf;
8601
8602 if (brstate->show_stats) {
8603 bridge_link_statfields_buf_t bbuf;
8604
8605 bzero(&bbuf, sizeof (bbuf));
8606 brstate->state.ls_status = print_bridge_link_stats(
8607 &brstate->state, linkid, &bbuf);
8608 buf = &bbuf;
8609 } else {
8610 bridge_link_fields_buf_t bbuf;
8611
8612 bzero(&bbuf, sizeof (bbuf));
8613 brstate->state.ls_status = print_bridge_link(&brstate->state,
8614 linkid, &bbuf);
8615 buf = &bbuf;
8616 }
8617 if (brstate->state.ls_status == DLADM_STATUS_OK)
8618 ofmt_print(brstate->state.ls_ofmt, buf);
8619 }
8620
8621 /* ARGSUSED */
8622 static int
show_bridge_link_walk(dladm_handle_t handle,datalink_id_t linkid,void * arg)8623 show_bridge_link_walk(dladm_handle_t handle, datalink_id_t linkid, void *arg)
8624 {
8625 show_brstate_t *brstate = arg;
8626 char bridge[MAXLINKNAMELEN];
8627
8628 if (dladm_bridge_getlink(handle, linkid, bridge, sizeof (bridge)) ==
8629 DLADM_STATUS_OK && strcmp(bridge, brstate->bridge) == 0) {
8630 show_bridge_link(linkid, brstate);
8631 }
8632 return (DLADM_WALK_CONTINUE);
8633 }
8634
8635 static void
show_bridge_fwd(dladm_handle_t handle,bridge_listfwd_t * blf,show_state_t * state)8636 show_bridge_fwd(dladm_handle_t handle, bridge_listfwd_t *blf,
8637 show_state_t *state)
8638 {
8639 bridge_fwd_fields_buf_t bbuf;
8640
8641 bzero(&bbuf, sizeof (bbuf));
8642 (void) snprintf(bbuf.bridgef_dest, sizeof (bbuf.bridgef_dest),
8643 "%s", ether_ntoa((struct ether_addr *)blf->blf_dest));
8644 if (blf->blf_is_local) {
8645 (void) strlcpy(bbuf.bridgef_flags, "L",
8646 sizeof (bbuf.bridgef_flags));
8647 } else {
8648 (void) snprintf(bbuf.bridgef_age, sizeof (bbuf.bridgef_age),
8649 "%2d.%03d", blf->blf_ms_age / 1000, blf->blf_ms_age % 1000);
8650 if (blf->blf_trill_nick != 0) {
8651 (void) snprintf(bbuf.bridgef_output,
8652 sizeof (bbuf.bridgef_output), "%u",
8653 blf->blf_trill_nick);
8654 }
8655 }
8656 if (blf->blf_linkid != DATALINK_INVALID_LINKID &&
8657 blf->blf_trill_nick == 0) {
8658 state->ls_status = dladm_datalink_id2info(handle,
8659 blf->blf_linkid, NULL, NULL, NULL, bbuf.bridgef_output,
8660 sizeof (bbuf.bridgef_output));
8661 }
8662 if (state->ls_status == DLADM_STATUS_OK)
8663 ofmt_print(state->ls_ofmt, &bbuf);
8664 }
8665
8666 static void
show_bridge_trillnick(trill_listnick_t * tln,show_state_t * state)8667 show_bridge_trillnick(trill_listnick_t *tln, show_state_t *state)
8668 {
8669 bridge_trill_fields_buf_t bbuf;
8670
8671 bzero(&bbuf, sizeof (bbuf));
8672 (void) snprintf(bbuf.bridget_nick, sizeof (bbuf.bridget_nick),
8673 "%u", tln->tln_nick);
8674 if (tln->tln_ours) {
8675 (void) strlcpy(bbuf.bridget_flags, "L",
8676 sizeof (bbuf.bridget_flags));
8677 } else {
8678 state->ls_status = dladm_datalink_id2info(handle,
8679 tln->tln_linkid, NULL, NULL, NULL, bbuf.bridget_link,
8680 sizeof (bbuf.bridget_link));
8681 (void) snprintf(bbuf.bridget_nexthop,
8682 sizeof (bbuf.bridget_nexthop), "%s",
8683 ether_ntoa((struct ether_addr *)tln->tln_nexthop));
8684 }
8685 if (state->ls_status == DLADM_STATUS_OK)
8686 ofmt_print(state->ls_ofmt, &bbuf);
8687 }
8688
8689 static void
do_show_bridge(int argc,char ** argv,const char * use)8690 do_show_bridge(int argc, char **argv, const char *use)
8691 {
8692 int option;
8693 enum {
8694 bridgeMode, linkMode, fwdMode, trillMode
8695 } op_mode = bridgeMode;
8696 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
8697 boolean_t parsable = B_FALSE;
8698 datalink_id_t linkid = DATALINK_ALL_LINKID;
8699 int interval = 0;
8700 show_brstate_t brstate;
8701 dladm_status_t status;
8702 char *fields_str = NULL;
8703 /* default: bridge-related data */
8704 char *all_fields = "bridge,protect,address,priority,bmaxage,"
8705 "bhellotime,bfwddelay,forceproto,tctime,tccount,tchange,"
8706 "desroot,rootcost,rootport,maxage,hellotime,fwddelay,holdtime";
8707 char *default_fields = "bridge,protect,address,priority,"
8708 "desroot";
8709 char *all_statfields = "bridge,drops,forwards,mbcast,"
8710 "unknown,recv,sent";
8711 char *default_statfields = "bridge,drops,forwards,mbcast,"
8712 "unknown";
8713 /* -l: link-related data */
8714 char *all_link_fields = "link,index,state,uptime,opercost,"
8715 "operp2p,operedge,desroot,descost,desbridge,desport,tcack";
8716 char *default_link_fields = "link,state,uptime,desroot";
8717 char *all_link_statfields = "link,cfgbpdu,tcnbpdu,rstpbpdu,"
8718 "txbpdu,drops,recv,xmit";
8719 char *default_link_statfields = "link,drops,recv,xmit";
8720 /* -f: bridge forwarding table related data */
8721 char *default_fwd_fields = "dest,age,flags,output";
8722 /* -t: TRILL nickname table related data */
8723 char *default_trill_fields = "nick,flags,link,nexthop";
8724 char *default_str;
8725 char *all_str = NULL;
8726 ofmt_field_t *field_arr = NULL;
8727 ofmt_handle_t ofmt;
8728 ofmt_status_t oferr;
8729 uint_t ofmtflags = 0;
8730
8731 bzero(&brstate, sizeof (brstate));
8732
8733 opterr = 0;
8734 while ((option = getopt_long(argc, argv, ":fi:lo:pst",
8735 bridge_show_lopts, NULL)) != -1) {
8736 switch (option) {
8737 case 'f':
8738 if (op_mode != bridgeMode && op_mode != fwdMode)
8739 die("-f is incompatible with -l or -t");
8740 op_mode = fwdMode;
8741 break;
8742 case 'i':
8743 if (interval != 0)
8744 die_optdup(option);
8745 if (!str2int(optarg, &interval) || interval == 0)
8746 die("invalid interval value '%s'", optarg);
8747 break;
8748 case 'l':
8749 if (op_mode != bridgeMode && op_mode != linkMode)
8750 die("-l is incompatible with -f or -t");
8751 op_mode = linkMode;
8752 break;
8753 case 'o':
8754 fields_str = optarg;
8755 break;
8756 case 'p':
8757 if (parsable)
8758 die_optdup(option);
8759 parsable = B_TRUE;
8760 break;
8761 case 's':
8762 if (brstate.show_stats)
8763 die_optdup(option);
8764 brstate.show_stats = B_TRUE;
8765 break;
8766 case 't':
8767 if (op_mode != bridgeMode && op_mode != trillMode)
8768 die("-t is incompatible with -f or -l");
8769 op_mode = trillMode;
8770 break;
8771 default:
8772 die_opterr(optopt, option, use);
8773 break;
8774 }
8775 }
8776
8777 if (interval != 0 && !brstate.show_stats)
8778 die("the -i option can be used only with -s");
8779
8780 if ((op_mode == fwdMode || op_mode == trillMode) && brstate.show_stats)
8781 die("the -f/-t and -s options cannot be used together");
8782
8783 /* get the bridge name (optional last argument) */
8784 if (optind == (argc-1)) {
8785 char lname[MAXLINKNAMELEN];
8786 uint32_t lnkflg;
8787 datalink_class_t class;
8788
8789 brstate.bridge = argv[optind];
8790 (void) snprintf(lname, sizeof (lname), "%s0", brstate.bridge);
8791 if ((status = dladm_name2info(handle, lname, &linkid, &lnkflg,
8792 &class, NULL)) != DLADM_STATUS_OK) {
8793 die_dlerr(status, "bridge %s is not valid",
8794 brstate.bridge);
8795 }
8796
8797 if (class != DATALINK_CLASS_BRIDGE)
8798 die("%s is not a bridge", brstate.bridge);
8799
8800 if (!(lnkflg & flags)) {
8801 die_dlerr(DLADM_STATUS_BADARG,
8802 "bridge %s is temporarily removed", brstate.bridge);
8803 }
8804 } else if (optind != argc) {
8805 usage();
8806 } else if (op_mode != bridgeMode) {
8807 die("bridge name required for -l, -f, or -t");
8808 return;
8809 }
8810
8811 brstate.state.ls_parsable = parsable;
8812 brstate.state.ls_flags = flags;
8813 brstate.state.ls_firstonly = (interval != 0);
8814
8815 switch (op_mode) {
8816 case bridgeMode:
8817 if (brstate.show_stats) {
8818 default_str = default_statfields;
8819 all_str = all_statfields;
8820 field_arr = bridge_statfields;
8821 } else {
8822 default_str = default_fields;
8823 all_str = all_fields;
8824 field_arr = bridge_fields;
8825 }
8826 break;
8827
8828 case linkMode:
8829 if (brstate.show_stats) {
8830 default_str = default_link_statfields;
8831 all_str = all_link_statfields;
8832 field_arr = bridge_link_statfields;
8833 } else {
8834 default_str = default_link_fields;
8835 all_str = all_link_fields;
8836 field_arr = bridge_link_fields;
8837 }
8838 break;
8839
8840 case fwdMode:
8841 default_str = all_str = default_fwd_fields;
8842 field_arr = bridge_fwd_fields;
8843 break;
8844
8845 case trillMode:
8846 default_str = all_str = default_trill_fields;
8847 field_arr = bridge_trill_fields;
8848 break;
8849
8850 default:
8851 die("unknown operations mode: %d", op_mode);
8852 }
8853
8854 if (fields_str == NULL)
8855 fields_str = default_str;
8856 else if (strcasecmp(fields_str, "all") == 0)
8857 fields_str = all_str;
8858
8859 if (parsable)
8860 ofmtflags |= OFMT_PARSABLE;
8861 oferr = ofmt_open(fields_str, field_arr, ofmtflags, 0, &ofmt);
8862 ofmt_check(oferr, brstate.state.ls_parsable, ofmt, die, warn);
8863 brstate.state.ls_ofmt = ofmt;
8864
8865 for (;;) {
8866 brstate.state.ls_donefirst = B_FALSE;
8867 switch (op_mode) {
8868 case bridgeMode:
8869 if (linkid == DATALINK_ALL_LINKID) {
8870 (void) dladm_walk_datalink_id(show_bridge,
8871 handle, &brstate, DATALINK_CLASS_BRIDGE,
8872 DATALINK_ANY_MEDIATYPE, flags);
8873 } else {
8874 (void) show_bridge(handle, linkid, &brstate);
8875 if (brstate.state.ls_status !=
8876 DLADM_STATUS_OK) {
8877 die_dlerr(brstate.state.ls_status,
8878 "failed to show bridge %s",
8879 brstate.bridge);
8880 }
8881 }
8882 break;
8883
8884 case linkMode: {
8885 datalink_id_t *dlp;
8886 uint_t i, nlinks;
8887
8888 dlp = dladm_bridge_get_portlist(brstate.bridge,
8889 &nlinks);
8890 if (dlp != NULL) {
8891 for (i = 0; i < nlinks; i++)
8892 show_bridge_link(dlp[i], &brstate);
8893 dladm_bridge_free_portlist(dlp);
8894 } else if (errno == ENOENT) {
8895 /* bridge not running; iterate on libdladm */
8896 (void) dladm_walk_datalink_id(
8897 show_bridge_link_walk, handle,
8898 &brstate, DATALINK_CLASS_PHYS |
8899 DATALINK_CLASS_AGGR |
8900 DATALINK_CLASS_ETHERSTUB,
8901 DATALINK_ANY_MEDIATYPE, flags);
8902 } else {
8903 die("unable to get port list for bridge %s: %s",
8904 brstate.bridge, strerror(errno));
8905 }
8906 break;
8907 }
8908
8909 case fwdMode: {
8910 bridge_listfwd_t *blf;
8911 uint_t i, nfwd;
8912
8913 blf = dladm_bridge_get_fwdtable(handle, brstate.bridge,
8914 &nfwd);
8915 if (blf == NULL) {
8916 die("unable to get forwarding entries for "
8917 "bridge %s", brstate.bridge);
8918 } else {
8919 for (i = 0; i < nfwd; i++)
8920 show_bridge_fwd(handle, blf + i,
8921 &brstate.state);
8922 dladm_bridge_free_fwdtable(blf);
8923 }
8924 break;
8925 }
8926
8927 case trillMode: {
8928 trill_listnick_t *tln;
8929 uint_t i, nnick;
8930
8931 tln = dladm_bridge_get_trillnick(brstate.bridge,
8932 &nnick);
8933 if (tln == NULL) {
8934 if (errno == ENOENT)
8935 die("bridge %s is not running TRILL",
8936 brstate.bridge);
8937 else
8938 die("unable to get TRILL nickname "
8939 "entries for bridge %s",
8940 brstate.bridge);
8941 } else {
8942 for (i = 0; i < nnick; i++)
8943 show_bridge_trillnick(tln + i,
8944 &brstate.state);
8945 dladm_bridge_free_trillnick(tln);
8946 }
8947 break;
8948 }
8949 }
8950 if (interval == 0)
8951 break;
8952 (void) sleep(interval);
8953 }
8954 }
8955
8956 /*
8957 * "-R" option support. It is used for live upgrading. Append dladm commands
8958 * to a upgrade script which will be run when the alternative root boots up:
8959 *
8960 * - If the /etc/dladm/datalink.conf file exists on the alternative root,
8961 * append dladm commands to the <altroot>/var/svc/profile/upgrade_datalink
8962 * script. This script will be run as part of the network/physical service.
8963 * We cannot defer this to /var/svc/profile/upgrade because then the
8964 * configuration will not be able to take effect before network/physical
8965 * plumbs various interfaces.
8966 *
8967 * - If the /etc/dladm/datalink.conf file does not exist on the alternative
8968 * root, append dladm commands to the <altroot>/var/svc/profile/upgrade script,
8969 * which will be run in the manifest-import service.
8970 *
8971 * Note that the SMF team is considering to move the manifest-import service
8972 * to be run at the very begining of boot. Once that is done, the need for
8973 * the /var/svc/profile/upgrade_datalink script will not exist any more.
8974 */
8975 static void
altroot_cmd(char * altroot,int argc,char * argv[])8976 altroot_cmd(char *altroot, int argc, char *argv[])
8977 {
8978 char path[MAXPATHLEN];
8979 struct stat stbuf;
8980 FILE *fp;
8981 int i;
8982
8983 /*
8984 * Check for the existence of the /etc/dladm/datalink.conf
8985 * configuration file, and determine the name of script file.
8986 */
8987 (void) snprintf(path, MAXPATHLEN, "/%s/etc/dladm/datalink.conf",
8988 altroot);
8989 if (stat(path, &stbuf) < 0) {
8990 (void) snprintf(path, MAXPATHLEN, "/%s/%s", altroot,
8991 SMF_UPGRADE_FILE);
8992 } else {
8993 (void) snprintf(path, MAXPATHLEN, "/%s/%s", altroot,
8994 SMF_UPGRADEDATALINK_FILE);
8995 }
8996
8997 if ((fp = fopen(path, "a+")) == NULL)
8998 die("operation not supported on %s", altroot);
8999
9000 (void) fprintf(fp, "/sbin/dladm ");
9001 for (i = 0; i < argc; i++) {
9002 /*
9003 * Directly write to the file if it is not the "-R <altroot>"
9004 * option. In which case, skip it.
9005 */
9006 if (strcmp(argv[i], "-R") != 0)
9007 (void) fprintf(fp, "%s ", argv[i]);
9008 else
9009 i ++;
9010 }
9011 (void) fprintf(fp, "%s\n", SMF_DLADM_UPGRADE_MSG);
9012 (void) fclose(fp);
9013 dladm_close(handle);
9014 exit(EXIT_SUCCESS);
9015 }
9016
9017 /*
9018 * Convert the string to an integer. Note that the string must not have any
9019 * trailing non-integer characters.
9020 */
9021 static boolean_t
str2int(const char * str,int * valp)9022 str2int(const char *str, int *valp)
9023 {
9024 int val;
9025 char *endp = NULL;
9026
9027 errno = 0;
9028 val = strtol(str, &endp, 10);
9029 if (errno != 0 || *endp != '\0')
9030 return (B_FALSE);
9031
9032 *valp = val;
9033 return (B_TRUE);
9034 }
9035
9036 /* PRINTFLIKE1 */
9037 static void
warn(const char * format,...)9038 warn(const char *format, ...)
9039 {
9040 va_list alist;
9041
9042 format = gettext(format);
9043 (void) fprintf(stderr, "%s: warning: ", progname);
9044
9045 va_start(alist, format);
9046 (void) vfprintf(stderr, format, alist);
9047 va_end(alist);
9048
9049 (void) putc('\n', stderr);
9050 }
9051
9052 /* PRINTFLIKE2 */
9053 static void
warn_dlerr(dladm_status_t err,const char * format,...)9054 warn_dlerr(dladm_status_t err, const char *format, ...)
9055 {
9056 va_list alist;
9057 char errmsg[DLADM_STRSIZE];
9058
9059 format = gettext(format);
9060 (void) fprintf(stderr, gettext("%s: warning: "), progname);
9061
9062 va_start(alist, format);
9063 (void) vfprintf(stderr, format, alist);
9064 va_end(alist);
9065 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
9066 }
9067
9068 static void
warn_dlerrlist(dladm_errlist_t * errlist)9069 warn_dlerrlist(dladm_errlist_t *errlist)
9070 {
9071 if (errlist != NULL && errlist->el_count > 0) {
9072 int i;
9073 for (i = 0; i < errlist->el_count; i++) {
9074 (void) fprintf(stderr, gettext("%s: warning: "),
9075 progname);
9076
9077 (void) fprintf(stderr, "%s\n",
9078 gettext(errlist->el_errs[i]));
9079 }
9080 }
9081 }
9082
9083 /*
9084 * Also closes the dladm handle if it is not NULL.
9085 */
9086 /* PRINTFLIKE2 */
9087 static void
die_dlerr(dladm_status_t err,const char * format,...)9088 die_dlerr(dladm_status_t err, const char *format, ...)
9089 {
9090 va_list alist;
9091 char errmsg[DLADM_STRSIZE];
9092
9093 format = gettext(format);
9094 (void) fprintf(stderr, "%s: ", progname);
9095
9096 va_start(alist, format);
9097 (void) vfprintf(stderr, format, alist);
9098 va_end(alist);
9099 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
9100
9101 /* close dladm handle if it was opened */
9102 if (handle != NULL)
9103 dladm_close(handle);
9104
9105 exit(EXIT_FAILURE);
9106 }
9107
9108 /*
9109 * Like die_dlerr, but uses the errlist for additional information.
9110 */
9111 /* PRINTFLIKE3 */
9112 static void
die_dlerrlist(dladm_status_t err,dladm_errlist_t * errlist,const char * format,...)9113 die_dlerrlist(dladm_status_t err, dladm_errlist_t *errlist,
9114 const char *format, ...)
9115 {
9116 va_list alist;
9117 char errmsg[DLADM_STRSIZE];
9118
9119 warn_dlerrlist(errlist);
9120 format = gettext(format);
9121 (void) fprintf(stderr, "%s: ", progname);
9122
9123 va_start(alist, format);
9124 (void) vfprintf(stderr, format, alist);
9125 va_end(alist);
9126 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
9127
9128 /* close dladm handle if it was opened */
9129 if (handle != NULL)
9130 dladm_close(handle);
9131
9132 exit(EXIT_FAILURE);
9133
9134 }
9135
9136 /* PRINTFLIKE1 */
9137 static void
die(const char * format,...)9138 die(const char *format, ...)
9139 {
9140 va_list alist;
9141
9142 format = gettext(format);
9143 (void) fprintf(stderr, "%s: ", progname);
9144
9145 va_start(alist, format);
9146 (void) vfprintf(stderr, format, alist);
9147 va_end(alist);
9148
9149 (void) putc('\n', stderr);
9150
9151 /* close dladm handle if it was opened */
9152 if (handle != NULL)
9153 dladm_close(handle);
9154
9155 exit(EXIT_FAILURE);
9156 }
9157
9158 static void
die_optdup(int opt)9159 die_optdup(int opt)
9160 {
9161 die("the option -%c cannot be specified more than once", opt);
9162 }
9163
9164 static void
die_opterr(int opt,int opterr,const char * usage)9165 die_opterr(int opt, int opterr, const char *usage)
9166 {
9167 switch (opterr) {
9168 case ':':
9169 die("option '-%c' requires a value\nusage: %s", opt,
9170 gettext(usage));
9171 break;
9172 case '?':
9173 default:
9174 die("unrecognized option '-%c'\nusage: %s", opt,
9175 gettext(usage));
9176 break;
9177 }
9178 }
9179
9180 static void
show_ether_xprop(void * arg,dladm_ether_info_t * eattr)9181 show_ether_xprop(void *arg, dladm_ether_info_t *eattr)
9182 {
9183 print_ether_state_t *statep = arg;
9184 ether_fields_buf_t ebuf;
9185 int i;
9186
9187 for (i = CAPABLE; i <= PEERADV; i++) {
9188 bzero(&ebuf, sizeof (ebuf));
9189 (void) strlcpy(ebuf.eth_ptype, ptype[i],
9190 sizeof (ebuf.eth_ptype));
9191 (void) dladm_ether_autoneg2str(ebuf.eth_autoneg,
9192 sizeof (ebuf.eth_autoneg), eattr, i);
9193 (void) dladm_ether_spdx2str(ebuf.eth_spdx,
9194 sizeof (ebuf.eth_spdx), eattr, i);
9195 (void) dladm_ether_pause2str(ebuf.eth_pause,
9196 sizeof (ebuf.eth_pause), eattr, i);
9197 (void) strlcpy(ebuf.eth_rem_fault,
9198 (eattr->lei_attr[i].le_fault ? "fault" : "none"),
9199 sizeof (ebuf.eth_rem_fault));
9200 ofmt_print(statep->es_ofmt, &ebuf);
9201 }
9202
9203 }
9204
9205 static boolean_t
link_is_ether(const char * link,datalink_id_t * linkid)9206 link_is_ether(const char *link, datalink_id_t *linkid)
9207 {
9208 uint32_t media;
9209 datalink_class_t class;
9210
9211 if (dladm_name2info(handle, link, linkid, NULL, &class, &media) ==
9212 DLADM_STATUS_OK) {
9213 if (class == DATALINK_CLASS_PHYS && media == DL_ETHER)
9214 return (B_TRUE);
9215 }
9216 return (B_FALSE);
9217 }
9218
9219 /*
9220 * default output callback function that, when invoked,
9221 * prints string which is offset by ofmt_arg->ofmt_id within buf.
9222 */
9223 static boolean_t
print_default_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)9224 print_default_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
9225 {
9226 char *value;
9227
9228 value = (char *)ofarg->ofmt_cbarg + ofarg->ofmt_id;
9229 (void) strlcpy(buf, value, bufsize);
9230 return (B_TRUE);
9231 }
9232
9233 /*
9234 * Called from the walker dladm_walk_datalink_id() for each IB partition to
9235 * display IB partition specific information.
9236 */
9237 static dladm_status_t
print_part(show_part_state_t * state,datalink_id_t linkid)9238 print_part(show_part_state_t *state, datalink_id_t linkid)
9239 {
9240 dladm_part_attr_t attr;
9241 dladm_status_t status;
9242 dladm_conf_t conf;
9243 char part_over[MAXLINKNAMELEN];
9244 char part_name[MAXLINKNAMELEN];
9245 part_fields_buf_t pbuf;
9246 boolean_t force_in_conf = B_FALSE;
9247
9248 /*
9249 * Get the information about the IB partition from the partition
9250 * datlink ID 'linkid'.
9251 */
9252 if ((status = dladm_part_info(handle, linkid, &attr, state->ps_flags))
9253 != DLADM_STATUS_OK)
9254 return (status);
9255
9256 /*
9257 * If an IB Phys link name was provided on the command line we have
9258 * the Phys link's datalink ID in the ps_over_id field of the state
9259 * structure. Proceed only if the IB partition represented by 'linkid'
9260 * was created over Phys link denoted by ps_over_id. The
9261 * 'dia_physlinkid' field of dladm_part_attr_t represents the IB Phys
9262 * link over which the partition was created.
9263 */
9264 if (state->ps_over_id != DATALINK_ALL_LINKID)
9265 if (state->ps_over_id != attr.dia_physlinkid)
9266 return (DLADM_STATUS_OK);
9267
9268 /*
9269 * The linkid argument passed to this function is the datalink ID
9270 * of the IB Partition. Get the partitions name from this linkid.
9271 */
9272 if (dladm_datalink_id2info(handle, linkid, NULL, NULL,
9273 NULL, part_name, sizeof (part_name)) != DLADM_STATUS_OK)
9274 return (DLADM_STATUS_BADARG);
9275
9276 bzero(part_over, sizeof (part_over));
9277
9278 /*
9279 * The 'dia_physlinkid' field contains the datalink ID of the IB Phys
9280 * link over which the partition was created. Use this linkid to get the
9281 * linkover field.
9282 */
9283 if (dladm_datalink_id2info(handle, attr.dia_physlinkid, NULL, NULL,
9284 NULL, part_over, sizeof (part_over)) != DLADM_STATUS_OK)
9285 (void) sprintf(part_over, "?");
9286 state->ps_found = B_TRUE;
9287
9288 /*
9289 * Read the FFORCE field from this datalink's persistent configuration
9290 * database line to determine if this datalink was created forcibly.
9291 * If this datalink is a temporary datalink, then it will not have an
9292 * entry in the persistent configuration, so check if force create flag
9293 * is set in the partition attributes.
9294 *
9295 * We need this two level check since persistent partitions brought up
9296 * by up-part during boot will have force create flag always set, since
9297 * we want up-part to always succeed even if the port is currently down
9298 * or P_Key is not yet available in the subnet.
9299 */
9300 if ((status = dladm_getsnap_conf(handle, linkid, &conf)) ==
9301 DLADM_STATUS_OK) {
9302 (void) dladm_get_conf_field(handle, conf, FFORCE,
9303 &force_in_conf, sizeof (boolean_t));
9304 dladm_destroy_conf(handle, conf);
9305 } else if (status == DLADM_STATUS_NOTFOUND) {
9306 /*
9307 * for a temp link the force create flag will determine
9308 * whether it was created with force flag.
9309 */
9310 force_in_conf = ((attr.dia_flags & DLADM_PART_FORCE_CREATE)
9311 != 0);
9312 }
9313
9314 (void) snprintf(pbuf.part_link, sizeof (pbuf.part_link),
9315 "%s", part_name);
9316
9317 (void) snprintf(pbuf.part_over, sizeof (pbuf.part_over),
9318 "%s", part_over);
9319
9320 (void) snprintf(pbuf.part_pkey, sizeof (pbuf.part_pkey),
9321 "%X", attr.dia_pkey);
9322
9323 (void) get_linkstate(pbuf.part_link, B_TRUE, pbuf.part_state);
9324
9325 (void) snprintf(pbuf.part_flags, sizeof (pbuf.part_flags),
9326 "%c----", force_in_conf ? 'f' : '-');
9327
9328 ofmt_print(state->ps_ofmt, &pbuf);
9329
9330 return (DLADM_STATUS_OK);
9331 }
9332
9333 /* ARGSUSED */
9334 static int
show_part(dladm_handle_t dh,datalink_id_t linkid,void * arg)9335 show_part(dladm_handle_t dh, datalink_id_t linkid, void *arg)
9336 {
9337 ((show_part_state_t *)arg)->ps_status = print_part(arg, linkid);
9338 return (DLADM_WALK_CONTINUE);
9339 }
9340
9341 /*
9342 * Show the information about the IB partition objects.
9343 */
9344 static void
do_show_part(int argc,char * argv[],const char * use)9345 do_show_part(int argc, char *argv[], const char *use)
9346 {
9347 int option;
9348 boolean_t l_arg = B_FALSE;
9349 uint32_t flags = DLADM_OPT_ACTIVE;
9350 datalink_id_t linkid = DATALINK_ALL_LINKID;
9351 datalink_id_t over_linkid = DATALINK_ALL_LINKID;
9352 char over_link[MAXLINKNAMELEN];
9353 show_part_state_t state;
9354 dladm_status_t status;
9355 boolean_t o_arg = B_FALSE;
9356 char *fields_str = NULL;
9357 ofmt_handle_t ofmt;
9358 ofmt_status_t oferr;
9359 uint_t ofmtflags = 0;
9360
9361 bzero(&state, sizeof (state));
9362 opterr = 0;
9363 while ((option = getopt_long(argc, argv, ":pPl:o:", show_part_lopts,
9364 NULL)) != -1) {
9365 switch (option) {
9366 case 'p':
9367 state.ps_parsable = B_TRUE;
9368 break;
9369 case 'P':
9370 flags = DLADM_OPT_PERSIST;
9371 break;
9372 case 'l':
9373 /*
9374 * The data link ID of the IB Phys link. When this
9375 * argument is provided we list only the partition
9376 * objects created over this IB Phys link.
9377 */
9378 if (strlcpy(over_link, optarg, MAXLINKNAMELEN) >=
9379 MAXLINKNAMELEN)
9380 die("link name too long");
9381
9382 l_arg = B_TRUE;
9383 break;
9384 case 'o':
9385 o_arg = B_TRUE;
9386 fields_str = optarg;
9387 break;
9388 default:
9389 die_opterr(optopt, option, use);
9390 }
9391 }
9392
9393 /*
9394 * Get the partition ID (optional last argument).
9395 */
9396 if (optind == (argc - 1)) {
9397 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
9398 NULL, NULL);
9399 if (status != DLADM_STATUS_OK) {
9400 die_dlerr(status, "invalid partition link name '%s'",
9401 argv[optind]);
9402 }
9403 (void) strlcpy(state.ps_part, argv[optind], MAXLINKNAMELEN);
9404 } else if (optind != argc) {
9405 usage();
9406 }
9407
9408 if (state.ps_parsable && !o_arg)
9409 die("-p requires -o");
9410
9411 /*
9412 * If an IB Phys link name was provided as an argument, then get its
9413 * datalink ID.
9414 */
9415 if (l_arg) {
9416 status = dladm_name2info(handle, over_link, &over_linkid, NULL,
9417 NULL, NULL);
9418 if (status != DLADM_STATUS_OK) {
9419 die_dlerr(status, "invalid link name '%s'", over_link);
9420 }
9421 }
9422
9423 state.ps_over_id = over_linkid; /* IB Phys link ID */
9424 state.ps_found = B_FALSE;
9425 state.ps_flags = flags;
9426
9427 if (state.ps_parsable)
9428 ofmtflags |= OFMT_PARSABLE;
9429 oferr = ofmt_open(fields_str, part_fields, ofmtflags, 0, &ofmt);
9430 ofmt_check(oferr, state.ps_parsable, ofmt, die, warn);
9431 state.ps_ofmt = ofmt;
9432
9433 /*
9434 * If a specific IB partition name was not provided as an argument,
9435 * walk all the datalinks and display the information for all
9436 * IB partitions. If IB Phys link was provided limit it to only
9437 * IB partitions created over that IB Phys link.
9438 */
9439 if (linkid == DATALINK_ALL_LINKID) {
9440 (void) dladm_walk_datalink_id(show_part, handle, &state,
9441 DATALINK_CLASS_PART, DATALINK_ANY_MEDIATYPE, flags);
9442 } else {
9443 (void) show_part(handle, linkid, &state);
9444 if (state.ps_status != DLADM_STATUS_OK) {
9445 ofmt_close(ofmt);
9446 die_dlerr(state.ps_status, "failed to show IB partition"
9447 " '%s'", state.ps_part);
9448 }
9449 }
9450 ofmt_close(ofmt);
9451 }
9452
9453
9454 /*
9455 * Called from the walker dladm_walk_datalink_id() for each IB Phys link to
9456 * display IB specific information for these Phys links.
9457 */
9458 static dladm_status_t
print_ib(show_ib_state_t * state,datalink_id_t phys_linkid)9459 print_ib(show_ib_state_t *state, datalink_id_t phys_linkid)
9460 {
9461 dladm_ib_attr_t attr;
9462 dladm_status_t status;
9463 char linkname[MAXLINKNAMELEN];
9464 char pkeystr[MAXPKEYLEN];
9465 int i;
9466 ib_fields_buf_t ibuf;
9467
9468 bzero(&attr, sizeof (attr));
9469
9470 /*
9471 * Get the attributes of the IB Phys link from active/Persistent config
9472 * based on the flag passed.
9473 */
9474 if ((status = dladm_ib_info(handle, phys_linkid, &attr,
9475 state->is_flags)) != DLADM_STATUS_OK)
9476 return (status);
9477
9478 if ((state->is_link_id != DATALINK_ALL_LINKID) && (state->is_link_id
9479 != attr.dia_physlinkid)) {
9480 dladm_free_ib_info(&attr);
9481 return (DLADM_STATUS_OK);
9482 }
9483
9484 /*
9485 * Get the data link name for the phys_linkid. If we are doing show-ib
9486 * for all IB Phys links, we have only the datalink IDs not the
9487 * datalink name.
9488 */
9489 if (dladm_datalink_id2info(handle, phys_linkid, NULL, NULL, NULL,
9490 linkname, MAXLINKNAMELEN) != DLADM_STATUS_OK)
9491 return (status);
9492
9493 (void) snprintf(ibuf.ib_link, sizeof (ibuf.ib_link),
9494 "%s", linkname);
9495
9496 (void) snprintf(ibuf.ib_portnum, sizeof (ibuf.ib_portnum),
9497 "%d", attr.dia_portnum);
9498
9499 (void) snprintf(ibuf.ib_hcaguid, sizeof (ibuf.ib_hcaguid),
9500 "%llX", attr.dia_hca_guid);
9501
9502 (void) snprintf(ibuf.ib_portguid, sizeof (ibuf.ib_portguid),
9503 "%llX", attr.dia_port_guid);
9504
9505 (void) get_linkstate(linkname, B_TRUE, ibuf.ib_state);
9506
9507 /*
9508 * Create a comma separated list of pkeys from the pkey table returned
9509 * by the IP over IB driver instance.
9510 */
9511 bzero(ibuf.ib_pkeys, attr.dia_port_pkey_tbl_sz * sizeof (ib_pkey_t));
9512 for (i = 0; i < attr.dia_port_pkey_tbl_sz; i++) {
9513 if (attr.dia_port_pkeys[i] != IB_PKEY_INVALID_FULL &&
9514 attr.dia_port_pkeys[i] != IB_PKEY_INVALID_LIMITED) {
9515 if (i == 0)
9516 (void) snprintf(pkeystr, MAXPKEYLEN, "%X",
9517 attr.dia_port_pkeys[i]);
9518 else
9519 (void) snprintf(pkeystr, MAXPKEYLEN, ",%X",
9520 attr.dia_port_pkeys[i]);
9521 (void) strlcat(ibuf.ib_pkeys, pkeystr, MAXPKEYSTRSZ);
9522 }
9523 }
9524
9525 dladm_free_ib_info(&attr);
9526
9527 ofmt_print(state->is_ofmt, &ibuf);
9528
9529 return (DLADM_STATUS_OK);
9530 }
9531
9532 /* ARGSUSED */
9533 static int
show_ib(dladm_handle_t dh,datalink_id_t linkid,void * arg)9534 show_ib(dladm_handle_t dh, datalink_id_t linkid, void *arg)
9535 {
9536 ((show_ib_state_t *)arg)->is_status = print_ib(arg, linkid);
9537 return (DLADM_WALK_CONTINUE);
9538 }
9539
9540 /*
9541 * Show the properties of one/all IB Phys links. This is different from
9542 * show-phys command since this will display IB specific information about the
9543 * Phys link like, HCA GUID, PORT GUID, PKEYS active for this port etc.
9544 */
9545 static void
do_show_ib(int argc,char * argv[],const char * use)9546 do_show_ib(int argc, char *argv[], const char *use)
9547 {
9548 int option;
9549 uint32_t flags = DLADM_OPT_ACTIVE;
9550 datalink_id_t linkid = DATALINK_ALL_LINKID;
9551 show_ib_state_t state;
9552 dladm_status_t status;
9553 boolean_t o_arg = B_FALSE;
9554 char *fields_str = NULL;
9555 ofmt_handle_t ofmt;
9556 ofmt_status_t oferr;
9557 uint_t ofmtflags = 0;
9558
9559 bzero(&state, sizeof (state));
9560 opterr = 0;
9561 while ((option = getopt_long(argc, argv, ":po:", show_lopts,
9562 NULL)) != -1) {
9563 switch (option) {
9564 case 'p':
9565 state.is_parsable = B_TRUE;
9566 break;
9567 case 'o':
9568 o_arg = B_TRUE;
9569 fields_str = optarg;
9570 break;
9571 default:
9572 die_opterr(optopt, option, use);
9573 }
9574 }
9575
9576 /* get IB Phys link ID (optional last argument) */
9577 if (optind == (argc - 1)) {
9578 status = dladm_name2info(handle, argv[optind], &linkid, NULL,
9579 NULL, NULL);
9580 if (status != DLADM_STATUS_OK) {
9581 die_dlerr(status, "invalid IB port name '%s'",
9582 argv[optind]);
9583 }
9584 (void) strlcpy(state.is_link, argv[optind], MAXLINKNAMELEN);
9585 } else if (optind != argc) {
9586 usage();
9587 }
9588
9589 if (state.is_parsable && !o_arg)
9590 die("-p requires -o");
9591
9592 /*
9593 * linkid is the data link ID of the IB Phys link. By default it will
9594 * be DATALINK_ALL_LINKID.
9595 */
9596 state.is_link_id = linkid;
9597 state.is_flags = flags;
9598
9599 if (state.is_parsable)
9600 ofmtflags |= OFMT_PARSABLE;
9601 oferr = ofmt_open(fields_str, ib_fields, ofmtflags, 0, &ofmt);
9602 ofmt_check(oferr, state.is_parsable, ofmt, die, warn);
9603 state.is_ofmt = ofmt;
9604
9605 /*
9606 * If we are going to display the information for all IB Phys links
9607 * then we'll walk through all the datalinks for datalinks of Phys
9608 * class and media type IB.
9609 */
9610 if (linkid == DATALINK_ALL_LINKID) {
9611 (void) dladm_walk_datalink_id(show_ib, handle, &state,
9612 DATALINK_CLASS_PHYS, DL_IB, flags);
9613 } else {
9614 /*
9615 * We need to display the information only for the IB phys link
9616 * linkid. Call show_ib for this link.
9617 */
9618 (void) show_ib(handle, linkid, &state);
9619 if (state.is_status != DLADM_STATUS_OK) {
9620 ofmt_close(ofmt);
9621 die_dlerr(state.is_status, "failed to show IB Phys link"
9622 " '%s'", state.is_link);
9623 }
9624 }
9625 ofmt_close(ofmt);
9626 }
9627
9628 /*
9629 * Create an IP over Infiniband partition object over an IB Phys link. The IB
9630 * Phys link is associated with an Infiniband HCA port. The IB partition object
9631 * is created over a port, pkey combination. This partition object represents
9632 * an instance of IP over IB interface.
9633 */
9634 /* ARGSUSED */
9635 static void
do_create_part(int argc,char * argv[],const char * use)9636 do_create_part(int argc, char *argv[], const char *use)
9637 {
9638 int status, option;
9639 int flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9640 char *pname;
9641 char *l_arg = NULL;
9642 char *altroot = NULL;
9643 datalink_id_t physlinkid = 0;
9644 datalink_id_t partlinkid = 0;
9645 unsigned long opt_pkey;
9646 ib_pkey_t pkey = 0;
9647 char *endp = NULL;
9648 char propstr[DLADM_STRSIZE];
9649 dladm_arg_list_t *proplist = NULL;
9650
9651 propstr[0] = '\0';
9652 while ((option = getopt_long(argc, argv, ":tfl:P:R:p:",
9653 part_lopts, NULL)) != -1) {
9654 switch (option) {
9655 case 't':
9656 /*
9657 * Create a temporary IB partition object. This
9658 * instance is not entered into the persistent database
9659 * so it will not be recreated automatically on a
9660 * reboot.
9661 */
9662 flags &= ~DLADM_OPT_PERSIST;
9663 break;
9664 case 'l':
9665 /*
9666 * The IB phys link over which the partition object will
9667 * be created.
9668 */
9669 l_arg = optarg;
9670 break;
9671 case 'R':
9672 altroot = optarg;
9673 break;
9674 case 'p':
9675 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
9676 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
9677 DLADM_STRSIZE)
9678 die("property list too long '%s'", propstr);
9679 break;
9680 case 'P':
9681 /*
9682 * The P_Key for the port, pkey tuple of the partition
9683 * object. This P_Key should exist in the IB subnet.
9684 * The partition creation for a non-existent P_Key will
9685 * fail unless the -f option is used.
9686 *
9687 * The P_Key is expected to be a hexadecimal number.
9688 */
9689 opt_pkey = strtoul(optarg, &endp, 16);
9690 if (errno == ERANGE || opt_pkey > USHRT_MAX ||
9691 *endp != '\0')
9692 die("Invalid pkey");
9693
9694 pkey = (ib_pkey_t)opt_pkey;
9695 break;
9696 case 'f':
9697 flags |= DLADM_OPT_FORCE;
9698 break;
9699 default:
9700 die_opterr(optopt, option, use);
9701 break;
9702 }
9703 }
9704
9705 /* check required options */
9706 if (!l_arg)
9707 usage();
9708
9709 /* the partition name is a required operand */
9710 if (optind != (argc - 1))
9711 usage();
9712
9713 pname = argv[argc - 1];
9714
9715 /*
9716 * Verify that the partition object's name is in the valid link name
9717 * format.
9718 */
9719 if (!dladm_valid_linkname(pname))
9720 die("Invalid link name '%s'", pname);
9721
9722 /* pkey is a mandatory argument */
9723 if (pkey == 0)
9724 usage();
9725
9726 if (altroot != NULL)
9727 altroot_cmd(altroot, argc, argv);
9728
9729 /*
9730 * Get the data link id of the IB Phys link over which we will be
9731 * creating partition object.
9732 */
9733 if (dladm_name2info(handle, l_arg,
9734 &physlinkid, NULL, NULL, NULL) != DLADM_STATUS_OK)
9735 die("invalid link name '%s'", l_arg);
9736
9737 /*
9738 * parse the property list provided with -p option.
9739 */
9740 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
9741 != DLADM_STATUS_OK)
9742 die("invalid IB partition property");
9743
9744 /*
9745 * Call the library routine to create the partition object.
9746 */
9747 status = dladm_part_create(handle, physlinkid, pkey, flags, pname,
9748 &partlinkid, proplist);
9749 if (status != DLADM_STATUS_OK)
9750 die_dlerr(status,
9751 "partition %x creation over %s failed", pkey, l_arg);
9752 }
9753
9754 /*
9755 * Delete an IP over Infiniband partition object. The partition object should
9756 * be unplumbed before attempting the delete.
9757 */
9758 static void
do_delete_part(int argc,char * argv[],const char * use)9759 do_delete_part(int argc, char *argv[], const char *use)
9760 {
9761 int option, flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9762 int status;
9763 char *altroot = NULL;
9764 datalink_id_t partid;
9765
9766 opterr = 0;
9767 while ((option = getopt_long(argc, argv, "R:t", part_lopts,
9768 NULL)) != -1) {
9769 switch (option) {
9770 case 't':
9771 flags &= ~DLADM_OPT_PERSIST;
9772 break;
9773 case 'R':
9774 altroot = optarg;
9775 break;
9776 default:
9777 die_opterr(optopt, option, use);
9778 }
9779 }
9780
9781 /* get partition name (required last argument) */
9782 if (optind != (argc - 1))
9783 usage();
9784
9785 if (altroot != NULL)
9786 altroot_cmd(altroot, argc, argv);
9787
9788 /*
9789 * Get the data link id of the partition object given the partition
9790 * name.
9791 */
9792 status = dladm_name2info(handle, argv[optind], &partid, NULL, NULL,
9793 NULL);
9794 if (status != DLADM_STATUS_OK)
9795 die("invalid link name '%s'", argv[optind]);
9796
9797 /*
9798 * Call the library routine to delete the IB partition. This will
9799 * result in the IB partition object and all its resources getting
9800 * deleted.
9801 */
9802 status = dladm_part_delete(handle, partid, flags);
9803 if (status != DLADM_STATUS_OK)
9804 die_dlerr(status, "%s: partition deletion failed",
9805 argv[optind]);
9806 }
9807
9808 /*
9809 * Bring up all or one IB partition already present in the persistent database
9810 * but not active yet.
9811 *
9812 * This sub-command is used during the system boot up to bring up all IB
9813 * partitions present in the persistent database. This is similar to a
9814 * create partition except that, the partitions are always created even if the
9815 * HCA port is down or P_Key is not present in the IB subnet. This is similar
9816 * to using the 'force' option while creating the partition except that the 'f'
9817 * flag will be set in the flags field only if the create-part for this command
9818 * was called with '-f' option.
9819 */
9820 /* ARGSUSED */
9821 static void
do_up_part(int argc,char * argv[],const char * use)9822 do_up_part(int argc, char *argv[], const char *use)
9823 {
9824 datalink_id_t partid = DATALINK_ALL_LINKID;
9825 dladm_status_t status;
9826
9827 /*
9828 * If a partition name was passed as an argument, get its data link
9829 * id. By default we'll attempt to bring up all IB partition data
9830 * links.
9831 */
9832 if (argc == 2) {
9833 status = dladm_name2info(handle, argv[argc - 1], &partid, NULL,
9834 NULL, NULL);
9835 if (status != DLADM_STATUS_OK)
9836 return;
9837 } else if (argc > 2) {
9838 usage();
9839 }
9840
9841 (void) dladm_part_up(handle, partid, 0);
9842 }
9843
9844 static void
do_create_overlay(int argc,char * argv[],const char * use)9845 do_create_overlay(int argc, char *argv[], const char *use)
9846 {
9847 int opt;
9848 char *encap = NULL, *endp, *search = NULL;
9849 char name[MAXLINKNAMELEN];
9850 dladm_status_t status;
9851 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9852 uint64_t vid = 0;
9853 boolean_t havevid = B_FALSE;
9854 char propstr[DLADM_STRSIZE];
9855 dladm_arg_list_t *proplist = NULL;
9856
9857 bzero(propstr, sizeof (propstr));
9858 while ((opt = getopt_long(argc, argv, ":te:v:p:s:",
9859 overlay_create_lopts, NULL)) != -1) {
9860 switch (opt) {
9861 case 'e':
9862 encap = optarg;
9863 break;
9864 case 's':
9865 search = optarg;
9866 break;
9867 case 't':
9868 flags &= ~DLADM_OPT_PERSIST;
9869 break;
9870 case 'p':
9871 (void) strlcat(propstr, optarg, DLADM_STRSIZE);
9872 if (strlcat(propstr, ",", DLADM_STRSIZE) >=
9873 DLADM_STRSIZE)
9874 die("property list too long '%s'", propstr);
9875 break;
9876 case 'v':
9877 vid = strtoul(optarg, &endp, 10);
9878 if (*endp != '\0' || (vid == 0 && errno == EINVAL))
9879 die("couldn't parse virtual networkd id: %s",
9880 optarg);
9881 if (vid == ULONG_MAX && errno == ERANGE)
9882 die("virtual networkd id too large: %s",
9883 optarg);
9884 havevid = B_TRUE;
9885 break;
9886 default:
9887 die_opterr(optopt, opt, use);
9888 }
9889 }
9890
9891 if (havevid == B_FALSE)
9892 die("missing required virtual network id");
9893
9894 if (encap == NULL)
9895 die("missing required encapsulation plugin");
9896
9897 if (search == NULL)
9898 die("missing required search plugin");
9899
9900 if (optind != (argc - 1))
9901 die("missing device name");
9902
9903 if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >= MAXLINKNAMELEN)
9904 die("link name too long '%s'", argv[optind]);
9905
9906 if (!dladm_valid_linkname(name))
9907 die("invalid link name '%s'", argv[optind]);
9908
9909 if (strlen(encap) + 1 > MAXLINKNAMELEN)
9910 die("encapsulation plugin name too long '%s'", encap);
9911
9912 if (strlen(search) + 1 > MAXLINKNAMELEN)
9913 die("search plugin name too long '%s'", encap);
9914
9915 if (dladm_parse_link_props(propstr, &proplist, B_FALSE)
9916 != DLADM_STATUS_OK)
9917 die("invalid overlay property");
9918
9919 status = dladm_overlay_create(handle, name, encap, search, vid,
9920 proplist, &errlist, flags);
9921 dladm_free_props(proplist);
9922 if (status != DLADM_STATUS_OK) {
9923 die_dlerrlist(status, &errlist, "overlay creation failed");
9924 }
9925 }
9926
9927 /* ARGSUSED */
9928 static void
do_delete_overlay(int argc,char * argv[],const char * use)9929 do_delete_overlay(int argc, char *argv[], const char *use)
9930 {
9931 datalink_id_t linkid = DATALINK_ALL_LINKID;
9932 dladm_status_t status;
9933 uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;
9934 int option;
9935
9936 opterr = 0;
9937 while ((option = getopt_long(argc, argv, ":t", lopts,
9938 NULL)) != -1) {
9939 switch (option) {
9940 case 't':
9941 flags &= ~DLADM_OPT_PERSIST;
9942 break;
9943 default:
9944 die_opterr(optopt, option, use);
9945 }
9946 }
9947
9948 /* get overlay name (required last argument) */
9949 if (optind != (argc - 1))
9950 usage();
9951
9952 status = dladm_name2info(handle, argv[optind], &linkid,
9953 NULL, NULL, NULL);
9954 if (status != DLADM_STATUS_OK)
9955 die_dlerr(status, "failed to delete %s", argv[optind]);
9956
9957 status = dladm_overlay_delete(handle, linkid, flags);
9958 if (status != DLADM_STATUS_OK)
9959 die_dlerr(status, "failed to delete %s", argv[optind]);
9960 }
9961
9962 typedef struct showoverlay_state {
9963 ofmt_handle_t sho_ofmt;
9964 const char *sho_linkname;
9965 dladm_overlay_propinfo_handle_t sho_info;
9966 uint8_t sho_value[DLADM_OVERLAY_PROP_SIZEMAX];
9967 uint32_t sho_size;
9968 } showoverlay_state_t;
9969
9970 typedef struct showoverlay_fma_state {
9971 ofmt_handle_t shof_ofmt;
9972 const char *shof_linkname;
9973 dladm_overlay_status_t *shof_status;
9974 } showoverlay_fma_state_t;
9975
9976 typedef struct showoverlay_targ_state {
9977 ofmt_handle_t shot_ofmt;
9978 const char *shot_linkname;
9979 const struct ether_addr *shot_key;
9980 const dladm_overlay_point_t *shot_point;
9981 } showoverlay_targ_state_t;
9982
9983 static void
print_overlay_value(char * outbuf,uint_t bufsize,uint_t type,const void * pbuf,const size_t psize)9984 print_overlay_value(char *outbuf, uint_t bufsize, uint_t type, const void *pbuf,
9985 const size_t psize)
9986 {
9987 const struct in6_addr *ipv6;
9988 struct in_addr ip;
9989
9990 switch (type) {
9991 case OVERLAY_PROP_T_INT:
9992 if (psize != 1 && psize != 2 && psize != 4 && psize != 8) {
9993 (void) snprintf(outbuf, bufsize, "?");
9994 break;
9995 }
9996 if (psize == 1)
9997 (void) snprintf(outbuf, bufsize, "%d", *(int8_t *)pbuf);
9998 if (psize == 2)
9999 (void) snprintf(outbuf, bufsize, "%d",
10000 *(int16_t *)pbuf);
10001 if (psize == 4)
10002 (void) snprintf(outbuf, bufsize, "%d",
10003 *(int32_t *)pbuf);
10004 if (psize == 8)
10005 (void) snprintf(outbuf, bufsize, "%d",
10006 *(int64_t *)pbuf);
10007 break;
10008 case OVERLAY_PROP_T_UINT:
10009 if (psize != 1 && psize != 2 && psize != 4 && psize != 8) {
10010 (void) snprintf(outbuf, bufsize, "?");
10011 break;
10012 }
10013 if (psize == 1)
10014 (void) snprintf(outbuf, bufsize, "%d",
10015 *(uint8_t *)pbuf);
10016 if (psize == 2)
10017 (void) snprintf(outbuf, bufsize, "%d",
10018 *(uint16_t *)pbuf);
10019 if (psize == 4)
10020 (void) snprintf(outbuf, bufsize, "%d",
10021 *(uint32_t *)pbuf);
10022 if (psize == 8)
10023 (void) snprintf(outbuf, bufsize, "%d",
10024 *(uint64_t *)pbuf);
10025 break;
10026 case OVERLAY_PROP_T_IP:
10027 if (psize != sizeof (struct in6_addr)) {
10028 warn("malformed overlay IP property: %d bytes\n",
10029 psize);
10030 (void) snprintf(outbuf, bufsize, "--");
10031 break;
10032 }
10033
10034 ipv6 = pbuf;
10035 if (IN6_IS_ADDR_V4MAPPED(ipv6)) {
10036 IN6_V4MAPPED_TO_INADDR(ipv6, &ip);
10037 if (inet_ntop(AF_INET, &ip, outbuf, bufsize) == NULL) {
10038 warn("malformed overlay IP property\n");
10039 (void) snprintf(outbuf, bufsize, "--");
10040 break;
10041 }
10042 } else {
10043 if (inet_ntop(AF_INET6, ipv6, outbuf, bufsize) ==
10044 NULL) {
10045 warn("malformed overlay IP property\n");
10046 (void) snprintf(outbuf, bufsize, "--");
10047 break;
10048 }
10049 }
10050
10051 break;
10052 case OVERLAY_PROP_T_STRING:
10053 (void) snprintf(outbuf, bufsize, "%s", pbuf);
10054 break;
10055 default:
10056 abort();
10057 }
10058
10059 return;
10060
10061 }
10062
10063 static boolean_t
print_overlay_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)10064 print_overlay_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
10065 {
10066 dladm_status_t status;
10067 showoverlay_state_t *sp = ofarg->ofmt_cbarg;
10068 dladm_overlay_propinfo_handle_t infop = sp->sho_info;
10069 const char *pname;
10070 uint_t type, prot;
10071 const void *def;
10072 uint32_t defsize;
10073 const mac_propval_range_t *rangep;
10074
10075 if ((status = dladm_overlay_prop_info(infop, &pname, &type, &prot, &def,
10076 &defsize, &rangep)) != DLADM_STATUS_OK) {
10077 warn_dlerr(status, "failed to get get property info");
10078 return (B_TRUE);
10079 }
10080
10081 switch (ofarg->ofmt_id) {
10082 case OVERLAY_LINK:
10083 (void) snprintf(buf, bufsize, "%s", sp->sho_linkname);
10084 break;
10085 case OVERLAY_PROPERTY:
10086 (void) snprintf(buf, bufsize, "%s", pname);
10087 break;
10088 case OVERLAY_PERM:
10089 if ((prot & OVERLAY_PROP_PERM_RW) == OVERLAY_PROP_PERM_RW) {
10090 (void) snprintf(buf, bufsize, "%s", "rw");
10091 } else if ((prot & OVERLAY_PROP_PERM_RW) ==
10092 OVERLAY_PROP_PERM_READ) {
10093 (void) snprintf(buf, bufsize, "%s", "r-");
10094 } else {
10095 (void) snprintf(buf, bufsize, "%s", "--");
10096 }
10097 break;
10098 case OVERLAY_REQ:
10099 (void) snprintf(buf, bufsize, "%s",
10100 prot & OVERLAY_PROP_PERM_REQ ? "y" : "-");
10101 break;
10102 case OVERLAY_VALUE:
10103 if (sp->sho_size == 0) {
10104 (void) snprintf(buf, bufsize, "%s", "--");
10105 } else {
10106 print_overlay_value(buf, bufsize, type, sp->sho_value,
10107 sp->sho_size);
10108 }
10109 break;
10110 case OVERLAY_DEFAULT:
10111 if (defsize == 0) {
10112 (void) snprintf(buf, bufsize, "%s", "--");
10113 } else {
10114 print_overlay_value(buf, bufsize, type, def, defsize);
10115 }
10116 break;
10117 case OVERLAY_POSSIBLE: {
10118 int i;
10119 char **vals, *ptr, *lim;
10120 if (rangep->mpr_count == 0) {
10121 (void) snprintf(buf, bufsize, "%s", "--");
10122 break;
10123 }
10124
10125 vals = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) *
10126 rangep->mpr_count);
10127 if (vals == NULL)
10128 die("insufficient memory");
10129 for (i = 0; i < rangep->mpr_count; i++) {
10130 vals[i] = (char *)vals + sizeof (char *) *
10131 rangep->mpr_count + i * DLADM_MAX_PROP_VALCNT;
10132 }
10133
10134 if (dladm_range2strs(rangep, vals) != 0) {
10135 free(vals);
10136 (void) snprintf(buf, bufsize, "%s", "?");
10137 break;
10138 }
10139
10140 ptr = buf;
10141 lim = buf + bufsize;
10142 for (i = 0; i < rangep->mpr_count; i++) {
10143 ptr += snprintf(ptr, lim - ptr, "%s,", vals[i]);
10144 if (ptr >= lim)
10145 break;
10146 }
10147 if (rangep->mpr_count > 0)
10148 buf[strlen(buf) - 1] = '\0';
10149 free(vals);
10150 break;
10151 }
10152 default:
10153 abort();
10154 }
10155 return (B_TRUE);
10156 }
10157
10158 static int
dladm_overlay_show_one(dladm_handle_t handle,datalink_id_t linkid,dladm_overlay_propinfo_handle_t phdl,void * arg)10159 dladm_overlay_show_one(dladm_handle_t handle, datalink_id_t linkid,
10160 dladm_overlay_propinfo_handle_t phdl, void *arg)
10161 {
10162 showoverlay_state_t *sp = arg;
10163 sp->sho_info = phdl;
10164
10165 sp->sho_size = sizeof (sp->sho_value);
10166 if (dladm_overlay_get_prop(handle, linkid, phdl, &sp->sho_value,
10167 &sp->sho_size) != DLADM_STATUS_OK)
10168 return (DLADM_WALK_CONTINUE);
10169
10170 ofmt_print(sp->sho_ofmt, sp);
10171 return (DLADM_WALK_CONTINUE);
10172 }
10173
10174 static int
show_one_overlay(dladm_handle_t hdl,datalink_id_t linkid,void * arg)10175 show_one_overlay(dladm_handle_t hdl, datalink_id_t linkid, void *arg)
10176 {
10177 char buf[MAXLINKNAMELEN];
10178 dladm_status_t info_status;
10179 showoverlay_state_t state;
10180 datalink_class_t class;
10181 show_overlay_request_t *req = arg;
10182
10183 if ((info_status = dladm_datalink_id2info(hdl, linkid, NULL, &class,
10184 NULL, buf, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
10185 warn_dlerr(info_status, "failed to get info for "
10186 "datalink id %u", linkid);
10187 req->sor_failed = B_TRUE;
10188 return (DLADM_WALK_CONTINUE);
10189 }
10190
10191 if (class != DATALINK_CLASS_OVERLAY) {
10192 warn("%s is not an overlay", buf);
10193 req->sor_failed = B_TRUE;
10194 return (DLADM_WALK_CONTINUE);
10195 }
10196
10197 state.sho_linkname = buf;
10198 state.sho_ofmt = req->sor_ofmt;
10199
10200 dladm_errlist_reset(&errlist);
10201 (void) dladm_overlay_walk_prop(handle, linkid, dladm_overlay_show_one,
10202 &state, &errlist);
10203 warn_dlerrlist(&errlist);
10204 if (errlist.el_count) {
10205 req->sor_failed = B_TRUE;
10206 }
10207
10208 return (DLADM_WALK_CONTINUE);
10209 }
10210
10211 static boolean_t
print_overlay_targ_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)10212 print_overlay_targ_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
10213 {
10214 char keybuf[ETHERADDRSTRL];
10215 const showoverlay_targ_state_t *shot = ofarg->ofmt_cbarg;
10216 const dladm_overlay_point_t *point = shot->shot_point;
10217 char macbuf[ETHERADDRSTRL];
10218 char ipbuf[INET6_ADDRSTRLEN];
10219 custr_t *cus;
10220
10221 switch (ofarg->ofmt_id) {
10222 case OVERLAY_TARG_LINK:
10223 (void) snprintf(buf, bufsize, shot->shot_linkname);
10224 break;
10225 case OVERLAY_TARG_TARGET:
10226 if ((point->dop_flags & DLADM_OVERLAY_F_DEFAULT) != 0) {
10227 (void) snprintf(buf, bufsize, "*:*:*:*:*:*");
10228 } else {
10229 if (ether_ntoa_r(shot->shot_key, keybuf) == NULL) {
10230 warn("encountered malformed mac address key\n");
10231 return (B_FALSE);
10232 }
10233 (void) snprintf(buf, bufsize, "%s", keybuf);
10234 }
10235 break;
10236 case OVERLAY_TARG_DEST:
10237 if (custr_alloc_buf(&cus, buf, bufsize) != 0) {
10238 die("ran out of memory for printing the overlay "
10239 "target destination");
10240 }
10241
10242 if (point->dop_dest & OVERLAY_PLUGIN_D_ETHERNET) {
10243 if (ether_ntoa_r(&point->dop_mac, macbuf) == NULL) {
10244 warn("encountered malformed mac address target "
10245 "for key %s\n", keybuf);
10246 return (B_FALSE);
10247 }
10248 (void) custr_append(cus, macbuf);
10249 }
10250
10251 if (point->dop_dest & OVERLAY_PLUGIN_D_IP) {
10252 if (IN6_IS_ADDR_V4MAPPED(&point->dop_ip)) {
10253 struct in_addr v4;
10254 IN6_V4MAPPED_TO_INADDR(&point->dop_ip, &v4);
10255 if (inet_ntop(AF_INET, &v4, ipbuf,
10256 sizeof (ipbuf)) == NULL)
10257 abort();
10258 } else if (inet_ntop(AF_INET6, &point->dop_ip, ipbuf,
10259 sizeof (ipbuf)) == NULL) {
10260 /*
10261 * The only failures we should get are
10262 * EAFNOSUPPORT and ENOSPC because of buffer
10263 * exhaustion. In either of these cases, that
10264 * means something has gone horribly wrong.
10265 */
10266 abort();
10267 }
10268 if (point->dop_dest & OVERLAY_PLUGIN_D_ETHERNET)
10269 (void) custr_appendc(cus, ',');
10270 (void) custr_append(cus, ipbuf);
10271 }
10272
10273 if (point->dop_dest & OVERLAY_PLUGIN_D_PORT) {
10274 if (point->dop_dest & OVERLAY_PLUGIN_D_IP)
10275 (void) custr_appendc(cus, ':');
10276 else if (point->dop_dest & OVERLAY_PLUGIN_D_ETHERNET)
10277 (void) custr_appendc(cus, ',');
10278 (void) custr_append_printf(cus, "%u", point->dop_port);
10279 }
10280
10281 custr_free(cus);
10282
10283 break;
10284 }
10285 return (B_TRUE);
10286 }
10287
10288 /* ARGSUSED */
10289 static int
show_one_overlay_table_entry(dladm_handle_t handle,datalink_id_t linkid,const struct ether_addr * key,const dladm_overlay_point_t * point,void * arg)10290 show_one_overlay_table_entry(dladm_handle_t handle, datalink_id_t linkid,
10291 const struct ether_addr *key, const dladm_overlay_point_t *point, void *arg)
10292 {
10293 showoverlay_targ_state_t *shot = arg;
10294
10295 shot->shot_key = key;
10296 shot->shot_point = point;
10297 ofmt_print(shot->shot_ofmt, shot);
10298
10299 return (DLADM_WALK_CONTINUE);
10300 }
10301
10302 /* ARGSUSED */
10303 static int
show_one_overlay_table(dladm_handle_t handle,datalink_id_t linkid,void * arg)10304 show_one_overlay_table(dladm_handle_t handle, datalink_id_t linkid, void *arg)
10305 {
10306 char linkbuf[MAXLINKNAMELEN];
10307 dladm_status_t info_status;
10308 showoverlay_targ_state_t shot;
10309 datalink_class_t class;
10310 show_overlay_request_t *req = arg;
10311
10312 if ((info_status = dladm_datalink_id2info(handle, linkid, NULL, &class,
10313 NULL, linkbuf, MAXLINKNAMELEN)) != DLADM_STATUS_OK) {
10314 warn_dlerr(info_status, "failed to get info for "
10315 "datalink id %u", linkid);
10316 req->sor_failed = B_TRUE;
10317 return (DLADM_WALK_CONTINUE);
10318 }
10319
10320 if (class != DATALINK_CLASS_OVERLAY) {
10321 warn("%s is not an overlay", linkbuf);
10322 req->sor_failed = B_TRUE;
10323 return (DLADM_WALK_CONTINUE);
10324 }
10325
10326 shot.shot_ofmt = req->sor_ofmt;
10327 shot.shot_linkname = linkbuf;
10328
10329 (void) dladm_overlay_walk_cache(handle, linkid,
10330 show_one_overlay_table_entry, &shot);
10331
10332 return (DLADM_WALK_CONTINUE);
10333 }
10334
10335 static boolean_t
print_overlay_fma_cb(ofmt_arg_t * ofarg,char * buf,uint_t bufsize)10336 print_overlay_fma_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
10337 {
10338 showoverlay_fma_state_t *shof = ofarg->ofmt_cbarg;
10339 dladm_overlay_status_t *st = shof->shof_status;
10340
10341 switch (ofarg->ofmt_id) {
10342 case OVERLAY_FMA_LINK:
10343 (void) snprintf(buf, bufsize, "%s", shof->shof_linkname);
10344 break;
10345 case OVERLAY_FMA_STATUS:
10346 (void) snprintf(buf, bufsize, st->dos_degraded == B_TRUE ?
10347 "DEGRADED": "ONLINE");
10348 break;
10349 case OVERLAY_FMA_DETAILS:
10350 (void) snprintf(buf, bufsize, "%s", st->dos_degraded == B_TRUE ?
10351 st->dos_fmamsg : "-");
10352 break;
10353 default:
10354 abort();
10355 }
10356 return (B_TRUE);
10357 }
10358
10359 /* ARGSUSED */
10360 static void
show_one_overlay_fma_cb(dladm_handle_t handle,datalink_id_t linkid,dladm_overlay_status_t * stat,void * arg)10361 show_one_overlay_fma_cb(dladm_handle_t handle, datalink_id_t linkid,
10362 dladm_overlay_status_t *stat, void *arg)
10363 {
10364 showoverlay_fma_state_t *shof = arg;
10365 shof->shof_status = stat;
10366 ofmt_print(shof->shof_ofmt, shof);
10367 }
10368
10369
10370 static int
show_one_overlay_fma(dladm_handle_t handle,datalink_id_t linkid,void * arg)10371 show_one_overlay_fma(dladm_handle_t handle, datalink_id_t linkid, void *arg)
10372 {
10373 dladm_status_t status;
10374 char linkbuf[MAXLINKNAMELEN];
10375 datalink_class_t class;
10376 showoverlay_fma_state_t shof;
10377 show_overlay_request_t *req = arg;
10378
10379 if (dladm_datalink_id2info(handle, linkid, NULL, &class, NULL, linkbuf,
10380 MAXLINKNAMELEN) != DLADM_STATUS_OK ||
10381 class != DATALINK_CLASS_OVERLAY) {
10382 die("datalink %s is not an overlay device\n", linkbuf);
10383 }
10384
10385 shof.shof_ofmt = req->sor_ofmt;
10386 shof.shof_linkname = linkbuf;
10387
10388 status = dladm_overlay_status(handle, linkid,
10389 show_one_overlay_fma_cb, &shof);
10390 if (status != DLADM_STATUS_OK)
10391 die_dlerr(status, "failed to obtain device status for %s",
10392 linkbuf);
10393
10394 return (DLADM_WALK_CONTINUE);
10395 }
10396
10397 static void
do_show_overlay(int argc,char * argv[],const char * use)10398 do_show_overlay(int argc, char *argv[], const char *use)
10399 {
10400 int i, opt;
10401 datalink_id_t linkid = DATALINK_ALL_LINKID;
10402 dladm_status_t status;
10403 int (*funcp)(dladm_handle_t, datalink_id_t, void *);
10404 char *fields_str = NULL;
10405 const ofmt_field_t *fieldsp;
10406 ofmt_status_t oferr;
10407 boolean_t parse;
10408 show_overlay_request_t req;
10409 uint_t ofmtflags;
10410 int err;
10411
10412 funcp = show_one_overlay;
10413 fieldsp = overlay_fields;
10414 parse = B_FALSE;
10415 req.sor_failed = B_FALSE;
10416 ofmtflags = OFMT_WRAP;
10417 while ((opt = getopt_long(argc, argv, ":o:pft", overlay_show_lopts,
10418 NULL)) != -1) {
10419 switch (opt) {
10420 case 'f':
10421 funcp = show_one_overlay_fma;
10422 fieldsp = overlay_fma_fields;
10423 break;
10424 case 'o':
10425 fields_str = optarg;
10426 break;
10427 case 'p':
10428 parse = B_TRUE;
10429 ofmtflags = OFMT_PARSABLE;
10430 break;
10431 case 't':
10432 funcp = show_one_overlay_table;
10433 fieldsp = overlay_targ_fields;
10434 break;
10435 default:
10436 die_opterr(optopt, opt, use);
10437 }
10438 }
10439
10440 if (fields_str != NULL && strcasecmp(fields_str, "all") == 0)
10441 fields_str = NULL;
10442
10443 oferr = ofmt_open(fields_str, fieldsp, ofmtflags, 0, &req.sor_ofmt);
10444 ofmt_check(oferr, parse, req.sor_ofmt, die, warn);
10445
10446 err = 0;
10447 if (argc > optind) {
10448 for (i = optind; i < argc; i++) {
10449 status = dladm_name2info(handle, argv[i], &linkid,
10450 NULL, NULL, NULL);
10451 if (status != DLADM_STATUS_OK) {
10452 warn_dlerr(status, "failed to find %s",
10453 argv[i]);
10454 err = 1;
10455 continue;
10456 }
10457 (void) funcp(handle, linkid, &req);
10458 }
10459 } else {
10460 (void) dladm_walk_datalink_id(funcp, handle, &req,
10461 DATALINK_CLASS_OVERLAY, DATALINK_ANY_MEDIATYPE,
10462 DLADM_OPT_ACTIVE);
10463 }
10464 if (req.sor_failed) {
10465 err = 1;
10466 }
10467 ofmt_close(req.sor_ofmt);
10468
10469 exit(err);
10470 }
10471
10472 static void
do_modify_overlay(int argc,char * argv[],const char * use)10473 do_modify_overlay(int argc, char *argv[], const char *use)
10474 {
10475 int opt, ocnt = 0;
10476 boolean_t flush, set, delete;
10477 struct ether_addr e;
10478 char *dest = NULL;
10479 datalink_id_t linkid = DATALINK_ALL_LINKID;
10480 dladm_status_t status;
10481
10482 flush = set = delete = B_FALSE;
10483 while ((opt = getopt_long(argc, argv, ":fd:s:", overlay_modify_lopts,
10484 NULL)) != -1) {
10485 switch (opt) {
10486 case 'd':
10487 if (delete == B_TRUE)
10488 die_optdup('d');
10489 delete = B_TRUE;
10490 ocnt++;
10491 if (ether_aton_r(optarg, &e) == NULL)
10492 die("invalid mac address: %s\n", optarg);
10493 break;
10494 case 'f':
10495 if (flush == B_TRUE)
10496 die_optdup('f');
10497 flush = B_TRUE;
10498 ocnt++;
10499 break;
10500 case 's':
10501 if (set == B_TRUE)
10502 die_optdup('s');
10503 set = B_TRUE;
10504 ocnt++;
10505 dest = strchr(optarg, '=');
10506 *dest = '\0';
10507 dest++;
10508 if (dest == NULL)
10509 die("malformed value, expected mac=dest, "
10510 "got: %s\n", optarg);
10511 if (ether_aton_r(optarg, &e) == NULL)
10512 die("invalid mac address: %s\n", optarg);
10513 break;
10514 default:
10515 die_opterr(optopt, opt, use);
10516 }
10517 }
10518
10519 if (ocnt == 0)
10520 die("need to specify one of -d, -f, or -s");
10521 if (ocnt > 1)
10522 die("only one of -d, -f, or -s may be used");
10523
10524 if (argv[optind] == NULL)
10525 die("missing required overlay device\n");
10526 if (argc > optind + 1)
10527 die("only one overlay device may be specified\n");
10528
10529 status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,
10530 NULL);
10531 if (status != DLADM_STATUS_OK) {
10532 die_dlerr(status, "failed to find overlay %s", argv[optind]);
10533 }
10534
10535 if (flush == B_TRUE) {
10536 status = dladm_overlay_cache_flush(handle, linkid);
10537 if (status != DLADM_STATUS_OK)
10538 die_dlerr(status, "failed to flush target cache for "
10539 "overlay %s", argv[optind]);
10540 }
10541
10542 if (delete == B_TRUE) {
10543 status = dladm_overlay_cache_delete(handle, linkid, &e);
10544 if (status != DLADM_STATUS_OK)
10545 die_dlerr(status, "failed to flush target %s from "
10546 "overlay target cache %s", optarg, argv[optind]);
10547 }
10548
10549 if (set == B_TRUE) {
10550 status = dladm_overlay_cache_set(handle, linkid, &e, dest);
10551 if (status != DLADM_STATUS_OK)
10552 die_dlerr(status, "failed to set target %s for overlay "
10553 "target cache %s", optarg, argv[optind]);
10554 }
10555
10556 }
10557
10558 static void
do_up_overlay(int argc,char * argv[],const char * use)10559 do_up_overlay(int argc, char *argv[], const char *use)
10560 {
10561 datalink_id_t linkid = DATALINK_ALL_LINKID;
10562 dladm_status_t status;
10563
10564 /*
10565 * get the id or the name of the overlay (optional last argument)
10566 */
10567 if (argc == 2) {
10568 status = dladm_name2info(handle, argv[1], &linkid, NULL, NULL,
10569 NULL);
10570 if (status != DLADM_STATUS_OK)
10571 goto done;
10572 } else if (argc > 2) {
10573 usage();
10574 }
10575
10576 status = dladm_overlay_up(handle, linkid, &errlist);
10577
10578 done:
10579 if (status != DLADM_STATUS_OK) {
10580 if (argc == 2) {
10581 die_dlerrlist(status, &errlist,
10582 "could not bring up overlay '%s'", argv[1]);
10583 } else {
10584 die_dlerrlist(status, &errlist,
10585 "could not bring overlays up");
10586 }
10587 }
10588 }
10589