#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>

#define STR_UNDEF_VAL "--"

#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 CMD_TYPE_ANY 0xffffffff

#define WIFI_CMD_SCAN 0x00000001

#define WIFI_CMD_SHOW 0x00000002

#define WIFI_CMD_ALL (WIFI_CMD_SCAN | WIFI_CMD_SHOW)

typedef struct print_field_s {

const char *pf_name; /* name of column to be printed */

const char *pf_header; /* header for this column */

uint_t pf_width;

union {

uint_t _pf_index; /* private index for sub-command */

size_t _pf_offset;

}_pf_un;

#define pf_index _pf_un._pf_index

#define pf_offset _pf_un._pf_offset;

uint_t pf_cmdtype;

} print_field_t;

typedef struct print_state_s {

print_field_t **ps_fields;

uint_t ps_nfields;

boolean_t ps_lastfield;

uint_t ps_overflow;

} print_state_t;

typedef char *(*print_callback_t)(print_field_t *, void *);

static print_field_t **parse_output_fields(char *, print_field_t *, int,

uint_t, uint_t *);

static void print_header(print_state_t *);

static void print_field(print_state_t *, print_field_t *, const char *,

boolean_t);

static void dladm_print_output(print_state_t *, boolean_t,

print_callback_t, void *);

static char *dladm_print_field(print_field_t *, void *);

#define MAX_FIELD_LEN 32

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;

print_state_t ls_print;

boolean_t ls_parseable;

boolean_t ls_printheader;

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

boolean_t gs_lacp;

boolean_t gs_extended;

boolean_t gs_stats;

boolean_t gs_firstonly;

boolean_t gs_donefirst;

boolean_t gs_printheader;

print_state_t gs_print;

} 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_parseable;

boolean_t vs_printheader;

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;

print_state_t vs_print;

} show_vnic_state_t;

typedef struct show_usage_state_s {

boolean_t us_plot;

boolean_t us_parseable;

boolean_t us_printheader;

boolean_t us_first;

print_state_t us_print;

} show_usage_state_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 [-d|-p -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'},

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

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

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

{ 0, 0, 0, 0 }

};

static const struct option wifi_longopts[] = {

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

{"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 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 print_field_t ether_fields[] = {

{ "link", "LINK", 15,

offsetof(ether_fields_buf_t, eth_link), CMD_TYPE_ANY},

{ "ptype", "PTYPE", 8,

offsetof(ether_fields_buf_t, eth_ptype), CMD_TYPE_ANY},

{ "state", "STATE", 8,

offsetof(ether_fields_buf_t, eth_state), CMD_TYPE_ANY},

{ "auto", "AUTO", 5,

offsetof(ether_fields_buf_t, eth_autoneg), CMD_TYPE_ANY},

{ "speed-duplex", "SPEED-DUPLEX", 31,

offsetof(ether_fields_buf_t, eth_spdx), CMD_TYPE_ANY},

{ "pause", "PAUSE", 6,

offsetof(ether_fields_buf_t, eth_pause), CMD_TYPE_ANY},

{ "rem_fault", "REM_FAULT", 16,

offsetof(ether_fields_buf_t, eth_rem_fault), CMD_TYPE_ANY}}

;

#define ETHER_MAX_FIELDS (sizeof (ether_fields) / sizeof (print_field_t))

typedef struct print_ether_state {

const char *es_link;

boolean_t es_parseable;

boolean_t es_header;

boolean_t es_extended;

print_state_t es_print;

} print_ether_state_t;

typedef enum {

DEVS_LINK,

DEVS_IPKTS,

DEVS_RBYTES,

DEVS_IERRORS,

DEVS_OPKTS,

DEVS_OBYTES,

DEVS_OERRORS

} devs_field_index_t;

static print_field_t devs_fields[] = {

{ "link", "LINK", 15, DEVS_LINK, CMD_TYPE_ANY},

{ "ipackets", "IPACKETS", 10, DEVS_IPKTS, CMD_TYPE_ANY},

{ "rbytes", "RBYTES", 8, DEVS_RBYTES, CMD_TYPE_ANY},

{ "ierrors", "IERRORS", 10, DEVS_IERRORS, CMD_TYPE_ANY},

{ "opackets", "OPACKETS", 12, DEVS_OPKTS, CMD_TYPE_ANY},

{ "obytes", "OBYTES", 12, DEVS_OBYTES, CMD_TYPE_ANY},

{ "oerrors", "OERRORS", 8, DEVS_OERRORS, CMD_TYPE_ANY}}

;

#define DEVS_MAX_FIELDS (sizeof (devs_fields) / sizeof (print_field_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 print_field_t link_fields[] = {

{ "link", "LINK", 11,

offsetof(link_fields_buf_t, link_name), CMD_TYPE_ANY},

{ "class", "CLASS", 8,

offsetof(link_fields_buf_t, link_class), CMD_TYPE_ANY},

{ "mtu", "MTU", 6,

offsetof(link_fields_buf_t, link_mtu), CMD_TYPE_ANY},

{ "state", "STATE", 8,

offsetof(link_fields_buf_t, link_state), CMD_TYPE_ANY},

{ "over", "OVER", DLPI_LINKNAME_MAX,

offsetof(link_fields_buf_t, link_over), CMD_TYPE_ANY}}

