dladm.c (c7e4935f) dladm.c (f595a68a)
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

--- 32 unchanged lines hidden (view full) ---

41#include <unistd.h>
42#include <priv.h>
43#include <termios.h>
44#include <pwd.h>
45#include <auth_attr.h>
46#include <auth_list.h>
47#include <libintl.h>
48#include <libdlpi.h>
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

--- 32 unchanged lines hidden (view full) ---

41#include <unistd.h>
42#include <priv.h>
43#include <termios.h>
44#include <pwd.h>
45#include <auth_attr.h>
46#include <auth_list.h>
47#include <libintl.h>
48#include <libdlpi.h>
49#include <libdladm.h>
50#include <liblaadm.h>
51#include <libmacadm.h>
52#include <libwladm.h>
49#include <libdllink.h>
50#include <libdlaggr.h>
51#include <libdlwlan.h>
53#include <libinetutil.h>
54#include <bsm/adt.h>
55#include <bsm/adt_event.h>
56
57#define AGGR_DRV "aggr"
58#define MAXPORT 256
59#define DUMP_LACP_FORMAT " %-9s %-8s %-7s %-12s " \
60 "%-5s %-4s %-4s %-9s %-7s\n"

--- 27 unchanged lines hidden (view full) ---

88
89typedef struct show_mac_state {
90 boolean_t ms_firstonly;
91 boolean_t ms_donefirst;
92 pktsum_t ms_prevstats;
93 boolean_t ms_parseable;
94} show_mac_state_t;
95
52#include <libinetutil.h>
53#include <bsm/adt.h>
54#include <bsm/adt_event.h>
55
56#define AGGR_DRV "aggr"
57#define MAXPORT 256
58#define DUMP_LACP_FORMAT " %-9s %-8s %-7s %-12s " \
59 "%-5s %-4s %-4s %-9s %-7s\n"

--- 27 unchanged lines hidden (view full) ---

