void ns_os_inituserinfo (const char *username)
{
char strbuf[ISC_STRERRORSIZE];
if (username == NULL)
return;
if (all_digits (username))
runas_pw = getpwuid ((uid_t) atoi (username));
else
runas_pw = getpwnam (username);
endpwent ();
if (runas_pw == NULL)
ns_main_earlyfatal ("user '%s' unknown", username);
if (getuid () == 0)
{
if (initgroups (runas_pw->pw_name, runas_pw->pw_gid) < 0)
{
isc__strerror (errno, strbuf, sizeof (strbuf));
ns_main_earlyfatal ("initgroups(): %s", strbuf);
}
}
}
object_t parse_sexp2(char **in, object_t current) {
char *buf;
enum kind k = next_token(in, &buf);
object_t rest, s;
switch(k) {
case End:
return current;
case Left:
rest = parse_sexp2(in, NIL);
if(current == NULL)
return rest;
else if(current == NIL)
current = cons(rest, NIL);
else
storage_append(rest, current);
return parse_sexp2(in, current);
case Right:
return current;
case Period:
rest = parse_sexp2(in, NULL);
set_cdr(storage_last(current), rest);
return parse_sexp2(in, current);
case Single: /* following are reader-macros */
return wrap(in, current, "quote");
case Back:
return wrap(in, current, "quasiquote");
case Comma:
return wrap(in, current, "unquote");
case Symbol:
case String:
if(k == Symbol) {
if(all_digits(buf))
s = obj_new_number(atoi(buf));
else
s = obj_new_symbol(buf);
}
else if(k == String)
s = obj_new_string(buf);
if(current == NULL)
return s;
else if(current == NIL)
return parse_sexp2(in, cons(s, NIL));
else {
storage_append(s, current);
return parse_sexp2(in, current);
}
}
return NULL;
}
/*! \fn find_keyword_by_word(const struct keyword *tbl, const char *word, int dflt)
* \brief takes a generic word and returns either TRUE or FALSE
* \param tbl the table that contains the translation from text to boolean
* \param word the word to compare against the table for the result
* \param dflt the default value to be returned if the string can not be found
*
* Given a table of keywords and a user's word, look that word up in the
* table and return the value associted with it. If the word is not found,
* return the user-provide default value.
*
* The default-value parameter can be used for either the actual default
* value of the parameter being searched for (say, LOGDEST_BOTH), or
* a didn't-find-it value (say, -1) which the caller can key off of.
*
* NOTE: if the given word is all digits, it's parsed as a number and
* returned numerically.
*
* \return TRUE, FALSE, or dflt depending on results of search
*
*/
static int find_keyword_by_word(const struct keyword *tbl, const char *word, int dflt)
{
assert(tbl != 0);
assert(word != 0);
if (all_digits(word)) {
return atoi(word);
}
for (; tbl->word; tbl++) {
if (STRIMATCH(word, tbl->word)) {
return tbl->value;
}
}
return dflt;
}
int
process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n)
{
PROC_PID_FILE(fn, "/proc/%d/task", pid);
DIR * d = opendir(fn);
if (d == NULL)
return -1;
pid_t *tasks = NULL;
size_t n = 0;
size_t alloc = 0;
while (1) {
struct dirent entry;
struct dirent *result;
if (readdir_r(d, &entry, &result) != 0) {
free(tasks);
return -1;
}
if (result == NULL)
break;
if (result->d_type == DT_DIR && all_digits(result->d_name)) {
pid_t npid = atoi(result->d_name);
if (n >= alloc) {
alloc = alloc > 0 ? (2 * alloc) : 8;
pid_t *ntasks = realloc(tasks,
sizeof(*tasks) * alloc);
if (ntasks == NULL) {
free(tasks);
return -1;
}
tasks = ntasks;
}
if (n >= alloc)
abort();
tasks[n++] = npid;
}
}
closedir(d);
*ret_tasks = tasks;
*ret_n = n;
return 0;
}
void
options_spinbox_modCB(
Widget widget,
XtPointer clientdata,
XtPointer calldata
)
{
Widget spinbox = (Widget) clientdata;
int mvalue, value;
Display *dpy = XtDisplayOfObject(widget);
char *text = XtMalloc(BUFSIZ);
char *textvalue;
XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct*) calldata;
if (NULL == cbs->text->ptr) return;
if (!all_digits(cbs->text->ptr))
{
cbs->doit = FALSE;
XBell(dpy, 50);
}
textvalue = XmTextGetString(widget);
strncpy(text, textvalue, cbs->startPos);
text[cbs->startPos] = '\0';
strcat(text, cbs->text->ptr);
strcat(text, textvalue+cbs->endPos);
XtVaGetValues(spinbox, XmNmaximumValue, &mvalue, NULL);
value = (int) strtol(text, NULL, 10);
if (value > mvalue)
{
cbs->doit = FALSE;
XBell(dpy, 50);
}
if (NULL != text) XtFree(text);
if (NULL != textvalue) XtFree(textvalue);
}
unsigned long long str_to_nano_seconds(const char* str) {
/* possible formats:
nnnnnn - micro timer
nnnn/nn/nn aa:aa:aa nnnnn - timestamp timer
aa:aa:aa nnnnn - omit date
part of the last two - assume zeros
*/
int len;
if (!str) return 0;
#define NEXT_DIGIT while (*str && !is_digit(*str)) str++ ; len = strlen(str)
NEXT_DIGIT;
/* 000000211630 */
if (len > 9 && all_digits(str)) {
return atoll(str);
}
struct tm t = { 0 };
/* 2012/09/03 05:10:56 674869660 */
/* date? */
if (len >= 10 && str[4] == '/' && str[7] == '/') {
t.tm_year = atoll_n(str+0, 4) - 1900;
t.tm_mon = atoll_n(str+5, 2) - 1;
t.tm_mday = atoll_n(str+8, 2);
str += 10;
NEXT_DIGIT;
}
if (len >= 8 && str[2] == ':' && str[5] == ':') {
t.tm_hour = atoll_n(str+0, 2);
t.tm_min = atoll_n(str+3, 2);
t.tm_sec = atoll_n(str+6, 2);
str += 8;
NEXT_DIGIT;
}
return (SECOND * (timegm(&t))) + atoll_n(str, 9);
}
void
options_spinbox_chgCB(
Widget widget,
XtPointer clientdata,
XtPointer calldata
)
{
Widget spinbox = (Widget) clientdata;
int mvalue, value =
(int) strtol(XmTextGetString(widget), NULL, 10);
Display *dpy = XtDisplayOfObject(widget);
calldata = calldata;
props_changed = TRUE;
if (!all_digits(XmTextGetString(widget))){
XtVaSetValues(spinbox, XmNposition, 1, NULL);
XBell(dpy, 50);
return;
}
XtVaGetValues(spinbox, XmNmaximumValue, &mvalue, NULL);
if (value > mvalue) {
XtVaSetValues(spinbox, XmNposition, mvalue, NULL);
XBell(dpy, 50);
return;
}
// It could never be less than the minimum value because a
// '-' is an invalid entry and it would be cleared and reset
// if entered. So if we made it here it is a valid entry. We
// also have to reset the insertion point! Another spinbox bug
// we have to work around.
XtVaSetValues(spinbox, XmNposition, value, NULL);
int shift = 1;
while ((value /= 10) > 0)
shift++;
XmTextSetInsertionPosition(widget, shift);
}
int validate_weight(char *input)
{
if (!all_digits(input)) return 0;
return within(50, 500, strtol(input, NULL, 10));
}
int validate_height_feet(char *input)
{
if (!all_digits(input)) return 0;
return within(1, 9, strtol(input, NULL, 10));
}
int validate_height_inches(char *input)
{
if (!all_digits(input)) return 0;
return within(0, 11, strtol(input, NULL, 10));
}
int validate_year(char *input)
{
if (!all_digits(input)) return 0;
return within(1900, 2014, strtol(input, NULL, 10));
}
int validate_month(char *input)
{
if (!all_digits(input)) return 0;
return within(1, 12, strtol(input, NULL, 10));
}
int validate_day(char *input)
{
if (!all_digits(input)) return 0;
return within(1, 31, strtol(input, NULL, 10));
}
int
main (register int const argc, register char *const argv[])
{
auto in_addr listen_addr;
register int optch;
auto int one = 1;
register int portno = 0;
register int option_errors = 0;
register int server_sock;
auto sockaddr_in sin;
register servent *servp;
auto ecb listen_ecb;
register int kq;
pname = strrchr (argv[0], '/');
pname = pname ? pname+1 : argv[0];
listen_addr.s_addr = htonl (INADDR_ANY); /* Default. */
while ((optch = getopt (argc, argv, "p:")) != EOF)
{
switch (optch)
{
case 'p':
if (strlen (optarg) == 0 || !all_digits (optarg))
{
error ("Invalid argument for -p option: %s", optarg);
option_errors++;
}
portno = atoi (optarg);
if (portno == 0 || portno >= (1u << 16))
{
error ("Invalid argument for -p option: %s", optarg);
option_errors++;
}
break;
default:
error ("Invalid option: -%c", optch);
option_errors++;
}
}
if (option_errors || optind != argc)
usage ();
if (daemon(0,0) < 0)
perror("daemon failed");
if (portno == 0)
{
if ((servp = getservbyname (servname, protoname)) == NULL)
fatal ("Error getting port number for service `%s': %s",
servname, strerror (errno));
portno = ntohs (servp->s_port);
}
if ((server_sock = socket (PF_INET, SOCK_STREAM, 0)) == -1)
fatal ("Error creating socket: %s", strerror (errno));
if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one) == -1)
fatal ("Error setting SO_REUSEADDR for socket: %s", strerror (errno));
memset (&sin, 0, sizeof sin);
sin.sin_family = AF_INET;
sin.sin_addr = listen_addr;
sin.sin_port = htons (portno);
if (bind (server_sock, (const struct sockaddr *)&sin, sizeof sin) == -1)
fatal ("Error binding socket: %s", strerror (errno));
if (listen (server_sock, 20) == -1)
fatal ("Error listening to socket: %s", strerror (errno));
if ((kq = kqueue ()) == -1)
fatal ("Error creating kqueue: %s", strerror (errno));
listen_ecb.do_read = do_accept;
listen_ecb.buf = NULL;
listen_ecb.buf = 0;
ke_change (server_sock, EVFILT_READ, EV_ADD | EV_ENABLE, &listen_ecb);
event_loop (kq);
}
/** Evaluate a map
*
* @param[in] request the REQUEST
* @param[in] modreturn the previous module return code
* @param[in] depth of the recursion (only used for debugging)
* @param[in] c the condition to evaluate
* @return -1 on error, 0 for "no match", 1 for "match".
*/
int radius_evaluate_map(REQUEST *request, UNUSED int modreturn, UNUSED int depth,
fr_cond_t const *c)
{
int rcode;
char *lhs, *rhs;
value_pair_map_t *map;
rad_assert(c->type == COND_TYPE_MAP);
map = c->data.map;
rad_assert(map->dst->type != VPT_TYPE_UNKNOWN);
rad_assert(map->src->type != VPT_TYPE_UNKNOWN);
rad_assert(map->dst->type != VPT_TYPE_LIST);
rad_assert(map->src->type != VPT_TYPE_LIST);
rad_assert(map->dst->type != VPT_TYPE_REGEX);
/*
* Verify regexes.
*/
if (map->src->type == VPT_TYPE_REGEX) {
rad_assert(map->op == T_OP_REG_EQ);
} else {
rad_assert(!((map->op == T_OP_REG_EQ) || (map->op == T_OP_REG_NE)));
}
/*
* They're both attributes. Do attribute-specific work.
*
* LHS is DST. RHS is SRC <sigh>
*/
if (!c->cast && (map->src->type == VPT_TYPE_ATTR) && (map->dst->type == VPT_TYPE_ATTR)) {
VALUE_PAIR *lhs_vp, *rhs_vp;
EVAL_DEBUG("ATTR to ATTR");
if ((radius_vpt_get_vp(&lhs_vp, request, map->dst) < 0) ||
(radius_vpt_get_vp(&rhs_vp, request, map->src) < 0)) {
return -2;
}
return paircmp_op(lhs_vp, map->op, rhs_vp);
}
/*
* LHS is a cast. Do type-specific comparisons, as if
* the LHS was a real attribute.
*/
if (c->cast) {
VALUE_PAIR *lhs_vp, *rhs_vp;
rcode = get_cast_vp(&lhs_vp, request, map->dst, c->cast);
if (rcode < 0) {
return rcode;
}
rad_assert(lhs_vp);
/*
* Get either a real VP, or parse the RHS into a
* VP, and return that.
*/
if (map->src->type == VPT_TYPE_ATTR) {
if (radius_vpt_get_vp(&rhs_vp, request, map->src) < 0) {
return -2;
}
} else {
rcode = get_cast_vp(&rhs_vp, request, map->src, c->cast);
if (rcode < 0) {
return rcode;
}
rad_assert(rhs_vp);
}
if (!rhs_vp) return -2;
EVAL_DEBUG("CAST to ...");
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
pairfree(&lhs_vp);
if (map->src->type != VPT_TYPE_ATTR) {
pairfree(&rhs_vp);
}
return rcode;
}
/*
* Might be a virtual comparison
*/
if ((map->dst->type == VPT_TYPE_ATTR) &&
(map->src->type != VPT_TYPE_REGEX) &&
(c->pass2_fixup == PASS2_PAIRCOMPARE)) {
VALUE_PAIR *rhs_vp;
EVAL_DEBUG("virtual ATTR to DATA");
rcode = get_cast_vp(&rhs_vp, request, map->src, map->dst->da);
if (rcode < 0) {
return rcode;
}
rad_assert(rhs_vp);
if (paircompare(request, request->packet->vps, rhs_vp, NULL) == 0) {
return true;
}
return false;
}
rad_assert(c->pass2_fixup != PASS2_PAIRCOMPARE);
/*
* RHS has been pre-parsed into binary data. Go check
* that.
*/
if ((map->dst->type == VPT_TYPE_ATTR) &&
(map->src->type == VPT_TYPE_DATA)) {
VALUE_PAIR *lhs_vp, *rhs_vp;
EVAL_DEBUG("ATTR to DATA");
if (radius_vpt_get_vp(&lhs_vp, request, map->dst) < 0) {
return -2;
}
rcode = get_cast_vp(&rhs_vp, request, map->src, map->dst->da);
if (rcode < 0) {
return rcode;
}
rad_assert(rhs_vp);
#ifdef WITH_EVAL_DEBUG
debug_pair(lhs_vp);
debug_pair(rhs_vp);
#endif
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
pairfree(&rhs_vp);
return rcode;
}
rad_assert(map->src->type != VPT_TYPE_DATA);
rad_assert(map->dst->type != VPT_TYPE_DATA);
/*
* The RHS now needs to be expanded into a string.
*/
rcode = radius_expand_tmpl(&rhs, request, map->src);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return rcode;
}
/*
* User-Name == FOO
*
* Parse the RHS to be the same DA as the LHS. do
* comparisons. So long as it's not a regex, which does
* string comparisons.
*
* The LHS may be a virtual attribute, too.
*/
if ((map->dst->type == VPT_TYPE_ATTR) &&
(map->src->type != VPT_TYPE_REGEX)) {
VALUE_PAIR *lhs_vp, *rhs_vp;
EVAL_DEBUG("ATTR to non-REGEX");
/*
* No LHS means no match
*/
if (radius_vpt_get_vp(&lhs_vp, request, map->dst) < 0) {
/*
* Not a real attr: might be a dynamic comparison.
*/
if ((map->dst->type == VPT_TYPE_ATTR) &&
(map->dst->da->vendor == 0) &&
radius_find_compare(map->dst->da)) {
rhs_vp = pairalloc(request, map->dst->da);
if (!pairparsevalue(rhs_vp, rhs)) {
talloc_free(rhs);
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
talloc_free(rhs);
rcode = (radius_callback_compare(request, NULL, rhs_vp, NULL, NULL) == 0);
pairfree(&rhs_vp);
return rcode;
}
return -2;
}
/*
* Get VP for RHS
*/
rhs_vp = pairalloc(request, map->dst->da);
rad_assert(rhs_vp != NULL);
if (!pairparsevalue(rhs_vp, rhs)) {
talloc_free(rhs);
pairfree(&rhs_vp);
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
talloc_free(rhs);
pairfree(&rhs_vp);
return rcode;
}
/*
* The LHS is a string. Expand it.
*/
rcode = radius_expand_tmpl(&lhs, request, map->dst);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return rcode;
}
EVAL_DEBUG("LHS is %s", lhs);
/*
* Compile the RHS to a regex, and do regex stuff
*/
if (map->src->type == VPT_TYPE_REGEX) {
return do_regex(request, lhs, rhs, c->regex_i);
}
/*
* Loop over the string, doing comparisons
*/
if (all_digits(lhs) && all_digits(rhs)) {
int lint, rint;
lint = strtoul(lhs, NULL, 0);
rint = strtoul(rhs, NULL, 0);
talloc_free(lhs);
talloc_free(rhs);
switch (map->op) {
case T_OP_CMP_EQ:
return (lint == rint);
case T_OP_NE:
return (lint != rint);
case T_OP_LT:
return (lint < rint);
case T_OP_GT:
return (lint > rint);
case T_OP_LE:
return (lint <= rint);
case T_OP_GE:
return (lint >= rint);
default:
break;
}
} else {
rcode = strcmp(lhs, rhs);
talloc_free(lhs);
talloc_free(rhs);
switch (map->op) {
case T_OP_CMP_EQ:
return (rcode == 0);
case T_OP_NE:
return (rcode != 0);
case T_OP_LT:
return (rcode < 0);
case T_OP_GT:
return (rcode > 0);
case T_OP_LE:
return (rcode <= 0);
case T_OP_GE:
return (rcode >= 0);
default:
break;
}
}
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
int main(int argc, char **argv) {
prog_name = argv[0];
int show_the_system_info = 0;
int show_the_numastat_info = 0;
static struct option long_options[] = {
{"help", 0, 0, '?'},
{0, 0, 0, 0}
};
int long_option_index = 0;
int opt;
while ((opt = getopt_long(argc, argv, "cmnp:s::vVz?", long_options, &long_option_index)) != -1) {
switch (opt) {
case 0:
printf("Unexpected long option %s", long_options[long_option_index].name);
if (optarg) {
printf(" with arg %s", optarg);
}
printf("\n");
display_usage_and_exit();
break;
case 'c':
compress_display = 1;
break;
case 'm':
show_the_system_info = 1;
break;
case 'n':
show_the_numastat_info = 1;
break;
case 'p':
if ((optarg) && (all_digits(optarg))) {
add_pid_to_list(atoi(optarg));
} else {
add_pids_from_pattern_search(optarg);
}
break;
case 's':
sort_table = 1;
if ((optarg) && (all_digits(optarg))) {
sort_table_node = atoi(optarg);
}
break;
case 'v':
verbose = 1;
break;
case 'V':
display_version_and_exit();
break;
case 'z':
show_zero_data = 0;
break;
default:
case '?':
display_usage_and_exit();
break;
}
}
// Figure out the display width, which is used to format the tables
// and limit the output columns per row
screen_width = get_screen_width();
// Any remaining arguments are assumed to be additional process specifiers
while (optind < argc) {
if (all_digits(argv[optind])) {
add_pid_to_list(atoi(argv[optind]));
} else {
add_pids_from_pattern_search(argv[optind]);
}
optind += 1;
}
// If there are no program options or arguments, be extremely compatible
// with the old numastat perl script (which is included at the end of this
// file for reference)
compatibility_mode = (argc == 1);
init_node_ix_map_and_header(compatibility_mode); // enumarate the NUMA nodes
if (compatibility_mode) {
show_numastat_info();
free_node_ix_map_and_header();
exit(EXIT_SUCCESS);
}
// Figure out page sizes
page_size_in_bytes = (double)sysconf(_SC_PAGESIZE);
huge_page_size_in_bytes = get_huge_page_size_in_bytes();
// Display the info for the process specifiers
if (num_pids > 0) {
sort_pids_and_remove_duplicates();
show_process_info();
}
if (pid_array != NULL) {
free(pid_array);
}
// Display the system-wide memory usage info
if (show_the_system_info) {
show_system_info();
}
// Display the numastat statistics info
if ((show_the_numastat_info) || ((num_pids == 0) && (!show_the_system_info))) {
show_numastat_info();
}
free_node_ix_map_and_header();
exit(EXIT_SUCCESS);
}
/*! \fn main(int argc, char *argv[])
* \brief The Cactid program entry point
* \param argc The number of arguments passed to the function plus one (+1)
* \param argv An array of the command line arguments
*
* The Cactid entry point. This function performs the following tasks.
* 1) Processes command line input parameters
* 2) Processes the Cactid configuration file to obtain database access information
* 3) Process runtime parameters from the settings table
* 4) Initialize the runtime threads and mutexes for the threaded environment
* 5) Initialize Net-SNMP, MySQL, and the PHP Script Server (if required)
* 6) Spawns X threads in order to process hosts
* 7) Loop until either all hosts have been processed or until the poller runtime
* has been exceeded
* 8) Close database and free variables
* 9) Log poller process statistics if required
* 10) Exit
*
* Note: Command line runtime parameters override any database settings.
*
* \return 0 if SUCCESS, or -1 if FAILED
*
*/
int main(int argc, char *argv[]) {
struct timeval now;
char *conf_file = NULL;
double begin_time, end_time, current_time;
int poller_interval;
int num_rows;
int device_counter = 0;
int poller_counter = 0;
int last_active_threads = 0;
long int EXTERNAL_THREAD_SLEEP = 100000;
long int internal_thread_sleep;
time_t nowbin;
struct tm now_time;
struct tm *now_ptr;
pthread_t* threads = NULL;
pthread_attr_t attr;
int* ids = NULL;
MYSQL mysql;
MYSQL_RES *result = NULL;
MYSQL_ROW mysql_row;
int canexit = 0;
int host_id;
int i;
int mutex_status = 0;
int thread_status = 0;
UNUSED_PARAMETER(argc); /* we operate strictly with argv */
/* establish php processes and initialize space */
php_processes = (php_t*) calloc(MAX_PHP_SERVERS, sizeof(php_t));
for (i = 0; i < MAX_PHP_SERVERS; i++) {
php_processes[i].php_state = PHP_BUSY;
}
/* set start time for cacti */
begin_time = get_time_as_double();
/* get time for poller_output table */
if (time(&nowbin) == (time_t) - 1) {
die("ERROR: Could not get time of day from time()\n");
}
localtime_r(&nowbin,&now_time);
now_ptr = &now_time;
if (strftime(start_datetime, sizeof(start_datetime), "%Y-%m-%d %H:%M:%S", now_ptr) == (size_t) 0) {
die("ERROR: Could not get string from strftime()\n");
}
/* set default verbosity */
set.log_level = POLLER_VERBOSITY_LOW;
/* get static defaults for system */
config_defaults();
/*! ----------------------------------------------------------------
* PROCESS COMMAND LINE
*
* Run through the list of ARGV words looking for parameters we
* know about. Most have two flavors (-C + --conf), and many
* themselves take a parameter.
*
* These parameters can be structured in two ways:
*
* --conf=FILE both parts in one argv[] string
* --conf FILE two separate argv[] strings
*
* We set "arg" to point to "--conf", and "opt" to point to FILE.
* The helper routine
*
* In each loop we set "arg" to next argv[] string, then look
* to see if it has an equal sign. If so, we split it in half
* and point to the option separately.
*
* NOTE: most direction to the program is given with dash-type
* parameters, but we also allow standalone numeric device IDs
* in "first last" format: this is how poller.php calls this
* program.
*/
/* initialize some global variables */
set.start_host_id = -1;
set.end_host_id = -1;
set.php_initialized = FALSE;
set.logfile_processed = FALSE;
set.parent_fork = CACTID_PARENT;
for (argv++; *argv; argv++) {
char *arg = *argv;
char *opt = strchr(arg, '='); /* pick off the =VALUE part */
if (opt) *opt++ = '\0';
if (STRIMATCH(arg, "-f") ||
STRIMATCH(arg, "--first")) {
if (HOSTID_DEFINED(set.start_host_id)) {
die("ERROR: %s can only be used once", arg);
}
set.start_host_id = atoi(opt = getarg(opt, &argv));
if (!HOSTID_DEFINED(set.start_host_id)) {
die("ERROR: '%s=%s' is invalid first-host ID", arg, opt);
}
}
else if (STRIMATCH(arg, "-l") ||
STRIMATCH(arg, "--last")) {
if (HOSTID_DEFINED(set.end_host_id)) {
die("ERROR: %s can only be used once", arg);
}
set.end_host_id = atoi(opt = getarg(opt, &argv));
if (!HOSTID_DEFINED(set.end_host_id)) {
die("ERROR: '%s=%s' is invalid last-host ID", arg, opt);
}
}
else if (STRIMATCH(arg, "-p") ||
STRIMATCH(arg, "--poller")) {
set.poller_id = atoi(getarg(opt, &argv));
}
else if (STRIMATCH(arg, "-h") ||
STRIMATCH(arg, "-v") ||
STRIMATCH(arg, "--help") ||
STRIMATCH(arg, "--version")) {
display_help();
exit(EXIT_SUCCESS);
}
else if (STRIMATCH(arg, "-O") ||
STRIMATCH(arg, "--option")) {
char *setting = getarg(opt, &argv);
char *value = strchr(setting, ':');
if (*value) {
*value++ = '\0';
}else{
die("ERROR: -O requires setting:value");
}
set_option(setting, value);
}
else if (STRIMATCH(arg, "-R") ||
STRIMATCH(arg, "--readonly") ||
STRIMATCH(arg, "--read-only")) {
set.SQL_readonly = TRUE;
}
else if (STRIMATCH(arg, "-C") ||
STRIMATCH(arg, "--conf")) {
conf_file = strdup(getarg(opt, &argv));
}
else if (STRIMATCH(arg, "-S") ||
STRIMATCH(arg, "--stdout")) {
set_option("log_destination", "STDOUT");
}
else if (STRIMATCH(arg, "-L") ||
STRIMATCH(arg, "--log")) {
set_option("log_destination", getarg(opt, &argv));
}
else if (STRIMATCH(arg, "-V") ||
STRIMATCH(arg, "--verbosity")) {
set_option("log_verbosity", getarg(opt, &argv));
}
else if (STRIMATCH(arg, "--snmponly") ||
STRIMATCH(arg, "--snmp-only")) {
set.snmponly = TRUE;
}
else if (!HOSTID_DEFINED(set.start_host_id) && all_digits(arg)) {
set.start_host_id = atoi(arg);
}
else if (!HOSTID_DEFINED(set.end_host_id) && all_digits(arg)) {
set.end_host_id = atoi(arg);
}
else {
die("ERROR: %s is an unknown command-line parameter", arg);
}
}
/* we require either both the first and last hosts, or niether host */
if (HOSTID_DEFINED(set.start_host_id) != HOSTID_DEFINED(set.end_host_id)) {
die("ERROR: must provide both -f/-l, or neither");
}
if (set.start_host_id > set.end_host_id) {
die("ERROR: Invalid row spec; first host_id must be less than the second");
}
/* read configuration file to establish local environment */
if (conf_file) {
if ((read_cactid_config(conf_file)) < 0) {
die("ERROR: Could not read config file: %s\n", conf_file);
}
}else{
if (!(conf_file = calloc(1, BUFSIZE))) {
die("ERROR: Fatal malloc error: cactid.c conf_file!\n");
}
for (i=0; i<CONFIG_PATHS; i++) {
snprintf(conf_file, BUFSIZE-1, "%s%s", config_paths[i], DEFAULT_CONF_FILE);
if (read_cactid_config(conf_file) >= 0) {
break;
}
if (i == CONFIG_PATHS-1) {
snprintf(conf_file, BUFSIZE-1, "%s%s", config_paths[0], DEFAULT_CONF_FILE);
}
}
}
/* read settings table from the database to further establish environment */
read_config_options();
/* set the poller interval for those who use less than 5 minute intervals */
if (set.poller_interval == 0) {
poller_interval = 300;
}else {
poller_interval = set.poller_interval;
}
/* calculate the external_tread_sleep value */
internal_thread_sleep = EXTERNAL_THREAD_SLEEP * set.num_parent_processes / 2;
if (set.log_level == POLLER_VERBOSITY_DEBUG) {
CACTID_LOG_DEBUG(("CACTID: Version %s starting\n", VERSION));
}else{
printf("CACTID: Version %s starting\n", VERSION);
}
/* connect to database */
db_connect(set.dbdb, &mysql);
/* initialize SNMP */
CACTID_LOG_DEBUG(("CACTID: Initializing Net-SNMP API\n"));
snmp_cactid_init();
/* initialize PHP if required */
CACTID_LOG_DEBUG(("CACTID: Initializing PHP Script Server\n"));
/* tell cactid that it is parent, and set the poller id */
set.parent_fork = CACTID_PARENT;
set.poller_id = 0;
/* initialize the script server */
if (set.php_required) {
php_init(PHP_INIT);
set.php_initialized = TRUE;
set.php_current_server = 0;
}
/* obtain the list of hosts to poll */
{
char querybuf[256], *qp = querybuf;
qp += sprintf(qp, "SELECT id FROM host");
qp += sprintf(qp, " WHERE disabled=''");
qp += append_hostrange(qp, "id"); /* AND id BETWEEN a AND b */
qp += sprintf(qp, " ORDER BY id");
result = db_query(&mysql, querybuf);
}
num_rows = mysql_num_rows(result) + 1; /* add 1 for host = 0 */
if (!(threads = (pthread_t *)malloc(num_rows * sizeof(pthread_t)))) {
die("ERROR: Fatal malloc error: cactid.c threads!\n");
}
if (!(ids = (int *)malloc(num_rows * sizeof(int)))) {
die("ERROR: Fatal malloc error: cactid.c host id's!\n");
}
/* initialize threads and mutexes */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
init_mutexes();
CACTID_LOG_DEBUG(("DEBUG: Initial Value of Active Threads is %i\n", active_threads));
/* tell fork processes that they are now active */
set.parent_fork = CACTID_FORK;
/* loop through devices until done */
while ((device_counter < num_rows) && (canexit == 0)) {
mutex_status = thread_mutex_trylock(LOCK_THREAD);
switch (mutex_status) {
case 0:
if (last_active_threads != active_threads) {
last_active_threads = active_threads;
}
while ((active_threads < set.threads) && (device_counter < num_rows)) {
if (device_counter > 0) {
mysql_row = mysql_fetch_row(result);
host_id = atoi(mysql_row[0]);
ids[device_counter] = host_id;
}else{
ids[device_counter] = 0;
}
/* create child process */
thread_status = pthread_create(&threads[device_counter], &attr, child, &ids[device_counter]);
switch (thread_status) {
case 0:
CACTID_LOG_DEBUG(("DEBUG: Valid Thread to be Created\n"));
device_counter++;
active_threads++;
CACTID_LOG_DEBUG(("DEBUG: The Value of Active Threads is %i\n", active_threads));
break;
case EAGAIN:
CACTID_LOG(("ERROR: The System Lacked the Resources to Create a Thread\n"));
break;
case EFAULT:
CACTID_LOG(("ERROR: The Thread or Attribute Was Invalid\n"));
break;
case EINVAL:
CACTID_LOG(("ERROR: The Thread Attribute is Not Initialized\n"));
break;
default:
CACTID_LOG(("ERROR: Unknown Thread Creation Error\n"));
break;
}
usleep(internal_thread_sleep);
/* get current time and exit program if time limit exceeded */
if (poller_counter >= 20) {
current_time = get_time_as_double();
if ((current_time - begin_time + 6) > poller_interval) {
CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n"));
canexit = 1;
break;
}
poller_counter = 0;
}else{
poller_counter++;
}
}
thread_mutex_unlock(LOCK_THREAD);
break;
case EDEADLK:
CACTID_LOG(("ERROR: Deadlock Occured\n"));
break;
case EBUSY:
break;
case EINVAL:
CACTID_LOG(("ERROR: Attempt to Unlock an Uninitialized Mutex\n"));
break;
case EFAULT:
CACTID_LOG(("ERROR: Attempt to Unlock an Invalid Mutex\n"));
break;
default:
CACTID_LOG(("ERROR: Unknown Mutex Lock Error Code Returned\n"));
break;
}
usleep(internal_thread_sleep);
/* get current time and exit program if time limit exceeded */
if (poller_counter >= 20) {
current_time = get_time_as_double();
if ((current_time - begin_time + 6) > poller_interval) {
CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n"));
canexit = 1;
break;
}
poller_counter = 0;
}else{
poller_counter++;
}
}
/* wait for all threads to complete */
while (canexit == 0) {
if (thread_mutex_trylock(LOCK_THREAD) == 0) {
if (last_active_threads != active_threads) {
last_active_threads = active_threads;
}
if (active_threads == 0) {
canexit = 1;
}
thread_mutex_unlock(LOCK_THREAD);
}
usleep(EXTERNAL_THREAD_SLEEP);
/* get current time and exit program if time limit exceeded */
if (poller_counter >= 20) {
current_time = get_time_as_double();
if ((current_time - begin_time + 6) > poller_interval) {
CACTID_LOG(("ERROR: Cactid Timed Out While Processing Hosts Internal\n"));
canexit = 1;
break;
}
poller_counter = 0;
}else{
poller_counter++;
}
}
/* tell Cactid that it is now parent */
set.parent_fork = CACTID_PARENT;
/* print out stats */
gettimeofday(&now, NULL);
/* update the db for |data_time| on graphs */
db_insert(&mysql, "replace into settings (name,value) values ('date',NOW())");
db_insert(&mysql, "insert into poller_time (poller_id, start_time, end_time) values (0, NOW(), NOW())");
/* cleanup and exit program */
pthread_attr_destroy(&attr);
CACTID_LOG_DEBUG(("DEBUG: Thread Cleanup Complete\n"));
/* close the php script server */
if (set.php_required) {
php_close(PHP_INIT);
}
CACTID_LOG_DEBUG(("DEBUG: PHP Script Server Pipes Closed\n"));
/* free malloc'd variables */
free(threads);
free(ids);
free(conf_file);
CACTID_LOG_DEBUG(("DEBUG: Allocated Variable Memory Freed\n"));
/* shutdown SNMP */
snmp_cactid_close();
CACTID_LOG_DEBUG(("CACTID: Net-SNMP API Shutdown Completed\n"));
/* close mysql */
mysql_free_result(result);
mysql_close(&mysql);
CACTID_LOG_DEBUG(("DEBUG: MYSQL Free & Close Completed\n"));
/* finally add some statistics to the log and exit */
end_time = TIMEVAL_TO_DOUBLE(now);
CACTID_LOG_MEDIUM(("Time: %.4f s, Threads: %i, Hosts: %i\n", (end_time - begin_time), set.threads, num_rows));
exit(EXIT_SUCCESS);
}
/*
* *presult is "did comparison match or not"
*/
static int radius_do_cmp(REQUEST *request, int *presult,
FR_TOKEN lt, const char *pleft, FR_TOKEN token,
FR_TOKEN rt, const char *pright,
int cflags, int modreturn)
{
int result;
uint32_t lint, rint;
VALUE_PAIR *vp = NULL;
#ifdef HAVE_REGEX_H
char buffer[8192];
#else
cflags = cflags; /* -Wunused */
#endif
rt = rt; /* -Wunused */
if (lt == T_BARE_WORD) {
/*
* Maybe check the last return code.
*/
if (token == T_OP_CMP_TRUE) {
int isreturn;
/*
* Looks like a return code, treat is as such.
*/
isreturn = fr_str2int(modreturn_table, pleft, -1);
if (isreturn != -1) {
*presult = (modreturn == isreturn);
return TRUE;
}
}
/*
* Bare words on the left can be attribute names.
*/
if (radius_get_vp(request, pleft, &vp)) {
VALUE_PAIR myvp;
/*
* VP exists, and that's all we're looking for.
*/
if (token == T_OP_CMP_TRUE) {
*presult = (vp != NULL);
return TRUE;
}
if (!vp) {
DICT_ATTR *da;
/*
* The attribute on the LHS may
* have been a dynamically
* registered callback. i.e. it
* doesn't exist as a VALUE_PAIR.
* If so, try looking for it.
*/
da = dict_attrbyname(pleft);
if (da && (da->vendor == 0) && radius_find_compare(da->attr)) {
VALUE_PAIR *check = pairmake(pleft, pright, token);
*presult = (radius_callback_compare(request, NULL, check, NULL, NULL) == 0);
RDEBUG3(" Callback returns %d",
*presult);
pairfree(&check);
return TRUE;
}
RDEBUG2(" (Attribute %s was not found)",
pleft);
*presult = 0;
return TRUE;
}
#ifdef HAVE_REGEX_H
/*
* Regex comparisons treat everything as
* strings.
*/
if ((token == T_OP_REG_EQ) ||
(token == T_OP_REG_NE)) {
vp_prints_value(buffer, sizeof(buffer), vp, 0);
pleft = buffer;
goto do_checks;
}
#endif
memcpy(&myvp, vp, sizeof(myvp));
if (!pairparsevalue(&myvp, pright)) {
RDEBUG2("Failed parsing \"%s\": %s",
pright, fr_strerror());
return FALSE;
}
myvp.operator = token;
*presult = paircmp(&myvp, vp);
RDEBUG3(" paircmp -> %d", *presult);
return TRUE;
} /* else it's not a VP in a list */
}
#ifdef HAVE_REGEX_H
do_checks:
#endif
switch (token) {
case T_OP_GE:
case T_OP_GT:
case T_OP_LE:
case T_OP_LT:
if (!all_digits(pright)) {
RDEBUG2(" (Right field is not a number at: %s)", pright);
return FALSE;
}
rint = strtoul(pright, NULL, 0);
if (!all_digits(pleft)) {
RDEBUG2(" (Left field is not a number at: %s)", pleft);
return FALSE;
}
lint = strtoul(pleft, NULL, 0);
break;
default:
lint = rint = 0; /* quiet the compiler */
break;
}
switch (token) {
case T_OP_CMP_TRUE:
/*
* Check for truth or falsehood.
*/
if (all_digits(pleft)) {
lint = strtoul(pleft, NULL, 0);
result = (lint != 0);
} else {
result = (*pleft != '\0');
}
break;
case T_OP_CMP_EQ:
result = (strcmp(pleft, pright) == 0);
break;
case T_OP_NE:
result = (strcmp(pleft, pright) != 0);
break;
case T_OP_GE:
result = (lint >= rint);
break;
case T_OP_GT:
result = (lint > rint);
break;
case T_OP_LE:
result = (lint <= rint);
break;
case T_OP_LT:
result = (lint < rint);
break;
#ifdef HAVE_REGEX_H
case T_OP_REG_EQ: {
int i, compare;
regex_t reg;
regmatch_t rxmatch[REQUEST_MAX_REGEX + 1];
/*
* Include substring matches.
*/
compare = regcomp(®, pright, cflags);
if (compare != 0) {
if (debug_flag) {
char errbuf[128];
regerror(compare, ®, errbuf, sizeof(errbuf));
DEBUG("ERROR: Failed compiling regular expression: %s", errbuf);
}
return FALSE;
}
compare = regexec(®, pleft,
REQUEST_MAX_REGEX + 1,
rxmatch, 0);
regfree(®);
/*
* Add new %{0}, %{1}, etc.
*/
if (compare == 0) for (i = 0; i <= REQUEST_MAX_REGEX; i++) {
char *r;
free(request_data_get(request, request,
REQUEST_DATA_REGEX | i));
/*
* No %{i}, skip it.
* We MAY have %{2} without %{1}.
*/
if (rxmatch[i].rm_so == -1) continue;
/*
* Copy substring into allocated buffer
*/
r = rad_malloc(rxmatch[i].rm_eo -rxmatch[i].rm_so + 1);
memcpy(r, pleft + rxmatch[i].rm_so,
rxmatch[i].rm_eo - rxmatch[i].rm_so);
r[rxmatch[i].rm_eo - rxmatch[i].rm_so] = '\0';
request_data_add(request, request,
REQUEST_DATA_REGEX | i,
r, free);
}
result = (compare == 0);
}
break;
case T_OP_REG_NE: {
int compare;
regex_t reg;
regmatch_t rxmatch[REQUEST_MAX_REGEX + 1];
/*
* Include substring matches.
*/
compare = regcomp(®, pright, cflags);
if (compare != 0) {
if (debug_flag) {
char errbuf[128];
regerror(compare, ®, errbuf, sizeof(errbuf));
DEBUG("ERROR: Failed compiling regular expression: %s", errbuf);
}
return FALSE;
}
compare = regexec(®, pleft,
REQUEST_MAX_REGEX + 1,
rxmatch, 0);
regfree(®);
result = (compare != 0);
}
break;
#endif
default:
DEBUG("ERROR: Comparison operator %s is not supported",
fr_token_name(token));
result = FALSE;
break;
}
*presult = result;
return TRUE;
}
/** Evaluate a map
*
* @param[in] request the REQUEST
* @param[in] modreturn the previous module return code
* @param[in] depth of the recursion (only used for debugging)
* @param[in] c the condition to evaluate
* @return -1 on error, 0 for "no match", 1 for "match".
*/
int radius_evaluate_map(REQUEST *request, UNUSED int modreturn, UNUSED int depth,
fr_cond_t const *c)
{
int rcode;
char *lhs, *rhs;
value_pair_map_t *map;
rad_assert(c->type == COND_TYPE_MAP);
map = c->data.map;
rad_assert(map->dst->type != TMPL_TYPE_UNKNOWN);
rad_assert(map->src->type != TMPL_TYPE_UNKNOWN);
rad_assert(map->dst->type != TMPL_TYPE_LIST);
rad_assert(map->src->type != TMPL_TYPE_LIST);
rad_assert(map->dst->type != TMPL_TYPE_REGEX);
rad_assert(map->dst->type != TMPL_TYPE_REGEX_STRUCT);
EVAL_DEBUG("MAP TYPES LHS: %s, RHS: %s",
fr_int2str(template_names, map->dst->type, "???"),
fr_int2str(template_names, map->src->type, "???"));
/*
* Verify regexes.
*/
if ((map->src->type == TMPL_TYPE_REGEX) ||
(map->src->type == TMPL_TYPE_REGEX_STRUCT)) {
rad_assert(map->op == T_OP_REG_EQ);
} else {
rad_assert(!((map->op == T_OP_REG_EQ) || (map->op == T_OP_REG_NE)));
}
/*
* They're both attributes. Do attribute-specific work.
*
* LHS is DST. RHS is SRC <sigh>
*/
if (!c->cast && (map->src->type == TMPL_TYPE_ATTR) && (map->dst->type == TMPL_TYPE_ATTR)) {
VALUE_PAIR *lhs_vp, *rhs_vp, *cast_vp;
EVAL_DEBUG("ATTR to ATTR");
if ((tmpl_find_vp(&lhs_vp, request, map->dst) < 0) ||
(tmpl_find_vp(&rhs_vp, request, map->src) < 0)) return -1;
if (map->dst->tmpl_da->type == map->src->tmpl_da->type) {
return paircmp_op(lhs_vp, map->op, rhs_vp);
}
/*
* Compare a large integer (lhs) to a small integer (rhs).
* We allow this without a cast.
*/
rad_assert((map->dst->tmpl_da->type == PW_TYPE_INTEGER64) ||
(map->dst->tmpl_da->type == PW_TYPE_INTEGER) ||
(map->dst->tmpl_da->type == PW_TYPE_SHORT));
rad_assert((map->src->tmpl_da->type == PW_TYPE_INTEGER) ||
(map->src->tmpl_da->type == PW_TYPE_SHORT) ||
(map->src->tmpl_da->type == PW_TYPE_BYTE));
cast_vp = pairalloc(request, lhs_vp->da);
if (!cast_vp) return false;
/*
* Copy the RHS to the casted type.
*/
if (do_cast_copy(cast_vp, rhs_vp) < 0) {
talloc_free(cast_vp);
return false;
}
rcode = paircmp_op(lhs_vp, map->op, cast_vp);
talloc_free(cast_vp);
return rcode;
}
/*
* LHS is a cast. Do type-specific comparisons, as if
* the LHS was a real attribute.
*/
if (c->cast) {
VALUE_PAIR *lhs_vp, *rhs_vp;
/*
* Try to copy data from the VP which is being
* casted, instead of printing it to a string and
* then re-parsing it.
*/
if (map->dst->type == TMPL_TYPE_ATTR) {
VALUE_PAIR *cast_vp;
if (tmpl_find_vp(&cast_vp, request, map->dst) < 0) return false;
lhs_vp = pairalloc(request, c->cast);
if (!lhs_vp) return -1;
/*
* In a separate function for clarity
*/
if (do_cast_copy(lhs_vp, cast_vp) < 0) {
talloc_free(lhs_vp);
return -1;
}
} else {
rcode = tmpl_cast_to_vp(&lhs_vp, request, map->dst, c->cast);
if (rcode < 0) {
return rcode;
}
}
rad_assert(lhs_vp);
/*
* Get either a real VP, or parse the RHS into a
* VP, and return that.
*/
if (map->src->type == TMPL_TYPE_ATTR) {
if (tmpl_find_vp(&rhs_vp, request, map->src) < 0) {
return -2;
}
} else {
rcode = tmpl_cast_to_vp(&rhs_vp, request, map->src, c->cast);
if (rcode < 0) {
return rcode;
}
rad_assert(rhs_vp);
}
if (!rhs_vp) return -2;
EVAL_DEBUG("CAST to %s",
fr_int2str(dict_attr_types,
c->cast->type, "?Unknown?"));
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
pairfree(&lhs_vp);
if (map->src->type != TMPL_TYPE_ATTR) {
pairfree(&rhs_vp);
}
return rcode;
}
/*
* Might be a virtual comparison
*/
if ((map->dst->type == TMPL_TYPE_ATTR) &&
(map->src->type != TMPL_TYPE_REGEX) &&
(map->src->type != TMPL_TYPE_REGEX_STRUCT) &&
(c->pass2_fixup == PASS2_PAIRCOMPARE)) {
int ret;
VALUE_PAIR *lhs_vp;
EVAL_DEBUG("virtual ATTR to DATA");
rcode = tmpl_cast_to_vp(&lhs_vp, request, map->src, map->dst->tmpl_da);
if (rcode < 0) return rcode;
rad_assert(lhs_vp);
/*
* paircompare requires the operator be set for the
* check attribute.
*/
lhs_vp->op = map->op;
ret = paircompare(request, request->packet->vps, lhs_vp, NULL);
talloc_free(lhs_vp);
if (ret == 0) {
return true;
}
return false;
}
rad_assert(c->pass2_fixup != PASS2_PAIRCOMPARE);
/*
* RHS has been pre-parsed into binary data. Go check
* that.
*/
if ((map->dst->type == TMPL_TYPE_ATTR) &&
(map->src->type == TMPL_TYPE_DATA)) {
VALUE_PAIR *lhs_vp, *rhs_vp;
EVAL_DEBUG("ATTR to DATA");
if (tmpl_find_vp(&lhs_vp, request, map->dst) < 0) return -2;
rcode = tmpl_cast_to_vp(&rhs_vp, request, map->src, map->dst->tmpl_da);
if (rcode < 0) return rcode;
rad_assert(rhs_vp);
#ifdef WITH_EVAL_DEBUG
debug_pair(lhs_vp);
debug_pair(rhs_vp);
#endif
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
pairfree(&rhs_vp);
return rcode;
}
rad_assert(map->src->type != TMPL_TYPE_DATA);
rad_assert(map->dst->type != TMPL_TYPE_DATA);
#ifdef HAVE_REGEX_H
/*
* Parse regular expressions.
*/
if ((map->src->type == TMPL_TYPE_REGEX) ||
(map->src->type == TMPL_TYPE_REGEX_STRUCT)) {
return do_regex(request, map);
}
#endif
/*
* The RHS now needs to be expanded into a string.
*/
rcode = radius_expand_tmpl(&rhs, request, map->src);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return rcode;
}
rad_assert(rhs != NULL);
/*
* User-Name == FOO
*
* Parse the RHS to be the same DA as the LHS. do
* comparisons. So long as it's not a regex, which does
* string comparisons.
*
* The LHS may be a virtual attribute, too.
*/
if (map->dst->type == TMPL_TYPE_ATTR) {
VALUE_PAIR *lhs_vp, *rhs_vp;
EVAL_DEBUG("ATTR to non-REGEX");
/*
* No LHS means no match
*/
if (tmpl_find_vp(&lhs_vp, request, map->dst) < 0) {
/*
* Not a real attr: might be a dynamic comparison.
*/
if ((map->dst->type == TMPL_TYPE_ATTR) &&
(map->dst->tmpl_da->vendor == 0) &&
radius_find_compare(map->dst->tmpl_da)) {
rhs_vp = pairalloc(request, map->dst->tmpl_da);
rad_assert(rhs_vp != NULL);
if (pairparsevalue(rhs_vp, rhs, 0) < 0) {
talloc_free(rhs);
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
talloc_free(rhs);
rcode = (radius_callback_compare(request, NULL, rhs_vp, NULL, NULL) == 0);
pairfree(&rhs_vp);
return rcode;
}
return -2;
}
/*
* Get VP for RHS
*/
rhs_vp = pairalloc(request, map->dst->tmpl_da);
rad_assert(rhs_vp != NULL);
if (pairparsevalue(rhs_vp, rhs, 0) < 0) {
talloc_free(rhs);
pairfree(&rhs_vp);
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
rcode = paircmp_op(lhs_vp, map->op, rhs_vp);
talloc_free(rhs);
pairfree(&rhs_vp);
return rcode;
}
/*
* The LHS is a string. Expand it.
*/
rcode = radius_expand_tmpl(&lhs, request, map->dst);
if (rcode < 0) {
EVAL_DEBUG("FAIL %d", __LINE__);
return rcode;
}
rad_assert(lhs != NULL);
EVAL_DEBUG("LHS is %s", lhs);
/*
* Loop over the string, doing comparisons
*/
if (all_digits(lhs) && all_digits(rhs)) {
int lint, rint;
lint = strtoul(lhs, NULL, 0);
rint = strtoul(rhs, NULL, 0);
talloc_free(lhs);
talloc_free(rhs);
switch (map->op) {
case T_OP_CMP_EQ:
return (lint == rint);
case T_OP_NE:
return (lint != rint);
case T_OP_LT:
return (lint < rint);
case T_OP_GT:
return (lint > rint);
case T_OP_LE:
return (lint <= rint);
case T_OP_GE:
return (lint >= rint);
default:
break;
}
} else {
rad_assert(lhs != NULL);
rad_assert(rhs != NULL);
rcode = strcmp(lhs, rhs);
talloc_free(lhs);
talloc_free(rhs);
switch (map->op) {
case T_OP_CMP_EQ:
return (rcode == 0);
case T_OP_NE:
return (rcode != 0);
case T_OP_LT:
return (rcode < 0);
case T_OP_GT:
return (rcode > 0);
case T_OP_LE:
return (rcode <= 0);
case T_OP_GE:
return (rcode >= 0);
default:
break;
}
}
EVAL_DEBUG("FAIL %d", __LINE__);
return -1;
}
