#include <stdio.h>

#include <ctype.h>

#include <dlfcn.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 <limits.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 <libdliptun.h>

#include <libdlsim.h>

#include <libdlbridge.h>

#include <libinetutil.h>

#include <libvrrpadm.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 <stp_in.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 brsum_s {

uint64_t drops;

uint64_t forward_dir;

uint64_t forward_mb;

uint64_t forward_unk;

uint64_t recv;

uint64_t sent;

} brsum_t;

typedef struct brlsum_s {

uint32_t cfgbpdu;

uint32_t tcnbpdu;

uint32_t rstpbpdu;

uint32_t txbpdu;

uint64_t drops;

uint64_t recv;

uint64_t xmit;

} brlsum_t;

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_create_simnet, do_modify_simnet;

static cmdfunc_t do_delete_simnet, do_show_simnet, do_up_simnet;

static cmdfunc_t do_show_usage;

static cmdfunc_t do_create_bridge, do_modify_bridge, do_delete_bridge;

static cmdfunc_t do_add_bridge, do_remove_bridge, do_show_bridge;

static cmdfunc_t do_create_iptun, do_modify_iptun, do_delete_iptun;

static cmdfunc_t do_show_iptun, do_up_iptun, do_down_iptun;

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 iptun_type_t iptun_gettypebyname(char *);

static const char *iptun_gettypebyvalue(iptun_type_t);

static dladm_status_t print_iptun(dladm_handle_t, datalink_id_t,

show_state_t *);

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

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 },

{ "create-iptun", do_create_iptun,

" create-iptun [-t] -T <type> "

"[-a {local|remote}=<addr>,...] <link>]" },

