| 1 |
/* |
| 2 |
* DisMan Expression MIB: |
| 3 |
* Core implementation of expression evaluation |
| 4 |
*/ |
| 5 |
|
| 6 |
#ifdef HAVE_INTTYPES_H |
| 7 |
#include <inttypes.h> |
| 8 |
#endif |
| 9 |
|
| 10 |
#include <net-snmp/net-snmp-config.h> |
| 11 |
#include <net-snmp/net-snmp-includes.h> |
| 12 |
#include <net-snmp/agent/net-snmp-agent-includes.h> |
| 13 |
#include "disman/expr/expExpression.h" |
| 14 |
#include "disman/expr/expObject.h" |
| 15 |
#include "disman/expr/expValue.h" |
| 16 |
|
| 17 |
#include <ctype.h> |
| 18 |
|
| 19 |
void _expValue_setError( struct expExpression *exp, int reason, |
| 20 |
oid *suffix, size_t suffix_len, |
| 21 |
netsnmp_variable_list *var); |
| 22 |
|
| 23 |
|
| 24 |
#define ASN_PRIV_OPERATOR (ASN_PRIVATE | 0x0f) |
| 25 |
#define ASN_PRIV_FUNCTION (ASN_PRIVATE | 0x0e) |
| 26 |
|
| 27 |
int ops[128]; /* mapping from operator characters to numeric |
| 28 |
tokens (ordered by priority). */ |
| 29 |
|
| 30 |
void |
| 31 |
init_expValue(void) |
| 32 |
{ |
| 33 |
DEBUGMSGTL(("disman:expr:eval", "Init expValue")); |
| 34 |
/* Single-character operators */ |
| 35 |
ops['+'] = EXP_OPERATOR_ADD; |
| 36 |
ops['-'] = EXP_OPERATOR_SUBTRACT; |
| 37 |
ops['*'] = EXP_OPERATOR_MULTIPLY; |
| 38 |
ops['/'] = EXP_OPERATOR_DIVIDE; |
| 39 |
ops['%'] = EXP_OPERATOR_REMAINDER; |
| 40 |
ops['^'] = EXP_OPERATOR_BITXOR; |
| 41 |
ops['~'] = EXP_OPERATOR_BITNEGATE; |
| 42 |
ops['|'] = EXP_OPERATOR_BITOR; |
| 43 |
ops['&'] = EXP_OPERATOR_BITAND; |
| 44 |
ops['!'] = EXP_OPERATOR_NOT; |
| 45 |
ops['<'] = EXP_OPERATOR_LESS; |
| 46 |
ops['>'] = EXP_OPERATOR_GREAT; |
| 47 |
|
| 48 |
/* |
| 49 |
* Arbitrary offsets, chosen so |
| 50 |
* the three blocks don't overlap. |
| 51 |
*/ |
| 52 |
/* "X=" operators */ |
| 53 |
ops['='+20] = EXP_OPERATOR_EQUAL; |
| 54 |
ops['!'+20] = EXP_OPERATOR_NOTEQ; |
| 55 |
ops['<'+20] = EXP_OPERATOR_LESSEQ; |
| 56 |
ops['>'+20] = EXP_OPERATOR_GREATEQ; |
| 57 |
|
| 58 |
/* "XX" operators */ |
| 59 |
ops['|'-30] = EXP_OPERATOR_OR; |
| 60 |
ops['&'-30] = EXP_OPERATOR_AND; |
| 61 |
ops['<'-30] = EXP_OPERATOR_LSHIFT; |
| 62 |
ops['>'-30] = EXP_OPERATOR_RSHIFT; |
| 63 |
} |
| 64 |
|
| 65 |
/* |
| 66 |
* Insert the value of the specified object parameter, |
| 67 |
* using the instance 'suffix' for wildcarded objects. |
| 68 |
*/ |
| 69 |
netsnmp_variable_list * |
| 70 |
_expValue_evalParam( netsnmp_variable_list *expIdx, int param, |
| 71 |
oid *suffix, size_t suffix_len ) |
| 72 |
{ |
| 73 |
netsnmp_variable_list *var = NULL; |
| 74 |
struct expObject *obj; |
| 75 |
netsnmp_variable_list *val_var = NULL, *oval_var = NULL; /* values */ |
| 76 |
netsnmp_variable_list *dd_var = NULL, *odd_var = NULL; /* deltaDs */ |
| 77 |
netsnmp_variable_list *cond_var = NULL; /* conditionals */ |
| 78 |
int n; |
| 79 |
|
| 80 |
/* |
| 81 |
* Retrieve the expObject entry for the requested parameter. |
| 82 |
*/ |
| 83 |
if (!expIdx || !expIdx->next_variable || |
| 84 |
!expIdx->next_variable->next_variable ) { |
| 85 |
return NULL; |
| 86 |
} |
| 87 |
var = SNMP_MALLOC_TYPEDEF( netsnmp_variable_list ); |
| 88 |
if (!var) { |
| 89 |
return NULL; |
| 90 |
} |
| 91 |
|
| 92 |
*expIdx->next_variable->next_variable->val.integer = param; |
| 93 |
obj = (struct expObject *) |
| 94 |
netsnmp_tdata_row_entry( |
| 95 |
netsnmp_tdata_row_get_byidx( expObject_table_data, expIdx )); |
| 96 |
if (!obj) { |
| 97 |
/* |
| 98 |
* No such parameter configured for this expression |
| 99 |
*/ |
| 100 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_INDEX ); |
| 101 |
var->type = ASN_NULL; |
| 102 |
return var; |
| 103 |
} |
| 104 |
if ( obj->expObjectSampleType != EXPSAMPLETYPE_ABSOLUTE && |
| 105 |
obj->old_vars == NULL ) { |
| 106 |
/* |
| 107 |
* Can't calculate delta values until the second pass |
| 108 |
*/ |
| 109 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_RESOURCE ); |
| 110 |
var->type = ASN_NULL; |
| 111 |
return var; |
| 112 |
} |
| 113 |
|
| 114 |
|
| 115 |
/* |
| 116 |
* For a wildcarded object, search for the matching suffix. |
| 117 |
*/ |
| 118 |
val_var = obj->vars; |
| 119 |
if ( obj->flags & EXP_OBJ_FLAG_OWILD ) { |
| 120 |
if ( !suffix ) { |
| 121 |
/* |
| 122 |
* If there's no suffix to match against, throw an error. |
| 123 |
* An exact expression with a wildcarded object is invalid. |
| 124 |
* XXX - Or just use first entry? |
| 125 |
*/ |
| 126 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_INDEX ); |
| 127 |
var->type = ASN_NULL; |
| 128 |
return var; |
| 129 |
} |
| 130 |
/* |
| 131 |
* Otherwise, we'll walk *all* wildcarded values in parallel. |
| 132 |
* This relies on the various varbind lists being set up with |
| 133 |
* exactly the same entries. A little extra preparation |
| 134 |
* during the data gathering simplifies things significantly! |
| 135 |
*/ |
| 136 |
if ( obj->expObjectSampleType != EXPSAMPLETYPE_ABSOLUTE ) |
| 137 |
oval_var = obj->old_vars; |
| 138 |
if ( obj->flags & EXP_OBJ_FLAG_DWILD ) { |
| 139 |
dd_var = obj->dvars; |
| 140 |
odd_var = obj->old_dvars; |
| 141 |
} |
| 142 |
if ( obj->flags & EXP_OBJ_FLAG_CWILD ) |
| 143 |
cond_var = obj->cvars; |
| 144 |
|
| 145 |
n = obj->expObjectID_len; |
| 146 |
while ( val_var ) { |
| 147 |
if ( snmp_oid_compare( val_var->name+n, val_var->name_length-n, |
| 148 |
suffix, suffix_len )) |
| 149 |
break; |
| 150 |
val_var = val_var->next_variable; |
| 151 |
if (oval_var) |
| 152 |
oval_var = oval_var->next_variable; |
| 153 |
if (dd_var) { |
| 154 |
dd_var = dd_var->next_variable; |
| 155 |
odd_var = odd_var->next_variable; |
| 156 |
} |
| 157 |
if (cond_var) |
| 158 |
cond_var = cond_var->next_variable; |
| 159 |
} |
| 160 |
|
| 161 |
} |
| 162 |
if (!val_var) { |
| 163 |
/* |
| 164 |
* No matching entry |
| 165 |
*/ |
| 166 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_INDEX ); |
| 167 |
var->type = ASN_NULL; |
| 168 |
return var; |
| 169 |
} |
| 170 |
/* |
| 171 |
* Set up any non-wildcarded values - some |
| 172 |
* of which may be null. That's fine. |
| 173 |
*/ |
| 174 |
if (!oval_var) |
| 175 |
oval_var = obj->old_vars; |
| 176 |
if (!dd_var) { |
| 177 |
dd_var = obj->dvars; |
| 178 |
odd_var = obj->old_dvars; |
| 179 |
} |
| 180 |
if (!cond_var) |
| 181 |
cond_var = obj->cvars; |
| 182 |
|
| 183 |
|
| 184 |
/* |
| 185 |
* ... and return the appropriate value. |
| 186 |
*/ |
| 187 |
if (obj->expObjCond_len && |
| 188 |
(!cond_var || *cond_var->val.integer == 0)) { |
| 189 |
/* |
| 190 |
* expObjectConditional says no |
| 191 |
*/ |
| 192 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_INDEX ); |
| 193 |
var->type = ASN_NULL; |
| 194 |
return var; |
| 195 |
} |
| 196 |
if (dd_var && odd_var && |
| 197 |
*dd_var->val.integer != *odd_var->val.integer) { |
| 198 |
/* |
| 199 |
* expObjectDeltaD says no |
| 200 |
*/ |
| 201 |
snmp_set_var_typed_integer( var, ASN_INTEGER, EXPERRCODE_INDEX ); |
| 202 |
var->type = ASN_NULL; |
| 203 |
return var; |
| 204 |
} |
| 205 |
|
| 206 |
/* |
| 207 |
* XXX - May need to check sysUpTime discontinuities |
| 208 |
* (unless this is handled earlier....) |
| 209 |
*/ |
| 210 |
switch ( obj->expObjectSampleType ) { |
| 211 |
case EXPSAMPLETYPE_ABSOLUTE: |
| 212 |
snmp_clone_var( val_var, var ); |
| 213 |
break; |
| 214 |
case EXPSAMPLETYPE_DELTA: |
| 215 |
snmp_set_var_typed_integer( var, ASN_INTEGER /* or UNSIGNED? */, |
| 216 |
*val_var->val.integer - *oval_var->val.integer ); |
| 217 |
break; |
| 218 |
case EXPSAMPLETYPE_CHANGED: |
| 219 |
if ( val_var->val_len != oval_var->val_len ) |
| 220 |
n = 1; |
| 221 |
else if (memcmp( val_var->val.string, oval_var->val.string, |
| 222 |
val_var->val_len ) != 0 ) |
| 223 |
n = 1; |
| 224 |
else |
| 225 |
n = 0; |
| 226 |
snmp_set_var_typed_integer( var, ASN_UNSIGNED, n ); |
| 227 |
} |
| 228 |
return var; |
| 229 |
} |
| 230 |
|
| 231 |
|
| 232 |
/* |
| 233 |
* Utility routine to parse (and skip over) an integer constant |
| 234 |
*/ |
| 235 |
int |
| 236 |
_expParse_integer( char *start, char **end ) { |
| 237 |
int n; |
| 238 |
char *cp; |
| 239 |
|
| 240 |
n = atoi(start); |
| 241 |
for (cp=start; *cp; cp++) |
| 242 |
if (!isdigit(*cp & 0xFF)) |
| 243 |
break; |
| 244 |
*end = cp; |
| 245 |
return n; |
| 246 |
} |
| 247 |
|
| 248 |
netsnmp_variable_list * |
| 249 |
_expValue_evalOperator(netsnmp_variable_list *left, |
| 250 |
netsnmp_variable_list *op, |
| 251 |
netsnmp_variable_list *right) { |
| 252 |
int n; |
| 253 |
|
| 254 |
if (left->val.integer == NULL || right->val.integer == NULL) { |
| 255 |
return right; |
| 256 |
} |
| 257 |
switch( *op->val.integer ) { |
| 258 |
case EXP_OPERATOR_ADD: |
| 259 |
n = *left->val.integer + *right->val.integer; break; |
| 260 |
case EXP_OPERATOR_SUBTRACT: |
| 261 |
n = *left->val.integer - *right->val.integer; break; |
| 262 |
case EXP_OPERATOR_MULTIPLY: |
| 263 |
n = *left->val.integer * *right->val.integer; break; |
| 264 |
case EXP_OPERATOR_DIVIDE: |
| 265 |
n = *left->val.integer / *right->val.integer; break; |
| 266 |
case EXP_OPERATOR_REMAINDER: |
| 267 |
n = *left->val.integer % *right->val.integer; break; |
| 268 |
case EXP_OPERATOR_BITXOR: |
| 269 |
n = *left->val.integer ^ *right->val.integer; break; |
| 270 |
case EXP_OPERATOR_BITNEGATE: |
| 271 |
n = 99; /* *left->val.integer ~ *right->val.integer; */ break; |
| 272 |
case EXP_OPERATOR_BITOR: |
| 273 |
n = *left->val.integer | *right->val.integer; break; |
| 274 |
case EXP_OPERATOR_BITAND: |
| 275 |
n = *left->val.integer & *right->val.integer; break; |
| 276 |
case EXP_OPERATOR_NOT: |
| 277 |
n = 99; /* *left->val.integer ! *right->val.integer; */ break; |
| 278 |
case EXP_OPERATOR_LESS: |
| 279 |
n = *left->val.integer < *right->val.integer; break; |
| 280 |
case EXP_OPERATOR_GREAT: |
| 281 |
n = *left->val.integer > *right->val.integer; break; |
| 282 |
case EXP_OPERATOR_EQUAL: |
| 283 |
n = *left->val.integer == *right->val.integer; break; |
| 284 |
case EXP_OPERATOR_NOTEQ: |
| 285 |
n = *left->val.integer != *right->val.integer; break; |
| 286 |
case EXP_OPERATOR_LESSEQ: |
| 287 |
n = *left->val.integer <= *right->val.integer; break; |
| 288 |
case EXP_OPERATOR_GREATEQ: |
| 289 |
n = *left->val.integer >= *right->val.integer; break; |
| 290 |
case EXP_OPERATOR_OR: |
| 291 |
n = *left->val.integer || *right->val.integer; break; |
| 292 |
case EXP_OPERATOR_AND: |
| 293 |
n = *left->val.integer && *right->val.integer; break; |
| 294 |
case EXP_OPERATOR_LSHIFT: |
| 295 |
n = *left->val.integer << *right->val.integer; break; |
| 296 |
case EXP_OPERATOR_RSHIFT: |
| 297 |
n = *left->val.integer >> *right->val.integer; break; |
| 298 |
break; |
| 299 |
default: |
| 300 |
left->next_variable = NULL; |
| 301 |
snmp_free_var(left); |
| 302 |
right->next_variable = NULL; |
| 303 |
snmp_free_var(right); |
| 304 |
|
| 305 |
snmp_set_var_typed_integer( op, ASN_INTEGER, EXPERRCODE_OPERATOR ); |
| 306 |
op->type = ASN_NULL; |
| 307 |
return op; |
| 308 |
} |
| 309 |
|
| 310 |
/* XXX */ |
| 311 |
left->next_variable = NULL; |
| 312 |
snmp_free_var(left); |
| 313 |
op->next_variable = NULL; |
| 314 |
snmp_free_var(op); |
| 315 |
snmp_set_var_typed_integer( right, ASN_INTEGER, n ); |
| 316 |
return right; |
| 317 |
} |
| 318 |
|
| 319 |
netsnmp_variable_list * |
| 320 |
_expValue_evalFunction(netsnmp_variable_list *func) { |
| 321 |
netsnmp_variable_list *params = func->next_variable; |
| 322 |
/* XXX */ |
| 323 |
params->next_variable = NULL; |
| 324 |
snmp_free_var(params); |
| 325 |
snmp_set_var_typed_integer( func, ASN_INTEGER, 99 ); |
| 326 |
return func; |
| 327 |
} |
| 328 |
|
| 329 |
netsnmp_variable_list *_expValue_evalExpr2(netsnmp_variable_list *exprAlDente); |
| 330 |
netsnmp_variable_list * |
| 331 |
_expValue_evalExpr( netsnmp_variable_list *expIdx, |
| 332 |
char *exprRaw, char **exprEnd, |
| 333 |
oid *suffix, size_t suffix_len ) |
| 334 |
{ |
| 335 |
netsnmp_variable_list *exprAlDente = NULL; |
| 336 |
netsnmp_variable_list *vtail = NULL; |
| 337 |
char *cp1, *cp2; |
| 338 |
netsnmp_variable_list *var = NULL; |
| 339 |
int i, n; |
| 340 |
int neg = 0; |
| 341 |
oid oid_buf[MAX_OID_LEN]; |
| 342 |
|
| 343 |
DEBUGMSGTL(("disman:expr:eval1", "Evaluating '%s'\n", exprRaw)); |
| 344 |
if (!expIdx || !exprRaw) |
| 345 |
return NULL; |
| 346 |
|
| 347 |
/* |
| 348 |
* The expression is evaluated in two stages. |
| 349 |
* First, we simplify ("parboil") the raw expression, |
| 350 |
* tokenizing it into a sequence of varbind values, inserting |
| 351 |
* object parameters, and (recursively) evaluating any |
| 352 |
* parenthesised sub-expressions or function arguments. |
| 353 |
*/ |
| 354 |
|
| 355 |
for (cp1=exprRaw; cp1 && *cp1; ) { |
| 356 |
switch (*cp1) { |
| 357 |
case '$': |
| 358 |
/* |
| 359 |
* Locate the appropriate instance of the specified |
| 360 |
* parameter, and insert the corresponding value. |
| 361 |
*/ |
| 362 |
n = _expParse_integer( cp1+1, &cp1 ); |
| 363 |
var = _expValue_evalParam( expIdx, n, suffix, suffix_len ); |
| 364 |
if ( var && var->type == ASN_NULL ) { |
| 365 |
DEBUGMSGTL(("disman:expr:eval", "Invalid parameter '%d'\n", n)); |
| 366 |
/* Note position of failure in expression */ |
| 367 |
var->data = (void *)(cp1 - exprRaw); |
| 368 |
snmp_free_var(exprAlDente); |
| 369 |
*exprEnd = cp1; |
| 370 |
return var; |
| 371 |
} else { |
| 372 |
if (vtail) |
| 373 |
vtail->next_variable = var; |
| 374 |
else |
| 375 |
exprAlDente = var; |
| 376 |
vtail = var; |
| 377 |
var = NULL; |
| 378 |
} |
| 379 |
break; |
| 380 |
case '(': |
| 381 |
/* |
| 382 |
* Recursively evaluate the sub-expression |
| 383 |
*/ |
| 384 |
var = _expValue_evalExpr( expIdx, cp1+1, &cp2, |
| 385 |
suffix, suffix_len ); |
| 386 |
if ( var && var->type == ASN_NULL ) { |
| 387 |
/* Adjust position of failure */ |
| 388 |
var->data = (void *)(cp1 - exprRaw + (uintptr_t)var->data); |
| 389 |
return var; |
| 390 |
} else if (*cp2 != ')') { |
| 391 |
snmp_free_var(exprAlDente); |
| 392 |
DEBUGMSGTL(("disman:expr:eval", "Unbalanced parenthesis\n")); |
| 393 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 394 |
EXPERRCODE_PARENTHESIS ); |
| 395 |
var->type = ASN_NULL; |
| 396 |
var->data = (void *)(cp2 - exprRaw); |
| 397 |
*exprEnd = cp1; |
| 398 |
return var; |
| 399 |
} else { |
| 400 |
if (vtail) |
| 401 |
vtail->next_variable = var; |
| 402 |
else |
| 403 |
exprAlDente = var; |
| 404 |
vtail = var; |
| 405 |
var = NULL; |
| 406 |
cp1 = cp2+1; /* Skip to end of sub-expression */ |
| 407 |
} |
| 408 |
break; |
| 409 |
case ')': |
| 410 |
case ',': |
| 411 |
/* |
| 412 |
* End of current (sub-)expression |
| 413 |
* Note the end-position, and evaluate |
| 414 |
* the parboiled list of tokens. |
| 415 |
*/ |
| 416 |
*exprEnd = cp1; |
| 417 |
var = _expValue_evalExpr2( exprAlDente ); |
| 418 |
return var; |
| 419 |
|
| 420 |
/* === Constants === */ |
| 421 |
case '.': /* OID */ |
| 422 |
i = 0; |
| 423 |
memset( oid_buf, 0, sizeof(oid_buf)); |
| 424 |
while ( cp1 && *cp1 == '.' ) { |
| 425 |
n = _expParse_integer( cp1+1, &cp2 ); |
| 426 |
OID: |
| 427 |
oid_buf[i++] = n; |
| 428 |
cp1 = cp2; |
| 429 |
} |
| 430 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 431 |
ASN_OBJECT_ID, |
| 432 |
(u_char*)oid_buf, i*sizeof(oid)); |
| 433 |
break; |
| 434 |
DIGIT: |
| 435 |
case '0': |
| 436 |
case '1': |
| 437 |
case '2': |
| 438 |
case '3': |
| 439 |
case '4': |
| 440 |
case '5': |
| 441 |
case '6': |
| 442 |
case '7': |
| 443 |
case '8': |
| 444 |
case '9': |
| 445 |
n = _expParse_integer( cp1, &cp2 ); |
| 446 |
if ( cp2 && *cp2 == '.' ) { |
| 447 |
i = 0; |
| 448 |
memset( oid_buf, 0, sizeof(oid_buf)); |
| 449 |
goto OID; |
| 450 |
} |
| 451 |
if ( neg ) |
| 452 |
n = -n; |
| 453 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 454 |
ASN_INTEGER, |
| 455 |
(u_char*)&n, sizeof(n)); |
| 456 |
vtail = var; |
| 457 |
var = NULL; |
| 458 |
neg = 0; |
| 459 |
cp1 = cp2; |
| 460 |
break; |
| 461 |
|
| 462 |
case '"': /* String Constant */ |
| 463 |
for ( cp2 = cp1+1; *cp2; cp2++ ) { |
| 464 |
if ( *cp2 == '"' ) |
| 465 |
break; |
| 466 |
if ( *cp2 == '\\' && *(cp2+1) == '"' ) |
| 467 |
cp2++; |
| 468 |
} |
| 469 |
if ( *cp2 != '"' ) { |
| 470 |
/* |
| 471 |
* Unterminated string |
| 472 |
*/ |
| 473 |
DEBUGMSGTL(("disman:expr:eval", "Unterminated string\n")); |
| 474 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 475 |
EXPERRCODE_SYNTAX ); |
| 476 |
var->type = ASN_NULL; |
| 477 |
var->data = (void *)(cp2 - exprRaw); |
| 478 |
return var; |
| 479 |
} |
| 480 |
n = cp2 - cp1; |
| 481 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 482 |
ASN_OCTET_STR, |
| 483 |
(u_char*)cp1+1, n); |
| 484 |
vtail = var; |
| 485 |
var = NULL; |
| 486 |
break; |
| 487 |
|
| 488 |
|
| 489 |
/* === Operators === */ |
| 490 |
case '-': |
| 491 |
/* |
| 492 |
* Could be a unary minus.... |
| 493 |
*/ |
| 494 |
if (!vtail || vtail->type == ASN_PRIV_OPERATOR) { |
| 495 |
neg = 1; |
| 496 |
goto DIGIT; |
| 497 |
} |
| 498 |
/* |
| 499 |
* ... or a (single-character) binary operator. |
| 500 |
*/ |
| 501 |
/* Fallthrough */ |
| 502 |
case '+': |
| 503 |
case '*': |
| 504 |
case '/': |
| 505 |
case '%': |
| 506 |
case '^': |
| 507 |
case '~': |
| 508 |
if ( !vtail ) { |
| 509 |
/* |
| 510 |
* Can't start an expression with a binary operator |
| 511 |
*/ |
| 512 |
DEBUGMSGTL(("disman:expr:eval", "Initial binary operator\n")); |
| 513 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 514 |
EXPERRCODE_SYNTAX ); |
| 515 |
var->type = ASN_NULL; |
| 516 |
var->data = (void *)(cp1 - exprRaw); |
| 517 |
*exprEnd = cp1; |
| 518 |
return var; |
| 519 |
} |
| 520 |
n = ops[ *cp1 & 0xFF ]; |
| 521 |
DEBUGMSGTL(("disman:expr:eval", "Binary operator %c (%d)\n", *cp1, n)); |
| 522 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 523 |
ASN_INTEGER, |
| 524 |
(u_char*)&n, sizeof(n)); |
| 525 |
var->type = ASN_PRIV_OPERATOR; |
| 526 |
vtail = var; |
| 527 |
cp1++; |
| 528 |
break; |
| 529 |
|
| 530 |
/* |
| 531 |
* Multi-character binary operators |
| 532 |
*/ |
| 533 |
case '&': |
| 534 |
case '|': |
| 535 |
case '!': |
| 536 |
case '>': |
| 537 |
case '<': |
| 538 |
case '=': |
| 539 |
if ( !vtail ) { |
| 540 |
/* |
| 541 |
* Can't start an expression with a binary operator |
| 542 |
*/ |
| 543 |
DEBUGMSGTL(("disman:expr:eval", "Initial binary operator\n")); |
| 544 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 545 |
EXPERRCODE_SYNTAX ); |
| 546 |
var->type = ASN_NULL; |
| 547 |
var->data = (void *)(cp1 - exprRaw); |
| 548 |
*exprEnd = cp1; |
| 549 |
return var; |
| 550 |
} |
| 551 |
if ( *(cp1+1) == '=' ) |
| 552 |
n = ops[ *cp1++ + 20]; |
| 553 |
else if ( *(cp1+1) == *cp1 ) |
| 554 |
n = ops[ *cp1++ - 30]; |
| 555 |
else |
| 556 |
n = ops[ *cp1 & 0xFF ]; |
| 557 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 558 |
ASN_INTEGER, |
| 559 |
(u_char*)&n, sizeof(n)); |
| 560 |
var->type = ASN_PRIV_OPERATOR; |
| 561 |
vtail = var; |
| 562 |
cp1++; |
| 563 |
break; |
| 564 |
|
| 565 |
/* === Functions === */ |
| 566 |
case 'a': /* average/arraySection */ |
| 567 |
case 'c': /* counter32/counter64 */ |
| 568 |
case 'e': /* exists */ |
| 569 |
case 'm': /* maximum/minimum */ |
| 570 |
case 'o': /* oidBegins/Ends/Contains */ |
| 571 |
case 's': /* sum / string{B,E,C} */ |
| 572 |
var = snmp_varlist_add_variable( &exprAlDente, NULL, 0, |
| 573 |
ASN_OCTET_STR, |
| 574 |
(u_char*)cp1, 3 ); |
| 575 |
/* XXX */ |
| 576 |
var->type = ASN_PRIV_FUNCTION; |
| 577 |
vtail = var; |
| 578 |
while (*cp1 >= 'a' && *cp1 <= 'z') |
| 579 |
cp1++; |
| 580 |
break; |
| 581 |
|
| 582 |
default: |
| 583 |
if (isalpha( *cp1 & 0xFF )) { |
| 584 |
/* |
| 585 |
* Unrecognised function call ? |
| 586 |
*/ |
| 587 |
DEBUGMSGTL(("disman:expr:eval", "Unrecognised function '%s'\n", cp1)); |
| 588 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 589 |
EXPERRCODE_FUNCTION ); |
| 590 |
var->type = ASN_NULL; |
| 591 |
var->data = (void *)(cp1 - exprRaw); |
| 592 |
*exprEnd = cp1; |
| 593 |
return var; |
| 594 |
} |
| 595 |
else if (!isspace( *cp1 & 0xFF )) { |
| 596 |
/* |
| 597 |
* Unrecognised operator ? |
| 598 |
*/ |
| 599 |
DEBUGMSGTL(("disman:expr:eval", "Unrecognised operator '%c'\n", *cp1)); |
| 600 |
snmp_set_var_typed_integer( var, ASN_INTEGER, |
| 601 |
EXPERRCODE_OPERATOR ); |
| 602 |
var->type = ASN_NULL; |
| 603 |
var->data = (void *)(cp1 - exprRaw); |
| 604 |
*exprEnd = cp1; |
| 605 |
return var; |
| 606 |
} |
| 607 |
cp1++; |
| 608 |
break; |
| 609 |
} |
| 610 |
} |
| 611 |
|
| 612 |
/* |
| 613 |
* ... then we evaluate the resulting simplified ("al dente") |
| 614 |
* expression, in the usual manner. |
| 615 |
*/ |
| 616 |
*exprEnd = cp1; |
| 617 |
var = _expValue_evalExpr2( exprAlDente ); |
| 618 |
DEBUGMSGTL(( "disman:expr:eval1", "Evaluated to ")); |
| 619 |
DEBUGMSGVAR(("disman:expr:eval1", var)); |
| 620 |
DEBUGMSG(( "disman:expr:eval1", "\n")); |
| 621 |
/* snmp_free_var(exprAlDente); XXX - Crashes */ |
| 622 |
return var; |
| 623 |
} |
| 624 |
|
| 625 |
netsnmp_variable_list * |
| 626 |
_expValue_evalExpr2( netsnmp_variable_list *exprAlD ) |
| 627 |
{ |
| 628 |
netsnmp_variable_list *stack = NULL; |
| 629 |
netsnmp_variable_list *lval, *rval, *op; |
| 630 |
netsnmp_variable_list *vp, *vp1 = NULL; |
| 631 |
|
| 632 |
DEBUGIF(( "disman:expr:eval2")) { |
| 633 |
for (vp = exprAlD; vp; vp=vp->next_variable) { |
| 634 |
if ( vp->type == ASN_PRIV_OPERATOR ) |
| 635 |
DEBUGMSGTL(( "disman:expr:eval2", "Operator %ld\n", |
| 636 |
*vp->val.integer)); |
| 637 |
else if ( vp->type == ASN_PRIV_FUNCTION ) |
| 638 |
DEBUGMSGTL(( "disman:expr:eval2", "Function %s\n", |
| 639 |
vp->val.string)); |
| 640 |
else { |
| 641 |
DEBUGMSGTL(( "disman:expr:eval2", "Operand ")); |
| 642 |
DEBUGMSGVAR(("disman:expr:eval2", vp)); |
| 643 |
DEBUGMSG(( "disman:expr:eval2", "\n")); |
| 644 |
} |
| 645 |
} |
| 646 |
} |
| 647 |
|
| 648 |
for (vp = exprAlD; vp; vp=vp1) { |
| 649 |
vp1 = vp->next_variable; |
| 650 |
if ( vp->type == ASN_PRIV_OPERATOR ) { |
| 651 |
/* Must *always* follow a value */ |
| 652 |
if ( !stack || stack->type == ASN_PRIV_OPERATOR ) { |
| 653 |
snmp_set_var_typed_integer( vp, ASN_INTEGER, |
| 654 |
EXPERRCODE_SYNTAX ); |
| 655 |
vp->type = ASN_NULL; |
| 656 |
snmp_free_var( stack ); |
| 657 |
return vp; |
| 658 |
} |
| 659 |
/* |
| 660 |
* Evaluate any higher priority operators |
| 661 |
* already on the stack.... |
| 662 |
*/ |
| 663 |
while ( stack->next_variable && |
| 664 |
stack->next_variable->type == ASN_PRIV_OPERATOR && |
| 665 |
(*stack->next_variable->val.integer > *vp->val.integer)) { |
| 666 |
rval = stack; |
| 667 |
op = stack->next_variable; |
| 668 |
lval = op->next_variable; |
| 669 |
stack = lval->next_variable; |
| 670 |
|
| 671 |
rval = _expValue_evalOperator( lval, op, rval ); |
| 672 |
rval->next_variable = stack; |
| 673 |
stack = rval; |
| 674 |
} |
| 675 |
/* |
| 676 |
* ... and then push this operator onto the stack. |
| 677 |
*/ |
| 678 |
vp->next_variable = stack; |
| 679 |
stack = vp; |
| 680 |
} else if ( vp->type == ASN_PRIV_FUNCTION ) { |
| 681 |
/* Must be first, or follow an operator */ |
| 682 |
if ( stack && stack->type != ASN_PRIV_OPERATOR ) { |
| 683 |
snmp_set_var_typed_integer( vp, ASN_INTEGER, |
| 684 |
EXPERRCODE_SYNTAX ); |
| 685 |
vp->type = ASN_NULL; |
| 686 |
snmp_free_var( stack ); |
| 687 |
return vp; |
| 688 |
} |
| 689 |
/* |
| 690 |
* Evaluate this function (consuming the |
| 691 |
* appropriate parameters from the token |
| 692 |
* list), and push the result onto the stack. |
| 693 |
*/ |
| 694 |
vp = _expValue_evalFunction( vp ); |
| 695 |
vp1 = vp->next_variable; |
| 696 |
vp->next_variable = stack; |
| 697 |
stack = vp; |
| 698 |
} else { |
| 699 |
/* Must be first, or follow an operator */ |
| 700 |
if ( stack && stack->type != ASN_PRIV_OPERATOR ) { |
| 701 |
snmp_set_var_typed_integer( vp, ASN_INTEGER, |
| 702 |
EXPERRCODE_SYNTAX ); |
| 703 |
vp->type = ASN_NULL; |
| 704 |
snmp_free_var( stack ); |
| 705 |
return vp; |
| 706 |
} |
| 707 |
/* |
| 708 |
* Push this value onto the stack |
| 709 |
*/ |
| 710 |
vp->next_variable = stack; |
| 711 |
stack = vp; |
| 712 |
} |
| 713 |
} |
| 714 |
|
| 715 |
/* |
| 716 |
* Now evaluate whatever's left on the stack |
| 717 |
* and return the final result. |
| 718 |
*/ |
| 719 |
while ( stack && stack->next_variable ) { |
| 720 |
rval = stack; |
| 721 |
op = stack->next_variable; |
| 722 |
lval = op->next_variable; |
| 723 |
stack = lval->next_variable; |
| 724 |
|
| 725 |
rval = _expValue_evalOperator( lval, op, rval ); |
| 726 |
rval->next_variable = stack; |
| 727 |
stack = rval; |
| 728 |
} |
| 729 |
return stack; |
| 730 |
} |
| 731 |
|
| 732 |
/* ============= |
| 733 |
* Main API |
| 734 |
* ============= */ |
| 735 |
netsnmp_variable_list * |
| 736 |
expValue_evaluateExpression( struct expExpression *exp, |
| 737 |
oid *suffix, size_t suffix_len ) |
| 738 |
{ |
| 739 |
char exprRaw[ EXP_STR3_LEN+1 ]; |
| 740 |
netsnmp_variable_list *var; |
| 741 |
netsnmp_variable_list owner_var, name_var, param_var; |
| 742 |
int n; |
| 743 |
char *cp; |
| 744 |
|
| 745 |
if (!exp) |
| 746 |
return NULL; |
| 747 |
|
| 748 |
/* |
| 749 |
* Gather data for evaluating expressions with no regular delta-value |
| 750 |
* sampling, i.e. expressions with sampling/delta interval of 0 |
| 751 |
*/ |
| 752 |
expExpression_getData(0, exp); |
| 753 |
|
| 754 |
/* |
| 755 |
* Set up a varbind list containing the various index values |
| 756 |
* (including a placeholder for expObjectIndex). |
| 757 |
* |
| 758 |
* This saves having to construct the same index list repeatedly |
| 759 |
*/ |
| 760 |
memset(&owner_var, 0, sizeof(netsnmp_variable_list)); |
| 761 |
memset(&name_var, 0, sizeof(netsnmp_variable_list)); |
| 762 |
memset(¶m_var, 0, sizeof(netsnmp_variable_list)); |
| 763 |
snmp_set_var_typed_value( &owner_var, ASN_OCTET_STR, |
| 764 |
(u_char*)exp->expOwner, strlen(exp->expOwner)); |
| 765 |
snmp_set_var_typed_value( &name_var, ASN_OCTET_STR, |
| 766 |
(u_char*)exp->expName, strlen(exp->expName)); |
| 767 |
n = 99; /* dummy value */ |
| 768 |
snmp_set_var_typed_value( ¶m_var, ASN_INTEGER, |
| 769 |
(u_char*)&n, sizeof(n)); |
| 770 |
owner_var.next_variable = &name_var; |
| 771 |
name_var.next_variable = ¶m_var; |
| 772 |
|
| 773 |
/* |
| 774 |
* Make a working copy of the expression, and evaluate it. |
| 775 |
*/ |
| 776 |
memset(exprRaw, 0, sizeof(exprRaw)); |
| 777 |
memcpy(exprRaw, exp->expExpression, sizeof(exprRaw)); |
| 778 |
|
| 779 |
var = _expValue_evalExpr( &owner_var, exprRaw, &cp, suffix, suffix_len ); |
| 780 |
/* |
| 781 |
* Check for any problems, and record the appropriate error |
| 782 |
*/ |
| 783 |
if (!cp || *cp != '\0') { |
| 784 |
/* |
| 785 |
* When we had finished, there was a lot |
| 786 |
* of bricks^Wcharacters left over.... |
| 787 |
*/ |
| 788 |
_expValue_setError( exp, EXPERRCODE_SYNTAX, suffix, suffix_len, var ); |
| 789 |
return NULL; |
| 790 |
} |
| 791 |
if (!var) { |
| 792 |
/* Shouldn't happen */ |
| 793 |
_expValue_setError( exp, EXPERRCODE_RESOURCE, suffix, suffix_len, NULL ); |
| 794 |
return NULL; |
| 795 |
} |
| 796 |
if (var->type == ASN_NULL) { |
| 797 |
/* |
| 798 |
* Error explicitly reported from the evaluation routines. |
| 799 |
*/ |
| 800 |
_expValue_setError( exp, *(var->val.integer), suffix, suffix_len, var ); |
| 801 |
return NULL; |
| 802 |
} |
| 803 |
if (0 /* COMPARE var->type WITH exp->expValueType */ ) { |
| 804 |
/* |
| 805 |
* XXX - Check to see whether the returned type (ASN_XXX) |
| 806 |
* is compatible with the requested type (an enum) |
| 807 |
*/ |
| 808 |
|
| 809 |
/* If not, throw an error */ |
| 810 |
_expValue_setError( exp, EXPERRCODE_TYPE, suffix, suffix_len, var ); |
| 811 |
return NULL; |
| 812 |
} |
| 813 |
return var; |
| 814 |
} |
| 815 |
|
| 816 |
void |
| 817 |
_expValue_setError( struct expExpression *exp, int reason, |
| 818 |
oid *suffix, size_t suffix_len, |
| 819 |
netsnmp_variable_list *var) |
| 820 |
{ |
| 821 |
if (!exp) |
| 822 |
return; |
| 823 |
exp->expErrorCount++; |
| 824 |
/* exp->expErrorTime = NOW; */ |
| 825 |
exp->expErrorIndex = ( var && var->data ? (uintptr_t)var->data : 0 ); |
| 826 |
exp->expErrorCode = reason; |
| 827 |
memset( exp->expErrorInstance, 0, sizeof(exp->expErrorInstance)); |
| 828 |
memcpy( exp->expErrorInstance, suffix, suffix_len * sizeof(oid)); |
| 829 |
exp->expErrorInst_len = suffix_len; |
| 830 |
if (var) var->data = NULL; |
| 831 |
snmp_free_var( var ); |
| 832 |
} |