Debian Codegraph @

agent/mibgroup/disman/expr/expValue.c

raw
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(&param_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( &param_var, ASN_INTEGER,
769 (u_char*)&n, sizeof(n));
770 owner_var.next_variable = &name_var;
771 name_var.next_variable = &param_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 }