auditconfig.c revision d0fa49b78d1f40d84ec76c363cdc38cf128511dd
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* auditconfig - set and display audit parameters
*/
#include <locale.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <nlist.h>
#include <fcntl.h>
#include <netdb.h>
#include <pwd.h>
#include <libintl.h>
#include <zone.h>
#include <bsm/audit_record.h>
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SUNW_OST_OSCMD"
#endif
enum commands {
};
#define AC_KERN_EVENT 0
#define AC_USER_EVENT 1
#define ALL_POLICIES (AUDIT_AHLT|\
#define NO_POLICIES (0)
#define ONEK 1024
/*
* remove this after the audit.h is fixed
*/
struct arg_entry {
char *arg_str;
char *arg_opts;
enum commands auditconfig_cmd;
};
struct policy_entry {
char *policy_str;
char *policy_desc;
};
{ "-setaudit", "auid audit_flags termid asid [cmd]",
};
static struct policy_entry policy_table[] = {
"async event"},
"zone"},
"information in audit recs"},
"information in audit recs"},
};
static char *progname = "auditconfig";
static char *cond2str(void);
static int strisflags(char *s);
static int strisipaddr(char *s);
static int strisnum(char *s);
static void chk_retval(char *retval_str);
static void do_aconf(void);
static void do_audit(char *, char, int, char *);
static void do_chkaconf(void);
static void do_chkconf(void);
static void do_conf(void);
static void do_getasid(void);
static void do_getaudit(void);
static void do_getkaudit(void);
static void do_setkaudit(char *t, char *s);
static void do_getauid(void);
static void do_getcar(void);
static void do_getclass(char *event_str);
static void do_getcond(void);
static void do_getcwd(void);
static void do_getkmask(void);
static void do_getpinfo(char *pid_str);
static void do_getpolicy(void);
static void do_getqbufsz(void);
static void do_getqctrl(void);
static void do_getqdelay(void);
static void do_getqhiwater(void);
static void do_getqlowater(void);
static void do_getstat(void);
static void do_gettermid(void);
static void do_lsevent(void);
static void do_lspolicy(void);
static void do_setkmask(char *audit_flags);
static void do_setpolicy(char *policy_str);
static void do_setqbufsz(char *bufsz);
static void do_setqdelay(char *delay);
static void do_setqhiwater(char *hiwater);
static void do_setqlowater(char *lowater);
static void do_setstat(void);
static void do_getfsize(void);
static void do_setfsize(char *size);
static void exit_error(char *fmt, ...);
static void exit_usage(int status);
static void parse_args(char **argv);
int
{
(void) textdomain(TEXT_DOMAIN);
if (argc == 1) {
exit_usage(0);
exit(0);
}
if (argc == 2 &&
exit_usage(0);
return (0);
}
/*
* parse_args()
* Desc: Checks command line argument syntax.
* Inputs: Command line argv;
* Returns: If a syntax error is detected, a usage message is printed
* and exit() is called. If a syntax error is not detected,
* parse_args() returns without a value.
*/
static void
parse_args(char **argv)
{
exit_usage(1);
}
switch (ae->auditconfig_cmd) {
case AC_ARG_AUDIT:
++argv;
if (!*argv)
exit_usage(1);
} else {
}
++argv;
if (!*argv)
exit_usage(1);
++argv;
if (!*argv)
exit_usage(1);
chk_retval(*argv);
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_CHKCONF:
case AC_ARG_CONF:
case AC_ARG_ACONF:
case AC_ARG_CHKACONF:
case AC_ARG_GETASID:
case AC_ARG_GETAUID:
case AC_ARG_GETAUDIT:
case AC_ARG_GETKAUDIT:
break;
case AC_ARG_GETCLASS:
case AC_ARG_GETESTATE:
++argv;
if (!*argv)
exit_usage(1);
} else {
}
break;
case AC_ARG_GETCAR:
case AC_ARG_GETCOND:
case AC_ARG_GETCWD:
case AC_ARG_GETKMASK:
case AC_ARG_GETPOLICY:
case AC_ARG_GETQBUFSZ:
case AC_ARG_GETQCTRL:
case AC_ARG_GETQDELAY:
case AC_ARG_GETQHIWATER:
case AC_ARG_GETQLOWATER:
case AC_ARG_GETSTAT:
case AC_ARG_GETTERMID:
case AC_ARG_LSEVENT:
case AC_ARG_LSPOLICY:
break;
case AC_ARG_SETASID:
case AC_ARG_SETAUID:
case AC_ARG_SETAUDIT:
++argv;
if (!*argv)
exit_usage(1);
while (*argv)
++argv;
--argv;
break;
case AC_ARG_SETKAUDIT:
++argv;
if (!*argv)
exit_usage(1);
"Invalid IP address type specified."));
++argv;
if (!*argv)
exit_usage(1);
"Invalid IP address specified."));
break;
case AC_ARG_SETCLASS:
++argv;
if (!*argv)
exit_usage(1);
else
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETKMASK:
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETPOLICY:
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETSTAT:
break;
case AC_ARG_GETPINFO:
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETPMASK:
++argv;
if (!*argv)
exit_usage(1);
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETQBUFSZ:
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETQCTRL:
++argv;
if (!*argv)
exit_usage(1);
"Invalid hiwater specified."));
++argv;
if (!*argv)
exit_usage(1);
gettext("Invalid lowater specified.")));
++argv;
if (!*argv)
exit_usage(1);
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETQDELAY:
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_SETQHIWATER:
++argv;
if (!*argv)
exit_usage(1);
"Invalid hiwater specified."));
}
break;
case AC_ARG_SETQLOWATER:
++argv;
if (!*argv)
exit_usage(1);
"Invalid lowater specified."));
}
break;
case AC_ARG_SETSMASK:
case AC_ARG_SETUMASK:
++argv;
if (!*argv)
exit_usage(1);
++argv;
if (!*argv)
exit_usage(1);
break;
case AC_ARG_GETFSIZE:
break;
case AC_ARG_SETFSIZE:
++argv;
if (!*argv)
exit_usage(1);
"Invalid hiwater specified."));
}
break;
default:
break;
}
}
}
/*
* do_args()
* Desc: Do command line arguments in the order in which they appear.
*/
static void
{
switch (ae->auditconfig_cmd) {
case AC_ARG_AUDIT:
{
char sorf;
int retval;
char *event_name;
char *audit_str;
++argv;
event_name = *argv;
++argv;
++argv;
++argv;
}
break;
case AC_ARG_CHKCONF:
do_chkconf();
break;
case AC_ARG_CONF:
do_conf();
break;
case AC_ARG_CHKACONF:
do_chkaconf();
break;
case AC_ARG_ACONF:
do_aconf();
break;
case AC_ARG_GETASID:
do_getasid();
break;
case AC_ARG_GETAUID:
do_getauid();
break;
case AC_ARG_GETAUDIT:
do_getaudit();
break;
case AC_ARG_GETKAUDIT:
do_getkaudit();
break;
case AC_ARG_GETCLASS:
case AC_ARG_GETESTATE:
++argv;
do_getclass(*argv);
break;
case AC_ARG_GETCAR:
do_getcar();
break;
case AC_ARG_GETCOND:
do_getcond();
break;
case AC_ARG_GETCWD:
do_getcwd();
break;
case AC_ARG_GETKMASK:
do_getkmask();
break;
case AC_ARG_GETPOLICY:
do_getpolicy();
break;
case AC_ARG_GETQBUFSZ:
do_getqbufsz();
break;
case AC_ARG_GETQCTRL:
do_getqctrl();
break;
case AC_ARG_GETQDELAY:
do_getqdelay();
break;
case AC_ARG_GETQHIWATER:
break;
case AC_ARG_GETQLOWATER:
break;
case AC_ARG_GETSTAT:
do_getstat();
break;
case AC_ARG_GETTERMID:
do_gettermid();
break;
case AC_ARG_LSEVENT:
do_lsevent();
break;
case AC_ARG_LSPOLICY:
do_lspolicy();
break;
case AC_ARG_SETASID:
{
char *sid_str;
++argv;
++argv;
}
break;
case AC_ARG_SETAUID:
{
char *user;
++argv;
++argv;
}
break;
case AC_ARG_SETAUDIT:
{
char *user_str;
char *mask_str;
char *tid_str;
char *sid_str;
++argv;
++argv;
++argv;
++argv;
++argv;
}
break;
case AC_ARG_SETKAUDIT:
{
char *address_type, *address;
}
break;
case AC_ARG_SETCLASS:
{
char *event_str, *audit_flags;
}
break;
case AC_ARG_SETKMASK:
++argv;
do_setkmask(*argv);
break;
case AC_ARG_SETPOLICY:
++argv;
do_setpolicy(*argv);
break;
case AC_ARG_GETPINFO:
{
char *pid_str;
++argv;
}
break;
case AC_ARG_SETPMASK:
{
char *pid_str;
char *audit_flags;
++argv;
++argv;
audit_flags = *argv;
}
break;
case AC_ARG_SETSTAT:
do_setstat();
break;
case AC_ARG_SETQBUFSZ:
++argv;
do_setqbufsz(*argv);
break;
case AC_ARG_SETQCTRL:
{
}
break;
case AC_ARG_SETQDELAY:
++argv;
do_setqdelay(*argv);
break;
case AC_ARG_SETQHIWATER:
++argv;
break;
case AC_ARG_SETQLOWATER:
++argv;
break;
case AC_ARG_SETSMASK:
{
char *asid_str;
char *audit_flags;
++argv;
++argv;
audit_flags = *argv;
}
break;
case AC_ARG_SETUMASK:
{
char *auid_str;
char *audit_flags;
++argv;
++argv;
audit_flags = *argv;
}
break;
case AC_ARG_GETFSIZE:
do_getfsize();
break;
case AC_ARG_SETFSIZE:
++argv;
do_setfsize(*argv);
break;
default:
break;
}
}
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_chkconf(void)
{
register au_event_ent_t *evp;
char conf_aflags[256];
char run_aflags[256];
int class;
int len;
struct au_evclass_map cmap;
setauevent();
if (getauevent() == NULL) {
(void) exit_error(gettext(
"NO AUDIT EVENTS: Could not read %s\n."), AUDITEVENTFILE);
}
setauevent();
len = sizeof (struct au_evclass_map);
(void) printf("%s(%hu):%s",
gettext("UNKNOWN EVENT: Could not get "
"class for event. Configuration may "
"be bad.\n"));
} else {
(void) getauditflagschar(run_aflags,
&pmask, 0);
(void) getauditflagschar(conf_aflags,
&pmask, 0);
"%s(%hu): CLASS MISMATCH: "
"runtime class (%s) != "
"configured class (%s)\n"),
NONE(conf_aflags));
}
}
}
}
endauevent();
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_conf(void)
{
register au_event_ent_t *evp;
register int i;
i = 0;
setauevent();
++i;
}
}
endauevent();
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_chkaconf(void)
{
char buf[1024];
gettext("bad non-attributable flags in audit_control\n"));
exit(1);
}
gettext("bad audit flag value encountered\n"));
exit(1);
}
char kbuf[2048];
gettext("bad kernel non-attributable mask\n"));
exit(1);
}
}
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_aconf(void)
{
char buf[2048];
gettext("bad non-attributable flags in audit_control\n"));
exit(1);
}
gettext("bad audit flag value encountered\n"));
exit(1);
}
}
static void
{
int rtn;
int rd;
} else {
}
if (rtn == -1) {
exit_error("%s\n%s %hu\n",
gettext("Check audit event configuration."),
gettext("Could not get audit class for event number"),
}
/* record is preselected */
if (rtn == 1) {
"descriptor\n"));
}
"token\n"));
}
"token of audit record\n"));
}
if (is_system_labeled()) {
"label token\n"));
}
"label token of audit record\n"));
}
}
"audit record\n"));
#ifdef _LP64
#else
#endif
"token\n"));
"of audit record\n"));
}
}
}
}
static void
do_getauid(void)
{
}
static void
do_getaudit(void)
{
}
static void
do_getkaudit(void)
{
}
/*
* per zone if AUDIT_PERZONE set, else only in global zone.
*/
static void
do_setkaudit(char *t, char *s)
{
}
/*
* returns zone-relative root
*/
static void
do_getcar(void)
{
char path[MAXPATHLEN];
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getclass(char *event_str)
{
char *event_name;
} else {
}
} else {
}
}
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set. (AUC_DISABLED is always global, the other states are per zone
* if AUDIT_PERZONE is set)
*/
static void
do_getcond(void)
{
}
/*
* returned path is relative to zone root
*/
static void
do_getcwd(void)
{
char path[MAXPATHLEN];
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getkmask(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set. (some policies can only be set from the global zone, but all
* can be read from anywhere.)
*/
static void
do_getpolicy(void)
{
char policy_str[1024];
}
static void
do_getpinfo(char *pid_str)
{
struct auditpinfo_addr ap;
else
exit_usage(1);
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getqbufsz(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getqctrl(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getqdelay(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getqhiwater(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getqlowater(void)
{
}
static void
do_getasid(void)
{
}
}
/*
* The stats are for the entire system unless AUDIT_PERZONE is set.
*/
static void
do_getstat(void)
{
char buf[512];
"%n%4lu %n%4lu %n%4lu %n%4lu %n%4lu%n",
/*
* TRANSLATION_NOTE
* Print a properly aligned header.
*/
(void) printf("%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s\n",
}
static void
do_gettermid(void)
{
}
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_getfsize(void)
{
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_lsevent(void)
{
register au_event_ent_t *evp;
char auflags[256];
setauevent();
if (getauevent() == NULL) {
(void) exit_error(gettext(
"NO AUDIT EVENTS: Could not read %s\n."), AUDITEVENTFILE);
}
setauevent();
(void) printf("%-30s %5hu %s %s\n",
}
endauevent();
}
/*
* The returned value is for the global zone unless AUDIT_PERZONE is
* set.
*/
static void
do_lspolicy(void)
{
int i;
/*
* TRANSLATION_NOTE
* Print a properly aligned header.
*/
for (i = 0; i < POLICY_TBL_SZ; i++) {
}
}
static void
{
struct auditinfo_addr ai;
}
}
}
static void
char **argv)
{
}
static void
{
}
static void
{
struct auditpinfo ap;
else
exit_usage(1);
}
static void
{
else
exit_usage(1);
}
static void
{
else
exit_usage(1);
}
/*
* local zone use is valid if AUDIT_PERZONE is set, otherwise the
* syscall returns EPERM.
*/
static void
do_setstat(void)
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
{
int mask;
else {
}
if (strisnum(audit_flags))
else {
}
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setkmask(char *audit_flags)
{
}
/*
* ahlt and perzone are global zone only; the other policies are valid
* in a local zone if AUDIT_PERZONE is set. The kernel insures that
* a local zone can't change ahlt and perzone (EINVAL).
*/
static void
do_setpolicy(char *policy_str)
{
case 2:
"policy (%s) invalid in a local zone."),
break;
default:
"Invalid policy (%s) specified."),
break;
case 0:
break;
}
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setqbufsz(char *bufsz)
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setqdelay(char *delay)
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setqhiwater(char *hiwater)
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setqlowater(char *lowater)
{
}
/*
* AUDIT_PERZONE set: valid in all zones
* AUDIT_PERZONE not set: valid in global zone only
*/
static void
do_setfsize(char *size)
{
}
static void
{
}
static void
{
}
static void
{
}
static void
{
}
static void
{
}
static void
{
return;
}
}
static au_event_ent_t *
{
}
return (evp);
}
static au_event_ent_t *
egetauevnam(char *event_name)
{
register au_event_ent_t *evp;
return (evp);
}
static void
{
}
static void
{
}
static uid_t
get_user_id(char *user)
{
}
} else {
}
}
}
/*
* get_arg_ent()
* Inputs: command line argument string
* Returns ptr to policy_entry if found; null, if not found
*/
static struct arg_entry *
get_arg_ent(char *arg_str)
{
}
/*
* arg_ent_compare()
* Compares two command line arguments to determine which is
* lexicographically greater.
* Inputs: two argument map table entry pointers
* Returns: > 1: aep1->arg_str > aep2->arg_str
* < 1: aep1->arg_str < aep2->arg_str
* 0: aep1->arg_str = aep->arg_str2
*/
static int
{
}
/*
* Convert mask of the following forms:
*
* audit_flags (ie. +lo,-ad,pc)
* 0xffffffff,0xffffffff
* ffffffff,ffffffff
* 20,20
*/
static void
{
char sp[256];
char fp[256];
mp->am_success = 0;
mp->am_failure = 0;
/*
* a mask of the form +aa,bb,cc,-dd or
* a mask of the form 0xffffffff,0xffffffff or 1,1
*/
if (strisflags(mask_str)) {
} else {
} else {
}
} else {
}
}
}
/*
* tid_str is major,minor,host -- host is a name or an ip address
*/
static void
{
char *major_str;
char *minor_str;
int err;
*minor_str = '\0';
minor_str++;
}
if (minor_str) {
*host_str = '\0';
host_str++;
}
}
if (major_str)
if (minor_str)
if (host_str) {
if (strisipaddr(host_str)) {
}
} else {
if (phe == 0) {
}
/* address is IPv6 (128 bits) */
} else {
/* address is IPv4 (32 bits) */
}
}
}
}
}
static char *
cond2str(void)
{
switch (cond) {
case AUC_AUDITING:
return ("auditing");
case AUC_NOAUDIT:
case AUC_INIT_AUDIT:
return ("noaudit");
case AUC_UNSET:
return ("unset");
case AUC_NOSPACE:
return ("nospace");
default:
return ("");
}
}
static struct policy_entry *
get_policy_ent(char *policy)
{
int i;
for (i = 0; i < POLICY_TBL_SZ; i++) {
if (strcasecmp(policy,
policy_table[i].policy_str) == 0) {
return (&policy_table[i]);
}
}
return (NULL);
}
/*
* exit = 0, success
* 1, error
* 2, bad zone
*/
static int
{
char *buf;
char *tok;
char pfix;
struct policy_entry *pep;
pfix = *policy_str;
++policy_str;
return (1);
return (1);
} else {
is_all = 1;
}
}
}
if (pfix == '-') {
if (!is_all &&
(getzoneid() != GLOBAL_ZONEID) &&
(pm & ~AUDIT_LOCAL)) {
return (2);
}
if (getzoneid() != GLOBAL_ZONEID)
curp &= AUDIT_LOCAL;
} else if (pfix == '+') {
/*
* In a local zone, accept specifying "all", but not
* individually specifying global-zone only policies.
* Limit to all locally allowed, so system call doesn't
* fail.
*/
if (!is_all &&
(getzoneid() != GLOBAL_ZONEID) &&
(pm & ~AUDIT_LOCAL)) {
return (2);
}
if (getzoneid() != GLOBAL_ZONEID) {
curp &= AUDIT_LOCAL;
if (is_all) {
pm &= AUDIT_LOCAL;
}
}
} else {
pm &= AUDIT_LOCAL;
}
*policy_mask = pm;
}
return (0);
}
static int
{
int i, j;
if (policy == ALL_POLICIES) {
return (1);
}
if (policy == NO_POLICIES) {
return (1);
}
*policy_str = '\0';
for (i = 0, j = 0; i < POLICY_TBL_SZ; i++) {
if (j++) {
}
len);
}
}
if (*policy_str)
return (0);
return (1);
}
static int
strisnum(char *s)
{
if (s == NULL || !*s)
return (0);
for (; *s == '-' || *s == '+'; s++)
if (!*s)
return (0);
for (; *s; s++)
if (!isdigit(*s))
return (0);
return (1);
}
static int
strisflags(char *s)
{
if (s == NULL || !*s)
return (0);
for (; *s; s++) {
if (!isalpha(*s) &&
(*s != '+' && *s != '-' && *s != '^' && *s != ','))
return (0);
}
return (1);
}
static int
strisipaddr(char *s)
{
int dot = 0;
int colon = 0;
/* no string */
if ((s == NULL) || (!*s))
return (0);
for (; *s; s++) {
return (0);
if (*s == '.')
dot++;
if (*s == ':')
colon++;
}
return (0);
return (0);
return (1);
}
static void
{
while (*s != '\0' && *s != c)
*p1++ = *s++;
*p1 = '\0';
s++;
while (*s != '\0')
*p2++ = *s++;
*p2 = '\0';
}
static void
{
if (etype == AC_KERN_EVENT) {
"number specified.\n"
"\t%hu is outside allowable range 0-%d."),
}
} else {
/* user event */
"number specified %hu."), event);
}
}
}
static void
{
gettext("Invalid kernel audit event string specified.\n"
"\t\"%s\" appears to be a user level event. "
"Check configuration."), event_str);
} else if (etype == AC_USER_EVENT &&
gettext("Invalid user audit event string specified.\n"
"\t\"%s\" appears to be a kernel event. "
"Check configuration."), event_str);
}
}
static void
{
}
static void
chk_retval(char *retval_str)
{
if (!strisnum(retval_str))
}
static void
{
size_t n = 0;
char **argv_pos;
if (*argv) {
/* concatenate argument array to be passed to sh -c "..." */
"failed"));
}
/* strip the last space */
} else {
}
}
/*
* exit_error()
* Desc: Prints an error message along with corresponding system
* error number and error message, then exits.
* Inputs: Program name, program error message.
*/
/*PRINTFLIKE1*/
static void
exit_error(char *fmt, ...)
{
if (errno)
exit(1);
}
static void
exit_usage(int status)
{
int i;
for (i = 0; i < ARG_TBL_SZ; i++)
}
static void
{
}
static void
{
char *username;
else
}
static void
{
char auflags[512];
(void) printf("%s = %s(0x%x,0x%x)\n",
}
static void
{
char *hostname;
int err;
char buf[INET6_ADDRSTRLEN];
char *bufp;
/* IPV6 or IPV4 address */
} else {
}
"terminal id (maj,min,host) = %u,%u,%s(%s)\n"),
} else {
} else {
}
"terminal id (maj,min,host) = %u,%u,%s(%s)\n"),
if (phe) {
}
}
}
static int
{
int j, sl;
char *ss;
unsigned int v;
if (strisipaddr(s)) {
return (0);
}
return (1);
return (0);
return (1);
}
return (1);
} else {
return (0);
ss = s;
for (j = 3; j >= 0; j--) {
if ((sl - 8) <= 0) {
(void) sscanf(s, "%x", &v);
addr[j] = v;
return (0);
}
addr[j] = v;
sl -= 8;
*ss = '\0';
}
}
return (0);
}
}
static int
{
if (strcmp(s, "ipv6") == 0) {
return (0);
}
if (strcmp(s, "ipv4") == 0) {
return (0);
}
return (1);
}