int
_topo_init(topo_mod_t *mod, topo_version_t version)
{
dladm_handle_t handle;
if (getenv("TOPONICDEBUG") != NULL)
topo_mod_setdebug(mod);
topo_mod_dprintf(mod, "_mod_init: "
"initializing %s enumerator\n", NIC);
if (version != NIC_VERSION) {
return (-1);
}
if (dladm_open(&handle) != 0)
return (-1);
if (topo_mod_register(mod, &nic_mod, TOPO_VERSION) != 0) {
dladm_close(handle);
return (-1);
}
topo_mod_setspecific(mod, handle);
return (0);
}
int dladm_init() {
dladm_status_t dlstat;
char errmsg[DLADM_STRSIZE];
dlstat = dladm_open(&g_handle);
if (dlstat != DLADM_STATUS_OK) {
fprintf(stderr, "dladm_open: %s\n", dladm_status2str(dlstat, errmsg));
return 1;
}
return 0;
}
int
main(int argc, char *argv[])
{
int i, arglen, cmdlen;
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];
arglen = strlen(argv[1]);
cmdlen = strlen(cmdp->c_name);
if ((arglen == cmdlen) && (strncmp(argv[1], cmdp->c_name,
cmdlen) == 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]);
dladm_close(handle);
exit(EXIT_SUCCESS);
}
}
(void) fprintf(stderr, gettext("%s: unknown subcommand '%s'\n"),
progname, argv[1]);
usage();
return (0);
}
/*
* rcm_mod_init()
*
* Update registrations, and return the ops structure.
*/
struct rcm_mod_ops *
rcm_mod_init(void)
{
dladm_status_t status;
char errmsg[DLADM_STRSIZE];
cache_head.next = &cache_tail;
cache_head.prev = NULL;
cache_tail.prev = &cache_head;
cache_tail.next = NULL;
(void) mutex_init(&cache_lock, NULL, NULL);
if ((status = dladm_open(&dld_handle)) != DLADM_STATUS_OK) {
rcm_log_message(RCM_WARNING,
"NET: mod_init failed: cannot open datalink handle: %s\n",
dladm_status2str(status, errmsg));
return (NULL);
}
/* Return the ops vectors */
return (&net_ops);
}
/*ARGSUSED*/
void
dlpi_walk(dlpi_walkfunc_t *fn, void *arg, uint_t flags)
{
struct i_dlpi_walklink_arg warg;
struct dirent *d;
DIR *dp;
dladm_handle_t handle;
warg.fn = fn;
warg.arg = arg;
if (flags & DLPI_DEVIPNET) {
if ((dp = opendir("/dev/ipnet")) == NULL)
return;
while ((d = readdir(dp)) != NULL) {
if (d->d_name[0] == '.')
continue;
if (warg.fn(d->d_name, warg.arg))
break;
}
(void) closedir(dp);
} else {
/*
* Rather than have libdlpi take the libdladm handle,
* open the handle here.
*/
if (dladm_open(&handle) != DLADM_STATUS_OK)
return;
(void) dladm_walk(i_dlpi_walk_link, handle, &warg,
DATALINK_CLASS_ALL, DATALINK_ANY_MEDIATYPE,
DLADM_OPT_ACTIVE);
dladm_close(handle);
}
}
int
main(int argc, char *argv[])
{
dladm_status_t status;
int option;
boolean_t r_arg = B_FALSE;
boolean_t t_arg = B_FALSE;
boolean_t p_arg = B_FALSE;
boolean_t i_arg = B_FALSE;
boolean_t o_arg = B_FALSE;
boolean_t u_arg = B_FALSE;
boolean_t A_arg = B_FALSE;
boolean_t flow_arg = B_FALSE;
datalink_id_t linkid = DATALINK_ALL_LINKID;
char linkname[MAXLINKNAMELEN];
char flowname[MAXFLOWNAMELEN];
uint32_t interval = 0;
char unit = '\0';
show_flow_state_t state;
char *fields_str = NULL;
char *o_fields_str = NULL;
char *zonename = NULL;
char *total_stat_fields =
"flow,ipkts,rbytes,ierrs,opkts,obytes,oerrs";
char *rx_stat_fields =
"flow,ipkts,rbytes,ierrs";
char *tx_stat_fields =
"flow,opkts,obytes,oerrs";
ofmt_handle_t ofmt;
ofmt_status_t oferr;
uint_t ofmtflags = OFMT_RIGHTJUST;
dladm_flow_attr_t attr;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
progname = argv[0];
/* Open the libdladm handle */
if ((status = dladm_open(&handle)) != DLADM_STATUS_OK)
die_dlerr(status, "could not open /dev/dld");
linkname[0] = '\0';
bzero(&state, sizeof (state));
opterr = 0;
while ((option = getopt_long(argc, argv, ":rtApi:o:u:l:hz:",
NULL, NULL)) != -1) {
switch (option) {
case 'r':
if (r_arg)
die_optdup(option);
r_arg = B_TRUE;
break;
case 't':
if (t_arg)
die_optdup(option);
t_arg = B_TRUE;
break;
case 'A':
if (A_arg)
die_optdup(option);
A_arg = B_TRUE;
break;
case 'p':
if (p_arg)
die_optdup(option);
p_arg = B_TRUE;
break;
case 'i':
if (i_arg)
die_optdup(option);
i_arg = B_TRUE;
if (!dladm_str2interval(optarg, &interval))
die("invalid interval value '%s'", optarg);
break;
case 'o':
o_arg = B_TRUE;
o_fields_str = optarg;
break;
case 'u':
if (u_arg)
die_optdup(option);
u_arg = B_TRUE;
if (!flowstat_unit(optarg, &unit))
die("invalid unit value '%s',"
"unit must be R|K|M|G|T|P", optarg);
break;
case 'l':
if (strlcpy(linkname, optarg, MAXLINKNAMELEN)
>= MAXLINKNAMELEN)
die("link name too long\n");
break;
case 'h':
if (r_arg || t_arg || p_arg || o_arg || u_arg ||
i_arg || A_arg) {
die("the option -h is not compatible with "
"-r, -t, -p, -o, -u, -i, -A");
}
do_show_history(argc, argv);
return (0);
break;
case 'z':
zonename = optarg;
break;
default:
die_opterr(optopt, option, usage_ermsg);
break;
}
}
if (r_arg && t_arg)
die("the option -t and -r are not compatible");
if (u_arg && p_arg)
die("the option -u and -p are not compatible");
if (p_arg && !o_arg)
die("-p requires -o");
if (p_arg && strcasecmp(o_fields_str, "all") == 0)
die("\"-o all\" is invalid with -p");
if (A_arg &&
(r_arg || t_arg || p_arg || o_arg || u_arg || i_arg))
die("the option -A is not compatible with "
"-r, -t, -p, -o, -u, -i");
if (linkname[0] != '\0') {
if (dladm_zname2info(handle, zonename, linkname, &linkid, NULL,
NULL, NULL) != DLADM_STATUS_OK)
die("invalid link '%s'", linkname);
}
/* get flow name (optional last argument) */
if (optind == (argc-1)) {
if (strlcpy(flowname, argv[optind], MAXFLOWNAMELEN)
>= MAXFLOWNAMELEN)
die("flow name too long");
flow_arg = B_TRUE;
} else if (optind != argc) {
usage();
}
if (flow_arg &&
dladm_flow_info(handle, flowname, &attr) != DLADM_STATUS_OK)
die("invalid flow %s", flowname);
if (A_arg) {
dump_all_flow_stats(&attr, &state, linkid, flow_arg);
return (0);
}
state.fs_unit = unit;
state.fs_parsable = p_arg;
if (state.fs_parsable)
ofmtflags |= OFMT_PARSABLE;
if (r_arg)
fields_str = rx_stat_fields;
else if (t_arg)
fields_str = tx_stat_fields;
else
fields_str = total_stat_fields;
if (o_arg) {
fields_str = (strcasecmp(o_fields_str, "all") == 0) ?
fields_str : o_fields_str;
}
oferr = ofmt_open(fields_str, flow_s_fields, ofmtflags, 0, &ofmt);
ofmt_check(oferr, state.fs_parsable, ofmt, die, warn);
state.fs_ofmt = ofmt;
for (;;) {
/* Show stats for named flow */
if (flow_arg) {
(void) query_flow_stats(handle, &attr, &state);
/* Show stats for flows on one link */
} else if (linkid != DATALINK_INVALID_LINKID) {
(void) dladm_walk_flow(query_flow_stats, handle, linkid,
&state, B_FALSE);
/* Show stats for all flows on all links */
} else {
(void) dladm_walk_datalink_id(query_link_flow_stats,
handle, &state, DATALINK_CLASS_ALL,
DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
}
if (interval == 0)
break;
(void) fflush(stdout);
cleanup_removed_flows(&state);
(void) sleep(interval);
}
ofmt_close(ofmt);
dladm_close(handle);
return (0);
}
int init()
{
init_mapping();
return map_status( dladm_open( &handle ) );
}
int
main(int argc, char *argv[])
{
int c;
dladm_status_t status;
const char *outfile = NULL;
uint_t count = 0;
dltran_progname = basename(argv[0]);
while ((c = getopt(argc, argv, ":xvw:")) != -1) {
switch (c) {
case 'v':
dltran_verbose = B_TRUE;
break;
case 'x':
dltran_hex = B_TRUE;
break;
case 'w':
dltran_write = B_TRUE;
outfile = optarg;
break;
case ':':
dltran_usage("option -%c requires an "
"operand\n", optopt);
return (2);
case '?':
default:
dltran_usage("unknown option: -%c\n", optopt);
return (2);
}
}
argc -= optind;
argv += optind;
if (dltran_verbose)
count++;
if (dltran_hex)
count++;
if (dltran_write)
count++;
if (count > 1) {
(void) fprintf(stderr, "only one of -v, -w, and -x may be "
"specified\n");
return (2);
}
if (dltran_write) {
if ((dltran_outfd = open(outfile, O_RDWR | O_TRUNC | O_CREAT,
0644)) < 0) {
(void) fprintf(stderr, "failed to open output file "
"%s: %s\n", outfile, strerror(errno));
return (1);
}
}
if ((status = dladm_open(&dltran_hdl)) != DLADM_STATUS_OK) {
(void) fprintf(stderr, "failed to open /dev/dld: %s\n",
dladm_status2str(status, dltran_dlerrmsg));
return (1);
}
if (argc == 0) {
(void) dladm_walk_datalink_id(dltran_dump_transceivers,
dltran_hdl, NULL, DATALINK_CLASS_PHYS,
DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);
} else {
int i;
char *c;
for (i = 0; i < argc; i++) {
uint_t tran;
uint_t *tranidp = NULL;
datalink_id_t linkid;
if ((c = strrchr(argv[i], '/')) != NULL) {
unsigned long u;
char *eptr;
c++;
errno = 0;
u = strtoul(c, &eptr, 10);
if (errno != 0 || *eptr != '\0' ||
u >= UINT_MAX) {
(void) fprintf(stderr, "failed to "
"parse link/transceiver: %s\n",
argv[i]);
return (1);
}
c--;
*c = '\0';
tran = (uint_t)u;
tranidp = &tran;
}
if ((status = dladm_name2info(dltran_hdl, argv[i],
&linkid, NULL, NULL, NULL)) != DLADM_STATUS_OK) {
(void) fprintf(stderr, "failed to get link "
"id for link %s: %s\n", argv[i],
dladm_status2str(status, dltran_dlerrmsg));
return (1);
}
(void) dltran_dump_transceivers(dltran_hdl, linkid,
tranidp);
}
}
return (dltran_errors != 0 ? 1 : 0);
}
/*
* This function attempts to open a device under the following namespaces:
* /dev/ipnet - if DLPI_DEVIPNET is specified
* /dev/net - if a data-link with the specified name exists
* /dev - if DLPI_DEVONLY is specified, or if there is no
* data-link with the specified name (could be /dev/ip)
*
* In particular, if DLPI_DEVIPNET is not specified, this function is used to
* open a data-link node, or "/dev/ip" node. It is usually be called firstly
* with style1 being B_TRUE, and if that fails and the return value is not
* DLPI_ENOTSTYLE2, the function will again be called with style1 being
* B_FALSE (style-1 open attempt first, then style-2 open attempt).
*
* If DLPI_DEVONLY is specified, both attempt will try to open the /dev node
* directly.
*
* Otherwise, for style-1 attempt, the function will try to open the style-1
* /dev/net node, and perhaps fallback to open the style-1 /dev node if the
* give name is not a data-link name (e.g., it is /dev/ip). Note that the
* fallback and the subsequent style-2 attempt will not happen if:
* 1. style-1 opening of the /dev/net node succeeds;
* 2. style-1 opening of the /dev/net node fails with errno other than ENOENT,
* which means that the specific /dev/net node exist, but the attempt fails
* for some other reason;
* 3. style-1 openning of the /dev/net fails with ENOENT, but the name is
* a known device name or its VLAN PPA hack name. (for example, assuming
* device bge0 is renamed to net0, opening /dev/net/bge1000 would return
* ENOENT, but we should not fallback to open /dev/bge1000 in this case,
* as VLAN 1 over the bge0 device should be named as net1000.
*
* DLPI_ENOTSTYLE2 will be returned in case 2 and 3 to indicate not to proceed
* the second style-2 open attempt.
*/
static int
i_dlpi_open(const char *provider, int *fd, uint_t flags, boolean_t style1)
{
char path[MAXPATHLEN];
int oflags;
errno = ENOENT;
oflags = O_RDWR;
if (flags & DLPI_EXCL)
oflags |= O_EXCL;
if (flags & DLPI_DEVIPNET) {
(void) snprintf(path, sizeof (path), "/dev/ipnet/%s", provider);
if ((*fd = open(path, oflags)) != -1)
return (DLPI_SUCCESS);
else
return (errno == ENOENT ? DLPI_ENOLINK : DL_SYSERR);
} else if (style1 && !(flags & DLPI_DEVONLY)) {
char driver[DLPI_LINKNAME_MAX];
char device[DLPI_LINKNAME_MAX];
datalink_id_t linkid;
uint_t ppa;
dladm_handle_t handle;
/*
* This is not a valid style-1 name. It could be "ip" module
* for example. Fallback to open the /dev node.
*/
if (dlpi_parselink(provider, driver, &ppa) != DLPI_SUCCESS)
goto fallback;
(void) snprintf(path, sizeof (path), "/dev/net/%s", provider);
if ((*fd = open(path, oflags)) != -1)
return (DLPI_SUCCESS);
/*
* We don't fallback to open the /dev node when it returns
* error codes other than ENOENT. In that case, DLPI_ENOTSTYLE2
* is returned to indicate not to continue the style-2 open.
*/
if (errno != ENOENT)
return (DLPI_ENOTSTYLE2);
/*
* We didn't find the /dev/net node. Then we check whether
* the given name is a device name or its VLAN PPA hack name
* of a known link. If the answer is yes, and this link
* supports vanity naming, then the link (or the VLAN) should
* also have its /dev/net node but perhaps with another vanity
* name (for example, when bge0 is renamed to net0). In this
* case, although attempt to open the /dev/net/<devname> fails,
* we should not fallback to open the /dev/<devname> node.
*/
(void) snprintf(device, DLPI_LINKNAME_MAX, "%s%d", driver,
ppa >= 1000 ? ppa % 1000 : ppa);
/* open libdladm handle rather than taking it as input */
if (dladm_open(&handle) != DLADM_STATUS_OK)
goto fallback;
if (dladm_dev2linkid(handle, device, &linkid) ==
DLADM_STATUS_OK) {
dladm_phys_attr_t dpa;
if ((dladm_phys_info(handle, linkid, &dpa,
DLADM_OPT_ACTIVE)) == DLADM_STATUS_OK &&
!dpa.dp_novanity) {
dladm_close(handle);
return (DLPI_ENOTSTYLE2);
}
}
dladm_close(handle);
}
fallback:
(void) snprintf(path, sizeof (path), "/dev/%s", provider);
if ((*fd = open(path, oflags)) != -1)
return (DLPI_SUCCESS);
return (errno == ENOENT ? DLPI_ENOLINK : DL_SYSERR);
}
/**
* \brief Initializes the library.
*
* \return 0 on success
* \return non-zero otherwise
*/
int init()
{
return dladm_open( &handle );
}
int
main(int argc, char *argv[])
{
int c; /* options character */
int type = 0; /* type of accounting */
int modified = 0; /* have we modified any properties? */
acctconf_t ac; /* current configuration */
char *typestr = NULL; /* type of accounting argument string */
char *enabled = NULL; /* enabled resources string */
char *disabled = NULL; /* disabled resources string */
char *file = NULL;
int Eflg = 0;
int Dflg = 0;
int rflg = 0;
int sflg = 0;
int xflg = 0;
int optcnt = 0;
int state;
const char *fmri; /* FMRI for this instance */
int err = 0;
setup_privs();
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
(void) setpname(argv[0]);
for (; optind < argc; optind++) {
while ((c = getopt(argc, argv, OPTS)) != (int)EOF) {
switch (c) {
case 'd':
disabled = optarg;
break;
case 'e':
enabled = optarg;
break;
case 'D':
Dflg = 1;
optcnt++;
break;
case 'E':
Eflg = 1;
optcnt++;
break;
case 'f':
file = optarg;
optcnt++;
break;
case 'r':
rflg = 1;
optcnt++;
break;
case 's':
sflg = 1;
optcnt++;
break;
case 'x':
xflg = 1;
optcnt++;
break;
case '?':
default:
usage();
}
}
/*
* Permanently give up euid 0, egid 0 and privileges we
* don't need for the specified options.
*/
if (!(file || sflg)) {
if (setreuid(getuid(), getuid()) == -1 ||
setregid(getgid(), getgid()) == -1)
die(gettext("setreuid()/setregid() failed"));
(void) priv_set(PRIV_OFF, PRIV_PERMITTED,
PRIV_FILE_DAC_WRITE, NULL);
}
if (!(disabled || enabled || Dflg || Eflg || file || sflg ||
xflg))
(void) priv_set(PRIV_OFF, PRIV_PERMITTED,
PRIV_SYS_ACCT, PRIV_SYS_DL_CONFIG, NULL);
if (optind < argc) {
if (typestr != NULL) {
warn(gettext("illegal argument -- %s\n"),
argv[optind]);
usage();
} else {
typestr = argv[optind];
}
}
}
if (typestr != NULL) {
if (strcmp(typestr, "process") == 0 ||
strcmp(typestr, "proc") == 0)
type |= AC_PROC;
else if (strcmp(typestr, "task") == 0)
type |= AC_TASK;
else if (strcmp(typestr, "flow") == 0)
type |= AC_FLOW;
else if (strcmp(typestr, "net") == 0)
type |= AC_NET;
else {
warn(gettext("unknown accounting type -- %s\n"),
typestr);
usage();
}
} else
type = AC_PROC | AC_TASK | AC_FLOW | AC_NET;
/*
* Drop the DL config privilege if we are not working with
* net.
*/
if ((type & AC_NET) == 0) {
(void) priv_set(PRIV_OFF, PRIV_PERMITTED,
PRIV_SYS_DL_CONFIG, NULL);
}
/*
* check for invalid options
*/
if (optcnt > 1)
usage();
/*
* XXX For AC_NET, enabled/disabled should only be "basic" or
* "extended" - need to check it here.
*/
if ((enabled || disabled) && (rflg || Dflg || sflg || xflg || Eflg))
usage();
if ((file || xflg || Dflg || Eflg || enabled || disabled) &&
!typestr) {
warn(gettext("accounting type must be specified\n"));
usage();
}
if (rflg) {
printgroups(type);
return (E_SUCCESS);
}
/*
* If no arguments have been passed then just print out the current
* state and exit.
*/
if (!enabled && !disabled && !file &&
!Eflg && !rflg && !Dflg && !sflg && !xflg) {
aconf_print(stdout, type);
return (E_SUCCESS);
}
/* Open the libdladm handle */
if (dladm_open(&dld_handle) != DLADM_STATUS_OK)
die(gettext("failed to open dladm handle\n"));
/*
* smf(5) start method. The FMRI to operate on is retrieved from the
* SMF_FMRI environment variable that the restarter provides.
*/
if (sflg) {
if ((fmri = getenv("SMF_FMRI")) != NULL) {
int ret = aconf_setup(fmri);
dladm_close(dld_handle);
return (ret);
}
die(gettext("-s option should only be invoked by smf(5)\n"));
}
assert(type == AC_PROC || type == AC_TASK || type == AC_FLOW ||
type == AC_NET);
if ((type == AC_FLOW || type == AC_NET) && getzoneid() != GLOBAL_ZONEID)
die(gettext("%s accounting cannot be configured in "
"non-global zones\n"), ac_type_name(type));
fmri = aconf_type2fmri(type);
if (aconf_scf_init(fmri) == -1)
die(gettext("cannot connect to repository for %s\n"), fmri);
/*
* Since the sys_acct the privilege allows use of acctctl() regardless
* of the accounting type, we check the smf(5) authorizations granted
* to the user to determine whether the user is allowed to change the
* configuration for this particular accounting type.
*/
if (!aconf_have_smf_auths())
die(gettext("insufficient authorization to change %s extended "
"accounting configuration\n"), ac_type_name(type));
if (xflg) {
/*
* Turn off the specified accounting and close its file
*/
/*
* Stop net logging before turning it off so that the last
* set of logs can be written.
*/
if (type & AC_NET) {
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
err = dladm_stop_usagelog(dld_handle,
DLADM_LOGTYPE_FLOW);
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
if (err != DLADM_STATUS_OK) {
die(gettext("failed to stop logging network "
"information, error %d\n"), errno);
}
}
state = AC_OFF;
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (acctctl(type | AC_STATE_SET, &state, sizeof (int)) == -1)
die(gettext("cannot disable %s accounting"),
ac_type_name(type));
if (acctctl(type | AC_FILE_SET, NULL, 0) == -1)
die(gettext("cannot close %s accounting file\n"),
ac_type_name(type));
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (aconf_set_bool(AC_PROP_STATE, B_FALSE) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_STATE);
if (aconf_set_string(AC_PROP_FILE, AC_STR_NONE) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_FILE);
modified++;
}
if (enabled || disabled) {
char *tracked, *untracked;
ac_res_t *buf;
/*
* Enable/disable resources
*/
if ((buf = malloc(AC_BUFSIZE)) == NULL)
die(gettext("not enough memory\n"));
(void) memset(buf, 0, AC_BUFSIZE);
if (acctctl(type | AC_RES_GET, buf, AC_BUFSIZE) == -1) {
free(buf);
die(gettext("cannot obtain list of resources\n"));
}
if (disabled) {
/*
* Stop net logging before turning it off so that the
* last set of logs can be written.
*/
if (type & AC_NET) {
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
err = dladm_stop_usagelog(dld_handle,
strcmp(disabled, "basic") == 0 ?
DLADM_LOGTYPE_LINK : DLADM_LOGTYPE_FLOW);
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
if (err != DLADM_STATUS_OK) {
die(gettext("failed to stop logging "
"network information, error %d\n"),
errno);
}
}
str2buf(buf, disabled, AC_OFF, type);
} else if (enabled) {
str2buf(buf, enabled, AC_ON, type);
}
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (acctctl(type | AC_RES_SET, buf, AC_BUFSIZE) == -1) {
free(buf);
die(gettext("cannot enable/disable %s accounting "
"resources\n"), ac_type_name(type));
}
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
tracked = buf2str(buf, AC_BUFSIZE, AC_ON, type);
untracked = buf2str(buf, AC_BUFSIZE, AC_OFF, type);
if (aconf_set_string(AC_PROP_TRACKED, tracked) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_TRACKED);
if (aconf_set_string(AC_PROP_UNTRACKED, untracked) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_UNTRACKED);
free(tracked);
free(untracked);
free(buf);
modified++;
}
if (file) {
/*
* Open new accounting file
*/
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (open_exacct_file(file, type) == -1) {
dladm_close(dld_handle);
exit(E_ERROR);
}
if (aconf_set_string(AC_PROP_FILE, file) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_FILE);
state = AC_ON;
if (acctctl(type | AC_STATE_SET, &state, sizeof (int)) == -1)
die(gettext("cannot enable %s accounting"),
ac_type_name(type));
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (aconf_set_bool(AC_PROP_STATE, B_TRUE) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_STATE);
modified++;
}
/*
* Let's get network logging started. We do this after turning on
* accounting and opening the file so that we can start writing
* immediately.
*/
if (enabled && (type & AC_NET)) {
/*
* Default logging interval for AC_NET is
* ACCTADM_NET_LOG_INTERVAL.
*/
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
err = dladm_start_usagelog(dld_handle,
strcmp(enabled, "basic") == 0 ?
DLADM_LOGTYPE_LINK : DLADM_LOGTYPE_FLOW,
ACCTADM_NET_LOG_INTERVAL);
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
if (err != DLADM_STATUS_OK) {
die(gettext("failed to start logging "
"network information, error %d\n"),
errno);
}
}
if (Dflg) {
/*
* Disable accounting
*/
/*
* Stop net logging before turning it off so that the last
* set of logs can be written.
*/
if (type & AC_NET) {
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
err = dladm_stop_usagelog(dld_handle,
DLADM_LOGTYPE_FLOW);
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
if (err != DLADM_STATUS_OK) {
die(gettext("failed to stop logging "
"network information, error %d\n"), errno);
}
}
state = AC_OFF;
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (acctctl(type | AC_STATE_SET, &state, sizeof (int)) == -1)
die(gettext("cannot disable %s accounting"),
ac_type_name(type));
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (aconf_set_bool(AC_PROP_STATE, B_FALSE) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_STATE);
modified++;
}
if (Eflg) {
/*
* Enable accounting
*/
/*
* Let's get network logging started.
*/
if (type & AC_NET) {
/*
* Default logging interval for AC_NET is
* ACCTADM_NET_LOG_INTERVAL.
*/
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
err = dladm_start_usagelog(dld_handle,
DLADM_LOGTYPE_FLOW, ACCTADM_NET_LOG_INTERVAL);
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE,
PRIV_SYS_DL_CONFIG, NULL);
if (err != DLADM_STATUS_OK) {
die(gettext("failed to start logging "
"network information, error %d\n"), errno);
}
}
state = AC_ON;
(void) priv_set(PRIV_ON, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (acctctl(type | AC_STATE_SET, &state, sizeof (int)) == -1)
die(gettext("cannot enable %s accounting"),
ac_type_name(type));
(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_SYS_ACCT, NULL);
if (aconf_set_bool(AC_PROP_STATE, B_TRUE) == -1)
die(gettext("cannot update %s property\n"),
AC_PROP_STATE);
modified++;
}
(void) priv_set(PRIV_OFF, PRIV_PERMITTED, PRIV_SYS_ACCT, NULL);
if (modified) {
char *smf_state;
if (aconf_save() == -1)
die(gettext("cannot save %s accounting "
"configuration\n"), ac_type_name(type));
/*
* Enable or disable the instance depending on the effective
* configuration. If the effective configuration results in
* extended accounting being 'on', the instance is enabled so
* the configuration is applied at the next boot.
*/
smf_state = smf_get_state(fmri);
aconf_init(&ac, type);
if (ac.state == AC_ON ||
strcmp(ac.file, AC_STR_NONE) != 0 ||
strcmp(ac.tracked, AC_STR_NONE) != 0) {
if (strcmp(smf_state, SCF_STATE_STRING_ONLINE) != 0)
if (smf_enable_instance(fmri, 0) == -1)
die(gettext("cannot enable %s\n"),
fmri);
} else {
if (strcmp(smf_state, SCF_STATE_STRING_ONLINE) == 0)
if (smf_disable_instance(fmri, 0) == -1)
die(gettext("cannot disable %s\n"),
fmri);
}
free(smf_state);
}
aconf_scf_fini();
dladm_close(dld_handle);
return (E_SUCCESS);
}
int
main(int argc, char *argv[])
{
int c;
int scan_lev;
struct np_event *e;
enum np_event_type etype;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
shutting_down = B_FALSE;
start_logging();
syslog(LOG_INFO, "nwamd pid %d started", getpid());
while ((c = getopt(argc, argv, "fs:")) != -1) {
switch (c) {
case 'f':
fg = B_TRUE;
break;
case 's':
scan_lev = atoi(optarg);
if (scan_lev >= DLADM_WLAN_STRENGTH_VERY_WEAK &&
scan_lev <= DLADM_WLAN_STRENGTH_EXCELLENT) {
wireless_scan_level = scan_lev;
} else {
syslog(LOG_ERR, "invalid signal "
"strength: %s", optarg);
}
break;
default:
syslog(LOG_ERR, "unrecognized option %c",
optopt);
break;
}
}
lookup_daemon_properties();
/*
* The dladm handle *must* be opened before privileges are dropped
* by nwamd. The device privilege requirements from
* /etc/security/device_policy may not be loaded yet. These are
* loaded by svc:/system/filesystem/root, which comes online after
* svc:/network/physical.
*/
if (dladm_open(&dld_handle) != DLADM_STATUS_OK) {
syslog(LOG_ERR, "failed to open dladm handle");
exit(EXIT_FAILURE);
}
change_user_set_privs();
if (!fg)
daemonize();
initialize_llp();
init_signalhandling();
initialize_wireless();
lookup_zonename(zonename, sizeof (zonename));
init_machine_mutex();
initialize_interfaces();
llp_parse_config();
initialize_door();
(void) start_event_collection();
while ((e = np_queue_get_event()) != NULL) {
etype = e->npe_type;
syslog(LOG_INFO, "got event type %s", npe_type_str(etype));
if (etype == EV_SHUTDOWN)
terminate_door();
if (pthread_mutex_lock(&machine_lock) != 0) {
syslog(LOG_ERR, "mutex lock");
exit(EXIT_FAILURE);
}
state_machine(e);
(void) pthread_mutex_unlock(&machine_lock);
free_event(e);
if (etype == EV_SHUTDOWN)
break;
}
syslog(LOG_DEBUG, "terminating routing and scanning threads");
(void) pthread_cancel(routing);
(void) pthread_join(routing, NULL);
if (scan != 0) {
(void) pthread_cancel(scan);
(void) pthread_join(scan, NULL);
}
dladm_close(dld_handle);
syslog(LOG_INFO, "nwamd shutting down");
return (EXIT_SUCCESS);
}
static int
aoeadm_list_ports(int argc, char **argv)
{
AOE_STATUS ret;
aoe_port_list_t *portlist = NULL;
char c;
dladm_handle_t handle;
int i;
int portid = -1;
int verbose = 0;
uint32_t nports;
while ((c = getopt(argc, argv, "v")) != -1) {
switch (c) {
case 'v':
verbose = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 1) {
errno = 0;
portid = strtol(argv[0], (char **)NULL, 10);
if (errno != 0 || portid < 0)
usage();
}
ret = aoe_get_port_list(&nports, &portlist);
if (ret != AOE_STATUS_OK) {
(void) fprintf(stderr, _("Failed to list ports: %s\n"),
aoe_strerror(ret));
return (ret);
}
if (nports == 0) {
free(portlist);
return (0);
}
if (dladm_open(&handle) != DLADM_STATUS_OK)
handle = NULL;
for (i = 0; i < nports; i++) {
aoe_port_instance_t *pi = &portlist->ports[i];
char linknames[AOE_MAX_MACOBJ * MAXLINKNAMELEN];
int j;
if (portid >= 0 && pi->api_port_id != portid)
continue;
if ((pi->api_port_type == AOE_CLIENT_INITIATOR &&
strcmp(cmdname, "list-target") == 0) ||
(pi->api_port_type == AOE_CLIENT_TARGET &&
strcmp(cmdname, "list-initiator") == 0))
continue;
/* Convert linkid to interface name */
for (j = 0; j < pi->api_mac_cnt; j++) {
aoe_mac_instance_t *mi = &pi->api_mac[j];
char *linkname = linknames + j * MAXLINKNAMELEN;
if (handle == NULL ||
dladm_datalink_id2info(handle, mi->ami_mac_linkid,
NULL, NULL, NULL, linkname, MAXLINKNAMELEN - 1) !=
DLADM_STATUS_OK)
(void) strcpy(linkname, "<unknown>");
}
print_port_info(pi, linknames, verbose);
if (portid >= 0) {
if (handle != NULL)
dladm_close(handle);
free(portlist);
return (0);
}
}
if (handle != NULL)
dladm_close(handle);
free(portlist);
return (portid >= 0 ? 1 : 0);
}
