int
show_all_matched_objects(FILE * fp, const char *patmatch, oid * name, size_t * name_length, int f_desc, /* non-zero if descriptions should be shown */
int width)
{
int result = 0, count = 0;
size_t savlen = *name_length;
#ifndef NETSNMP_DISABLE_MIB_LOADING
clear_tree_flags(get_tree_head());
#endif /* NETSNMP_DISABLE_MIB_LOADING */
while (1) {
*name_length = savlen;
#ifndef NETSNMP_DISABLE_MIB_LOADING
result = get_wild_node(patmatch, name, name_length);
#endif /* NETSNMP_DISABLE_MIB_LOADING */
if (!result)
break;
count++;
fprint_objid(fp, name, *name_length);
#ifndef NETSNMP_DISABLE_MIB_LOADING
if (f_desc)
fprint_description(fp, name, *name_length, width);
#endif /* NETSNMP_DISABLE_MIB_LOADING */
}
return (count);
}
static char *snmp_get_octet_string(struct variable_list *vars)
{
const char *__function_name = "snmp_get_octet_string";
static char buf[MAX_STRING_LEN];
const char *hint;
char *strval_dyn = NULL, is_hex = 0;
size_t offset = 0;
struct tree *subtree;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
/* find the subtree to get display hint */
subtree = get_tree(vars->name, vars->name_length, get_tree_head());
hint = subtree ? subtree->hint : NULL;
/* we will decide if we want the value from vars->val or what snprint_value() returned later */
if (-1 == snprint_value(buf, sizeof(buf), vars->name, vars->name_length, vars))
goto end;
zabbix_log(LOG_LEVEL_DEBUG, "%s() full value:'%s'", __function_name, buf);
/* decide if it's Hex, offset will be possibly needed later */
if (0 == strncmp(buf, "Hex-STRING: ", 12))
{
is_hex = 1;
offset = 12;
}
/* in case of no hex and no display hint take the value from */
/* vars->val, it contains unquoted and unescaped string */
if (0 == is_hex && NULL == hint)
{
strval_dyn = zbx_malloc(strval_dyn, vars->val_len + 1);
memcpy(strval_dyn, vars->val.string, vars->val_len);
strval_dyn[vars->val_len] = '\0';
}
else
{
if (0 == is_hex && 0 == strncmp(buf, "STRING: ", 8))
offset = 8;
strval_dyn = zbx_strdup(strval_dyn, buf + offset);
}
zbx_rtrim(strval_dyn, ZBX_WHITESPACE);
zbx_ltrim(strval_dyn, ZBX_WHITESPACE);
end:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():'%s'", __function_name, strval_dyn ? strval_dyn : "(null)");
return strval_dyn;
}
int
main(int argc, char **argv) {
/*
int list[INTCNT] = {1,9,0,3,2,4,6,7,5,8,10,13,11,12,14}, i;
*/
int list[INTCNT] = {1,2,3,4,6,7,0,8,9,23,32,35,33,54,42}, i;
tree_t *mytree = make_empty_tree(void_intcmp);
/* Unbalanced */
for(i=0; i<INTCNT; i++) {
mytree = insert_in_order(mytree, list+i);
}
print_tree(mytree);
printf("minimum: %d\n\n", *(int*)((node_t*)get_tree_head(mytree))->data);
/* Unbalanced Tail */
mytree = get_tree_tail(mytree);
print_tree(mytree);
printf("minimum: %d\n", *(int*)((node_t*)get_tree_head(mytree))->data);
free_tree(mytree);
mytree = make_empty_tree(void_intcmp);
/* Balanced */
int_balance_insert(mytree, list, INTCNT);
print_tree(mytree);
printf("minimum: %d\n", *(int*)((node_t*)get_tree_head(mytree))->data);
/* Balanced Tail */
mytree = get_tree_tail(mytree);
print_tree(mytree);
printf("minimum: %d\n", *(int*)((node_t*)get_tree_head(mytree))->data);
return 0;
}
int
show_all_matched_objects(FILE * fp, const char *patmatch, oid * name, size_t * name_length, int f_desc, /* non-zero if descriptions should be shown */
int width)
{
int result, count = 0;
size_t savlen = *name_length;
clear_tree_flags(get_tree_head());
while (1) {
*name_length = savlen;
result = get_wild_node(patmatch, name, name_length);
if (!result)
break;
count++;
fprint_objid(fp, name, *name_length);
if (f_desc)
fprint_description(fp, name, *name_length, width);
}
return (count);
}
unsigned int
encode_vbind (char *oid_string, char oid_asntype, union t_val *value,
unsigned char *out_buffer, size_t out_size)
{
oid var_name[MAX_OID_LEN];
size_t name_len = MAX_OID_LEN;
oid oid_value[MAX_OID_LEN];
size_t oid_value_len = MAX_OID_LEN;
unsigned char *data_ptr;
unsigned char buf[SPRINT_MAX_LEN];
unsigned int ltmp;
struct tree *tp;
struct range_list *rp;
long len=0;
int rv;
long longval;
unsigned long ulongval;
memset (buf, 0, SPRINT_MAX_LEN);
if (!get_node (oid_string, var_name, &name_len))
{
if (!read_objid (oid_string, var_name, &name_len))
{
/* enable random access */
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_RANDOM_ACCESS))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_RANDOM_ACCESS);
}
if (!get_node (oid_string, var_name, &name_len))
{
/* Not found, try UCD style OID access */
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_READ_UCD_STYLE_OID);
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_READ_UCD_STYLE_OID))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_READ_UCD_STYLE_OID);
}
if (!read_objid (oid_string, var_name, &name_len))
{
/* Hmm, still not found, go back to net-snmp-style OID and try regex access */
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_READ_UCD_STYLE_OID);
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_REGEX_ACCESS))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_REGEX_ACCESS);
}
if (!get_wild_node (oid_string, var_name, &name_len))
{
/* Ran out of ideas. */
fprintf(stderr, "/* Error: Can't find oid %s at line %d */\n",
oid_string, line);
snmp_perror ("encode_vbind");
return 0;
}
}
}
}
}
switch (oid_asntype)
{
case 'i':
longval = value->intval;
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_INTEGER,
sizeof (long),
(unsigned char *) &longval,
&out_size);
return data_ptr - out_buffer;
break;
;;
case 'g':
ulongval = value->intval;
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_GAUGE,
sizeof (unsigned long),
(unsigned char *) &ulongval,
&out_size);
return data_ptr - out_buffer;
break;
;;
case 'c':
ulongval = value->intval;
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_COUNTER,
sizeof (unsigned long),
(unsigned char *) &ulongval,
&out_size);
return data_ptr - out_buffer;
break;
;;
case 'u':
ulongval = value->intval;
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_GAUGE,
sizeof (unsigned long),
(unsigned char *) &ulongval,
&out_size);
return data_ptr - out_buffer;
break;
;;
case 't':
ulongval = value->intval;
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_TIMETICKS,
sizeof (unsigned long),
(unsigned char *) &ulongval,
&out_size);
return data_ptr - out_buffer;
break;
;;
case 's':
case 'x':
case 'd':
if (oid_asntype == 'd')
{
/* ltmp = ascii_to_binary(value->strval, buf);
strncpy((char*)buf, value, SPRINT_MAX_BUF);
ltmp = strlen((char*)buf); */
}
else if (oid_asntype == 's')
{
strncpy ((char *) buf, value->strval, SPRINT_MAX_LEN);
len = strlen ((char *) buf);
}
else if (oid_asntype == 'x')
{
if ((rv = hexadecimal_to_binary (value->strval, buf)) == -1)
{
fprintf(stderr, "Invalid hexadecimal string at line %d\n", line);
return 0;
}
ltmp = (unsigned int) rv;
len = ltmp;
}
if (len < 0 || len > SPRINT_MAX_LEN - 1)
{
fprintf(stderr, "String too long at line %d, max allowed %d\n", line,
SPRINT_MAX_LEN);
return 0;
break;
}
tp = get_tree (var_name, name_len, get_tree_head ());
if (tp && tp->ranges
&& !netsnmp_ds_get_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_DONT_CHECK_RANGE))
{
rp = tp->ranges;
while (rp)
{
if (rp->low <= len && len <= rp->high)
break;
rp = rp->next;
}
if (!rp)
{
fprintf(stderr, "Value too long at line %d\n", line);
return 0;
break;
}
}
/* If length is more than 127, won't fit into a 1-byte quantity */
if (len+name_len+8 < 0x7f ) {
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_OCTET_STR,
len, (unsigned char *) buf,
&out_size);
} else {
data_ptr = snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_OCTET_STR,
len, (unsigned char *) buf,
&out_size);
}
#ifdef DEBUG
fprintf (stderr, "encoded len %ld var_len %d leftover %ud difference %d\n", len, name_len, out_size, (data_ptr - out_buffer) );
#endif
return data_ptr - out_buffer;
break;
;;
case 'a':
if (!inet_aton (value->strval, (struct in_addr *) <mp))
{
fprintf(stderr, "Invalid IP address %s at line %d\n", value->strval, line);
return 0;
}
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_IPADDRESS,
sizeof (struct in_addr),
(unsigned char *) <mp, &out_size);
return data_ptr - out_buffer;
break;
;;
case 'o':
strncpy ((char *) buf, value->strval, SPRINT_MAX_LEN);
len = strlen ((char *) buf);
if (!read_objid ((char *) buf, oid_value, &oid_value_len))
{
fprintf(stderr, "Can't find oid %s at line %d\n", buf, line);
return 0;
}
data_ptr = _docsis_snmp_build_var_op (out_buffer,
var_name,
&name_len,
ASN_OBJECT_ID,
oid_value_len*sizeof(oid),
(unsigned char *) &oid_value, &out_size);
return data_ptr - out_buffer;
break;
;;
default:
fprintf(stderr, "Variable type %s not supported yet\n", &oid_asntype);
return 0;
;;
}
/* NOTREACHED */
}
int
decode_vbind (unsigned char *data, unsigned int vb_len)
{
unsigned char *var_val;
oid var_name[MAX_OID_LEN]; /* To test the objid */
size_t name_len = MAX_OID_LEN; /* To test the objid */
int badtype=0;
size_t len;
struct variable_list *vp;
oid objid[MAX_OID_LEN];
char _docsis_snmp_label[50]; /* To hold the 'name' of the type, i.e. Integer etc */
char *enum_string = NULL;
static char outbuf[16384];
struct tree *subtree;
struct enum_list *enums;
memset (outbuf, 0, 16384);
vp = (struct variable_list *) malloc (sizeof (struct variable_list));
if (vp == NULL)
{
fprintf (stderr, "Out of memory\n");
return 0;
}
memset (vp, 0, sizeof (struct variable_list));
vp->next_variable = NULL;
vp->val.string = NULL;
vp->name_length = MAX_OID_LEN;
vp->name = 0;
data = snmp_parse_var_op (data, objid, &vp->name_length, &vp->type, &vp->val_len,
&var_val, (size_t *) & vb_len);
if (data == NULL)
return -1;
if (snmp_set_var_objid (vp, objid, vp->name_length))
return -1;
len = PACKET_LENGTH;
if (netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_EXTENDED_INDEX))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_EXTENDED_INDEX);
} /* Disable extended index format ... makes it harder to parse tokens in lex */
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_PRINT_NUMERIC_ENUM))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRINT_NUMERIC_ENUM);
} /* Enable printing numeric enums */
if (netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_ESCAPE_QUOTES))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_ESCAPE_QUOTES);
} /* Disable escape quotes in string index output */
netsnmp_ds_set_int (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_SUFFIX);
if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_OID_OUTPUT_NUMERIC)) {
netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_NUMERIC);
}
snprint_objid (outbuf, 1023, vp->name, vp->name_length);
if (!get_node (outbuf, var_name, &name_len))
{
if (!read_objid (outbuf, var_name, &name_len))
{
fprintf (stderr,
"/* Hmm ... can't find oid %s at line %d ... perhaps the MIBs are not installed ? */\n",
outbuf, line);
/* temporarily set full output format */
netsnmp_ds_set_int (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_FULL);
memset (outbuf, 0, 1024);
snprint_objid (outbuf, 1023, vp->name, vp->name_length);
/* Go back to suffix-mode for better readability */
netsnmp_ds_set_int (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_SUFFIX);
}
}
printf("%s", outbuf);
/* save the subtree - we need it later to show enums */
subtree = get_tree (var_name, name_len, get_tree_head() );
/* This first switch is just for saving the type in the format we actually want
to print. */
switch ((short) vp->type)
{
case ASN_INTEGER:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Integer");
break;
case ASN_COUNTER:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Counter32");
break;
case ASN_GAUGE:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Gauge32");
break;
case ASN_TIMETICKS:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "TimeTicks");
break;
case ASN_UINTEGER:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Unsigned32");
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_COUNTER64:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "OpaqueCounter64");
break;
case ASN_OPAQUE_U64:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "OpaqueU64");
break;
#endif /* OPAQUE_SPECIAL_TYPES */
case ASN_COUNTER64:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Counter64");
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_FLOAT:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "OpaqueFloat");
break;
case ASN_OPAQUE_DOUBLE:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "OpaqueDouble");
break;
case ASN_OPAQUE_I64:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "OpaqueI64");
break;
#endif /* OPAQUE_SPECIAL_TYPES */
case ASN_OCTET_STR:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "String");
break;
case ASN_IPADDRESS:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "IPAddress");
break;
case ASN_OPAQUE:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "Opaque");
break;
case ASN_NSAP:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "NSAP");
break;
case ASN_OBJECT_ID:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "ObjectID");
break;
case ASN_BIT_STR:
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "BitString");
break;
}
switch ((short) vp->type)
{
case ASN_INTEGER:
vp->val.integer = (long *) vp->buf;
vp->val_len = sizeof (long);
asn_parse_int (var_val, &len, &vp->type,
(long *) vp->val.integer, sizeof (vp->val.integer));
break;
case ASN_COUNTER:
case ASN_GAUGE:
case ASN_TIMETICKS:
case ASN_UINTEGER:
vp->val.integer = (long *) vp->buf;
vp->val_len = sizeof (u_long);
asn_parse_unsigned_int (var_val, &len, &vp->type,
(u_long *) vp->val.integer,
sizeof (vp->val.integer));
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_COUNTER64:
case ASN_OPAQUE_U64:
#endif /* OPAQUE_SPECIAL_TYPES */
case ASN_COUNTER64:
vp->val.counter64 = (struct counter64 *) vp->buf;
vp->val_len = sizeof (struct counter64);
asn_parse_unsigned_int64 (var_val, &len, &vp->type,
(struct counter64 *) vp->val.counter64,
sizeof (*vp->val.counter64));
break;
#ifdef OPAQUE_SPECIAL_TYPES
case ASN_OPAQUE_FLOAT:
vp->val.floatVal = (float *) vp->buf;
vp->val_len = sizeof (float);
asn_parse_float (var_val, &len, &vp->type,
vp->val.floatVal, vp->val_len);
break;
case ASN_OPAQUE_DOUBLE:
vp->val.doubleVal = (double *) vp->buf;
vp->val_len = sizeof (double);
asn_parse_double (var_val, &len, &vp->type,
vp->val.doubleVal, vp->val_len);
break;
case ASN_OPAQUE_I64:
vp->val.counter64 = (struct counter64 *) vp->buf;
vp->val_len = sizeof (struct counter64);
asn_parse_signed_int64 (var_val, &len, &vp->type,
(struct counter64 *) vp->val.counter64,
sizeof (*vp->val.counter64));
break;
#endif /* OPAQUE_SPECIAL_TYPES */
case ASN_OCTET_STR:
case ASN_IPADDRESS:
case ASN_OPAQUE:
case ASN_NSAP:
if (vp->val_len < sizeof (vp->buf))
{
vp->val.string = (u_char *) vp->buf;
}
else
{
vp->val.string = (u_char *) malloc ((unsigned) vp->val_len+1);
memset(vp->val.string, 0, vp->val_len+1);
}
asn_parse_string (var_val, &len, &vp->type, vp->val.string,
&vp->val_len);
break;
case ASN_OBJECT_ID:
vp->val_len = MAX_OID_LEN;
asn_parse_objid (var_val, &len, &vp->type, objid, &vp->val_len);
vp->val_len *= sizeof (oid);
vp->val.objid = (oid *) malloc ((unsigned) vp->val_len);
memmove (vp->val.objid, objid, vp->val_len);
break;
case SNMP_NOSUCHOBJECT:
case SNMP_NOSUCHINSTANCE:
case SNMP_ENDOFMIBVIEW:
case ASN_NULL:
break;
case ASN_BIT_STR:
vp->val.bitstring = (u_char *) malloc (vp->val_len);
asn_parse_bitstring (var_val, &len, &vp->type,
vp->val.bitstring, &vp->val_len);
break;
default:
fprintf(stderr, "Error: bad type returned (%x)\n", vp->type);
badtype = 1;
break;
}
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_PRINT_FULL_OID))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRINT_FULL_OID);
}
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_PRINT_NUMERIC_OIDS))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_PRINT_NUMERIC_OIDS);
}
if (!netsnmp_ds_get_boolean
(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_QUICK_PRINT))
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_QUICK_PRINT);
}
if (!strcmp (_docsis_snmp_label, "String")) /* Strings need special treatment - see below */
{
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_QUICK_PRINT);
netsnmp_ds_toggle_boolean (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_ESCAPE_QUOTES);
}
switch ((short) vp->type)
{
case ASN_OCTET_STR:
if (str_isprint((char *) vp->val.string, vp->val_len))
{
snprintf(outbuf, vp->val_len+5, "\"%s\"", vp->val.string);
} else {
snprint_hexadecimal (outbuf, 16383, (char *) vp->val.string, vp->val_len);
memset (_docsis_snmp_label, 0, 50);
sprintf (_docsis_snmp_label, "HexString");
}
break;
case ASN_BIT_STR:
snprint_hexadecimal (outbuf, 1023, (char *) vp->val.bitstring, vp->val_len);
break;
case ASN_OBJECT_ID:
netsnmp_ds_set_int (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_NUMERIC);
snprint_value (outbuf, 1023, vp->name, vp->name_length, vp);
netsnmp_ds_set_int (NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_OID_OUTPUT_FORMAT,
NETSNMP_OID_OUTPUT_SUFFIX);
break;
default:
snprint_value (outbuf, 1023, vp->name, vp->name_length, vp);
}
if ( subtree )
{
enums = subtree->enums;
for (; enums; enums = enums->next) {
if (enums->value == *vp->val.integer) {
enum_string = enums->label;
break;
}
}
}
if (enum_string)
printf(" %s %s; /* %s */", _docsis_snmp_label, outbuf, enum_string);
else
printf(" %s %s;", _docsis_snmp_label, outbuf);
snmp_free_var (vp);
return badtype;
}
/** @internal */
void
netsnmp_config_parse_table_set(const char *token, char *line)
{
oid name[MAX_OID_LEN], table_name[MAX_OID_LEN];
size_t name_length = MAX_OID_LEN, table_name_length =
MAX_OID_LEN;
struct tree *tp, *indexnode;
netsnmp_table_data_set *table_set;
data_set_tables *tables;
struct index_list *index;
unsigned int mincol = 0xffffff, maxcol = 0;
u_char type;
char *pos;
/*
* instatiate a fake table based on MIB information
*/
DEBUGMSGTL(("9:table_set_add_table", "processing '%s'\n", line));
if (NULL != (pos = strchr(line,' '))) {
config_pwarn("ignoring extra tokens on line");
snmp_log(LOG_WARNING," ignoring '%s'\n", pos);
*pos = '\0';
}
/*
* check for duplicate table
*/
tables = (data_set_tables *) netsnmp_get_list_data(auto_tables, line);
if (NULL != tables) {
config_pwarn("duplicate table definition");
return;
}
/*
* parse oid and find tree structure
*/
if (!snmp_parse_oid(line, table_name, &table_name_length)) {
config_pwarn
("can't instatiate table since I can't parse the table name");
return;
}
if(NULL == (tp = get_tree(table_name, table_name_length,
get_tree_head()))) {
config_pwarn("can't instatiate table since "
"I can't find mib information about it");
return;
}
if (NULL == (tp = tp->child_list) || NULL == tp->child_list) {
config_pwarn("can't instatiate table since it doesn't appear to be "
"a proper table (no children)");
return;
}
/*
* check for augments indexes
*/
if (NULL != tp->augments) {
if (!snmp_parse_oid(tp->augments, table_name, &table_name_length)) {
config_pwarn("I can't parse the augment tabel name");
snmp_log(LOG_WARNING, " can't parse %s\n", tp->augments);
return;
}
if(NULL == (tp = get_tree(table_name, table_name_length,
get_tree_head()))) {
config_pwarn("can't instatiate table since "
"I can't find mib information about augment table");
snmp_log(LOG_WARNING, " table %s not found in tree\n",
tp->augments);
return;
}
table_set = netsnmp_create_table_data_set(line);
/*
* loop through indexes and add types
*/
for (index = tp->indexes; index; index = index->next) {
if (!snmp_parse_oid(index->ilabel, name, &name_length) ||
(NULL ==
(indexnode = get_tree(name, name_length, get_tree_head())))) {
config_pwarn("can't instatiate table since "
"I don't know anything about one index");
snmp_log(LOG_WARNING, " index %s not found in tree\n",
index->ilabel);
return; /* xxx mem leak */
}
type = mib_to_asn_type(indexnode->type);
if (type == (u_char) - 1) {
config_pwarn("unknown index type");
return; /* xxx mem leak */
}
if (index->isimplied) /* if implied, mark it as such */
type |= ASN_PRIVATE;
DEBUGMSGTL(("table_set_add_row",
"adding default index of type %d\n", type));
netsnmp_table_dataset_add_index(table_set, type);
}
}
else
table_set = netsnmp_create_table_data_set(line);
/*
* loop through indexes and add types
*/
for (index = tp->indexes; index; index = index->next) {
if (!snmp_parse_oid(index->ilabel, name, &name_length) ||
(NULL ==
(indexnode = get_tree(name, name_length, get_tree_head())))) {
config_pwarn("can't instatiate table since "
"I don't know anything about one index");
snmp_log(LOG_WARNING, " index %s not found in tree\n",
index->ilabel);
return; /* xxx mem leak */
}
type = mib_to_asn_type(indexnode->type);
if (type == (u_char) - 1) {
config_pwarn("unknown index type");
return; /* xxx mem leak */
}
if (index->isimplied) /* if implied, mark it as such */
type |= ASN_PRIVATE;
DEBUGMSGTL(("table_set_add_row",
"adding default index of type %d\n", type));
netsnmp_table_dataset_add_index(table_set, type);
}
/*
* loop through children and add each column info
*/
for (tp = tp->child_list; tp; tp = tp->next_peer) {
int canwrite = 0;
type = mib_to_asn_type(tp->type);
if (type == (u_char) - 1) {
config_pwarn("unknown column type");
return; /* xxx mem leak */
}
DEBUGMSGTL(("table_set_add_row",
"adding column %s(%d) of type %d (access %d)\n",
tp->label, tp->subid, type, tp->access));
switch (tp->access) {
case MIB_ACCESS_CREATE:
table_set->allow_creation = 1;
case MIB_ACCESS_READWRITE:
case MIB_ACCESS_WRITEONLY:
canwrite = 1;
case MIB_ACCESS_READONLY:
DEBUGMSGTL(("table_set_add_row",
"adding column %d of type %d\n", tp->subid, type));
netsnmp_table_set_add_default_row(table_set, tp->subid, type,
canwrite, NULL, 0);
mincol = SNMP_MIN(mincol, tp->subid);
maxcol = SNMP_MAX(maxcol, tp->subid);
break;
case MIB_ACCESS_NOACCESS:
case MIB_ACCESS_NOTIFY:
break;
default:
config_pwarn("unknown column access type");
break;
}
}
/*
* register the table
*/
netsnmp_register_table_data_set(netsnmp_create_handler_registration
(line, NULL, table_name,
table_name_length,
HANDLER_CAN_RWRITE), table_set, NULL);
netsnmp_register_auto_data_table(table_set, NULL);
}
void
parse_notificationEvent( const char *token, char *line )
{
char ename[MTE_STR1_LEN+1];
char buf[SPRINT_MAX_LEN];
oid name_buf[MAX_OID_LEN];
size_t name_buf_len;
struct mteEvent *entry;
struct mteObject *object;
int wild = 1;
int idx = 0;
char *cp;
#ifndef NETSNMP_DISABLE_MIB_LOADING
struct tree *tp;
#endif
struct varbind_list *var;
DEBUGMSGTL(("disman:event:conf", "Parsing notificationEvent config\n"));
/*
* The event name could be used directly to index the mteObjectsTable.
* But it's quite possible that the same name could also be used to
* set up a mteTriggerTable entry (with trigger-specific objects).
*
* To avoid such a clash, we'll add a prefix ("_E").
*/
memset(ename, 0, sizeof(ename));
ename[0] = '_';
ename[1] = 'E';
cp = copy_nword(line, ename+2, MTE_STR1_LEN-2);
if (!cp || ename[2] == '\0') {
config_perror("syntax error: no event name");
return;
}
/*
* Parse the notification OID field ...
*/
cp = copy_nword(cp, buf, SPRINT_MAX_LEN);
if ( buf[0] == '\0' ) {
config_perror("syntax error: no notification OID");
return;
}
name_buf_len = MAX_OID_LEN;
if (!snmp_parse_oid(buf, name_buf, &name_buf_len)) {
snmp_log(LOG_ERR, "notificationEvent OID: %s\n", buf);
config_perror("unknown notification OID");
return;
}
/*
* ... and the relevant object/instances.
*/
if ( cp && *cp=='-' && *(cp+1)=='m' ) {
#ifdef NETSNMP_DISABLE_MIB_LOADING
config_perror("Can't use -m if MIB loading is disabled");
return;
#else
/*
* Use the MIB definition to add the standard
* notification payload to the mteObjectsTable.
*/
cp = skip_token( cp );
tp = get_tree( name_buf, name_buf_len, get_tree_head());
if (!tp) {
config_perror("Can't locate notification payload info");
return;
}
for (var = tp->varbinds; var; var=var->next) {
idx++;
object = mteObjects_addOID( "snmpd.conf", ename, idx,
var->vblabel, wild );
idx = object->mteOIndex;
}
#endif
}
while (cp) {
if ( *cp == '-' ) {
switch (*(cp+1)) {
case 'm':
config_perror("-m option must come first");
return;
case 'i': /* exact instance */
case 'w': /* "not-wild" (backward compatability) */
wild = 0;
break;
case 'o': /* wildcarded object */
wild = 1;
break;
default:
config_perror("unrecognised option");
return;
}
cp = skip_token( cp );
if (!cp) {
config_perror("missing parameter");
return;
}
}
idx++;
cp = copy_nword(cp, buf, SPRINT_MAX_LEN);
object = mteObjects_addOID( "snmpd.conf", ename, idx, buf, wild );
idx = object->mteOIndex;
wild = 1; /* default to wildcarded objects */
}
/*
* If the entry has parsed successfully, then create,
* populate and activate the new event entry.
*/
entry = _find_typed_mteEvent_entry("snmpd.conf", ename+2,
MTE_EVENT_NOTIFICATION);
if (!entry) {
mteObjects_removeEntries( "snmpd.conf", ename );
return;
}
entry->mteNotification_len = name_buf_len;
memcpy( entry->mteNotification, name_buf, name_buf_len*sizeof(oid));
memcpy( entry->mteNotifyOwner, "snmpd.conf", 10 );
memcpy( entry->mteNotifyObjects, ename, MTE_STR1_LEN );
entry->mteEventActions |= MTE_EVENT_NOTIFICATION;
entry->flags |= MTE_EVENT_FLAG_ENABLED |
MTE_EVENT_FLAG_ACTIVE |
MTE_EVENT_FLAG_FIXED |
MTE_EVENT_FLAG_VALID;
return;
}
int
main(int argc, char *argv[])
{
int arg;
char *current_name = NULL, *cp = NULL;
oid name[MAX_OID_LEN];
size_t name_length;
int description = 0;
int print = 0;
int find_all = 0;
int width = 1000000;
/*
* usage: snmptranslate name
*/
while ((arg = getopt(argc, argv, "Vhm:M:w:D:P:T:O:I:L:")) != EOF) {
switch (arg) {
case 'h':
usage();
exit(1);
case 'm':
setenv("MIBS", optarg, 1);
break;
case 'M':
setenv("MIBDIRS", optarg, 1);
break;
case 'D':
debug_register_tokens(optarg);
snmp_set_do_debugging(1);
break;
case 'V':
fprintf(stderr, "NET-SNMP version: %s\n",
netsnmp_get_version());
exit(0);
break;
case 'w':
width = atoi(optarg);
if (width <= 0) {
fprintf(stderr, "Invalid width specification: %s\n", optarg);
exit (1);
}
break;
#ifndef NETSNMP_DISABLE_MIB_LOADING
case 'P':
cp = snmp_mib_toggle_options(optarg);
if (cp != NULL) {
fprintf(stderr, "Unknown parser option to -P: %c.\n", *cp);
usage();
exit(1);
}
break;
#endif /* NETSNMP_DISABLE_MIB_LOADING */
case 'O':
cp = snmp_out_toggle_options(optarg);
if (cp != NULL) {
fprintf(stderr, "Unknown OID option to -O: %c.\n", *cp);
usage();
exit(1);
}
break;
case 'I':
cp = snmp_in_toggle_options(optarg);
if (cp != NULL) {
fprintf(stderr, "Unknown OID option to -I: %c.\n", *cp);
usage();
exit(1);
}
break;
case 'T':
for (cp = optarg; *cp; cp++) {
switch (*cp) {
#ifndef NETSNMP_DISABLE_MIB_LOADING
case 'l':
print = 3;
print_oid_report_enable_labeledoid();
break;
case 'o':
print = 3;
print_oid_report_enable_oid();
break;
case 's':
print = 3;
print_oid_report_enable_symbolic();
break;
case 't':
print = 3;
print_oid_report_enable_suffix();
break;
case 'z':
print = 3;
print_oid_report_enable_mibchildoid();
break;
#endif /* NETSNMP_DISABLE_MIB_LOADING */
case 'd':
description = 1;
snmp_set_save_descriptions(1);
break;
case 'B':
find_all = 1;
break;
case 'p':
print = 1;
break;
case 'a':
print = 2;
break;
default:
fprintf(stderr, "Invalid -T<lostpad> character: %c\n",
*cp);
usage();
exit(1);
break;
}
}
break;
case 'L':
if (snmp_log_options(optarg, argc, argv) < 0) {
return (-1);
}
break;
default:
fprintf(stderr, "invalid option: -%c\n", arg);
usage();
exit(1);
break;
}
}
init_snmp("snmpapp");
if (optind < argc)
current_name = argv[optind];
if (current_name == NULL) {
switch (print) {
default:
usage();
exit(1);
#ifndef NETSNMP_DISABLE_MIB_LOADING
case 1:
print_mib_tree(stdout, get_tree_head(), width);
break;
case 2:
print_ascii_dump(stdout);
break;
case 3:
print_oid_report(stdout);
break;
#endif /* NETSNMP_DISABLE_MIB_LOADING */
}
exit(0);
}
do {
name_length = MAX_OID_LEN;
if (snmp_get_random_access()) {
#ifndef NETSNMP_DISABLE_MIB_LOADING
if (!get_node(current_name, name, &name_length)) {
#endif /* NETSNMP_DISABLE_MIB_LOADING */
fprintf(stderr, "Unknown object identifier: %s\n",
current_name);
exit(2);
#ifndef NETSNMP_DISABLE_MIB_LOADING
}
#endif /* NETSNMP_DISABLE_MIB_LOADING */
} else if (find_all) {
if (0 == show_all_matched_objects(stdout, current_name,
name, &name_length,
description, width)) {
fprintf(stderr,
"Unable to find a matching object identifier for \"%s\"\n",
current_name);
exit(1);
}
exit(0);
} else if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_REGEX_ACCESS)) {
#ifndef NETSNMP_DISABLE_MIB_LOADING
if (0 == get_wild_node(current_name, name, &name_length)) {
#endif /* NETSNMP_DISABLE_MIB_LOADING */
fprintf(stderr,
"Unable to find a matching object identifier for \"%s\"\n",
current_name);
exit(1);
#ifndef NETSNMP_DISABLE_MIB_LOADING
}
#endif /* NETSNMP_DISABLE_MIB_LOADING */
} else {
if (!read_objid(current_name, name, &name_length)) {
snmp_perror(current_name);
exit(2);
}
}
if (print == 1) {
#ifndef NETSNMP_DISABLE_MIB_LOADING
struct tree *tp;
tp = get_tree(name, name_length, get_tree_head());
if (tp == NULL) {
#endif /* NETSNMP_DISABLE_MIB_LOADING */
snmp_log(LOG_ERR,
"Unable to find a matching object identifier for \"%s\"\n",
current_name);
exit(1);
#ifndef NETSNMP_DISABLE_MIB_LOADING
}
print_mib_tree(stdout, tp, width);
#endif /* NETSNMP_DISABLE_MIB_LOADING */
} else {
print_objid(name, name_length);
if (description) {
#ifndef NETSNMP_DISABLE_MIB_LOADING
print_description(name, name_length, width);
#endif /* NETSNMP_DISABLE_MIB_LOADING */
}
}
current_name = argv[++optind];
if (current_name != NULL)
printf("\n");
} while (optind < argc);
return (0);
}
static void
_table_set_add_indexes(netsnmp_table_data_set *table_set, struct tree *tp)
{
oid name[MAX_OID_LEN];
size_t name_length = MAX_OID_LEN;
struct index_list *index;
struct tree *indexnode;
u_char type;
int fixed_len = 0;
/*
* loop through indexes and add types
*/
for (index = tp->indexes; index; index = index->next) {
if (!snmp_parse_oid(index->ilabel, name, &name_length) ||
(NULL ==
(indexnode = get_tree(name, name_length, get_tree_head())))) {
config_pwarn("can't instatiate table since "
"I don't know anything about one index");
snmp_log(LOG_WARNING, " index %s not found in tree\n",
index->ilabel);
return; /* xxx mem leak */
}
type = mib_to_asn_type(indexnode->type);
if (type == (u_char) - 1) {
config_pwarn("unknown index type");
return; /* xxx mem leak */
}
/*
* if implied, mark it as such. also mark fixed length
* octet strings as implied (ie no length prefix) as well.
* */
if ((TYPE_OCTETSTR == indexnode->type) && /* octet str */
(NULL != indexnode->ranges) && /* & has range */
(NULL == indexnode->ranges->next) && /* but only one */
(indexnode->ranges->high == /* & high==low */
indexnode->ranges->low)) {
type |= ASN_PRIVATE;
fixed_len = indexnode->ranges->high;
}
else if (index->isimplied)
type |= ASN_PRIVATE;
DEBUGMSGTL(("table_set_add_table",
"adding default index of type %d\n", type));
netsnmp_table_dataset_add_index(table_set, type);
/*
* hack alert: for fixed lenght strings, save the
* lenght for use during oid parsing.
*/
if (fixed_len) {
/*
* find last (just added) index
*/
netsnmp_variable_list *var = table_set->table->indexes_template;
while (NULL != var->next_variable)
var = var->next_variable;
var->val_len = fixed_len;
}
}
}
void
get_field_names(void)
{
char *buf = NULL, *name_p = NULL;
size_t buf_len = 0, out_len = 0;
#ifndef NETSNMP_DISABLE_MIB_LOADING
struct tree *tbl = NULL;
#endif /* NETSNMP_DISABLE_MIB_LOADING */
int going = 1;
#ifndef NETSNMP_DISABLE_MIB_LOADING
tbl = get_tree(root, rootlen, get_tree_head());
if (tbl) {
tbl = tbl->child_list;
if (tbl) {
root[rootlen++] = tbl->subid;
tbl = tbl->child_list;
} else {
root[rootlen++] = 1;
going = 0;
}
}
#endif /* NETSNMP_DISABLE_MIB_LOADING */
if (sprint_realloc_objid
((u_char **)&buf, &buf_len, &out_len, 1, root, rootlen - 1)) {
table_name = buf;
buf = NULL;
buf_len = out_len = 0;
} else {
table_name = strdup("[TRUNCATED]");
out_len = 0;
}
fields = 0;
while (going) {
fields++;
#ifndef NETSNMP_DISABLE_MIB_LOADING
if (tbl) {
if (tbl->access == MIB_ACCESS_NOACCESS) {
fields--;
tbl = tbl->next_peer;
if (!tbl) {
going = 0;
}
continue;
}
root[rootlen] = tbl->subid;
tbl = tbl->next_peer;
if (!tbl)
going = 0;
} else {
#endif /* NETSNMP_DISABLE_MIB_LOADING */
root[rootlen] = fields;
#ifndef NETSNMP_DISABLE_MIB_LOADING
}
#endif /* NETSNMP_DISABLE_MIB_LOADING */
out_len = 0;
if (sprint_realloc_objid
((u_char **)&buf, &buf_len, &out_len, 1, root, rootlen + 1)) {
name_p = strrchr(buf, '.');
if (name_p == NULL) {
name_p = strrchr(buf, ':');
}
if (name_p == NULL) {
name_p = buf;
} else {
name_p++;
}
} else {
break;
}
if (localdebug) {
printf("%s %c\n", buf, name_p[0]);
}
if ('0' <= name_p[0] && name_p[0] <= '9') {
fields--;
break;
}
if (fields == 1) {
column = (struct column *) malloc(sizeof(*column));
} else {
column =
(struct column *) realloc(column,
fields * sizeof(*column));
}
column[fields - 1].label = strdup(name_p);
column[fields - 1].width = strlen(name_p);
column[fields - 1].subid = root[rootlen];
}
if (fields == 0) {
fprintf(stderr, "Was that a table? %s\n", table_name);
exit(1);
}
if (name_p) {
*name_p = 0;
memmove(name, root, rootlen * sizeof(oid));
name_length = rootlen + 1;
name_p = strrchr(buf, '.');
if (name_p == NULL) {
name_p = strrchr(buf, ':');
}
if (name_p != NULL) {
*name_p = 0;
}
}
if (brief && fields > 1) {
char *f1, *f2;
int common = strlen(column[0].label);
int field, len;
for (field = 1; field < fields; field++) {
f1 = column[field - 1].label;
f2 = column[field].label;
while (*f1 && *f1++ == *f2++);
len = f2 - column[field].label - 1;
if (len < common)
common = len;
}
if (common) {
for (field = 0; field < fields; field++) {
column[field].label += common;
column[field].width -= common;
}
}
}
if (buf != NULL) {
free(buf);
}
}