;

#define DEV_LINK_FIELDS (sizeof (link_fields) / sizeof (print_field_t))

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_prevstats; /* -s only */

boolean_t laggr_parseable;

} laggr_args_t;

static print_field_t laggr_fields[] = {

{ "link", "LINK", 15,

offsetof(laggr_fields_buf_t, laggr_name), CMD_TYPE_ANY},

{ "policy", "POLICY", 8,

offsetof(laggr_fields_buf_t, laggr_policy), CMD_TYPE_ANY},

{ "addrpolicy", "ADDRPOLICY", ETHERADDRL * 3 + 2,

offsetof(laggr_fields_buf_t, laggr_addrpolicy), CMD_TYPE_ANY},

{ "lacpactivity", "LACPACTIVITY", 13,

offsetof(laggr_fields_buf_t, laggr_lacpactivity), CMD_TYPE_ANY},

{ "lacptimer", "LACPTIMER", 11,

offsetof(laggr_fields_buf_t, laggr_lacptimer), CMD_TYPE_ANY},

{ "flags", "FLAGS", 7,

offsetof(laggr_fields_buf_t, laggr_flags), CMD_TYPE_ANY}}

;

#define LAGGR_MAX_FIELDS (sizeof (laggr_fields) / sizeof (print_field_t))

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 print_field_t aggr_x_fields[] = {

{ "link", "LINK", 11, AGGR_X_LINK, CMD_TYPE_ANY},

{ "port", "PORT", 14, AGGR_X_PORT, CMD_TYPE_ANY},

{ "speed", "SPEED", 4, AGGR_X_SPEED, CMD_TYPE_ANY},

{ "duplex", "DUPLEX", 9, AGGR_X_DUPLEX, CMD_TYPE_ANY},

{ "state", "STATE", 9, AGGR_X_STATE, CMD_TYPE_ANY},

{ "address", "ADDRESS", 18, AGGR_X_ADDRESS, CMD_TYPE_ANY},

{ "portstate", "PORTSTATE", 15, AGGR_X_PORTSTATE, CMD_TYPE_ANY}}

;

#define AGGR_X_MAX_FIELDS \

(sizeof (aggr_x_fields) / sizeof (print_field_t))

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 print_field_t aggr_s_fields[] = {

{ "link", "LINK", 11, AGGR_S_LINK,

CMD_TYPE_ANY},

{ "port", "PORT", 9, AGGR_S_PORT,

CMD_TYPE_ANY},

{ "ipackets", "IPACKETS", 7, AGGR_S_IPKTS,

CMD_TYPE_ANY},

{ "rbytes", "RBYTES", 7, AGGR_S_RBYTES,

CMD_TYPE_ANY},

{ "opackets", "OPACKETS", 7, AGGR_S_OPKTS,

CMD_TYPE_ANY},

{ "obytes", "OBYTES", 7, AGGR_S_OBYTES,

CMD_TYPE_ANY},

{ "ipktdist", "IPKTDIST", 8, AGGR_S_IPKTDIST,

CMD_TYPE_ANY},

{ "opktdist", "OPKTDIST", 14, AGGR_S_OPKTDIST,

CMD_TYPE_ANY}}