87
88typedef struct show_mac_state {
89 boolean_t ms_firstonly;
90 boolean_t ms_donefirst;
91 pktsum_t ms_prevstats;
92 boolean_t ms_parseable;
93} show_mac_state_t;
94
96typedef struct port_state {
97 char *state_name;
98 aggr_port_state_t state_num;
99} port_state_t;
100
101static port_state_t port_states[] = {
102 {"standby", AGGR_PORT_STATE_STANDBY },
103 {"attached", AGGR_PORT_STATE_ATTACHED }
104};
105
106#define NPORTSTATES (sizeof (port_states) / sizeof (port_state_t))
107
108typedef void cmdfunc_t(int, char **);
109
110static cmdfunc_t do_show_link, do_show_dev, do_show_wifi;
111static cmdfunc_t do_create_aggr, do_delete_aggr, do_add_aggr, do_remove_aggr;
112static cmdfunc_t do_modify_aggr, do_show_aggr, do_up_aggr, do_down_aggr;
113static cmdfunc_t do_scan_wifi, do_connect_wifi, do_disconnect_wifi;
114static cmdfunc_t do_show_linkprop, do_set_linkprop, do_reset_linkprop;
115static cmdfunc_t do_create_secobj, do_delete_secobj, do_show_secobj;
116static cmdfunc_t do_init_linkprop, do_init_secobj;
117
118static void show_linkprop_onelink(void *, const char *);
119
120static void link_stats(const char *, uint_t);
121static void aggr_stats(uint32_t, uint_t);
122static void dev_stats(const char *dev, uint32_t);
123
124static void get_mac_stats(const char *, pktsum_t *);
125static void get_link_stats(const char *, pktsum_t *);
126static uint64_t mac_ifspeed(const char *);
95typedef void cmdfunc_t(int, char **);
96
97static cmdfunc_t do_show_link, do_show_dev, do_show_wifi;
98static cmdfunc_t do_create_aggr, do_delete_aggr, do_add_aggr, do_remove_aggr;
99static cmdfunc_t do_modify_aggr, do_show_aggr, do_up_aggr, do_down_aggr;
100static cmdfunc_t do_scan_wifi, do_connect_wifi, do_disconnect_wifi;
101static cmdfunc_t do_show_linkprop, do_set_linkprop, do_reset_linkprop;
102static cmdfunc_t do_create_secobj, do_delete_secobj, do_show_secobj;
103static cmdfunc_t do_init_linkprop, do_init_secobj;
104
105static void show_linkprop_onelink(void *, const char *);
106
107static void link_stats(const char *, uint_t);
108static void aggr_stats(uint32_t, uint_t);
109static void dev_stats(const char *dev, uint32_t);
110
111static void get_mac_stats(const char *, pktsum_t *);
112static void get_link_stats(const char *, pktsum_t *);
113static uint64_t mac_ifspeed(const char *);
127static char *mac_link_state(const char *);
128static char *mac_link_duplex(const char *);
129static void stats_total(pktsum_t *, pktsum_t *, pktsum_t *);
130static void stats_diff(pktsum_t *, pktsum_t *, pktsum_t *);
114static void stats_total(pktsum_t *, pktsum_t *, pktsum_t *);
115static void stats_diff(pktsum_t *, pktsum_t *, pktsum_t *);
116static const char *mac_link_state(const char *);
117static const char *mac_link_duplex(const char *);
131
132static boolean_t str2int(const char *, int *);
133static void die(const char *, ...);
134static void die_optdup(int);
135static void die_opterr(int, int);
118
119static boolean_t str2int(const char *, int *);
120static void die(const char *, ...);
121static void die_optdup(int);
122static void die_opterr(int, int);
136static void die_laerr(laadm_diag_t, const char *, ...);
137static void die_wlerr(wladm_status_t, const char *, ...);
138static void die_dlerr(dladm_status_t, const char *, ...);
139static void warn(const char *, ...);
123static void die_dlerr(dladm_status_t, const char *, ...);
124static void warn(const char *, ...);
140static void warn_wlerr(wladm_status_t, const char *, ...);
141static void warn_dlerr(dladm_status_t, const char *, ...);
142
143typedef struct cmd {
144 char *c_name;
145 cmdfunc_t *c_fn;
146} cmd_t;
147
148static cmd_t cmds[] = {

--- 138 unchanged lines hidden (view full) ---

287 usage();
288
289 return (0);
290}
291
292static void
293do_create_aggr(int argc, char *argv[])
294{
125static void warn_dlerr(dladm_status_t, const char *, ...);
126
127typedef struct cmd {
128 char *c_name;
129 cmdfunc_t *c_fn;
130} cmd_t;
131
132static cmd_t cmds[] = {

--- 138 unchanged lines hidden (view full) ---

271 usage();
272
273 return (0);
274}
275
276static void
277do_create_aggr(int argc, char *argv[])
278{
295 char option;
296 int key;
297 uint32_t policy = AGGR_POLICY_L4;
298 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
299 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
300 laadm_port_attr_db_t port[MAXPORT];
301 uint_t nport = 0;
302 uint8_t mac_addr[ETHERADDRL];
303 boolean_t mac_addr_fixed = B_FALSE;
304 boolean_t P_arg = B_FALSE;
305 boolean_t l_arg = B_FALSE;
306 boolean_t t_arg = B_FALSE;
307 boolean_t u_arg = B_FALSE;
308 boolean_t T_arg = B_FALSE;
309 char *altroot = NULL;
310 laadm_diag_t diag = 0;
279 char option;
280 int key;
281 uint32_t policy = AGGR_POLICY_L4;
282 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
283 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
284 dladm_aggr_port_attr_db_t port[MAXPORT];
285 uint_t nport = 0;
286 uint8_t mac_addr[ETHERADDRL];
287 boolean_t mac_addr_fixed = B_FALSE;
288 boolean_t P_arg = B_FALSE;
289 boolean_t l_arg = B_FALSE;
290 boolean_t t_arg = B_FALSE;
291 boolean_t u_arg = B_FALSE;
292 boolean_t T_arg = B_FALSE;
293 char *altroot = NULL;
294 dladm_status_t status;
311
312 opterr = 0;
313 while ((option = getopt_long(argc, argv, ":d:l:P:R:tu:T:",
314 longopts, NULL)) != -1) {
315 switch (option) {
316 case 'd':
317 if (nport >= MAXPORT)
318 die("too many <dev> arguments");

--- 4 unchanged lines hidden (view full) ---

323
324 nport++;
325 break;
326 case 'P':
327 if (P_arg)
328 die_optdup(option);
329
330 P_arg = B_TRUE;
295
296 opterr = 0;
297 while ((option = getopt_long(argc, argv, ":d:l:P:R:tu:T:",
298 longopts, NULL)) != -1) {
299 switch (option) {
300 case 'd':
301 if (nport >= MAXPORT)
302 die("too many <dev> arguments");

--- 4 unchanged lines hidden (view full) ---

307
308 nport++;
309 break;
310 case 'P':
311 if (P_arg)
312 die_optdup(option);
313
314 P_arg = B_TRUE;
331 if (!laadm_str_to_policy(optarg, &policy))
315 if (!dladm_aggr_str2policy(optarg, &policy))
332 die("invalid policy '%s'", optarg);
333 break;
334 case 'u':
335 if (u_arg)
336 die_optdup(option);
337
338 u_arg = B_TRUE;
316 die("invalid policy '%s'", optarg);
317 break;
318 case 'u':
319 if (u_arg)
320 die_optdup(option);
321
322 u_arg = B_TRUE;
339 if (!laadm_str_to_mac_addr(optarg, &mac_addr_fixed,
323 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
340 mac_addr))
341 die("invalid MAC address '%s'", optarg);
342 break;
343 case 'l':
344 if (l_arg)
345 die_optdup(option);
346
347 l_arg = B_TRUE;
324 mac_addr))
325 die("invalid MAC address '%s'", optarg);
326 break;
327 case 'l':
328 if (l_arg)
329 die_optdup(option);
330
331 l_arg = B_TRUE;
348 if (!laadm_str_to_lacp_mode(optarg, &lacp_mode))
332 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
349 die("invalid LACP mode '%s'", optarg);
350 break;
351 case 'T':
352 if (T_arg)
353 die_optdup(option);
354
355 T_arg = B_TRUE;
333 die("invalid LACP mode '%s'", optarg);
334 break;
335 case 'T':
336 if (T_arg)
337 die_optdup(option);
338
339 T_arg = B_TRUE;
356 if (!laadm_str_to_lacp_timer(optarg, &lacp_timer))
340 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
357 die("invalid LACP timer value '%s'", optarg);
358 break;
359 case 't':
360 t_arg = B_TRUE;
361 break;
362 case 'R':
363 altroot = optarg;
364 break;

--- 8 unchanged lines hidden (view full) ---

373
374 /* get key value (required last argument) */
375 if (optind != (argc-1))
376 usage();
377
378 if (!str2int(argv[optind], &key) || key < 1)
379 die("invalid key value '%s'", argv[optind]);
380
341 die("invalid LACP timer value '%s'", optarg);
342 break;
343 case 't':
344 t_arg = B_TRUE;
345 break;
346 case 'R':
347 altroot = optarg;
348 break;

--- 8 unchanged lines hidden (view full) ---

357
358 /* get key value (required last argument) */
359 if (optind != (argc-1))
360 usage();
361
362 if (!str2int(argv[optind], &key) || key < 1)
363 die("invalid key value '%s'", argv[optind]);
364
381 if (laadm_create(key, nport, port, policy, mac_addr_fixed,
382 mac_addr, lacp_mode, lacp_timer, t_arg, altroot, &diag) < 0)
383 die_laerr(diag, "create operation failed");
365 status = dladm_aggr_create(key, nport, port, policy, mac_addr_fixed,
366 mac_addr, lacp_mode, lacp_timer, t_arg, altroot);
367 if (status != DLADM_STATUS_OK)
368 die_dlerr(status, "create operation failed");
384}
385
386static void
387do_delete_aggr(int argc, char *argv[])
388{
389 int key;
390 char option;
391 boolean_t t_arg = B_FALSE;
392 char *altroot = NULL;
369}
370
371static void
372do_delete_aggr(int argc, char *argv[])
373{
374 int key;
375 char option;
376 boolean_t t_arg = B_FALSE;
377 char *altroot = NULL;
393 laadm_diag_t diag = 0;
378 dladm_status_t status;
394
395 opterr = 0;
396 while ((option = getopt_long(argc, argv, ":R:t", longopts,
397 NULL)) != -1) {
398 switch (option) {
399 case 't':
400 t_arg = B_TRUE;
401 break;

--- 8 unchanged lines hidden (view full) ---

410
411 /* get key value (required last argument) */
412 if (optind != (argc-1))
413 usage();
414
415 if (!str2int(argv[optind], &key) || key < 1)
416 die("invalid key value '%s'", argv[optind]);
417
379
380 opterr = 0;
381 while ((option = getopt_long(argc, argv, ":R:t", longopts,
382 NULL)) != -1) {
383 switch (option) {
384 case 't':
385 t_arg = B_TRUE;
386 break;

--- 8 unchanged lines hidden (view full) ---

395
396 /* get key value (required last argument) */
397 if (optind != (argc-1))
398 usage();
399
400 if (!str2int(argv[optind], &key) || key < 1)
401 die("invalid key value '%s'", argv[optind]);
402
418 if (laadm_delete(key, t_arg, altroot, &diag) < 0)
419 die_laerr(diag, "delete operation failed");
403 status = dladm_aggr_delete(key, t_arg, altroot);
404 if (status != DLADM_STATUS_OK)
405 die_dlerr(status, "delete operation failed");
420}
421
422static void
423do_add_aggr(int argc, char *argv[])
424{
406}
407
408static void
409do_add_aggr(int argc, char *argv[])
410{
425 char option;
426 int key;
427 laadm_port_attr_db_t port[MAXPORT];
428 uint_t nport = 0;
429 boolean_t t_arg = B_FALSE;
430 char *altroot = NULL;
431 laadm_diag_t diag = 0;
411 char option;
412 int key;
413 dladm_aggr_port_attr_db_t port[MAXPORT];
414 uint_t nport = 0;
415 boolean_t t_arg = B_FALSE;
416 char *altroot = NULL;
417 dladm_status_t status;
432
433 opterr = 0;
434 while ((option = getopt_long(argc, argv, ":d:R:t", longopts,
435 NULL)) != -1) {
436 switch (option) {
437 case 'd':
438 if (nport >= MAXPORT)
439 die("too many <dev> arguments");

--- 21 unchanged lines hidden (view full) ---

461
462 /* get key value (required last argument) */
463 if (optind != (argc-1))
464 usage();
465
466 if (!str2int(argv[optind], &key) || key < 1)
467 die("invalid key value '%s'", argv[optind]);
468
418
419 opterr = 0;
420 while ((option = getopt_long(argc, argv, ":d:R:t", longopts,
421 NULL)) != -1) {
422 switch (option) {
423 case 'd':
424 if (nport >= MAXPORT)
425 die("too many <dev> arguments");

--- 21 unchanged lines hidden (view full) ---

447
448 /* get key value (required last argument) */
449 if (optind != (argc-1))
450 usage();
451
452 if (!str2int(argv[optind], &key) || key < 1)
453 die("invalid key value '%s'", argv[optind]);
454
469 if (laadm_add(key, nport, port, t_arg, altroot, &diag) < 0) {
455 status = dladm_aggr_add(key, nport, port, t_arg, altroot);
456 if (status != DLADM_STATUS_OK) {
470 /*
457 /*
471 * checking ENOTSUP is a temporary workaround
458 * checking DLADM_STATUS_NOTSUP is a temporary workaround
472 * and should be removed once 6399681 is fixed.
473 */
459 * and should be removed once 6399681 is fixed.
460 */
474 if (errno == ENOTSUP) {
461 if (status == DLADM_STATUS_NOTSUP) {
475 (void) fprintf(stderr,
476 gettext("%s: add operation failed: %s\n"),
477 progname,
478 gettext("device capabilities don't match"));
479 exit(ENOTSUP);
480 }
462 (void) fprintf(stderr,
463 gettext("%s: add operation failed: %s\n"),
464 progname,
465 gettext("device capabilities don't match"));
466 exit(ENOTSUP);
467 }
481 die_laerr(diag, "add operation failed");
468 die_dlerr(status, "add operation failed");
482 }
483}
484
485static void
486do_remove_aggr(int argc, char *argv[])
487{
469 }
470}
471
472static void
473do_remove_aggr(int argc, char *argv[])
474{
488 char option;
489 int key;
490 laadm_port_attr_db_t port[MAXPORT];
491 uint_t nport = 0;
492 boolean_t t_arg = B_FALSE;
493 char *altroot = NULL;
494 laadm_diag_t diag = 0;
475 char option;
476 int key;
477 dladm_aggr_port_attr_db_t port[MAXPORT];
478 uint_t nport = 0;
479 boolean_t t_arg = B_FALSE;
480 char *altroot = NULL;
481 dladm_status_t status;
495
496 opterr = 0;
497 while ((option = getopt_long(argc, argv, ":d:R:t",
498 longopts, NULL)) != -1) {
499 switch (option) {
500 case 'd':
501 if (nport >= MAXPORT)
502 die("too many <dev> arguments");

--- 21 unchanged lines hidden (view full) ---

524
525 /* get key value (required last argument) */
526 if (optind != (argc-1))
527 usage();
528
529 if (!str2int(argv[optind], &key) || key < 1)
530 die("invalid key value '%s'", argv[optind]);
531
482
483 opterr = 0;
484 while ((option = getopt_long(argc, argv, ":d:R:t",
485 longopts, NULL)) != -1) {
486 switch (option) {
487 case 'd':
488 if (nport >= MAXPORT)
489 die("too many <dev> arguments");

--- 21 unchanged lines hidden (view full) ---

511
512 /* get key value (required last argument) */
513 if (optind != (argc-1))
514 usage();
515
516 if (!str2int(argv[optind], &key) || key < 1)
517 die("invalid key value '%s'", argv[optind]);
518
532 if (laadm_remove(key, nport, port, t_arg, altroot, &diag) < 0)
533 die_laerr(diag, "remove operation failed");
519 status = dladm_aggr_remove(key, nport, port, t_arg, altroot);
520 if (status != DLADM_STATUS_OK)
521 die_dlerr(status, "remove operation failed");
534}
535
536static void
537do_modify_aggr(int argc, char *argv[])
538{
539 char option;
540 int key;
541 uint32_t policy = AGGR_POLICY_L4;
542 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
543 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
544 uint8_t mac_addr[ETHERADDRL];
545 boolean_t mac_addr_fixed = B_FALSE;
546 uint8_t modify_mask = 0;
547 boolean_t t_arg = B_FALSE;
548 char *altroot = NULL;
522}
523
524static void
525do_modify_aggr(int argc, char *argv[])
526{
527 char option;
528 int key;
529 uint32_t policy = AGGR_POLICY_L4;
530 aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;
531 aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;
532 uint8_t mac_addr[ETHERADDRL];
533 boolean_t mac_addr_fixed = B_FALSE;
534 uint8_t modify_mask = 0;
535 boolean_t t_arg = B_FALSE;
536 char *altroot = NULL;
549 laadm_diag_t diag = 0;
537 dladm_status_t status;
550
551 opterr = 0;
552 while ((option = getopt_long(argc, argv, ":l:P:R:tu:T:", longopts,
553 NULL)) != -1) {
554 switch (option) {
555 case 'P':
538
539 opterr = 0;
540 while ((option = getopt_long(argc, argv, ":l:P:R:tu:T:", longopts,
541 NULL)) != -1) {
542 switch (option) {
543 case 'P':
556 if (modify_mask & LAADM_MODIFY_POLICY)
544 if (modify_mask & DLADM_AGGR_MODIFY_POLICY)
557 die_optdup(option);
558
545 die_optdup(option);
546
559 modify_mask |= LAADM_MODIFY_POLICY;
547 modify_mask |= DLADM_AGGR_MODIFY_POLICY;
560
548
561 if (!laadm_str_to_policy(optarg, &policy))
549 if (!dladm_aggr_str2policy(optarg, &policy))
562 die("invalid policy '%s'", optarg);
563 break;
564 case 'u':
550 die("invalid policy '%s'", optarg);
551 break;
552 case 'u':
565 if (modify_mask & LAADM_MODIFY_MAC)
553 if (modify_mask & DLADM_AGGR_MODIFY_MAC)
566 die_optdup(option);
567
554 die_optdup(option);
555
568 modify_mask |= LAADM_MODIFY_MAC;
556 modify_mask |= DLADM_AGGR_MODIFY_MAC;
569
557
570 if (!laadm_str_to_mac_addr(optarg, &mac_addr_fixed,
558 if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,
571 mac_addr))
572 die("invalid MAC address '%s'", optarg);
573 break;
574 case 'l':
559 mac_addr))
560 die("invalid MAC address '%s'", optarg);
561 break;
562 case 'l':
575 if (modify_mask & LAADM_MODIFY_LACP_MODE)
563 if (modify_mask & DLADM_AGGR_MODIFY_LACP_MODE)
576 die_optdup(option);
577
564 die_optdup(option);
565
578 modify_mask |= LAADM_MODIFY_LACP_MODE;
566 modify_mask |= DLADM_AGGR_MODIFY_LACP_MODE;
579
567
580 if (!laadm_str_to_lacp_mode(optarg, &lacp_mode))
568 if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))
581 die("invalid LACP mode '%s'", optarg);
582 break;
583 case 'T':
569 die("invalid LACP mode '%s'", optarg);
570 break;
571 case 'T':
584 if (modify_mask & LAADM_MODIFY_LACP_TIMER)
572 if (modify_mask & DLADM_AGGR_MODIFY_LACP_TIMER)
585 die_optdup(option);
586
573 die_optdup(option);
574
587 modify_mask |= LAADM_MODIFY_LACP_TIMER;
575 modify_mask |= DLADM_AGGR_MODIFY_LACP_TIMER;
588
576
589 if (!laadm_str_to_lacp_timer(optarg, &lacp_timer))
577 if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))
590 die("invalid LACP timer value '%s'", optarg);
591 break;
592 case 't':
593 t_arg = B_TRUE;
594 break;
595 case 'R':
596 altroot = optarg;
597 break;

--- 8 unchanged lines hidden (view full) ---

606
607 /* get key value (required last argument) */
608 if (optind != (argc-1))
609 usage();
610
611 if (!str2int(argv[optind], &key) || key < 1)
612 die("invalid key value '%s'", argv[optind]);
613
578 die("invalid LACP timer value '%s'", optarg);
579 break;
580 case 't':
581 t_arg = B_TRUE;
582 break;
583 case 'R':
584 altroot = optarg;
585 break;

--- 8 unchanged lines hidden (view full) ---

594
595 /* get key value (required last argument) */
596 if (optind != (argc-1))
597 usage();
598
599 if (!str2int(argv[optind], &key) || key < 1)
600 die("invalid key value '%s'", argv[optind]);
601
614 if (laadm_modify(key, modify_mask, policy, mac_addr_fixed, mac_addr,
615 lacp_mode, lacp_timer, t_arg, altroot, &diag) < 0)
616 die_laerr(diag, "modify operation failed");
602 status = dladm_aggr_modify(key, modify_mask, policy, mac_addr_fixed,
603 mac_addr, lacp_mode, lacp_timer, t_arg, altroot);
604 if (status != DLADM_STATUS_OK)
605 die_dlerr(status, "modify operation failed");
617}
618
619static void
620do_up_aggr(int argc, char *argv[])
621{
622 int key = 0;
606}
607
608static void
609do_up_aggr(int argc, char *argv[])
610{
611 int key = 0;
623 laadm_diag_t diag = 0;
612 dladm_status_t status;
624
625 /* get aggregation key (optional last argument) */
626 if (argc == 2) {
627 if (!str2int(argv[1], &key) || key < 1)
628 die("invalid key value '%s'", argv[1]);
629 } else if (argc > 2) {
630 usage();
631 }
632
613
614 /* get aggregation key (optional last argument) */
615 if (argc == 2) {
616 if (!str2int(argv[1], &key) || key < 1)
617 die("invalid key value '%s'", argv[1]);
618 } else if (argc > 2) {
619 usage();
620 }
621
633 if (laadm_up(key, NULL, &diag) < 0) {
622 if ((status = dladm_aggr_up(key, NULL)) != DLADM_STATUS_OK) {
634 if (key != 0) {
623 if (key != 0) {
635 die_laerr(diag, "could not bring up aggregation '%u'",
624 die_dlerr(status, "could not bring up aggregation '%u'",
636 key);
637 } else {
625 key);
626 } else {
638 die_laerr(diag, "could not bring aggregations up");
627 die_dlerr(status, "could not bring aggregations up");
639 }
640 }
641}
642
643static void
644do_down_aggr(int argc, char *argv[])
645{
628 }
629 }
630}
631
632static void
633do_down_aggr(int argc, char *argv[])
634{
646 int key = 0;
635 dladm_status_t status;
636 int key = 0;
647
648 /* get aggregation key (optional last argument) */
649 if (argc == 2) {
650 if (!str2int(argv[1], &key) || key < 1)
651 die("invalid key value '%s'", argv[1]);
652 } else if (argc > 2) {
653 usage();
654 }
655
637
638 /* get aggregation key (optional last argument) */
639 if (argc == 2) {
640 if (!str2int(argv[1], &key) || key < 1)
641 die("invalid key value '%s'", argv[1]);
642 } else if (argc > 2) {
643 usage();
644 }
645
656 if (laadm_down(key) < 0) {
646 if ((status = dladm_aggr_down(key)) != DLADM_STATUS_OK) {
657 if (key != 0) {
647 if (key != 0) {
658 die("could not bring down aggregation '%u': %s",
659 key, strerror(errno));
648 die_dlerr(status,
649 "could not bring down aggregation '%u'", key);
660 } else {
650 } else {
661 die("could not bring down aggregations: %s",
662 strerror(errno));
651 die_dlerr(status, "could not bring down aggregations");
663 }
664 }
665}
666
667#define TYPE_WIDTH 10
668
669static void
670print_link_parseable(const char *name, dladm_attr_t *dap, boolean_t legacy)

--- 143 unchanged lines hidden (view full) ---

814 (void) printf("%-10llu", diff_stats.opackets);
815 (void) printf("%-12llu", diff_stats.obytes);
816 (void) printf("%-8u\n", diff_stats.oerrors);
817
818 state->ls_prevstats = stats;
819}
820
821static void
652 }
653 }
654}
655
656#define TYPE_WIDTH 10
657
658static void
659print_link_parseable(const char *name, dladm_attr_t *dap, boolean_t legacy)

--- 143 unchanged lines hidden (view full) ---

803 (void) printf("%-10llu", diff_stats.opackets);
804 (void) printf("%-12llu", diff_stats.obytes);
805 (void) printf("%-8u\n", diff_stats.oerrors);
806
807 state->ls_prevstats = stats;
808}
809
810static void
822dump_grp(laadm_grp_attr_sys_t *grp, boolean_t parseable)
811dump_grp(dladm_aggr_grp_attr_t *grp, boolean_t parseable)
823{
812{
824 char policy_str[LAADM_POLICY_STR_LEN];
813 char buf[DLADM_STRSIZE];
825 char addr_str[ETHERADDRL * 3];
826
827 if (!parseable) {
828 (void) printf(gettext("key: %d (0x%04x)"),
829 grp->lg_key, grp->lg_key);
830
831 (void) printf(gettext("\tpolicy: %s"),
814 char addr_str[ETHERADDRL * 3];
815
816 if (!parseable) {
817 (void) printf(gettext("key: %d (0x%04x)"),
818 grp->lg_key, grp->lg_key);
819
820 (void) printf(gettext("\tpolicy: %s"),
832 laadm_policy_to_str(grp->lg_policy, policy_str));
821 dladm_aggr_policy2str(grp->lg_policy, buf));
833
834 (void) printf(gettext("\taddress: %s (%s)\n"),
822
823 (void) printf(gettext("\taddress: %s (%s)\n"),
835 laadm_mac_addr_to_str(grp->lg_mac, addr_str),
824 dladm_aggr_macaddr2str(grp->lg_mac, addr_str),
836 (grp->lg_mac_fixed) ? gettext("fixed") : gettext("auto"));
837 } else {
838 (void) printf("aggr key=%d", grp->lg_key);
839
840 (void) printf(" policy=%s",
825 (grp->lg_mac_fixed) ? gettext("fixed") : gettext("auto"));
826 } else {
827 (void) printf("aggr key=%d", grp->lg_key);
828
829 (void) printf(" policy=%s",
841 laadm_policy_to_str(grp->lg_policy, policy_str));
830 dladm_aggr_policy2str(grp->lg_policy, buf));
842
843 (void) printf(" address=%s",
831
832 (void) printf(" address=%s",
844 laadm_mac_addr_to_str(grp->lg_mac, addr_str));
833 dladm_aggr_macaddr2str(grp->lg_mac, addr_str));
845
846 (void) printf(" address-type=%s\n",
847 (grp->lg_mac_fixed) ? "fixed" : "auto");
848 }
849}
850
851static void
834
835 (void) printf(" address-type=%s\n",
836 (grp->lg_mac_fixed) ? "fixed" : "auto");
837 }
838}
839
840static void
852dump_grp_lacp(laadm_grp_attr_sys_t *grp, boolean_t parseable)
841dump_grp_lacp(dladm_aggr_grp_attr_t *grp, boolean_t parseable)
853{
842{
854 const char *lacp_mode_str = laadm_lacp_mode_to_str(grp->lg_lacp_mode);
855 const char *lacp_timer_str =
856 laadm_lacp_timer_to_str(grp->lg_lacp_timer);
843 char lacp_mode_str[DLADM_STRSIZE];
844 char lacp_timer_str[DLADM_STRSIZE];
857
845
846 (void) dladm_aggr_lacpmode2str(grp->lg_lacp_mode, lacp_mode_str);
847 (void) dladm_aggr_lacptimer2str(grp->lg_lacp_timer, lacp_timer_str);
848
858 if (!parseable) {
859 (void) printf(gettext("\t\tLACP mode: %s"), lacp_mode_str);
860 (void) printf(gettext("\tLACP timer: %s\n"), lacp_timer_str);
861 } else {
862 (void) printf(" lacp-mode=%s", lacp_mode_str);
863 (void) printf(" lacp-timer=%s\n", lacp_timer_str);
864 }
865}
866
867static void
849 if (!parseable) {
850 (void) printf(gettext("\t\tLACP mode: %s"), lacp_mode_str);
851 (void) printf(gettext("\tLACP timer: %s\n"), lacp_timer_str);
852 } else {
853 (void) printf(" lacp-mode=%s", lacp_mode_str);
854 (void) printf(" lacp-timer=%s\n", lacp_timer_str);
855 }
856}
857
858static void
868dump_grp_stats(laadm_grp_attr_sys_t *grp)
859dump_grp_stats(dladm_aggr_grp_attr_t *grp)
869{
870 (void) printf("key: %d", grp->lg_key);
871 (void) printf("\tipackets rbytes opackets obytes ");
872 (void) printf("%%ipkts %%opkts\n");
873}
874
875static void
876dump_ports_lacp_head(void)

--- 6 unchanged lines hidden (view full) ---

883
884static void
885dump_ports_head(void)
886{
887 (void) printf(gettext(" device\taddress\t\t speed\t\tduplex\tlink\t"
888 "state\n"));
889}
890
860{
861 (void) printf("key: %d", grp->lg_key);
862 (void) printf("\tipackets rbytes opackets obytes ");
863 (void) printf("%%ipkts %%opkts\n");
864}
865
866static void
867dump_ports_lacp_head(void)

--- 6 unchanged lines hidden (view full) ---

874
875static void
876dump_ports_head(void)
877{
878 (void) printf(gettext(" device\taddress\t\t speed\t\tduplex\tlink\t"
879 "state\n"));
880}
881
891static char *
892port_state_to_str(aggr_port_state_t state_num)
893{
894 int i;
895 port_state_t *state;
896
897 for (i = 0; i < NPORTSTATES; i++) {
898 state = &port_states[i];
899 if (state->state_num == state_num)
900 return (state->state_name);
901 }
902
903 return ("unknown");
904}
905
906static void
882static void
907dump_port(laadm_port_attr_sys_t *port, boolean_t parseable)
883dump_port(dladm_aggr_port_attr_t *port, boolean_t parseable)
908{
909 char *dev = port->lp_devname;
884{
885 char *dev = port->lp_devname;
910 char buf[ETHERADDRL * 3];
886 char mac_addr[ETHERADDRL * 3];
887 char buf[DLADM_STRSIZE];
911
912 if (!parseable) {
888
889 if (!parseable) {
913 (void) printf(" %-9s\t%s", dev, laadm_mac_addr_to_str(
914 port->lp_mac, buf));
890 (void) printf(" %-9s\t%s", dev, dladm_aggr_macaddr2str(
891 port->lp_mac, mac_addr));
915 (void) printf("\t %5uMb", (int)(mac_ifspeed(dev) /
916 1000000ull));
917 (void) printf("\t%s", mac_link_duplex(dev));
918 (void) printf("\t%s", mac_link_state(dev));
892 (void) printf("\t %5uMb", (int)(mac_ifspeed(dev) /
893 1000000ull));
894 (void) printf("\t%s", mac_link_duplex(dev));
895 (void) printf("\t%s", mac_link_state(dev));
919 (void) printf("\t%s\n", port_state_to_str(port->lp_state));
896 (void) printf("\t%s\n",
897 dladm_aggr_portstate2str(port->lp_state, buf));
920
921 } else {
922 (void) printf(" device=%s address=%s", dev,
898
899 } else {
900 (void) printf(" device=%s address=%s", dev,
923 laadm_mac_addr_to_str(port->lp_mac, buf));
901 dladm_aggr_macaddr2str(port->lp_mac, mac_addr));
924 (void) printf(" speed=%u", (int)(mac_ifspeed(dev) /
925 1000000ull));
926 (void) printf(" duplex=%s", mac_link_duplex(dev));
927 (void) printf(" link=%s", mac_link_state(dev));
902 (void) printf(" speed=%u", (int)(mac_ifspeed(dev) /
903 1000000ull));
904 (void) printf(" duplex=%s", mac_link_duplex(dev));
905 (void) printf(" link=%s", mac_link_state(dev));
928 (void) printf(" port=%s", port_state_to_str(port->lp_state));
906 (void) printf(" port=%s",
907 dladm_aggr_portstate2str(port->lp_state, buf));
929 }
930}
931
932static void
908 }
909}
910
911static void
933dump_port_lacp(laadm_port_attr_sys_t *port)
912dump_port_lacp(dladm_aggr_port_attr_t *port)
934{
935 aggr_lacp_state_t *state = &port->lp_lacp_state;
936
937 (void) printf(DUMP_LACP_FORMAT,
938 port->lp_devname, state->bit.activity ? "active" : "passive",
939 state->bit.timeout ? "short" : "long",
940 state->bit.aggregation ? "yes" : "no",
941 state->bit.sync ? "yes" : "no",

--- 30 unchanged lines hidden (view full) ---

972 (double)tot_stats->opackets * 100);
973
974 (void) printf("\n");
975
976 *old_stats = *port_stats;
977}
978
979static int
913{
914 aggr_lacp_state_t *state = &port->lp_lacp_state;
915
916 (void) printf(DUMP_LACP_FORMAT,
917 port->lp_devname, state->bit.activity ? "active" : "passive",
918 state->bit.timeout ? "short" : "long",
919 state->bit.aggregation ? "yes" : "no",
920 state->bit.sync ? "yes" : "no",

--- 30 unchanged lines hidden (view full) ---

951 (double)tot_stats->opackets * 100);
952
953 (void) printf("\n");
954
955 *old_stats = *port_stats;
956}
957
958static int
980show_key(void *arg, laadm_grp_attr_sys_t *grp)
959show_key(void *arg, dladm_aggr_grp_attr_t *grp)
981{
982 show_grp_state_t *state = (show_grp_state_t *)arg;
983 int i;
984 pktsum_t pktsumtot, port_stat;
985
986 if (state->gs_key != 0 && state->gs_key != grp->lg_key)
987 return (0);
988 if (state->gs_firstonly) {

--- 262 unchanged lines hidden (view full) ---

1251 if (s_arg) {
1252 aggr_stats(key, interval);
1253 return;
1254 }
1255
1256 state.gs_key = key;
1257 state.gs_found = B_FALSE;
1258
960{
961 show_grp_state_t *state = (show_grp_state_t *)arg;
962 int i;
963 pktsum_t pktsumtot, port_stat;
964
965 if (state->gs_key != 0 && state->gs_key != grp->lg_key)
966 return (0);
967 if (state->gs_firstonly) {

--- 262 unchanged lines hidden (view full) ---

1230 if (s_arg) {
1231 aggr_stats(key, interval);
1232 return;
1233 }
1234
1235 state.gs_key = key;
1236 state.gs_found = B_FALSE;
1237
1259 (void) laadm_walk_sys(show_key, &state);
1238 (void) dladm_aggr_walk(show_key, &state);
1260
1261 if (key != 0 && !state.gs_found)
1262 die("non-existent aggregation key '%u'", key);
1263}
1264
1265static void
1266do_show_dev(int argc, char *argv[])
1267{

--- 59 unchanged lines hidden (view full) ---

1327 }
1328
1329 if (s_arg) {
1330 dev_stats(dev, interval);
1331 return;
1332 }
1333
1334 if (dev == NULL)
1239
1240 if (key != 0 && !state.gs_found)
1241 die("non-existent aggregation key '%u'", key);
1242}
1243
1244static void
1245do_show_dev(int argc, char *argv[])
1246{

--- 59 unchanged lines hidden (view full) ---

1306 }
1307
1308 if (s_arg) {
1309 dev_stats(dev, interval);
1310 return;
1311 }
1312
1313 if (dev == NULL)
1335 (void) macadm_walk(show_dev, &state, B_TRUE);
1314 (void) dladm_mac_walk(show_dev, &state);
1336 else
1337 show_dev(&state, dev);
1338}
1339
1340/* ARGSUSED */
1341static void
1342link_stats(const char *link, uint_t interval)
1343{

--- 42 unchanged lines hidden (view full) ---

1386 /*
1387 * If an interval is specified, continuously show the stats
1388 * only for the first group.
1389 */
1390 state.gs_firstonly = (interval != 0);
1391
1392 for (;;) {
1393 state.gs_found = B_FALSE;
1315 else
1316 show_dev(&state, dev);
1317}
1318
1319/* ARGSUSED */
1320static void
1321link_stats(const char *link, uint_t interval)
1322{

--- 42 unchanged lines hidden (view full) ---

1365 /*
1366 * If an interval is specified, continuously show the stats
1367 * only for the first group.
1368 */
1369 state.gs_firstonly = (interval != 0);
1370
1371 for (;;) {
1372 state.gs_found = B_FALSE;
1394 (void) laadm_walk_sys(show_key, &state);
1373 (void) dladm_aggr_walk(show_key, &state);
1395 if (state.gs_key != 0 && !state.gs_found)
1396 die("non-existent aggregation key '%u'", key);
1397
1398 if (interval == 0)
1399 break;
1400
1401 (void) sleep(interval);
1402 }

--- 15 unchanged lines hidden (view full) ---

1418
1419 for (;;) {
1420
1421 (void) printf("\t\tipackets rbytes ierrors ");
1422 (void) printf("opackets obytes oerrors\n");
1423
1424 state.ms_donefirst = B_FALSE;
1425 if (dev == NULL)
1374 if (state.gs_key != 0 && !state.gs_found)
1375 die("non-existent aggregation key '%u'", key);
1376
1377 if (interval == 0)
1378 break;
1379
1380 (void) sleep(interval);
1381 }

--- 15 unchanged lines hidden (view full) ---

1397
1398 for (;;) {
1399
1400 (void) printf("\t\tipackets rbytes ierrors ");
1401 (void) printf("opackets obytes oerrors\n");
1402
1403 state.ms_donefirst = B_FALSE;
1404 if (dev == NULL)
1426 (void) macadm_walk(show_dev_stats, &state, B_TRUE);
1405 (void) dladm_mac_walk(show_dev_stats, &state);
1427 else
1428 show_dev_stats(&state, dev);
1429
1430 if (interval == 0)
1431 break;
1432
1433 (void) sleep(interval);
1434 }

--- 156 unchanged lines hidden (view full) ---

1591mac_ifspeed(const char *dev)
1592{
1593 uint64_t ifspeed = 0;
1594
1595 (void) get_single_mac_stat(dev, "ifspeed", KSTAT_DATA_UINT64, &ifspeed);
1596 return (ifspeed);
1597}
1598
1406 else
1407 show_dev_stats(&state, dev);
1408
1409 if (interval == 0)
1410 break;
1411
1412 (void) sleep(interval);
1413 }

--- 156 unchanged lines hidden (view full) ---

1570mac_ifspeed(const char *dev)
1571{
1572 uint64_t ifspeed = 0;
1573
1574 (void) get_single_mac_stat(dev, "ifspeed", KSTAT_DATA_UINT64, &ifspeed);
1575 return (ifspeed);
1576}
1577
1599static char *
1578static const char *
1600mac_link_state(const char *dev)
1601{
1602 link_state_t link_state;
1579mac_link_state(const char *dev)
1580{
1581 link_state_t link_state;
1603 char *state_str = "unknown";
1582 char buf[DLADM_STRSIZE];
1604
1605 if (get_single_mac_stat(dev, "link_state", KSTAT_DATA_UINT32,
1606 &link_state) != 0) {
1583
1584 if (get_single_mac_stat(dev, "link_state", KSTAT_DATA_UINT32,
1585 &link_state) != 0) {
1607 return (state_str);
1586 return ("unknown");
1608 }
1609
1587 }
1588
1610 switch (link_state) {
1611 case LINK_STATE_UP:
1612 state_str = "up";
1613 break;
1614 case LINK_STATE_DOWN:
1615 state_str = "down";
1616 break;
1617 default:
1618 break;
1619 }
1620
1621 return (state_str);
1589 return (dladm_linkstate2str(link_state, buf));
1622}
1623
1624
1590}
1591
1592
1625static char *
1593static const char *
1626mac_link_duplex(const char *dev)
1627{
1628 link_duplex_t link_duplex;
1594mac_link_duplex(const char *dev)
1595{
1596 link_duplex_t link_duplex;
1629 char *duplex_str = "unknown";
1597 char buf[DLADM_STRSIZE];
1630
1631 if (get_single_mac_stat(dev, "link_duplex", KSTAT_DATA_UINT32,
1632 &link_duplex) != 0) {
1598
1599 if (get_single_mac_stat(dev, "link_duplex", KSTAT_DATA_UINT32,
1600 &link_duplex) != 0) {
1633 return (duplex_str);
1601 return ("unknown");
1634 }
1635
1602 }
1603
1636 switch (link_duplex) {
1637 case LINK_DUPLEX_FULL:
1638 duplex_str = "full";
1639 break;
1640 case LINK_DUPLEX_HALF:
1641 duplex_str = "half";
1642 break;
1643 default:
1644 break;
1645 }
1646
1647 return (duplex_str);
1604 return (dladm_linkduplex2str(link_duplex, buf));
1648}
1649
1650#define WIFI_CMD_SCAN 0x00000001
1651#define WIFI_CMD_SHOW 0x00000002
1652#define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)
1653typedef struct wifi_field {
1654 const char *wf_name;
1655 const char *wf_header;
1656 uint_t wf_width;
1657 uint_t wf_mask;
1658 uint_t wf_cmdtype;
1659} wifi_field_t;
1660
1661static wifi_field_t wifi_fields[] = {
1605}
1606
1607#define WIFI_CMD_SCAN 0x00000001
1608#define WIFI_CMD_SHOW 0x00000002
1609#define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)
1610typedef struct wifi_field {
1611 const char *wf_name;
1612 const char *wf_header;
1613 uint_t wf_width;
1614 uint_t wf_mask;
1615 uint_t wf_cmdtype;
1616} wifi_field_t;
1617
1618static wifi_field_t wifi_fields[] = {
1662{ "link", "LINK", 10, 0, WIFI_CMD_ALL},
1663{ "essid", "ESSID", 19, WLADM_WLAN_ATTR_ESSID, WIFI_CMD_ALL},
1664{ "bssid", "BSSID/IBSSID", 17, WLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},
1665{ "ibssid", "BSSID/IBSSID", 17, WLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},
1666{ "mode", "MODE", 6, WLADM_WLAN_ATTR_MODE, WIFI_CMD_ALL},
1667{ "speed", "SPEED", 6, WLADM_WLAN_ATTR_SPEED, WIFI_CMD_ALL},
1668{ "auth", "AUTH", 8, WLADM_WLAN_ATTR_AUTH, WIFI_CMD_SHOW},
1669{ "bsstype", "BSSTYPE", 8, WLADM_WLAN_ATTR_BSSTYPE, WIFI_CMD_ALL},
1670{ "sec", "SEC", 6, WLADM_WLAN_ATTR_SECMODE, WIFI_CMD_ALL},
1671{ "status", "STATUS", 17, WLADM_LINK_ATTR_STATUS, WIFI_CMD_SHOW},
1672{ "strength", "STRENGTH", 10, WLADM_WLAN_ATTR_STRENGTH, WIFI_CMD_ALL}}
1619{ "link", "LINK", 10, 0, WIFI_CMD_ALL},
1620{ "essid", "ESSID", 19, DLADM_WLAN_ATTR_ESSID, WIFI_CMD_ALL},
1621{ "bssid", "BSSID/IBSSID", 17, DLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},
1622{ "ibssid", "BSSID/IBSSID", 17, DLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},
1623{ "mode", "MODE", 6, DLADM_WLAN_ATTR_MODE, WIFI_CMD_ALL},
1624{ "speed", "SPEED", 6, DLADM_WLAN_ATTR_SPEED, WIFI_CMD_ALL},
1625{ "auth", "AUTH", 8, DLADM_WLAN_ATTR_AUTH, WIFI_CMD_SHOW},
1626{ "bsstype", "BSSTYPE", 8, DLADM_WLAN_ATTR_BSSTYPE, WIFI_CMD_ALL},
1627{ "sec", "SEC", 6, DLADM_WLAN_ATTR_SECMODE, WIFI_CMD_ALL},
1628{ "status", "STATUS", 17, DLADM_WLAN_LINKATTR_STATUS, WIFI_CMD_SHOW},
1629{ "strength", "STRENGTH", 10, DLADM_WLAN_ATTR_STRENGTH, WIFI_CMD_ALL}}
1673;
1674
1675static char *all_scan_wifi_fields =
1676 "link,essid,bssid,sec,strength,mode,speed,bsstype";
1677static char *all_show_wifi_fields =
1678 "link,status,essid,sec,strength,mode,speed,auth,bssid,bsstype";
1679static char *def_scan_wifi_fields =
1680 "link,essid,bssid,sec,strength,mode,speed";

--- 167 unchanged lines hidden (view full) ---

1848 }
1849
1850 if (!statep->ws_lastfield)
1851 (void) putchar(' ');
1852}
1853
1854static void
1855print_wlan_attr(print_wifi_state_t *statep, wifi_field_t *wfp,
1630;
1631
1632static char *all_scan_wifi_fields =
1633 "link,essid,bssid,sec,strength,mode,speed,bsstype";
1634static char *all_show_wifi_fields =
1635 "link,status,essid,sec,strength,mode,speed,auth,bssid,bsstype";
1636static char *def_scan_wifi_fields =
1637 "link,essid,bssid,sec,strength,mode,speed";

--- 167 unchanged lines hidden (view full) ---

1805 }
1806
1807 if (!statep->ws_lastfield)
1808 (void) putchar(' ');
1809}
1810
1811static void
1812print_wlan_attr(print_wifi_state_t *statep, wifi_field_t *wfp,
1856 wladm_wlan_attr_t *attrp)
1813 dladm_wlan_attr_t *attrp)
1857{
1814{
1858 char buf[WLADM_STRSIZE];
1815 char buf[DLADM_STRSIZE];
1859 const char *str = "";
1860
1861 if (wfp->wf_mask == 0) {
1862 print_wifi_field(statep, wfp, statep->ws_link);
1863 return;
1864 }
1865
1866 if ((wfp->wf_mask & attrp->wa_valid) == 0) {
1867 print_wifi_field(statep, wfp, "");
1868 return;
1869 }
1870
1871 switch (wfp->wf_mask) {
1816 const char *str = "";
1817
1818 if (wfp->wf_mask == 0) {
1819 print_wifi_field(statep, wfp, statep->ws_link);
1820 return;
1821 }
1822
1823 if ((wfp->wf_mask & attrp->wa_valid) == 0) {
1824 print_wifi_field(statep, wfp, "");
1825 return;
1826 }
1827
1828 switch (wfp->wf_mask) {
1872 case WLADM_WLAN_ATTR_ESSID:
1873 str = wladm_essid2str(&attrp->wa_essid, buf);
1829 case DLADM_WLAN_ATTR_ESSID:
1830 str = dladm_wlan_essid2str(&attrp->wa_essid, buf);
1874 break;
1831 break;
1875 case WLADM_WLAN_ATTR_BSSID:
1876 str = wladm_bssid2str(&attrp->wa_bssid, buf);
1832 case DLADM_WLAN_ATTR_BSSID:
1833 str = dladm_wlan_bssid2str(&attrp->wa_bssid, buf);
1877 break;
1834 break;
1878 case WLADM_WLAN_ATTR_SECMODE:
1879 str = wladm_secmode2str(&attrp->wa_secmode, buf);
1835 case DLADM_WLAN_ATTR_SECMODE:
1836 str = dladm_wlan_secmode2str(&attrp->wa_secmode, buf);
1880 break;
1837 break;
1881 case WLADM_WLAN_ATTR_STRENGTH:
1882 str = wladm_strength2str(&attrp->wa_strength, buf);
1838 case DLADM_WLAN_ATTR_STRENGTH:
1839 str = dladm_wlan_strength2str(&attrp->wa_strength, buf);
1883 break;
1840 break;
1884 case WLADM_WLAN_ATTR_MODE:
1885 str = wladm_mode2str(&attrp->wa_mode, buf);
1841 case DLADM_WLAN_ATTR_MODE:
1842 str = dladm_wlan_mode2str(&attrp->wa_mode, buf);
1886 break;
1843 break;
1887 case WLADM_WLAN_ATTR_SPEED:
1888 str = wladm_speed2str(&attrp->wa_speed, buf);
1844 case DLADM_WLAN_ATTR_SPEED:
1845 str = dladm_wlan_speed2str(&attrp->wa_speed, buf);
1889 (void) strlcat(buf, "Mb", sizeof (buf));
1890 break;
1846 (void) strlcat(buf, "Mb", sizeof (buf));
1847 break;
1891 case WLADM_WLAN_ATTR_AUTH:
1892 str = wladm_auth2str(&attrp->wa_auth, buf);
1848 case DLADM_WLAN_ATTR_AUTH:
1849 str = dladm_wlan_auth2str(&attrp->wa_auth, buf);
1893 break;
1850 break;
1894 case WLADM_WLAN_ATTR_BSSTYPE:
1895 str = wladm_bsstype2str(&attrp->wa_bsstype, buf);
1851 case DLADM_WLAN_ATTR_BSSTYPE:
1852 str = dladm_wlan_bsstype2str(&attrp->wa_bsstype, buf);
1896 break;
1897 }
1898
1899 print_wifi_field(statep, wfp, str);
1900}
1901
1902static boolean_t
1853 break;
1854 }
1855
1856 print_wifi_field(statep, wfp, str);
1857}
1858
1859static boolean_t
1903print_scan_results(void *arg, wladm_wlan_attr_t *attrp)
1860print_scan_results(void *arg, dladm_wlan_attr_t *attrp)
1904{
1905 print_wifi_state_t *statep = arg;
1906 int i;
1907
1908 if (statep->ws_header) {
1909 statep->ws_header = B_FALSE;
1910 if (!statep->ws_parseable)
1911 print_wifi_head(statep);

--- 7 unchanged lines hidden (view full) ---

1919 (void) putchar('\n');
1920 return (B_TRUE);
1921}
1922
1923static boolean_t
1924scan_wifi(void *arg, const char *link)
1925{
1926 print_wifi_state_t *statep = arg;
1861{
1862 print_wifi_state_t *statep = arg;
1863 int i;
1864
1865 if (statep->ws_header) {
1866 statep->ws_header = B_FALSE;
1867 if (!statep->ws_parseable)
1868 print_wifi_head(statep);

--- 7 unchanged lines hidden (view full) ---

1876 (void) putchar('\n');
1877 return (B_TRUE);
1878}
1879
1880static boolean_t
1881scan_wifi(void *arg, const char *link)
1882{
1883 print_wifi_state_t *statep = arg;
1927 wladm_status_t status;
1884 dladm_status_t status;
1928
1929 statep->ws_link = link;
1885
1886 statep->ws_link = link;
1930 status = wladm_scan(link, statep, print_scan_results);
1931 if (status != WLADM_STATUS_OK)
1932 die_wlerr(status, "cannot scan link '%s'", link);
1887 status = dladm_wlan_scan(link, statep, print_scan_results);
1888 if (status != DLADM_STATUS_OK)
1889 die_dlerr(status, "cannot scan link '%s'", link);
1933
1934 return (B_TRUE);
1935}
1936
1937static void
1938print_link_attr(print_wifi_state_t *statep, wifi_field_t *wfp,
1890
1891 return (B_TRUE);
1892}
1893
1894static void
1895print_link_attr(print_wifi_state_t *statep, wifi_field_t *wfp,
1939 wladm_link_attr_t *attrp)
1896 dladm_wlan_linkattr_t *attrp)
1940{
1897{
1941 char buf[WLADM_STRSIZE];
1898 char buf[DLADM_STRSIZE];
1942 const char *str = "";
1943
1944 if (strcmp(wfp->wf_name, "status") == 0) {
1945 if ((wfp->wf_mask & attrp->la_valid) != 0)
1899 const char *str = "";
1900
1901 if (strcmp(wfp->wf_name, "status") == 0) {
1902 if ((wfp->wf_mask & attrp->la_valid) != 0)
1946 str = wladm_linkstatus2str(&attrp->la_status, buf);
1903 str = dladm_wlan_linkstatus2str(&attrp->la_status, buf);
1947 print_wifi_field(statep, wfp, str);
1948 return;
1949 }
1950 print_wlan_attr(statep, wfp, &attrp->la_wlan_attr);
1951}
1952
1953static boolean_t
1954show_wifi(void *arg, const char *link)
1955{
1956 int i;
1957 print_wifi_state_t *statep = arg;
1904 print_wifi_field(statep, wfp, str);
1905 return;
1906 }
1907 print_wlan_attr(statep, wfp, &attrp->la_wlan_attr);
1908}
1909
1910static boolean_t
1911show_wifi(void *arg, const char *link)
1912{
1913 int i;
1914 print_wifi_state_t *statep = arg;
1958 wladm_link_attr_t attr;
1959 wladm_status_t status;
1915 dladm_wlan_linkattr_t attr;
1916 dladm_status_t status;
1960
1917
1961 status = wladm_get_link_attr(link, &attr);
1962 if (status != WLADM_STATUS_OK)
1963 die_wlerr(status, "cannot get link attributes for '%s'", link);
1918 status = dladm_wlan_get_linkattr(link, &attr);
1919 if (status != DLADM_STATUS_OK)
1920 die_dlerr(status, "cannot get link attributes for '%s'", link);
1964
1965 if (statep->ws_header) {
1966 statep->ws_header = B_FALSE;
1967 if (!statep->ws_parseable)
1968 print_wifi_head(statep);
1969 }
1970
1971 statep->ws_link = link;

--- 10 unchanged lines hidden (view full) ---

1982do_display_wifi(int argc, char **argv, int cmd)
1983{
1984 int option;
1985 char *fields_str = NULL;
1986 wifi_field_t **fields;
1987 boolean_t (*callback)(void *, const char *);
1988 uint_t nfields;
1989 print_wifi_state_t state;
1921
1922 if (statep->ws_header) {
1923 statep->ws_header = B_FALSE;
1924 if (!statep->ws_parseable)
1925 print_wifi_head(statep);
1926 }
1927
1928 statep->ws_link = link;

--- 10 unchanged lines hidden (view full) ---

1939do_display_wifi(int argc, char **argv, int cmd)
1940{
1941 int option;
1942 char *fields_str = NULL;
1943 wifi_field_t **fields;
1944 boolean_t (*callback)(void *, const char *);
1945 uint_t nfields;
1946 print_wifi_state_t state;
1990 wladm_status_t status;
1947 dladm_status_t status;
1991
1992 if (cmd == WIFI_CMD_SCAN)
1993 callback = scan_wifi;
1994 else if (cmd == WIFI_CMD_SHOW)
1995 callback = show_wifi;
1996 else
1997 return;
1998

--- 25 unchanged lines hidden (view full) ---

2024
2025 if (parse_wifi_fields(fields_str, &fields, &nfields, cmd) < 0)
2026 die("invalid field(s) specified");
2027
2028 state.ws_fields = fields;
2029 state.ws_nfields = nfields;
2030
2031 if (state.ws_link == NULL) {
1948
1949 if (cmd == WIFI_CMD_SCAN)
1950 callback = scan_wifi;
1951 else if (cmd == WIFI_CMD_SHOW)
1952 callback = show_wifi;
1953 else
1954 return;
1955

--- 25 unchanged lines hidden (view full) ---

1981
1982 if (parse_wifi_fields(fields_str, &fields, &nfields, cmd) < 0)
1983 die("invalid field(s) specified");
1984
1985 state.ws_fields = fields;
1986 state.ws_nfields = nfields;
1987
1988 if (state.ws_link == NULL) {
2032 status = wladm_walk(&state, callback);
2033 if (status != WLADM_STATUS_OK)
2034 die_wlerr(status, "cannot walk wifi links");
1989 status = dladm_wlan_walk(&state, callback);
1990 if (status != DLADM_STATUS_OK)
1991 die_dlerr(status, "cannot walk wifi links");
2035 } else {
2036 (void) (*callback)(&state, state.ws_link);
2037 }
2038 free(fields);
2039}
2040
2041static void
2042do_scan_wifi(int argc, char **argv)

--- 19 unchanged lines hidden (view full) ---

2062
2063 if (cp->wc_count == 0)
2064 cp->wc_link = strdup(link);
2065 cp->wc_count++;
2066 return (B_TRUE);
2067}
2068
2069static int
1992 } else {
1993 (void) (*callback)(&state, state.ws_link);
1994 }
1995 free(fields);
1996}
1997
1998static void
1999do_scan_wifi(int argc, char **argv)

--- 19 unchanged lines hidden (view full) ---

2019
2020 if (cp->wc_count == 0)
2021 cp->wc_link = strdup(link);
2022 cp->wc_count++;
2023 return (B_TRUE);
2024}
2025
2026static int
2070parse_wep_keys(char *str, wladm_wep_key_t **keys, uint_t *key_countp)
2027parse_wep_keys(char *str, dladm_wlan_wepkey_t **keys, uint_t *key_countp)
2071{
2028{
2072 uint_t i;
2073 split_t *sp;
2074 wladm_wep_key_t *wk;
2029 uint_t i;
2030 split_t *sp;
2031 dladm_wlan_wepkey_t *wk;
2075
2032
2076 sp = split(str, WLADM_MAX_WEPKEYS, WLADM_MAX_WEPKEYNAME_LEN);
2033 sp = split(str, DLADM_WLAN_MAX_WEPKEYS, DLADM_WLAN_MAX_WEPKEYNAME_LEN);
2077 if (sp == NULL)
2078 return (-1);
2079
2034 if (sp == NULL)
2035 return (-1);
2036
2080 wk = malloc(sp->s_nfields * sizeof (wladm_wep_key_t));
2037 wk = malloc(sp->s_nfields * sizeof (dladm_wlan_wepkey_t));
2081 if (wk == NULL)
2082 goto fail;
2083
2084 for (i = 0; i < sp->s_nfields; i++) {
2085 char *s;
2086 dladm_secobj_class_t class;
2087 dladm_status_t status;
2088
2089 (void) strlcpy(wk[i].wk_name, sp->s_fields[i],
2038 if (wk == NULL)
2039 goto fail;
2040
2041 for (i = 0; i < sp->s_nfields; i++) {
2042 char *s;
2043 dladm_secobj_class_t class;
2044 dladm_status_t status;
2045
2046 (void) strlcpy(wk[i].wk_name, sp->s_fields[i],
2090 WLADM_MAX_WEPKEYNAME_LEN);
2047 DLADM_WLAN_MAX_WEPKEYNAME_LEN);
2091
2092 wk[i].wk_idx = 1;
2093 if ((s = strrchr(wk[i].wk_name, ':')) != NULL) {
2094 if (s[1] == '\0' || s[2] != '\0' || !isdigit(s[1]))
2095 goto fail;
2096
2097 wk[i].wk_idx = (uint_t)(s[1] - '0');
2098 *s = '\0';
2099 }
2048
2049 wk[i].wk_idx = 1;
2050 if ((s = strrchr(wk[i].wk_name, ':')) != NULL) {
2051 if (s[1] == '\0' || s[2] != '\0' || !isdigit(s[1]))
2052 goto fail;
2053
2054 wk[i].wk_idx = (uint_t)(s[1] - '0');
2055 *s = '\0';
2056 }
2100 wk[i].wk_len = WLADM_MAX_WEPKEY_LEN;
2057 wk[i].wk_len = DLADM_WLAN_MAX_WEPKEY_LEN;
2101
2102 status = dladm_get_secobj(wk[i].wk_name, &class,
2103 wk[i].wk_val, &wk[i].wk_len, 0);
2104 if (status != DLADM_STATUS_OK) {
2105 if (status == DLADM_STATUS_NOTFOUND) {
2106 status = dladm_get_secobj(wk[i].wk_name,
2107 &class, wk[i].wk_val, &wk[i].wk_len,
2108 DLADM_OPT_PERSIST);

--- 11 unchanged lines hidden (view full) ---

2120 splitfree(sp);
2121 return (-1);
2122}
2123
2124static void
2125do_connect_wifi(int argc, char **argv)
2126{
2127 int option;
2058
2059 status = dladm_get_secobj(wk[i].wk_name, &class,
2060 wk[i].wk_val, &wk[i].wk_len, 0);
2061 if (status != DLADM_STATUS_OK) {
2062 if (status == DLADM_STATUS_NOTFOUND) {
2063 status = dladm_get_secobj(wk[i].wk_name,
2064 &class, wk[i].wk_val, &wk[i].wk_len,
2065 DLADM_OPT_PERSIST);

--- 11 unchanged lines hidden (view full) ---

2077 splitfree(sp);
2078 return (-1);
2079}
2080
2081static void
2082do_connect_wifi(int argc, char **argv)
2083{
2084 int option;
2128 wladm_wlan_attr_t attr, *attrp;
2129 wladm_status_t status = WLADM_STATUS_OK;
2130 int timeout = WLADM_CONNECT_TIMEOUT_DEFAULT;
2085 dladm_wlan_attr_t attr, *attrp;
2086 dladm_status_t status = DLADM_STATUS_OK;
2087 int timeout = DLADM_WLAN_CONNECT_TIMEOUT_DEFAULT;
2131 const char *link = NULL;
2088 const char *link = NULL;
2132 wladm_wep_key_t *keys = NULL;
2089 dladm_wlan_wepkey_t *keys = NULL;
2133 uint_t key_count = 0;
2134 uint_t flags = 0;
2090 uint_t key_count = 0;
2091 uint_t flags = 0;
2135 wladm_secmode_t keysecmode = WLADM_SECMODE_NONE;
2092 dladm_wlan_secmode_t keysecmode = DLADM_WLAN_SECMODE_NONE;
2136
2137 opterr = 0;
2138 (void) memset(&attr, 0, sizeof (attr));
2139 while ((option = getopt_long(argc, argv, ":e:i:a:m:b:s:k:T:c",
2140 wifi_longopts, NULL)) != -1) {
2141 switch (option) {
2142 case 'e':
2093
2094 opterr = 0;
2095 (void) memset(&attr, 0, sizeof (attr));
2096 while ((option = getopt_long(argc, argv, ":e:i:a:m:b:s:k:T:c",
2097 wifi_longopts, NULL)) != -1) {
2098 switch (option) {
2099 case 'e':
2143 status = wladm_str2essid(optarg, &attr.wa_essid);
2144 if (status != WLADM_STATUS_OK)
2100 status = dladm_wlan_str2essid(optarg, &attr.wa_essid);
2101 if (status != DLADM_STATUS_OK)
2145 die("invalid ESSID '%s'", optarg);
2146
2102 die("invalid ESSID '%s'", optarg);
2103
2147 attr.wa_valid |= WLADM_WLAN_ATTR_ESSID;
2104 attr.wa_valid |= DLADM_WLAN_ATTR_ESSID;
2148 /*
2149 * Try to connect without doing a scan.
2150 */
2105 /*
2106 * Try to connect without doing a scan.
2107 */
2151 flags |= WLADM_OPT_NOSCAN;
2108 flags |= DLADM_WLAN_CONNECT_NOSCAN;
2152 break;
2153 case 'i':
2109 break;
2110 case 'i':
2154 status = wladm_str2bssid(optarg, &attr.wa_bssid);
2155 if (status != WLADM_STATUS_OK)
2111 status = dladm_wlan_str2bssid(optarg, &attr.wa_bssid);
2112 if (status != DLADM_STATUS_OK)
2156 die("invalid BSSID %s", optarg);
2157
2113 die("invalid BSSID %s", optarg);
2114
2158 attr.wa_valid |= WLADM_WLAN_ATTR_BSSID;
2115 attr.wa_valid |= DLADM_WLAN_ATTR_BSSID;
2159 break;
2160 case 'a':
2116 break;
2117 case 'a':
2161 status = wladm_str2auth(optarg, &attr.wa_auth);
2162 if (status != WLADM_STATUS_OK)
2118 status = dladm_wlan_str2auth(optarg, &attr.wa_auth);
2119 if (status != DLADM_STATUS_OK)
2163 die("invalid authentication mode '%s'", optarg);
2164
2120 die("invalid authentication mode '%s'", optarg);
2121
2165 attr.wa_valid |= WLADM_WLAN_ATTR_AUTH;
2122 attr.wa_valid |= DLADM_WLAN_ATTR_AUTH;
2166 break;
2167 case 'm':
2123 break;
2124 case 'm':
2168 status = wladm_str2mode(optarg, &attr.wa_mode);
2169 if (status != WLADM_STATUS_OK)
2125 status = dladm_wlan_str2mode(optarg, &attr.wa_mode);
2126 if (status != DLADM_STATUS_OK)
2170 die("invalid mode '%s'", optarg);
2171
2127 die("invalid mode '%s'", optarg);
2128
2172 attr.wa_valid |= WLADM_WLAN_ATTR_MODE;
2129 attr.wa_valid |= DLADM_WLAN_ATTR_MODE;
2173 break;
2174 case 'b':
2130 break;
2131 case 'b':
2175 status = wladm_str2bsstype(optarg, &attr.wa_bsstype);
2176 if (status != WLADM_STATUS_OK)
2132 if ((status = dladm_wlan_str2bsstype(optarg,
2133 &attr.wa_bsstype)) != DLADM_STATUS_OK) {
2177 die("invalid bsstype '%s'", optarg);
2134 die("invalid bsstype '%s'", optarg);
2135 }
2178
2136
2179 attr.wa_valid |= WLADM_WLAN_ATTR_BSSTYPE;
2137 attr.wa_valid |= DLADM_WLAN_ATTR_BSSTYPE;
2180 break;
2181 case 's':
2138 break;
2139 case 's':
2182 status = wladm_str2secmode(optarg, &attr.wa_secmode);
2183 if (status != WLADM_STATUS_OK)
2140 if ((status = dladm_wlan_str2secmode(optarg,
2141 &attr.wa_secmode)) != DLADM_STATUS_OK) {
2184 die("invalid security mode '%s'", optarg);
2142 die("invalid security mode '%s'", optarg);
2143 }
2185
2144
2186 attr.wa_valid |= WLADM_WLAN_ATTR_SECMODE;
2145 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
2187 break;
2188 case 'k':
2189 if (parse_wep_keys(optarg, &keys, &key_count) < 0)
2190 die("invalid key(s) '%s'", optarg);
2191
2146 break;
2147 case 'k':
2148 if (parse_wep_keys(optarg, &keys, &key_count) < 0)
2149 die("invalid key(s) '%s'", optarg);
2150
2192 keysecmode = WLADM_SECMODE_WEP;
2151 keysecmode = DLADM_WLAN_SECMODE_WEP;
2193 break;
2194 case 'T':
2195 if (strcasecmp(optarg, "forever") == 0) {
2196 timeout = -1;
2197 break;
2198 }
2199 if (!str2int(optarg, &timeout) || timeout < 0)
2200 die("invalid timeout value '%s'", optarg);
2201 break;
2202 case 'c':
2152 break;
2153 case 'T':
2154 if (strcasecmp(optarg, "forever") == 0) {
2155 timeout = -1;
2156 break;
2157 }
2158 if (!str2int(optarg, &timeout) || timeout < 0)
2159 die("invalid timeout value '%s'", optarg);
2160 break;
2161 case 'c':
2203 flags |= WLADM_OPT_CREATEIBSS;
2162 flags |= DLADM_WLAN_CONNECT_CREATEIBSS;
2204 break;
2205 default:
2206 die_opterr(optopt, option);
2207 break;
2208 }
2209 }
2210
2163 break;
2164 default:
2165 die_opterr(optopt, option);
2166 break;
2167 }
2168 }
2169
2211 if (keysecmode == WLADM_SECMODE_NONE) {
2212 if ((attr.wa_valid & WLADM_WLAN_ATTR_SECMODE) != 0 &&
2213 attr.wa_secmode == WLADM_SECMODE_WEP)
2170 if (keysecmode == DLADM_WLAN_SECMODE_NONE) {
2171 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0 &&
2172 attr.wa_secmode == DLADM_WLAN_SECMODE_WEP)
2214 die("key required for security mode 'wep'");
2215 } else {
2173 die("key required for security mode 'wep'");
2174 } else {
2216 if ((attr.wa_valid & WLADM_WLAN_ATTR_SECMODE) != 0 &&
2175 if ((attr.wa_valid & DLADM_WLAN_ATTR_SECMODE) != 0 &&
2217 attr.wa_secmode != keysecmode)
2218 die("incompatible -s and -k options");
2219 }
2220 attr.wa_secmode = keysecmode;
2176 attr.wa_secmode != keysecmode)
2177 die("incompatible -s and -k options");
2178 }
2179 attr.wa_secmode = keysecmode;
2221 attr.wa_valid |= WLADM_WLAN_ATTR_SECMODE;
2180 attr.wa_valid |= DLADM_WLAN_ATTR_SECMODE;
2222
2223 if (optind == (argc - 1))
2224 link = argv[optind];
2225 else if (optind != argc)
2226 usage();
2227
2228 if (link == NULL) {
2229 wlan_count_attr_t wcattr;
2230
2231 wcattr.wc_link = NULL;
2232 wcattr.wc_count = 0;
2181
2182 if (optind == (argc - 1))
2183 link = argv[optind];
2184 else if (optind != argc)
2185 usage();
2186
2187 if (link == NULL) {
2188 wlan_count_attr_t wcattr;
2189
2190 wcattr.wc_link = NULL;
2191 wcattr.wc_count = 0;
2233 (void) wladm_walk(&wcattr, do_count_wlan);
2192 (void) dladm_wlan_walk(&wcattr, do_count_wlan);
2234 if (wcattr.wc_count == 0) {
2235 die("no wifi links are available");
2236 } else if (wcattr.wc_count > 1) {
2237 die("link name is required when more than one wifi "
2238 "link is available");
2239 }
2240 link = wcattr.wc_link;
2241 }
2242 attrp = (attr.wa_valid == 0) ? NULL : &attr;
2243again:
2193 if (wcattr.wc_count == 0) {
2194 die("no wifi links are available");
2195 } else if (wcattr.wc_count > 1) {
2196 die("link name is required when more than one wifi "
2197 "link is available");
2198 }
2199 link = wcattr.wc_link;
2200 }
2201 attrp = (attr.wa_valid == 0) ? NULL : &attr;
2202again:
2244 status = wladm_connect(link, attrp, timeout, keys, key_count, flags);
2245 if (status != WLADM_STATUS_OK) {
2246 if ((flags & WLADM_OPT_NOSCAN) != 0) {
2203 if ((status = dladm_wlan_connect(link, attrp, timeout, keys,
2204 key_count, flags)) != DLADM_STATUS_OK) {
2205 if ((flags & DLADM_WLAN_CONNECT_NOSCAN) != 0) {
2247 /*
2248 * Try again with scanning and filtering.
2249 */
2206 /*
2207 * Try again with scanning and filtering.
2208 */
2250 flags &= ~WLADM_OPT_NOSCAN;
2209 flags &= ~DLADM_WLAN_CONNECT_NOSCAN;
2251 goto again;
2252 }
2253
2210 goto again;
2211 }
2212
2254 if (status == WLADM_STATUS_NOTFOUND) {
2213 if (status == DLADM_STATUS_NOTFOUND) {
2255 if (attr.wa_valid == 0) {
2256 die("no wifi networks are available");
2257 } else {
2258 die("no wifi networks with the specified "
2259 "criteria are available");
2260 }
2261 }
2214 if (attr.wa_valid == 0) {
2215 die("no wifi networks are available");
2216 } else {
2217 die("no wifi networks with the specified "
2218 "criteria are available");
2219 }
2220 }
2262 die_wlerr(status, "cannot connect link '%s'", link);
2221 die_dlerr(status, "cannot connect link '%s'", link);
2263 }
2264 free(keys);
2265}
2266
2267/* ARGSUSED */
2268static boolean_t
2269do_all_disconnect_wifi(void *arg, const char *link)
2270{
2222 }
2223 free(keys);
2224}
2225
2226/* ARGSUSED */
2227static boolean_t
2228do_all_disconnect_wifi(void *arg, const char *link)
2229{
2271 wladm_status_t status;
2230 dladm_status_t status;
2272
2231
2273 status = wladm_disconnect(link);
2274 if (status != WLADM_STATUS_OK)
2275 warn_wlerr(status, "cannot disconnect link '%s'", link);
2232 status = dladm_wlan_disconnect(link);
2233 if (status != DLADM_STATUS_OK)
2234 warn_dlerr(status, "cannot disconnect link '%s'", link);
2276
2277 return (B_TRUE);
2278}
2279
2280static void
2281do_disconnect_wifi(int argc, char **argv)
2282{
2283 int option;
2284 const char *link = NULL;
2285 boolean_t all_links = B_FALSE;
2235
2236 return (B_TRUE);
2237}
2238
2239static void
2240do_disconnect_wifi(int argc, char **argv)
2241{
2242 int option;
2243 const char *link = NULL;
2244 boolean_t all_links = B_FALSE;
2286 wladm_status_t status;
2245 dladm_status_t status;
2287 wlan_count_attr_t wcattr;
2288
2289 opterr = 0;
2290 while ((option = getopt_long(argc, argv, ":a",
2291 wifi_longopts, NULL)) != -1) {
2292 switch (option) {
2293 case 'a':
2294 all_links = B_TRUE;

--- 8 unchanged lines hidden (view full) ---

2303 link = argv[optind];
2304 else if (optind != argc)
2305 usage();
2306
2307 if (link == NULL) {
2308 if (!all_links) {
2309 wcattr.wc_link = NULL;
2310 wcattr.wc_count = 0;
2246 wlan_count_attr_t wcattr;
2247
2248 opterr = 0;
2249 while ((option = getopt_long(argc, argv, ":a",
2250 wifi_longopts, NULL)) != -1) {
2251 switch (option) {
2252 case 'a':
2253 all_links = B_TRUE;

--- 8 unchanged lines hidden (view full) ---

2262 link = argv[optind];
2263 else if (optind != argc)
2264 usage();
2265
2266 if (link == NULL) {
2267 if (!all_links) {
2268 wcattr.wc_link = NULL;
2269 wcattr.wc_count = 0;
2311 (void) wladm_walk(&wcattr, do_count_wlan);
2270 (void) dladm_wlan_walk(&wcattr, do_count_wlan);
2312 if (wcattr.wc_count == 0) {
2313 die("no wifi links are available");
2314 } else if (wcattr.wc_count > 1) {
2315 die("link name is required when more than "
2316 "one wifi link is available");
2317 }
2318 link = wcattr.wc_link;
2319 } else {
2271 if (wcattr.wc_count == 0) {
2272 die("no wifi links are available");
2273 } else if (wcattr.wc_count > 1) {
2274 die("link name is required when more than "
2275 "one wifi link is available");
2276 }
2277 link = wcattr.wc_link;
2278 } else {
2320 (void) wladm_walk(&all_links, do_all_disconnect_wifi);
2279 (void) dladm_wlan_walk(&all_links,
2280 do_all_disconnect_wifi);
2321 return;
2322 }
2323 }
2281 return;
2282 }
2283 }
2324 status = wladm_disconnect(link);
2325 if (status != WLADM_STATUS_OK)
2326 die_wlerr(status, "cannot disconnect link '%s'", link);
2284 status = dladm_wlan_disconnect(link);
2285 if (status != DLADM_STATUS_OK)
2286 die_dlerr(status, "cannot disconnect link '%s'", link);
2327}
2328
2329#define MAX_PROPS 32
2330#define MAX_PROP_VALS 32
2331#define MAX_PROP_LINE 512
2332
2333typedef struct prop_info {
2334 char *pi_name;

--- 7 unchanged lines hidden (view full) ---

2342 char *pl_buf;
2343} prop_list_t;
2344
2345typedef struct show_linkprop_state {
2346 const char *ls_link;
2347 char *ls_line;
2348 char **ls_propvals;
2349 prop_list_t *ls_proplist;
2287}
2288
2289#define MAX_PROPS 32
2290#define MAX_PROP_VALS 32
2291#define MAX_PROP_LINE 512
2292
2293typedef struct prop_info {
2294 char *pi_name;

--- 7 unchanged lines hidden (view full) ---

2302 char *pl_buf;
2303} prop_list_t;
2304
2305typedef struct show_linkprop_state {
2306 const char *ls_link;
2307 char *ls_line;
2308 char **ls_propvals;
2309 prop_list_t *ls_proplist;
2350 boolean_t ls_parseable;
2351 boolean_t ls_persist;
2352 boolean_t ls_header;
2310 uint32_t ls_parseable : 1,
2311 ls_persist : 1,
2312 ls_header : 1,
2313 ls_pad_bits : 29;
2314 dladm_status_t ls_status;
2353} show_linkprop_state_t;
2354
2355static void
2356free_props(prop_list_t *list)
2357{
2358 if (list != NULL) {
2359 free(list->pl_buf);
2360 free(list);

--- 81 unchanged lines hidden (view full) ---

2442 char *unknown = "?", *notsup = "";
2443 char **propvals = statep->ls_propvals;
2444 uint_t valcnt = MAX_PROP_VALS;
2445 dladm_status_t status;
2446
2447 status = dladm_get_prop(statep->ls_link, type, propname,
2448 propvals, &valcnt);
2449 if (status != DLADM_STATUS_OK) {
2315} show_linkprop_state_t;
2316
2317static void
2318free_props(prop_list_t *list)
2319{
2320 if (list != NULL) {
2321 free(list->pl_buf);
2322 free(list);

--- 81 unchanged lines hidden (view full) ---

2404 char *unknown = "?", *notsup = "";
2405 char **propvals = statep->ls_propvals;
2406 uint_t valcnt = MAX_PROP_VALS;
2407 dladm_status_t status;
2408
2409 status = dladm_get_prop(statep->ls_link, type, propname,
2410 propvals, &valcnt);
2411 if (status != DLADM_STATUS_OK) {
2450 if (status == DLADM_STATUS_NOTSUP || statep->ls_persist) {
2412 if (status == DLADM_STATUS_TEMPONLY) {
2413 statep->ls_status = status;
2414 return;
2415 } else if (status == DLADM_STATUS_NOTSUP ||
2416 statep->ls_persist) {
2451 valcnt = 1;
2452 if (type == DLADM_PROP_VAL_CURRENT)
2453 propvals = &unknown;
2454 else
2455 propvals = &notsup;
2456 } else {
2417 valcnt = 1;
2418 if (type == DLADM_PROP_VAL_CURRENT)
2419 propvals = &unknown;
2420 else
2421 propvals = &notsup;
2422 } else {
2457 die_dlerr(status, "cannot get link property '%s'",
2458 propname);
2423 statep->ls_status = status;
2424 warn_dlerr(status,
2425 "cannot get link property '%s' for %s",
2426 propname, statep->ls_link);
2427 return;
2459 }
2460 }
2461
2462 ptr = buf;
2463 lim = buf + DLADM_STRSIZE;
2464 for (i = 0; i < valcnt; i++) {
2465 if (propvals[i][0] == '\0' && !statep->ls_parseable)
2466 ptr += snprintf(ptr, lim - ptr, "--,");

--- 16 unchanged lines hidden (view full) ---

2483
2484static boolean_t
2485show_linkprop(void *arg, const char *propname)
2486{
2487 show_linkprop_state_t *statep = arg;
2488 char *ptr = statep->ls_line;
2489 char *lim = ptr + MAX_PROP_LINE;
2490
2428 }
2429 }
2430
2431 ptr = buf;
2432 lim = buf + DLADM_STRSIZE;
2433 for (i = 0; i < valcnt; i++) {
2434 if (propvals[i][0] == '\0' && !statep->ls_parseable)
2435 ptr += snprintf(ptr, lim - ptr, "--,");

--- 16 unchanged lines hidden (view full) ---

2452
2453static boolean_t
2454show_linkprop(void *arg, const char *propname)
2455{
2456 show_linkprop_state_t *statep = arg;
2457 char *ptr = statep->ls_line;
2458 char *lim = ptr + MAX_PROP_LINE;
2459
2491 if (statep->ls_persist && dladm_is_prop_temponly(propname, NULL))
2492 return (B_TRUE);
2493
2494 if (statep->ls_parseable)
2495 ptr += snprintf(ptr, lim - ptr, "LINK=\"%s\" ",
2496 statep->ls_link);
2497 else
2498 ptr += snprintf(ptr, lim - ptr, "%-12s ", statep->ls_link);
2499
2500 if (statep->ls_parseable)
2501 ptr += snprintf(ptr, lim - ptr, "PROPERTY=\"%s\" ", propname);
2502 else
2503 ptr += snprintf(ptr, lim - ptr, "%-15s ", propname);
2504
2505 print_linkprop(statep, propname,
2506 statep->ls_persist ? DLADM_PROP_VAL_PERSISTENT :
2507 DLADM_PROP_VAL_CURRENT, "VALUE", "%-14s ", &ptr);
2460 if (statep->ls_parseable)
2461 ptr += snprintf(ptr, lim - ptr, "LINK=\"%s\" ",
2462 statep->ls_link);
2463 else
2464 ptr += snprintf(ptr, lim - ptr, "%-12s ", statep->ls_link);
2465
2466 if (statep->ls_parseable)
2467 ptr += snprintf(ptr, lim - ptr, "PROPERTY=\"%s\" ", propname);
2468 else
2469 ptr += snprintf(ptr, lim - ptr, "%-15s ", propname);
2470
2471 print_linkprop(statep, propname,
2472 statep->ls_persist ? DLADM_PROP_VAL_PERSISTENT :
2473 DLADM_PROP_VAL_CURRENT, "VALUE", "%-14s ", &ptr);
2474
2475 /*
2476 * If we failed to query the link property, for example, query
2477 * the persistent value of a non-persistable link property, simply
2478 * skip the output.
2479 */
2480 if (statep->ls_status != DLADM_STATUS_OK)
2481 return (B_TRUE);
2482
2508 print_linkprop(statep, propname, DLADM_PROP_VAL_DEFAULT,
2509 "DEFAULT", "%-14s ", &ptr);
2483 print_linkprop(statep, propname, DLADM_PROP_VAL_DEFAULT,
2484 "DEFAULT", "%-14s ", &ptr);
2485 if (statep->ls_status != DLADM_STATUS_OK)
2486 return (B_TRUE);
2487
2510 print_linkprop(statep, propname, DLADM_PROP_VAL_MODIFIABLE,
2511 "POSSIBLE", "%-20s ", &ptr);
2488 print_linkprop(statep, propname, DLADM_PROP_VAL_MODIFIABLE,
2489 "POSSIBLE", "%-20s ", &ptr);
2490 if (statep->ls_status != DLADM_STATUS_OK)
2491 return (B_TRUE);
2512
2513 if (statep->ls_header) {
2514 statep->ls_header = B_FALSE;
2515 if (!statep->ls_parseable)
2516 print_linkprop_head();
2517 }
2518 (void) printf("%s\n", statep->ls_line);
2519 return (B_TRUE);

--- 33 unchanged lines hidden (view full) ---

2553 }
2554
2555 if (optind == (argc - 1))
2556 state.ls_link = argv[optind];
2557 else if (optind != argc)
2558 usage();
2559
2560 state.ls_proplist = proplist;
2492
2493 if (statep->ls_header) {
2494 statep->ls_header = B_FALSE;
2495 if (!statep->ls_parseable)
2496 print_linkprop_head();
2497 }
2498 (void) printf("%s\n", statep->ls_line);
2499 return (B_TRUE);

--- 33 unchanged lines hidden (view full) ---

2533 }
2534
2535 if (optind == (argc - 1))
2536 state.ls_link = argv[optind];
2537 else if (optind != argc)
2538 usage();
2539
2540 state.ls_proplist = proplist;
2541 state.ls_status = DLADM_STATUS_OK;
2561
2562 if (state.ls_link == NULL) {
2563 (void) dladm_walk(show_linkprop_onelink, &state);
2564 } else {
2565 show_linkprop_onelink(&state, state.ls_link);
2566 }
2567 free_props(proplist);
2542
2543 if (state.ls_link == NULL) {
2544 (void) dladm_walk(show_linkprop_onelink, &state);
2545 } else {
2546 show_linkprop_onelink(&state, state.ls_link);
2547 }
2548 free_props(proplist);
2549
2550 if (state.ls_status != DLADM_STATUS_OK)
2551 exit(EXIT_FAILURE);
2568}
2569
2570static void
2571show_linkprop_onelink(void *arg, const char *link)
2572{
2573 int i, fd;
2574 char linkname[MAXPATHLEN];
2575 char *buf;

--- 9 unchanged lines hidden (view full) ---

2585
2586 /*
2587 * When some WiFi links are opened for the first time, their hardware
2588 * automatically scans for APs and does other slow operations. Thus,
2589 * if there are no open links, the retrieval of link properties
2590 * (below) will proceed slowly unless we hold the link open.
2591 */
2592 (void) snprintf(linkname, MAXPATHLEN, "/dev/%s", link);
2552}
2553
2554static void
2555show_linkprop_onelink(void *arg, const char *link)
2556{
2557 int i, fd;
2558 char linkname[MAXPATHLEN];
2559 char *buf;

--- 9 unchanged lines hidden (view full) ---

2569
2570 /*
2571 * When some WiFi links are opened for the first time, their hardware
2572 * automatically scans for APs and does other slow operations. Thus,
2573 * if there are no open links, the retrieval of link properties
2574 * (below) will proceed slowly unless we hold the link open.
2575 */
2576 (void) snprintf(linkname, MAXPATHLEN, "/dev/%s", link);
2593 if ((fd = open(linkname, O_RDWR)) < 0)
2594 die("cannot open %s: %s", link, strerror(errno));
2577 if ((fd = open(linkname, O_RDWR)) < 0) {
2578 warn("cannot open %s: %s", link, strerror(errno));
2579 statep->ls_status = DLADM_STATUS_NOTFOUND;
2580 return;
2581 }
2595
2596 buf = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) * MAX_PROP_VALS +
2597 MAX_PROP_LINE);
2598 if (buf == NULL)
2599 die("insufficient memory");
2600
2601 statep->ls_propvals = (char **)(void *)buf;
2602 for (i = 0; i < MAX_PROP_VALS; i++) {
2603 statep->ls_propvals[i] = buf + sizeof (char *) * MAX_PROP_VALS +
2604 i * DLADM_PROP_VAL_MAX;
2605 }
2606 statep->ls_line = buf +
2607 (sizeof (char *) + DLADM_PROP_VAL_MAX) * MAX_PROP_VALS;
2608
2609 if (proplist != NULL) {
2582
2583 buf = malloc((sizeof (char *) + DLADM_PROP_VAL_MAX) * MAX_PROP_VALS +
2584 MAX_PROP_LINE);
2585 if (buf == NULL)
2586 die("insufficient memory");
2587
2588 statep->ls_propvals = (char **)(void *)buf;
2589 for (i = 0; i < MAX_PROP_VALS; i++) {
2590 statep->ls_propvals[i] = buf + sizeof (char *) * MAX_PROP_VALS +
2591 i * DLADM_PROP_VAL_MAX;
2592 }
2593 statep->ls_line = buf +
2594 (sizeof (char *) + DLADM_PROP_VAL_MAX) * MAX_PROP_VALS;
2595
2596 if (proplist != NULL) {
2610 for (i = 0; i < proplist->pl_count; i++) {
2611 if (!show_linkprop(statep,
2612 proplist->pl_info[i].pi_name))
2613 break;
2614 }
2597 for (i = 0; i < proplist->pl_count; i++)
2598 (void) show_linkprop(statep,
2599 proplist->pl_info[i].pi_name);
2615 } else {
2616 status = dladm_walk_prop(link, statep, show_linkprop);
2617 if (status != DLADM_STATUS_OK)
2600 } else {
2601 status = dladm_walk_prop(link, statep, show_linkprop);
2602 if (status != DLADM_STATUS_OK)
2618 die_dlerr(status, "show-linkprop");
2603 warn_dlerr(status, "show-linkprop failed for %s", link);
2619 }
2620 (void) close(fd);
2621 free(buf);
2622 statep->ls_link = savep;
2623}
2624
2625static dladm_status_t
2626set_linkprop_persist(const char *link, const char *prop_name, char **prop_val,

--- 722 unchanged lines hidden (view full) ---

3349 (void) vfprintf(stderr, format, alist);
3350 va_end(alist);
3351
3352 (void) putchar('\n');
3353}
3354
3355/* PRINTFLIKE2 */
3356static void
2604 }
2605 (void) close(fd);
2606 free(buf);
2607 statep->ls_link = savep;
2608}
2609
2610static dladm_status_t
2611set_linkprop_persist(const char *link, const char *prop_name, char **prop_val,

--- 722 unchanged lines hidden (view full) ---

3334 (void) vfprintf(stderr, format, alist);
3335 va_end(alist);
3336
3337 (void) putchar('\n');
3338}
3339
3340/* PRINTFLIKE2 */
3341static void
3357warn_wlerr(wladm_status_t err, const char *format, ...)
3358{
3359 va_list alist;
3360 char errmsg[WLADM_STRSIZE];
3361
3362 format = gettext(format);
3363 (void) fprintf(stderr, gettext("%s: warning: "), progname);
3364
3365 va_start(alist, format);
3366 (void) vfprintf(stderr, format, alist);
3367 va_end(alist);
3368 (void) fprintf(stderr, ": %s\n", wladm_status2str(err, errmsg));
3369}
3370
3371/* PRINTFLIKE2 */
3372static void
3373warn_dlerr(dladm_status_t err, const char *format, ...)
3374{
3375 va_list alist;
3376 char errmsg[DLADM_STRSIZE];
3377
3378 format = gettext(format);
3379 (void) fprintf(stderr, gettext("%s: warning: "), progname);
3380
3381 va_start(alist, format);
3382 (void) vfprintf(stderr, format, alist);
3383 va_end(alist);
3384 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
3385}
3386
3387/* PRINTFLIKE2 */
3388static void
3342warn_dlerr(dladm_status_t err, const char *format, ...)
3343{
3344 va_list alist;
3345 char errmsg[DLADM_STRSIZE];
3346
3347 format = gettext(format);
3348 (void) fprintf(stderr, gettext("%s: warning: "), progname);
3349
3350 va_start(alist, format);
3351 (void) vfprintf(stderr, format, alist);
3352 va_end(alist);
3353 (void) fprintf(stderr, ": %s\n", dladm_status2str(err, errmsg));
3354}
3355
3356/* PRINTFLIKE2 */
3357static void
3389die_laerr(laadm_diag_t diag, const char *format, ...)
3390{
3391 va_list alist;
3392 char *errstr = strerror(errno);
3393
3394 format = gettext(format);
3395 (void) fprintf(stderr, "%s: ", progname);
3396
3397 va_start(alist, format);
3398 (void) vfprintf(stderr, format, alist);
3399 va_end(alist);
3400
3401 if (diag == 0)
3402 (void) fprintf(stderr, ": %s\n", errstr);
3403 else
3404 (void) fprintf(stderr, ": %s (%s)\n", errstr, laadm_diag(diag));
3405
3406 exit(EXIT_FAILURE);
3407}
3408
3409/* PRINTFLIKE2 */
3410static void
3411die_wlerr(wladm_status_t err, const char *format, ...)
3412{
3413 va_list alist;
3414 char errmsg[WLADM_STRSIZE];
3415
3416 format = gettext(format);
3417 (void) fprintf(stderr, "%s: ", progname);
3418
3419 va_start(alist, format);
3420 (void) vfprintf(stderr, format, alist);
3421 va_end(alist);
3422 (void) fprintf(stderr, ": %s\n", wladm_status2str(err, errmsg));
3423
3424 exit(EXIT_FAILURE);
3425}
3426
3427/* PRINTFLIKE2 */
3428static void
3429die_dlerr(dladm_status_t err, const char *format, ...)
3430{
3431 va_list alist;
3432 char errmsg[DLADM_STRSIZE];
3433
3434 format = gettext(format);
3435 (void) fprintf(stderr, "%s: ", progname);
3436

--- 44 unchanged lines hidden --- 		3358die_dlerr(dladm_status_t err, const char *format, ...)
3359{
3360 va_list alist;
3361 char errmsg[DLADM_STRSIZE];
3362
3363 format = gettext(format);
3364 (void) fprintf(stderr, "%s: ", progname);
3365

--- 44 unchanged lines hidden ---