Debian Codegraph @

agent/mibgroup/target/snmpTargetParamsEntry.c

raw
1 /*
2 * TargetParamTable MIB
3 *
4 * This file was generated by mib2c and is intended for use as a mib module
5 * for the ucd-snmp snmpd agent. Edited by Michael Baer
6 *
7 * Portions of this file are copyrighted by:
8 * Copyright (c) 2016 VMware, Inc. All rights reserved.
9 * Use is subject to license terms specified in the COPYING file
10 * distributed with the Net-SNMP package.
11 */
12
13 #include <net-snmp/net-snmp-config.h>
14 #ifdef HAVE_STRING_H
15 #include <string.h>
16 #else
17 #include <strings.h>
18 #endif
19 #include <stdlib.h>
20 #include <ctype.h>
21
22 #include <net-snmp/net-snmp-includes.h>
23 #include <net-snmp/agent/net-snmp-agent-includes.h>
24
25 #include "snmpTargetParamsEntry.h"
26 #include "snmpTargetParamsEntry_data.h"
27
28 #define snmpTargetParamsOIDLen 11 /*This is base+column,
29 * i.e. everything but index */
30
31 oid snmpTargetParamsOID[snmpTargetParamsOIDLen] =
32 { 1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 0 };
33
34
35 /*
36 * Utility routines
37 */
38
39
40 /*
41 * snmpTargetParams_rowStatusCheck is boolean funciton that checks
42 * the status of a row's values in order to determine whether
43 * the row should be notReady or notInService
44 */
45 int
46 snmpTargetParams_rowStatusCheck(struct targetParamTable_struct *entry)
47 {
48 if ((entry->mpModel < 0) || (entry->secModel < 0) ||
49 (entry->secLevel < 0) || (entry->secNameData == NULL))
50 return 0;
51 else
52 return 1;
53 } /* snmtpTargetParamTable_rowStatusCheck */
54
55
56 /*
57 * initialization routines
58 */
59
60
61 /*
62 * this variable defines function callbacks and type return information
63 * for the snmpTargetAddrEntry mib
64 */
65
66 struct variable2 snmpTargetParamsEntry_variables[] = {
67 {SNMPTARGETPARAMSMPMODEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
68 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSMPMODELCOLUMN}},
69 {SNMPTARGETPARAMSSECURITYMODEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
70 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYMODELCOLUMN}},
71 {SNMPTARGETPARAMSSECURITYNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
72 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYNAMECOLUMN}},
73 {SNMPTARGETPARAMSSECURITYLEVEL, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
74 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSECURITYLEVELCOLUMN}},
75 {SNMPTARGETPARAMSSTORAGETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
76 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSSTORAGETYPECOLUMN}},
77 {SNMPTARGETPARAMSROWSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
78 var_snmpTargetParamsEntry, 1, {SNMPTARGETPARAMSROWSTATUSCOLUMN}}
79 };
80
81 /*
82 * now load this mib into the agents mib table
83 */
84 oid snmpTargetParamsEntry_variables_oid[] =
85 { 1, 3, 6, 1, 6, 3, 12, 1, 3, 1 };
86
87
88 void
89 init_snmpTargetParamsEntry(void)
90 {
91 init_snmpTargetParamsEntry_data();
92
93 REGISTER_MIB("target/snmpTargetParamsEntry",
94 snmpTargetParamsEntry_variables, variable2,
95 snmpTargetParamsEntry_variables_oid);
96
97 snmpd_register_config_handler("targetParams",
98 snmpd_parse_config_targetParams,
99 NULL, NULL);
100
101 } /* init_snmpTargetParmsEntry */
102
103 void
104 shutdown_snmpTargetParamsEntry(void)
105 {
106 shutdown_snmpTargetParamsEntry_data();
107 }
108
109
110 int
111 snmpTargetParams_addParamName(struct targetParamTable_struct *entry,
112 char *cptr)
113 {
114 size_t len;
115 if (cptr == NULL) {
116 DEBUGMSGTL(("snmpTargetParamsEntry",
117 "ERROR snmpTargetParamsEntry: no param name in config string\n"));
118 return (0);
119 } else {
120 len = strlen(cptr);
121 /*
122 * spec check for string 1-32
123 */
124 if (len < 1 || len > 32) {
125 DEBUGMSGTL(("snmpTargetParamsEntry",
126 "ERROR snmpTargetParamsEntry: param name out of range in config string\n"));
127 return (0);
128 }
129 entry->paramNameData = strdup(cptr);
130 entry->paramNameLen = strlen(cptr);
131 }
132 return (1);
133 }
134
135
136 int
137 snmpTargetParams_addMPModel(struct targetParamTable_struct *entry,
138 char *cptr)
139 {
140 if (cptr == NULL) {
141 DEBUGMSGTL(("snmpTargetParamsEntry",
142 "ERROR snmpTargetParamsEntry: no mp model in config string\n"));
143 return (0);
144 } else if (!(isdigit((unsigned char)(*cptr)))) {
145 DEBUGMSGTL(("snmpTargetParamsEntry",
146 "ERROR snmpTargeParamsEntry: mp model is not digit in config string\n"));
147 return (0);
148 }
149 /*
150 * spec check MP Model >= 0
151 */
152 else if ((entry->mpModel = (int) strtol(cptr, (char **) NULL, 0)) < 0) {
153 DEBUGMSGTL(("snmpTargetParamsEntry",
154 "ERROR snmpTargeParamsEntry: mp model out of range in config string\n"));
155 return (0);
156 }
157 return (1);
158 } /* snmpTargetParams_addMPModel */
159
160
161 int
162 snmpTargetParams_addSecModel(struct targetParamTable_struct *entry,
163 char *cptr)
164 {
165 if (cptr == NULL) {
166 DEBUGMSGTL(("snmpTargetParamsEntry",
167 "ERROR snmpTargetParamsEntry: no sec model in config string\n"));
168 return (0);
169 } else if (!(isdigit((unsigned char)(*cptr)))) {
170 DEBUGMSGTL(("snmpTargetParamsEntry",
171 "ERROR snmpTargeParamsEntry: security model is not digit in config string\n"));
172 return (0);
173 }
174 /*
175 * spec check Sec. Model > 0
176 */
177 else if ((entry->secModel =
178 (int) strtol(cptr, (char **) NULL, 0)) <= 0) {
179 DEBUGMSGTL(("snmpTargetParamsEntry",
180 "ERROR snmpTargetParamsEntry: security model out of range in config string\n"));
181 return (0);
182 }
183 return (1);
184 } /* snmpTargetParams_addSecModel */
185
186
187 int
188 snmpTargetParams_addSecName(struct targetParamTable_struct *entry,
189 char *cptr)
190 {
191 if (cptr == NULL) {
192 DEBUGMSGTL(("snmpTargetParamsEntry",
193 "ERROR snmpTargetParamsEntry: no security name in config string\n"));
194 return (0);
195 } else {
196 entry->secNameData = strdup(cptr);
197 entry->secNameLen = strlen(cptr);
198 }
199 return (1);
200 } /* snmpTargetParams_addSecName */
201
202
203 int
204 snmpTargetParams_addSecLevel(struct targetParamTable_struct *entry,
205 char *cptr)
206 {
207 if (cptr == NULL) {
208 DEBUGMSGTL(("snmpTargetParamsEntry",
209 "ERROR snmpTargetParamsEntry: no security level in config string\n"));
210 return (0);
211 } else if (!(isdigit((unsigned char)(*cptr)))) {
212 DEBUGMSGTL(("snmpTargetParamsEntry",
213 "ERROR snmpTargeParamsEntry: security level is not digit in config string\n"));
214 return (0);
215 }
216 /*
217 * no spec range check, but noAuthNoPriv is 1 so...
218 */
219 else if ((entry->secLevel =
220 (int) strtol(cptr, (char **) NULL, 0)) <= 0) {
221 DEBUGMSGTL(("snmpTargetParamsEntry",
222 "ERROR snmpTargeParamsEntry: security level is not greater than 0 in config string\n"));
223 return (0);
224 }
225 return (1);
226 } /* snmpTargetParams_addSecLevel */
227
228
229 int
230 snmpTargetParams_addStorageType(struct targetParamTable_struct *entry,
231 char *cptr)
232 {
233 if (cptr == NULL) {
234 DEBUGMSGTL(("snmpTargetParamsEntry",
235 "ERROR snmpTargetParamsEntry: no storage type in config string\n"));
236 return (0);
237 } else if (!(isdigit((unsigned char)(*cptr)))) {
238 DEBUGMSGTL(("snmpTargetParamsEntry",
239 "ERROR snmpTargeParamsEntry: storage type is not digit in config string\n"));
240 return (0);
241 }
242 /*
243 * check that storage type is a possible value
244 */
245 else if (((entry->storageType = (int) strtol(cptr, (char **) NULL, 0))
246 != SNMP_STORAGE_OTHER) &&
247 (entry->storageType != SNMP_STORAGE_VOLATILE) &&
248 (entry->storageType != SNMP_STORAGE_NONVOLATILE) &&
249 (entry->storageType != SNMP_STORAGE_PERMANENT) &&
250 (entry->storageType != SNMP_STORAGE_READONLY)) {
251 DEBUGMSGTL(("snmpTargetParamsEntry",
252 "ERROR snmpTargeParamsEntry: storage type is not a valid value of"));
253 DEBUGMSG(("snmpTargetParamsEntry",
254 " other(%d), volatile(%d), nonvolatile(%d), permanent(%d), or ",
255 SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
256 SNMP_STORAGE_NONVOLATILE, SNMP_STORAGE_PERMANENT));
257 DEBUGMSGTL(("snmpTargetParamsEntry",
258 "readonly(%d) in config string.\n",
259 SNMP_STORAGE_READONLY));
260
261 return (0);
262 }
263 return (1);
264 } /* snmpTargetParams_addStorageType */
265
266
267 int
268 snmpTargetParams_addRowStatus(struct targetParamTable_struct *entry,
269 char *cptr)
270 {
271 if (cptr == NULL) {
272 DEBUGMSGTL(("snmpTargetParamsEntry",
273 "ERROR snmpTargetParamsEntry: no row status in config string\n"));
274 return (0);
275 } else if (!(isdigit((unsigned char)(*cptr)))) {
276 DEBUGMSGTL(("snmpTargetParamsEntry",
277 "ERROR snmpTargeParamsEntry: row status is not digit in config string\n"));
278 return (0);
279 }
280 /*
281 * check that row status is a valid value
282 */
283 else if (((entry->rowStatus = (int) strtol(cptr, (char **) NULL, 0))
284 != SNMP_ROW_ACTIVE) &&
285 (entry->rowStatus != SNMP_ROW_NOTINSERVICE) &&
286 (entry->rowStatus != SNMP_ROW_NOTREADY)) {
287 DEBUGMSGTL(("snmpTargetParamsEntry",
288 "ERROR snmpTargetParamsEntry: Row Status is not a valid value of "));
289 DEBUGMSG(("snmpTargetParamsEntry",
290 "active(%d), notinservice(%d), or notready(%d) in config string.\n",
291 SNMP_ROW_ACTIVE, SNMP_ROW_NOTINSERVICE,
292 SNMP_ROW_NOTREADY));
293
294 return (0);
295 }
296 return (1);
297 } /* snmpTargetParams_addRowStatus */
298
299 /*
300 * timestamp the current entry's modification time
301 */
302 void
303 update_timestamp(struct targetParamTable_struct *temp_struct)
304 {
305 temp_struct->updateTime = time(NULL);
306 }
307
308 void
309 snmpd_parse_config_targetParams(const char *token, char *char_ptr)
310 {
311 char *cptr = char_ptr, buff[1024];
312 struct targetParamTable_struct *newEntry;
313
314 newEntry = snmpTargetParamTable_create();
315
316 cptr = copy_nword(cptr, buff, sizeof(buff));
317 if (snmpTargetParams_addParamName(newEntry, buff) == 0) {
318 snmpTargetParamTable_dispose(newEntry);
319 return;
320 }
321 cptr = copy_nword(cptr, buff, sizeof(buff));
322 if (snmpTargetParams_addMPModel(newEntry, buff) == 0) {
323 snmpTargetParamTable_dispose(newEntry);
324 return;
325 }
326 cptr = copy_nword(cptr, buff, sizeof(buff));
327 if (snmpTargetParams_addSecModel(newEntry, buff) == 0) {
328 snmpTargetParamTable_dispose(newEntry);
329 return;
330 }
331 cptr = copy_nword(cptr, buff, sizeof(buff));
332 if (snmpTargetParams_addSecName(newEntry, buff) == 0) {
333 snmpTargetParamTable_dispose(newEntry);
334 return;
335 }
336 cptr = copy_nword(cptr, buff, sizeof(buff));
337 if (snmpTargetParams_addSecLevel(newEntry, buff) == 0) {
338 snmpTargetParamTable_dispose(newEntry);
339 return;
340 }
341 cptr = copy_nword(cptr, buff, sizeof(buff));
342 if (snmpTargetParams_addStorageType(newEntry, buff) == 0) {
343 snmpTargetParamTable_dispose(newEntry);
344 return;
345 }
346 cptr = copy_nword(cptr, buff, sizeof(buff));
347 if (snmpTargetParams_addRowStatus(newEntry, buff) == 0) {
348 snmpTargetParamTable_dispose(newEntry);
349 return;
350 }
351 DEBUGMSGTL(("snmpTargetParamsEntry",
352 "snmp_parse_config_targetParams, read: %s %d %d %s %d %d %d\n",
353 newEntry->paramNameData, newEntry->mpModel, newEntry->secModel,
354 newEntry->secNameData, newEntry->secLevel,
355 newEntry->storageType, newEntry->rowStatus));
356
357 update_timestamp(newEntry);
358 snmpTargetParamTable_add(newEntry);
359 } /* snmpd_parse_config_target */
360
361
362 /*
363 * shutdown routines
364 */
365
366
367 /*
368 * MIB table access routines
369 */
370
371
372 u_char *
373 var_snmpTargetParamsEntry(struct variable * vp,
374 oid * name,
375 size_t * length,
376 int exact,
377 size_t * var_len, WriteMethod ** write_method)
378 {
379 /*
380 * variables we may use later
381 */
382 static long long_ret;
383 static unsigned char string[1500];
384 struct targetParamTable_struct *temp_struct;
385
386 switch (vp->magic) {
387 #ifndef NETSNMP_NO_WRITE_SUPPORT
388 case SNMPTARGETPARAMSMPMODEL:
389 *write_method = write_snmpTargetParamsMPModel;
390 break;
391 case SNMPTARGETPARAMSSECURITYMODEL:
392 *write_method = write_snmpTargetParamsSecModel;
393 break;
394 case SNMPTARGETPARAMSSECURITYNAME:
395 *write_method = write_snmpTargetParamsSecName;
396 break;
397 case SNMPTARGETPARAMSSECURITYLEVEL:
398 *write_method = write_snmpTargetParamsSecLevel;
399 break;
400 case SNMPTARGETPARAMSSTORAGETYPE:
401 *write_method = write_snmpTargetParamsStorageType;
402 break;
403 case SNMPTARGETPARAMSROWSTATUS:
404 *write_method = write_snmpTargetParamsRowStatus;
405 break;
406 #endif /* !NETSNMP_NO_WRITE_SUPPORT */
407 default:
408 *write_method = NULL;
409 }
410
411 /* assume an integer and change later if not */
412 *var_len = sizeof(long_ret);
413
414 /*
415 * look for OID in current table
416 */
417 if ((temp_struct = search_snmpTargetParamsTable(vp->name, vp->namelen,
418 name, length,
419 exact)) == NULL) {
420 return NULL;
421 }
422
423 /*
424 * We found what we were looking for, either the next OID or the exact OID
425 */
426 /*
427 * this is where we do the value assignments for the mib results.
428 */
429 switch (vp->magic) {
430
431 case SNMPTARGETPARAMSMPMODEL:
432 /*
433 * if unset value, (i.e. new row)
434 */
435 if (temp_struct->mpModel == -1)
436 return NULL;
437 long_ret = temp_struct->mpModel;
438 return (unsigned char *) &long_ret;
439
440 case SNMPTARGETPARAMSSECURITYMODEL:
441 /*
442 * if unset value, (i.e. new row)
443 */
444 if (temp_struct->secModel == -1)
445 return NULL;
446 long_ret = temp_struct->secModel;
447 return (unsigned char *) &long_ret;
448
449 case SNMPTARGETPARAMSSECURITYNAME:
450 /*
451 * if unset value, (i.e. new row)
452 */
453 if (temp_struct->secNameData == NULL)
454 return NULL;
455 /*
456 * including null character.
457 */
458 strlcpy((char *)string, temp_struct->secNameData, sizeof(string));
459 *var_len = strlen(temp_struct->secNameData);
460 return (unsigned char *) string;
461
462 case SNMPTARGETPARAMSSECURITYLEVEL:
463 /*
464 * if unset value, (i.e. new row)
465 */
466 if (temp_struct->secLevel == -1)
467 return NULL;
468 long_ret = temp_struct->secLevel;
469 return (unsigned char *) &long_ret;
470
471 case SNMPTARGETPARAMSSTORAGETYPE:
472 long_ret = temp_struct->storageType;
473 return (unsigned char *) &long_ret;
474
475 case SNMPTARGETPARAMSROWSTATUS:
476 long_ret = temp_struct->rowStatus;
477 return (unsigned char *) &long_ret;
478
479 default:
480 DEBUGMSGTL(("snmpd",
481 "unknown sub-id %d in var_snmpTargetParamsEntry\n",
482 vp->magic));
483 }
484
485 return NULL;
486 } /* var_snmpTargetParamsEntry */
487
488
489 #ifndef NETSNMP_NO_WRITE_SUPPORT
490 /*
491 * Assign a value to the mpModel variable.
492 */
493 int
494 write_snmpTargetParamsMPModel(int action,
495 u_char * var_val,
496 u_char var_val_type,
497 size_t var_val_len,
498 u_char * statP, oid * name, size_t name_len)
499 {
500 long long_ret = *((long *) var_val);
501 static long old_mp;
502 struct targetParamTable_struct *params = NULL;
503
504 if (action == RESERVE1) {
505 if (var_val_type != ASN_INTEGER) {
506 DEBUGMSGTL(("snmpTargetParamsEntry",
507 "write to snmpTargetParamsMPModel: not ASN_INTEGER\n"));
508 return SNMP_ERR_WRONGTYPE;
509 }
510 if (var_val_len != sizeof(long)) {
511 DEBUGMSGTL(("snmpTargetParamsEntry",
512 "write to snmpTargetParamsMPModel: bad length\n"));
513 return SNMP_ERR_WRONGLENGTH;
514 }
515 if (long_ret < 0) {
516 DEBUGMSGTL(("snmpTargetParamsEntry",
517 "write to snmpTargetParamsMPModel: MP Model out of range\n"));
518 return SNMP_ERR_INCONSISTENTVALUE;
519 }
520 } else if (action == RESERVE2) {
521 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
522 SNMPTARGETPARAMSMPMODELCOLUMN;
523 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
524 snmpTargetParamsOIDLen,
525 name, &name_len, 1);
526 if (params == NULL) {
527 DEBUGMSGTL(("snmpTargetParamsEntry",
528 "write to snmpTargetParamsMPModel: BAD OID\n"));
529 return SNMP_ERR_INCONSISTENTNAME;
530 } else {
531 /*
532 * Row exists, check if it is changeable.
533 */
534 if (params->storageType == SNMP_STORAGE_READONLY) {
535 DEBUGMSGTL(("snmpTargetParamsEntry",
536 "write to snmpTargetParamMPModel: row is read only\n"));
537 return SNMP_ERR_NOTWRITABLE;
538 }
539 /*
540 * Check if row is active.
541 */
542 if (params->rowStatus == SNMP_ROW_ACTIVE) {
543 DEBUGMSGTL(("snmpTargetParamsEntry",
544 "write to snmpTargetParamsMPModel: this change not allowed in active row.\n"));
545 return SNMP_ERR_INCONSISTENTVALUE;
546 }
547
548 old_mp = params->mpModel;
549 params->mpModel = long_ret;
550
551 if (params->rowStatus == SNMP_ROW_NOTREADY &&
552 snmpTargetParams_rowStatusCheck(params)) {
553 params->rowStatus = SNMP_ROW_NOTINSERVICE;
554 }
555 }
556 } else if (action == COMMIT) {
557 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
558 SNMPTARGETPARAMSMPMODELCOLUMN;
559 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
560 snmpTargetParamsOIDLen,
561 name, &name_len,
562 1)) != NULL) {
563 update_timestamp(params);
564 }
565 } else if (action == FREE || action == UNDO) {
566 /*
567 * Try to undo the SET here (abnormal usage of FREE clause)
568 */
569 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
570 SNMPTARGETPARAMSMPMODELCOLUMN;
571 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
572 snmpTargetParamsOIDLen,
573 name, &name_len,
574 1)) != NULL) {
575 if (params->storageType != SNMP_STORAGE_READONLY
576 && params->rowStatus != SNMP_ROW_ACTIVE) {
577 params->mpModel = old_mp;
578 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
579 !snmpTargetParams_rowStatusCheck(params)) {
580 params->rowStatus = SNMP_ROW_NOTREADY;
581 }
582 }
583 }
584 }
585
586 return SNMP_ERR_NOERROR;
587 } /* write_snmpTargetParamsMPModel */
588
589 /*
590 * Assign a value to the secModel variable.
591 */
592 int
593 write_snmpTargetParamsSecModel(int action,
594 u_char * var_val,
595 u_char var_val_type,
596 size_t var_val_len,
597 u_char * statP, oid * name, size_t name_len)
598 {
599 long long_ret = *((long *) var_val);
600 static long old_sec;
601 struct targetParamTable_struct *params = NULL;
602
603 if (action == RESERVE1) {
604 if (var_val_type != ASN_INTEGER) {
605 DEBUGMSGTL(("snmpTargetParamsEntry",
606 "write to snmpTargetParamsSecModel: not ASN_INTEGER\n"));
607 return SNMP_ERR_WRONGTYPE;
608 }
609 if (var_val_len != sizeof(long)) {
610 DEBUGMSGTL(("snmpTargetParamsEntry",
611 "write to snmpTargetParamsSecModel: bad length\n"));
612 return SNMP_ERR_WRONGLENGTH;
613 }
614 if (long_ret <= 0) {
615 DEBUGMSGTL(("snmpTargetParamsEntry",
616 "write to snmpTargetParamsSecModel: secModel out of range\n"));
617 return SNMP_ERR_WRONGVALUE;
618 }
619 if (find_sec_mod(long_ret) == NULL && long_ret >= 3) {
620 DEBUGMSGTL(("snmpTargetParamsEntry",
621 "write to snmpTargetParamsSecModel: secModel %ld unsupported\n",
622 long_ret));
623 return SNMP_ERR_INCONSISTENTVALUE;
624 }
625
626 } else if (action == RESERVE2) {
627 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
628 SNMPTARGETPARAMSSECURITYMODELCOLUMN;
629 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
630 snmpTargetParamsOIDLen,
631 name, &name_len, 1);
632 if (params == NULL) {
633 DEBUGMSGTL(("snmpTargetParamsEntry",
634 "write to snmpTargetParamsSecModel: BAD OID\n"));
635 return SNMP_ERR_INCONSISTENTNAME;
636 } else {
637 /*
638 * Row exists, check if it is changeable.
639 */
640 if (params->storageType == SNMP_STORAGE_READONLY) {
641 DEBUGMSGTL(("snmpTargetParamsEntry",
642 "write to snmpTargetParamSecModel: row is read only\n"));
643 return SNMP_ERR_NOTWRITABLE;
644 }
645 /*
646 * Check if row is active.
647 */
648 if (params->rowStatus == SNMP_ROW_ACTIVE) {
649 DEBUGMSGTL(("snmpTargetParamsEntry",
650 "write to snmpTargetParamsSecModel: this change not allowed in active row.\n"));
651 return SNMP_ERR_INCONSISTENTVALUE;
652 }
653
654 old_sec = params->secModel;
655 params->secModel = long_ret;
656
657 if (params->rowStatus == SNMP_ROW_NOTREADY &&
658 snmpTargetParams_rowStatusCheck(params)) {
659 params->rowStatus = SNMP_ROW_NOTINSERVICE;
660 }
661 }
662 } else if (action == COMMIT) {
663 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
664 SNMPTARGETPARAMSSECURITYMODELCOLUMN;
665 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
666 snmpTargetParamsOIDLen,
667 name, &name_len,
668 1)) != NULL) {
669 update_timestamp(params);
670 }
671 } else if (action == FREE || action == UNDO) {
672 /*
673 * Try to undo the SET here (abnormal usage of FREE clause)
674 */
675 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
676 SNMPTARGETPARAMSSECURITYMODELCOLUMN;
677 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
678 snmpTargetParamsOIDLen,
679 name, &name_len,
680 1)) != NULL) {
681 if (params->storageType != SNMP_STORAGE_READONLY
682 && params->rowStatus != SNMP_ROW_ACTIVE) {
683 params->secModel = old_sec;
684 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
685 !snmpTargetParams_rowStatusCheck(params)) {
686 params->rowStatus = SNMP_ROW_NOTREADY;
687 }
688 }
689 }
690 }
691
692 return SNMP_ERR_NOERROR;
693 } /* write_snmpTargetParamsSecModel */
694
695 /*
696 * Assign a value to the SecLevel variable.
697 */
698 int
699 write_snmpTargetParamsSecLevel(int action,
700 u_char * var_val,
701 u_char var_val_type,
702 size_t var_val_len,
703 u_char * statP, oid * name, size_t name_len)
704 {
705 long long_ret = *((long *) var_val);
706 static long old_level;
707 struct targetParamTable_struct *params = NULL;
708
709 if (action == RESERVE1) {
710 if (var_val_type != ASN_INTEGER) {
711 DEBUGMSGTL(("snmpTargetParamsEntry",
712 "write to snmpTargetParamsSecLevel: not ASN_INTEGER\n"));
713 return SNMP_ERR_WRONGTYPE;
714 }
715 if (var_val_len != sizeof(long)) {
716 DEBUGMSGTL(("snmpTargetParamsEntry",
717 "write to snmpTargetParamsSecLevel: bad length\n"));
718 return SNMP_ERR_WRONGLENGTH;
719 }
720 if (long_ret <= 0 || long_ret > 3) {
721 DEBUGMSGTL(("snmpTargetParamsEntry",
722 "write to snmpTargetParamsSecLevel: security level is not noAuthNoPriv(1), authNopriv(2) or authPriv(3)\n"));
723 return SNMP_ERR_WRONGVALUE;
724 }
725 } else if (action == RESERVE2) {
726 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
727 SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
728 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
729 snmpTargetParamsOIDLen,
730 name, &name_len, 1);
731 if (params == NULL) {
732 DEBUGMSGTL(("snmpTargetParamsEntry",
733 "write to snmpTargetParamsSecLevel: BAD OID\n"));
734 return SNMP_ERR_INCONSISTENTNAME;
735 } else {
736 /*
737 * Row exists, check if it is changeable.
738 */
739 if (params->storageType == SNMP_STORAGE_READONLY) {
740 DEBUGMSGTL(("snmpTargetParamsEntry",
741 "write to snmpTargetParamSecLevel: row is read only\n"));
742 return SNMP_ERR_NOTWRITABLE;
743 }
744 /*
745 * Check if row is active.
746 */
747 if (params->rowStatus == SNMP_ROW_ACTIVE) {
748 DEBUGMSGTL(("snmpTargetParamsEntry",
749 "write to snmpTargetParamsSecLevel: this change not allowed in active row.\n"));
750 return SNMP_ERR_INCONSISTENTVALUE;
751 }
752
753 old_level = params->secLevel;
754 params->secLevel = long_ret;
755
756 if (params->rowStatus == SNMP_ROW_NOTREADY &&
757 snmpTargetParams_rowStatusCheck(params)) {
758 params->rowStatus = SNMP_ROW_NOTINSERVICE;
759 }
760 }
761 } else if (action == COMMIT) {
762 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
763 SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
764 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
765 snmpTargetParamsOIDLen,
766 name, &name_len,
767 1)) != NULL) {
768 update_timestamp(params);
769 }
770 } else if (action == FREE || action == UNDO) {
771 /*
772 * Try to undo the SET here (abnormal usage of FREE clause)
773 */
774 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
775 SNMPTARGETPARAMSSECURITYLEVELCOLUMN;
776 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
777 snmpTargetParamsOIDLen,
778 name, &name_len,
779 1)) != NULL) {
780 if (params->storageType != SNMP_STORAGE_READONLY
781 && params->rowStatus != SNMP_ROW_ACTIVE) {
782 params->secLevel = old_level;
783 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
784 !snmpTargetParams_rowStatusCheck(params)) {
785 params->rowStatus = SNMP_ROW_NOTREADY;
786 }
787 }
788 }
789 }
790
791 return SNMP_ERR_NOERROR;
792 } /* write_snmpTargetParamsSecLevel */
793
794 /*
795 * Assign a value to the storageType variable.
796 */
797 int
798 write_snmpTargetParamsStorageType(int action,
799 u_char * var_val,
800 u_char var_val_type,
801 size_t var_val_len,
802 u_char * statP,
803 oid * name, size_t name_len)
804 {
805 long long_ret = *((long *) var_val);
806 static long old_st;
807 struct targetParamTable_struct *params = NULL;
808
809 if (action == RESERVE1) {
810 if (var_val_type != ASN_INTEGER) {
811 DEBUGMSGTL(("snmpTargetParamsEntry",
812 "write to snmpTargetParamsStorageType: not ASN_INTEGER\n"));
813 return SNMP_ERR_WRONGTYPE;
814 }
815 if (var_val_len != sizeof(long)) {
816 DEBUGMSGTL(("snmpTargetParamsEntry",
817 "write to snmpTargetParamsStorageType: bad length\n"));
818 return SNMP_ERR_WRONGLENGTH;
819 }
820 if (long_ret != SNMP_STORAGE_OTHER &&
821 long_ret != SNMP_STORAGE_VOLATILE &&
822 long_ret != SNMP_STORAGE_NONVOLATILE) {
823 DEBUGMSGTL(("snmpTargetParamsEntry",
824 "write to snmpTargetParamsStorageType: attempted storage type not a valid"));
825 DEBUGMSG(("snmpTargetParamsEntry",
826 " value of other(%d), volatile(%d), or nonvolatile(%d)\n",
827 SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
828 SNMP_STORAGE_NONVOLATILE));
829 return SNMP_ERR_WRONGVALUE;
830 }
831 } else if (action == RESERVE2) {
832 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
833 SNMPTARGETPARAMSSTORAGETYPECOLUMN;
834 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
835 snmpTargetParamsOIDLen,
836 name, &name_len, 1);
837 if (params == NULL) {
838 DEBUGMSGTL(("snmpTargetParamsEntry",
839 "write to snmpTargetParamsStorageType: BAD OID\n"));
840 return SNMP_ERR_INCONSISTENTNAME;
841 } else {
842 /*
843 * Row exists, check if it is changeable.
844 */
845 if (params->storageType == SNMP_STORAGE_READONLY ||
846 params->storageType == SNMP_STORAGE_PERMANENT) {
847 DEBUGMSGTL(("snmpTargetParamsEntry",
848 "write to snmpTargetParamsStorageType: row has unchangeable storage status: %d\n",
849 params->storageType));
850 return SNMP_ERR_INCONSISTENTVALUE;
851 }
852
853 old_st = params->storageType;
854 params->storageType = long_ret;
855 }
856 } else if (action == FREE || action == UNDO) {
857 /*
858 * Try to undo the SET here (abnormal usage of FREE clause)
859 */
860 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
861 SNMPTARGETPARAMSSTORAGETYPECOLUMN;
862 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
863 snmpTargetParamsOIDLen,
864 name, &name_len,
865 1)) != NULL) {
866 if (params->storageType != SNMP_STORAGE_READONLY
867 && params->storageType != SNMP_STORAGE_PERMANENT) {
868 params->storageType = old_st;
869 }
870 }
871 }
872
873 return SNMP_ERR_NOERROR;
874 } /* write_snmpTargetParamsStorageType */
875
876 /*
877 * Assign a value to the secName variable.
878 */
879 int
880 write_snmpTargetParamsSecName(int action,
881 u_char * var_val,
882 u_char var_val_type,
883 size_t var_val_len,
884 u_char * statP, oid * name, size_t name_len)
885 {
886 static char *old_name = NULL;
887 static size_t old_name_len;
888 struct targetParamTable_struct *params = NULL;
889
890 if (action == RESERVE1) {
891 if (var_val_type != ASN_OCTET_STR) {
892 DEBUGMSGTL(("snmpTargetParamsEntry",
893 "write to snmpTargetParamsSecName: not ASN_OCTET_STR\n"));
894 return SNMP_ERR_WRONGTYPE;
895 }
896 if (var_val_len > 255) {
897 DEBUGMSGTL(("snmpTargetParamsEntry",
898 "write to snmpTargetParamsSecName: bad length\n"));
899 return SNMP_ERR_WRONGLENGTH;
900 }
901 } else if (action == RESERVE2) {
902 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
903 SNMPTARGETPARAMSSECURITYNAMECOLUMN;
904 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
905 snmpTargetParamsOIDLen,
906 name, &name_len, 1);
907 if (params == NULL) {
908 DEBUGMSGTL(("snmpTargetParamsEntry",
909 "write to snmpTargetParamsSecName: BAD OID\n"));
910 return SNMP_ERR_INCONSISTENTNAME;
911 } else {
912 /*
913 * Row exists, check if it is changeable.
914 */
915 if (params->storageType == SNMP_STORAGE_READONLY) {
916 DEBUGMSGTL(("snmpTargetParamsEntry",
917 "write to snmpTargetParamSecName: row is read only\n"));
918 return SNMP_ERR_NOTWRITABLE;
919 }
920 /*
921 * Check if row is active.
922 */
923 if (params->rowStatus == SNMP_ROW_ACTIVE) {
924 DEBUGMSGTL(("snmpTargetParamsEntry",
925 "write to snmpTargetParamsSecName: this change not allowed in active row.\n"));
926 return SNMP_ERR_INCONSISTENTVALUE;
927 }
928 if (old_name != NULL) {
929 DEBUGMSGTL(("snmpTargetParamsEntry",
930 "multiple rows/sets no supported.\n"));
931 return SNMP_ERR_GENERR;
932 }
933
934 old_name = params->secNameData;
935 old_name_len = params->secNameLen;
936 params->secNameData = netsnmp_memdup_nt(var_val, var_val_len,
937 &params->secNameLen);
938 if (params->secNameData == NULL) {
939 return SNMP_ERR_RESOURCEUNAVAILABLE;
940 }
941
942 if (params->rowStatus == SNMP_ROW_NOTREADY &&
943 snmpTargetParams_rowStatusCheck(params)) {
944 params->rowStatus = SNMP_ROW_NOTINSERVICE;
945 }
946 }
947 } else if (action == COMMIT) {
948 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
949 SNMPTARGETPARAMSSECURITYNAMECOLUMN;
950 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
951 snmpTargetParamsOIDLen,
952 name, &name_len,
953 1)) != NULL) {
954 update_timestamp(params);
955 SNMP_FREE(old_name);
956 old_name = NULL;
957 }
958 } else if (action == FREE || action == UNDO) {
959 /*
960 * Try to undo the SET here (abnormal usage of FREE clause)
961 */
962 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
963 SNMPTARGETPARAMSSECURITYNAMECOLUMN;
964 if ((params = search_snmpTargetParamsTable(snmpTargetParamsOID,
965 snmpTargetParamsOIDLen,
966 name, &name_len,
967 1)) != NULL) {
968 if (params->storageType != SNMP_STORAGE_READONLY
969 && params->rowStatus != SNMP_ROW_ACTIVE) {
970 SNMP_FREE(params->secNameData);
971 params->secNameData = old_name;
972 params->secNameLen = old_name_len;
973 if (params->rowStatus == SNMP_ROW_NOTINSERVICE &&
974 !snmpTargetParams_rowStatusCheck(params)) {
975 params->rowStatus = SNMP_ROW_NOTREADY;
976 }
977 }
978 }
979 old_name = NULL;
980 }
981
982 return SNMP_ERR_NOERROR;
983 } /* write_snmpTargetParamsSecName */
984
985 /*
986 * snmpTargeParams_createNewRow is called from write_snmpTargetParamsRowStatus
987 * when a new row is required. It creates a new row with
988 * the index of the passed in 'name' (i.e. full index OID) and
989 * adds it to the linked list. 'name' should be the full OID of the new index.
990 * It passes back 0 if unsuccessfull.
991 */
992 int
993 snmpTargetParams_createNewRow(oid * name, size_t name_len)
994 {
995 int pNameLen, i;
996 struct targetParamTable_struct *temp_struct;
997
998 /*
999 * setup a new snmpTargetParamTable structure and add it to the list
1000 */
1001 pNameLen = name_len - snmpTargetParamsOIDLen;
1002 if (pNameLen > 0) {
1003 temp_struct = snmpTargetParamTable_create();
1004 if (NULL == temp_struct)
1005 return 0;
1006 temp_struct->paramNameData = (char *) malloc(pNameLen + 1);
1007
1008 for (i = 0; i < pNameLen; i++) {
1009 temp_struct->paramNameData[i] =
1010 (char) name[i + snmpTargetParamsOIDLen];
1011 }
1012
1013 temp_struct->paramNameData[pNameLen] = '\0';
1014 temp_struct->paramNameLen = pNameLen;
1015 temp_struct->rowStatus = SNMP_ROW_NOTREADY;
1016
1017 update_timestamp(temp_struct);
1018 snmpTargetParamTable_add(temp_struct);
1019
1020 return 1;
1021 }
1022
1023 return 0;
1024 } /* snmpTargetParams_createNewRow */
1025
1026 /*
1027 * Assign a value to the Row Status variable
1028 */
1029 int
1030 write_snmpTargetParamsRowStatus(int action,
1031 u_char * var_val,
1032 u_char var_val_type,
1033 size_t var_val_len,
1034 u_char * statP,
1035 oid * name, size_t name_len)
1036 {
1037 static long value;
1038 struct targetParamTable_struct *params = NULL;
1039
1040 if (action == RESERVE1) {
1041 if (var_val_type != ASN_INTEGER) {
1042 DEBUGMSGTL(("snmpTargetParamsEntry",
1043 "write to snmpTargetParamsRowStatus not ASN_INTEGER\n"));
1044 return SNMP_ERR_WRONGTYPE;
1045 }
1046 if (var_val_len != sizeof(long)) {
1047 DEBUGMSGTL(("snmpTargetParamsEntry",
1048 "write to snmpTargetParamsRowStatus: bad length\n"));
1049 return SNMP_ERR_WRONGLENGTH;
1050 }
1051 value = *((long *) var_val);
1052 if (value == SNMP_ROW_NOTREADY || value < 1 || value > 6) {
1053 return SNMP_ERR_WRONGVALUE;
1054 }
1055
1056 /*
1057 * Check index value is reasonable.
1058 */
1059
1060 if (name_len < snmpTargetParamsOIDLen + 1 ||
1061 name_len > snmpTargetParamsOIDLen + 32) {
1062 DEBUGMSGTL(("snmpTargetParamsEntry", "bad index length %d\n",
1063 (int)(name_len - snmpTargetParamsOIDLen)));
1064 return SNMP_ERR_NOCREATION;
1065 }
1066
1067 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
1068 SNMPTARGETPARAMSROWSTATUSCOLUMN;
1069 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
1070 snmpTargetParamsOIDLen,
1071 name, &name_len, 1);
1072 if (params != NULL) {
1073 if (value == SNMP_ROW_CREATEANDGO
1074 || value == SNMP_ROW_CREATEANDWAIT) {
1075 value = SNMP_ROW_NOTREADY;
1076 return SNMP_ERR_INCONSISTENTVALUE;
1077 }
1078 if (params->storageType == SNMP_STORAGE_READONLY) {
1079 DEBUGMSGTL(("snmpTargetParamsEntry",
1080 "row is read only\n"));
1081 return SNMP_ERR_NOTWRITABLE;
1082 }
1083 if (params->storageType == SNMP_STORAGE_PERMANENT) {
1084 if (value == SNMP_ROW_DESTROY) {
1085 DEBUGMSGTL(("snmpTargetParamsEntry",
1086 "unable to destroy permanent row\n"));
1087 return SNMP_ERR_INCONSISTENTVALUE;
1088 }
1089 }
1090 } else {
1091 if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
1092 return SNMP_ERR_INCONSISTENTVALUE;
1093 }
1094 if (value == SNMP_ROW_CREATEANDGO
1095 || value == SNMP_ROW_CREATEANDWAIT) {
1096 if (snmpTargetParams_createNewRow(name, name_len) == 0) {
1097 DEBUGMSGTL(("snmpTargetParamsEntry",
1098 "couldn't malloc() new row\n"));
1099 return SNMP_ERR_RESOURCEUNAVAILABLE;
1100 }
1101 }
1102 }
1103 } else if (action == ACTION) {
1104 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
1105 SNMPTARGETPARAMSROWSTATUSCOLUMN;
1106 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
1107 snmpTargetParamsOIDLen,
1108 name, &name_len, 1);
1109 if (params != NULL) {
1110 if (value == SNMP_ROW_CREATEANDGO) {
1111 /*
1112 * Check whether all the required objects have been set.
1113 */
1114 if (snmpTargetParams_rowStatusCheck(params)) {
1115 params->rowStatus = SNMP_ROW_ACTIVE;
1116 } else {
1117 params->rowStatus = SNMP_ROW_NOTREADY;
1118 }
1119 } else if (value == SNMP_ROW_CREATEANDWAIT) {
1120 /*
1121 * Check whether all the required objects have been set.
1122 */
1123 if (snmpTargetParams_rowStatusCheck(params)) {
1124 params->rowStatus = SNMP_ROW_NOTINSERVICE;
1125 } else {
1126 params->rowStatus = SNMP_ROW_NOTREADY;
1127 }
1128 } else if (value == SNMP_ROW_ACTIVE) {
1129 if (params->rowStatus == SNMP_ROW_NOTINSERVICE) {
1130 params->rowStatus = SNMP_ROW_ACTIVE;
1131 } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
1132 return SNMP_ERR_INCONSISTENTVALUE;
1133 }
1134 } else if (value == SNMP_ROW_NOTINSERVICE) {
1135 if (params->rowStatus == SNMP_ROW_ACTIVE) {
1136 params->rowStatus = SNMP_ROW_NOTINSERVICE;
1137 } else if (params->rowStatus == SNMP_ROW_NOTREADY) {
1138 return SNMP_ERR_INCONSISTENTVALUE;
1139 }
1140 }
1141 }
1142 } else if (action == COMMIT) {
1143 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
1144 SNMPTARGETPARAMSROWSTATUSCOLUMN;
1145 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
1146 snmpTargetParamsOIDLen,
1147 name, &name_len, 1);
1148 if (params != NULL) {
1149 if (value == SNMP_ROW_DESTROY) {
1150 snmpTargetParamTable_remove(params);
1151 }
1152 if (value == SNMP_ROW_ACTIVE || value == SNMP_ROW_NOTINSERVICE) {
1153 update_timestamp(params);
1154 }
1155 }
1156 } else if (action == UNDO || action == FREE) {
1157 snmpTargetParamsOID[snmpTargetParamsOIDLen - 1] =
1158 SNMPTARGETPARAMSROWSTATUSCOLUMN;
1159 params = search_snmpTargetParamsTable(snmpTargetParamsOID,
1160 snmpTargetParamsOIDLen,
1161 name, &name_len, 1);
1162 if (value == SNMP_ROW_CREATEANDGO
1163 || value == SNMP_ROW_CREATEANDWAIT) {
1164 if (params != NULL) {
1165 snmpTargetParamTable_remove(params);
1166 }
1167 }
1168 }
1169 return SNMP_ERR_NOERROR;
1170 }
1171
1172 #endif /* !NETSNMP_NO_WRITE_SUPPORT */