#include <stdio.h>

#include <ctype.h>

#include <locale.h>

#include <signal.h>

#include <stdarg.h>

#include <stdlib.h>

#include <fcntl.h>

#include <string.h>

#include <stropts.h>

#include <sys/stat.h>

#include <errno.h>

#include <kstat.h>

#include <strings.h>

#include <getopt.h>

#include <unistd.h>

#include <priv.h>

#include <termios.h>

#include <pwd.h>

#include <auth_attr.h>

#include <auth_list.h>

#include <libintl.h>

#include <libdevinfo.h>

#include <libdlpi.h>

#include <libdladm.h>

#include <libdllink.h>

#include <libdlstat.h>

#include <libdlaggr.h>

#include <libdlwlan.h>

#include <libdlvlan.h>

#include <libdlvnic.h>

#include <libdlether.h>

#include <libinetutil.h>

#include <bsm/adt.h>

#include <bsm/adt_event.h>

#include <libdlvnic.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/processor.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <net/if_types.h>

#include <stddef.h>

#include <ofmt.h>

#define MAXPORT 256

#define MAXVNIC 256

#define BUFLEN(lim, ptr) (((lim) > (ptr)) ? ((lim) - (ptr)) : 0)

#define MAXLINELEN 1024

#define SMF_UPGRADE_FILE "/var/svc/profile/upgrade"

#define SMF_UPGRADEDATALINK_FILE "/var/svc/profile/upgrade_datalink"

#define SMF_DLADM_UPGRADE_MSG " # added by dladm(1M)"

#define DLADM_DEFAULT_COL 80

#define WIFI_CMD_SCAN 0x00000001

#define WIFI_CMD_SHOW 0x00000002

#define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)

typedef struct show_state {

boolean_t ls_firstonly;

boolean_t ls_donefirst;

pktsum_t ls_prevstats;

uint32_t ls_flags;

dladm_status_t ls_status;

ofmt_handle_t ls_ofmt;

boolean_t ls_parsable;

boolean_t ls_mac;

boolean_t ls_hwgrp;

} show_state_t;

typedef struct show_grp_state {

pktsum_t gs_prevstats[MAXPORT];

uint32_t gs_flags;

dladm_status_t gs_status;

boolean_t gs_parsable;

boolean_t gs_lacp;

boolean_t gs_extended;

boolean_t gs_stats;

boolean_t gs_firstonly;

boolean_t gs_donefirst;

ofmt_handle_t gs_ofmt;

} show_grp_state_t;

typedef struct show_vnic_state {

datalink_id_t vs_vnic_id;

datalink_id_t vs_link_id;

char vs_vnic[MAXLINKNAMELEN];

char vs_link[MAXLINKNAMELEN];

boolean_t vs_parsable;

boolean_t vs_found;

boolean_t vs_firstonly;

boolean_t vs_donefirst;

boolean_t vs_stats;

boolean_t vs_printstats;

pktsum_t vs_totalstats;

pktsum_t vs_prevstats[MAXVNIC];

boolean_t vs_etherstub;

dladm_status_t vs_status;

uint32_t vs_flags;

ofmt_handle_t vs_ofmt;

} show_vnic_state_t;

typedef struct show_usage_state_s {

boolean_t us_plot;

boolean_t us_parsable;

boolean_t us_printheader;

boolean_t us_first;

boolean_t us_showall;

ofmt_handle_t us_ofmt;

} show_usage_state_t;

static ofmt_cb_t print_default_cb, print_link_stats_cb, print_linkprop_cb;

static ofmt_cb_t print_lacp_cb, print_phys_one_mac_cb;

static ofmt_cb_t print_xaggr_cb, print_aggr_stats_cb;

static ofmt_cb_t print_phys_one_hwgrp_cb, print_wlan_attr_cb;

static ofmt_cb_t print_wifi_status_cb, print_link_attr_cb;

static void dladm_ofmt_check(ofmt_status_t, boolean_t, ofmt_handle_t);

typedef void cmdfunc_t(int, char **, const char *);

static cmdfunc_t do_show_link, do_show_wifi, do_show_phys;

static cmdfunc_t do_create_aggr, do_delete_aggr, do_add_aggr, do_remove_aggr;

static cmdfunc_t do_modify_aggr, do_show_aggr, do_up_aggr;

static cmdfunc_t do_scan_wifi, do_connect_wifi, do_disconnect_wifi;

static cmdfunc_t do_show_linkprop, do_set_linkprop, do_reset_linkprop;

static cmdfunc_t do_create_secobj, do_delete_secobj, do_show_secobj;

static cmdfunc_t do_init_linkprop, do_init_secobj;

static cmdfunc_t do_create_vlan, do_delete_vlan, do_up_vlan, do_show_vlan;

static cmdfunc_t do_rename_link, do_delete_phys, do_init_phys;

static cmdfunc_t do_show_linkmap;

static cmdfunc_t do_show_ether;

static cmdfunc_t do_create_vnic, do_delete_vnic, do_show_vnic;

static cmdfunc_t do_up_vnic;

static cmdfunc_t do_create_etherstub, do_delete_etherstub, do_show_etherstub;

static cmdfunc_t do_show_usage;

static void do_up_vnic_common(int, char **, const char *, boolean_t);

static void altroot_cmd(char *, int, char **);

static int show_linkprop_onelink(dladm_handle_t, datalink_id_t, void *);

static void link_stats(datalink_id_t, uint_t, char *, show_state_t *);

static void aggr_stats(datalink_id_t, show_grp_state_t *, uint_t);

static void vnic_stats(show_vnic_state_t *, uint32_t);

static int get_one_kstat(const char *, const char *, uint8_t,

void *, boolean_t);

static void get_mac_stats(const char *, pktsum_t *);

static void get_link_stats(const char *, pktsum_t *);

static uint64_t get_ifspeed(const char *, boolean_t);

static const char *get_linkstate(const char *, boolean_t, char *);

static const char *get_linkduplex(const char *, boolean_t, char *);

static int show_etherprop(dladm_handle_t, datalink_id_t, void *);

static void show_ether_xprop(void *, dladm_ether_info_t *);

static boolean_t link_is_ether(const char *, datalink_id_t *);

static boolean_t str2int(const char *, int *);

static void die(const char *, ...);

static void die_optdup(int);

static void die_opterr(int, int, const char *);

static void die_dlerr(dladm_status_t, const char *, ...);

static void warn(const char *, ...);

static void warn_dlerr(dladm_status_t, const char *, ...);

typedef struct cmd {

char *c_name;

cmdfunc_t *c_fn;

const char *c_usage;

} cmd_t;

static cmd_t cmds[] = {

{ "rename-link", do_rename_link,

" rename-link <oldlink> <newlink>" },

{ "show-link", do_show_link,

" show-link [-pP] [-o <field>,..] [-s [-i <interval>]] "

"[<link>]\n" },

{ "create-aggr", do_create_aggr,

" create-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "

"[-u <address>]\n"

"\t\t -l <link> [-l <link>...] <link>" },

{ "delete-aggr", do_delete_aggr,

" delete-aggr [-t] <link>" },

{ "add-aggr", do_add_aggr,

" add-aggr [-t] -l <link> [-l <link>...] <link>" },

{ "remove-aggr", do_remove_aggr,

" remove-aggr [-t] -l <link> [-l <link>...] <link>" },

{ "modify-aggr", do_modify_aggr,

" modify-aggr [-t] [-P <policy>] [-L <mode>] [-T <time>] "

"[-u <address>]\n"

"\t\t <link>" },

{ "show-aggr", do_show_aggr,

" show-aggr [-pPLx] [-o <field>,..] [-s [-i <interval>]] "

"[<link>]\n" },

{ "up-aggr", do_up_aggr, NULL },

{ "scan-wifi", do_scan_wifi,

" scan-wifi [-p] [-o <field>,...] [<link>]" },

{ "connect-wifi", do_connect_wifi,

" connect-wifi [-e <essid>] [-i <bssid>] [-k <key>,...] "

"[-s wep|wpa]\n"

"\t\t [-a open|shared] [-b bss|ibss] [-c] [-m a|b|g] "

"[-T <time>]\n"

"\t\t [<link>]" },

{ "disconnect-wifi", do_disconnect_wifi,

" disconnect-wifi [-a] [<link>]" },

{ "show-wifi", do_show_wifi,

" show-wifi [-p] [-o <field>,...] [<link>]\n" },

{ "set-linkprop", do_set_linkprop,

" set-linkprop [-t] -p <prop>=<value>[,...] <name>" },

{ "reset-linkprop", do_reset_linkprop,

" reset-linkprop [-t] [-p <prop>,...] <name>" },

{ "show-linkprop", do_show_linkprop,

" show-linkprop [-cP] [-o <field>,...] [-p <prop>,...] "

"<name>\n" },

{ "show-ether", do_show_ether,

" show-ether [-px][-o <field>,...] <link>\n" },

{ "create-secobj", do_create_secobj,

" create-secobj [-t] [-f <file>] -c <class> <secobj>" },

{ "delete-secobj", do_delete_secobj,

" delete-secobj [-t] <secobj>[,...]" },

{ "show-secobj", do_show_secobj,

" show-secobj [-pP] [-o <field>,...] [<secobj>,...]\n" },

{ "init-linkprop", do_init_linkprop, NULL },

{ "init-secobj", do_init_secobj, NULL },

{ "create-vlan", do_create_vlan,

" create-vlan [-ft] -l <link> -v <vid> [link]" },

{ "delete-vlan", do_delete_vlan,

" delete-vlan [-t] <link>" },

{ "show-vlan", do_show_vlan,

" show-vlan [-pP] [-o <field>,..] [<link>]\n" },

{ "up-vlan", do_up_vlan, NULL },

{ "delete-phys", do_delete_phys,

" delete-phys <link>" },

{ "show-phys", do_show_phys,

" show-phys [-pP] [-o <field>,..] [-H] [<link>]\n"},

{ "init-phys", do_init_phys, NULL },

{ "show-linkmap", do_show_linkmap, NULL },

{ "create-vnic", do_create_vnic,

" create-vnic [-t] -l <link> [-m <value> | auto |\n"

"\t\t {factory [-n <slot-id>]} | {random [-r <prefix>]}]\n"

"\t\t [-v <vid> [-f]] [-p <prop>=<value>[,...]] [-H] "

"<vnic-link>" },

{ "delete-vnic", do_delete_vnic,

" delete-vnic [-t] <vnic-link>" },

{ "show-vnic", do_show_vnic,

" show-vnic [-pP] [-l <link>] [-s [-i <interval>]] "

"[<link>]\n" },

{ "up-vnic", do_up_vnic, NULL },

{ "create-etherstub", do_create_etherstub,

" create-etherstub [-t] <link>" },

{ "delete-etherstub", do_delete_etherstub,

" delete-etherstub [-t] <link>" },

{ "show-etherstub", do_show_etherstub,

" show-etherstub [-t] [<link>]\n" },

{ "show-usage", do_show_usage,

" show-usage [-a] [-d | -F <format>] "

"[-s <DD/MM/YYYY,HH:MM:SS>]\n"

"\t\t [-e <DD/MM/YYYY,HH:MM:SS>] -f <logfile> [<link>]" }

};