{ "delete-iptun", do_delete_iptun,

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

{ "modify-iptun", do_modify_iptun,

" modify-iptun [-t] -a {local|remote}=<addr>,... <link>" },

{ "show-iptun", do_show_iptun,

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

{ "up-iptun", do_up_iptun, NULL },

{ "down-iptun", do_down_iptun, 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 {vrrp -V <vrid> -A {inet | inet6}} [-v <vid> [-f]]\n"

"\t\t [-H] [-p <prop>=<value>[,...]] <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" },

{ "create-simnet", do_create_simnet, NULL },

{ "modify-simnet", do_modify_simnet, NULL },

{ "delete-simnet", do_delete_simnet, NULL },

{ "show-simnet", do_show_simnet, NULL },

{ "up-simnet", do_up_simnet, NULL },

{ "create-bridge", do_create_bridge,

" create-bridge [-R <root-dir>] [-P <protect>] "

"[-p <priority>]\n"

"\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"

"\t\t [-f <force-protocol>] [-l <link>]... <bridge>" },

{ "modify-bridge", do_modify_bridge,

" modify-bridge [-R <root-dir>] [-P <protect>] "

"[-p <priority>]\n"

"\t\t [-m <max-age>] [-h <hello-time>] [-d <forward-delay>]\n"

"\t\t [-f <force-protocol>] <bridge>" },

{ "delete-bridge", do_delete_bridge,

" delete-bridge [-R <root-dir>] <bridge>" },

{ "add-bridge", do_add_bridge,

" add-bridge [-R <root-dir>] -l <link> [-l <link>]... "

"<bridge>" },

{ "remove-bridge", do_remove_bridge,

" remove-bridge [-R <root-dir>] -l <link> [-l <link>]... "

"<bridge>" },

{ "show-bridge", do_show_bridge,

" show-bridge [-p] [-o <field>,...] [-s [-i <interval>]] "

"[<bridge>]\n"

" show-bridge -l [-p] [-o <field>,...] [-s [-i <interval>]]"

" <bridge>\n"

" show-bridge -f [-p] [-o <field>,...] [-s [-i <interval>]]"

" <bridge>\n"

" show-bridge -t [-p] [-o <field>,...] [-s [-i <interval>]]"

" <bridge>\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 iptun_lopts[] = {

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

{"tunnel-type", required_argument, 0, 'T'},

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

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

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

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

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

{ 0, 0, 0, 0 }

};

static char * const iptun_addropts[] = {

#define IPTUN_LOCAL 0

"local",

#define IPTUN_REMOTE 1

"remote",

NULL};

static const struct {

const char *type_name;

iptun_type_t type_value;

} iptun_types[] = {

{"ipv4", IPTUN_TYPE_IPV4},

{"ipv6", IPTUN_TYPE_IPV6},

{"6to4", IPTUN_TYPE_6TO4},

{NULL, 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' },

{"vrid", required_argument, 0, 'V' },

{"address-family", required_argument, 0, 'A' },

{ 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 struct option simnet_lopts[] = {

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

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

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

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

{ 0, 0, 0, 0 }

};

static const struct option bridge_lopts[] = {

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

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

{ "forward-delay", required_argument, 0, 'd' },

{ "force-protocol", required_argument, 0, 'f' },

{ "hello-time", required_argument, 0, 'h' },

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

{ "max-age", required_argument, 0, 'm' },

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

{ NULL, NULL, 0, 0 }

};

static const struct option bridge_show_lopts[] = {

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

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

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

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

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

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

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

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

{ 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 const 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 const 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_bridge[MAXLINKNAMELEN];

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 const ofmt_field_t link_fields[] = {

{ "LINK", 12,

offsetof(link_fields_buf_t, link_name), print_default_cb},

{ "CLASS", 10,

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},

{ "BRIDGE", 11,

offsetof(link_fields_buf_t, link_bridge), 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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 const 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", 20, 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 const 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[18];

char vnic_macaddrtype[19];

char vnic_vid[6];

} vnic_fields_buf_t;

static const 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", 18,

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 simnet_fields_buf_s

{

char simnet_name[DLPI_LINKNAME_MAX];

char simnet_media[DLADM_STRSIZE];

char simnet_macaddr[18];

char simnet_otherlink[DLPI_LINKNAME_MAX];

} simnet_fields_buf_t;

static const ofmt_field_t simnet_fields[] = {

{ "LINK", 12,

offsetof(simnet_fields_buf_t, simnet_name), print_default_cb},

{ "MEDIA", 20,

offsetof(simnet_fields_buf_t, simnet_media), print_default_cb},

{ "MACADDRESS", 18,

offsetof(simnet_fields_buf_t, simnet_macaddr), print_default_cb},

{ "OTHERLINK", 12,

offsetof(simnet_fields_buf_t, simnet_otherlink), 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 const 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 const 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}}

;

enum { IPTUN_SFLAG_INDEX, IPTUN_IFLAG_INDEX, IPTUN_NUM_FLAGS };

typedef struct iptun_fields_buf_s {

char iptun_name[MAXLINKNAMELEN];

char iptun_type[5];

char iptun_laddr[NI_MAXHOST];

char iptun_raddr[NI_MAXHOST];

char iptun_flags[IPTUN_NUM_FLAGS + 1];

} iptun_fields_buf_t;

static const ofmt_field_t iptun_fields[] = {

{ "LINK", 16,

offsetof(iptun_fields_buf_t, iptun_name), print_default_cb },

{ "TYPE", 6,

offsetof(iptun_fields_buf_t, iptun_type), print_default_cb },

{ "FLAGS", 7,

offsetof(iptun_fields_buf_t, iptun_flags), print_default_cb },

{ "LOCAL", 20,

offsetof(iptun_fields_buf_t, iptun_laddr), print_default_cb },

{ "REMOTE", 20,

offsetof(iptun_fields_buf_t, iptun_raddr), print_default_cb },

{ NULL, 0, 0, NULL}

};

typedef struct bridge_fields_buf_s {

char bridge_name[MAXLINKNAMELEN]; /* 14.4.1.2.3(b) */

char bridge_protect[7]; /* stp or trill */

char bridge_address[24]; /* 17.18.3, 7.12.5, 14.4.1.2.3(a) */

char bridge_priority[7]; /* 17.18.3 9.2.5 - only upper 4 bits */

char bridge_bmaxage[7]; /* 17.18.4 configured */

char bridge_bhellotime[7]; /* 17.18.4 configured */

char bridge_bfwddelay[7]; /* 17.18.4 configured */

char bridge_forceproto[3]; /* 17.13.4 configured */

char bridge_tctime[12]; /* 14.8.1.1.3(b) */

char bridge_tccount[12]; /* 17.17.8 */

char bridge_tchange[12]; /* 17.17.8 */

char bridge_desroot[24]; /* 17.18.6 priority "/" MAC */

char bridge_rootcost[12]; /* 17.18.6 */

char bridge_rootport[12]; /* 17.18.6 */

char bridge_maxage[7]; /* 17.18.7 for root */

char bridge_hellotime[7]; /* 17.13.6 for root */

char bridge_fwddelay[7]; /* 17.13.5 for root */

char bridge_holdtime[12]; /* 17.13.12 for root */

} bridge_fields_buf_t;

static ofmt_field_t bridge_fields[] = {

{ "BRIDGE", 12,

offsetof(bridge_fields_buf_t, bridge_name), print_default_cb },

{ "PROTECT", 8,

offsetof(bridge_fields_buf_t, bridge_protect), print_default_cb },

{ "ADDRESS", 19,

offsetof(bridge_fields_buf_t, bridge_address), print_default_cb },

{ "PRIORITY", 9,

offsetof(bridge_fields_buf_t, bridge_priority), print_default_cb },

{ "BMAXAGE", 8,

offsetof(bridge_fields_buf_t, bridge_bmaxage), print_default_cb },

{ "BHELLOTIME", 11,

offsetof(bridge_fields_buf_t, bridge_bhellotime), print_default_cb },

{ "BFWDDELAY", 10,

offsetof(bridge_fields_buf_t, bridge_bfwddelay), print_default_cb },

{ "FORCEPROTO", 11,

offsetof(bridge_fields_buf_t, bridge_forceproto), print_default_cb },

{ "TCTIME", 10,

offsetof(bridge_fields_buf_t, bridge_tctime), print_default_cb },

{ "TCCOUNT", 10,

offsetof(bridge_fields_buf_t, bridge_tccount), print_default_cb },

{ "TCHANGE", 10,

offsetof(bridge_fields_buf_t, bridge_tchange), print_default_cb },

{ "DESROOT", 23,

offsetof(bridge_fields_buf_t, bridge_desroot), print_default_cb },

{ "ROOTCOST", 11,

offsetof(bridge_fields_buf_t, bridge_rootcost), print_default_cb },

{ "ROOTPORT", 11,

offsetof(bridge_fields_buf_t, bridge_rootport), print_default_cb },

{ "MAXAGE", 8,

offsetof(bridge_fields_buf_t, bridge_maxage), print_default_cb },

{ "HELLOTIME", 10,

offsetof(bridge_fields_buf_t, bridge_hellotime), print_default_cb },

{ "FWDDELAY", 9,

offsetof(bridge_fields_buf_t, bridge_fwddelay), print_default_cb },

{ "HOLDTIME", 9,

offsetof(bridge_fields_buf_t, bridge_holdtime), print_default_cb },

{ NULL, 0, 0, NULL}};

typedef struct bridge_link_fields_buf_s {

char bridgel_link[MAXLINKNAMELEN];

char bridgel_index[7]; /* 14.4.1.2.3(d1) */

char bridgel_state[11]; /* 14.8.2.1.3(b) */

char bridgel_uptime[7]; /* 14.8.2.1.3(a) */

char bridgel_opercost[7] /* 14.8.2.1.3(d) */;

char bridgel_operp2p[4]; /* 14.8.2.1.3(p) */

char bridgel_operedge[4]; /* 14.8.2.1.3(k) */

char bridgel_desroot[23]; /* 14.8.2.1.3(e) */

char bridgel_descost[12]; /* 14.8.2.1.3(f) */

char bridgel_desbridge[23]; /* 14.8.2.1.3(g) */

char bridgel_desport[7]; /* 14.8.2.1.3(h) */

char bridgel_tcack[4]; /* 14.8.2.1.3(i) */

} bridge_link_fields_buf_t;

static ofmt_field_t bridge_link_fields[] = {

{ "LINK", 12,

offsetof(bridge_link_fields_buf_t, bridgel_link), print_default_cb },

{ "INDEX", 8,

offsetof(bridge_link_fields_buf_t, bridgel_index), print_default_cb },

{ "STATE", 12,

offsetof(bridge_link_fields_buf_t, bridgel_state), print_default_cb },

{ "UPTIME", 8,

offsetof(bridge_link_fields_buf_t, bridgel_uptime), print_default_cb },

{ "OPERCOST", 9,

offsetof(bridge_link_fields_buf_t, bridgel_opercost), print_default_cb },

{ "OPERP2P", 8,

offsetof(bridge_link_fields_buf_t, bridgel_operp2p), print_default_cb },

{ "OPEREDGE", 9,

offsetof(bridge_link_fields_buf_t, bridgel_operedge), print_default_cb },

{ "DESROOT", 22,

offsetof(bridge_link_fields_buf_t, bridgel_desroot), print_default_cb },

{ "DESCOST", 11,

offsetof(bridge_link_fields_buf_t, bridgel_descost), print_default_cb },

{ "DESBRIDGE", 22,

offsetof(bridge_link_fields_buf_t, bridgel_desbridge), print_default_cb },

{ "DESPORT", 8,

offsetof(bridge_link_fields_buf_t, bridgel_desport), print_default_cb },

{ "TCACK", 6,

offsetof(bridge_link_fields_buf_t, bridgel_tcack), print_default_cb },

{ NULL, 0, 0, NULL}};

#define ULONG_DIG (((sizeof (ulong_t) * NBBY) * 3 / 10) + 1)

#define UINT64_DIG (((sizeof (uint64_t) * NBBY) * 3 / 10) + 1)

typedef struct bridge_statfields_buf_s {

char bridges_name[MAXLINKNAMELEN];

char bridges_drops[UINT64_DIG];

char bridges_forwards[UINT64_DIG];

char bridges_mbcast[UINT64_DIG];

char bridges_unknown[UINT64_DIG];

char bridges_recv[UINT64_DIG];

char bridges_sent[UINT64_DIG];

} bridge_statfields_buf_t;

static ofmt_field_t bridge_statfields[] = {

{ "BRIDGE", 12,

offsetof(bridge_statfields_buf_t, bridges_name), print_default_cb },

{ "DROPS", 12,

offsetof(bridge_statfields_buf_t, bridges_drops), print_default_cb },

{ "FORWARDS", 12,

offsetof(bridge_statfields_buf_t, bridges_forwards), print_default_cb },

{ "MBCAST", 12,

offsetof(bridge_statfields_buf_t, bridges_mbcast), print_default_cb },

{ "UNKNOWN", 12,

offsetof(bridge_statfields_buf_t, bridges_unknown), print_default_cb },

{ "RECV", 12,

offsetof(bridge_statfields_buf_t, bridges_recv), print_default_cb },

{ "SENT", 12,

offsetof(bridge_statfields_buf_t, bridges_sent), print_default_cb },

{ NULL, 0, 0, NULL}};

typedef struct bridge_link_statfields_buf_s {

char bridgels_link[MAXLINKNAMELEN];

char bridgels_cfgbpdu[ULONG_DIG];

char bridgels_tcnbpdu[ULONG_DIG];

char bridgels_rstpbpdu[ULONG_DIG];

char bridgels_txbpdu[ULONG_DIG];

char bridgels_drops[UINT64_DIG]; /* 14.6.1.1.3(d) */

char bridgels_recv[UINT64_DIG]; /* 14.6.1.1.3(a) */

char bridgels_xmit[UINT64_DIG]; /* 14.6.1.1.3(c) */

} bridge_link_statfields_buf_t;

static ofmt_field_t bridge_link_statfields[] = {

{ "LINK", 12,

offsetof(bridge_link_statfields_buf_t, bridgels_link), print_default_cb },

{ "CFGBPDU", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_cfgbpdu),

print_default_cb },

{ "TCNBPDU", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_tcnbpdu),

print_default_cb },

{ "RSTPBPDU", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_rstpbpdu),

print_default_cb },

{ "TXBPDU", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_txbpdu), print_default_cb },

{ "DROPS", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_drops), print_default_cb },

{ "RECV", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_recv), print_default_cb },

{ "XMIT", 9,

offsetof(bridge_link_statfields_buf_t, bridgels_xmit), print_default_cb },

{ NULL, 0, 0, NULL}};

typedef struct bridge_fwd_fields_buf_s {

char bridgef_dest[18]; /* 14.7.6.3.3(a) */

char bridgef_age[8];

char bridgef_flags[6];

char bridgef_output[MAXLINKNAMELEN]; /* 14.7.6.3.3(c) */

} bridge_fwd_fields_buf_t;

static ofmt_field_t bridge_fwd_fields[] = {

{ "DEST", 17,

offsetof(bridge_fwd_fields_buf_t, bridgef_dest), print_default_cb },

{ "AGE", 7,

offsetof(bridge_fwd_fields_buf_t, bridgef_age), print_default_cb },

{ "FLAGS", 6,

offsetof(bridge_fwd_fields_buf_t, bridgef_flags), print_default_cb },

{ "OUTPUT", 12,

offsetof(bridge_fwd_fields_buf_t, bridgef_output), print_default_cb },

{ NULL, 0, 0, NULL}};

typedef struct bridge_trill_fields_buf_s {

char bridget_nick[6];

char bridget_flags[6];

char bridget_link[MAXLINKNAMELEN];

char bridget_nexthop[18];

} bridge_trill_fields_buf_t;

static ofmt_field_t bridge_trill_fields[] = {

{ "NICK", 5,

offsetof(bridge_trill_fields_buf_t, bridget_nick), print_default_cb },

{ "FLAGS", 6,

offsetof(bridge_trill_fields_buf_t, bridget_flags), print_default_cb },

{ "LINK", 12,

offsetof(bridge_trill_fields_buf_t, bridget_link), print_default_cb },

{ "NEXTHOP", 17,

offsetof(bridge_trill_fields_buf_t, bridget_nexthop), 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(EXIT_FAILURE);

}

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);

return (EXIT_SUCCESS);

}

}

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

progname, argv[1]);

usage();

return (EXIT_FAILURE);

}

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)

{

int 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("not all links have link up/down detection; must "

"use -f (see dladm(1M))");

} 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)

{

int 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)

{

int 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) {

die("add operation failed: link capabilities don't "

"match");

} else if (status == DLADM_STATUS_NONOTIF) {

die("not all links have link up/down detection; must "

"use -f (see dladm(1M))");

} else {

die_dlerr(status, "add operation failed");

}

}

}

static void

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

{

int 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)

{

int 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;

int 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");

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

flags, &linkid);

switch (status) {

case DLADM_STATUS_OK:

break;

case DLADM_STATUS_NOTSUP:

die("VLAN over '%s' may require lowered MTU; must use -f (see "

"dladm(1M))", link);

break;

case DLADM_STATUS_LINKBUSY:

die("VLAN over '%s' may not use default_tag ID", link);

break;

default:

die_dlerr(status, "create operation failed");

}

}

static void

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

{

int 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)

{

int 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,