;

#define AGGR_S_MAX_FIELDS \

(sizeof (aggr_s_fields) / sizeof (print_field_t))

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 print_field_t aggr_l_fields[] = {

{ "link", "LINK", 11, AGGR_L_LINK,

CMD_TYPE_ANY},

{ "port", "PORT", 12, AGGR_L_PORT,

CMD_TYPE_ANY},

{ "aggregatable", "AGGREGATABLE", 12, AGGR_L_AGGREGATABLE,

CMD_TYPE_ANY},

{ "sync", "SYNC", 4, AGGR_L_SYNC,

CMD_TYPE_ANY},

{ "coll", "COLL", 4, AGGR_L_COLL,

CMD_TYPE_ANY},

{ "dist", "DIST", 4, AGGR_L_DIST,

CMD_TYPE_ANY},

{ "defaulted", "DEFAULTED", 9, AGGR_L_DEFAULTED,

CMD_TYPE_ANY},

{ "expired", "EXPIRED", 14, AGGR_L_EXPIRED,

CMD_TYPE_ANY}}

;

#define AGGR_L_MAX_FIELDS \

(sizeof (aggr_l_fields) / sizeof (print_field_t))

static print_field_t phys_fields[] = {

{ "link", "LINK", 12,

offsetof(link_fields_buf_t, link_name), CMD_TYPE_ANY},

{ "media", "MEDIA", 20,

offsetof(link_fields_buf_t, link_phys_media), CMD_TYPE_ANY},

{ "state", "STATE", 10,

offsetof(link_fields_buf_t, link_phys_state), CMD_TYPE_ANY},

{ "speed", "SPEED", 6,

offsetof(link_fields_buf_t, link_phys_speed), CMD_TYPE_ANY},

{ "duplex", "DUPLEX", 9,

offsetof(link_fields_buf_t, link_phys_duplex), CMD_TYPE_ANY},

{ "device", "DEVICE", 12,

offsetof(link_fields_buf_t, link_phys_device), CMD_TYPE_ANY},

{ "flags", "FLAGS", 6,

offsetof(link_fields_buf_t, link_flags), CMD_TYPE_ANY}}

;

#define PHYS_MAX_FIELDS (sizeof (phys_fields) / sizeof (print_field_t))

typedef enum {

PHYS_M_LINK,

PHYS_M_SLOT,

PHYS_M_ADDRESS,

PHYS_M_INUSE,

PHYS_M_CLIENT

} phys_m_field_index_t;

static print_field_t phys_m_fields[] = {

{ "link", "LINK", 12, PHYS_M_LINK, CMD_TYPE_ANY},

{ "slot", "SLOT", 8, PHYS_M_SLOT, CMD_TYPE_ANY},

{ "address", "ADDRESS", 18, PHYS_M_ADDRESS, CMD_TYPE_ANY},

{ "inuse", "INUSE", 4, PHYS_M_INUSE, CMD_TYPE_ANY},

{ "client", "CLIENT", 12, PHYS_M_CLIENT, CMD_TYPE_ANY}}

;

#define PHYS_M_MAX_FIELDS (sizeof (phys_m_fields) / sizeof (print_field_t))

typedef enum {

PHYS_H_LINK,

PHYS_H_GROUP,

PHYS_H_GRPTYPE,

PHYS_H_RINGS,

PHYS_H_CLIENTS

} phys_h_field_index_t;