static const struct option lopts[] = {

{"vlan-id", required_argument, 0, 'v'},

{"output", required_argument, 0, 'o'},

{"dev", required_argument, 0, 'd'},

{"policy", required_argument, 0, 'P'},

{"lacp-mode", required_argument, 0, 'L'},

{"lacp-timer", required_argument, 0, 'T'},

{"unicast", required_argument, 0, 'u'},

{"temporary", no_argument, 0, 't'},

{"root-dir", required_argument, 0, 'R'},

{"link", required_argument, 0, 'l'},

{"forcible", no_argument, 0, 'f'},

{"bw-limit", required_argument, 0, 'b'},

{"mac-address", required_argument, 0, 'm'},

{"slot", required_argument, 0, 'n'},

{ 0, 0, 0, 0 }

};

static const struct option show_lopts[] = {

{"statistics", no_argument, 0, 's'},

{"continuous", no_argument, 0, 'S'},

{"interval", required_argument, 0, 'i'},

{"parsable", no_argument, 0, 'p'},

{"parseable", no_argument, 0, 'p'},

{"extended", no_argument, 0, 'x'},

{"output", required_argument, 0, 'o'},

{"persistent", no_argument, 0, 'P'},

{"lacp", no_argument, 0, 'L'},

{ 0, 0, 0, 0 }

};

static const struct option prop_longopts[] = {

{"temporary", no_argument, 0, 't' },

{"output", required_argument, 0, 'o' },

{"root-dir", required_argument, 0, 'R' },

{"prop", required_argument, 0, 'p' },

{"parsable", no_argument, 0, 'c' },

{"parseable", no_argument, 0, 'c' },

{"persistent", no_argument, 0, 'P' },

{ 0, 0, 0, 0 }

};

static const struct option wifi_longopts[] = {

{"parsable", no_argument, 0, 'p' },

{"parseable", no_argument, 0, 'p' },

{"output", required_argument, 0, 'o' },

{"essid", required_argument, 0, 'e' },

{"bsstype", required_argument, 0, 'b' },

{"mode", required_argument, 0, 'm' },

{"key", required_argument, 0, 'k' },

{"sec", required_argument, 0, 's' },

{"auth", required_argument, 0, 'a' },

{"create-ibss", required_argument, 0, 'c' },

{"timeout", required_argument, 0, 'T' },

{"all-links", no_argument, 0, 'a' },

{"temporary", no_argument, 0, 't' },

{"root-dir", required_argument, 0, 'R' },

{"persistent", no_argument, 0, 'P' },

{"file", required_argument, 0, 'f' },

{ 0, 0, 0, 0 }

};

static const struct option showeth_lopts[] = {

{"parsable", no_argument, 0, 'p' },

{"parseable", no_argument, 0, 'p' },

{"extended", no_argument, 0, 'x' },

{"output", required_argument, 0, 'o' },

{ 0, 0, 0, 0 }

};

static const struct option vnic_lopts[] = {

{"temporary", no_argument, 0, 't' },

{"root-dir", required_argument, 0, 'R' },

{"dev", required_argument, 0, 'd' },

{"mac-address", required_argument, 0, 'm' },

{"cpus", required_argument, 0, 'c' },

{"bw-limit", required_argument, 0, 'b' },

{"slot", required_argument, 0, 'n' },

{"mac-prefix", required_argument, 0, 'r' },

{ 0, 0, 0, 0 }

};

static const struct option etherstub_lopts[] = {

{"temporary", no_argument, 0, 't' },

{"root-dir", required_argument, 0, 'R' },

{ 0, 0, 0, 0 }

};

static const struct option usage_opts[] = {

{"file", required_argument, 0, 'f' },

{"format", required_argument, 0, 'F' },

{"start", required_argument, 0, 's' },

{"stop", required_argument, 0, 'e' },

{ 0, 0, 0, 0 }

};

static const char *ptype[] = {LEI_ATTR_NAMES};

typedef struct ether_fields_buf_s

{

char eth_link[15];

char eth_ptype[8];

char eth_state[8];

char eth_autoneg[5];

char eth_spdx[31];

char eth_pause[6];

char eth_rem_fault[16];

} ether_fields_buf_t;

static ofmt_field_t ether_fields[] = {

{ "LINK", 16,

offsetof(ether_fields_buf_t, eth_link), print_default_cb},

{ "PTYPE", 9,

offsetof(ether_fields_buf_t, eth_ptype), print_default_cb},

{ "STATE", 9,

offsetof(ether_fields_buf_t, eth_state),

print_default_cb},

{ "AUTO", 6,

offsetof(ether_fields_buf_t, eth_autoneg), print_default_cb},

{ "SPEED-DUPLEX", 32,

offsetof(ether_fields_buf_t, eth_spdx), print_default_cb},

{ "PAUSE", 7,

offsetof(ether_fields_buf_t, eth_pause), print_default_cb},

{ "REM_FAULT", 17,

offsetof(ether_fields_buf_t, eth_rem_fault), print_default_cb},

{NULL, 0,

0, NULL}}

;

typedef struct print_ether_state {

const char *es_link;

boolean_t es_parsable;

boolean_t es_header;

boolean_t es_extended;

ofmt_handle_t es_ofmt;

} print_ether_state_t;

typedef enum {

LINK_S_LINK,

LINK_S_IPKTS,

LINK_S_RBYTES,

LINK_S_IERRORS,

LINK_S_OPKTS,

LINK_S_OBYTES,

LINK_S_OERRORS

} link_s_field_index_t;

static ofmt_field_t link_s_fields[] = {

{ "LINK", 15, LINK_S_LINK, print_link_stats_cb},

{ "IPACKETS", 10, LINK_S_IPKTS, print_link_stats_cb},

{ "RBYTES", 8, LINK_S_RBYTES, print_link_stats_cb},

{ "IERRORS", 10, LINK_S_IERRORS, print_link_stats_cb},

{ "OPACKETS", 12, LINK_S_OPKTS, print_link_stats_cb},

{ "OBYTES", 12, LINK_S_OBYTES, print_link_stats_cb},

{ "OERRORS", 8, LINK_S_OERRORS, print_link_stats_cb}}

;

typedef struct link_args_s {

char *link_s_link;

pktsum_t *link_s_psum;

} link_args_t;

typedef struct link_fields_buf_s {

char link_name[MAXLINKNAMELEN];

char link_class[DLADM_STRSIZE];

char link_mtu[11];

char link_state[DLADM_STRSIZE];

char link_over[MAXLINKNAMELEN];

char link_phys_state[DLADM_STRSIZE];

char link_phys_media[DLADM_STRSIZE];

char link_phys_speed[DLADM_STRSIZE];

char link_phys_duplex[DLPI_LINKNAME_MAX];

char link_phys_device[DLPI_LINKNAME_MAX];

char link_flags[6];

char link_vlan_vid[6];

} link_fields_buf_t;

static ofmt_field_t link_fields[] = {

{ "LINK", 12,

offsetof(link_fields_buf_t, link_name), print_default_cb},

{ "CLASS", 9,

offsetof(link_fields_buf_t, link_class), print_default_cb},

{ "MTU", 7,

offsetof(link_fields_buf_t, link_mtu), print_default_cb},

{ "STATE", 9,

offsetof(link_fields_buf_t, link_state), print_default_cb},

{ "OVER", DLPI_LINKNAME_MAX,

offsetof(link_fields_buf_t, link_over), print_default_cb},

{ NULL, 0, 0, NULL}}

;

