void
proc_parse_config(const char *token, char *cptr)
{
char tmpname[STRMAX];
struct myproc **procp = &procwatch;
/*
* don't allow two entries with the same name
*/
copy_nword(cptr, tmpname, sizeof(tmpname));
if (get_proc_by_name(tmpname) != NULL) {
config_perror("Already have an entry for this process.");
return;
}
/*
* skip past used ones
*/
while (*procp != NULL)
procp = &((*procp)->next);
(*procp) = (struct myproc *) calloc(1, sizeof(struct myproc));
if (*procp == NULL)
return; /* memory alloc error */
numprocs++;
/*
* not blank and not a comment
*/
copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr))) {
(*procp)->max = atoi(cptr);
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr)))
(*procp)->min = atoi(cptr);
else
(*procp)->min = 0;
} else {
/* Default to asssume that we require at least one
* such process to be running, but no upper limit */
(*procp)->max = 0;
(*procp)->min = 1;
/* This frees "proc <procname> 0 0" to monitor
* processes that should _not_ be running. */
}
#ifdef NETSNMP_PROCFIXCMD
sprintf((*procp)->fixcmd, NETSNMP_PROCFIXCMD, (*procp)->name);
#endif
DEBUGMSGTL(("ucd-snmp/proc", "Read: %s (%d) (%d)\n",
(*procp)->name, (*procp)->max, (*procp)->min));
}
void
loadave_parse_config(const char *token, char *cptr)
{
int i;
if (strcmp(token, "pload") == 0) {
if (laConfigSet < 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
return;
} else {
laConfigSet++;
}
} else {
if (laConfigSet > 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
/*
* Fall through and copy in this value.
*/
}
laConfigSet = -1;
}
for (i = 0; i <= 2; i++) {
if (cptr != NULL)
maxload[i] = atof(cptr);
else
maxload[i] = maxload[i - 1];
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
}
}
char *skip_token(char *ptr)
{
ptr = skip_white(ptr);
ptr = skip_not_white(ptr);
ptr = skip_white(ptr);
return (ptr);
}
void
proc_parse_config(const char *token, char *cptr)
{
char tmpname[STRMAX];
struct myproc **procp = &procwatch;
/*
* don't allow two entries with the same name
*/
copy_nword(cptr, tmpname, sizeof(tmpname));
if (get_proc_by_name(tmpname) != NULL) {
config_perror("Already have an entry for this process.");
return;
}
/*
* skip past used ones
*/
while (*procp != NULL)
procp = &((*procp)->next);
(*procp) = (struct myproc *) calloc(1, sizeof(struct myproc));
if (*procp == NULL)
return; /* memory alloc error */
numprocs++;
/*
* not blank and not a comment
*/
copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr))) {
(*procp)->max = atoi(cptr);
cptr = skip_not_white(cptr);
if ((cptr = skip_white(cptr)))
(*procp)->min = atoi(cptr);
else
(*procp)->min = 0;
} else {
(*procp)->max = 0;
(*procp)->min = 0;
}
#ifdef NETSNMP_PROCFIXCMD
sprintf((*procp)->fixcmd, NETSNMP_PROCFIXCMD, (*procp)->name);
#endif
DEBUGMSGTL(("ucd-snmp/proc", "Read: %s (%d) (%d)\n",
(*procp)->name, (*procp)->max, (*procp)->min));
}
/**
* @internal
* parse mode:
*/
void
_pm_save_index_string_string(FILE *f, netsnmp_container *cin,
int flags)
{
char line[STRINGMAX], *ptr;
netsnmp_token_value_index *tvi;
size_t count = 0, len;
netsnmp_assert(NULL != f);
netsnmp_assert(NULL != cin);
while (fgets(line, sizeof(line), f) != NULL) {
++count;
ptr = line;
len = strlen(line) - 1;
if (line[len] == '\n')
line[len] = 0;
/*
* save blank line or comment?
*/
if (flags & PM_FLAG_SKIP_WHITESPACE) {
if (NULL == (ptr = skip_white(ptr)))
continue;
}
tvi = SNMP_MALLOC_TYPEDEF(netsnmp_token_value_index);
if (NULL == tvi) {
snmp_log(LOG_ERR,"malloc failed\n");
break;
}
/*
* copy whole line, then set second pointer to
* after token. One malloc, 2 strings!
*/
tvi->index = count;
tvi->token = strdup(line);
if (NULL == tvi->token) {
snmp_log(LOG_ERR,"malloc failed\n");
free(tvi);
break;
}
tvi->value.cp = skip_not_white(tvi->token);
if (NULL != tvi->value.cp) {
*(tvi->value.cp) = 0;
++(tvi->value.cp);
}
CONTAINER_INSERT(cin, tvi);
}
}
void
loadave_parse_config(const char *token, char *cptr)
{
int i;
for (i = 0; i <= 2; i++) {
if (cptr != NULL)
maxload[i] = atof(cptr);
else
maxload[i] = maxload[i - 1];
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
}
}
char *find_field (char *ptr, int field)
{
int i;
char *init = ptr;
if (field == NETSNMP_LASTFIELD)
{
/*
* skip to end
*/
while (*ptr++);
ptr = ptr - 2;
/*
* rewind a field length
*/
while (*ptr != 0 && isspace ((unsigned char) (*ptr)) && init <= ptr)
ptr--;
while (*ptr != 0 && !isspace ((unsigned char) (*ptr)) && init <= ptr)
ptr--;
if (isspace ((unsigned char) (*ptr)))
ptr++; /* past space */
if (ptr < init)
ptr = init;
if (!isspace ((unsigned char) (*ptr)) && *ptr != 0)
return (ptr);
}
else
{
if ((ptr = skip_white (ptr)) == NULL)
return (NULL);
for (i = 1; *ptr != 0 && i != field; i++)
{
if ((ptr = skip_not_white (ptr)) == NULL)
return (NULL);
if ((ptr = skip_white (ptr)) == NULL)
return (NULL);
}
if (*ptr != 0 && i == field)
return (ptr);
return (NULL);
}
return (NULL);
}
void
extensible_parse_config(const char *token, char *cptr)
{
struct extensible *ptmp, **pp;
char *tcptr;
int scount;
/*
* allocate and clear memory structure
*/
ptmp = (struct extensible *) calloc(1, sizeof(struct extensible));
if (ptmp == NULL)
return; /* XXX memory alloc error */
if (*cptr == '.')
cptr++;
if (isdigit(*cptr)) {
/*
* its a relocatable extensible mib
*/
config_perror("WARNING: This output format is not valid, and is only retained for backward compatibility - Please consider using the 'extend' directive instead" );
for (pp = &relocs, numrelocs++; *pp; pp = &((*pp)->next));
(*pp) = ptmp;
pp = &relocs; scount = numrelocs;
} else {
/*
* it goes in with the general extensible table
*/
for (pp = &extens, numextens++; *pp; pp = &((*pp)->next));
(*pp) = ptmp;
pp = &extens; scount = numextens;
}
/*
* the rest is pretty much handled the same
*/
if (!strncasecmp(token, "sh", 2))
ptmp->type = SHPROC;
else
ptmp->type = EXECPROC;
if (isdigit(*cptr)) {
ptmp->miblen = parse_miboid(cptr, ptmp->miboid);
while (isdigit(*cptr) || *cptr == '.')
cptr++;
}
/*
* name
*/
cptr = skip_white(cptr);
copy_nword(cptr, ptmp->name, sizeof(ptmp->name));
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
/*
* command
*/
if (cptr == NULL) {
config_perror("No command specified on line");
} else {
/*
* Support multi-element commands in shell configuration
* lines, but truncate after the first command for 'exec'
*/
for (tcptr = cptr; *tcptr != 0 && *tcptr != '#'; tcptr++)
if (*tcptr == ';' && ptmp->type == EXECPROC)
break;
sprintf(ptmp->command, "%.*s", (int) (tcptr - cptr), cptr);
}
#ifdef NETSNMP_EXECFIXCMD
sprintf(ptmp->fixcmd, NETSNMP_EXECFIXCMD, ptmp->name);
#endif
if (ptmp->miblen > 0) {
/*
* For relocatable "exec" entries,
* register the new (not-strictly-valid) MIB subtree...
*/
register_mib(token,
(struct variable *) extensible_relocatable_variables,
sizeof(struct variable2),
sizeof(extensible_relocatable_variables) /
sizeof(*extensible_relocatable_variables),
ptmp->miboid, ptmp->miblen);
/*
* ... and ensure the entries are sorted by OID.
* This isn't needed for entries in the main extTable (which
* don't have MIB OIDs explicitly associated with them anyway)
*/
if (scount > 1 && pp != &extens) {
int i;
struct extensible **etmp = (struct extensible **)
malloc(((sizeof(struct extensible *)) * scount));
if (etmp == NULL)
return; /* XXX memory alloc error */
for (i = 0, ptmp = *pp;
i < scount && ptmp != 0; i++, ptmp = ptmp->next)
etmp[i] = ptmp;
qsort(etmp, scount, sizeof(struct extensible *),
pass_compare);
*pp = (struct extensible *) etmp[0];
ptmp = (struct extensible *) etmp[0];
for (i = 0; i < scount - 1; i++) {
ptmp->next = etmp[i + 1];
ptmp = ptmp->next;
}
ptmp->next = NULL;
free(etmp);
}
}
}
static void
disk_parse_config(const char *token, char *cptr)
{
#if HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS
char tmpbuf[1024];
char path[STRMAX];
int minpercent;
int minspace;
if (numdisks == maxdisks) {
if (maxdisks == 0) {
maxdisks = 50;
disks = malloc(maxdisks * sizeof(struct diskpart));
if (!disks) {
config_perror("malloc failed for new disk allocation.");
sprintf(tmpbuf, "\tignoring: %s", cptr);
tmpbuf[ sizeof(tmpbuf)-1 ] = 0;
config_perror(tmpbuf);
return;
}
memset(disks, 0, maxdisks * sizeof(struct diskpart));
} else {
maxdisks *= 2;
disks = realloc(disks, maxdisks * sizeof(struct diskpart));
if (!disks) {
config_perror("malloc failed for new disk allocation.");
sprintf(tmpbuf, "\tignoring: %s", cptr);
tmpbuf[ sizeof(tmpbuf)-1 ] = 0;
config_perror(tmpbuf);
return;
}
memset(disks + maxdisks/2, 0, maxdisks/2 * sizeof(struct diskpart));
}
}
/*
* read disk path (eg, /1 or /usr)
*/
copy_nword(cptr, path, sizeof(path));
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
/*
* read optional minimum disk usage spec
*/
if(cptr != NULL) {
if(strchr(cptr, '%') == 0) {
minspace = atoi(cptr);
minpercent = -1;
}
else {
minspace = -1;
minpercent = atoi(cptr);
}
} else {
minspace = NETSNMP_DEFDISKMINIMUMSPACE;
minpercent = -1;
}
/*
* check if the disk already exists, if so then modify its
* parameters. if it does not exist then add it
*/
add_device(path, find_device(path), minspace, minpercent, 1);
#endif /* HAVE_FSTAB_H || HAVE_GETMNTENT || HAVE_STATFS */
}
/**
* @internal
* process token value index line
*/
static int
_process_line_udp_ep(netsnmp_line_info *line_info, void *mem,
struct netsnmp_line_process_info_s* lpi)
{
netsnmp_udp_endpoint_entry *ep = (netsnmp_udp_endpoint_entry *)mem;
char *ptr, *sep;
u_char *u_ptr;
size_t u_ptr_len, offset, len;
unsigned long long inode;
size_t count = 0;
/*
* skip 'sl'
*/
ptr = skip_not_white(line_info->start);
if (NULL == ptr) {
DEBUGMSGTL(("access:udp_endpoint", "no sl '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
ptr = skip_white(ptr);
if (NULL == ptr) {
DEBUGMSGTL(("text:util:tvi", "no space after sl '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
/*
* get local address. ignore error on hex conversion, since that
* function doesn't like the ':' between address and port. check the
* offset to see if it worked. May need to flip string too.
*/
u_ptr = ep->loc_addr;
u_ptr_len = sizeof(ep->loc_addr);
sep = strchr(ptr, ':');
if (NULL == sep) {
DEBUGMSGTL(("text:util:tvi", "no ':' '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
len = (sep - ptr);
if (-1 == netsnmp_addrstr_hton(ptr, len)) {
DEBUGMSGTL(("text:util:tvi", "bad length %d for loc addr '%s'\n",
(int)u_ptr_len, line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
offset = 0;
netsnmp_hex_to_binary(&u_ptr, &u_ptr_len, &offset, 0, ptr, NULL);
if ((4 != offset) && (16 != offset)) {
DEBUGMSGTL(("text:util:tvi", "bad offset %d for loc addr '%s'\n",
(int)offset, line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
ep->loc_addr_len = offset;
ptr += (offset * 2);
++ptr; /* skip ':' */
/*
* get local port
*/
ep->loc_port = strtol(ptr, &ptr, 16);
ptr = skip_white(ptr);
/*
* get remote address. ignore error on hex conversion, since that
* function doesn't like the ':' between address and port. check the
* offset to see if it worked. May need to flip string too.
*/
u_ptr = ep->rmt_addr;
u_ptr_len = sizeof(ep->rmt_addr);
sep = strchr(ptr, ':');
if (NULL == sep) {
DEBUGMSGTL(("text:util:tvi", "no ':' '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
len = (sep - ptr);
if (-1 == netsnmp_addrstr_hton(ptr, len)) {
DEBUGMSGTL(("text:util:tvi", "bad length %d for rmt addr '%s'\n",
(int)u_ptr_len, line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
offset = 0;
netsnmp_hex_to_binary(&u_ptr, &u_ptr_len, &offset, 0, ptr, NULL);
if ((4 != offset) && (16 != offset)) {
DEBUGMSGTL(("text:util:tvi", "bad offset %d for rmt addr '%s'\n",
(int)offset, line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
ep->rmt_addr_len = offset;
ptr += (offset * 2);
++ptr; /* skip ':' */
/*
* get remote port
*/
ep->rmt_port = strtol(ptr, &ptr, 16);
ptr = skip_white(ptr);
/*
* get state too
*/
ep->state = strtol(ptr, &ptr, 16);
/*
* Use inode as instance value.
*/
while (count != 5) {
ptr = skip_white(ptr);
ptr = skip_not_white(ptr);
count++;
}
inode = strtoull(ptr, &ptr, 0);
ep->instance = (u_int)inode;
/*
* get the pid also
*/
ep->pid = netsnmp_get_pid_from_inode(inode);
ep->index = (uintptr_t)(lpi->user_context);
lpi->user_context = (void*)((char*)(lpi->user_context) + 1);
ep->oid_index.oids = &ep->index;
ep->oid_index.len = 1;
return PMLP_RC_MEMORY_USED;
}
void disk_parse_config(char *token, char *cptr)
{
#if HAVE_GETMNTENT
#if HAVE_SYS_MNTTAB_H
struct mnttab mnttab;
#else
struct mntent *mntent;
#endif
FILE *mntfp;
#else
#if HAVE_FSTAB_H
struct fstab *fstab;
struct stat stat1, stat2;
#endif
#endif
char tmpbuf[1024];
#if defined(HAVE_GETMNTENT) && !defined(HAVE_SETMNTENT)
int i;
#endif
#if HAVE_FSTAB_H || HAVE_GETMNTENT
if (numdisks == MAXDISKS) {
config_perror("Too many disks specified.");
sprintf(tmpbuf,"\tignoring: %s",cptr);
config_perror(tmpbuf);
}
else {
/* read disk path (eg, /1 or /usr) */
copy_word(cptr,disks[numdisks].path);
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
/* read optional minimum disk usage spec */
if (cptr != NULL) {
if (strchr(cptr, '%') == 0) {
disks[numdisks].minimumspace = atoi(cptr);
disks[numdisks].minpercent = -1;
}
else {
disks[numdisks].minimumspace = -1;
disks[numdisks].minpercent = atoi(cptr);
}
}
else {
disks[numdisks].minimumspace = DEFDISKMINIMUMSPACE;
disks[numdisks].minpercent = -1;
}
/* find the device associated with the directory */
#if HAVE_GETMNTENT
#if HAVE_SETMNTENT
mntfp = setmntent(ETC_MNTTAB, "r");
disks[numdisks].device[0] = 0;
while ((mntent = getmntent (mntfp)))
if (strcmp (disks[numdisks].path, mntent->mnt_dir) == 0) {
copy_word (mntent->mnt_fsname, disks[numdisks].device);
DEBUGMSGTL(("ucd-snmp/disk", "Disk: %s\n",mntent->mnt_fsname));
break;
}
else {
DEBUGMSGTL(("ucd-snmp/disk", " %s != %s\n", disks[numdisks].path,
mntent->mnt_dir));
}
endmntent(mntfp);
if (disks[numdisks].device[0] != 0) {
/* dummy clause for else below */
numdisks += 1; /* but inc numdisks here after test */
}
#else /* getmentent but not setmntent */
mntfp = fopen (ETC_MNTTAB, "r");
while ((i = getmntent (mntfp, &mnttab)) == 0)
if (strcmp (disks[numdisks].path, mnttab.mnt_mountp) == 0)
break;
else {
DEBUGMSGTL(("ucd-snmp/disk", " %s != %s\n", disks[numdisks].path, mnttab.mnt_mountp));
}
fclose (mntfp);
if (i == 0) {
copy_word (mnttab.mnt_special, disks[numdisks].device);
numdisks += 1;
}
#endif /* HAVE_SETMNTENT */
#else
#if HAVE_FSTAB_H
stat(disks[numdisks].path,&stat1);
setfsent();
if ((fstab = getfsfile(disks[numdisks].path))) {
copy_word(fstab->fs_spec,disks[numdisks].device);
numdisks += 1;
}
#endif
#endif
else {
sprintf(tmpbuf, "Couldn't find device for disk %s",
disks[numdisks].path);
config_pwarn(tmpbuf);
disks[numdisks].minimumspace = -1;
disks[numdisks].minpercent = -1;
disks[numdisks].path[0] = 0;
}
#if HAVE_FSTAB_H
endfsent();
#endif
}
#else
config_perror("'disk' checks not supported on this architecture.");
#endif
}
void extensible_parse_config(char *token, char* cptr)
{
struct extensible **pptmp;
struct extensible **pprelocs = &relocs;
struct extensible **ppexten = &extens;
char *tcptr;
if (*cptr == '.') cptr++;
if (isdigit(*cptr)) {
/* its a relocatable extensible mib */
while(*pprelocs != NULL)
pprelocs = &((*pprelocs)->next);
numrelocs++;
(*pprelocs) = (struct extensible *) malloc(sizeof(struct extensible));
pptmp = pprelocs;
} else {
/* it goes in with the general extensible table */
while(*ppexten != NULL)
ppexten = &((*ppexten)->next);
numextens++;
(*ppexten) =
(struct extensible *) malloc(sizeof(struct extensible));
pptmp = ppexten;
}
/* the rest is pretty much handled the same */
if (!strncasecmp(token,"sh",2))
(*pptmp)->type = SHPROC;
else
(*pptmp)->type = EXECPROC;
if (isdigit(*cptr)) {
(*pptmp)->miblen = parse_miboid(cptr,(*pptmp)->miboid);
while (isdigit(*cptr) || *cptr == '.') cptr++;
}
else {
(*pptmp)->miboid[0] = 0;
(*pptmp)->miblen = 0;
}
/* name */
cptr = skip_white(cptr);
copy_word(cptr,(*pptmp)->name);
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
/* command */
if (cptr == NULL) {
config_perror("No command specified on line");
(*pptmp)->command[0] = 0;
} else {
for(tcptr=cptr; *tcptr != 0 && *tcptr != '#' && *tcptr != ';';
tcptr++);
strncpy((*pptmp)->command,cptr,tcptr-cptr);
(*pptmp)->command[tcptr-cptr] = 0;
(*pptmp)->next = NULL;
}
#ifdef PROCFIXCMD
sprintf((*pptmp)->fixcmd, EXECFIXCMD, (*pptmp)->name);
#endif
if ((*pptmp)->miblen > 0) {
register_mib(token, (struct variable *) extensible_relocatable_variables,
sizeof(struct variable2),
6, (*pptmp)->miboid, (*pptmp)->miblen);
}
}
/* read_config_read_octet_string(): reads an octet string that was
saved by the read_config_save_octet_string() function */
char *read_config_read_octet_string(char *readfrom, u_char **str, size_t *len) {
u_char *cptr=NULL;
char *cptr1;
u_int tmp;
int i;
if (readfrom == NULL || str == NULL)
return NULL;
if (strncasecmp(readfrom,"0x",2) == 0) {
/* A hex string submitted. How long? */
readfrom += 2;
cptr1 = skip_not_white(readfrom);
if (cptr1)
*len = (cptr1 - readfrom);
else
*len = strlen(readfrom);
if (*len % 2) {
DEBUGMSGTL(("read_config_read_octet_string","invalid hex string: wrong length"));
return NULL;
}
*len = *len / 2;
/* malloc data space if needed */
if (*str == NULL) {
if (*len == 0) {
/* null length string found */
cptr = NULL;
} else if (*len > 0 && (str == NULL || (cptr = (u_char *)malloc(*len)) == NULL)) {
return NULL;
}
*str = cptr;
} else {
cptr = *str;
}
/* copy data */
for(i = 0; i < (int)*len; i++) {
sscanf(readfrom,"%2x",&tmp);
*cptr++ = (u_char) tmp;
readfrom += 2;
}
readfrom = skip_white(readfrom);
} else {
/* Normal string */
/* malloc data space if needed */
if (*str == NULL) {
char buf[SNMP_MAXBUF];
readfrom = copy_word(readfrom, buf);
*len = strlen(buf);
/* malloc an extra space to add a null */
if (*len > 0 && (str == NULL ||
(cptr = (u_char *) malloc(*len + 1))
== NULL))
return NULL;
*str = cptr;
if (cptr)
memcpy(cptr, buf, (*len+1));
} else {
readfrom = copy_word(readfrom, (char *)*str);
}
}
return readfrom;
}
/**
* @internal
* process token value index line
*/
int
_process_line_tvi(netsnmp_line_info *line_info, void *mem,
struct netsnmp_line_process_info_s* lpi)
{
netsnmp_token_value_index *tvi = (netsnmp_token_value_index *)mem;
char *ptr;
/*
* get token
*/
ptr = skip_not_white(line_info->start);
if (NULL == ptr) {
DEBUGMSGTL(("text:util:tvi", "no value after token '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
/*
* null terminate, search for value;
*/
*(ptr++) = 0;
ptr = skip_white(ptr);
if (NULL == ptr) {
DEBUGMSGTL(("text:util:tvi", "no value after token '%s'\n",
line_info->start));
return PMLP_RC_MEMORY_UNUSED;
}
/*
* get value
*/
switch((int)(intptr_t)lpi->user_context) {
case PMLP_TYPE_UNSIGNED:
tvi->value.ul = strtoul(ptr, NULL, 0);
if ((errno == ERANGE) && (ULONG_MAX == tvi->value.ul))
snmp_log(LOG_WARNING,"value overflow\n");
break;
case PMLP_TYPE_INTEGER:
tvi->value.sl = strtol(ptr, NULL, 0);
if ((errno == ERANGE) &&
((LONG_MAX == tvi->value.sl) ||
(LONG_MIN == tvi->value.sl)))
snmp_log(LOG_WARNING,"value over/under-flow\n");
break;
case PMLP_TYPE_STRING:
tvi->value.cp = strdup(ptr);
break;
case PMLP_TYPE_BOOLEAN:
if (isdigit((unsigned char)(*ptr)))
tvi->value.ul = strtoul(ptr, NULL, 0);
else if (strcasecmp(ptr,"true") == 0)
tvi->value.ul = 1;
else if (strcasecmp(ptr,"false") == 0)
tvi->value.ul = 0;
else {
snmp_log(LOG_WARNING,"bad value for boolean\n");
return PMLP_RC_MEMORY_UNUSED;
}
break;
default:
snmp_log(LOG_ERR,"unsupported value type %d\n",
(int)(intptr_t)lpi->user_context);
break;
}
/*
* save token and value
*/
tvi->token = strdup(line_info->start);
tvi->index = line_info->index;
return PMLP_RC_MEMORY_USED;
}
