Debian Codegraph @

agent/mibgroup/disman/expr/expExpression.c

raw
1 /*
2 * DisMan Expression MIB:
3 * Core implementation of the expression handling behaviour
4 */
5
6 #include <net-snmp/net-snmp-config.h>
7 #include <net-snmp/net-snmp-includes.h>
8 #include <net-snmp/agent/net-snmp-agent-includes.h>
9 #include "disman/expr/expExpression.h"
10 #include "disman/expr/expObject.h"
11
12 netsnmp_tdata *expr_table_data;
13
14 /*
15 * Initializes the container for the expExpression table,
16 * regardless of which module initialisation routine is called first.
17 */
18 void
19 init_expr_table_data(void)
20 {
21 DEBUGMSGTL(("disman:expr:init", "init expression container\n"));
22 if (!expr_table_data) {
23 expr_table_data = netsnmp_tdata_create_table("expExpressionTable", 0);
24 DEBUGMSGTL(("disman:expr:init", "create expression container (%p)\n",
25 expr_table_data));
26 }
27 }
28
29 /** Initialize the expExpression module */
30 void
31 init_expExpression(void)
32 {
33 init_expr_table_data();
34 }
35
36
37 /* ===================================================
38 *
39 * APIs for maintaining the contents of the
40 * expression table container.
41 *
42 * =================================================== */
43
44 void
45 _mteExpr_dump(void)
46 {
47 struct mteExpression *entry;
48 netsnmp_tdata_row *row;
49 int i = 0;
50
51 for (row = netsnmp_tdata_row_first(expr_table_data);
52 row;
53 row = netsnmp_tdata_row_next(expr_table_data, row)) {
54 entry = (struct mteExpression *)row->data;
55 DEBUGMSGTL(("disman:expr:dump", "ExpressionTable entry %d: ", i));
56 DEBUGMSGOID(("disman:expr:dump", row->oid_index.oids, row->oid_index.len));
57 DEBUGMSG(("disman:expr:dump", "(%s, %s)",
58 row->indexes->val.string,
59 row->indexes->next_variable->val.string));
60 DEBUGMSG(("disman:expr:dump", ": %p, %p\n", row, entry));
61 i++;
62 }
63 DEBUGMSGTL(("disman:expr:dump", "ExpressionTable %d entries\n", i));
64 }
65
66
67
68 /*
69 * Create a new row in the expression table
70 */
71 struct expExpression *
72 expExpression_createEntry(const char *expOwner, const char *expName, int fixed)
73 {
74 netsnmp_tdata_row *row;
75
76 row = expExpression_createRow(expOwner, expName, fixed);
77 return row ? (struct expExpression *)row->data : NULL;
78 }
79
80
81 netsnmp_tdata_row *
82 expExpression_createRow(const char *expOwner, const char *expName, int fixed)
83 {
84 struct expExpression *entry;
85 netsnmp_tdata_row *row;
86 size_t expOwner_len = (expOwner) ? strlen(expOwner) : 0;
87 size_t expName_len = (expName) ? strlen(expName) : 0;
88
89 /*
90 * Create the expExpression entry, and the
91 * (table-independent) row wrapper structure...
92 */
93 entry = SNMP_MALLOC_TYPEDEF(struct expExpression);
94 if (!entry)
95 return NULL;
96
97 row = netsnmp_tdata_create_row();
98 if (!row) {
99 SNMP_FREE(entry);
100 return NULL;
101 }
102 row->data = entry;
103
104 /*
105 * ... initialize this row with the indexes supplied
106 * and the default values for the row...
107 */
108 if (expOwner)
109 memcpy(entry->expOwner, expOwner, expOwner_len);
110 netsnmp_tdata_row_add_index(row, ASN_OCTET_STR,
111 entry->expOwner, expOwner_len);
112 if (expName)
113 memcpy(entry->expName, expName, expName_len);
114 netsnmp_tdata_row_add_index(row, ASN_OCTET_STR,
115 entry->expName, expName_len);
116
117 entry->expValueType = EXPVALTYPE_COUNTER;
118 entry->expErrorCount = 0;
119 if (fixed)
120 entry->flags |= EXP_FLAG_FIXED;
121
122 /*
123 * ... and insert the row into the table container.
124 */
125 netsnmp_tdata_add_row(expr_table_data, row);
126 DEBUGMSGTL(("disman:expr:table", "Expression entry created (%s, %s)\n",
127 expOwner, expName));
128 return row;
129 }
130
131 /*
132 * Remove a row from the expression table
133 */
134 void
135 expExpression_removeEntry(netsnmp_tdata_row *row)
136 {
137 struct expExpression *entry;
138
139 if (!row)
140 return; /* Nothing to remove */
141 entry = (struct expExpression *)
142 netsnmp_tdata_remove_and_delete_row(expr_table_data, row);
143 if (entry) {
144 /* expExpression_disable( entry ) */
145 SNMP_FREE(entry);
146 }
147 }
148
149
150 struct expExpression *
151 expExpression_getFirstEntry( void )
152 {
153 return (struct expExpression *)
154 netsnmp_tdata_row_entry(netsnmp_tdata_row_first(expr_table_data));
155 }
156
157 struct expExpression *
158 expExpression_getNextEntry(const char *owner, const char *name )
159 {
160 netsnmp_variable_list owner_var, name_var;
161
162 memset(&owner_var, 0, sizeof(netsnmp_variable_list));
163 memset(&name_var, 0, sizeof(netsnmp_variable_list));
164 snmp_set_var_typed_value( &owner_var, ASN_OCTET_STR,
165 (const u_char*)owner, strlen(owner));
166 snmp_set_var_typed_value( &name_var, ASN_OCTET_STR,
167 (const u_char*)name, strlen(name));
168 owner_var.next_variable = &name_var;
169
170 return (struct expExpression *)
171 netsnmp_tdata_row_entry(
172 netsnmp_tdata_row_next_byidx(expr_table_data, &owner_var));
173 }
174
175 struct expExpression *
176 expExpression_getEntry(const char *owner, const char *name )
177 {
178 netsnmp_variable_list owner_var, name_var;
179
180 memset(&owner_var, 0, sizeof(netsnmp_variable_list));
181 memset(&name_var, 0, sizeof(netsnmp_variable_list));
182 snmp_set_var_typed_value( &owner_var, ASN_OCTET_STR,
183 (const u_char*)owner, strlen(owner));
184 snmp_set_var_typed_value( &name_var, ASN_OCTET_STR,
185 (const u_char*)name, strlen(name));
186 owner_var.next_variable = &name_var;
187
188 return (struct expExpression *)
189 netsnmp_tdata_row_entry(
190 netsnmp_tdata_row_get_byidx(expr_table_data, &owner_var));
191 }
192
193
194 /* ===================================================
195 *
196 * APIs for evaluating an expression - data gathering
197 *
198 * =================================================== */
199
200
201
202 /*
203 * Gather the data necessary for evaluating an expression.
204 *
205 * This will retrieve *all* the data relevant for all
206 * instances of this expression, rather than just the
207 * just the values needed for expanding a given instance.
208 */
209 void
210 expExpression_getData( unsigned int reg, void *clientarg )
211 {
212 struct expExpression *entry = (struct expExpression *)clientarg;
213 netsnmp_tdata_row *row;
214 netsnmp_variable_list *var;
215 int ret;
216
217 if ( !entry && reg ) {
218 snmp_alarm_unregister( reg );
219 return;
220 }
221
222 if (( entry->expExpression[0] == '\0' ) ||
223 !(entry->flags & EXP_FLAG_ACTIVE) ||
224 !(entry->flags & EXP_FLAG_VALID))
225 return;
226
227 DEBUGMSGTL(("disman:expr:run", "Gathering expression data (%s, %s)\n",
228 entry->expOwner, entry->expName));
229
230 /*
231 * This routine can be called in two situations:
232 * - regularly by 'snmp_alarm' (reg != 0)
233 * (as part of ongoing delta-value sampling)
234 * - on-demand (reg == 0)
235 * (for evaluating a particular entry)
236 *
237 * If a regularly sampled expression (entry->alarm != 0)
238 * is invoked on-demand (reg == 0), then use the most
239 * recent sampled values, rather than retrieving them again.
240 */
241 if ( !reg && entry->alarm )
242 return;
243
244 /*
245 * XXX - may want to implement caching for on-demand evaluation
246 * of non-regularly sampled expressions.
247 */
248
249 /*
250 * For a wildcarded expression, expExpressionPrefix is used
251 * to determine which object instances to retrieve.
252 * (For a non-wildcarded expression, we already know
253 * explicitly which object instances will be needed).
254 *
255 * If we walk this object here, then the results can be
256 * used to build the necessary GET requests for each
257 * individual parameter object (within expObject_getData)
258 *
259 * This will probably be simpler (and definitely more efficient)
260 * than walking the object instances separately and merging
261 * merging the results).
262 *
263 * NB: Releasing any old results is handled by expObject_getData.
264 * Assigning to 'entry->pvars' without first releasing the
265 * previous contents does *not* introduce a memory leak.
266 */
267 if ( entry->expPrefix_len ) {
268 var = (netsnmp_variable_list *)
269 SNMP_MALLOC_TYPEDEF( netsnmp_variable_list );
270 snmp_set_var_objid( var, entry->expPrefix, entry->expPrefix_len);
271 ret = netsnmp_query_walk( var, entry->session );
272 DEBUGMSGTL(("disman:expr:run", "Walk returned %d\n", ret ));
273 entry->pvars = var;
274 }
275
276 /* XXX - retrieve sysUpTime.0 value, and check for discontinuity */
277 /*
278 entry->flags &= ~EXP_FLAG_SYSUT;
279 var = (netsnmp_variable_list *)
280 SNMP_MALLOC_TYPEDEF( netsnmp_variable_list );
281 snmp_set_var_objid( var, sysUT_oid, sysUT_oid_len );
282 netsnmp_query_get( var, entry->session );
283 if ( *var->val.integer != entry->sysUpTime ) {
284 entry->flags |= EXP_FLAG_SYSUT;
285 entry->sysUpTime = *var->val.integer;
286 }
287 snmp_free_varbind(var);
288 */
289
290 /*
291 * Loop through the list of relevant objects,
292 * and retrieve the corresponding values.
293 */
294 for ( row = expObject_getFirst( entry->expOwner, entry->expName );
295 row;
296 row = expObject_getNext( row )) {
297
298 /* XXX - may need to check whether owner/name still match */
299 expObject_getData( entry, (struct expObject *)row->data);
300 }
301 }
302
303
304 void
305 expExpression_enable( struct expExpression *entry )
306 {
307 DEBUGMSGTL(("disman:expr:run", "Enabling %s\n", entry->expName));
308 if (!entry)
309 return;
310
311 if (entry->alarm) {
312 /* or explicitly call expExpression_disable ?? */
313 snmp_alarm_unregister( entry->alarm );
314 entry->alarm = 0;
315 }
316
317 if (entry->expDeltaInterval) {
318 entry->alarm = snmp_alarm_register(
319 entry->expDeltaInterval, SA_REPEAT,
320 expExpression_getData, entry );
321 expExpression_getData( entry->alarm, (void*)entry );
322 }
323 }
324
325 void
326 expExpression_disable( struct expExpression *entry )
327 {
328 if (!entry)
329 return;
330
331 if (entry->alarm) {
332 snmp_alarm_unregister( entry->alarm );
333 entry->alarm = 0;
334 /* Perhaps release any previous results ?? */
335 }
336 }
337
338
339 long _expExpression_MaxCount = 0;
340 long _expExpression_countEntries(void)
341 {
342 struct expExpression *entry;
343 netsnmp_tdata_row *row;
344 long count = 0;
345
346 for (row = netsnmp_tdata_row_first(expr_table_data);
347 row;
348 row = netsnmp_tdata_row_next(expr_table_data, row)) {
349 entry = (struct expExpression *)row->data;
350 count += entry->count;
351 }
352
353 return count;
354 }
355
356 long expExpression_getNumEntries(int max)
357 {
358 long count;
359 /* XXX - implement some form of caching ??? */
360 count = _expExpression_countEntries();
361 if ( count > _expExpression_MaxCount )
362 _expExpression_MaxCount = count;
363
364 return ( max ? _expExpression_MaxCount : count);
365 }