typedef struct laggr_fields_buf_s {

char laggr_name[DLPI_LINKNAME_MAX];

char laggr_policy[9];

char laggr_addrpolicy[ETHERADDRL * 3 + 3];

char laggr_lacpactivity[14];

char laggr_lacptimer[DLADM_STRSIZE];

char laggr_flags[7];

} laggr_fields_buf_t;

typedef struct laggr_args_s {

int laggr_lport; /* -1 indicates the aggr itself */

const char *laggr_link;

dladm_aggr_grp_attr_t *laggr_ginfop;

dladm_status_t *laggr_status;

pktsum_t *laggr_pktsumtot; /* -s only */

pktsum_t *laggr_diffstats; /* -s only */

boolean_t laggr_parsable;

} laggr_args_t;

static ofmt_field_t laggr_fields[] = {

{ "LINK", 16,

offsetof(laggr_fields_buf_t, laggr_name), print_default_cb},

{ "POLICY", 9,

offsetof(laggr_fields_buf_t, laggr_policy), print_default_cb},

{ "ADDRPOLICY", ETHERADDRL * 3 + 3,

offsetof(laggr_fields_buf_t, laggr_addrpolicy), print_default_cb},

{ "LACPACTIVITY", 14,

offsetof(laggr_fields_buf_t, laggr_lacpactivity), print_default_cb},

{ "LACPTIMER", 12,

offsetof(laggr_fields_buf_t, laggr_lacptimer), print_default_cb},

{ "FLAGS", 8,

offsetof(laggr_fields_buf_t, laggr_flags), print_default_cb},

{ NULL, 0, 0, NULL}}

;

typedef enum {

AGGR_X_LINK,

AGGR_X_PORT,

AGGR_X_SPEED,

AGGR_X_DUPLEX,

AGGR_X_STATE,

AGGR_X_ADDRESS,

AGGR_X_PORTSTATE

} aggr_x_field_index_t;

static ofmt_field_t aggr_x_fields[] = {

{ "LINK", 12, AGGR_X_LINK, print_xaggr_cb},

{ "PORT", 15, AGGR_X_PORT, print_xaggr_cb},

{ "SPEED", 5, AGGR_X_SPEED, print_xaggr_cb},

{ "DUPLEX", 10, AGGR_X_DUPLEX, print_xaggr_cb},

{ "STATE", 10, AGGR_X_STATE, print_xaggr_cb},

{ "ADDRESS", 19, AGGR_X_ADDRESS, print_xaggr_cb},

{ "PORTSTATE", 16, AGGR_X_PORTSTATE, print_xaggr_cb},

{ NULL, 0, 0, NULL}}

;

typedef enum {

AGGR_S_LINK,

AGGR_S_PORT,

AGGR_S_IPKTS,

AGGR_S_RBYTES,

AGGR_S_OPKTS,

AGGR_S_OBYTES,

AGGR_S_IPKTDIST,

AGGR_S_OPKTDIST

} aggr_s_field_index_t;

static ofmt_field_t aggr_s_fields[] = {

{ "LINK", 12, AGGR_S_LINK, print_aggr_stats_cb},

{ "PORT", 10, AGGR_S_PORT, print_aggr_stats_cb},

{ "IPACKETS", 8, AGGR_S_IPKTS, print_aggr_stats_cb},

{ "RBYTES", 8, AGGR_S_RBYTES, print_aggr_stats_cb},

{ "OPACKETS", 8, AGGR_S_OPKTS, print_aggr_stats_cb},

{ "OBYTES", 8, AGGR_S_OBYTES, print_aggr_stats_cb},

{ "IPKTDIST", 9, AGGR_S_IPKTDIST, print_aggr_stats_cb},

{ "OPKTDIST", 15, AGGR_S_OPKTDIST, print_aggr_stats_cb},

{ NULL, 0, 0, NULL}}

;

typedef enum {

AGGR_L_LINK,

AGGR_L_PORT,

AGGR_L_AGGREGATABLE,

AGGR_L_SYNC,

AGGR_L_COLL,

AGGR_L_DIST,

AGGR_L_DEFAULTED,

AGGR_L_EXPIRED

} aggr_l_field_index_t;

static ofmt_field_t aggr_l_fields[] = {

{ "LINK", 12, AGGR_L_LINK, print_lacp_cb},

{ "PORT", 13, AGGR_L_PORT, print_lacp_cb},

{ "AGGREGATABLE", 13, AGGR_L_AGGREGATABLE, print_lacp_cb},

{ "SYNC", 5, AGGR_L_SYNC, print_lacp_cb},

{ "COLL", 5, AGGR_L_COLL, print_lacp_cb},

{ "DIST", 5, AGGR_L_DIST, print_lacp_cb},

{ "DEFAULTED", 10, AGGR_L_DEFAULTED, print_lacp_cb},

{ "EXPIRED", 15, AGGR_L_EXPIRED, print_lacp_cb},

{ NULL, 0, 0, NULL}}

;

static ofmt_field_t phys_fields[] = {

{ "LINK", 13,

offsetof(link_fields_buf_t, link_name), print_default_cb},

{ "MEDIA", 21,

offsetof(link_fields_buf_t, link_phys_media), print_default_cb},

{ "STATE", 11,

offsetof(link_fields_buf_t, link_phys_state), print_default_cb},

{ "SPEED", 7,

offsetof(link_fields_buf_t, link_phys_speed), print_default_cb},

{ "DUPLEX", 10,

offsetof(link_fields_buf_t, link_phys_duplex), print_default_cb},

{ "DEVICE", 13,

offsetof(link_fields_buf_t, link_phys_device), print_default_cb},

{ "FLAGS", 7,

offsetof(link_fields_buf_t, link_flags), print_default_cb},

{ NULL, 0, NULL, 0}}

;

typedef enum {

PHYS_M_LINK,

PHYS_M_SLOT,

PHYS_M_ADDRESS,

PHYS_M_INUSE,

PHYS_M_CLIENT

} phys_m_field_index_t;

static ofmt_field_t phys_m_fields[] = {

{ "LINK", 13, PHYS_M_LINK, print_phys_one_mac_cb},

{ "SLOT", 9, PHYS_M_SLOT, print_phys_one_mac_cb},

{ "ADDRESS", 19, PHYS_M_ADDRESS, print_phys_one_mac_cb},

{ "INUSE", 5, PHYS_M_INUSE, print_phys_one_mac_cb},

{ "CLIENT", 13, PHYS_M_CLIENT, print_phys_one_mac_cb},

{ NULL, 0, 0, NULL}}

;

typedef enum {

PHYS_H_LINK,

PHYS_H_GROUP,

PHYS_H_GRPTYPE,

PHYS_H_RINGS,

PHYS_H_CLIENTS

} phys_h_field_index_t;

static ofmt_field_t phys_h_fields[] = {

{ "LINK", 13, PHYS_H_LINK, print_phys_one_hwgrp_cb},

{ "GROUP", 9, PHYS_H_GROUP, print_phys_one_hwgrp_cb},

{ "GROUPTYPE", 7, PHYS_H_GRPTYPE, print_phys_one_hwgrp_cb},

{ "RINGS", 17, PHYS_H_RINGS, print_phys_one_hwgrp_cb},

{ "CLIENTS", 21, PHYS_H_CLIENTS, print_phys_one_hwgrp_cb},

{ NULL, 0, 0, NULL}}

;

static ofmt_field_t vlan_fields[] = {

{ "LINK", 16,

offsetof(link_fields_buf_t, link_name), print_default_cb},

{ "VID", 9,

offsetof(link_fields_buf_t, link_vlan_vid), print_default_cb},

{ "OVER", 13,

offsetof(link_fields_buf_t, link_over), print_default_cb},

{ "FLAGS", 7,

offsetof(link_fields_buf_t, link_flags), print_default_cb},

{ NULL, 0, 0, NULL}}

;

