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