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