static ofmt_field_t wifi_common_fields[] = {

{ "LINK", 11, 0, NULL},

{ "ESSID", 20, DLADM_WLAN_ATTR_ESSID, NULL},

{ "BSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},

{ "IBSSID", 18, DLADM_WLAN_ATTR_BSSID, NULL},

{ "MODE", 7, DLADM_WLAN_ATTR_MODE, NULL},

{ "SPEED", 7, DLADM_WLAN_ATTR_SPEED, NULL},

{ "BSSTYPE", 9, DLADM_WLAN_ATTR_BSSTYPE, NULL},

{ "SEC", 7, DLADM_WLAN_ATTR_SECMODE, NULL},

{ "STRENGTH", 11, DLADM_WLAN_ATTR_STRENGTH, NULL},

{ NULL, 0, 0, NULL}};

static ofmt_field_t wifi_show_fields[A_CNT(wifi_common_fields) + 2] = {

{ "AUTH", 9, DLADM_WLAN_ATTR_AUTH, NULL},

{ "STATUS", 18, DLADM_WLAN_LINKATTR_STATUS, print_wifi_status_cb},

};

static char *all_scan_wifi_fields =

"link,essid,bssid,sec,strength,mode,speed,bsstype";

static char *all_show_wifi_fields =

"link,status,essid,sec,strength,mode,speed,auth,bssid,bsstype";

static char *def_scan_wifi_fields =

"link,essid,bssid,sec,strength,mode,speed";

static char *def_show_wifi_fields =

"link,status,essid,sec,strength,mode,speed";

typedef enum {

LINKPROP_LINK,

LINKPROP_PROPERTY,

LINKPROP_PERM,

LINKPROP_VALUE,

LINKPROP_DEFAULT,

LINKPROP_POSSIBLE

} linkprop_field_index_t;

static ofmt_field_t linkprop_fields[] = {

{ "LINK", 13, LINKPROP_LINK, print_linkprop_cb},

{ "PROPERTY", 16, LINKPROP_PROPERTY, print_linkprop_cb},

{ "PERM", 5, LINKPROP_PERM, print_linkprop_cb},

{ "VALUE", 15, LINKPROP_VALUE, print_linkprop_cb},

{ "DEFAULT", 15, LINKPROP_DEFAULT, print_linkprop_cb},

{ "POSSIBLE", 21, LINKPROP_POSSIBLE, print_linkprop_cb},

{ NULL, 0, 0, NULL}}

;

#define MAX_PROP_LINE 512

typedef struct show_linkprop_state {

char ls_link[MAXLINKNAMELEN];

char *ls_line;

char **ls_propvals;

dladm_arg_list_t *ls_proplist;

boolean_t ls_parsable;

boolean_t ls_persist;

boolean_t ls_header;

dladm_status_t ls_status;

dladm_status_t ls_retstatus;

ofmt_handle_t ls_ofmt;

} show_linkprop_state_t;

typedef struct set_linkprop_state {

const char *ls_name;

boolean_t ls_reset;

boolean_t ls_temp;

dladm_status_t ls_status;

} set_linkprop_state_t;

typedef struct linkprop_args_s {

show_linkprop_state_t *ls_state;

char *ls_propname;

datalink_id_t ls_linkid;

} linkprop_args_t;

typedef struct secobj_fields_buf_s {

char ss_obj_name[DLADM_SECOBJ_VAL_MAX];

char ss_class[20];

char ss_val[30];

} secobj_fields_buf_t;

static ofmt_field_t secobj_fields[] = {

{ "OBJECT", 21,

offsetof(secobj_fields_buf_t, ss_obj_name), print_default_cb},

{ "CLASS", 21,

offsetof(secobj_fields_buf_t, ss_class), print_default_cb},

{ "VALUE", 31,

offsetof(secobj_fields_buf_t, ss_val), print_default_cb},

{ NULL, 0, 0, NULL}}

;

typedef struct vnic_fields_buf_s

{

char vnic_link[DLPI_LINKNAME_MAX];

char vnic_over[DLPI_LINKNAME_MAX];

char vnic_speed[6];

char vnic_macaddr[19];

char vnic_macaddrtype[19];

char vnic_vid[6];

} vnic_fields_buf_t;

static ofmt_field_t vnic_fields[] = {

{ "LINK", 13,

offsetof(vnic_fields_buf_t, vnic_link), print_default_cb},

{ "OVER", 13,

offsetof(vnic_fields_buf_t, vnic_over), print_default_cb},

{ "SPEED", 7,

offsetof(vnic_fields_buf_t, vnic_speed), print_default_cb},

{ "MACADDRESS", 21,

offsetof(vnic_fields_buf_t, vnic_macaddr), print_default_cb},

{ "MACADDRTYPE", 20,

offsetof(vnic_fields_buf_t, vnic_macaddrtype), print_default_cb},

{ "VID", 7,

offsetof(vnic_fields_buf_t, vnic_vid), print_default_cb},

{ NULL, 0, 0, NULL}}

;

typedef struct usage_fields_buf_s {

char usage_link[12];

char usage_duration[10];

char usage_ipackets[9];

char usage_rbytes[10];

char usage_opackets[9];

char usage_obytes[10];

char usage_bandwidth[14];

} usage_fields_buf_t;

static ofmt_field_t usage_fields[] = {

{ "LINK", 13,

offsetof(usage_fields_buf_t, usage_link), print_default_cb},

{ "DURATION", 11,

offsetof(usage_fields_buf_t, usage_duration), print_default_cb},

{ "IPACKETS", 10,

offsetof(usage_fields_buf_t, usage_ipackets), print_default_cb},

{ "RBYTES", 11,

offsetof(usage_fields_buf_t, usage_rbytes), print_default_cb},

{ "OPACKETS", 10,

offsetof(usage_fields_buf_t, usage_opackets), print_default_cb},

{ "OBYTES", 11,

offsetof(usage_fields_buf_t, usage_obytes), print_default_cb},

{ "BANDWIDTH", 15,

offsetof(usage_fields_buf_t, usage_bandwidth), print_default_cb},

{ NULL, 0, 0, NULL}}

;

typedef struct usage_l_fields_buf_s {

char usage_l_link[12];

char usage_l_stime[13];

char usage_l_etime[13];

char usage_l_rbytes[8];

char usage_l_obytes[8];

char usage_l_bandwidth[14];

} usage_l_fields_buf_t;

static ofmt_field_t usage_l_fields[] = {

{ "LINK", 13,

offsetof(usage_l_fields_buf_t, usage_l_link), print_default_cb},

{ "START", 14,

offsetof(usage_l_fields_buf_t, usage_l_stime), print_default_cb},

{ "END", 14,

offsetof(usage_l_fields_buf_t, usage_l_etime), print_default_cb},

{ "RBYTES", 9,

offsetof(usage_l_fields_buf_t, usage_l_rbytes), print_default_cb},

{ "OBYTES", 9,

offsetof(usage_l_fields_buf_t, usage_l_obytes), print_default_cb},

{ "BANDWIDTH", 15,

offsetof(usage_l_fields_buf_t, usage_l_bandwidth), print_default_cb},

{ NULL, 0, 0, NULL}}

;

static char *progname;

static sig_atomic_t signalled;

static dladm_handle_t handle = NULL;

#define DLADM_ETHERSTUB_NAME "etherstub"

#define DLADM_IS_ETHERSTUB(id) (id == DATALINK_INVALID_LINKID)

static void

usage(void)

{

int i;

cmd_t *cmdp;

(void) fprintf(stderr, gettext("usage: dladm <subcommand> <args> ..."

"\n"));

for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {

cmdp = &cmds[i];

if (cmdp->c_usage != NULL)

(void) fprintf(stderr, "%s\n", gettext(cmdp->c_usage));

}

/* close dladm handle if it was opened */

if (handle != NULL)

dladm_close(handle);

exit(1);

}

main(int argc, char *argv[])

{

int i;

cmd_t *cmdp;

dladm_status_t status;

(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)

#define TEXT_DOMAIN "SYS_TEST"

#endif

(void) textdomain(TEXT_DOMAIN);

progname = argv[0];

if (argc < 2)

usage();

for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {

cmdp = &cmds[i];

if (strcmp(argv[1], cmdp->c_name) == 0) {

/* Open the libdladm handle */

if ((status = dladm_open(&handle)) != DLADM_STATUS_OK) {

die_dlerr(status,

"could not open /dev/dld");

}

cmdp->c_fn(argc - 1, &argv[1], cmdp->c_usage);

dladm_close(handle);

exit(0);

}

}

(void) fprintf(stderr, gettext("%s: unknown subcommand '%s'\n"),

progname, argv[1]);

usage();

return (0);

}

static int

show_usage_date(dladm_usage_t *usage, void *arg)

{

show_usage_state_t *state = (show_usage_state_t *)arg;

time_t stime;

char timebuf[20];

dladm_status_t status;

uint32_t flags;

/*

if (!state->us_showall) {

if ((status = dladm_name2info(handle, usage->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

stime = usage->du_stime;

(void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",

localtime(&stime));

(void) printf("%s\n", timebuf);

return (DLADM_STATUS_OK);

}

static int

show_usage_time(dladm_usage_t *usage, void *arg)

{

show_usage_state_t *state = (show_usage_state_t *)arg;

char buf[DLADM_STRSIZE];

usage_l_fields_buf_t ubuf;

time_t time;

double bw;

dladm_status_t status;

uint32_t flags;

/*

if (!state->us_showall) {

if ((status = dladm_name2info(handle, usage->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

if (state->us_plot) {

if (!state->us_printheader) {

if (state->us_first) {

(void) printf("# Time");

state->us_first = B_FALSE;

}

(void) printf(" %s", usage->du_name);

if (usage->du_last) {

(void) printf("\n");

state->us_first = B_TRUE;

state->us_printheader = B_TRUE;

}

} else {

if (state->us_first) {

time = usage->du_etime;

(void) strftime(buf, sizeof (buf), "%T",

localtime(&time));

state->us_first = B_FALSE;

(void) printf("%s", buf);

}

bw = (double)usage->du_bandwidth/1000;

(void) printf(" %.2f", bw);

if (usage->du_last) {

(void) printf("\n");

state->us_first = B_TRUE;

}

}

return (DLADM_STATUS_OK);

}

bzero(&ubuf, sizeof (ubuf));

(void) snprintf(ubuf.usage_l_link, sizeof (ubuf.usage_l_link), "%s",

usage->du_name);

time = usage->du_stime;

(void) strftime(buf, sizeof (buf), "%T", localtime(&time));

(void) snprintf(ubuf.usage_l_stime, sizeof (ubuf.usage_l_stime), "%s",

buf);

time = usage->du_etime;

(void) strftime(buf, sizeof (buf), "%T", localtime(&time));

(void) snprintf(ubuf.usage_l_etime, sizeof (ubuf.usage_l_etime), "%s",

buf);

(void) snprintf(ubuf.usage_l_rbytes, sizeof (ubuf.usage_l_rbytes),

"%llu", usage->du_rbytes);

(void) snprintf(ubuf.usage_l_obytes, sizeof (ubuf.usage_l_obytes),

"%llu", usage->du_obytes);

(void) snprintf(ubuf.usage_l_bandwidth, sizeof (ubuf.usage_l_bandwidth),

"%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));

ofmt_print(state->us_ofmt, &ubuf);

return (DLADM_STATUS_OK);

}

static int

show_usage_res(dladm_usage_t *usage, void *arg)

{

show_usage_state_t *state = (show_usage_state_t *)arg;

char buf[DLADM_STRSIZE];

usage_fields_buf_t ubuf;

dladm_status_t status;

uint32_t flags;

/*

if (!state->us_showall) {

if ((status = dladm_name2info(handle, usage->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

bzero(&ubuf, sizeof (ubuf));

(void) snprintf(ubuf.usage_link, sizeof (ubuf.usage_link), "%s",

usage->du_name);

(void) snprintf(ubuf.usage_duration, sizeof (ubuf.usage_duration),

"%llu", usage->du_duration);

(void) snprintf(ubuf.usage_ipackets, sizeof (ubuf.usage_ipackets),

"%llu", usage->du_ipackets);

(void) snprintf(ubuf.usage_rbytes, sizeof (ubuf.usage_rbytes),

"%llu", usage->du_rbytes);

(void) snprintf(ubuf.usage_opackets, sizeof (ubuf.usage_opackets),

"%llu", usage->du_opackets);

(void) snprintf(ubuf.usage_obytes, sizeof (ubuf.usage_obytes),

"%llu", usage->du_obytes);

(void) snprintf(ubuf.usage_bandwidth, sizeof (ubuf.usage_bandwidth),

"%s Mbps", dladm_bw2str(usage->du_bandwidth, buf));

ofmt_print(state->us_ofmt, &ubuf);

return (DLADM_STATUS_OK);

}

static boolean_t

valid_formatspec(char *formatspec_str)

{

if (strcmp(formatspec_str, "gnuplot") == 0)

return (B_TRUE);

return (B_FALSE);

}

static void

do_show_usage(int argc, char *argv[], const char *use)

{

char *file = NULL;

int opt;

dladm_status_t status;

boolean_t d_arg = B_FALSE;

char *stime = NULL;

char *etime = NULL;

char *resource = NULL;

show_usage_state_t state;

boolean_t o_arg = B_FALSE;

boolean_t F_arg = B_FALSE;

char *fields_str = NULL;

char *formatspec_str = NULL;

char *all_l_fields =

"link,start,end,rbytes,obytes,bandwidth";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = 0;

bzero(&state, sizeof (show_usage_state_t));

state.us_parsable = B_FALSE;

state.us_printheader = B_FALSE;

state.us_plot = B_FALSE;

state.us_first = B_TRUE;

while ((opt = getopt_long(argc, argv, "das:e:o:f:F:",

usage_opts, NULL)) != -1) {

switch (opt) {

case 'd':

d_arg = B_TRUE;

break;

case 'a':

state.us_showall = B_TRUE;

break;

case 'f':

file = optarg;

break;

case 's':

stime = optarg;

break;

case 'e':

etime = optarg;

break;

case 'o':

o_arg = B_TRUE;

fields_str = optarg;

break;

case 'F':

state.us_plot = F_arg = B_TRUE;

formatspec_str = optarg;

break;

default:

die_opterr(optopt, opt, use);

break;

}

}

if (file == NULL)

die("show-usage requires a file");

if (optind == (argc-1)) {

uint32_t flags;

resource = argv[optind];

if (!state.us_showall &&

(((status = dladm_name2info(handle, resource, NULL, &flags,

NULL, NULL)) != DLADM_STATUS_OK) ||

((flags & DLADM_OPT_ACTIVE) == 0))) {

die("invalid link: '%s'", resource);

}

}

if (F_arg && d_arg)

die("incompatible -d and -F options");

if (F_arg && valid_formatspec(formatspec_str) == B_FALSE)

die("Format specifier %s not supported", formatspec_str);

if (state.us_parsable)

ofmtflags |= OFMT_PARSABLE;

if (resource == NULL && stime == NULL && etime == NULL) {

oferr = ofmt_open(fields_str, usage_fields, ofmtflags, 0,

&ofmt);

} else {

if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))

fields_str = all_l_fields;

oferr = ofmt_open(fields_str, usage_l_fields, ofmtflags, 0,

&ofmt);

}

dladm_ofmt_check(oferr, state.us_parsable, ofmt);

state.us_ofmt = ofmt;

if (d_arg) {

/* Print log dates */

status = dladm_usage_dates(show_usage_date,

DLADM_LOGTYPE_LINK, file, resource, &state);

} else if (resource == NULL && stime == NULL && etime == NULL &&

!F_arg) {

/* Print summary */

status = dladm_usage_summary(show_usage_res,

DLADM_LOGTYPE_LINK, file, &state);

} else if (resource != NULL) {

/* Print log entries for named resource */

status = dladm_walk_usage_res(show_usage_time,

DLADM_LOGTYPE_LINK, file, resource, stime, etime, &state);

} else {

/* Print time and information for each link */

status = dladm_walk_usage_time(show_usage_time,

DLADM_LOGTYPE_LINK, file, stime, etime, &state);

}

if (status != DLADM_STATUS_OK)

die_dlerr(status, "show-usage");

ofmt_close(ofmt);

}

