00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <net-snmp/net-snmp-config.h>
00011 #include <signal.h>
00012 #if HAVE_STRING_H
00013 #include <string.h>
00014 #endif
00015 #if HAVE_STDLIB_H
00016 #include <stdlib.h>
00017 #endif
00018 #include <sys/types.h>
00019 #include <stdio.h>
00020 #include <fcntl.h>
00021 #if HAVE_WINSOCK_H
00022 #include <winsock.h>
00023 #endif
00024 #if TIME_WITH_SYS_TIME
00025 # ifdef WIN32
00026 # include <sys/timeb.h>
00027 # else
00028 # include <sys/time.h>
00029 # endif
00030 # include <time.h>
00031 #else
00032 # if HAVE_SYS_TIME_H
00033 # include <sys/time.h>
00034 # else
00035 # include <time.h>
00036 # endif
00037 #endif
00038 #if HAVE_NETINET_IN_H
00039 #include <netinet/in.h>
00040 #endif
00041
00042 #include <net-snmp/net-snmp-includes.h>
00043 #include <net-snmp/agent/net-snmp-agent-includes.h>
00044 #include <net-snmp/agent/agent_callbacks.h>
00045 #include <net-snmp/agent/agent_index.h>
00046
00047 #include "snmpd.h"
00048 #include "mibgroup/struct.h"
00049 #include <net-snmp/agent/table.h>
00050 #include <net-snmp/agent/table_iterator.h>
00051 #include "mib_module_includes.h"
00052
00053 #ifdef USING_AGENTX_SUBAGENT_MODULE
00054 #include "agentx/subagent.h"
00055 #include "agentx/client.h"
00056 #endif
00057
00058
00059
00060
00061
00062 struct snmp_index {
00063 netsnmp_variable_list *varbind;
00064 int allocated;
00065 netsnmp_session *session;
00066 struct snmp_index *next_oid;
00067 struct snmp_index *prev_oid;
00068 struct snmp_index *next_idx;
00069 } *snmp_index_head = NULL;
00070
00071 extern netsnmp_session *main_session;
00072
00073
00074
00075
00076
00077
00078 char *
00079 register_string_index(oid * name, size_t name_len, char *cp)
00080 {
00081 netsnmp_variable_list varbind, *res;
00082
00083 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00084 varbind.type = ASN_OCTET_STR;
00085 snmp_set_var_objid(&varbind, name, name_len);
00086 if (cp != ANY_STRING_INDEX) {
00087 snmp_set_var_value(&varbind, (u_char *) cp, strlen(cp));
00088 res = register_index(&varbind, ALLOCATE_THIS_INDEX, main_session);
00089 } else {
00090 res = register_index(&varbind, ALLOCATE_ANY_INDEX, main_session);
00091 }
00092
00093 if (res == NULL) {
00094 return NULL;
00095 } else {
00096 char *rv = strdup(res->val.string);
00097 free(res);
00098 return rv;
00099 }
00100 }
00101
00102 int
00103 register_int_index(oid * name, size_t name_len, int val)
00104 {
00105 netsnmp_variable_list varbind, *res;
00106
00107 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00108 varbind.type = ASN_INTEGER;
00109 snmp_set_var_objid(&varbind, name, name_len);
00110 varbind.val.string = varbind.buf;
00111 if (val != ANY_INTEGER_INDEX) {
00112 varbind.val_len = sizeof(long);
00113 *varbind.val.integer = val;
00114 res = register_index(&varbind, ALLOCATE_THIS_INDEX, main_session);
00115 } else {
00116 res = register_index(&varbind, ALLOCATE_ANY_INDEX, main_session);
00117 }
00118
00119 if (res == NULL) {
00120 return -1;
00121 } else {
00122 int rv = *(res->val.integer);
00123 free(res);
00124 return rv;
00125 }
00126 }
00127
00128
00129
00130
00131
00132
00133 netsnmp_variable_list *
00134 register_oid_index(oid * name, size_t name_len,
00135 oid * value, size_t value_len)
00136 {
00137 netsnmp_variable_list varbind;
00138
00139 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00140 varbind.type = ASN_OBJECT_ID;
00141 snmp_set_var_objid(&varbind, name, name_len);
00142 if (value != ANY_OID_INDEX) {
00143 snmp_set_var_value(&varbind, (u_char *) value,
00144 value_len * sizeof(oid));
00145 return register_index(&varbind, ALLOCATE_THIS_INDEX, main_session);
00146 } else {
00147 return register_index(&varbind, ALLOCATE_ANY_INDEX, main_session);
00148 }
00149 }
00150
00151
00152
00153
00154
00155
00156 netsnmp_variable_list *
00157 register_index(netsnmp_variable_list * varbind, int flags,
00158 netsnmp_session * ss)
00159 {
00160 netsnmp_variable_list *rv = NULL;
00161 struct snmp_index *new_index, *idxptr, *idxptr2;
00162 struct snmp_index *prev_oid_ptr, *prev_idx_ptr;
00163 int res, res2, i;
00164
00165 DEBUGMSGTL(("register_index", "register "));
00166 DEBUGMSGVAR(("register_index", varbind));
00167 DEBUGMSG(("register_index", "for session %08p\n", ss));
00168
00169 #if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(TESTING)
00170 if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
00171 NETSNMP_DS_AGENT_ROLE) == SUB_AGENT) {
00172 return (agentx_register_index(ss, varbind, flags));
00173 }
00174 #endif
00175
00176
00177
00178 prev_oid_ptr = NULL;
00179 prev_idx_ptr = NULL;
00180 res = 1;
00181 res2 = 1;
00182 for (idxptr = snmp_index_head; idxptr != NULL;
00183 prev_oid_ptr = idxptr, idxptr = idxptr->next_oid) {
00184 if ((res = snmp_oid_compare(varbind->name, varbind->name_length,
00185 idxptr->varbind->name,
00186 idxptr->varbind->name_length)) <= 0)
00187 break;
00188 }
00189
00190
00191
00192
00193 if (res == 0 && idxptr) {
00194 if (varbind->type != idxptr->varbind->type)
00195 return NULL;
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206 if (flags & ALLOCATE_ANY_INDEX) {
00207 for (idxptr2 = idxptr; idxptr2 != NULL;
00208 prev_idx_ptr = idxptr2, idxptr2 = idxptr2->next_idx) {
00209
00210 if (flags == ALLOCATE_ANY_INDEX && !(idxptr2->allocated)) {
00211 if ((rv =
00212 snmp_clone_varbind(idxptr2->varbind)) != NULL) {
00213 idxptr2->session = ss;
00214 idxptr2->allocated = 1;
00215 }
00216 return rv;
00217 }
00218 }
00219 } else {
00220 for (idxptr2 = idxptr; idxptr2 != NULL;
00221 prev_idx_ptr = idxptr2, idxptr2 = idxptr2->next_idx) {
00222 switch (varbind->type) {
00223 case ASN_INTEGER:
00224 res2 =
00225 (*varbind->val.integer -
00226 *idxptr2->varbind->val.integer);
00227 break;
00228 case ASN_OCTET_STR:
00229 i = SNMP_MIN(varbind->val_len,
00230 idxptr2->varbind->val_len);
00231 res2 =
00232 memcmp(varbind->val.string,
00233 idxptr2->varbind->val.string, i);
00234 break;
00235 case ASN_OBJECT_ID:
00236 res2 =
00237 snmp_oid_compare(varbind->val.objid,
00238 varbind->val_len / sizeof(oid),
00239 idxptr2->varbind->val.objid,
00240 idxptr2->varbind->val_len /
00241 sizeof(oid));
00242 break;
00243 default:
00244 return NULL;
00245 }
00246 if (res2 <= 0)
00247 break;
00248 }
00249 if (res2 == 0) {
00250 if (idxptr2->allocated) {
00251
00252
00253
00254 return NULL;
00255 } else {
00256
00257
00258
00259
00260 if ((rv =
00261 snmp_clone_varbind(idxptr2->varbind)) != NULL) {
00262 idxptr2->session = ss;
00263 idxptr2->allocated = 1;
00264 }
00265 return rv;
00266 }
00267 }
00268 }
00269 }
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 new_index = (struct snmp_index *) calloc(1, sizeof(struct snmp_index));
00302 if (new_index == NULL)
00303 return NULL;
00304
00305 if (0 == snmp_varlist_add_variable(&new_index->varbind,
00306 varbind->name,
00307 varbind->name_length,
00308 varbind->type,
00309 varbind->val.string,
00310 varbind->val_len)) {
00311
00312
00313
00314 free(new_index);
00315 return NULL;
00316 }
00317 new_index->session = ss;
00318 new_index->allocated = 1;
00319
00320 if (varbind->type == ASN_OCTET_STR && flags == ALLOCATE_THIS_INDEX)
00321 new_index->varbind->val.string[new_index->varbind->val_len] = 0;
00322
00323
00324
00325
00326
00327
00328
00329 if (flags & ALLOCATE_ANY_INDEX) {
00330 if (prev_idx_ptr) {
00331 if (snmp_clone_var(prev_idx_ptr->varbind, new_index->varbind)
00332 != 0) {
00333 free(new_index);
00334 return NULL;
00335 }
00336 } else
00337 new_index->varbind->val.string = new_index->varbind->buf;
00338
00339 switch (varbind->type) {
00340 case ASN_INTEGER:
00341 if (prev_idx_ptr) {
00342 (*new_index->varbind->val.integer)++;
00343 } else
00344 *(new_index->varbind->val.integer) = 1;
00345 new_index->varbind->val_len = sizeof(long);
00346 break;
00347 case ASN_OCTET_STR:
00348 if (prev_idx_ptr) {
00349 i = new_index->varbind->val_len - 1;
00350 while (new_index->varbind->buf[i] == 'z') {
00351 new_index->varbind->buf[i] = 'a';
00352 i--;
00353 if (i < 0) {
00354 i = new_index->varbind->val_len;
00355 new_index->varbind->buf[i] = 'a';
00356 new_index->varbind->buf[i + 1] = 0;
00357 }
00358 }
00359 new_index->varbind->buf[i]++;
00360 } else
00361 strcpy((char *) new_index->varbind->buf, "aaaa");
00362 new_index->varbind->val_len =
00363 strlen((char *) new_index->varbind->buf);
00364 break;
00365 case ASN_OBJECT_ID:
00366 if (prev_idx_ptr) {
00367 i = prev_idx_ptr->varbind->val_len / sizeof(oid) - 1;
00368 while (new_index->varbind->val.objid[i] == 255) {
00369 new_index->varbind->val.objid[i] = 1;
00370 i--;
00371 if (i == 0 && new_index->varbind->val.objid[0] == 2) {
00372 new_index->varbind->val.objid[0] = 1;
00373 i = new_index->varbind->val_len / sizeof(oid);
00374 new_index->varbind->val.objid[i] = 0;
00375 new_index->varbind->val_len += sizeof(oid);
00376 }
00377 }
00378 new_index->varbind->val.objid[i]++;
00379 } else {
00380
00381
00382
00383
00384
00385 if ((varbind->name_length + 1) * sizeof(oid) <= 40) {
00386 for (i = 0; i < (int) varbind->name_length; i++)
00387 new_index->varbind->val.objid[i] =
00388 varbind->name[i];
00389 new_index->varbind->val.objid[varbind->name_length] =
00390 1;
00391 new_index->varbind->val_len =
00392 (varbind->name_length + 1) * sizeof(oid);
00393 } else {
00394
00395
00396
00397 i = 40 / sizeof(oid);
00398 if (i > 4)
00399 i = 4;
00400 new_index->varbind->val_len = i * (sizeof(oid));
00401 for (i--; i >= 0; i--)
00402 new_index->varbind->val.objid[i] = 1;
00403 }
00404 }
00405 break;
00406 default:
00407 snmp_free_var(new_index->varbind);
00408 free(new_index);
00409 return NULL;
00410 }
00411 }
00412
00413
00414
00415
00416
00417 if ((rv = snmp_clone_varbind(new_index->varbind)) == NULL) {
00418 snmp_free_var(new_index->varbind);
00419 free(new_index);
00420 return NULL;
00421 }
00422
00423
00424
00425
00426
00427
00428
00429 if (prev_idx_ptr) {
00430 new_index->next_idx = prev_idx_ptr->next_idx;
00431 new_index->next_oid = prev_idx_ptr->next_oid;
00432 prev_idx_ptr->next_idx = new_index;
00433 } else {
00434 if (res == 0 && idxptr) {
00435 new_index->next_idx = idxptr;
00436 new_index->next_oid = idxptr->next_oid;
00437 } else {
00438 new_index->next_idx = NULL;
00439 new_index->next_oid = idxptr;
00440 }
00441
00442 if (prev_oid_ptr) {
00443 while (prev_oid_ptr) {
00444 prev_oid_ptr->next_oid = new_index;
00445 prev_oid_ptr = prev_oid_ptr->next_idx;
00446 }
00447 } else
00448 snmp_index_head = new_index;
00449 }
00450 return rv;
00451 }
00452
00453
00454
00455
00456
00457 int
00458 release_index(netsnmp_variable_list * varbind)
00459 {
00460 return (unregister_index(varbind, TRUE, NULL));
00461 }
00462
00463
00464
00465
00466
00467 int
00468 remove_index(netsnmp_variable_list * varbind, netsnmp_session * ss)
00469 {
00470 return (unregister_index(varbind, FALSE, ss));
00471 }
00472
00473 void
00474 unregister_index_by_session(netsnmp_session * ss)
00475 {
00476 struct snmp_index *idxptr, *idxptr2;
00477 for (idxptr = snmp_index_head; idxptr != NULL;
00478 idxptr = idxptr->next_oid)
00479 for (idxptr2 = idxptr; idxptr2 != NULL;
00480 idxptr2 = idxptr2->next_idx)
00481 if (idxptr2->session == ss) {
00482 idxptr2->allocated = 0;
00483 idxptr2->session = NULL;
00484 }
00485 }
00486
00487
00488 int
00489 unregister_index(netsnmp_variable_list * varbind, int remember,
00490 netsnmp_session * ss)
00491 {
00492 struct snmp_index *idxptr, *idxptr2;
00493 struct snmp_index *prev_oid_ptr, *prev_idx_ptr;
00494 int res, res2, i;
00495
00496 #if defined(USING_AGENTX_SUBAGENT_MODULE) && !defined(TESTING)
00497 if (netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
00498 NETSNMP_DS_AGENT_ROLE) == SUB_AGENT) {
00499 return (agentx_unregister_index(ss, varbind));
00500 }
00501 #endif
00502
00503
00504
00505 prev_oid_ptr = NULL;
00506 prev_idx_ptr = NULL;
00507 res = 1;
00508 res2 = 1;
00509 for (idxptr = snmp_index_head; idxptr != NULL;
00510 prev_oid_ptr = idxptr, idxptr = idxptr->next_oid) {
00511 if ((res = snmp_oid_compare(varbind->name, varbind->name_length,
00512 idxptr->varbind->name,
00513 idxptr->varbind->name_length)) <= 0)
00514 break;
00515 }
00516
00517 if (res != 0)
00518 return INDEX_ERR_NOT_ALLOCATED;
00519 if (varbind->type != idxptr->varbind->type)
00520 return INDEX_ERR_WRONG_TYPE;
00521
00522 for (idxptr2 = idxptr; idxptr2 != NULL;
00523 prev_idx_ptr = idxptr2, idxptr2 = idxptr2->next_idx) {
00524 i = SNMP_MIN(varbind->val_len, idxptr2->varbind->val_len);
00525 res2 =
00526 memcmp(varbind->val.string, idxptr2->varbind->val.string, i);
00527 if (res2 <= 0)
00528 break;
00529 }
00530 if (res2 != 0 || (res2 == 0 && !idxptr2->allocated)) {
00531 return INDEX_ERR_NOT_ALLOCATED;
00532 }
00533 if (ss != idxptr2->session)
00534 return INDEX_ERR_WRONG_SESSION;
00535
00536
00537
00538
00539
00540
00541
00542 if (remember) {
00543 idxptr2->allocated = 0;
00544 idxptr2->session = NULL;
00545 return SNMP_ERR_NOERROR;
00546 }
00547
00548
00549
00550
00551
00552 if (prev_idx_ptr) {
00553 prev_idx_ptr->next_idx = idxptr2->next_idx;
00554 } else if (prev_oid_ptr) {
00555 if (idxptr2->next_idx)
00556 prev_idx_ptr = idxptr2->next_idx;
00557 else
00558 prev_idx_ptr = idxptr2->next_oid;
00559 while (prev_oid_ptr) {
00560 prev_oid_ptr->next_oid = prev_idx_ptr;
00561 prev_oid_ptr = prev_oid_ptr->next_idx;
00562 }
00563 } else {
00564 if (idxptr2->next_idx)
00565 snmp_index_head = idxptr2->next_idx;
00566 else
00567 snmp_index_head = idxptr2->next_oid;
00568 }
00569 snmp_free_var(idxptr2->varbind);
00570 free(idxptr2);
00571 return SNMP_ERR_NOERROR;
00572 }
00573
00574 int
00575 unregister_string_index(oid * name, size_t name_len, char *cp)
00576 {
00577 netsnmp_variable_list varbind;
00578
00579 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00580 varbind.type = ASN_OCTET_STR;
00581 snmp_set_var_objid(&varbind, name, name_len);
00582 snmp_set_var_value(&varbind, (u_char *) cp, strlen(cp));
00583 return (unregister_index(&varbind, FALSE, main_session));
00584 }
00585
00586 int
00587 unregister_int_index(oid * name, size_t name_len, int val)
00588 {
00589 netsnmp_variable_list varbind;
00590
00591 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00592 varbind.type = ASN_INTEGER;
00593 snmp_set_var_objid(&varbind, name, name_len);
00594 varbind.val.string = varbind.buf;
00595 varbind.val_len = sizeof(long);
00596 *varbind.val.integer = val;
00597 return (unregister_index(&varbind, FALSE, main_session));
00598 }
00599
00600 int
00601 unregister_oid_index(oid * name, size_t name_len,
00602 oid * value, size_t value_len)
00603 {
00604 netsnmp_variable_list varbind;
00605
00606 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00607 varbind.type = ASN_OBJECT_ID;
00608 snmp_set_var_objid(&varbind, name, name_len);
00609 snmp_set_var_value(&varbind, (u_char *) value,
00610 value_len * sizeof(oid));
00611 return (unregister_index(&varbind, FALSE, main_session));
00612 }
00613
00614 void
00615 dump_idx_registry(void)
00616 {
00617 struct snmp_index *idxptr, *idxptr2;
00618 u_char *sbuf = NULL, *ebuf = NULL;
00619 size_t sbuf_len = 0, sout_len = 0, ebuf_len = 0, eout_len = 0;
00620
00621 if (snmp_index_head != NULL) {
00622 printf("\nIndex Allocations:\n");
00623 }
00624
00625 for (idxptr = snmp_index_head; idxptr != NULL;
00626 idxptr = idxptr->next_oid) {
00627 sout_len = 0;
00628 if (sprint_realloc_objid(&sbuf, &sbuf_len, &sout_len, 1,
00629 idxptr->varbind->name,
00630 idxptr->varbind->name_length)) {
00631 printf("%s indexes:\n", sbuf);
00632 } else {
00633 printf("%s [TRUNCATED] indexes:\n", sbuf);
00634 }
00635
00636 for (idxptr2 = idxptr; idxptr2 != NULL;
00637 idxptr2 = idxptr2->next_idx) {
00638 switch (idxptr2->varbind->type) {
00639 case ASN_INTEGER:
00640 printf(" %ld for session %8p, allocated %d\n",
00641 *idxptr2->varbind->val.integer, idxptr2->session,
00642 idxptr2->allocated);
00643 break;
00644 case ASN_OCTET_STR:
00645 printf(" \"%s\" for session %8p, allocated %d\n",
00646 idxptr2->varbind->val.string, idxptr2->session,
00647 idxptr2->allocated);
00648 break;
00649 case ASN_OBJECT_ID:
00650 eout_len = 0;
00651 if (sprint_realloc_objid(&ebuf, &ebuf_len, &eout_len, 1,
00652 idxptr2->varbind->val.objid,
00653 idxptr2->varbind->val_len /
00654 sizeof(oid))) {
00655 printf(" %s for session %8p, allocated %d\n", ebuf,
00656 idxptr2->session, idxptr2->allocated);
00657 } else {
00658 printf
00659 (" %s [TRUNCATED] for sess %8p, allocated %d\n",
00660 ebuf, idxptr2->session, idxptr2->allocated);
00661 }
00662 break;
00663 default:
00664 printf("unsupported type (%d/0x%02x)\n",
00665 idxptr2->varbind->type, idxptr2->varbind->type);
00666 }
00667 }
00668 }
00669
00670 if (sbuf != NULL) {
00671 free(sbuf);
00672 }
00673 if (ebuf != NULL) {
00674 free(ebuf);
00675 }
00676 }
00677
00678 unsigned long
00679 count_indexes(oid * name, size_t namelen, int include_unallocated)
00680 {
00681 struct snmp_index *i = NULL, *j = NULL;
00682 unsigned long n = 0;
00683
00684 for (i = snmp_index_head; i != NULL; i = i->next_oid) {
00685 if (netsnmp_oid_equals(name, namelen,
00686 i->varbind->name,
00687 i->varbind->name_length) == 0) {
00688 for (j = i; j != NULL; j = j->next_idx) {
00689 if (j->allocated || include_unallocated) {
00690 n++;
00691 }
00692 }
00693 }
00694 }
00695 return n;
00696 }
00697
00698
00699 #ifdef TESTING
00700 netsnmp_variable_list varbind;
00701 netsnmp_session main_sess, *main_session = &main_sess;
00702
00703 void
00704 test_string_register(int n, char *cp)
00705 {
00706 varbind->name[4] = n;
00707 if (register_string_index(varbind->name, varbind.name_length, cp) ==
00708 NULL)
00709 printf("allocating %s failed\n", cp);
00710 }
00711
00712 void
00713 test_int_register(int n, int val)
00714 {
00715 varbind->name[4] = n;
00716 if (register_int_index(varbind->name, varbind.name_length, val) == -1)
00717 printf("allocating %d/%d failed\n", n, val);
00718 }
00719
00720 void
00721 test_oid_register(int n, int subid)
00722 {
00723 netsnmp_variable_list *res;
00724
00725 varbind->name[4] = n;
00726 if (subid != -1) {
00727 varbind->val.objid[5] = subid;
00728 res = register_oid_index(varbind->name, varbind.name_length,
00729 varbind->val.objid,
00730 varbind->val_len / sizeof(oid));
00731 } else
00732 res =
00733 register_oid_index(varbind->name, varbind.name_length, NULL,
00734 0);
00735
00736 if (res == NULL)
00737 printf("allocating %d/%d failed\n", n, subid);
00738 }
00739
00740 void
00741 main(int argc, char argv[])
00742 {
00743 oid name[] = { 1, 2, 3, 4, 0 };
00744 int i;
00745
00746 memset(&varbind, 0, sizeof(netsnmp_variable_list));
00747 snmp_set_var_objid(&varbind, name, 5);
00748 varbind->type = ASN_OCTET_STR;
00749
00750
00751
00752
00753 test_string_register(20, "empty OID");
00754 test_string_register(10, "first OID");
00755 test_string_register(40, "last OID");
00756 test_string_register(30, "middle OID");
00757
00758
00759
00760
00761 test_string_register(25, "eee: empty IDX");
00762 test_string_register(25, "aaa: first IDX");
00763 test_string_register(25, "zzz: last IDX");
00764 test_string_register(25, "mmm: middle IDX");
00765 printf("This next one should fail....\n");
00766 test_string_register(25, "eee: empty IDX");
00767 printf("done\n");
00768
00769
00770
00771
00772 test_string_register(5, "eee: empty initial IDX");
00773 test_string_register(5, "aaa: replace initial IDX");
00774
00775
00776
00777
00778 dump_idx_registry();
00779 unregister_index_by_session(main_session);
00780
00781
00782
00783
00784 test_int_register(110, -1);
00785 test_int_register(110, -1);
00786 test_int_register(110, 10);
00787 printf("This next one should fail....\n");
00788 test_int_register(110, 10);
00789 printf("done\n");
00790 test_int_register(110, -1);
00791 test_int_register(110, 5);
00792
00793
00794
00795
00796 test_string_register(120, NULL);
00797 test_string_register(120, NULL);
00798 test_string_register(120, "aaaz");
00799 test_string_register(120, NULL);
00800 test_string_register(120, "zzzz");
00801 test_string_register(120, NULL);
00802
00803
00804
00805
00806
00807 test_oid_register(130, -1);
00808 test_oid_register(130, -1);
00809
00810 varbind->val_len = varbind.name_length * sizeof(oid);
00811 memcpy(varbind->buf, varbind.name, varbind.val_len);
00812 varbind->val.objid = (oid *) varbind.buf;
00813 varbind->val_len += sizeof(oid);
00814
00815 test_oid_register(130, 255);
00816 test_oid_register(130, -1);
00817 test_oid_register(130, 100);
00818 printf("This next one should fail....\n");
00819 test_oid_register(130, 100);
00820 printf("done\n");
00821
00822 varbind->val.objid = (oid *) varbind.buf;
00823 for (i = 0; i < 6; i++)
00824 varbind->val.objid[i] = 255;
00825 varbind->val.objid[0] = 1;
00826 test_oid_register(130, 255);
00827 test_oid_register(130, -1);
00828
00829 for (i = 0; i < 6; i++)
00830 varbind->val.objid[i] = 255;
00831 varbind->val.objid[0] = 2;
00832 test_oid_register(130, 255);
00833 test_oid_register(130, -1);
00834
00835
00836
00837
00838 dump_idx_registry();
00839
00840
00841
00842
00843
00844 printf("The rest of these should fail....\n");
00845 test_oid_register(110, -1);
00846 test_oid_register(110, 100);
00847 test_oid_register(120, -1);
00848 test_oid_register(120, 100);
00849 test_string_register(110, NULL);
00850 test_string_register(110, "aaaa");
00851 test_string_register(130, NULL);
00852 test_string_register(130, "aaaa");
00853 test_int_register(120, -1);
00854 test_int_register(120, 1);
00855 test_int_register(130, -1);
00856 test_int_register(130, 1);
00857 printf("done - this dump should be the same as before\n");
00858 dump_idx_registry();
00859 }
00860 #endif