Debian Codegraph @

agent/mibgroup/target/snmpTargetAddrEntry.c

raw
1 /*
2 * snmpTargetAddrEntry 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 "snmpTargetAddrEntry.h"
26 #include "snmpTargetAddrEntry_data.h"
27 #include "util_funcs/header_generic.h"
28
29 #define snmpTargetAddrOIDLen 11 /*This is base+column,
30 * i.e. everything but index */
31
32 static oid snmpTargetAddrOID[snmpTargetAddrOIDLen] =
33 { 1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 0 };
34
35 static unsigned long snmpTargetSpinLock = 0;
36
37
38 /*
39 * snmpTargetAddr_rowStatusCheck is boolean funciton that checks
40 * the status of a row's values in order to determine whether
41 * the row should be notReady or notInService.
42 */
43 static int
44 snmpTargetAddr_rowStatusCheck(const struct targetAddrTable_struct *entry)
45 {
46 return entry->tDomainLen && entry->tAddress && entry->paramsData;
47 } /* snmtpTargetAddrTable_rowStatusCheck */
48
49
50 /*
51 * Init routines
52 */
53
54 /*
55 * this variable defines function callbacks and type return information
56 * for the snmpTargetAddrEntry mib
57 */
58
59 static const struct variable2 snmpTargetAddrEntry_variables[] = {
60 {SNMPTARGETADDRTDOMAIN, ASN_OBJECT_ID, NETSNMP_OLDAPI_RWRITE,
61 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTDOMAINCOLUMN}},
62 {SNMPTARGETADDRTADDRESS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
63 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTADDRESSCOLUMN}},
64 {SNMPTARGETADDRTIMEOUT, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
65 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTIMEOUTCOLUMN}},
66 {SNMPTARGETADDRRETRYCOUNT, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
67 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRRETRYCOUNTCOLUMN}},
68 {SNMPTARGETADDRTAGLIST, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
69 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRTAGLISTCOLUMN}},
70 {SNMPTARGETADDRPARAMS, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
71 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRPARAMSCOLUMN}},
72 {SNMPTARGETADDRSTORAGETYPE, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
73 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRSTORAGETYPECOLUMN}},
74 {SNMPTARGETADDRROWSTATUS, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
75 var_snmpTargetAddrEntry, 1, {SNMPTARGETADDRROWSTATUSCOLUMN}},
76
77 };
78
79 static const struct variable2 snmpTargetSpinLock_var[] = {
80 {SNMPTARGETSPINLOCK, ASN_INTEGER, NETSNMP_OLDAPI_RWRITE,
81 var_targetSpinLock, 1, {1}}
82 };
83
84 static const oid snmpTargetSpinLock_oid[] = { 1, 3, 6, 1, 6, 3, 12, 1 };
85
86 /*
87 * now load this mib into the agents mib table
88 */
89 static const oid snmpTargetAddrEntry_variables_oid[] =
90 { 1, 3, 6, 1, 6, 3, 12, 1, 2, 1 };
91
92
93 void
94 init_snmpTargetAddrEntry(void)
95 {
96 init_snmpTargetAddrEntry_data();
97
98 DEBUGMSGTL(("snmpTargetAddrEntry", "init\n"));
99 REGISTER_MIB("target/snmpTargetAddrEntry",
100 snmpTargetAddrEntry_variables, variable2,
101 snmpTargetAddrEntry_variables_oid);
102 REGISTER_MIB("target/snmpTargetSpinLock", snmpTargetSpinLock_var,
103 variable2, snmpTargetSpinLock_oid);
104
105 } /* init_snmpTargetAddrEntry */
106
107 void
108 shutdown_snmpTargetAddrEntry(void)
109 {
110 shutdown_snmpTargetAddrEntry_data();
111 }
112
113 /*
114 * Shutdown routines
115 */
116
117
118 /*
119 * MIB table access routines
120 */
121
122
123 u_char *
124 var_snmpTargetAddrEntry(struct variable * vp,
125 oid * name,
126 size_t * length,
127 int exact,
128 size_t * var_len, WriteMethod ** write_method)
129 {
130
131 /*
132 * variables we may use later
133 */
134 static long long_ret;
135 static char string[1500];
136 static oid objid[128];
137 struct targetAddrTable_struct *temp_struct;
138 int i = 0;
139
140 /*
141 * Set up write_method first, in case we return NULL before getting to the
142 * switch (vp->magic) below. In some of these cases, we still want to call
143 * the appropriate write_method, if only to have it return the appropriate
144 * error.
145 */
146
147 switch (vp->magic) {
148 #ifndef NETSNMP_NO_WRITE_SUPPORT
149 case SNMPTARGETADDRTDOMAIN:
150 *write_method = write_snmpTargetAddrTDomain;
151 break;
152 case SNMPTARGETADDRTADDRESS:
153 *write_method = write_snmpTargetAddrTAddress;
154 break;
155 case SNMPTARGETADDRRETRYCOUNT:
156 *write_method = write_snmpTargetAddrRetryCount;
157 break;
158 case SNMPTARGETADDRTIMEOUT:
159 *write_method = write_snmpTargetAddrTimeout;
160 break;
161 case SNMPTARGETADDRTAGLIST:
162 *write_method = write_snmpTargetAddrTagList;
163 break;
164 case SNMPTARGETADDRPARAMS:
165 *write_method = write_snmpTargetAddrParams;
166 break;
167 case SNMPTARGETADDRSTORAGETYPE:
168 *write_method = write_snmpTargetAddrStorageType;
169 break;
170 case SNMPTARGETADDRROWSTATUS:
171 *write_method = write_snmpTargetAddrRowStatus;
172 break;
173 #endif /* !NETSNMP_NO_WRITE_SUPPORT */
174 default:
175 *write_method = NULL;
176 }
177
178 /* assume an integer and change later if not */
179 *var_len = sizeof(long_ret);
180
181 /*
182 * look for OID in current table
183 */
184 if ((temp_struct = search_snmpTargetAddrTable(vp->name, vp->namelen,
185 name, length,
186 exact)) == NULL) {
187 return NULL;
188 }
189
190 /*
191 * We found what we were looking for, either the next OID or the exact OID
192 */
193 /*
194 * this is where we do the value assignments for the mib results.
195 */
196 switch (vp->magic) {
197 case SNMPTARGETADDRTDOMAIN:
198 if (temp_struct->tDomainLen <= 0) {
199 return NULL;
200 } else {
201 for (i = 0; i < temp_struct->tDomainLen; i++) {
202 objid[i] = temp_struct->tDomain[i];
203 }
204 *var_len = temp_struct->tDomainLen * sizeof(oid);
205 }
206 return (unsigned char *) objid;
207
208 case SNMPTARGETADDRTADDRESS:
209 if (temp_struct->tAddress == NULL)
210 return NULL;
211 *var_len = temp_struct->tAddressLen;
212 return (unsigned char *) temp_struct->tAddress;
213
214 case SNMPTARGETADDRTIMEOUT:
215 long_ret = temp_struct->timeout;
216 return (unsigned char *) &long_ret;
217
218 case SNMPTARGETADDRRETRYCOUNT:
219 long_ret = temp_struct->retryCount;
220 return (unsigned char *) &long_ret;
221
222 case SNMPTARGETADDRTAGLIST:
223 if (temp_struct->tagListData == NULL)
224 return NULL;
225 memcpy(string, temp_struct->tagListData, temp_struct->tagListLen);
226 *var_len = temp_struct->tagListLen;
227 return (unsigned char *) string;
228
229 case SNMPTARGETADDRPARAMS:
230 if (temp_struct->paramsData == NULL)
231 return NULL;
232 memcpy(string, temp_struct->paramsData, temp_struct->paramsLen);
233 *var_len = temp_struct->paramsLen;
234 return (unsigned char *) string;
235
236 case SNMPTARGETADDRSTORAGETYPE:
237 long_ret = temp_struct->storageType;
238 return (unsigned char *) &long_ret;
239
240 case SNMPTARGETADDRROWSTATUS:
241 long_ret = temp_struct->rowStatus;
242 return (unsigned char *) &long_ret;
243
244 default:
245 DEBUGMSGTL(("snmpd",
246 "unknown sub-id %d in var_snmpTargetAddrEntry\n",
247 vp->magic));
248 }
249
250 return NULL;
251 } /* var_snmpTargetAddrEntry */
252
253
254 #ifndef NETSNMP_NO_WRITE_SUPPORT
255 int
256 write_snmpTargetAddrTDomain(int action,
257 u_char * var_val,
258 u_char var_val_type,
259 size_t var_val_len,
260 u_char * statP, oid * name, size_t name_len)
261 {
262 struct targetAddrTable_struct *target = NULL;
263 static oid old_oid[MAX_OID_LEN];
264 static size_t old_oid_len;
265
266 if (action == RESERVE1) {
267 if (var_val_type != ASN_OBJECT_ID) {
268 DEBUGMSGTL(("snmpTargetAddrEntry",
269 "write to snmpTargetAddrTDomain not ASN_OBJECT_ID\n"));
270 return SNMP_ERR_WRONGTYPE;
271 }
272 if ((var_val_len > (MAX_OID_LEN * sizeof(oid))) ||
273 (var_val_len % sizeof(oid) != 0)) {
274 DEBUGMSGTL(("snmpTargetAddrEntry",
275 "write to snmpTargetAddrTDomain: bad length\n"));
276 return SNMP_ERR_WRONGLENGTH;
277 }
278 } else if (action == RESERVE2) {
279 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
280 SNMPTARGETADDRTDOMAINCOLUMN;
281 if ((target =
282 search_snmpTargetAddrTable(snmpTargetAddrOID,
283 snmpTargetAddrOIDLen, name,
284 &name_len, 1)) == NULL) {
285 DEBUGMSGTL(("snmpTargetAddrEntry",
286 "write to snmpTargetAddrTDomain: BAD OID!\n"));
287 return SNMP_ERR_INCONSISTENTNAME;
288 } else {
289 if (target->storageType == SNMP_STORAGE_READONLY) {
290 DEBUGMSGTL(("snmpTargetAddrEntry",
291 "write to snmpTargetAddrTDomain: row is read only\n"));
292 return SNMP_ERR_NOTWRITABLE;
293 }
294 if (target->rowStatus == SNMP_ROW_ACTIVE) {
295 DEBUGMSGTL(("snmpTargetAddrEntry",
296 "write to snmpTargetAddrTDomain: not allowed in active row.\n"));
297 return SNMP_ERR_INCONSISTENTVALUE;
298 }
299
300 /*
301 * Finally, we're golden, save current value.
302 */
303
304 memcpy(old_oid, target->tDomain,
305 target->tDomainLen * sizeof(oid));
306 old_oid_len = target->tDomainLen;
307
308 memcpy((u_char *) target->tDomain, var_val, var_val_len);
309 target->tDomainLen = var_val_len / sizeof(oid);
310
311 /*
312 * If row is new, check if its status can be updated.
313 */
314 if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
315 (snmpTargetAddr_rowStatusCheck(target) != 0)) {
316 target->rowStatus = SNMP_ROW_NOTINSERVICE;
317 }
318 }
319 } else if (action == COMMIT) {
320 snmp_store_needed(NULL);
321 } else if (action == FREE || action == UNDO) {
322 /*
323 * Try to undo the SET here (abnormal usage of FREE clause)
324 */
325 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
326 SNMPTARGETADDRTDOMAINCOLUMN;
327 if ((target =
328 search_snmpTargetAddrTable(snmpTargetAddrOID,
329 snmpTargetAddrOIDLen, name,
330 &name_len, 1)) != NULL) {
331 if (target->storageType != SNMP_STORAGE_READONLY
332 && target->rowStatus != SNMP_ROW_ACTIVE) {
333 memcpy((u_char *) target->tDomain, (u_char *) old_oid,
334 (old_oid_len * sizeof(oid)));
335 target->tDomainLen = old_oid_len;
336 if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
337 snmpTargetAddr_rowStatusCheck(target) == 0) {
338 target->rowStatus = SNMP_ROW_NOTREADY;
339 }
340 }
341 }
342 }
343 return SNMP_ERR_NOERROR;
344 } /* write_snmpTargetAddrTDomain */
345
346
347 int
348 write_snmpTargetAddrTAddress(int action,
349 u_char * var_val,
350 u_char var_val_type,
351 size_t var_val_len,
352 u_char * statP, oid * name, size_t name_len)
353 {
354 struct targetAddrTable_struct *target = NULL;
355 static char *old_addr = NULL;
356 static size_t old_len = 0;
357
358 if (action == RESERVE1) {
359 if (var_val_type != ASN_OCTET_STR) {
360 DEBUGMSGTL(("snmpTargetAddrEntry",
361 "write to snmpTargetAddrTAddress not ASN_OCTET_STR\n"));
362 return SNMP_ERR_WRONGTYPE;
363 } else if (var_val_len < 1 || var_val_len > 255) {
364 return SNMP_ERR_WRONGLENGTH;
365 }
366 } else if (action == RESERVE2) {
367 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
368 SNMPTARGETADDRTADDRESSCOLUMN;
369 if ((target =
370 search_snmpTargetAddrTable(snmpTargetAddrOID,
371 snmpTargetAddrOIDLen, name,
372 &name_len, 1)) == NULL) {
373 DEBUGMSGTL(("snmpTargetAddrEntry",
374 "write to snmpTargetAddrTAddress: BAD OID!\n"));
375 return SNMP_ERR_INCONSISTENTNAME;
376 } else {
377 if (target->storageType == SNMP_STORAGE_READONLY) {
378 DEBUGMSGTL(("snmpTargetAddrEntry",
379 "write to snmpTargetAddrTAddress: row is read only\n"));
380 return SNMP_ERR_NOTWRITABLE;
381 }
382 if (target->rowStatus == SNMP_ROW_ACTIVE) {
383 DEBUGMSGTL(("snmpTargetAddrEntry",
384 "write to snmpTargetAddrTAddress: not allowed in active row.\n"));
385 return SNMP_ERR_INCONSISTENTVALUE;
386 }
387
388 old_addr = target->tAddress;
389 old_len = target->tAddressLen;
390 target->tAddress = malloc(var_val_len);
391 if (target->tAddress == NULL) {
392 return SNMP_ERR_RESOURCEUNAVAILABLE;
393 }
394 memcpy(target->tAddress, var_val, var_val_len);
395 target->tAddressLen = var_val_len;
396
397 /*
398 * If row is new, check if its status can be updated.
399 */
400 if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
401 (snmpTargetAddr_rowStatusCheck(target) != 0)) {
402 target->rowStatus = SNMP_ROW_NOTINSERVICE;
403 }
404 }
405 } else if (action == COMMIT) {
406 SNMP_FREE(old_addr);
407 old_addr = NULL;
408 snmp_store_needed(NULL);
409 } else if (action == FREE || action == UNDO) {
410 /*
411 * Try to undo the SET here (abnormal usage of FREE clause)
412 */
413 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
414 SNMPTARGETADDRTADDRESSCOLUMN;
415 if ((target =
416 search_snmpTargetAddrTable(snmpTargetAddrOID,
417 snmpTargetAddrOIDLen, name,
418 &name_len, 1)) != NULL) {
419 if (target->storageType != SNMP_STORAGE_READONLY
420 && target->rowStatus != SNMP_ROW_ACTIVE) {
421 SNMP_FREE(target->tAddress);
422 target->tAddress = old_addr;
423 target->tAddressLen = old_len;
424 if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
425 snmpTargetAddr_rowStatusCheck(target) == 0) {
426 target->rowStatus = SNMP_ROW_NOTREADY;
427 }
428 }
429 }
430 }
431
432 return SNMP_ERR_NOERROR;
433 } /* write_snmpTargetAddrTAddress */
434
435
436 int
437 write_snmpTargetAddrTimeout(int action,
438 u_char * var_val,
439 u_char var_val_type,
440 size_t var_val_len,
441 u_char * statP, oid * name, size_t name_len)
442 {
443 /*
444 * variables we may use later
445 */
446 static long long_ret;
447 size_t size;
448 struct targetAddrTable_struct *temp_struct;
449
450 if (action == RESERVE1) {
451 if (var_val_type != ASN_INTEGER) {
452 DEBUGMSGTL(("snmpTargetAddrEntry",
453 "write to snmpTargetAddrTimeout not ASN_INTEGER\n"));
454 return SNMP_ERR_WRONGTYPE;
455 }
456 if (var_val_len > (size = sizeof(long_ret))) {
457 DEBUGMSGTL(("snmpTargetAddrEntry",
458 "write to snmpTargetAddrTimeout: bad length\n"));
459 return SNMP_ERR_WRONGLENGTH;
460 }
461 long_ret = *((long *) var_val);
462 if (long_ret < 0 || long_ret > 2147483647) {
463 return SNMP_ERR_WRONGVALUE;
464 }
465 } else if (action == RESERVE2) {
466
467 /*
468 * spec check range, no spec check
469 */
470
471 /*
472 * Find row in linked list and check pertinent status...
473 */
474 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
475 SNMPTARGETADDRTIMEOUTCOLUMN;
476 if ((temp_struct =
477 search_snmpTargetAddrTable(snmpTargetAddrOID,
478 snmpTargetAddrOIDLen, name, &name_len,
479 1)) == NULL) {
480 DEBUGMSGTL(("snmpTargetAddrEntry",
481 "write to snmpTargetAddrTimeout : BAD OID\n"));
482 return SNMP_ERR_NOSUCHNAME;
483 }
484 /*
485 * row exists, check if it is changeable
486 */
487 if (temp_struct->storageType == SNMP_STORAGE_READONLY) {
488 DEBUGMSGTL(("snmpTargetAddrEntry",
489 "write to snmpTargetAddrTimeout : row is read only\n"));
490 return SNMP_ERR_NOTWRITABLE;
491 }
492 } else if (action == COMMIT) {
493 /*
494 * Finally, we're golden, should we save value?
495 */
496 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
497 SNMPTARGETADDRTIMEOUTCOLUMN;
498 if ((temp_struct =
499 search_snmpTargetAddrTable(snmpTargetAddrOID,
500 snmpTargetAddrOIDLen, name, &name_len,
501 1)) != NULL) {
502 temp_struct->timeout = long_ret;
503 }
504 snmp_store_needed(NULL);
505 }
506
507 return SNMP_ERR_NOERROR;
508 } /* write_snmpTargetAddrTimeout */
509
510
511 int
512 write_snmpTargetAddrRetryCount(int action,
513 u_char * var_val,
514 u_char var_val_type,
515 size_t var_val_len,
516 u_char * statP, oid * name, size_t name_len)
517 {
518 static long long_ret;
519 struct targetAddrTable_struct *target;
520
521 if (action == RESERVE1) {
522 if (var_val_type != ASN_INTEGER) {
523 DEBUGMSGTL(("snmpTargetAddrEntry",
524 "write to snmpTargetAddrRetryCount not ASN_INTEGER\n"));
525 return SNMP_ERR_WRONGTYPE;
526 }
527 if (var_val_len != sizeof(long)) {
528 DEBUGMSGTL(("snmpTargetAddrEntry",
529 "write to snmpTargetAddrRetryCount: bad length\n"));
530 return SNMP_ERR_WRONGLENGTH;
531 }
532 long_ret = *((long *) var_val);
533 if (long_ret < 0 || long_ret > 255) {
534 return SNMP_ERR_WRONGVALUE;
535 }
536 } else if (action == RESERVE2) {
537 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
538 SNMPTARGETADDRRETRYCOUNTCOLUMN;
539 if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
540 snmpTargetAddrOIDLen,
541 name, &name_len,
542 1)) == NULL) {
543 DEBUGMSGTL(("snmpTargetAddrEntry",
544 "write to snmpTargetAddrTimeout: BAD OID\n"));
545 return SNMP_ERR_INCONSISTENTNAME;
546 } else {
547 if (target->storageType == SNMP_STORAGE_READONLY) {
548 DEBUGMSGTL(("snmpTargetAddrEntry",
549 "write to snmpTargetAddrRetryCount: row is read only\n"));
550 return SNMP_ERR_NOTWRITABLE;
551 }
552 }
553 } else if (action == COMMIT) {
554 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
555 SNMPTARGETADDRRETRYCOUNTCOLUMN;
556 if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
557 snmpTargetAddrOIDLen,
558 name, &name_len,
559 1)) != NULL) {
560 target->retryCount = long_ret;
561 }
562 snmp_store_needed(NULL);
563 }
564
565 return SNMP_ERR_NOERROR;
566 } /* write_snmpTargetAddrRetryCount */
567
568 static int
569 is_delim(const char c)
570 {
571 return (c == 0x020 || c == 0x09 || c == 0x0d || c == 0x0b);
572 }
573
574 int
575 snmpTagListValid(const char *tagList, const size_t tagListLen)
576 {
577 size_t i = 0;
578 int inTag = 0;
579
580
581 for (i = 0; i < tagListLen; i++) {
582 if (is_delim(tagList[i]) && !inTag) {
583 /*
584 * Either a leading delimiter or two consecutive delimiters.
585 */
586 return 0;
587 } else if (is_delim(tagList[i]) && inTag) {
588 inTag = 0;
589 } else if (!is_delim(tagList[i]) && !inTag) {
590 inTag = 1;
591 }
592 }
593 if (!inTag) {
594 /*
595 * Trailing delimiter.
596 */
597 return 0;
598 }
599 return 1;
600 }
601
602 int
603 write_snmpTargetAddrTagList(int action,
604 u_char * var_val,
605 u_char var_val_type,
606 size_t var_val_len,
607 u_char * statP, oid * name, size_t name_len)
608 {
609 struct targetAddrTable_struct *target = NULL;
610 static char *old_tlist = NULL;
611 static int old_tlist_len;
612
613 if (action == RESERVE1) {
614 if (var_val_type != ASN_OCTET_STR) {
615 DEBUGMSGTL(("snmpTargetAddrEntry",
616 "write to snmpTargetAddrTagList not ASN_OCTET_STR\n"));
617 return SNMP_ERR_WRONGTYPE;
618 }
619 if (var_val_len > 255) {
620 DEBUGMSGTL(("snmpTargetAddrEntry",
621 "write to snmpTargetAddrTagList: bad length\n"));
622 return SNMP_ERR_WRONGLENGTH;
623 }
624 if (!snmpTagListValid((char *) var_val, var_val_len)) {
625 return SNMP_ERR_WRONGVALUE;
626 }
627 } else if (action == RESERVE2) {
628 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
629 SNMPTARGETADDRTAGLISTCOLUMN;
630 if ((target =
631 search_snmpTargetAddrTable(snmpTargetAddrOID,
632 snmpTargetAddrOIDLen, name,
633 &name_len, 1)) == NULL) {
634 DEBUGMSGTL(("snmpTargetAddrEntry",
635 "write to snmpTargetAddrTagList: BAD OID!\n"));
636 return SNMP_ERR_INCONSISTENTNAME;
637 } else {
638 if (target->storageType == SNMP_STORAGE_READONLY) {
639 DEBUGMSGTL(("snmpTargetAddrEntry",
640 "write to snmpTargetAddrTagList: row is read only\n"));
641 return SNMP_ERR_NOTWRITABLE;
642 }
643 if (old_tlist != NULL) {
644 DEBUGMSGTL(("snmpTargetAddrEntry",
645 "writing multiple rows/values not supported\n"));
646 return SNMP_ERR_GENERR;
647 }
648 old_tlist = target->tagListData;
649 old_tlist_len = target->tagListLen;
650 target->tagListData = netsnmp_memdup_nt(var_val, var_val_len,
651 &target->tagListLen);
652 if (target->tagListData == NULL) {
653 return SNMP_ERR_RESOURCEUNAVAILABLE;
654 }
655 }
656 } else if (action == COMMIT) {
657 SNMP_FREE(old_tlist);
658 old_tlist = NULL;
659 snmp_store_needed(NULL);
660 } else if (action == FREE || action == UNDO) {
661 old_tlist = NULL;
662 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
663 SNMPTARGETADDRTAGLISTCOLUMN;
664 if ((target =
665 search_snmpTargetAddrTable(snmpTargetAddrOID,
666 snmpTargetAddrOIDLen, name,
667 &name_len, 1)) != NULL) {
668 if (target->storageType != SNMP_STORAGE_READONLY) {
669 SNMP_FREE(target->tagListData);
670 target->tagListData = old_tlist;
671 target->tagListLen = old_tlist_len;
672 }
673 }
674 }
675
676 return SNMP_ERR_NOERROR;
677 } /* write_snmpTargetAddrTagList */
678
679
680 int
681 write_snmpTargetAddrParams(int action,
682 u_char * var_val,
683 u_char var_val_type,
684 size_t var_val_len,
685 u_char * statP, oid * name, size_t name_len)
686 {
687 struct targetAddrTable_struct *target = NULL;
688 static char *old_params = NULL;
689 static size_t old_params_len;
690
691 if (action == RESERVE1) {
692 if (var_val_type != ASN_OCTET_STR) {
693 DEBUGMSGTL(("snmpTargetAddrEntry",
694 "write to snmpTargetAddrParams not ASN_OCTET_STR\n"));
695 return SNMP_ERR_WRONGTYPE;
696 } else if (var_val_len < 1 || var_val_len > 32) {
697 return SNMP_ERR_WRONGLENGTH;
698 }
699 } else if (action == RESERVE2) {
700 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
701 SNMPTARGETADDRPARAMSCOLUMN;
702 if ((target =
703 search_snmpTargetAddrTable(snmpTargetAddrOID,
704 snmpTargetAddrOIDLen, name,
705 &name_len, 1)) == NULL) {
706 DEBUGMSGTL(("snmpTargetAddrEntry",
707 "write to snmpTargetAddrParams: BAD OID!\n"));
708 return SNMP_ERR_INCONSISTENTNAME;
709 } else {
710 if (target->storageType == SNMP_STORAGE_READONLY) {
711 DEBUGMSGTL(("snmpTargetAddrEntry",
712 "write to snmpTargetAddrParams: row is read only\n"));
713 return SNMP_ERR_NOTWRITABLE;
714 }
715 if (target->rowStatus == SNMP_ROW_ACTIVE) {
716 DEBUGMSGTL(("snmpTargetAddrEntry",
717 "write to snmpTargetAddrParams: not allowed in active row.\n"));
718 return SNMP_ERR_INCONSISTENTVALUE;
719 }
720 if (old_params != NULL) {
721 DEBUGMSGTL(("snmpTargetAddrEntry",
722 "writing multiple rows/values not supported\n"));
723 return SNMP_ERR_GENERR;
724 }
725
726 old_params = target->paramsData;
727 old_params_len = target->paramsLen;
728 target->paramsData = netsnmp_memdup_nt(var_val, var_val_len,
729 &target->paramsLen);
730 if (target->paramsData == NULL) {
731 return SNMP_ERR_RESOURCEUNAVAILABLE;
732 }
733
734 /*
735 * If row is new, check if its status can be updated.
736 */
737 if ((target->rowStatus == SNMP_ROW_NOTREADY) &&
738 (snmpTargetAddr_rowStatusCheck(target) != 0)) {
739 target->rowStatus = SNMP_ROW_NOTINSERVICE;
740 }
741 }
742 } else if (action == COMMIT) {
743 SNMP_FREE(old_params);
744 old_params = NULL;
745 snmp_store_needed(NULL);
746 } else if (action == FREE || action == UNDO) {
747 /*
748 * Try to undo the SET here (abnormal usage of FREE clause)
749 */
750 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
751 SNMPTARGETADDRPARAMSCOLUMN;
752 if ((target =
753 search_snmpTargetAddrTable(snmpTargetAddrOID,
754 snmpTargetAddrOIDLen, name,
755 &name_len, 1)) != NULL) {
756 if (target->storageType != SNMP_STORAGE_READONLY
757 && target->rowStatus != SNMP_ROW_ACTIVE) {
758 SNMP_FREE(target->paramsData);
759 target->paramsData = old_params;
760 target->paramsLen = old_params_len;
761 old_params = NULL;
762 if (target->rowStatus == SNMP_ROW_NOTINSERVICE &&
763 snmpTargetAddr_rowStatusCheck(target) == 0) {
764 target->rowStatus = SNMP_ROW_NOTREADY;
765 }
766 }
767 }
768 }
769
770 return SNMP_ERR_NOERROR;
771 } /* write_snmpTargetAddrParams */
772
773 int
774 write_snmpTargetAddrStorageType(int action,
775 u_char * var_val,
776 u_char var_val_type,
777 size_t var_val_len,
778 u_char * statP,
779 oid * name, size_t name_len)
780 {
781 long long_ret = *((long *) var_val);
782 struct targetAddrTable_struct *target;
783
784 if (action == RESERVE1) {
785 if (var_val_type != ASN_INTEGER) {
786 DEBUGMSGTL(("snmpTargetAddrEntry",
787 "write to snmpTargetAddrStorageType not ASN_INTEGER\n"));
788 return SNMP_ERR_WRONGTYPE;
789 }
790 if (var_val_len != sizeof(long)) {
791 DEBUGMSGTL(("snmpTargetAddrEntry",
792 "write to snmpTargetAddrStorageType: bad length\n"));
793 return SNMP_ERR_WRONGLENGTH;
794 }
795 if (long_ret != SNMP_STORAGE_OTHER &&
796 long_ret != SNMP_STORAGE_VOLATILE &&
797 long_ret != SNMP_STORAGE_NONVOLATILE) {
798 DEBUGMSGTL(("snmpTargetAddrEntry",
799 "write to snmpTargetAddrStorageType: attempted storage type not a valid"));
800 DEBUGMSG(("snmpTargetAddrEntry",
801 " value of other(%d), volatile(%d), or nonvolatile(%d)\n",
802 SNMP_STORAGE_OTHER, SNMP_STORAGE_VOLATILE,
803 SNMP_STORAGE_NONVOLATILE));
804 return SNMP_ERR_WRONGVALUE;
805 }
806 } else if (action == RESERVE2) {
807 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
808 SNMPTARGETADDRSTORAGETYPECOLUMN;
809 if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
810 snmpTargetAddrOIDLen,
811 name, &name_len,
812 1)) == NULL) {
813 DEBUGMSGTL(("snmpTargetAddrEntry",
814 "write to snmpTargetAddrStorageType: BAD OID\n"));
815 return SNMP_ERR_INCONSISTENTNAME;
816 } else {
817 if (target->storageType == SNMP_STORAGE_PERMANENT ||
818 target->storageType == SNMP_STORAGE_READONLY) {
819 DEBUGMSGTL(("snmpTargetAddrEntry",
820 "write to snmpTargetAddrStorageType: row has unchangeable storage status: %d\n",
821 target->storageType));
822 return SNMP_ERR_WRONGVALUE;
823 }
824 }
825 } else if (action == COMMIT) {
826 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
827 SNMPTARGETADDRSTORAGETYPECOLUMN;
828 if ((target = search_snmpTargetAddrTable(snmpTargetAddrOID,
829 snmpTargetAddrOIDLen,
830 name, &name_len,
831 1)) != NULL) {
832 target->storageType = long_ret;
833 }
834 snmp_store_needed(NULL);
835 }
836
837 return SNMP_ERR_NOERROR;
838 } /* write_snmpTargetAddrStorageType */
839
840
841 /*
842 * snmpTargeAddr_createNewRow is called from write_snmpTargetAddrRowStatus
843 * when a new row is required. It creates a new row with
844 * the index of the passed in 'name' (i.e. full index OID) and
845 * adds it to the linked list. 'name' should be the full OID of the new index.
846 * It passes back 0 if unsuccessfull.
847 */
848 int
849 snmpTargetAddr_createNewRow(oid * name, size_t name_len)
850 {
851 size_t newNameLen;
852 int i;
853 struct targetAddrTable_struct *temp_struct;
854
855 /*
856 * setup a new snmpTargetAddrTable structure and add it to the list
857 */
858 newNameLen = name_len - snmpTargetAddrOIDLen;
859 if (newNameLen > 0) {
860 temp_struct = snmpTargetAddrTable_create();
861 if (!temp_struct)
862 return SNMP_ERR_GENERR;
863 temp_struct->nameData = (char *) malloc(newNameLen+1);
864 if (temp_struct->nameData == NULL) {
865 snmpTargetAddrTable_dispose(temp_struct);
866 return 0;
867 }
868
869 temp_struct->nameLen = newNameLen;
870 for (i = 0; i < (int) newNameLen; i++) {
871 temp_struct->nameData[i] = (char) name[i + snmpTargetAddrOIDLen];
872 }
873 temp_struct->nameData[i] = 0; /* just-in-case null term */
874
875 temp_struct->rowStatus = SNMP_ROW_NOTREADY;
876
877 snmpTargetAddrTable_add(temp_struct);
878
879 return 1;
880 }
881
882 return 0;
883 } /* snmpTargetAddr_createNewRow */
884
885
886 /*
887 * Assign a value to the Row Status variable
888 */
889 int
890 write_snmpTargetAddrRowStatus(int action,
891 u_char * var_val,
892 u_char var_val_type,
893 size_t var_val_len,
894 u_char * statP, oid * name, size_t name_len)
895 {
896 static long value;
897 struct targetAddrTable_struct *target = NULL;
898
899 if (action == RESERVE1) {
900 value = *((long *) var_val);
901 if (var_val_type != ASN_INTEGER) {
902 DEBUGMSGTL(("snmpTargetAddrEntry",
903 "write to snmpTargetAddrRowStatus not ASN_INTEGER\n"));
904 return SNMP_ERR_WRONGTYPE;
905 }
906 if (var_val_len != sizeof(long)) {
907 DEBUGMSGTL(("snmpTargetAddrEntry",
908 "write to snmpTargetAddrRowStatus: bad length\n"));
909 return SNMP_ERR_WRONGLENGTH;
910 }
911 if (value == RS_NOTREADY || value < 1 || value > 6) {
912 return SNMP_ERR_WRONGVALUE;
913 }
914
915 /*
916 * Check index value is reasonable.
917 */
918
919 if (name_len < snmpTargetAddrOIDLen + 1 ||
920 name_len > snmpTargetAddrOIDLen + 32) {
921 DEBUGMSGTL(("snmpTargetAddrEntry", "bad index length %d\n",
922 (int)(name_len - snmpTargetAddrOIDLen)));
923 return SNMP_ERR_NOCREATION;
924 }
925
926 /*
927 * Search for struct in linked list.
928 */
929
930 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
931 SNMPTARGETADDRROWSTATUSCOLUMN;
932 target =
933 search_snmpTargetAddrTable(snmpTargetAddrOID,
934 snmpTargetAddrOIDLen, name,
935 &name_len, 1);
936
937 if (target != NULL) {
938 if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
939 value = RS_NOTREADY;
940 return SNMP_ERR_INCONSISTENTVALUE;
941 }
942 if (target->storageType == SNMP_STORAGE_READONLY) {
943 DEBUGMSGTL(("snmpTargetAddrEntry", "row is read only\n"));
944 return SNMP_ERR_NOTWRITABLE;
945 }
946 if (target->storageType == SNMP_STORAGE_PERMANENT) {
947 if (value == RS_DESTROY) {
948 DEBUGMSGTL(("snmpTargetAddrEntry",
949 "unable to destroy permanent row\n"));
950 return SNMP_ERR_INCONSISTENTVALUE;
951 }
952 }
953 } else {
954 if (value == RS_ACTIVE || value == RS_NOTINSERVICE) {
955 return SNMP_ERR_INCONSISTENTVALUE;
956 }
957 if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
958 if (snmpTargetAddr_createNewRow(name, name_len) == 0) {
959 DEBUGMSGTL(("snmpTargetAddrEntry",
960 "couldn't malloc() new row\n"));
961 return SNMP_ERR_RESOURCEUNAVAILABLE;
962 }
963 }
964 }
965 } else if (action == ACTION) {
966 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
967 SNMPTARGETADDRROWSTATUSCOLUMN;
968 target =
969 search_snmpTargetAddrTable(snmpTargetAddrOID,
970 snmpTargetAddrOIDLen, name,
971 &name_len, 1);
972
973 if (target != NULL) {
974 if (value == RS_CREATEANDGO) {
975 /*
976 * Check whether all the required objects have been set.
977 */
978 if (snmpTargetAddr_rowStatusCheck(target)) {
979 target->rowStatus = RS_ACTIVE;
980 } else {
981 target->rowStatus = RS_NOTREADY;
982 }
983 } else if (value == RS_CREATEANDWAIT) {
984 /*
985 * Check whether all the required objects have been set.
986 */
987 if (snmpTargetAddr_rowStatusCheck(target)) {
988 target->rowStatus = RS_NOTINSERVICE;
989 } else {
990 target->rowStatus = RS_NOTREADY;
991 }
992 } else if (value == RS_ACTIVE) {
993 if (target->rowStatus == RS_NOTINSERVICE) {
994 target->rowStatus = RS_ACTIVE;
995 } else if (target->rowStatus == RS_NOTREADY) {
996 return SNMP_ERR_INCONSISTENTVALUE;
997 }
998 } else if (value == RS_NOTINSERVICE) {
999 if (target->rowStatus == RS_ACTIVE) {
1000 target->rowStatus = RS_NOTINSERVICE;
1001 } else if (target->rowStatus == RS_NOTREADY) {
1002 return SNMP_ERR_INCONSISTENTVALUE;
1003 }
1004 }
1005 }
1006 } else if (action == COMMIT) {
1007 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
1008 SNMPTARGETADDRROWSTATUSCOLUMN;
1009 target =
1010 search_snmpTargetAddrTable(snmpTargetAddrOID,
1011 snmpTargetAddrOIDLen, name,
1012 &name_len, 1);
1013 if (target != NULL) {
1014 if (value == RS_DESTROY) {
1015 snmpTargetAddrTable_remove(target);
1016 }
1017 if (value == RS_NOTINSERVICE) {
1018 if (target->sess != NULL) {
1019 snmp_close(target->sess);
1020 target->sess = NULL;
1021 }
1022 }
1023 }
1024 snmp_store_needed(NULL);
1025 } else if (action == UNDO || action == FREE) {
1026 snmpTargetAddrOID[snmpTargetAddrOIDLen - 1] =
1027 SNMPTARGETADDRROWSTATUSCOLUMN;
1028 target =
1029 search_snmpTargetAddrTable(snmpTargetAddrOID,
1030 snmpTargetAddrOIDLen, name,
1031 &name_len, 1);
1032 if (value == RS_CREATEANDGO || value == RS_CREATEANDWAIT) {
1033 if (target != NULL) {
1034 snmpTargetAddrTable_remove(target);
1035 }
1036 }
1037 }
1038 return SNMP_ERR_NOERROR;
1039 } /* write_snmpTargetAddrRowStatus */
1040
1041
1042
1043 int
1044 write_targetSpinLock(int action,
1045 u_char * var_val,
1046 u_char var_val_type,
1047 size_t var_val_len,
1048 u_char * statP, oid * name, size_t name_len)
1049 {
1050 if (action == RESERVE1) {
1051 if (var_val_type != ASN_INTEGER) {
1052 return SNMP_ERR_WRONGTYPE;
1053 }
1054 if (var_val_len != sizeof(unsigned long)) {
1055 return SNMP_ERR_WRONGLENGTH;
1056 }
1057 if (*((unsigned long *) var_val) != snmpTargetSpinLock) {
1058 return SNMP_ERR_INCONSISTENTVALUE;
1059 }
1060 } else if (action == COMMIT) {
1061 if (snmpTargetSpinLock == 2147483647) {
1062 snmpTargetSpinLock = 0;
1063 } else {
1064 snmpTargetSpinLock++;
1065 }
1066 }
1067 return SNMP_ERR_NOERROR;
1068 }
1069
1070 #endif /* !NETSNMP_NO_WRITE_SUPPORT */
1071
1072
1073 u_char *
1074 var_targetSpinLock(struct variable * vp,
1075 oid * name,
1076 size_t * length,
1077 int exact,
1078 size_t * var_len, WriteMethod ** write_method)
1079 {
1080 if (header_generic(vp, name, length, exact, var_len, write_method) ==
1081 MATCH_FAILED) {
1082 #ifndef NETSNMP_NO_WRITE_SUPPORT
1083 *write_method = write_targetSpinLock;
1084 #else
1085 *write_method = NULL;
1086 #endif /* !NETSNMP_NO_WRITE_SUPPORT */
1087 return NULL;
1088 }
1089 if (vp->magic == SNMPTARGETSPINLOCK) {
1090 *var_len = sizeof(unsigned long);
1091 #ifndef NETSNMP_NO_WRITE_SUPPORT
1092 *write_method = write_targetSpinLock;
1093 #else
1094 *write_method = NULL;
1095 #endif /* !NETSNMP_NO_WRITE_SUPPORT */
1096 return (u_char *) & (snmpTargetSpinLock);
1097 }
1098 return NULL;
1099 }