static void

do_create_aggr(int argc, char *argv[], const char *use)

{

char option;

int key = 0;

uint32_t policy = AGGR_POLICY_L4;

aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;

aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;

dladm_aggr_port_attr_db_t port[MAXPORT];

uint_t n, ndev, nlink;

uint8_t mac_addr[ETHERADDRL];

boolean_t mac_addr_fixed = B_FALSE;

boolean_t P_arg = B_FALSE;

boolean_t l_arg = B_FALSE;

boolean_t u_arg = B_FALSE;

boolean_t T_arg = B_FALSE;

uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;

char *altroot = NULL;

char name[MAXLINKNAMELEN];

char *devs[MAXPORT];

char *links[MAXPORT];

dladm_status_t status;

dladm_status_t pstatus;

char propstr[DLADM_STRSIZE];

dladm_arg_list_t *proplist = NULL;

int i;

datalink_id_t linkid;

ndev = nlink = opterr = 0;

bzero(propstr, DLADM_STRSIZE);

while ((option = getopt_long(argc, argv, ":d:l:L:P:R:tfu:T:p:",

lopts, NULL)) != -1) {

switch (option) {

case 'd':

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

devs[ndev++] = optarg;

break;

case 'P':

if (P_arg)

die_optdup(option);

P_arg = B_TRUE;

if (!dladm_aggr_str2policy(optarg, &policy))

die("invalid policy '%s'", optarg);

break;

case 'u':

if (u_arg)

die_optdup(option);

u_arg = B_TRUE;

if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,

mac_addr))

die("invalid MAC address '%s'", optarg);

break;

case 'l':

if (isdigit(optarg[strlen(optarg) - 1])) {

/*

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

links[nlink++] = optarg;

break;

}

/* FALLTHROUGH */

case 'L':

if (l_arg)

die_optdup(option);

l_arg = B_TRUE;

if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))

die("invalid LACP mode '%s'", optarg);

break;

case 'T':

if (T_arg)

die_optdup(option);

T_arg = B_TRUE;

if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))

die("invalid LACP timer value '%s'", optarg);

break;

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'f':

flags |= DLADM_OPT_FORCE;

break;

case 'R':

altroot = optarg;

break;

case 'p':

(void) strlcat(propstr, optarg, DLADM_STRSIZE);

if (strlcat(propstr, ",", DLADM_STRSIZE) >=

DLADM_STRSIZE)

die("property list too long '%s'", propstr);

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (ndev + nlink == 0)

usage();

/* get key value or the aggregation name (required last argument) */

if (optind != (argc-1))

usage();

if (!str2int(argv[optind], &key)) {

if (strlcpy(name, argv[optind], MAXLINKNAMELEN) >=

MAXLINKNAMELEN) {

die("link name too long '%s'", argv[optind]);

}

if (!dladm_valid_linkname(name))

die("invalid link name '%s'", argv[optind]);

} else {

(void) snprintf(name, MAXLINKNAMELEN, "aggr%d", key);

}

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

for (n = 0; n < ndev; n++) {

if ((status = dladm_dev2linkid(handle, devs[n],

&port[n].lp_linkid)) != DLADM_STATUS_OK) {

die_dlerr(status, "invalid dev name '%s'", devs[n]);

}

}

for (n = 0; n < nlink; n++) {

if ((status = dladm_name2info(handle, links[n],

&port[ndev + n].lp_linkid, NULL, NULL, NULL)) !=

DLADM_STATUS_OK) {

die_dlerr(status, "invalid link name '%s'", links[n]);

}

}

status = dladm_aggr_create(handle, name, key, ndev + nlink, port,

policy, mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode,

lacp_timer, flags);

if (status != DLADM_STATUS_OK)

goto done;

if (dladm_parse_link_props(propstr, &proplist, B_FALSE)

!= DLADM_STATUS_OK)

die("invalid aggregation property");

if (proplist == NULL)

return;

status = dladm_name2info(handle, name, &linkid, NULL, NULL, NULL);

if (status != DLADM_STATUS_OK)

goto done;

