Debian Codegraph @

agent/mibgroup/disman/schedule/schedTable.c

raw
1 /*
2 * DisMan Schedule MIB:
3 * Core implementation of the schedTable MIB interface.
4 * See 'schedCore.c' for active behaviour of this table.
5 *
6 * (based on mib2c.table_data.conf output)
7 */
8
9 #include <net-snmp/net-snmp-config.h>
10 #include <net-snmp/net-snmp-features.h>
11 #include <net-snmp/net-snmp-includes.h>
12 #include <net-snmp/agent/net-snmp-agent-includes.h>
13 #include "utilities/iquery.h"
14 #include "disman/schedule/schedCore.h"
15 #include "disman/schedule/schedTable.h"
16
17 netsnmp_feature_require(iquery);
18 netsnmp_feature_require(iquery_pdu_session);
19 netsnmp_feature_require(table_tdata);
20 netsnmp_feature_require(date_n_time);
21 netsnmp_feature_require(check_vb_uint);
22 #ifndef NETSNMP_NO_WRITE_SUPPORT
23 netsnmp_feature_require(check_vb_type_and_max_size);
24 netsnmp_feature_require(check_vb_oid);
25 netsnmp_feature_require(check_vb_truthvalue);
26 netsnmp_feature_require(table_tdata_insert_row);
27 #endif /* NETSNMP_NO_WRITE_SUPPORT */
28
29 static netsnmp_table_registration_info *table_info;
30
31 /** Initializes the schedTable module */
32 void
33 init_schedTable(void)
34 {
35 static oid schedTable_oid[] = { 1, 3, 6, 1, 2, 1, 63, 1, 2 };
36 size_t schedTable_oid_len = OID_LENGTH(schedTable_oid);
37 netsnmp_handler_registration *reg;
38
39 DEBUGMSGTL(("disman:schedule:init", "Initializing table\n"));
40 /*
41 * Ensure the schedule table container is available...
42 */
43 init_schedule_container();
44
45 /*
46 * ... then set up the MIB interface.
47 */
48 reg = netsnmp_create_handler_registration("schedTable",
49 schedTable_handler,
50 schedTable_oid,
51 schedTable_oid_len,
52 HANDLER_CAN_RWRITE);
53
54 table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
55 netsnmp_table_helper_add_indexes(table_info,
56 ASN_OCTET_STR, /* index: schedOwner */
57 ASN_OCTET_STR, /* index: schedName */
58 0);
59 table_info->min_column = COLUMN_SCHEDDESCR;
60 table_info->max_column = COLUMN_SCHEDTRIGGERS;
61
62 netsnmp_tdata_register(reg, schedule_table, table_info);
63 }
64
65 void
66 shutdown_schedTable(void)
67 {
68 if (table_info) {
69 netsnmp_table_registration_info_free(table_info);
70 table_info = NULL;
71 }
72 }
73
74 /** handles requests for the schedTable table */
75 int
76 schedTable_handler(netsnmp_mib_handler *handler,
77 netsnmp_handler_registration *reginfo,
78 netsnmp_agent_request_info *reqinfo,
79 netsnmp_request_info *requests)
80 {
81
82 netsnmp_request_info *request;
83 netsnmp_table_request_info *tinfo;
84 netsnmp_tdata_row *row;
85 struct schedTable_entry *entry;
86 int recalculate = 0;
87 size_t len;
88 char *cp;
89 char owner[SCHED_STR1_LEN+1];
90 char name[ SCHED_STR1_LEN+1];
91 int ret;
92
93 DEBUGMSGTL(("disman:schedule:mib", "Schedule handler (%d)\n",
94 reqinfo->mode));
95 switch (reqinfo->mode) {
96 /*
97 * Read-support (also covers GetNext requests)
98 */
99 case MODE_GET:
100 for (request = requests; request; request = request->next) {
101 if (request->processed)
102 continue;
103
104 entry = (struct schedTable_entry *)
105 netsnmp_tdata_extract_entry(request);
106 tinfo = netsnmp_extract_table_info( request);
107
108 switch (tinfo->colnum) {
109 case COLUMN_SCHEDDESCR:
110 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
111 entry->schedDescr,
112 strlen(entry->schedDescr));
113 break;
114 case COLUMN_SCHEDINTERVAL:
115 snmp_set_var_typed_integer(request->requestvb, ASN_UNSIGNED,
116 entry->schedInterval);
117 break;
118 case COLUMN_SCHEDWEEKDAY:
119 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
120 &entry->schedWeekDay,
121 sizeof(entry->schedWeekDay));
122 break;
123 case COLUMN_SCHEDMONTH:
124 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
125 entry->schedMonth,
126 sizeof(entry->schedMonth));
127 break;
128 case COLUMN_SCHEDDAY:
129 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
130 entry->schedDay,
131 sizeof(entry->schedDay));
132 break;
133 case COLUMN_SCHEDHOUR:
134 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
135 entry->schedHour,
136 sizeof(entry->schedHour));
137 break;
138 case COLUMN_SCHEDMINUTE:
139 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
140 entry->schedMinute,
141 sizeof(entry->schedMinute));
142 break;
143 case COLUMN_SCHEDCONTEXTNAME:
144 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
145 entry->schedContextName,
146 strlen(entry->schedContextName));
147 break;
148 case COLUMN_SCHEDVARIABLE:
149 snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID,
150 (u_char *)entry->schedVariable,
151 entry->schedVariable_len*sizeof(oid));
152 break;
153 case COLUMN_SCHEDVALUE:
154 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
155 entry->schedValue);
156 break;
157 case COLUMN_SCHEDTYPE:
158 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
159 entry->schedType);
160 break;
161 case COLUMN_SCHEDADMINSTATUS:
162 ret = (entry->flags & SCHEDULE_FLAG_ENABLED ) ?
163 TV_TRUE : TV_FALSE;
164 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret);
165 break;
166 case COLUMN_SCHEDOPERSTATUS:
167 ret = (entry->flags & SCHEDULE_FLAG_ENABLED ) ?
168 TV_TRUE : TV_FALSE;
169 /*
170 * Check for one-shot entries that have already fired
171 */
172 if ((entry->schedType == SCHED_TYPE_ONESHOT) &&
173 (entry->schedLastRun != 0 ))
174 ret = 3; /* finished(3) */
175 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret);
176 break;
177 case COLUMN_SCHEDFAILURES:
178 snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER,
179 entry->schedFailures);
180 break;
181 case COLUMN_SCHEDLASTFAILURE:
182 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
183 entry->schedLastFailure);
184 break;
185 case COLUMN_SCHEDLASTFAILED:
186 /*
187 * Convert 'schedLastFailed' timestamp
188 * into DateAndTime string
189 */
190 cp = (char *) date_n_time( &entry->schedLastFailed, &len );
191 snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
192 cp, len);
193 break;
194 case COLUMN_SCHEDSTORAGETYPE:
195 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
196 entry->schedStorageType);
197 break;
198 case COLUMN_SCHEDROWSTATUS:
199 ret = (entry->flags & SCHEDULE_FLAG_ACTIVE ) ?
200 TV_TRUE : TV_FALSE;
201 snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret);
202 break;
203 case COLUMN_SCHEDTRIGGERS:
204 snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER,
205 entry->schedTriggers);
206 break;
207 }
208 }
209 break;
210
211 /*
212 * Write-support
213 */
214 case MODE_SET_RESERVE1:
215 for (request = requests; request; request = request->next) {
216 if (request->processed)
217 continue;
218
219 entry = (struct schedTable_entry *)
220 netsnmp_tdata_extract_entry(request);
221 tinfo = netsnmp_extract_table_info( request);
222
223 switch (tinfo->colnum) {
224 case COLUMN_SCHEDDESCR:
225 ret = netsnmp_check_vb_type_and_max_size(
226 request->requestvb, ASN_OCTET_STR, SCHED_STR2_LEN);
227 if (ret != SNMP_ERR_NOERROR) {
228 netsnmp_set_request_error(reqinfo, request, ret);
229 return SNMP_ERR_NOERROR;
230 }
231 break;
232 case COLUMN_SCHEDINTERVAL:
233 ret = netsnmp_check_vb_uint( request->requestvb );
234 if (ret != SNMP_ERR_NOERROR) {
235 netsnmp_set_request_error(reqinfo, request, ret);
236 return SNMP_ERR_NOERROR;
237 }
238 break;
239 case COLUMN_SCHEDWEEKDAY:
240 ret = netsnmp_check_vb_type_and_size(
241 request->requestvb, ASN_OCTET_STR, 1);
242 /* XXX - check for bit(7) set */
243 if (ret != SNMP_ERR_NOERROR) {
244 netsnmp_set_request_error(reqinfo, request, ret);
245 return SNMP_ERR_NOERROR;
246 }
247 break;
248 case COLUMN_SCHEDMONTH:
249 ret = netsnmp_check_vb_type_and_size( /* max_size ?? */
250 request->requestvb, ASN_OCTET_STR, 2);
251 /* XXX - check for bit(12)-bit(15) set */
252 if (ret != SNMP_ERR_NOERROR) {
253 netsnmp_set_request_error(reqinfo, request, ret);
254 return SNMP_ERR_NOERROR;
255 }
256 break;
257 case COLUMN_SCHEDDAY:
258 ret = netsnmp_check_vb_type_and_size( /* max_size ?? */
259 request->requestvb, ASN_OCTET_STR, 4+4);
260 /* XXX - check for bit(62) or bit(63) set */
261 if (ret != SNMP_ERR_NOERROR) {
262 netsnmp_set_request_error(reqinfo, request, ret);
263 return SNMP_ERR_NOERROR;
264 }
265 break;
266 case COLUMN_SCHEDHOUR:
267 ret = netsnmp_check_vb_type_and_size( /* max_size ?? */
268 request->requestvb, ASN_OCTET_STR, 3);
269 if (ret != SNMP_ERR_NOERROR) {
270 netsnmp_set_request_error(reqinfo, request, ret);
271 return SNMP_ERR_NOERROR;
272 }
273 break;
274 case COLUMN_SCHEDMINUTE:
275 ret = netsnmp_check_vb_type_and_size( /* max_size ?? */
276 request->requestvb, ASN_OCTET_STR, 8);
277 /* XXX - check for bit(60)-bit(63) set */
278 if (ret != SNMP_ERR_NOERROR) {
279 netsnmp_set_request_error(reqinfo, request, ret);
280 return SNMP_ERR_NOERROR;
281 }
282 break;
283 case COLUMN_SCHEDCONTEXTNAME:
284 ret = netsnmp_check_vb_type_and_max_size(
285 request->requestvb, ASN_OCTET_STR, SCHED_STR1_LEN);
286 if (ret != SNMP_ERR_NOERROR) {
287 netsnmp_set_request_error(reqinfo, request, ret);
288 return SNMP_ERR_NOERROR;
289 }
290 break;
291 case COLUMN_SCHEDVARIABLE:
292 ret = netsnmp_check_vb_oid( request->requestvb );
293 if (ret != SNMP_ERR_NOERROR) {
294 netsnmp_set_request_error(reqinfo, request, ret);
295 return SNMP_ERR_NOERROR;
296 }
297 break;
298 case COLUMN_SCHEDVALUE:
299 ret = netsnmp_check_vb_int( request->requestvb );
300 if (ret != SNMP_ERR_NOERROR) {
301 netsnmp_set_request_error(reqinfo, request, ret);
302 return SNMP_ERR_NOERROR;
303 }
304 break;
305 case COLUMN_SCHEDTYPE:
306 ret = netsnmp_check_vb_int_range( request->requestvb,
307 SCHED_TYPE_PERIODIC, SCHED_TYPE_ONESHOT );
308 if (ret != SNMP_ERR_NOERROR) {
309 netsnmp_set_request_error(reqinfo, request, ret);
310 return SNMP_ERR_NOERROR;
311 }
312 break;
313 case COLUMN_SCHEDADMINSTATUS:
314 ret = netsnmp_check_vb_truthvalue( request->requestvb );
315 if (ret != SNMP_ERR_NOERROR) {
316 netsnmp_set_request_error(reqinfo, request,
317 SNMP_ERR_WRONGTYPE);
318 return SNMP_ERR_NOERROR;
319 }
320 break;
321 case COLUMN_SCHEDSTORAGETYPE:
322 ret = netsnmp_check_vb_int_range( request->requestvb,
323 ST_NONE, ST_READONLY );
324 /* XXX - check valid/consistent assignments */
325 if (ret != SNMP_ERR_NOERROR) {
326 netsnmp_set_request_error(reqinfo, request, ret);
327 return SNMP_ERR_NOERROR;
328 }
329 break;
330 case COLUMN_SCHEDROWSTATUS:
331 ret = netsnmp_check_vb_rowstatus( request->requestvb,
332 (entry ? RS_ACTIVE: RS_NONEXISTENT));
333 /* XXX - check consistency assignments */
334 if (ret != SNMP_ERR_NOERROR) {
335 netsnmp_set_request_error(reqinfo, request, ret);
336 return SNMP_ERR_NOERROR;
337 }
338 break;
339 default:
340 netsnmp_set_request_error(reqinfo, request,
341 SNMP_ERR_NOTWRITABLE);
342 return SNMP_ERR_NOERROR;
343 }
344 }
345 break;
346
347 case MODE_SET_RESERVE2:
348 for (request = requests; request; request = request->next) {
349 if (request->processed)
350 continue;
351
352 tinfo = netsnmp_extract_table_info(request);
353
354 switch (tinfo->colnum) {
355 case COLUMN_SCHEDROWSTATUS:
356 switch (*request->requestvb->val.integer) {
357 case RS_CREATEANDGO:
358 case RS_CREATEANDWAIT:
359 /*
360 * Create an (empty) new row structure
361 */
362 memset(owner, 0, SCHED_STR1_LEN+1);
363 memset(name, 0, SCHED_STR1_LEN+1);
364 memcpy(owner, tinfo->indexes->val.string,
365 tinfo->indexes->val_len);
366 memcpy(name, tinfo->indexes->next_variable->val.string,
367 tinfo->indexes->next_variable->val_len);
368 row = schedTable_createEntry(owner, name);
369 if (!row) {
370 netsnmp_set_request_error(reqinfo, request,
371 SNMP_ERR_RESOURCEUNAVAILABLE);
372 return SNMP_ERR_NOERROR;
373 }
374 netsnmp_insert_tdata_row(request, row);
375 }
376 }
377 }
378 break;
379
380 case MODE_SET_FREE:
381 for (request = requests; request; request = request->next) {
382 if (request->processed)
383 continue;
384
385 tinfo = netsnmp_extract_table_info(request);
386
387 switch (tinfo->colnum) {
388 case COLUMN_SCHEDROWSTATUS:
389 switch (*request->requestvb->val.integer) {
390 case RS_CREATEANDGO:
391 case RS_CREATEANDWAIT:
392 /*
393 * Tidy up after a failed row creation request
394 */
395 entry = (struct schedTable_entry *)
396 netsnmp_tdata_extract_entry(request);
397 if (entry &&
398 !(entry->flags & SCHEDULE_FLAG_VALID)) {
399 row = (netsnmp_tdata_row *)
400 netsnmp_tdata_extract_row(request);
401 schedTable_removeEntry(row);
402 }
403 }
404 }
405 }
406 break;
407
408 case MODE_SET_ACTION:
409 for (request = requests; request; request = request->next) {
410 entry = (struct schedTable_entry *)
411 netsnmp_tdata_extract_entry(request);
412 if (!entry) {
413 /*
414 * New rows must be created via the RowStatus column
415 */
416 netsnmp_set_request_error(reqinfo, request,
417 SNMP_ERR_NOCREATION);
418 /* or inconsistentName? */
419 return SNMP_ERR_NOERROR;
420 }
421 }
422 break;
423
424 case MODE_SET_UNDO:
425 break;
426
427 case MODE_SET_COMMIT:
428 /*
429 * All these assignments are "unfailable", so it's
430 * (reasonably) safe to apply them in the Commit phase
431 */
432 entry = NULL;
433 for (request = requests; request; request = request->next) {
434 if (request->processed)
435 continue;
436
437 entry = (struct schedTable_entry *)
438 netsnmp_tdata_extract_entry(request);
439 tinfo = netsnmp_extract_table_info( request);
440
441 switch (tinfo->colnum) {
442 case COLUMN_SCHEDDESCR:
443 memset(entry->schedDescr, 0, sizeof(entry->schedDescr));
444 memcpy(entry->schedDescr, request->requestvb->val.string,
445 request->requestvb->val_len);
446 break;
447 case COLUMN_SCHEDINTERVAL:
448 entry->schedInterval = *request->requestvb->val.integer;
449 recalculate = 1;
450 break;
451 case COLUMN_SCHEDWEEKDAY:
452 entry->schedWeekDay[0] = request->requestvb->val.string[0];
453 recalculate = 1;
454 break;
455 case COLUMN_SCHEDMONTH:
456 entry->schedMonth[0] = request->requestvb->val.string[0];
457 entry->schedMonth[1] = request->requestvb->val.string[1];
458 recalculate = 1;
459 break;
460 case COLUMN_SCHEDDAY:
461 memset(entry->schedDay, 0, sizeof(entry->schedDay));
462 memcpy(entry->schedDay, request->requestvb->val.string,
463 request->requestvb->val_len);
464 recalculate = 1;
465 break;
466 case COLUMN_SCHEDHOUR:
467 entry->schedHour[0] = request->requestvb->val.string[0];
468 entry->schedHour[1] = request->requestvb->val.string[1];
469 entry->schedHour[2] = request->requestvb->val.string[2];
470 recalculate = 1;
471 break;
472 case COLUMN_SCHEDMINUTE:
473 memset(entry->schedMinute, 0, sizeof(entry->schedMinute));
474 memcpy(entry->schedMinute, request->requestvb->val.string,
475 request->requestvb->val_len);
476 recalculate = 1;
477 break;
478 case COLUMN_SCHEDCONTEXTNAME:
479 memset(entry->schedContextName, 0, sizeof(entry->schedContextName));
480 memcpy(entry->schedContextName,
481 request->requestvb->val.string,
482 request->requestvb->val_len);
483 break;
484 case COLUMN_SCHEDVARIABLE:
485 memset(entry->schedVariable, 0, sizeof(entry->schedVariable));
486 memcpy(entry->schedVariable,
487 request->requestvb->val.string,
488 request->requestvb->val_len);
489 entry->schedVariable_len =
490 request->requestvb->val_len/sizeof(oid);
491 break;
492 case COLUMN_SCHEDVALUE:
493 entry->schedValue = *request->requestvb->val.integer;
494 break;
495 case COLUMN_SCHEDTYPE:
496 entry->schedType = *request->requestvb->val.integer;
497 break;
498 case COLUMN_SCHEDADMINSTATUS:
499 if (*request->requestvb->val.integer == TV_TRUE)
500 entry->flags |= SCHEDULE_FLAG_ENABLED;
501 else
502 entry->flags &= ~SCHEDULE_FLAG_ENABLED;
503 break;
504 case COLUMN_SCHEDSTORAGETYPE:
505 entry->schedStorageType = *request->requestvb->val.integer;
506 break;
507 case COLUMN_SCHEDROWSTATUS:
508 switch (*request->requestvb->val.integer) {
509 case RS_ACTIVE:
510 entry->flags |= SCHEDULE_FLAG_ACTIVE;
511 break;
512 case RS_CREATEANDGO:
513 entry->flags |= SCHEDULE_FLAG_ACTIVE;
514 entry->flags |= SCHEDULE_FLAG_VALID;
515 entry->session =
516 netsnmp_iquery_pdu_session(reqinfo->asp->pdu);
517 break;
518 case RS_CREATEANDWAIT:
519 entry->flags |= SCHEDULE_FLAG_VALID;
520 entry->session =
521 netsnmp_iquery_pdu_session(reqinfo->asp->pdu);
522 break;
523
524 case RS_DESTROY:
525 row = (netsnmp_tdata_row *)
526 netsnmp_tdata_extract_row(request);
527 schedTable_removeEntry(row);
528 }
529 recalculate = 1;
530 break;
531 }
532 }
533 if (recalculate) {
534 netsnmp_assert(entry);
535 sched_nextTime(entry);
536 }
537 break;
538 }
539 return SNMP_ERR_NOERROR;
540 }