static print_field_t phys_h_fields[] = {

{ "link", "LINK", 12, PHYS_H_LINK, CMD_TYPE_ANY},

{ "group", "GROUP", 8, PHYS_H_GROUP, CMD_TYPE_ANY},

{ "grouptype", "TYPE", 6, PHYS_H_GRPTYPE, CMD_TYPE_ANY},

{ "rings", "NUM-RINGS", 16, PHYS_H_RINGS, CMD_TYPE_ANY},

{ "clients", "CLIENTS", 20, PHYS_H_CLIENTS, CMD_TYPE_ANY}}

;

#define PHYS_H_MAX_FIELDS (sizeof (phys_h_fields) / sizeof (print_field_t))

static print_field_t vlan_fields[] = {

{ "link", "LINK", 15,

offsetof(link_fields_buf_t, link_name), CMD_TYPE_ANY},

{ "vid", "VID", 8,

offsetof(link_fields_buf_t, link_vlan_vid), CMD_TYPE_ANY},

{ "over", "OVER", 12,

offsetof(link_fields_buf_t, link_over), CMD_TYPE_ANY},

{ "flags", "FLAGS", 6,

offsetof(link_fields_buf_t, link_flags), CMD_TYPE_ANY}}

;

#define VLAN_MAX_FIELDS (sizeof (vlan_fields) / sizeof (print_field_t))

static print_field_t wifi_fields[] = {

{ "link", "LINK", 10, 0, WIFI_CMD_ALL},

{ "essid", "ESSID", 19, DLADM_WLAN_ATTR_ESSID, WIFI_CMD_ALL},

{ "bssid", "BSSID/IBSSID", 17, DLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},

{ "ibssid", "BSSID/IBSSID", 17, DLADM_WLAN_ATTR_BSSID, WIFI_CMD_ALL},

{ "mode", "MODE", 6, DLADM_WLAN_ATTR_MODE, WIFI_CMD_ALL},

{ "speed", "SPEED", 6, DLADM_WLAN_ATTR_SPEED, WIFI_CMD_ALL},

{ "auth", "AUTH", 8, DLADM_WLAN_ATTR_AUTH, WIFI_CMD_SHOW},

{ "bsstype", "BSSTYPE", 8, DLADM_WLAN_ATTR_BSSTYPE, WIFI_CMD_ALL},

{ "sec", "SEC", 6, DLADM_WLAN_ATTR_SECMODE, WIFI_CMD_ALL},

{ "status", "STATUS", 17, DLADM_WLAN_LINKATTR_STATUS, WIFI_CMD_SHOW},

{ "strength", "STRENGTH", 10, DLADM_WLAN_ATTR_STRENGTH, WIFI_CMD_ALL}}

;

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

#define WIFI_MAX_FIELDS (sizeof (wifi_fields) / sizeof (print_field_t))

typedef enum {

LINKPROP_LINK,

LINKPROP_PROPERTY,

LINKPROP_PERM,

LINKPROP_VALUE,

LINKPROP_DEFAULT,

LINKPROP_POSSIBLE

} linkprop_field_index_t;

static print_field_t linkprop_fields[] = {

{ "link", "LINK", 12, LINKPROP_LINK, CMD_TYPE_ANY},

{ "property", "PROPERTY", 15, LINKPROP_PROPERTY, CMD_TYPE_ANY},

{ "perm", "PERM", 4, LINKPROP_PERM, CMD_TYPE_ANY},

{ "value", "VALUE", 14, LINKPROP_VALUE, CMD_TYPE_ANY},

{ "default", "DEFAULT", 14, LINKPROP_DEFAULT, CMD_TYPE_ANY},

{ "possible", "POSSIBLE", 20, LINKPROP_POSSIBLE, CMD_TYPE_ANY}}

;

#define LINKPROP_MAX_FIELDS \

(sizeof (linkprop_fields) / sizeof (print_field_t))

#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_parseable;

boolean_t ls_persist;

boolean_t ls_header;

dladm_status_t ls_status;

dladm_status_t ls_retstatus;

print_state_t ls_print;

} 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 print_field_t secobj_fields[] = {

{ "object", "OBJECT", 20,

offsetof(secobj_fields_buf_t, ss_obj_name), CMD_TYPE_ANY},

{ "class", "CLASS", 20,

offsetof(secobj_fields_buf_t, ss_class), CMD_TYPE_ANY},

{ "value", "VALUE", 30,

offsetof(secobj_fields_buf_t, ss_val), CMD_TYPE_ANY}}