for (i = 0; i < proplist->al_count; i++) {

dladm_arg_info_t *aip = &proplist->al_info[i];

pstatus = dladm_set_linkprop(handle, linkid, aip->ai_name,

aip->ai_val, aip->ai_count, flags);

if (pstatus != DLADM_STATUS_OK) {

die_dlerr(pstatus,

"aggr creation succeeded but "

"could not set property '%s'", aip->ai_name);

}

}

done:

dladm_free_props(proplist);

if (status != DLADM_STATUS_OK) {

if (status == DLADM_STATUS_NONOTIF) {

die_dlerr(status, "not all links have link up/down "

"detection; must use -f (see dladm(1M))\n");

} else {

die_dlerr(status, "create operation failed");

}

}

}

static dladm_status_t

i_dladm_aggr_get_linkid(const char *altroot, const char *arg,

datalink_id_t *linkidp, uint32_t flags)

{

int key = 0;

char *aggr = NULL;

dladm_status_t status;

if (!str2int(arg, &key))

aggr = (char *)arg;

if (aggr == NULL && key == 0)

return (DLADM_STATUS_LINKINVAL);

if (altroot != NULL)

return (DLADM_STATUS_OK);

if (aggr != NULL) {

status = dladm_name2info(handle, aggr, linkidp, NULL, NULL,

NULL);

} else {

status = dladm_key2linkid(handle, key, linkidp, flags);

}

return (status);

}

static void

do_delete_aggr(int argc, char *argv[], const char *use)