;

#define DEV_SOBJ_FIELDS (sizeof (secobj_fields) / sizeof (print_field_t))

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 print_field_t vnic_fields[] = {

{ "link", "LINK", 12,

offsetof(vnic_fields_buf_t, vnic_link), CMD_TYPE_ANY},

{ "over", "OVER", 12,

offsetof(vnic_fields_buf_t, vnic_over), CMD_TYPE_ANY},

{ "speed", "SPEED", 6,

offsetof(vnic_fields_buf_t, vnic_speed), CMD_TYPE_ANY},

{ "macaddr", "MACADDRESS", 20,

offsetof(vnic_fields_buf_t, vnic_macaddr), CMD_TYPE_ANY},

{ "macaddrtype", "MACADDRTYPE", 19,

offsetof(vnic_fields_buf_t, vnic_macaddrtype), CMD_TYPE_ANY},

{ "vid", "VID", 6,

offsetof(vnic_fields_buf_t, vnic_vid), CMD_TYPE_ANY}}

;

#define VNIC_MAX_FIELDS (sizeof (vnic_fields) / sizeof (print_field_t))

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 print_field_t usage_fields[] = {

{ "link", "LINK", 12,

offsetof(usage_fields_buf_t, usage_link), CMD_TYPE_ANY},

{ "duration", "DURATION", 10,

offsetof(usage_fields_buf_t, usage_duration), CMD_TYPE_ANY},

{ "ipackets", "IPACKETS", 9,

offsetof(usage_fields_buf_t, usage_ipackets), CMD_TYPE_ANY},

{ "rbytes", "RBYTES", 10,

offsetof(usage_fields_buf_t, usage_rbytes), CMD_TYPE_ANY},

{ "opackets", "OPACKETS", 9,

offsetof(usage_fields_buf_t, usage_opackets), CMD_TYPE_ANY},

{ "obytes", "OBYTES", 10,

offsetof(usage_fields_buf_t, usage_obytes), CMD_TYPE_ANY},

{ "bandwidth", "BANDWIDTH", 14,

offsetof(usage_fields_buf_t, usage_bandwidth), CMD_TYPE_ANY}}

;

#define USAGE_MAX_FIELDS (sizeof (usage_fields) / sizeof (print_field_t))

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 print_field_t usage_l_fields[] = {

{ "link", "LINK", 12,

offsetof(usage_l_fields_buf_t, usage_l_link), CMD_TYPE_ANY},

{ "start", "START", 13,

offsetof(usage_l_fields_buf_t, usage_l_stime), CMD_TYPE_ANY},

{ "end", "END", 13,

offsetof(usage_l_fields_buf_t, usage_l_etime), CMD_TYPE_ANY},

{ "rbytes", "RBYTES", 8,

offsetof(usage_l_fields_buf_t, usage_l_rbytes), CMD_TYPE_ANY},

{ "obytes", "OBYTES", 8,

offsetof(usage_l_fields_buf_t, usage_l_obytes), CMD_TYPE_ANY},

{ "bandwidth", "BANDWIDTH", 14,

offsetof(usage_l_fields_buf_t, usage_l_bandwidth), CMD_TYPE_ANY}}

;

#define USAGE_L_MAX_FIELDS \

(sizeof (usage_l_fields) /sizeof (print_field_t))

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)

{

time_t stime;

char timebuf[20];

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;

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

if (!state->us_parseable && !state->us_printheader) {

print_header(&state->us_print);

state->us_printheader = B_TRUE;

}

dladm_print_output(&state->us_print, state->us_parseable,

dladm_print_field, (void *)&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;

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

if (!state->us_parseable && !state->us_printheader) {

print_header(&state->us_print);

state->us_printheader = B_TRUE;

}

dladm_print_output(&state->us_print, state->us_parseable,

dladm_print_field, (void *)&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;

boolean_t p_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;

print_field_t **fields;

uint_t nfields;

char *all_fields =

"link,duration,ipackets,rbytes,opackets,obytes,bandwidth";

char *all_l_fields =

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

bzero(&state, sizeof (show_usage_state_t));

state.us_parseable = B_FALSE;

state.us_printheader = B_FALSE;

state.us_plot = B_FALSE;

state.us_first = B_TRUE;

while ((opt = getopt(argc, argv, "dps:e:o:f:F:")) != -1) {

switch (opt) {

case 'd':

d_arg = B_TRUE;

break;

case 'p':

state.us_plot = p_arg = 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':

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

resource = argv[optind];

}

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

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

fields_str = all_fields;

fields = parse_output_fields(fields_str, usage_fields,

USAGE_MAX_FIELDS, CMD_TYPE_ANY, &nfields);

} else {

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

fields_str = all_l_fields;

fields = parse_output_fields(fields_str, usage_l_fields,

USAGE_L_MAX_FIELDS, CMD_TYPE_ANY, &nfields);

}

if (fields == NULL) {

die("invalid fields(s) specified");

return;

}

state.us_print.ps_fields = fields;

state.us_print.ps_nfields = nfields;

if (p_arg && d_arg)

die("plot and date options are incompatible");

if (p_arg && !F_arg)

die("specify format speicifier: -F <format>");

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

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

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 &&

!p_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");

}

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;

dladm_arg_list_t *proplist = NULL;

int i;

datalink_id_t linkid;

ndev = nlink = opterr = 0;

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':

if (dladm_parse_link_props(optarg, &proplist, B_FALSE)

!= DLADM_STATUS_OK)

die("invalid aggregation property");

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 (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];

dladm_arg_list_t *proplist = NULL;

dladm_status_t status;

opterr = 0;

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':

if (dladm_parse_link_props(optarg, &proplist, B_FALSE)

!= DLADM_STATUS_OK) {

die("invalid vlan property");

}

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 ((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];

if (!state->ls_parseable)

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

else

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

if (!state->ls_parseable && !state->ls_printheader) {

print_header(&state->ls_print);

state->ls_printheader = B_TRUE;

}

dladm_print_output(&state->ls_print, state->ls_parseable,

dladm_print_field, (void *)&lbuf);

done:

state->ls_status = status;

return (DLADM_WALK_CONTINUE);

}

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;

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

(void) printf("%-12s", link);

(void) printf("%-10llu", diff_stats.ipackets);

(void) printf("%-12llu", diff_stats.rbytes);

(void) printf("%-8llu", diff_stats.ierrors);

(void) printf("%-10llu", diff_stats.opackets);

(void) printf("%-12llu", diff_stats.obytes);

(void) printf("%-8llu\n", diff_stats.oerrors);

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

if (!state->gs_parseable && !state->gs_printheader) {

print_header(&state->gs_print);

state->gs_printheader = B_TRUE;

}

dladm_print_output(&state->gs_print, state->gs_parseable,

dladm_print_field, (void *)&lbuf);

return (DLADM_STATUS_OK);

}

static char *

print_xaggr_callback(print_field_t *pf, void *arg)

{

const laggr_args_t *l = arg;

int portnum;

static char buf[DLADM_STRSIZE];

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

dladm_aggr_port_attr_t *portp;

dladm_phys_attr_t dpa;

dladm_status_t *stat, status;

stat = l->laggr_status;

*stat = DLADM_STATUS_OK;

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, sizeof (buf))) !=

DLADM_STATUS_OK) {

goto err;

}

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

&dpa, DLADM_OPT_ACTIVE)) != DLADM_STATUS_OK) {

goto err;

}

}

switch (pf->pf_index) {

case AGGR_X_LINK:

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

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

break;

case AGGR_X_PORT:

if (is_port)

break;

return ("");

break;

case AGGR_X_SPEED:

if (is_port) {

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

(uint_t)((get_ifspeed(dpa.dp_dev,

B_FALSE)) / 1000000ull));

} else {

(void) snprintf(buf, sizeof (buf), "%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, buf);