{

char option;

char *altroot = NULL;

uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;

dladm_status_t status;

datalink_id_t linkid;

opterr = 0;

while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {

switch (option) {

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

/* get key value or the aggregation name (required last argument) */

if (optind != (argc-1))

usage();

status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);

if (status != DLADM_STATUS_OK)

goto done;

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

status = dladm_aggr_delete(handle, linkid, flags);

done:

if (status != DLADM_STATUS_OK)

die_dlerr(status, "delete operation failed");

}

static void

do_add_aggr(int argc, char *argv[], const char *use)

{

char option;

uint_t n, ndev, nlink;

char *altroot = NULL;

uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;

datalink_id_t linkid;

dladm_status_t status;

dladm_aggr_port_attr_db_t port[MAXPORT];

char *devs[MAXPORT];

char *links[MAXPORT];

ndev = nlink = opterr = 0;

while ((option = getopt_long(argc, argv, ":d:l:R:tf", lopts,

NULL)) != -1) {

switch (option) {

case 'd':

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

devs[ndev++] = optarg;

break;

case 'l':

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

links[nlink++] = optarg;

break;

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'f':

flags |= DLADM_OPT_FORCE;

break;

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (ndev + nlink == 0)

usage();

/* get key value or the aggregation name (required last argument) */

if (optind != (argc-1))

usage();

if ((status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid,

flags & (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST))) !=

DLADM_STATUS_OK) {

goto done;

}

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

for (n = 0; n < ndev; n++) {

if ((status = dladm_dev2linkid(handle, devs[n],

&(port[n].lp_linkid))) != DLADM_STATUS_OK) {

die_dlerr(status, "invalid <dev> '%s'", devs[n]);

}

}

for (n = 0; n < nlink; n++) {

if ((status = dladm_name2info(handle, links[n],

&port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=

DLADM_STATUS_OK) {

die_dlerr(status, "invalid <link> '%s'", links[n]);

}

}

status = dladm_aggr_add(handle, linkid, ndev + nlink, port, flags);

done:

if (status != DLADM_STATUS_OK) {

/*

if (status == DLADM_STATUS_NOTSUP) {

(void) fprintf(stderr,

gettext("%s: add operation failed: %s\n"),

progname,

gettext("link capabilities don't match"));

dladm_close(handle);

exit(ENOTSUP);

} else if (status == DLADM_STATUS_NONOTIF) {

die_dlerr(status, "not all links have link up/down "

"detection; must use -f (see dladm(1M))\n");

} else {

die_dlerr(status, "add operation failed");

}

}

}

static void

do_remove_aggr(int argc, char *argv[], const char *use)

{

char option;

dladm_aggr_port_attr_db_t port[MAXPORT];

uint_t n, ndev, nlink;

char *devs[MAXPORT];

char *links[MAXPORT];

char *altroot = NULL;

uint32_t flags;

datalink_id_t linkid;

dladm_status_t status;

flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;

ndev = nlink = opterr = 0;

while ((option = getopt_long(argc, argv, ":d:l:R:t",

lopts, NULL)) != -1) {

switch (option) {

case 'd':

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

devs[ndev++] = optarg;

break;

case 'l':

if (ndev + nlink >= MAXPORT)

die("too many ports specified");

links[nlink++] = optarg;

break;

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (ndev + nlink == 0)

usage();

/* get key value or the aggregation name (required last argument) */

if (optind != (argc-1))

usage();

status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);

if (status != DLADM_STATUS_OK)

goto done;

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

for (n = 0; n < ndev; n++) {

if ((status = dladm_dev2linkid(handle, devs[n],

&(port[n].lp_linkid))) != DLADM_STATUS_OK) {

die_dlerr(status, "invalid <dev> '%s'", devs[n]);

}

}

for (n = 0; n < nlink; n++) {

if ((status = dladm_name2info(handle, links[n],

&port[n + ndev].lp_linkid, NULL, NULL, NULL)) !=

DLADM_STATUS_OK) {

die_dlerr(status, "invalid <link> '%s'", links[n]);

}

}

status = dladm_aggr_remove(handle, linkid, ndev + nlink, port, flags);

done:

if (status != DLADM_STATUS_OK)

die_dlerr(status, "remove operation failed");

}

static void

do_modify_aggr(int argc, char *argv[], const char *use)

{

char option;

uint32_t policy = AGGR_POLICY_L4;

aggr_lacp_mode_t lacp_mode = AGGR_LACP_OFF;

aggr_lacp_timer_t lacp_timer = AGGR_LACP_TIMER_SHORT;

uint8_t mac_addr[ETHERADDRL];

boolean_t mac_addr_fixed = B_FALSE;

uint8_t modify_mask = 0;

char *altroot = NULL;

uint32_t flags = DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST;

datalink_id_t linkid;

dladm_status_t status;

opterr = 0;

while ((option = getopt_long(argc, argv, ":L:l:P:R:tu:T:", lopts,

NULL)) != -1) {

switch (option) {

case 'P':

if (modify_mask & DLADM_AGGR_MODIFY_POLICY)

die_optdup(option);

modify_mask |= DLADM_AGGR_MODIFY_POLICY;

if (!dladm_aggr_str2policy(optarg, &policy))

die("invalid policy '%s'", optarg);

break;

case 'u':

if (modify_mask & DLADM_AGGR_MODIFY_MAC)

die_optdup(option);

modify_mask |= DLADM_AGGR_MODIFY_MAC;

if (!dladm_aggr_str2macaddr(optarg, &mac_addr_fixed,

mac_addr))

die("invalid MAC address '%s'", optarg);

break;

case 'l':

case 'L':

if (modify_mask & DLADM_AGGR_MODIFY_LACP_MODE)

die_optdup(option);

modify_mask |= DLADM_AGGR_MODIFY_LACP_MODE;

if (!dladm_aggr_str2lacpmode(optarg, &lacp_mode))

die("invalid LACP mode '%s'", optarg);

break;

case 'T':

if (modify_mask & DLADM_AGGR_MODIFY_LACP_TIMER)

die_optdup(option);

modify_mask |= DLADM_AGGR_MODIFY_LACP_TIMER;

if (!dladm_aggr_str2lacptimer(optarg, &lacp_timer))

die("invalid LACP timer value '%s'", optarg);

break;

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (modify_mask == 0)

die("at least one of the -PulT options must be specified");

/* get key value or the aggregation name (required last argument) */

if (optind != (argc-1))

usage();

status = i_dladm_aggr_get_linkid(altroot, argv[optind], &linkid, flags);

if (status != DLADM_STATUS_OK)

goto done;

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

status = dladm_aggr_modify(handle, linkid, modify_mask, policy,

mac_addr_fixed, (const uchar_t *)mac_addr, lacp_mode, lacp_timer,

flags);

done:

if (status != DLADM_STATUS_OK)

die_dlerr(status, "modify operation failed");

}

static void

do_up_aggr(int argc, char *argv[], const char *use)

{

datalink_id_t linkid = DATALINK_ALL_LINKID;

dladm_status_t status;

/*

if (argc == 2) {

if ((status = i_dladm_aggr_get_linkid(NULL, argv[1], &linkid,

DLADM_OPT_PERSIST)) != DLADM_STATUS_OK)

goto done;

} else if (argc > 2) {

usage();

}

status = dladm_aggr_up(handle, linkid);

done:

if (status != DLADM_STATUS_OK) {

if (argc == 2) {

die_dlerr(status,

"could not bring up aggregation '%s'", argv[1]);

} else {

die_dlerr(status, "could not bring aggregations up");

}

}

}

static void

do_create_vlan(int argc, char *argv[], const char *use)

{

char *link = NULL;

char drv[DLPI_LINKNAME_MAX];

uint_t ppa;

datalink_id_t linkid;

datalink_id_t dev_linkid;

int vid = 0;

char option;

uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);

char *altroot = NULL;

char vlan[MAXLINKNAMELEN];

char propstr[DLADM_STRSIZE];

dladm_arg_list_t *proplist = NULL;

dladm_status_t status;

opterr = 0;

bzero(propstr, DLADM_STRSIZE);

while ((option = getopt_long(argc, argv, ":tfR:l:v:p:",

lopts, NULL)) != -1) {

switch (option) {

case 'v':

if (vid != 0)

die_optdup(option);

if (!str2int(optarg, &vid) || vid < 1 || vid > 4094)

die("invalid VLAN identifier '%s'", optarg);

break;

case 'l':

if (link != NULL)

die_optdup(option);

link = optarg;

break;

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'R':

altroot = optarg;

break;

case 'p':

(void) strlcat(propstr, optarg, DLADM_STRSIZE);

if (strlcat(propstr, ",", DLADM_STRSIZE) >=

DLADM_STRSIZE)

die("property list too long '%s'", propstr);

break;

case 'f':

flags |= DLADM_OPT_FORCE;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

/* get vlan name if there is any */

if ((vid == 0) || (link == NULL) || (argc - optind > 1))

usage();

if (optind == (argc - 1)) {

if (strlcpy(vlan, argv[optind], MAXLINKNAMELEN) >=

MAXLINKNAMELEN) {

die("vlan name too long '%s'", argv[optind]);

}

} else {

if ((dlpi_parselink(link, drv, &ppa) != DLPI_SUCCESS) ||

(ppa >= 1000) ||

(dlpi_makelink(vlan, drv, vid * 1000 + ppa) !=

DLPI_SUCCESS)) {

die("invalid link name '%s'", link);

}

}

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

if (dladm_name2info(handle, link, &dev_linkid, NULL, NULL, NULL) !=

DLADM_STATUS_OK) {

die("invalid link name '%s'", link);

}

if (dladm_parse_link_props(propstr, &proplist, B_FALSE)

!= DLADM_STATUS_OK)

die("invalid vlan property");

if ((status = dladm_vlan_create(handle, vlan, dev_linkid, vid, proplist,

flags, &linkid)) != DLADM_STATUS_OK) {

die_dlerr(status, "create operation over %s failed", link);

}

}

static void

do_delete_vlan(int argc, char *argv[], const char *use)

{

char option;

uint32_t flags = (DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);

char *altroot = NULL;

datalink_id_t linkid;

dladm_status_t status;

opterr = 0;

while ((option = getopt_long(argc, argv, ":R:t", lopts, NULL)) != -1) {

switch (option) {

case 't':

flags &= ~DLADM_OPT_PERSIST;

break;

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

/* get VLAN link name (required last argument) */

if (optind != (argc - 1))

usage();

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

status = dladm_name2info(handle, argv[optind], &linkid, NULL, NULL,

NULL);

if (status != DLADM_STATUS_OK)

goto done;

status = dladm_vlan_delete(handle, linkid, flags);

done:

if (status != DLADM_STATUS_OK)

die_dlerr(status, "delete operation failed");

}

static void

do_up_vlan(int argc, char *argv[], const char *use)

{

do_up_vnic_common(argc, argv, use, B_TRUE);

}

static void

do_rename_link(int argc, char *argv[], const char *use)

{

char option;

char *link1, *link2;

char *altroot = NULL;

dladm_status_t status;

opterr = 0;

while ((option = getopt_long(argc, argv, ":R:", lopts, NULL)) != -1) {

switch (option) {

case 'R':

altroot = optarg;

break;

default:

die_opterr(optopt, option, use);

break;

}

}

/* get link1 and link2 name (required the last 2 arguments) */

if (optind != (argc - 2))

usage();

if (altroot != NULL)

altroot_cmd(altroot, argc, argv);

link1 = argv[optind++];

link2 = argv[optind];

if ((status = dladm_rename_link(handle, link1, link2)) !=

DLADM_STATUS_OK)

die_dlerr(status, "rename operation failed");

}

static void

do_delete_phys(int argc, char *argv[], const char *use)

{

datalink_id_t linkid = DATALINK_ALL_LINKID;

dladm_status_t status;

/* get link name (required the last argument) */

if (argc > 2)

usage();

if (argc == 2) {

if ((status = dladm_name2info(handle, argv[1], &linkid, NULL,

NULL, NULL)) != DLADM_STATUS_OK)

die_dlerr(status, "cannot delete '%s'", argv[1]);

}

if ((status = dladm_phys_delete(handle, linkid)) != DLADM_STATUS_OK) {

if (argc == 2)

die_dlerr(status, "cannot delete '%s'", argv[1]);

else

die_dlerr(status, "delete operation failed");

}

}

static int

i_dladm_walk_linkmap(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

char name[MAXLINKNAMELEN];

char mediabuf[DLADM_STRSIZE];

char classbuf[DLADM_STRSIZE];

datalink_class_t class;

uint32_t media;

uint32_t flags;

if (dladm_datalink_id2info(dh, linkid, &flags, &class, &media, name,

MAXLINKNAMELEN) == DLADM_STATUS_OK) {

(void) dladm_class2str(class, classbuf);

(void) dladm_media2str(media, mediabuf);

(void) printf("%-12s%8d %-12s%-20s %6d\n", name,

linkid, classbuf, mediabuf, flags);

}

return (DLADM_WALK_CONTINUE);

}

static void

do_show_linkmap(int argc, char *argv[], const char *use)

{

if (argc != 1)

die("invalid arguments");

(void) printf("%-12s%8s %-12s%-20s %6s\n", "NAME", "LINKID",

"CLASS", "MEDIA", "FLAGS");

(void) dladm_walk_datalink_id(i_dladm_walk_linkmap, handle, NULL,

DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,

DLADM_OPT_ACTIVE | DLADM_OPT_PERSIST);

}

static int

purge_phys(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

datalink_class_t class;

uint32_t flags;

if (dladm_datalink_id2info(dh, linkid, &flags, &class, NULL, NULL, 0)

!= DLADM_STATUS_OK) {

return (DLADM_WALK_CONTINUE);

}

if (class == DATALINK_CLASS_PHYS && !(flags & DLADM_OPT_ACTIVE))

(void) dladm_phys_delete(dh, linkid);

return (DLADM_WALK_CONTINUE);

}

static void

do_init_phys(int argc, char *argv[], const char *use)

{

di_node_t devtree;

if (argc > 1)

usage();

/*

if ((devtree = di_init("/", DINFOFORCE | DINFOSUBTREE)) != DI_NODE_NIL)

di_fini(devtree);

(void) dladm_walk_datalink_id(purge_phys, handle, NULL,

DATALINK_CLASS_PHYS, DATALINK_ANY_MEDIATYPE, DLADM_OPT_PERSIST);

}

static dladm_status_t

print_link_topology(show_state_t *state, datalink_id_t linkid,

datalink_class_t class, link_fields_buf_t *lbuf)

{

uint32_t flags = state->ls_flags;

dladm_status_t status = DLADM_STATUS_OK;

char tmpbuf[MAXLINKNAMELEN];

(void) sprintf(lbuf->link_over, "");

if (class == DATALINK_CLASS_VLAN) {

dladm_vlan_attr_t vinfo;

status = dladm_vlan_info(handle, linkid, &vinfo, flags);

if (status != DLADM_STATUS_OK)

goto done;

status = dladm_datalink_id2info(handle, vinfo.dv_linkid, NULL,

NULL, NULL, lbuf->link_over, sizeof (lbuf->link_over));

if (status != DLADM_STATUS_OK)

goto done;

} else if (class == DATALINK_CLASS_AGGR) {

dladm_aggr_grp_attr_t ginfo;

int i;

(void) sprintf(lbuf->link_over, "");

status = dladm_aggr_info(handle, linkid, &ginfo, flags);

if (status != DLADM_STATUS_OK)

goto done;

if (ginfo.lg_nports == 0) {

status = DLADM_STATUS_BADVAL;

goto done;

}

for (i = 0; i < ginfo.lg_nports; i++) {

status = dladm_datalink_id2info(handle,

ginfo.lg_ports[i].lp_linkid, NULL, NULL, NULL,

tmpbuf, sizeof (tmpbuf));

if (status != DLADM_STATUS_OK) {

free(ginfo.lg_ports);

goto done;

}

(void) strlcat(lbuf->link_over, tmpbuf,

sizeof (lbuf->link_over));

if (i != (ginfo.lg_nports - 1)) {

(void) strlcat(lbuf->link_over, " ",

sizeof (lbuf->link_over));

}

}

free(ginfo.lg_ports);

} else if (class == DATALINK_CLASS_VNIC) {

dladm_vnic_attr_t vinfo;

if ((status = dladm_vnic_info(handle, linkid, &vinfo, flags)) !=

DLADM_STATUS_OK ||

(status = dladm_datalink_id2info(handle, vinfo.va_link_id,

NULL, NULL, NULL, lbuf->link_over,

sizeof (lbuf->link_over)) != DLADM_STATUS_OK)) {

goto done;

}

}

done:

return (status);

}

static dladm_status_t

print_link(show_state_t *state, datalink_id_t linkid, link_fields_buf_t *lbuf)

{

char link[MAXLINKNAMELEN];

datalink_class_t class;

uint_t mtu;

uint32_t flags;

dladm_status_t status;

if ((status = dladm_datalink_id2info(handle, linkid, &flags, &class,

NULL, link, sizeof (link))) != DLADM_STATUS_OK) {

goto done;

}

if (!(state->ls_flags & flags)) {

status = DLADM_STATUS_NOTFOUND;

goto done;

}

if (state->ls_flags == DLADM_OPT_ACTIVE) {

dladm_attr_t dlattr;

if (class == DATALINK_CLASS_PHYS) {

dladm_phys_attr_t dpa;

dlpi_handle_t dh;

dlpi_info_t dlinfo;

if ((status = dladm_phys_info(handle, linkid, &dpa,

DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {

goto done;

}

if (!dpa.dp_novanity)

goto link_mtu;

/*

if (dlpi_open(dpa.dp_dev, &dh, DLPI_DEVONLY) !=

DLPI_SUCCESS) {

status = DLADM_STATUS_NOTFOUND;

goto done;

}

if (dlpi_info(dh, &dlinfo, 0) != DLPI_SUCCESS) {

dlpi_close(dh);

status = DLADM_STATUS_BADARG;

goto done;

}

dlpi_close(dh);

mtu = dlinfo.di_max_sdu;

} else {

link_mtu:

status = dladm_info(handle, linkid, &dlattr);

if (status != DLADM_STATUS_OK)

goto done;

mtu = dlattr.da_max_sdu;

}

}

(void) snprintf(lbuf->link_name, sizeof (lbuf->link_name),

"%s", link);

(void) dladm_class2str(class, lbuf->link_class);

if (state->ls_flags == DLADM_OPT_ACTIVE) {

(void) snprintf(lbuf->link_mtu, sizeof (lbuf->link_mtu),

"%u", mtu);

(void) get_linkstate(link, B_TRUE, lbuf->link_state);

}

status = print_link_topology(state, linkid, class, lbuf);

if (status != DLADM_STATUS_OK)

goto done;

done:

return (status);

}

static int

show_link(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

show_state_t *state = (show_state_t *)arg;

dladm_status_t status;

link_fields_buf_t lbuf;

/*

bzero(&lbuf, sizeof (link_fields_buf_t));

status = print_link(state, linkid, &lbuf);

if (status != DLADM_STATUS_OK)

goto done;

ofmt_print(state->ls_ofmt, &lbuf);

done:

state->ls_status = status;

return (DLADM_WALK_CONTINUE);

}

static boolean_t

print_link_stats_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)

{

link_args_t *largs = ofarg->ofmt_cbarg;

pktsum_t *diff_stats = largs->link_s_psum;

switch (ofarg->ofmt_id) {

case LINK_S_LINK:

(void) snprintf(buf, bufsize, "%s", largs->link_s_link);

break;

case LINK_S_IPKTS:

(void) snprintf(buf, bufsize, "%llu", diff_stats->ipackets);

break;

case LINK_S_RBYTES:

(void) snprintf(buf, bufsize, "%llu", diff_stats->rbytes);

break;

case LINK_S_IERRORS:

(void) snprintf(buf, bufsize, "%u", diff_stats->ierrors);

break;

case LINK_S_OPKTS:

(void) snprintf(buf, bufsize, "%llu", diff_stats->opackets);

break;

case LINK_S_OBYTES:

(void) snprintf(buf, bufsize, "%llu", diff_stats->obytes);

break;

case LINK_S_OERRORS:

(void) snprintf(buf, bufsize, "%u", diff_stats->oerrors);

break;

default:

die("invalid input");

break;

}

return (B_TRUE);

}

static int

show_link_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

char link[DLPI_LINKNAME_MAX];

datalink_class_t class;

show_state_t *state = (show_state_t *)arg;

pktsum_t stats, diff_stats;

dladm_phys_attr_t dpa;

link_args_t largs;

if (state->ls_firstonly) {

if (state->ls_donefirst)

return (DLADM_WALK_CONTINUE);

state->ls_donefirst = B_TRUE;

} else {

bzero(&state->ls_prevstats, sizeof (state->ls_prevstats));

}

if (dladm_datalink_id2info(dh, linkid, NULL, &class, NULL, link,

DLPI_LINKNAME_MAX) != DLADM_STATUS_OK) {

return (DLADM_WALK_CONTINUE);

}

if (class == DATALINK_CLASS_PHYS) {

if (dladm_phys_info(dh, linkid, &dpa, DLADM_OPT_ACTIVE) !=

DLADM_STATUS_OK) {

return (DLADM_WALK_CONTINUE);

}

if (dpa.dp_novanity)

get_mac_stats(dpa.dp_dev, &stats);

else

get_link_stats(link, &stats);

} else {

get_link_stats(link, &stats);

}

dladm_stats_diff(&diff_stats, &stats, &state->ls_prevstats);

largs.link_s_link = link;

largs.link_s_psum = &diff_stats;

ofmt_print(state->ls_ofmt, &largs);

state->ls_prevstats = stats;

return (DLADM_WALK_CONTINUE);

}

static dladm_status_t

print_aggr_info(show_grp_state_t *state, const char *link,

dladm_aggr_grp_attr_t *ginfop)

{

char addr_str[ETHERADDRL * 3];

laggr_fields_buf_t lbuf;

(void) snprintf(lbuf.laggr_name, sizeof (lbuf.laggr_name),

"%s", link);

(void) dladm_aggr_policy2str(ginfop->lg_policy,

lbuf.laggr_policy);

if (ginfop->lg_mac_fixed) {

(void) dladm_aggr_macaddr2str(ginfop->lg_mac, addr_str);

(void) snprintf(lbuf.laggr_addrpolicy,

sizeof (lbuf.laggr_addrpolicy), "fixed (%s)", addr_str);

} else {

(void) snprintf(lbuf.laggr_addrpolicy,

sizeof (lbuf.laggr_addrpolicy), "auto");

}

(void) dladm_aggr_lacpmode2str(ginfop->lg_lacp_mode,

lbuf.laggr_lacpactivity);

(void) dladm_aggr_lacptimer2str(ginfop->lg_lacp_timer,

lbuf.laggr_lacptimer);

(void) snprintf(lbuf.laggr_flags, sizeof (lbuf.laggr_flags), "%c----",

ginfop->lg_force ? 'f' : '-');

ofmt_print(state->gs_ofmt, &lbuf);

return (DLADM_STATUS_OK);

}

static boolean_t

print_xaggr_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)

{

const laggr_args_t *l = ofarg->ofmt_cbarg;

int portnum;

boolean_t is_port = (l->laggr_lport >= 0);

static char tmpbuf[DLADM_STRSIZE];

dladm_aggr_port_attr_t *portp;

dladm_phys_attr_t dpa;

dladm_status_t *stat, status = DLADM_STATUS_OK;

stat = l->laggr_status;

if (is_port) {

portnum = l->laggr_lport;

portp = &(l->laggr_ginfop->lg_ports[portnum]);

if ((status = dladm_datalink_id2info(handle,

portp->lp_linkid, NULL, NULL, NULL, buf, bufsize)) !=

DLADM_STATUS_OK) {

goto err;

}

if ((status = dladm_phys_info(handle, portp->lp_linkid,

&dpa, DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {

goto err;

}

}

switch (ofarg->ofmt_id) {

case AGGR_X_LINK:

(void) snprintf(buf, bufsize, "%s",

(is_port && !l->laggr_parsable ? " " : l->laggr_link));

break;

case AGGR_X_PORT:

if (is_port)

break;

*stat = DLADM_STATUS_OK;

return (B_TRUE);

case AGGR_X_SPEED:

if (is_port) {

(void) snprintf(buf, bufsize, "%uMb",

(uint_t)((get_ifspeed(dpa.dp_dev,

B_FALSE)) / 1000000ull));

} else {

(void) snprintf(buf, bufsize, "%uMb",

(uint_t)((get_ifspeed(l->laggr_link,

B_TRUE)) / 1000000ull));

}

break;

case AGGR_X_DUPLEX:

if (is_port)

(void) get_linkduplex(dpa.dp_dev, B_FALSE, tmpbuf);

else

(void) get_linkduplex(l->laggr_link, B_TRUE, tmpbuf);

(void) strlcpy(buf, tmpbuf, bufsize);

break;

case AGGR_X_STATE:

if (is_port)

(void) get_linkstate(dpa.dp_dev, B_FALSE, tmpbuf);

else

(void) get_linkstate(l->laggr_link, B_TRUE, tmpbuf);

(void) strlcpy(buf, tmpbuf, bufsize);

break;

case AGGR_X_ADDRESS:

(void) dladm_aggr_macaddr2str(

(is_port ? portp->lp_mac : l->laggr_ginfop->lg_mac),

tmpbuf);

(void) strlcpy(buf, tmpbuf, bufsize);

break;

case AGGR_X_PORTSTATE:

if (is_port) {

(void) dladm_aggr_portstate2str(portp->lp_state,

tmpbuf);

(void) strlcpy(buf, tmpbuf, bufsize);

}

break;

}

err:

*stat = status;

return (B_TRUE);

}

static dladm_status_t

print_aggr_extended(show_grp_state_t *state, const char *link,

dladm_aggr_grp_attr_t *ginfop)

{

int i;

dladm_status_t status;

laggr_args_t largs;

largs.laggr_lport = -1;

largs.laggr_link = link;

largs.laggr_ginfop = ginfop;

largs.laggr_status = &status;

largs.laggr_parsable = state->gs_parsable;

ofmt_print(state->gs_ofmt, &largs);

if (status != DLADM_STATUS_OK)

goto done;

for (i = 0; i < ginfop->lg_nports; i++) {

largs.laggr_lport = i;

ofmt_print(state->gs_ofmt, &largs);

if (status != DLADM_STATUS_OK)

goto done;

}

status = DLADM_STATUS_OK;

done: