1 #include <sys/socket.h> 2 #include <sys/time.h> 3 4 #include <ber.h> 5 #include <err.h> 6 #include <stdint.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <time.h> 10 #include <unistd.h> 11 12 #include "regress.h" 13 14 #define MIB_BACKEND_GET MIB_BACKEND, 1 15 #define MIB_BACKEND_GETNEXT MIB_BACKEND, 2 16 #define MIB_BACKEND_GETBULK MIB_BACKEND, 3 17 #define MIB_BACKEND_ERROR MIB_BACKEND, 4 18 19 #define MIB_SUBAGENT_BACKEND_GET MIB_SUBAGENT_BACKEND, 1 20 #define MIB_SUBAGENT_BACKEND_GETNEXT MIB_SUBAGENT_BACKEND, 2 21 #define MIB_SUBAGENT_BACKEND_GETBULK MIB_SUBAGENT_BACKEND, 3 22 #define MIB_SUBAGENT_BACKEND_ERROR MIB_SUBAGENT_BACKEND, 4 23 24 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 25 26 void 27 backend_get_integer(void) 28 { 29 struct sockaddr_storage ss; 30 struct sockaddr *sa = (struct sockaddr *)&ss; 31 socklen_t salen; 32 int snmp_s, ax_s; 33 uint32_t sessionid; 34 struct varbind varbind = { 35 .type = TYPE_NULL, 36 .name = OID_STRUCT(MIB_BACKEND_GET, 1, 0), 37 .data.int32 = 1 38 }; 39 int32_t requestid; 40 char buf[1024]; 41 size_t n; 42 43 ax_s = agentx_connect(axsocket); 44 sessionid = agentx_open(ax_s, 0, 0, 45 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 1), __func__); 46 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 47 OID_ARG(MIB_BACKEND_GET, 1), 0); 48 49 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 50 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 51 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 52 53 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 54 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 55 56 varbind.type = TYPE_INTEGER; 57 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 58 59 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 60 &varbind, 1); 61 } 62 63 void 64 backend_get_octetstring(void) 65 { 66 struct sockaddr_storage ss; 67 struct sockaddr *sa = (struct sockaddr *)&ss; 68 socklen_t salen; 69 int snmp_s, ax_s; 70 uint32_t sessionid; 71 struct varbind varbind = { 72 .type = TYPE_NULL, 73 .name = OID_STRUCT(MIB_BACKEND_GET, 2, 0), 74 .data.octetstring.string = "test", 75 .data.octetstring.len = 4 76 }; 77 int32_t requestid; 78 char buf[1024]; 79 size_t n; 80 81 ax_s = agentx_connect(axsocket); 82 sessionid = agentx_open(ax_s, 0, 0, 83 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 2), __func__); 84 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 85 OID_ARG(MIB_BACKEND_GET, 2), 0); 86 87 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 88 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 89 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 90 91 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 92 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 93 94 varbind.type = TYPE_OCTETSTRING; 95 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 96 97 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 98 &varbind, 1); 99 } 100 101 void 102 backend_get_objectidentifier(void) 103 { 104 struct sockaddr_storage ss; 105 struct sockaddr *sa = (struct sockaddr *)&ss; 106 socklen_t salen; 107 int snmp_s, ax_s; 108 uint32_t sessionid; 109 struct varbind varbind = { 110 .type = TYPE_NULL, 111 .name = OID_STRUCT(MIB_BACKEND_GET, 3, 0), 112 .data.oid = OID_STRUCT(MIB_BACKEND_GET, 3, 0), 113 }; 114 int32_t requestid; 115 char buf[1024]; 116 size_t n; 117 118 ax_s = agentx_connect(axsocket); 119 sessionid = agentx_open(ax_s, 0, 0, 120 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 3), __func__); 121 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 122 OID_ARG(MIB_BACKEND_GET, 3), 0); 123 124 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 125 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 126 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 127 128 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 129 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 130 131 varbind.type = TYPE_OBJECTIDENTIFIER; 132 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 133 134 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 135 &varbind, 1); 136 } 137 138 void 139 backend_get_ipaddress(void) 140 { 141 struct sockaddr_storage ss; 142 struct sockaddr *sa = (struct sockaddr *)&ss; 143 socklen_t salen; 144 int snmp_s, ax_s; 145 uint32_t sessionid; 146 struct varbind varbind = { 147 .type = TYPE_NULL, 148 .name = OID_STRUCT(MIB_BACKEND_GET, 4, 0), 149 .data.octetstring.string = "\0\0\0\0", 150 .data.octetstring.len = 4 151 }; 152 int32_t requestid; 153 char buf[1024]; 154 size_t n; 155 156 ax_s = agentx_connect(axsocket); 157 sessionid = agentx_open(ax_s, 0, 0, 158 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 4), __func__); 159 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 160 OID_ARG(MIB_BACKEND_GET, 4), 0); 161 162 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 163 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 164 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 165 166 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 167 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 168 169 varbind.type = TYPE_IPADDRESS; 170 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 171 172 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 173 &varbind, 1); 174 } 175 176 void 177 backend_get_counter32(void) 178 { 179 struct sockaddr_storage ss; 180 struct sockaddr *sa = (struct sockaddr *)&ss; 181 socklen_t salen; 182 int snmp_s, ax_s; 183 uint32_t sessionid; 184 struct varbind varbind = { 185 .type = TYPE_NULL, 186 .name = OID_STRUCT(MIB_BACKEND_GET, 5, 0), 187 .data.uint32 = 1 188 }; 189 int32_t requestid; 190 char buf[1024]; 191 size_t n; 192 193 ax_s = agentx_connect(axsocket); 194 sessionid = agentx_open(ax_s, 0, 0, 195 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 5), __func__); 196 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 197 OID_ARG(MIB_BACKEND_GET, 5), 0); 198 199 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 200 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 201 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 202 203 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 204 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 205 206 varbind.type = TYPE_COUNTER32; 207 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 208 209 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 210 &varbind, 1); 211 } 212 213 void 214 backend_get_gauge32(void) 215 { 216 struct sockaddr_storage ss; 217 struct sockaddr *sa = (struct sockaddr *)&ss; 218 socklen_t salen; 219 int snmp_s, ax_s; 220 uint32_t sessionid; 221 struct varbind varbind = { 222 .type = TYPE_NULL, 223 .name = OID_STRUCT(MIB_BACKEND_GET, 6, 0), 224 .data.uint32 = 1 225 }; 226 int32_t requestid; 227 char buf[1024]; 228 size_t n; 229 230 ax_s = agentx_connect(axsocket); 231 sessionid = agentx_open(ax_s, 0, 0, 232 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 6), __func__); 233 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 234 OID_ARG(MIB_BACKEND_GET, 6), 0); 235 236 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 237 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 238 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 239 240 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 241 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 242 243 varbind.type = TYPE_GAUGE32; 244 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 245 246 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 247 &varbind, 1); 248 } 249 250 void 251 backend_get_timeticks(void) 252 { 253 struct sockaddr_storage ss; 254 struct sockaddr *sa = (struct sockaddr *)&ss; 255 socklen_t salen; 256 int snmp_s, ax_s; 257 uint32_t sessionid; 258 struct varbind varbind = { 259 .type = TYPE_NULL, 260 .name = OID_STRUCT(MIB_BACKEND_GET, 7, 0), 261 .data.uint32 = 1 262 }; 263 int32_t requestid; 264 char buf[1024]; 265 size_t n; 266 267 ax_s = agentx_connect(axsocket); 268 sessionid = agentx_open(ax_s, 0, 0, 269 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 7), __func__); 270 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 271 OID_ARG(MIB_BACKEND_GET, 7), 0); 272 273 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 274 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 275 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 276 277 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 278 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 279 280 varbind.type = TYPE_TIMETICKS; 281 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 282 283 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 284 &varbind, 1); 285 } 286 287 void 288 backend_get_opaque(void) 289 { 290 struct sockaddr_storage ss; 291 struct sockaddr *sa = (struct sockaddr *)&ss; 292 socklen_t salen; 293 int snmp_s, ax_s; 294 uint32_t sessionid; 295 struct varbind varbind = { 296 .type = TYPE_NULL, 297 .name = OID_STRUCT(MIB_BACKEND_GET, 8, 0), 298 }; 299 int32_t requestid; 300 char buf[1024]; 301 size_t n; 302 struct ber ber = {}; 303 struct ber_element *elm; 304 ssize_t len; 305 306 ax_s = agentx_connect(axsocket); 307 sessionid = agentx_open(ax_s, 0, 0, 308 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 8), __func__); 309 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 310 OID_ARG(MIB_BACKEND_GET, 8), 0); 311 312 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 313 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 314 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 315 316 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 317 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 318 319 if ((elm = ober_add_integer(NULL, 1)) == NULL) 320 err(1, "ober_add_integer"); 321 if (ober_write_elements(&ber, elm) == -1) 322 err(1, "ober_write_elements"); 323 varbind.data.octetstring.len = ober_get_writebuf( 324 &ber, (void **)&varbind.data.octetstring.string); 325 ober_free_elements(elm); 326 327 varbind.type = TYPE_OPAQUE; 328 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 329 330 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 331 &varbind, 1); 332 ober_free(&ber); 333 } 334 335 void 336 backend_get_counter64(void) 337 { 338 struct sockaddr_storage ss; 339 struct sockaddr *sa = (struct sockaddr *)&ss; 340 socklen_t salen; 341 int snmp_s, ax_s; 342 uint32_t sessionid; 343 struct varbind varbind = { 344 .type = TYPE_NULL, 345 .name = OID_STRUCT(MIB_BACKEND_GET, 9, 0), 346 .data.uint64 = 1 347 }; 348 int32_t requestid; 349 char buf[1024]; 350 size_t n; 351 352 ax_s = agentx_connect(axsocket); 353 sessionid = agentx_open(ax_s, 0, 0, 354 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 9), __func__); 355 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 356 OID_ARG(MIB_BACKEND_GET, 9), 0); 357 358 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 359 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 360 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 361 362 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 363 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 364 365 varbind.type = TYPE_COUNTER64; 366 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 367 368 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 369 &varbind, 1); 370 } 371 372 void 373 backend_get_nosuchobject(void) 374 { 375 struct sockaddr_storage ss; 376 struct sockaddr *sa = (struct sockaddr *)&ss; 377 socklen_t salen; 378 int snmp_s, ax_s; 379 uint32_t sessionid; 380 struct varbind varbind = { 381 .type = TYPE_NULL, 382 .name = OID_STRUCT(MIB_BACKEND_GET, 10, 0), 383 }; 384 int32_t requestid; 385 char buf[1024]; 386 size_t n; 387 388 ax_s = agentx_connect(axsocket); 389 sessionid = agentx_open(ax_s, 0, 0, 390 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 10), __func__); 391 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 392 OID_ARG(MIB_BACKEND_GET, 10), 0); 393 394 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 395 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 396 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 397 398 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 399 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 400 401 varbind.type = TYPE_NOSUCHOBJECT; 402 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 403 404 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 405 &varbind, 1); 406 } 407 408 void 409 backend_get_nosuchinstance(void) 410 { 411 struct sockaddr_storage ss; 412 struct sockaddr *sa = (struct sockaddr *)&ss; 413 socklen_t salen; 414 int snmp_s, ax_s; 415 uint32_t sessionid; 416 struct varbind varbind = { 417 .type = TYPE_NULL, 418 .name = OID_STRUCT(MIB_BACKEND_GET, 11, 0), 419 }; 420 int32_t requestid; 421 char buf[1024]; 422 size_t n; 423 424 ax_s = agentx_connect(axsocket); 425 sessionid = agentx_open(ax_s, 0, 0, 426 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 11), __func__); 427 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 428 OID_ARG(MIB_BACKEND_GET, 11), 0); 429 430 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 431 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 432 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 433 434 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 435 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 436 437 varbind.type = TYPE_NOSUCHINSTANCE; 438 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 439 440 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 441 &varbind, 1); 442 } 443 444 void 445 backend_get_endofmibview(void) 446 { 447 struct sockaddr_storage ss; 448 struct sockaddr *sa = (struct sockaddr *)&ss; 449 socklen_t salen; 450 int snmp_s, ax_s; 451 uint32_t sessionid; 452 struct varbind varbind = { 453 .type = TYPE_NULL, 454 .name = OID_STRUCT(MIB_BACKEND_GET, 12, 0), 455 }; 456 int32_t requestid; 457 char buf[1024]; 458 size_t n; 459 460 ax_s = agentx_connect(axsocket); 461 sessionid = agentx_open(ax_s, 0, 0, 462 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 12), __func__); 463 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 464 OID_ARG(MIB_BACKEND_GET, 12), 0); 465 466 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 467 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 468 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 469 470 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 471 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 472 473 varbind.type = TYPE_ENDOFMIBVIEW; 474 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 475 476 varbind.type = TYPE_NULL; 477 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 478 &varbind, 1); 479 } 480 481 void 482 backend_get_two_single_backend(void) 483 { 484 struct sockaddr_storage ss; 485 struct sockaddr *sa = (struct sockaddr *)&ss; 486 socklen_t salen; 487 int snmp_s, ax_s; 488 uint32_t sessionid; 489 struct varbind varbind[] = { 490 { 491 .type = TYPE_NULL, 492 .name = OID_STRUCT(MIB_BACKEND_GET, 13, 1), 493 .data.int32 = 1 494 }, 495 { 496 .type = TYPE_NULL, 497 .name = OID_STRUCT(MIB_BACKEND_GET, 13, 2), 498 .data.int32 = 2 499 } 500 }; 501 struct varbind varbind_ax[] = { 502 { 503 .type = TYPE_INTEGER, 504 .name = OID_STRUCT(MIB_BACKEND_GET, 13, 1), 505 .data.int32 = 1 506 }, 507 { 508 .type = TYPE_INTEGER, 509 .name = OID_STRUCT(MIB_BACKEND_GET, 13, 2), 510 .data.int32 = 2 511 } 512 }; 513 int32_t requestid; 514 char buf[1024]; 515 size_t n; 516 517 ax_s = agentx_connect(axsocket); 518 sessionid = agentx_open(ax_s, 0, 0, 519 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 13), __func__); 520 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 521 OID_ARG(MIB_BACKEND_GET, 13), 0); 522 523 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 524 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 525 requestid = snmpv2_get(snmp_s, community, 0, varbind, 2); 526 527 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 528 agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2); 529 530 agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2); 531 532 varbind[0].type = varbind[1].type = TYPE_INTEGER; 533 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 534 varbind, 2); 535 } 536 537 void 538 backend_get_two_double_backend(void) 539 { 540 struct sockaddr_storage ss; 541 struct sockaddr *sa = (struct sockaddr *)&ss; 542 socklen_t salen; 543 int snmp_s, ax_s1, ax_s2; 544 uint32_t sessionid1, sessionid2; 545 struct varbind varbind[] = { 546 { 547 .type = TYPE_NULL, 548 .name = OID_STRUCT(MIB_BACKEND_GET, 14, 1), 549 .data.int32 = 1 550 }, 551 { 552 .type = TYPE_NULL, 553 .name = OID_STRUCT(MIB_BACKEND_GET, 14, 2), 554 .data.int32 = 2 555 } 556 }; 557 int32_t requestid; 558 char buf[1024]; 559 size_t n; 560 561 ax_s1 = agentx_connect(axsocket); 562 ax_s2 = agentx_connect(axsocket); 563 sessionid1 = agentx_open(ax_s1, 0, 0, 564 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 14, 1), 565 "backend_get_two_double_backend.1"); 566 sessionid2 = agentx_open(ax_s2, 0, 0, 567 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 14, 2), 568 "backend_get_two_double_backend.2"); 569 agentx_register(ax_s1, sessionid1, 0, 0, 127, 0, 570 OID_ARG(MIB_BACKEND_GET, 14, 1), 0); 571 agentx_register(ax_s2, sessionid2, 0, 0, 127, 0, 572 OID_ARG(MIB_BACKEND_GET, 14, 2), 0); 573 574 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 575 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 576 requestid = snmpv2_get(snmp_s, community, 0, varbind, 2); 577 578 varbind[0].type = varbind[1].type = TYPE_INTEGER; 579 n = agentx_read(ax_s1, buf, sizeof(buf), 1000); 580 agentx_get_handle(__func__, buf, n, 0, sessionid1, varbind, 1); 581 agentx_response(ax_s1, buf, NOERROR, 0, varbind, 1); 582 583 n = agentx_read(ax_s2, buf, sizeof(buf), 1000); 584 agentx_get_handle(__func__, buf, n, 0, sessionid2, varbind + 1, 1); 585 agentx_response(ax_s2, buf, NOERROR, 0, varbind + 1, 1); 586 587 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 588 varbind, 2); 589 } 590 591 void 592 backend_get_wrongorder(void) 593 { 594 struct sockaddr_storage ss; 595 struct sockaddr *sa = (struct sockaddr *)&ss; 596 socklen_t salen; 597 int snmp_s, ax_s; 598 uint32_t sessionid; 599 struct varbind varbind[] = { 600 { 601 .type = TYPE_NULL, 602 .name = OID_STRUCT(MIB_BACKEND_GET, 15, 1), 603 }, 604 { 605 .type = TYPE_NULL, 606 .name = OID_STRUCT(MIB_BACKEND_GET, 15, 2), 607 } 608 }; 609 struct varbind varbind_ax[] = { 610 { 611 .type = TYPE_INTEGER, 612 .name = OID_STRUCT(MIB_BACKEND_GET, 15, 1), 613 .data.int32 = 1 614 }, 615 { 616 .type = TYPE_INTEGER, 617 .name = OID_STRUCT(MIB_BACKEND_GET, 15, 2), 618 .data.int32 = 2 619 } 620 }, tmpvarbind; 621 int32_t requestid; 622 char buf[1024]; 623 size_t n; 624 625 ax_s = agentx_connect(axsocket); 626 sessionid = agentx_open(ax_s, 0, 0, 627 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 15), __func__); 628 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 629 OID_ARG(MIB_BACKEND_GET, 15), 0); 630 631 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 632 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 633 requestid = snmpv2_get(snmp_s, community, 0, varbind, 2); 634 635 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 636 agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2); 637 tmpvarbind = varbind_ax[0]; 638 varbind_ax[0] = varbind_ax[1]; 639 varbind_ax[1] = tmpvarbind; 640 641 agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2); 642 643 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2, 644 varbind, 2); 645 } 646 647 void 648 backend_get_toofew(void) 649 { 650 struct sockaddr_storage ss; 651 struct sockaddr *sa = (struct sockaddr *)&ss; 652 socklen_t salen; 653 int snmp_s, ax_s; 654 uint32_t sessionid; 655 struct varbind varbind[] = { 656 { 657 .type = TYPE_NULL, 658 .name = OID_STRUCT(MIB_BACKEND_GET, 16, 1), 659 }, 660 { 661 .type = TYPE_NULL, 662 .name = OID_STRUCT(MIB_BACKEND_GET, 16, 2), 663 } 664 }; 665 struct varbind varbind_ax[] = { 666 { 667 .type = TYPE_INTEGER, 668 .name = OID_STRUCT(MIB_BACKEND_GET, 16, 1), 669 .data.int32 = 1 670 }, 671 { 672 .type = TYPE_INTEGER, 673 .name = OID_STRUCT(MIB_BACKEND_GET, 16, 2), 674 .data.int32 = 2 675 } 676 }, tmpvarbind; 677 int32_t requestid; 678 char buf[1024]; 679 size_t n; 680 681 ax_s = agentx_connect(axsocket); 682 sessionid = agentx_open(ax_s, 0, 0, 683 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 16), __func__); 684 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 685 OID_ARG(MIB_BACKEND_GET, 16), 0); 686 687 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 688 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 689 requestid = snmpv2_get(snmp_s, community, 0, varbind, 2); 690 691 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 692 agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2); 693 694 agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 1); 695 696 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2, 697 varbind, 2); 698 } 699 700 void 701 backend_get_toomany(void) 702 { 703 struct sockaddr_storage ss; 704 struct sockaddr *sa = (struct sockaddr *)&ss; 705 socklen_t salen; 706 int snmp_s, ax_s; 707 uint32_t sessionid; 708 struct varbind varbind[] = { 709 { 710 .type = TYPE_NULL, 711 .name = OID_STRUCT(MIB_BACKEND_GET, 17, 1), 712 }, 713 { 714 .type = TYPE_NULL, 715 .name = OID_STRUCT(MIB_BACKEND_GET, 17, 2), 716 } 717 }; 718 struct varbind varbind_ax[] = { 719 { 720 .type = TYPE_INTEGER, 721 .name = OID_STRUCT(MIB_BACKEND_GET, 17, 1), 722 .data.int32 = 1 723 }, 724 { 725 .type = TYPE_INTEGER, 726 .name = OID_STRUCT(MIB_BACKEND_GET, 17, 2), 727 .data.int32 = 2 728 }, 729 { 730 .type = TYPE_INTEGER, 731 .name = OID_STRUCT(MIB_BACKEND_GET, 17, 3), 732 .data.int32 = 3 733 } 734 }, tmpvarbind; 735 int32_t requestid; 736 char buf[1024]; 737 size_t n; 738 739 ax_s = agentx_connect(axsocket); 740 sessionid = agentx_open(ax_s, 0, 0, 741 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 17), __func__); 742 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 743 OID_ARG(MIB_BACKEND_GET, 17), 0); 744 745 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 746 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 747 requestid = snmpv2_get(snmp_s, community, 0, varbind, 2); 748 749 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 750 agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2); 751 752 agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 3); 753 754 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2, 755 varbind, 2); 756 } 757 758 void 759 backend_get_instance(void) 760 { 761 struct sockaddr_storage ss; 762 struct sockaddr *sa = (struct sockaddr *)&ss; 763 socklen_t salen; 764 int snmp_s, ax_s; 765 uint32_t sessionid; 766 struct varbind varbind = { 767 .type = TYPE_NULL, 768 .name = OID_STRUCT(MIB_BACKEND_GET, 18, 0), 769 }; 770 int32_t requestid; 771 char buf[1024]; 772 size_t n; 773 774 ax_s = agentx_connect(axsocket); 775 sessionid = agentx_open(ax_s, 0, 0, 776 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 18), __func__); 777 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 778 OID_ARG(MIB_BACKEND_GET, 18, 0), 0); 779 780 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 781 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 782 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 783 784 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 785 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 786 787 varbind.type = TYPE_INTEGER; 788 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 789 790 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 791 &varbind, 1); 792 } 793 794 void 795 backend_get_instance_below(void) 796 { 797 struct sockaddr_storage ss; 798 struct sockaddr *sa = (struct sockaddr *)&ss; 799 socklen_t salen; 800 int snmp_s, ax_s; 801 uint32_t sessionid; 802 struct varbind varbind = { 803 .type = TYPE_NULL, 804 .name = OID_STRUCT(MIB_BACKEND_GET, 19, 0), 805 }; 806 int32_t requestid; 807 char buf[1024]; 808 size_t n; 809 810 ax_s = agentx_connect(axsocket); 811 sessionid = agentx_open(ax_s, 0, 0, 812 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 19), __func__); 813 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 814 OID_ARG(MIB_BACKEND_GET, 19), 0); 815 816 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 817 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 818 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 819 820 varbind.type = TYPE_NOSUCHINSTANCE; 821 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 822 &varbind, 1); 823 } 824 825 void 826 backend_get_timeout_default(void) 827 { 828 struct sockaddr_storage ss; 829 struct sockaddr *sa = (struct sockaddr *)&ss; 830 socklen_t salen; 831 int snmp_s, ax_s; 832 uint32_t sessionid; 833 struct varbind varbind = { 834 .type = TYPE_NULL, 835 .name = OID_STRUCT(MIB_BACKEND_GET, 20, 0), 836 }; 837 int32_t requestid; 838 char buf[1024]; 839 size_t n; 840 struct timespec start, end, diff; 841 842 ax_s = agentx_connect(axsocket); 843 sessionid = agentx_open(ax_s, 0, 0, 844 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 20), __func__); 845 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 846 OID_ARG(MIB_BACKEND_GET, 20), 0); 847 848 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 849 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 850 if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) 851 err(1, "clock_gettime"); 852 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 853 854 snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1, 855 &varbind, 1); 856 if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) 857 err(1, "clock_gettime"); 858 timespecsub(&end, &start, &diff); 859 if (diff.tv_sec != 5) 860 errx(1, "%s: unexpected timeout (%lld.%09ld/5)", __func__, 861 diff.tv_sec, diff.tv_nsec); 862 } 863 864 void 865 backend_get_timeout_session_lower(void) 866 { 867 struct sockaddr_storage ss; 868 struct sockaddr *sa = (struct sockaddr *)&ss; 869 socklen_t salen; 870 int snmp_s, ax_s; 871 uint32_t sessionid; 872 struct varbind varbind = { 873 .type = TYPE_NULL, 874 .name = OID_STRUCT(MIB_BACKEND_GET, 21, 0), 875 }; 876 int32_t requestid; 877 char buf[1024]; 878 size_t n; 879 struct timespec start, end, diff; 880 881 ax_s = agentx_connect(axsocket); 882 sessionid = agentx_open(ax_s, 0, 1, 883 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 21), __func__); 884 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 885 OID_ARG(MIB_BACKEND_GET, 21), 0); 886 887 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 888 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 889 if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) 890 err(1, "clock_gettime"); 891 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 892 893 snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1, 894 &varbind, 1); 895 if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) 896 err(1, "clock_gettime"); 897 timespecsub(&end, &start, &diff); 898 if (diff.tv_sec != 1) 899 errx(1, "%s: unexpected timeout (%lld.%09ld/1)", __func__, 900 diff.tv_sec, diff.tv_nsec); 901 } 902 903 void 904 backend_get_timeout_session_higher(void) 905 { 906 struct sockaddr_storage ss; 907 struct sockaddr *sa = (struct sockaddr *)&ss; 908 socklen_t salen; 909 int snmp_s, ax_s; 910 uint32_t sessionid; 911 struct varbind varbind = { 912 .type = TYPE_NULL, 913 .name = OID_STRUCT(MIB_BACKEND_GET, 22, 0), 914 }; 915 int32_t requestid; 916 char buf[1024]; 917 size_t n; 918 struct timespec start, end, diff; 919 920 ax_s = agentx_connect(axsocket); 921 sessionid = agentx_open(ax_s, 0, 6, 922 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 22), __func__); 923 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 924 OID_ARG(MIB_BACKEND_GET, 22), 0); 925 926 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 927 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 928 if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) 929 err(1, "clock_gettime"); 930 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 931 932 snmpv2_response_validate(snmp_s, 7000, community, requestid, GENERR, 1, 933 &varbind, 1); 934 if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) 935 err(1, "clock_gettime"); 936 timespecsub(&end, &start, &diff); 937 if (diff.tv_sec != 6) 938 errx(1, "%s: unexpected timeout (%lld.%09ld/6)", __func__, 939 diff.tv_sec, diff.tv_nsec); 940 } 941 942 void 943 backend_get_timeout_region_lower(void) 944 { 945 struct sockaddr_storage ss; 946 struct sockaddr *sa = (struct sockaddr *)&ss; 947 socklen_t salen; 948 int snmp_s, ax_s; 949 uint32_t sessionid; 950 struct varbind varbind = { 951 .type = TYPE_NULL, 952 .name = OID_STRUCT(MIB_BACKEND_GET, 23, 0), 953 }; 954 int32_t requestid; 955 char buf[1024]; 956 size_t n; 957 struct timespec start, end, diff; 958 959 ax_s = agentx_connect(axsocket); 960 sessionid = agentx_open(ax_s, 0, 4, 961 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 23), __func__); 962 agentx_register(ax_s, sessionid, 0, 1, 127, 0, 963 OID_ARG(MIB_BACKEND_GET, 23), 0); 964 965 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 966 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 967 if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) 968 err(1, "clock_gettime"); 969 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 970 971 snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1, 972 &varbind, 1); 973 if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) 974 err(1, "clock_gettime"); 975 timespecsub(&end, &start, &diff); 976 if (diff.tv_sec != 1) 977 errx(1, "%s: unexpected timeout (%lld.%09ld/1)", __func__, 978 diff.tv_sec, diff.tv_nsec); 979 } 980 981 void 982 backend_get_timeout_region_higher(void) 983 { 984 struct sockaddr_storage ss; 985 struct sockaddr *sa = (struct sockaddr *)&ss; 986 socklen_t salen; 987 int snmp_s, ax_s; 988 uint32_t sessionid; 989 struct varbind varbind = { 990 .type = TYPE_NULL, 991 .name = OID_STRUCT(MIB_BACKEND_GET, 24, 0), 992 }; 993 int32_t requestid; 994 char buf[1024]; 995 size_t n; 996 struct timespec start, end, diff; 997 998 ax_s = agentx_connect(axsocket); 999 sessionid = agentx_open(ax_s, 0, 7, 1000 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 24), __func__); 1001 agentx_register(ax_s, sessionid, 0, 6, 127, 0, 1002 OID_ARG(MIB_BACKEND_GET, 24), 0); 1003 1004 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1005 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1006 if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) 1007 err(1, "clock_gettime"); 1008 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1009 1010 snmpv2_response_validate(snmp_s, 8000, community, requestid, GENERR, 1, 1011 &varbind, 1); 1012 if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) 1013 err(1, "clock_gettime"); 1014 timespecsub(&end, &start, &diff); 1015 if (diff.tv_sec != 6) 1016 errx(1, "%s: unexpected timeout (%lld.%09ld/6)", __func__, 1017 diff.tv_sec, diff.tv_nsec); 1018 } 1019 1020 void 1021 backend_get_priority_lower(void) 1022 { 1023 struct sockaddr_storage ss; 1024 struct sockaddr *sa = (struct sockaddr *)&ss; 1025 socklen_t salen; 1026 int snmp_s, ax_s; 1027 uint32_t sessionid1, sessionid2; 1028 struct varbind varbind = { 1029 .type = TYPE_NULL, 1030 .name = OID_STRUCT(MIB_BACKEND_GET, 25, 0), 1031 .data.int32 = 1 1032 }; 1033 int32_t requestid; 1034 char buf[1024]; 1035 size_t n; 1036 1037 ax_s = agentx_connect(axsocket); 1038 sessionid1 = agentx_open(ax_s, 0, 0, 1039 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 25, 1), "backend_get_priority.1"); 1040 sessionid2 = agentx_open(ax_s, 0, 0, 1041 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 25, 2), "backend_get_priority.2"); 1042 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1043 OID_ARG(MIB_BACKEND_GET, 25), 0); 1044 agentx_register(ax_s, sessionid2, 0, 0, 126, 0, 1045 OID_ARG(MIB_BACKEND_GET, 25), 0); 1046 1047 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1048 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1049 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1050 1051 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1052 agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1); 1053 1054 varbind.type = TYPE_INTEGER; 1055 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1056 1057 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1058 &varbind, 1); 1059 } 1060 1061 void 1062 backend_get_priority_higher(void) 1063 { 1064 struct sockaddr_storage ss; 1065 struct sockaddr *sa = (struct sockaddr *)&ss; 1066 socklen_t salen; 1067 int snmp_s, ax_s; 1068 uint32_t sessionid1, sessionid2; 1069 struct varbind varbind = { 1070 .type = TYPE_NULL, 1071 .name = OID_STRUCT(MIB_BACKEND_GET, 26, 0), 1072 .data.int32 = 1 1073 }; 1074 int32_t requestid; 1075 char buf[1024]; 1076 size_t n; 1077 1078 ax_s = agentx_connect(axsocket); 1079 sessionid1 = agentx_open(ax_s, 0, 0, 1080 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 26, 1), 1081 "backend_get_priority_higher.1"); 1082 sessionid2 = agentx_open(ax_s, 0, 0, 1083 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 26, 2), 1084 "backend_get_priority_higher.2"); 1085 agentx_register(ax_s, sessionid1, 0, 0, 126, 0, 1086 OID_ARG(MIB_BACKEND_GET, 26), 0); 1087 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 1088 OID_ARG(MIB_BACKEND_GET, 26), 0); 1089 1090 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1091 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1092 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1093 1094 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1095 agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1); 1096 1097 varbind.type = TYPE_INTEGER; 1098 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1099 1100 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1101 &varbind, 1); 1102 } 1103 1104 void 1105 backend_get_priority_below_lower(void) 1106 { 1107 struct sockaddr_storage ss; 1108 struct sockaddr *sa = (struct sockaddr *)&ss; 1109 socklen_t salen; 1110 int snmp_s, ax_s; 1111 uint32_t sessionid1, sessionid2; 1112 struct varbind varbind = { 1113 .type = TYPE_NULL, 1114 .name = OID_STRUCT(MIB_BACKEND_GET, 27, 0), 1115 .data.int32 = 1 1116 }; 1117 int32_t requestid; 1118 char buf[1024]; 1119 size_t n; 1120 1121 ax_s = agentx_connect(axsocket); 1122 sessionid1 = agentx_open(ax_s, 0, 0, 1123 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 27, 1), 1124 "backend_get_priority_below_lower.1"); 1125 sessionid2 = agentx_open(ax_s, 0, 0, 1126 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 27, 2), 1127 "backend_get_priority_below_lower.2"); 1128 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1129 OID_ARG(MIB_BACKEND_GET, 27), 0); 1130 agentx_register(ax_s, sessionid2, 0, 0, 126, 0, 1131 OID_ARG(MIB_BACKEND_GET, 27, 0), 0); 1132 1133 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1134 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1135 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1136 1137 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1138 agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1); 1139 1140 varbind.type = TYPE_INTEGER; 1141 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1142 1143 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1144 &varbind, 1); 1145 } 1146 1147 void 1148 backend_get_priority_below_higher(void) 1149 { 1150 struct sockaddr_storage ss; 1151 struct sockaddr *sa = (struct sockaddr *)&ss; 1152 socklen_t salen; 1153 int snmp_s, ax_s; 1154 uint32_t sessionid1, sessionid2; 1155 struct varbind varbind = { 1156 .type = TYPE_NULL, 1157 .name = OID_STRUCT(MIB_BACKEND_GET, 28, 0), 1158 .data.int32 = 1 1159 }; 1160 int32_t requestid; 1161 char buf[1024]; 1162 size_t n; 1163 1164 ax_s = agentx_connect(axsocket); 1165 sessionid1 = agentx_open(ax_s, 0, 0, 1166 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 28, 1), 1167 "backend_get_priority_below_higher.1"); 1168 sessionid2 = agentx_open(ax_s, 0, 0, 1169 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 28, 2), 1170 "backend_get_priority_below_higher.2"); 1171 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1172 OID_ARG(MIB_BACKEND_GET, 28), 0); 1173 agentx_register(ax_s, sessionid2, 0, 0, 128, 0, 1174 OID_ARG(MIB_BACKEND_GET, 28, 0), 0); 1175 1176 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1177 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1178 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1179 1180 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1181 agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1); 1182 1183 varbind.type = TYPE_INTEGER; 1184 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1185 1186 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1187 &varbind, 1); 1188 } 1189 1190 void 1191 backend_get_close(void) 1192 { 1193 struct sockaddr_storage ss; 1194 struct sockaddr *sa = (struct sockaddr *)&ss; 1195 socklen_t salen; 1196 int snmp_s, ax_s; 1197 uint32_t sessionid; 1198 struct varbind varbind = { 1199 .type = TYPE_NULL, 1200 .name = OID_STRUCT(MIB_BACKEND_GET, 29, 0), 1201 }; 1202 int32_t requestid; 1203 char buf[1024]; 1204 size_t n; 1205 1206 ax_s = agentx_connect(axsocket); 1207 sessionid = agentx_open(ax_s, 0, 0, 1208 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 29), __func__); 1209 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1210 OID_ARG(MIB_BACKEND_GET, 29), 0); 1211 1212 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1213 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1214 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1215 1216 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1217 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1218 1219 agentx_close(ax_s, sessionid, REASONOTHER); 1220 1221 varbind.type = TYPE_NOSUCHOBJECT; 1222 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1223 &varbind, 1); 1224 } 1225 1226 void 1227 backend_get_close_overlap(void) 1228 { 1229 struct sockaddr_storage ss; 1230 struct sockaddr *sa = (struct sockaddr *)&ss; 1231 socklen_t salen; 1232 int snmp_s, ax_s1, ax_s2; 1233 uint32_t sessionid1, sessionid2; 1234 struct varbind varbind = { 1235 .type = TYPE_NULL, 1236 .name = OID_STRUCT(MIB_BACKEND_GET, 30, 0), 1237 .data.int32 = 1 1238 }; 1239 int32_t requestid; 1240 char buf[1024]; 1241 size_t n; 1242 1243 ax_s1 = agentx_connect(axsocket); 1244 ax_s2 = agentx_connect(axsocket); 1245 sessionid1 = agentx_open(ax_s1, 0, 0, 1246 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 30, 1), 1247 "backend_get_close_overlap.1"); 1248 sessionid2 = agentx_open(ax_s2, 0, 0, 1249 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 30, 1), 1250 "backend_get_close_overlap.2"); 1251 agentx_register(ax_s1, sessionid1, 0, 0, 127, 0, 1252 OID_ARG(MIB_BACKEND_GET, 30), 0); 1253 agentx_register(ax_s2, sessionid2, 0, 0, 128, 0, 1254 OID_ARG(MIB_BACKEND_GET, 30), 0); 1255 1256 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1257 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1258 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1259 1260 n = agentx_read(ax_s1, buf, sizeof(buf), 1000); 1261 agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1); 1262 agentx_close(ax_s1, sessionid1, REASONOTHER); 1263 1264 varbind.type = TYPE_INTEGER; 1265 n = agentx_read(ax_s2, buf, sizeof(buf), 1000); 1266 agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1); 1267 agentx_response(ax_s2, buf, NOERROR, 0, &varbind, 1); 1268 1269 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1270 &varbind, 1); 1271 } 1272 1273 void 1274 backend_get_disappear(void) 1275 { 1276 struct sockaddr_storage ss; 1277 struct sockaddr *sa = (struct sockaddr *)&ss; 1278 socklen_t salen; 1279 int snmp_s, ax_s; 1280 uint32_t sessionid; 1281 struct varbind varbind = { 1282 .type = TYPE_NULL, 1283 .name = OID_STRUCT(MIB_BACKEND_GET, 31, 0), 1284 }; 1285 int32_t requestid; 1286 char buf[1024]; 1287 size_t n; 1288 1289 ax_s = agentx_connect(axsocket); 1290 sessionid = agentx_open(ax_s, 0, 0, 1291 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 31), __func__); 1292 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1293 OID_ARG(MIB_BACKEND_GET, 31), 0); 1294 1295 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1296 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1297 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1298 1299 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1300 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1301 close(ax_s); 1302 1303 varbind.type = TYPE_NOSUCHOBJECT; 1304 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1305 &varbind, 1); 1306 } 1307 1308 void 1309 backend_get_disappear_overlap(void) 1310 { 1311 struct sockaddr_storage ss; 1312 struct sockaddr *sa = (struct sockaddr *)&ss; 1313 socklen_t salen; 1314 int snmp_s, ax_s1, ax_s2; 1315 uint32_t sessionid1, sessionid2; 1316 struct varbind varbind = { 1317 .type = TYPE_NULL, 1318 .name = OID_STRUCT(MIB_BACKEND_GET, 32, 0), 1319 .data.int32 = 1 1320 }; 1321 int32_t requestid; 1322 char buf[1024]; 1323 size_t n; 1324 1325 ax_s1 = agentx_connect(axsocket); 1326 ax_s2 = agentx_connect(axsocket); 1327 sessionid1 = agentx_open(ax_s1, 0, 0, 1328 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 32, 1), 1329 "backend_get_close_overlap.1"); 1330 sessionid2 = agentx_open(ax_s2, 0, 0, 1331 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 32, 1), 1332 "backend_get_close_overlap.2"); 1333 agentx_register(ax_s1, sessionid1, 0, 0, 127, 0, 1334 OID_ARG(MIB_BACKEND_GET, 32), 0); 1335 agentx_register(ax_s2, sessionid2, 0, 0, 128, 0, 1336 OID_ARG(MIB_BACKEND_GET, 32), 0); 1337 1338 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1339 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1340 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1341 1342 n = agentx_read(ax_s1, buf, sizeof(buf), 1000); 1343 agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1); 1344 close(ax_s1); 1345 1346 varbind.type = TYPE_INTEGER; 1347 n = agentx_read(ax_s2, buf, sizeof(buf), 1000); 1348 agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1); 1349 agentx_response(ax_s2, buf, NOERROR, 0, &varbind, 1); 1350 1351 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1352 &varbind, 1); 1353 } 1354 1355 void 1356 backend_get_disappear_doublesession(void) 1357 { 1358 struct sockaddr_storage ss; 1359 struct sockaddr *sa = (struct sockaddr *)&ss; 1360 socklen_t salen; 1361 int snmp_s, ax_s; 1362 uint32_t sessionid1, sessionid2; 1363 struct varbind varbind = { 1364 .type = TYPE_NULL, 1365 .name = OID_STRUCT(MIB_BACKEND_GET, 33, 0), 1366 }; 1367 int32_t requestid; 1368 char buf[1024]; 1369 size_t n; 1370 1371 ax_s = agentx_connect(axsocket); 1372 sessionid1 = agentx_open(ax_s, 0, 0, 1373 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 33, 1), 1374 "backend_get_disappear_doublesession.1"); 1375 sessionid2 = agentx_open(ax_s, 0, 0, 1376 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 33, 2), 1377 "backend_get_disappear_doublesession.2"); 1378 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1379 OID_ARG(MIB_BACKEND_GET, 33), 0); 1380 agentx_register(ax_s, sessionid2, 0, 0, 128, 0, 1381 OID_ARG(MIB_BACKEND_GET, 33), 0); 1382 1383 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1384 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1385 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1386 1387 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1388 agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1); 1389 close(ax_s); 1390 1391 varbind.type = TYPE_NOSUCHOBJECT; 1392 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1393 &varbind, 1); 1394 } 1395 1396 void 1397 backend_get_octetstring_max(void) 1398 { 1399 struct sockaddr_storage ss; 1400 struct sockaddr *sa = (struct sockaddr *)&ss; 1401 socklen_t salen; 1402 int snmp_s, ax_s; 1403 uint32_t sessionid; 1404 char vbbuf[65535] = {}; 1405 struct varbind varbind = { 1406 .type = TYPE_NULL, 1407 .name = OID_STRUCT(MIB_BACKEND_GET, 34, 0), 1408 .data.octetstring.string = vbbuf, 1409 .data.octetstring.len = sizeof(vbbuf) 1410 }; 1411 int32_t requestid; 1412 char buf[1024]; 1413 size_t n; 1414 1415 memset(vbbuf, 'a', sizeof(vbbuf)); 1416 ax_s = agentx_connect(axsocket); 1417 sessionid = agentx_open(ax_s, 0, 0, 1418 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 34), __func__); 1419 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1420 OID_ARG(MIB_BACKEND_GET, 34), 0); 1421 1422 /* Too big for SOCK_DGRAM */ 1423 salen = snmp_resolve(SOCK_STREAM, hostname, servname, sa); 1424 snmp_s = snmp_connect(SOCK_STREAM, sa, salen); 1425 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1426 1427 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1428 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1429 1430 varbind.type = TYPE_OCTETSTRING; 1431 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1432 1433 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1434 &varbind, 1); 1435 } 1436 1437 void 1438 backend_get_octetstring_too_long(void) 1439 { 1440 struct sockaddr_storage ss; 1441 struct sockaddr *sa = (struct sockaddr *)&ss; 1442 socklen_t salen; 1443 int snmp_s, ax_s; 1444 uint32_t sessionid; 1445 char vbbuf[65536]; 1446 struct varbind varbind = { 1447 .type = TYPE_NULL, 1448 .name = OID_STRUCT(MIB_BACKEND_GET, 35, 0), 1449 .data.octetstring.string = vbbuf, 1450 .data.octetstring.len = sizeof(vbbuf) 1451 }; 1452 int32_t requestid; 1453 char buf[1024]; 1454 size_t n; 1455 1456 memset(vbbuf, 'a', sizeof(vbbuf)); 1457 ax_s = agentx_connect(axsocket); 1458 sessionid = agentx_open(ax_s, 0, 0, 1459 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 35), __func__); 1460 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1461 OID_ARG(MIB_BACKEND_GET, 35), 0); 1462 1463 salen = snmp_resolve(SOCK_STREAM, hostname, servname, sa); 1464 snmp_s = snmp_connect(SOCK_STREAM, sa, salen); 1465 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1466 1467 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1468 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1469 1470 varbind.type = TYPE_OCTETSTRING; 1471 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1472 1473 varbind.type = TYPE_NULL; 1474 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 1475 &varbind, 1); 1476 } 1477 1478 void 1479 backend_get_ipaddress_too_short(void) 1480 { 1481 struct sockaddr_storage ss; 1482 struct sockaddr *sa = (struct sockaddr *)&ss; 1483 socklen_t salen; 1484 int snmp_s, ax_s; 1485 uint32_t sessionid; 1486 struct varbind varbind = { 1487 .type = TYPE_NULL, 1488 .name = OID_STRUCT(MIB_BACKEND_GET, 36, 0), 1489 .data.octetstring.string = "\0\0\0", 1490 .data.octetstring.len = 3 1491 }; 1492 int32_t requestid; 1493 char buf[1024]; 1494 size_t n; 1495 1496 ax_s = agentx_connect(axsocket); 1497 sessionid = agentx_open(ax_s, 0, 0, 1498 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 36), __func__); 1499 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1500 OID_ARG(MIB_BACKEND_GET, 36), 0); 1501 1502 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1503 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1504 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1505 1506 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1507 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1508 1509 varbind.type = TYPE_IPADDRESS; 1510 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1511 1512 varbind.type = TYPE_NULL; 1513 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 1514 &varbind, 1); 1515 } 1516 1517 void 1518 backend_get_ipaddress_too_long(void) 1519 { 1520 struct sockaddr_storage ss; 1521 struct sockaddr *sa = (struct sockaddr *)&ss; 1522 socklen_t salen; 1523 int snmp_s, ax_s; 1524 uint32_t sessionid; 1525 struct varbind varbind = { 1526 .type = TYPE_NULL, 1527 .name = OID_STRUCT(MIB_BACKEND_GET, 37, 0), 1528 .data.octetstring.string = "\0\0\0\0\0", 1529 .data.octetstring.len = 5 1530 }; 1531 int32_t requestid; 1532 char buf[1024]; 1533 size_t n; 1534 1535 ax_s = agentx_connect(axsocket); 1536 sessionid = agentx_open(ax_s, 0, 0, 1537 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 37), __func__); 1538 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1539 OID_ARG(MIB_BACKEND_GET, 37), 0); 1540 1541 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1542 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1543 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1544 1545 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1546 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1547 1548 varbind.type = TYPE_IPADDRESS; 1549 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1550 1551 varbind.type = TYPE_NULL; 1552 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 1553 &varbind, 1); 1554 } 1555 1556 void 1557 backend_get_opaque_non_ber(void) 1558 { 1559 struct sockaddr_storage ss; 1560 struct sockaddr *sa = (struct sockaddr *)&ss; 1561 socklen_t salen; 1562 int snmp_s, ax_s; 1563 uint32_t sessionid; 1564 struct varbind varbind = { 1565 .type = TYPE_NULL, 1566 .name = OID_STRUCT(MIB_BACKEND_GET, 38, 0), 1567 .data.octetstring.string = "\1", 1568 .data.octetstring.len = 1 1569 }; 1570 int32_t requestid; 1571 char buf[1024]; 1572 size_t n; 1573 ssize_t len; 1574 1575 ax_s = agentx_connect(axsocket); 1576 sessionid = agentx_open(ax_s, 0, 0, 1577 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 38), __func__); 1578 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1579 OID_ARG(MIB_BACKEND_GET, 38), 0); 1580 1581 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1582 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1583 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1584 1585 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1586 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1587 1588 varbind.type = TYPE_OPAQUE; 1589 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1590 1591 varbind.type = TYPE_NULL; 1592 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 1593 &varbind, 1); 1594 } 1595 1596 void 1597 backend_get_opaque_double_value(void) 1598 { 1599 struct sockaddr_storage ss; 1600 struct sockaddr *sa = (struct sockaddr *)&ss; 1601 socklen_t salen; 1602 int snmp_s, ax_s; 1603 uint32_t sessionid; 1604 char vbbuf[1024]; 1605 struct varbind varbind = { 1606 .type = TYPE_NULL, 1607 .name = OID_STRUCT(MIB_BACKEND_GET, 39, 0), 1608 .data.octetstring.string = vbbuf 1609 }; 1610 int32_t requestid; 1611 void *berdata; 1612 char buf[1024]; 1613 size_t n; 1614 struct ber ber = {}; 1615 struct ber_element *elm; 1616 ssize_t len; 1617 1618 ax_s = agentx_connect(axsocket); 1619 sessionid = agentx_open(ax_s, 0, 0, 1620 OID_ARG(MIB_SUBAGENT_BACKEND_GET, 39), __func__); 1621 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1622 OID_ARG(MIB_BACKEND_GET, 39), 0); 1623 1624 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1625 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1626 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 1627 1628 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1629 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 1630 1631 if ((elm = ober_add_integer(NULL, 1)) == NULL) 1632 err(1, "ober_add_integer"); 1633 if (ober_write_elements(&ber, elm) == -1) 1634 err(1, "ober_write_elements"); 1635 len = ober_get_writebuf(&ber, &berdata); 1636 ober_free_elements(elm); 1637 1638 memcpy(vbbuf, berdata, len); 1639 memcpy(vbbuf + len, berdata, len); 1640 varbind.data.octetstring.len = 2 * len; 1641 1642 varbind.type = TYPE_OPAQUE; 1643 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1644 1645 varbind.type = TYPE_NULL; 1646 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 1647 &varbind, 1); 1648 ober_free(&ber); 1649 } 1650 1651 void 1652 backend_getnext_selfbound(void) 1653 { 1654 struct sockaddr_storage ss; 1655 struct sockaddr *sa = (struct sockaddr *)&ss; 1656 socklen_t salen; 1657 int snmp_s, ax_s; 1658 uint32_t sessionid; 1659 struct varbind varbind = { 1660 .type = TYPE_NULL, 1661 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 1), 1662 .data.int32 = 1 1663 }; 1664 struct searchrange searchrange = { 1665 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 1), 1666 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 2) 1667 }; 1668 int32_t requestid; 1669 char buf[1024]; 1670 size_t n; 1671 1672 ax_s = agentx_connect(axsocket); 1673 sessionid = agentx_open(ax_s, 0, 0, 1674 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 1), __func__); 1675 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1676 OID_ARG(MIB_BACKEND_GETNEXT, 1), 0); 1677 1678 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1679 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1680 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1681 1682 varbind.name.subid[varbind.name.n_subid++] = 0; 1683 varbind.type = TYPE_INTEGER; 1684 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1685 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 1686 &varbind, 1); 1687 1688 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1689 1690 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1691 &varbind, 1); 1692 } 1693 1694 void 1695 backend_getnext_lowerbound(void) 1696 { 1697 struct sockaddr_storage ss; 1698 struct sockaddr *sa = (struct sockaddr *)&ss; 1699 socklen_t salen; 1700 int snmp_s, ax_s; 1701 uint32_t sessionid1, sessionid2; 1702 struct varbind varbind = { 1703 .type = TYPE_NULL, 1704 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 2), 1705 .data.int32 = 1 1706 }; 1707 struct searchrange searchrange = { 1708 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 2), 1709 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 2, 1) 1710 }; 1711 int32_t requestid; 1712 char buf[1024]; 1713 size_t n; 1714 1715 ax_s = agentx_connect(axsocket); 1716 sessionid1 = agentx_open(ax_s, 0, 0, 1717 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 2, 1), 1718 "backend_getnext_lowerbound.1"); 1719 sessionid2 = agentx_open(ax_s, 0, 0, 1720 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 2, 2), 1721 "backend_getnext_lowerbound.2"); 1722 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1723 OID_ARG(MIB_BACKEND_GETNEXT, 2), 0); 1724 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 1725 OID_ARG(MIB_BACKEND_GETNEXT, 2, 1), 0); 1726 1727 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1728 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1729 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1730 1731 varbind.name.subid[varbind.name.n_subid++] = 0; 1732 varbind.type = TYPE_INTEGER; 1733 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1734 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange, 1735 &varbind, 1); 1736 1737 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1738 1739 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1740 &varbind, 1); 1741 } 1742 1743 void 1744 backend_getnext_lowerbound_self(void) 1745 { 1746 struct sockaddr_storage ss; 1747 struct sockaddr *sa = (struct sockaddr *)&ss; 1748 socklen_t salen; 1749 int snmp_s, ax_s; 1750 uint32_t sessionid; 1751 struct varbind varbind = { 1752 .type = TYPE_NULL, 1753 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 3), 1754 .data.int32 = 1 1755 }; 1756 struct searchrange searchrange = { 1757 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 3), 1758 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 4) 1759 }; 1760 int32_t requestid; 1761 char buf[1024]; 1762 size_t n; 1763 1764 ax_s = agentx_connect(axsocket); 1765 sessionid = agentx_open(ax_s, 0, 0, 1766 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 3), __func__); 1767 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1768 OID_ARG(MIB_BACKEND_GETNEXT, 3), 0); 1769 1770 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1771 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1772 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1773 1774 varbind.name.subid[varbind.name.n_subid++] = 0; 1775 varbind.type = TYPE_INTEGER; 1776 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1777 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 1778 &varbind, 1); 1779 1780 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1781 1782 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1783 &varbind, 1); 1784 } 1785 1786 void 1787 backend_getnext_lowerbound_highprio(void) 1788 { 1789 struct sockaddr_storage ss; 1790 struct sockaddr *sa = (struct sockaddr *)&ss; 1791 socklen_t salen; 1792 int snmp_s, ax_s; 1793 uint32_t sessionid1, sessionid2; 1794 struct varbind varbind = { 1795 .type = TYPE_NULL, 1796 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 4), 1797 .data.int32 = 1 1798 }; 1799 struct searchrange searchrange = { 1800 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 4), 1801 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 4, 1) 1802 }; 1803 int32_t requestid; 1804 char buf[1024]; 1805 size_t n; 1806 1807 ax_s = agentx_connect(axsocket); 1808 sessionid1 = agentx_open(ax_s, 0, 0, 1809 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 4, 1), 1810 "backend_getnext_lowerbound_highprio.1"); 1811 sessionid2 = agentx_open(ax_s, 0, 0, 1812 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 4, 2), 1813 "backend_getnext_lowerbound_highprio.2"); 1814 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1815 OID_ARG(MIB_BACKEND_GETNEXT, 4), 0); 1816 agentx_register(ax_s, sessionid2, 0, 0, 128, 0, 1817 OID_ARG(MIB_BACKEND_GETNEXT, 4, 1), 0); 1818 1819 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1820 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1821 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1822 1823 varbind.name.subid[varbind.name.n_subid++] = 0; 1824 varbind.type = TYPE_INTEGER; 1825 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1826 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange, 1827 &varbind, 1); 1828 1829 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1830 1831 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1832 &varbind, 1); 1833 } 1834 1835 void 1836 backend_getnext_lowerbound_lowprio(void) 1837 { 1838 struct sockaddr_storage ss; 1839 struct sockaddr *sa = (struct sockaddr *)&ss; 1840 socklen_t salen; 1841 int snmp_s, ax_s; 1842 uint32_t sessionid1, sessionid2; 1843 struct varbind varbind = { 1844 .type = TYPE_NULL, 1845 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 5), 1846 .data.int32 = 1 1847 }; 1848 struct searchrange searchrange = { 1849 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 5), 1850 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 5, 1) 1851 }; 1852 int32_t requestid; 1853 char buf[1024]; 1854 size_t n; 1855 1856 ax_s = agentx_connect(axsocket); 1857 sessionid1 = agentx_open(ax_s, 0, 0, 1858 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 5, 1), 1859 "backend_getnext_lowerbound_lowprio.1"); 1860 sessionid2 = agentx_open(ax_s, 0, 0, 1861 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 5, 2), 1862 "backend_getnext_lowerbound_lowprio.2"); 1863 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1864 OID_ARG(MIB_BACKEND_GETNEXT, 5), 0); 1865 agentx_register(ax_s, sessionid2, 0, 0, 128, 0, 1866 OID_ARG(MIB_BACKEND_GETNEXT, 5, 1), 0); 1867 1868 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1869 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1870 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1871 1872 varbind.name.subid[varbind.name.n_subid++] = 0; 1873 varbind.type = TYPE_INTEGER; 1874 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1875 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange, 1876 &varbind, 1); 1877 1878 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1879 1880 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1881 &varbind, 1); 1882 } 1883 1884 void 1885 backend_getnext_sibling(void) 1886 { 1887 struct sockaddr_storage ss; 1888 struct sockaddr *sa = (struct sockaddr *)&ss; 1889 socklen_t salen; 1890 int snmp_s, ax_s; 1891 uint32_t sessionid; 1892 struct varbind varbind = { 1893 .type = TYPE_NULL, 1894 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 6), 1895 .data.int32 = 1 1896 }; 1897 struct searchrange searchrange = { 1898 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 6), 1899 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 8) 1900 }; 1901 int32_t requestid; 1902 char buf[1024]; 1903 size_t n; 1904 1905 ax_s = agentx_connect(axsocket); 1906 sessionid = agentx_open(ax_s, 0, 0, 1907 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6), __func__); 1908 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1909 OID_ARG(MIB_BACKEND_GETNEXT, 6), 0); 1910 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 1911 OID_ARG(MIB_BACKEND_GETNEXT, 7), 0); 1912 1913 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1914 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1915 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1916 1917 varbind.name.subid[varbind.name.n_subid++] = 0; 1918 varbind.type = TYPE_INTEGER; 1919 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1920 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 1921 &varbind, 1); 1922 1923 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1924 1925 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1926 &varbind, 1); 1927 } 1928 1929 void 1930 backend_getnext_child_gap(void) 1931 { 1932 struct sockaddr_storage ss; 1933 struct sockaddr *sa = (struct sockaddr *)&ss; 1934 socklen_t salen; 1935 int snmp_s, ax_s; 1936 uint32_t sessionid1, sessionid2; 1937 struct varbind varbind = { 1938 .type = TYPE_NULL, 1939 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 7), 1940 .data.int32 = 1 1941 }; 1942 struct searchrange searchrange = { 1943 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 7), 1944 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 7, 2) 1945 }; 1946 int32_t requestid; 1947 char buf[1024]; 1948 size_t n; 1949 1950 ax_s = agentx_connect(axsocket); 1951 sessionid1 = agentx_open(ax_s, 0, 0, 1952 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6, 1), 1953 "backend_getnext_child_gap.1"); 1954 sessionid2 = agentx_open(ax_s, 0, 0, 1955 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6, 2), 1956 "backend_getnext_child_gap.2"); 1957 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 1958 OID_ARG(MIB_BACKEND_GETNEXT, 7), 0); 1959 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 1960 OID_ARG(MIB_BACKEND_GETNEXT, 7, 2), 0); 1961 1962 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 1963 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 1964 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 1965 1966 varbind.name.subid[varbind.name.n_subid++] = 0; 1967 varbind.type = TYPE_INTEGER; 1968 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 1969 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange, 1970 &varbind, 1); 1971 1972 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 1973 1974 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 1975 &varbind, 1); 1976 } 1977 1978 void 1979 backend_getnext_nosuchobject(void) 1980 { 1981 struct sockaddr_storage ss; 1982 struct sockaddr *sa = (struct sockaddr *)&ss; 1983 socklen_t salen; 1984 int snmp_s, ax_s; 1985 uint32_t sessionid; 1986 struct varbind varbind = { 1987 .type = TYPE_NULL, 1988 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 8), 1989 }; 1990 struct searchrange searchrange = { 1991 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 8), 1992 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 9) 1993 }; 1994 int32_t requestid; 1995 char buf[1024]; 1996 size_t n; 1997 1998 ax_s = agentx_connect(axsocket); 1999 sessionid = agentx_open(ax_s, 0, 0, 2000 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 8), __func__); 2001 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2002 OID_ARG(MIB_BACKEND_GETNEXT, 8), 0); 2003 2004 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2005 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2006 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2007 2008 varbind.name.subid[varbind.name.n_subid++] = 0; 2009 varbind.type = TYPE_NOSUCHOBJECT; 2010 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2011 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2012 &varbind, 1); 2013 varbind.name.n_subid--; 2014 varbind.type = TYPE_NULL; 2015 2016 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2017 2018 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2019 &varbind, 1); 2020 } 2021 2022 void 2023 backend_getnext_nosuchinstance(void) 2024 { 2025 struct sockaddr_storage ss; 2026 struct sockaddr *sa = (struct sockaddr *)&ss; 2027 socklen_t salen; 2028 int snmp_s, ax_s; 2029 uint32_t sessionid; 2030 struct varbind varbind = { 2031 .type = TYPE_NULL, 2032 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 9), 2033 }; 2034 struct searchrange searchrange = { 2035 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 9), 2036 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 10) 2037 }; 2038 int32_t requestid; 2039 char buf[1024]; 2040 size_t n; 2041 2042 ax_s = agentx_connect(axsocket); 2043 sessionid = agentx_open(ax_s, 0, 0, 2044 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 9), __func__); 2045 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2046 OID_ARG(MIB_BACKEND_GETNEXT, 9), 0); 2047 2048 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2049 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2050 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2051 2052 varbind.name.subid[varbind.name.n_subid++] = 0; 2053 varbind.type = TYPE_NOSUCHINSTANCE; 2054 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2055 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2056 &varbind, 1); 2057 varbind.name.n_subid--; 2058 varbind.type = TYPE_NULL; 2059 2060 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2061 2062 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2063 &varbind, 1); 2064 } 2065 2066 /* Assume that everything is registered under 1.3.* */ 2067 void 2068 backend_getnext_endofmibview(void) 2069 { 2070 struct sockaddr_storage ss; 2071 struct sockaddr *sa = (struct sockaddr *)&ss; 2072 socklen_t salen; 2073 int snmp_s, ax_s; 2074 uint32_t sessionid; 2075 struct varbind varbind = { 2076 .type = TYPE_NULL, 2077 .name = OID_STRUCT(2, 0), 2078 }; 2079 struct searchrange searchrange = { 2080 .start = OID_STRUCT(2, 0), 2081 .end = OID_STRUCT(2, 1) 2082 }; 2083 int32_t requestid; 2084 char buf[1024]; 2085 size_t n; 2086 2087 ax_s = agentx_connect(axsocket); 2088 sessionid = agentx_open(ax_s, 0, 0, 2089 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 10), __func__); 2090 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2091 OID_ARG(2, 0), 0); 2092 2093 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2094 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2095 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2096 2097 varbind.name.subid[varbind.name.n_subid++] = 0; 2098 varbind.type = TYPE_ENDOFMIBVIEW; 2099 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2100 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2101 &varbind, 1); 2102 varbind.name.n_subid--; 2103 2104 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2105 2106 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2107 &varbind, 1); 2108 } 2109 2110 void 2111 backend_getnext_inclusive(void) 2112 { 2113 struct sockaddr_storage ss; 2114 struct sockaddr *sa = (struct sockaddr *)&ss; 2115 socklen_t salen; 2116 int snmp_s, ax_s; 2117 uint32_t sessionid; 2118 struct varbind varbind = { 2119 .type = TYPE_NULL, 2120 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 11), 2121 .data.int32 = 1 2122 }; 2123 struct searchrange searchrange = { 2124 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 11, 0), 2125 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 11, 1) 2126 }; 2127 int32_t requestid; 2128 char buf[1024]; 2129 size_t n; 2130 2131 searchrange.start.include = 1; 2132 ax_s = agentx_connect(axsocket); 2133 sessionid = agentx_open(ax_s, 0, 0, 2134 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 11), __func__); 2135 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2136 OID_ARG(MIB_BACKEND_GETNEXT, 11, 0), 0); 2137 2138 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2139 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2140 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2141 2142 varbind.name.subid[varbind.name.n_subid++] = 0; 2143 varbind.type = TYPE_INTEGER; 2144 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2145 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2146 &varbind, 1); 2147 2148 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2149 2150 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 2151 &varbind, 1); 2152 } 2153 2154 void 2155 backend_getnext_jumpnext(void) 2156 { 2157 struct sockaddr_storage ss; 2158 struct sockaddr *sa = (struct sockaddr *)&ss; 2159 socklen_t salen; 2160 int snmp_s, ax_s; 2161 uint32_t sessionid1, sessionid2; 2162 struct varbind varbind1 = { 2163 .type = TYPE_NULL, 2164 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 12) 2165 }, varbind2 = { 2166 .type = TYPE_INTEGER, 2167 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1), 2168 .data.int32 = 1 2169 }; 2170 struct searchrange searchrange1 = { 2171 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 12), 2172 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1) 2173 }, searchrange2 = { 2174 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1), 2175 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 2) 2176 }; 2177 int32_t requestid; 2178 char buf[1024]; 2179 size_t n; 2180 2181 ax_s = agentx_connect(axsocket); 2182 sessionid1 = agentx_open(ax_s, 0, 0, 2183 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 12, 1), 2184 "backend_getnext_jumpnext.1"); 2185 sessionid2 = agentx_open(ax_s, 0, 0, 2186 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 12, 2), 2187 "backend_getnext_jumpnext.2"); 2188 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 2189 OID_ARG(MIB_BACKEND_GETNEXT, 12), 0); 2190 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 2191 OID_ARG(MIB_BACKEND_GETNEXT, 12, 1), 0); 2192 2193 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2194 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2195 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1); 2196 2197 varbind1.type = TYPE_ENDOFMIBVIEW; 2198 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2199 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1, 2200 &varbind1, 1); 2201 agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1); 2202 2203 searchrange2.start.include = 1; 2204 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2205 agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2, 2206 &varbind2, 1); 2207 agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1); 2208 2209 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 2210 &varbind2, 1); 2211 } 2212 2213 /* Assume that everything is registered under 1.3.* */ 2214 void 2215 backend_getnext_jumpnext_endofmibview(void) 2216 { 2217 struct sockaddr_storage ss; 2218 struct sockaddr *sa = (struct sockaddr *)&ss; 2219 socklen_t salen; 2220 int snmp_s, ax_s; 2221 uint32_t sessionid1, sessionid2; 2222 struct varbind varbind1 = { 2223 .type = TYPE_NULL, 2224 .name = OID_STRUCT(2, 0) 2225 }, varbind2 = { 2226 .type = TYPE_ENDOFMIBVIEW, 2227 .name = OID_STRUCT(2, 1), 2228 }; 2229 struct searchrange searchrange1 = { 2230 .start = OID_STRUCT(2, 0), 2231 .end = OID_STRUCT(2, 1) 2232 }, searchrange2 = { 2233 .start = OID_STRUCT(2, 1), 2234 .end = OID_STRUCT(2, 2) 2235 }; 2236 int32_t requestid; 2237 char buf[1024]; 2238 size_t n; 2239 2240 ax_s = agentx_connect(axsocket); 2241 sessionid1 = agentx_open(ax_s, 0, 0, 2242 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 13, 1), 2243 "backend_getnext_jumpnext_endofmibview.1"); 2244 sessionid2 = agentx_open(ax_s, 0, 0, 2245 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 13, 2), 2246 "backend_getnext_jumpnext_endofmibview.2"); 2247 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 2248 OID_ARG(2, 0), 0); 2249 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 2250 OID_ARG(2, 1), 0); 2251 2252 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2253 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2254 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1); 2255 2256 varbind1.type = TYPE_ENDOFMIBVIEW; 2257 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2258 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1, 2259 &varbind1, 1); 2260 agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1); 2261 2262 searchrange2.start.include = 1; 2263 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2264 agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2, 2265 &varbind2, 1); 2266 agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1); 2267 2268 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 2269 &varbind1, 1); 2270 } 2271 2272 void 2273 backend_getnext_jump_up(void) 2274 { 2275 struct sockaddr_storage ss; 2276 struct sockaddr *sa = (struct sockaddr *)&ss; 2277 socklen_t salen; 2278 int snmp_s, ax_s; 2279 uint32_t sessionid1, sessionid2; 2280 struct varbind varbind1 = { 2281 .type = TYPE_NULL, 2282 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 1) 2283 }, varbind2 = { 2284 .type = TYPE_INTEGER, 2285 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2), 2286 .data.int32 = 1 2287 }; 2288 struct searchrange searchrange1 = { 2289 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 1), 2290 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2) 2291 }, searchrange2 = { 2292 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2), 2293 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 15) 2294 }; 2295 int32_t requestid; 2296 char buf[1024]; 2297 size_t n; 2298 2299 ax_s = agentx_connect(axsocket); 2300 sessionid1 = agentx_open(ax_s, 0, 0, 2301 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 14, 1), 2302 "backend_getnext_jump_up.1"); 2303 sessionid2 = agentx_open(ax_s, 0, 0, 2304 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 14, 2), 2305 "backend_getnext_jump_up.2"); 2306 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 2307 OID_ARG(MIB_BACKEND_GETNEXT, 14), 0); 2308 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 2309 OID_ARG(MIB_BACKEND_GETNEXT, 14, 1), 0); 2310 2311 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2312 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2313 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1); 2314 2315 varbind1.type = TYPE_ENDOFMIBVIEW; 2316 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2317 agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange1, 2318 &varbind1, 1); 2319 agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1); 2320 2321 searchrange2.start.include = 1; 2322 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2323 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange2, 2324 &varbind2, 1); 2325 agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1); 2326 2327 snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0, 2328 &varbind2, 1); 2329 } 2330 2331 void 2332 backend_getnext_two_single_backend(void) 2333 { 2334 struct sockaddr_storage ss; 2335 struct sockaddr *sa = (struct sockaddr *)&ss; 2336 socklen_t salen; 2337 int snmp_s, ax_s; 2338 uint32_t sessionid; 2339 struct varbind varbind[] = { 2340 { 2341 .type = TYPE_NULL, 2342 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 0), 2343 .data.int32 = 1 2344 }, 2345 { 2346 .type = TYPE_NULL, 2347 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1), 2348 .data.int32 = 2 2349 } 2350 }; 2351 struct varbind varbind_ax[] = { 2352 { 2353 .type = TYPE_INTEGER, 2354 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1), 2355 .data.int32 = 1 2356 }, 2357 { 2358 .type = TYPE_INTEGER, 2359 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 2), 2360 .data.int32 = 2 2361 } 2362 }; 2363 struct searchrange searchrange[] = { 2364 { 2365 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 0), 2366 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16) 2367 }, 2368 { 2369 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1), 2370 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16) 2371 } 2372 }; 2373 int32_t requestid; 2374 char buf[1024]; 2375 size_t n; 2376 2377 ax_s = agentx_connect(axsocket); 2378 sessionid = agentx_open(ax_s, 0, 0, 2379 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 15), __func__); 2380 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2381 OID_ARG(MIB_BACKEND_GETNEXT, 15), 0); 2382 2383 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2384 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2385 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2); 2386 2387 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2388 agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange, 2389 varbind_ax, 2); 2390 2391 agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2); 2392 2393 varbind[0].type = varbind[1].type = TYPE_INTEGER; 2394 varbind[0].name.subid[varbind[0].name.n_subid -1]++; 2395 varbind[1].name.subid[varbind[1].name.n_subid - 1]++; 2396 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2397 varbind, 2); 2398 } 2399 2400 void 2401 backend_getnext_two_double_backend(void) 2402 { 2403 struct sockaddr_storage ss; 2404 struct sockaddr *sa = (struct sockaddr *)&ss; 2405 socklen_t salen; 2406 int snmp_s, ax_s1, ax_s2; 2407 uint32_t sessionid1, sessionid2; 2408 struct varbind varbind[] = { 2409 { 2410 .type = TYPE_NULL, 2411 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 1), 2412 .data.int32 = 1 2413 }, 2414 { 2415 .type = TYPE_NULL, 2416 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2), 2417 .data.int32 = 2 2418 } 2419 }; 2420 struct searchrange searchrange1 = { 2421 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 1), 2422 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2) 2423 }, searchrange2 = { 2424 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2), 2425 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 3) 2426 }; 2427 int32_t requestid; 2428 char buf[1024]; 2429 size_t n; 2430 2431 ax_s1 = agentx_connect(axsocket); 2432 ax_s2 = agentx_connect(axsocket); 2433 sessionid1 = agentx_open(ax_s1, 0, 0, 2434 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 16, 1), 2435 "backend_getnext_two_double_backend.1"); 2436 sessionid2 = agentx_open(ax_s2, 0, 0, 2437 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 16, 2), 2438 "backend_getnext_two_double_backend.2"); 2439 agentx_register(ax_s1, sessionid1, 0, 0, 127, 0, 2440 OID_ARG(MIB_BACKEND_GETNEXT, 16, 1), 0); 2441 agentx_register(ax_s2, sessionid2, 0, 0, 127, 0, 2442 OID_ARG(MIB_BACKEND_GETNEXT, 16, 2), 0); 2443 2444 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2445 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2446 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2); 2447 2448 varbind[0].name.subid[varbind[0].name.n_subid++] = 0; 2449 varbind[1].name.subid[varbind[1].name.n_subid++] = 0; 2450 varbind[0].type = varbind[1].type = TYPE_INTEGER; 2451 n = agentx_read(ax_s1, buf, sizeof(buf), 1000); 2452 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1, 2453 varbind + 0, 1); 2454 agentx_response(ax_s1, buf, NOERROR, 0, varbind + 0, 1); 2455 2456 n = agentx_read(ax_s2, buf, sizeof(buf), 1000); 2457 agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2, 2458 varbind + 1, 1); 2459 agentx_response(ax_s2, buf, NOERROR, 0, varbind + 1, 1); 2460 2461 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2462 varbind, 2); 2463 } 2464 2465 void 2466 backend_getnext_instance_below(void) 2467 { 2468 struct sockaddr_storage ss; 2469 struct sockaddr *sa = (struct sockaddr *)&ss; 2470 socklen_t salen; 2471 int snmp_s, ax_s; 2472 uint32_t sessionid; 2473 struct varbind varbind = { 2474 .type = TYPE_NULL, 2475 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 1, 1), 2476 .data.int32 = 1 2477 }; 2478 struct searchrange searchrange = { 2479 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 2), 2480 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 3) 2481 }; 2482 int32_t requestid; 2483 char buf[1024]; 2484 size_t n; 2485 2486 ax_s = agentx_connect(axsocket); 2487 sessionid = agentx_open(ax_s, 0, 0, 2488 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 17), __func__); 2489 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 2490 OID_ARG(MIB_BACKEND_GETNEXT, 17, 1), 0); 2491 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2492 OID_ARG(MIB_BACKEND_GETNEXT, 17, 2), 0); 2493 2494 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2495 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2496 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2497 2498 varbind.type = TYPE_INTEGER; 2499 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 2); 2500 searchrange.start.include = 1; 2501 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2502 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2503 &varbind, 1); 2504 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2505 2506 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2507 &varbind, 1); 2508 } 2509 2510 void 2511 backend_getnext_instance(void) 2512 { 2513 struct sockaddr_storage ss; 2514 struct sockaddr *sa = (struct sockaddr *)&ss; 2515 socklen_t salen; 2516 int snmp_s, ax_s; 2517 uint32_t sessionid; 2518 struct varbind varbind = { 2519 .type = TYPE_NULL, 2520 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 18), 2521 .data.int32 = 1 2522 }; 2523 struct searchrange searchrange = { 2524 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 1), 2525 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 2) 2526 }; 2527 int32_t requestid; 2528 char buf[1024]; 2529 size_t n; 2530 2531 ax_s = agentx_connect(axsocket); 2532 sessionid = agentx_open(ax_s, 0, 0, 2533 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 18), __func__); 2534 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 2535 OID_ARG(MIB_BACKEND_GETNEXT, 18, 1), 0); 2536 2537 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2538 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2539 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2540 2541 varbind.type = TYPE_INTEGER; 2542 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 1); 2543 searchrange.start.include = 1; 2544 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2545 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2546 &varbind, 1); 2547 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2548 2549 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2550 &varbind, 1); 2551 } 2552 2553 void 2554 backend_getnext_instance_exact(void) 2555 { 2556 struct sockaddr_storage ss; 2557 struct sockaddr *sa = (struct sockaddr *)&ss; 2558 socklen_t salen; 2559 int snmp_s, ax_s; 2560 uint32_t sessionid; 2561 struct varbind varbind = { 2562 .type = TYPE_NULL, 2563 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 1), 2564 .data.int32 = 1 2565 }; 2566 struct searchrange searchrange = { 2567 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 2), 2568 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 3) 2569 }; 2570 int32_t requestid; 2571 char buf[1024]; 2572 size_t n; 2573 2574 ax_s = agentx_connect(axsocket); 2575 sessionid = agentx_open(ax_s, 0, 0, 2576 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 19), __func__); 2577 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 2578 OID_ARG(MIB_BACKEND_GETNEXT, 19, 1), 0); 2579 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2580 OID_ARG(MIB_BACKEND_GETNEXT, 19, 2), 0); 2581 2582 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2583 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2584 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2585 2586 varbind.type = TYPE_INTEGER; 2587 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 2); 2588 searchrange.start.include = 1; 2589 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2590 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2591 &varbind, 1); 2592 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2593 2594 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 2595 &varbind, 1); 2596 } 2597 2598 void 2599 backend_getnext_instance_ignore(void) 2600 { 2601 struct sockaddr_storage ss; 2602 struct sockaddr *sa = (struct sockaddr *)&ss; 2603 socklen_t salen; 2604 int snmp_s, ax_s; 2605 uint32_t sessionid; 2606 struct varbind varbind = { 2607 .type = TYPE_NULL, 2608 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20), 2609 .data.int32 = 1 2610 }; 2611 struct searchrange searchrange = { 2612 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 1), 2613 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 2) 2614 }; 2615 int32_t requestid; 2616 char buf[1024]; 2617 size_t n; 2618 2619 ax_s = agentx_connect(axsocket); 2620 sessionid = agentx_open(ax_s, 0, 0, 2621 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 20), __func__); 2622 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 2623 OID_ARG(MIB_BACKEND_GETNEXT, 20, 1), 0); 2624 2625 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2626 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2627 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2628 2629 varbind.type = TYPE_INTEGER; 2630 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 1, 0); 2631 searchrange.start.include = 1; 2632 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2633 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2634 &varbind, 1); 2635 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2636 varbind.type = TYPE_NULL; 2637 varbind.name.n_subid -= 2; 2638 2639 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2640 &varbind, 1); 2641 } 2642 2643 void 2644 backend_getnext_backwards(void) 2645 { 2646 struct sockaddr_storage ss; 2647 struct sockaddr *sa = (struct sockaddr *)&ss; 2648 socklen_t salen; 2649 int snmp_s, ax_s; 2650 uint32_t sessionid; 2651 struct varbind varbind = { 2652 .type = TYPE_NULL, 2653 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21), 2654 .data.int32 = 1 2655 }; 2656 struct searchrange searchrange = { 2657 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 21), 2658 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 22) 2659 }; 2660 int32_t requestid; 2661 char buf[1024]; 2662 size_t n; 2663 2664 ax_s = agentx_connect(axsocket); 2665 sessionid = agentx_open(ax_s, 0, 0, 2666 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 21), __func__); 2667 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2668 OID_ARG(MIB_BACKEND_GETNEXT, 21), 0); 2669 2670 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2671 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2672 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2673 2674 varbind.type = TYPE_INTEGER; 2675 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21, 1); 2676 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2677 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2678 &varbind, 1); 2679 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20); 2680 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2681 varbind.type = TYPE_NULL; 2682 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21); 2683 2684 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2685 &varbind, 1); 2686 } 2687 2688 void 2689 backend_getnext_stale(void) 2690 { 2691 struct sockaddr_storage ss; 2692 struct sockaddr *sa = (struct sockaddr *)&ss; 2693 socklen_t salen; 2694 int snmp_s, ax_s; 2695 uint32_t sessionid; 2696 struct varbind varbind = { 2697 .type = TYPE_NULL, 2698 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22), 2699 .data.int32 = 1 2700 }; 2701 struct searchrange searchrange = { 2702 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 22), 2703 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 23) 2704 }; 2705 int32_t requestid; 2706 char buf[1024]; 2707 size_t n; 2708 2709 ax_s = agentx_connect(axsocket); 2710 sessionid = agentx_open(ax_s, 0, 0, 2711 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 22), __func__); 2712 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2713 OID_ARG(MIB_BACKEND_GETNEXT, 22), 0); 2714 2715 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2716 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2717 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2718 2719 varbind.type = TYPE_INTEGER; 2720 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22, 1); 2721 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2722 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2723 &varbind, 1); 2724 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22); 2725 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2726 varbind.type = TYPE_NULL; 2727 2728 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2729 &varbind, 1); 2730 } 2731 2732 void 2733 backend_getnext_inclusive_backwards(void) 2734 { 2735 struct sockaddr_storage ss; 2736 struct sockaddr *sa = (struct sockaddr *)&ss; 2737 socklen_t salen; 2738 int snmp_s, ax_s; 2739 uint32_t sessionid; 2740 struct varbind varbind = { 2741 .type = TYPE_NULL, 2742 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23), 2743 .data.int32 = 1 2744 }; 2745 struct searchrange searchrange = { 2746 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 1), 2747 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 2) 2748 }; 2749 int32_t requestid; 2750 char buf[1024]; 2751 size_t n; 2752 2753 ax_s = agentx_connect(axsocket); 2754 sessionid = agentx_open(ax_s, 0, 0, 2755 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 23), __func__); 2756 agentx_register(ax_s, sessionid, 1, 0, 127, 0, 2757 OID_ARG(MIB_BACKEND_GETNEXT, 23, 1), 0); 2758 2759 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2760 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2761 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 2762 2763 varbind.type = TYPE_INTEGER; 2764 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 1); 2765 searchrange.start.include = 1; 2766 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2767 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 2768 &varbind, 1); 2769 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22); 2770 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 2771 varbind.type = TYPE_NULL; 2772 varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23); 2773 2774 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2775 &varbind, 1); 2776 } 2777 2778 void 2779 backend_getnext_toofew(void) 2780 { 2781 struct sockaddr_storage ss; 2782 struct sockaddr *sa = (struct sockaddr *)&ss; 2783 socklen_t salen; 2784 int snmp_s, ax_s; 2785 uint32_t sessionid; 2786 struct varbind varbind[] = { 2787 { 2788 .type = TYPE_NULL, 2789 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0), 2790 .data.int32 = 1 2791 }, 2792 { 2793 .type = TYPE_NULL, 2794 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1), 2795 .data.int32 = 2 2796 } 2797 }; 2798 struct searchrange searchrange[] = { 2799 { 2800 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0), 2801 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 25) 2802 }, 2803 { 2804 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1), 2805 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 25) 2806 } 2807 }; 2808 int32_t requestid; 2809 char buf[1024]; 2810 size_t n; 2811 2812 ax_s = agentx_connect(axsocket); 2813 sessionid = agentx_open(ax_s, 0, 0, 2814 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 24), __func__); 2815 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2816 OID_ARG(MIB_BACKEND_GETNEXT, 24), 0); 2817 2818 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2819 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2820 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2); 2821 2822 varbind[0].name.subid[varbind[0].name.n_subid - 1]++; 2823 varbind[1].name.subid[varbind[1].name.n_subid - 1]++; 2824 varbind[0].type = varbind[1].type = TYPE_INTEGER; 2825 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2826 agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange, 2827 varbind, 2); 2828 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 2829 varbind[0].type = varbind[1].type = TYPE_NULL; 2830 varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0), 2831 varbind[1].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1), 2832 2833 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2, 2834 varbind, 2); 2835 } 2836 2837 void 2838 backend_getnext_toomany(void) 2839 { 2840 struct sockaddr_storage ss; 2841 struct sockaddr *sa = (struct sockaddr *)&ss; 2842 socklen_t salen; 2843 int snmp_s, ax_s; 2844 uint32_t sessionid; 2845 struct varbind varbind[] = { 2846 { 2847 .type = TYPE_NULL, 2848 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0), 2849 .data.int32 = 1 2850 }, 2851 { 2852 .type = TYPE_NULL, 2853 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1), 2854 .data.int32 = 2 2855 }, 2856 { 2857 .type = TYPE_NULL, 2858 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 3), 2859 .data.int32 = 3 2860 } 2861 }; 2862 struct searchrange searchrange[] = { 2863 { 2864 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0), 2865 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26) 2866 }, 2867 { 2868 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1), 2869 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26) 2870 } 2871 }; 2872 int32_t requestid; 2873 char buf[1024]; 2874 size_t n; 2875 2876 ax_s = agentx_connect(axsocket); 2877 sessionid = agentx_open(ax_s, 0, 0, 2878 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 25), __func__); 2879 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 2880 OID_ARG(MIB_BACKEND_GETNEXT, 25), 0); 2881 2882 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2883 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2884 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2); 2885 2886 varbind[0].name.subid[varbind[0].name.n_subid - 1]++; 2887 varbind[1].name.subid[varbind[1].name.n_subid - 1]++; 2888 varbind[0].type = varbind[1].type = TYPE_INTEGER; 2889 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2890 agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange, 2891 varbind, 2); 2892 agentx_response(ax_s, buf, NOERROR, 0, varbind, 3); 2893 varbind[0].type = varbind[1].type = TYPE_NULL; 2894 varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0), 2895 varbind[1].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1), 2896 2897 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2, 2898 varbind, 2); 2899 } 2900 2901 void 2902 backend_getnext_response_equal_end(void) 2903 { 2904 struct sockaddr_storage ss; 2905 struct sockaddr *sa = (struct sockaddr *)&ss; 2906 socklen_t salen; 2907 int snmp_s, ax_s; 2908 uint32_t sessionid1, sessionid2; 2909 struct varbind varbind[] = { 2910 { 2911 .type = TYPE_NULL, 2912 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 26), 2913 .data.int32 = 1 2914 }, 2915 }; 2916 struct searchrange searchrange[] = { 2917 { 2918 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 26), 2919 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26, 1, 1) 2920 }, 2921 }; 2922 int32_t requestid; 2923 char buf[1024]; 2924 size_t n; 2925 2926 ax_s = agentx_connect(axsocket); 2927 sessionid1 = agentx_open(ax_s, 0, 0, 2928 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 26, 1), 2929 "backend_getnext_end_equal.1"); 2930 sessionid2 = agentx_open(ax_s, 0, 0, 2931 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 26, 2), 2932 "backend_getnext_end_equal.2"); 2933 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 2934 OID_ARG(MIB_BACKEND_GETNEXT, 26), 0); 2935 agentx_register(ax_s, sessionid2, 0, 0, 127, 0, 2936 OID_ARG(MIB_BACKEND_GETNEXT, 26, 1, 1), 0); 2937 2938 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2939 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2940 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1); 2941 2942 /* Fool agentx_getnext_handle() */ 2943 varbind[0].name.subid[varbind[0].name.n_subid++] = 1; 2944 varbind[0].type = TYPE_INTEGER; 2945 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2946 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange, 2947 varbind, 1); 2948 varbind[0].name = searchrange[0].end; 2949 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 2950 varbind[0].type = TYPE_NULL; 2951 varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 26), 2952 2953 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 2954 varbind, 1); 2955 } 2956 2957 void 2958 backend_getnext_instance_below_region_before_instance(void) 2959 { 2960 struct sockaddr_storage ss; 2961 struct sockaddr *sa = (struct sockaddr *)&ss; 2962 socklen_t salen; 2963 int snmp_s, ax_s; 2964 uint32_t sessionid1, sessionid2; 2965 struct varbind varbind[] = { 2966 { 2967 .type = TYPE_NULL, 2968 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 27), 2969 .data.int32 = 1 2970 }, 2971 }; 2972 struct searchrange searchrange[] = { 2973 { 2974 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 27), 2975 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 27, 1, 0) 2976 }, 2977 }; 2978 int32_t requestid; 2979 char buf[1024]; 2980 size_t n; 2981 2982 ax_s = agentx_connect(axsocket); 2983 sessionid1 = agentx_open(ax_s, 0, 0, 2984 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 27, 1), 2985 "backend_getnext_instance_below_region_before_instance.1"); 2986 sessionid2 = agentx_open(ax_s, 0, 0, 2987 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 27, 2), 2988 "backend_getnext_instance_below_region_before_instance.2"); 2989 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 2990 OID_ARG(MIB_BACKEND_GETNEXT, 27), 0); 2991 agentx_register(ax_s, sessionid2, 1, 0, 127, 0, 2992 OID_ARG(MIB_BACKEND_GETNEXT, 27, 1, 0), 0); 2993 2994 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 2995 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 2996 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1); 2997 2998 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 2999 varbind[0].type = TYPE_ENDOFMIBVIEW; 3000 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange, 3001 varbind, 1); 3002 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 3003 3004 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3005 varbind[0].name = searchrange[0].end; 3006 varbind[0].type = TYPE_INTEGER; 3007 searchrange[0].start = searchrange[0].end; 3008 searchrange[0].start.include = 1; 3009 searchrange[0].end.subid[searchrange[0].end.n_subid - 1]++; 3010 agentx_getnext_handle(__func__, buf, n, 0, sessionid2, searchrange, 3011 varbind, 1); 3012 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 3013 3014 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3015 varbind, 1); 3016 } 3017 3018 void 3019 backend_getnext_instance_below_region_on_instance(void) 3020 { 3021 struct sockaddr_storage ss; 3022 struct sockaddr *sa = (struct sockaddr *)&ss; 3023 socklen_t salen; 3024 int snmp_s, ax_s; 3025 uint32_t sessionid1, sessionid2; 3026 struct varbind varbind[] = { 3027 { 3028 .type = TYPE_NULL, 3029 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 28, 1, 0), 3030 .data.int32 = 1 3031 }, 3032 }; 3033 struct searchrange searchrange[] = { 3034 { 3035 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 28, 1, 1), 3036 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 29) 3037 }, 3038 }; 3039 int32_t requestid; 3040 char buf[1024]; 3041 size_t n; 3042 3043 ax_s = agentx_connect(axsocket); 3044 sessionid1 = agentx_open(ax_s, 0, 0, 3045 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 28, 1), 3046 "backend_getnext_instance_below_region_on_instance.1"); 3047 sessionid2 = agentx_open(ax_s, 0, 0, 3048 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 28, 2), 3049 "backend_getnext_instance_below_region_on_instance.2"); 3050 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 3051 OID_ARG(MIB_BACKEND_GETNEXT, 28), 0); 3052 agentx_register(ax_s, sessionid2, 1, 0, 127, 0, 3053 OID_ARG(MIB_BACKEND_GETNEXT, 28, 1, 0), 0); 3054 3055 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3056 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3057 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1); 3058 3059 searchrange[0].start.include = 1; 3060 varbind[0].name = searchrange[0].start; 3061 varbind[0].type = TYPE_INTEGER; 3062 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3063 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange, 3064 varbind, 1); 3065 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 3066 3067 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3068 varbind, 1); 3069 } 3070 3071 void 3072 backend_getnext_instance_below_region_below_instance(void) 3073 { 3074 struct sockaddr_storage ss; 3075 struct sockaddr *sa = (struct sockaddr *)&ss; 3076 socklen_t salen; 3077 int snmp_s, ax_s; 3078 uint32_t sessionid1, sessionid2; 3079 struct varbind varbind[] = { 3080 { 3081 .type = TYPE_NULL, 3082 .name = OID_STRUCT(MIB_BACKEND_GETNEXT, 29, 1, 0, 1), 3083 .data.int32 = 1 3084 }, 3085 }; 3086 struct searchrange searchrange[] = { 3087 { 3088 .start = OID_STRUCT(MIB_BACKEND_GETNEXT, 29, 1, 1), 3089 .end = OID_STRUCT(MIB_BACKEND_GETNEXT, 30) 3090 }, 3091 }; 3092 int32_t requestid; 3093 char buf[1024]; 3094 size_t n; 3095 3096 ax_s = agentx_connect(axsocket); 3097 sessionid1 = agentx_open(ax_s, 0, 0, 3098 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 29, 1), 3099 "backend_getnext_instance_below_region_below_instance.1"); 3100 sessionid2 = agentx_open(ax_s, 0, 0, 3101 OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 29, 2), 3102 "backend_getnext_instance_below_region_below_instance.2"); 3103 agentx_register(ax_s, sessionid1, 0, 0, 127, 0, 3104 OID_ARG(MIB_BACKEND_GETNEXT, 29), 0); 3105 agentx_register(ax_s, sessionid2, 1, 0, 127, 0, 3106 OID_ARG(MIB_BACKEND_GETNEXT, 29, 1, 0), 0); 3107 3108 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3109 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3110 requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1); 3111 3112 searchrange[0].start.include = 1; 3113 varbind[0].name = searchrange[0].start; 3114 varbind[0].type = TYPE_INTEGER; 3115 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3116 agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange, 3117 varbind, 1); 3118 agentx_response(ax_s, buf, NOERROR, 0, varbind, 1); 3119 3120 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3121 varbind, 1); 3122 } 3123 3124 void 3125 backend_getbulk_nonrep_zero_maxrep_one(void) 3126 { 3127 struct sockaddr_storage ss; 3128 struct sockaddr *sa = (struct sockaddr *)&ss; 3129 socklen_t salen; 3130 int snmp_s, ax_s; 3131 uint32_t sessionid; 3132 struct varbind request = { 3133 .type = TYPE_NULL, 3134 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 1) 3135 }, ax_request[] = { 3136 { 3137 .type = TYPE_INTEGER, 3138 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 1, 0), 3139 .data.int32 = 1 3140 } 3141 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3142 int32_t requestid; 3143 char buf[1024]; 3144 size_t n, nvarbind = nitems(ax_request), nout; 3145 3146 ax_s = agentx_connect(axsocket); 3147 sessionid = agentx_open(ax_s, 0, 0, 3148 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 1), __func__); 3149 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3150 OID_ARG(MIB_BACKEND_GETBULK, 1), 0); 3151 3152 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3153 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3154 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 1, &request, 1); 3155 3156 memcpy(response, ax_request, sizeof(ax_request)); 3157 while (nvarbind > 0) { 3158 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3159 nout = agentx_getbulk_handle(__func__, buf, n, 0, 3160 sessionid, ax_request, nvarbind, ax_response); 3161 agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout); 3162 nvarbind -= nout; 3163 } 3164 3165 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3166 response, nitems(response)); 3167 } 3168 3169 void 3170 backend_getbulk_nonrep_zero_maxrep_two(void) 3171 { 3172 struct sockaddr_storage ss; 3173 struct sockaddr *sa = (struct sockaddr *)&ss; 3174 socklen_t salen; 3175 int snmp_s, ax_s; 3176 uint32_t sessionid; 3177 struct varbind request = { 3178 .type = TYPE_NULL, 3179 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 2) 3180 }, ax_request[] = { 3181 { 3182 .type = TYPE_INTEGER, 3183 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 2, 1), 3184 .data.int32 = 1 3185 }, 3186 { 3187 .type = TYPE_INTEGER, 3188 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 2, 2), 3189 .data.int32 = 2 3190 } 3191 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3192 int32_t requestid; 3193 char buf[1024]; 3194 size_t n, nvarbind = nitems(ax_request), nout; 3195 3196 ax_s = agentx_connect(axsocket); 3197 sessionid = agentx_open(ax_s, 0, 0, 3198 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 2), __func__); 3199 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3200 OID_ARG(MIB_BACKEND_GETBULK, 2), 0); 3201 3202 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3203 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3204 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &request, 1); 3205 3206 memcpy(response, ax_request, sizeof(ax_request)); 3207 while (nvarbind > 0) { 3208 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3209 nout = agentx_getbulk_handle(__func__, buf, n, 0, 3210 sessionid, ax_request, nvarbind, ax_response); 3211 agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout); 3212 nvarbind -= nout; 3213 } 3214 3215 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3216 response, nitems(response)); 3217 } 3218 3219 void 3220 backend_getbulk_nonrep_one_maxrep_one(void) 3221 { 3222 struct sockaddr_storage ss; 3223 struct sockaddr *sa = (struct sockaddr *)&ss; 3224 socklen_t salen; 3225 int snmp_s, ax_s; 3226 uint32_t sessionid; 3227 struct varbind request[] = { 3228 { 3229 .type = TYPE_NULL, 3230 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 1) 3231 }, 3232 { 3233 .type = TYPE_NULL, 3234 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 2) 3235 } 3236 }, ax_request[] = { 3237 { 3238 .type = TYPE_INTEGER, 3239 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 1, 0), 3240 .data.int32 = 1 3241 }, 3242 { 3243 .type = TYPE_INTEGER, 3244 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 2, 0), 3245 .data.int32 = 2 3246 } 3247 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3248 int32_t requestid; 3249 char buf[1024]; 3250 size_t n, nvarbind = nitems(ax_request), nout; 3251 3252 ax_s = agentx_connect(axsocket); 3253 sessionid = agentx_open(ax_s, 0, 0, 3254 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 3), __func__); 3255 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3256 OID_ARG(MIB_BACKEND_GETBULK, 3), 0); 3257 3258 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3259 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3260 requestid = snmpv2_getbulk(snmp_s, community, 0, 1, 1, request, 2); 3261 3262 memcpy(response, ax_request, sizeof(ax_request)); 3263 while (nvarbind > 0) { 3264 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3265 nout = agentx_getbulk_handle(__func__, buf, n, 0, 3266 sessionid, ax_request, nvarbind, ax_response); 3267 agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout); 3268 nvarbind -= nout; 3269 } 3270 3271 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3272 response, nitems(response)); 3273 } 3274 3275 void 3276 backend_getbulk_nonrep_one_maxrep_two(void) 3277 { 3278 struct sockaddr_storage ss; 3279 struct sockaddr *sa = (struct sockaddr *)&ss; 3280 socklen_t salen; 3281 int snmp_s, ax_s; 3282 uint32_t sessionid; 3283 struct varbind request[] = { 3284 { 3285 .type = TYPE_NULL, 3286 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 1) 3287 }, 3288 { 3289 .type = TYPE_NULL, 3290 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2) 3291 } 3292 }, ax_request[] = { 3293 { 3294 .type = TYPE_INTEGER, 3295 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 1, 0), 3296 .data.int32 = 1 3297 }, 3298 { 3299 .type = TYPE_INTEGER, 3300 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2, 2), 3301 .data.int32 = 2 3302 }, 3303 { 3304 .type = TYPE_INTEGER, 3305 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2, 3), 3306 .data.int32 = 3 3307 } 3308 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3309 int32_t requestid; 3310 char buf[1024]; 3311 size_t n, nvarbind = nitems(ax_request), nout; 3312 3313 ax_s = agentx_connect(axsocket); 3314 sessionid = agentx_open(ax_s, 0, 0, 3315 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 4), __func__); 3316 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3317 OID_ARG(MIB_BACKEND_GETBULK, 4), 0); 3318 3319 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3320 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3321 requestid = snmpv2_getbulk(snmp_s, community, 0, 1, 2, request, 2); 3322 3323 memcpy(response, ax_request, sizeof(ax_request)); 3324 while (nvarbind > 0) { 3325 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3326 nout = agentx_getbulk_handle(__func__, buf, n, 0, 3327 sessionid, ax_request, nvarbind, ax_response); 3328 agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout); 3329 nvarbind -= nout; 3330 } 3331 3332 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3333 response, nitems(response)); 3334 } 3335 3336 void 3337 backend_getbulk_nonrep_two_maxrep_two(void) 3338 { 3339 struct sockaddr_storage ss; 3340 struct sockaddr *sa = (struct sockaddr *)&ss; 3341 socklen_t salen; 3342 int snmp_s, ax_s; 3343 uint32_t sessionid; 3344 struct varbind request[] = { 3345 { 3346 .type = TYPE_NULL, 3347 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 1) 3348 }, 3349 { 3350 .type = TYPE_NULL, 3351 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 2) 3352 }, 3353 { 3354 .type = TYPE_NULL, 3355 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3) 3356 } 3357 }, ax_request[] = { 3358 { 3359 .type = TYPE_INTEGER, 3360 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 1, 0), 3361 .data.int32 = 1 3362 }, 3363 { 3364 .type = TYPE_INTEGER, 3365 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 2, 0), 3366 .data.int32 = 2 3367 }, 3368 { 3369 .type = TYPE_INTEGER, 3370 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3, 3), 3371 .data.int32 = 3 3372 }, 3373 { 3374 .type = TYPE_INTEGER, 3375 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3, 4), 3376 .data.int32 = 4 3377 } 3378 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3379 int32_t requestid; 3380 char buf[1024]; 3381 size_t n, nvarbind = nitems(ax_request), nout; 3382 3383 ax_s = agentx_connect(axsocket); 3384 sessionid = agentx_open(ax_s, 0, 0, 3385 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 5), __func__); 3386 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3387 OID_ARG(MIB_BACKEND_GETBULK, 5), 0); 3388 3389 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3390 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3391 requestid = snmpv2_getbulk(snmp_s, community, 0, 2, 2, request, 3); 3392 3393 memcpy(response, ax_request, sizeof(ax_request)); 3394 while (nvarbind > 0) { 3395 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3396 nout = agentx_getbulk_handle(__func__, buf, n, 0, 3397 sessionid, ax_request, nvarbind, ax_response); 3398 agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout); 3399 nvarbind -= nout; 3400 } 3401 3402 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3403 response, nitems(response)); 3404 } 3405 3406 void 3407 backend_getbulk_nonrep_negative(void) 3408 { 3409 struct sockaddr_storage ss; 3410 struct sockaddr *sa = (struct sockaddr *)&ss; 3411 socklen_t salen; 3412 int snmp_s, ax_s; 3413 uint32_t sessionid; 3414 struct varbind request = { 3415 .type = TYPE_NULL, 3416 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 6) 3417 }, ax_request[] = { 3418 { 3419 .type = TYPE_INTEGER, 3420 .name = OID_STRUCT(MIB_BACKEND_GETBULK, 6), 3421 .data.int32 = 1 3422 } 3423 }, ax_response[nitems(ax_request)], response[nitems(ax_request)]; 3424 int32_t requestid; 3425 char buf[1024]; 3426 size_t n, nvarbind = nitems(ax_request), nout; 3427 3428 ax_s = agentx_connect(axsocket); 3429 sessionid = agentx_open(ax_s, 0, 0, 3430 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 6), __func__); 3431 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3432 OID_ARG(MIB_BACKEND_GETBULK, 6), 0); 3433 3434 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3435 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3436 requestid = snmpv2_getbulk(snmp_s, community, 0, -1, 1, &request, 1); 3437 3438 agentx_timeout(ax_s, 1000); 3439 snmp_timeout(snmp_s, 1); 3440 } 3441 3442 /* Assume that everything is registered under 1.3.* */ 3443 void 3444 backend_getbulk_endofmibview(void) 3445 { 3446 struct sockaddr_storage ss; 3447 struct sockaddr *sa = (struct sockaddr *)&ss; 3448 socklen_t salen; 3449 int snmp_s, ax_s; 3450 uint32_t sessionid; 3451 struct varbind varbind = { 3452 .type = TYPE_NULL, 3453 .name = OID_STRUCT(2, 0), 3454 }; 3455 struct searchrange searchrange = { 3456 .start = OID_STRUCT(2, 0), 3457 .end = OID_STRUCT(2, 1) 3458 }; 3459 int32_t requestid; 3460 char buf[1024]; 3461 size_t n; 3462 3463 ax_s = agentx_connect(axsocket); 3464 sessionid = agentx_open(ax_s, 0, 0, 3465 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 7), __func__); 3466 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3467 OID_ARG(2, 0), 0); 3468 3469 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3470 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3471 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1); 3472 3473 varbind.name.subid[varbind.name.n_subid++] = 0; 3474 varbind.type = TYPE_ENDOFMIBVIEW; 3475 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3476 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 3477 &varbind, 1); 3478 varbind.name.n_subid--; 3479 3480 agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1); 3481 3482 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3483 &varbind, 1); 3484 } 3485 3486 void 3487 backend_getbulk_endofmibview_second_rep(void) 3488 { 3489 struct sockaddr_storage ss; 3490 struct sockaddr *sa = (struct sockaddr *)&ss; 3491 socklen_t salen; 3492 int snmp_s, ax_s; 3493 uint32_t sessionid; 3494 struct varbind request[] = { 3495 { 3496 .type = TYPE_NULL, 3497 .name = OID_STRUCT(2 ,0), 3498 .data.int32 = 1 3499 }, 3500 { 3501 .type = TYPE_ENDOFMIBVIEW, 3502 .name = OID_STRUCT(2, 0, 0), 3503 } 3504 }; 3505 struct searchrange searchrange = { 3506 .start = OID_STRUCT(2, 0), 3507 .end = OID_STRUCT(2, 1) 3508 }; 3509 int32_t requestid; 3510 char buf[1024]; 3511 size_t n; 3512 3513 ax_s = agentx_connect(axsocket); 3514 sessionid = agentx_open(ax_s, 0, 0, 3515 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 8), __func__); 3516 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3517 OID_ARG(2, 0), 0); 3518 3519 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3520 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3521 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, request, 1); 3522 3523 request[0].name.subid[request[0].name.n_subid++] = 0; 3524 request[0].type = TYPE_INTEGER; 3525 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3526 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 3527 request, 1); 3528 agentx_response(ax_s, buf, NOERROR, 0, request, 1); 3529 3530 searchrange.start = request[0].name; 3531 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3532 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange, 3533 &request[1], 1); 3534 agentx_response(ax_s, buf, NOERROR, 0, &request[1], 1); 3535 3536 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3537 request, 2); 3538 } 3539 3540 void 3541 backend_getbulk_endofmibview_two_varbinds(void) 3542 { 3543 struct sockaddr_storage ss; 3544 struct sockaddr *sa = (struct sockaddr *)&ss; 3545 socklen_t salen; 3546 int snmp_s, ax_s; 3547 uint32_t sessionid; 3548 struct varbind request[] = { 3549 { 3550 .type = TYPE_NULL, 3551 .name = OID_STRUCT(2 ,0), 3552 .data.int32 = 1 3553 }, 3554 { 3555 .type = TYPE_NULL, 3556 .name = OID_STRUCT(2, 0, 0), 3557 }, 3558 { 3559 .type = TYPE_ENDOFMIBVIEW, 3560 .name = OID_STRUCT(2, 0, 0), 3561 }, 3562 { 3563 .type = TYPE_ENDOFMIBVIEW, 3564 .name = OID_STRUCT(2, 0, 0), 3565 } 3566 }; 3567 struct searchrange searchrange[] = { 3568 { 3569 .start = OID_STRUCT(2, 0), 3570 .end = OID_STRUCT(2, 1) 3571 }, 3572 { 3573 .start = OID_STRUCT(2, 0, 0), 3574 .end = OID_STRUCT(2, 1) 3575 }, 3576 }; 3577 int32_t requestid; 3578 char buf[1024]; 3579 size_t n; 3580 3581 ax_s = agentx_connect(axsocket); 3582 sessionid = agentx_open(ax_s, 0, 0, 3583 OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 9), __func__); 3584 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3585 OID_ARG(2, 0), 0); 3586 3587 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3588 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3589 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, request, 2); 3590 3591 request[0].name.subid[request[0].name.n_subid++] = 0; 3592 request[0].type = TYPE_INTEGER; 3593 request[1].type = TYPE_ENDOFMIBVIEW; 3594 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3595 agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange, 3596 request, 2); 3597 agentx_response(ax_s, buf, NOERROR, 0, request, 2); 3598 3599 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3600 agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange[1], 3601 &request[1], 1); 3602 agentx_response(ax_s, buf, NOERROR, 0, &request[1], 1); 3603 3604 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0, 3605 request, 4); 3606 } 3607 3608 void 3609 backend_error_get_toobig(void) 3610 { 3611 struct sockaddr_storage ss; 3612 struct sockaddr *sa = (struct sockaddr *)&ss; 3613 socklen_t salen; 3614 int snmp_s, ax_s; 3615 uint32_t sessionid; 3616 struct varbind varbind = { 3617 .type = TYPE_NULL, 3618 .name = OID_STRUCT(MIB_BACKEND_ERROR, 1, 0), 3619 }; 3620 int32_t requestid; 3621 char buf[1024]; 3622 size_t n; 3623 3624 ax_s = agentx_connect(axsocket); 3625 sessionid = agentx_open(ax_s, 0, 0, 3626 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 1), __func__); 3627 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3628 OID_ARG(MIB_BACKEND_ERROR, 1), 0); 3629 3630 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3631 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3632 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3633 3634 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3635 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3636 3637 agentx_response(ax_s, buf, TOOBIG, 1, &varbind, 1); 3638 3639 snmpv2_response_validate(snmp_s, 1000, community, requestid, TOOBIG, 1, 3640 &varbind, 1); 3641 } 3642 3643 void 3644 backend_error_get_nosuchname(void) 3645 { 3646 struct sockaddr_storage ss; 3647 struct sockaddr *sa = (struct sockaddr *)&ss; 3648 socklen_t salen; 3649 int snmp_s, ax_s; 3650 uint32_t sessionid; 3651 struct varbind varbind = { 3652 .type = TYPE_NULL, 3653 .name = OID_STRUCT(MIB_BACKEND_ERROR, 2, 0), 3654 }; 3655 int32_t requestid; 3656 char buf[1024]; 3657 size_t n; 3658 3659 ax_s = agentx_connect(axsocket); 3660 sessionid = agentx_open(ax_s, 0, 0, 3661 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 2), __func__); 3662 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3663 OID_ARG(MIB_BACKEND_ERROR, 2), 0); 3664 3665 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3666 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3667 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3668 3669 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3670 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3671 3672 agentx_response(ax_s, buf, NOSUCHNAME, 1, &varbind, 1); 3673 3674 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOSUCHNAME, 1, 3675 &varbind, 1); 3676 } 3677 3678 void 3679 backend_error_get_badvalue(void) 3680 { 3681 struct sockaddr_storage ss; 3682 struct sockaddr *sa = (struct sockaddr *)&ss; 3683 socklen_t salen; 3684 int snmp_s, ax_s; 3685 uint32_t sessionid; 3686 struct varbind varbind = { 3687 .type = TYPE_NULL, 3688 .name = OID_STRUCT(MIB_BACKEND_ERROR, 3, 0), 3689 }; 3690 int32_t requestid; 3691 char buf[1024]; 3692 size_t n; 3693 3694 ax_s = agentx_connect(axsocket); 3695 sessionid = agentx_open(ax_s, 0, 0, 3696 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 3), __func__); 3697 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3698 OID_ARG(MIB_BACKEND_ERROR, 3), 0); 3699 3700 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3701 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3702 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3703 3704 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3705 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3706 3707 agentx_response(ax_s, buf, BADVALUE, 1, &varbind, 1); 3708 3709 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3710 &varbind, 1); 3711 } 3712 3713 void 3714 backend_error_get_readonly(void) 3715 { 3716 struct sockaddr_storage ss; 3717 struct sockaddr *sa = (struct sockaddr *)&ss; 3718 socklen_t salen; 3719 int snmp_s, ax_s; 3720 uint32_t sessionid; 3721 struct varbind varbind = { 3722 .type = TYPE_NULL, 3723 .name = OID_STRUCT(MIB_BACKEND_ERROR, 4, 0), 3724 }; 3725 int32_t requestid; 3726 char buf[1024]; 3727 size_t n; 3728 3729 ax_s = agentx_connect(axsocket); 3730 sessionid = agentx_open(ax_s, 0, 0, 3731 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 4), __func__); 3732 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3733 OID_ARG(MIB_BACKEND_ERROR, 4), 0); 3734 3735 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3736 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3737 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3738 3739 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3740 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3741 3742 agentx_response(ax_s, buf, READONLY, 1, &varbind, 1); 3743 3744 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3745 &varbind, 1); 3746 } 3747 3748 void 3749 backend_error_get_generr(void) 3750 { 3751 struct sockaddr_storage ss; 3752 struct sockaddr *sa = (struct sockaddr *)&ss; 3753 socklen_t salen; 3754 int snmp_s, ax_s; 3755 uint32_t sessionid; 3756 struct varbind varbind = { 3757 .type = TYPE_NULL, 3758 .name = OID_STRUCT(MIB_BACKEND_ERROR, 5, 0), 3759 }; 3760 int32_t requestid; 3761 char buf[1024]; 3762 size_t n; 3763 3764 ax_s = agentx_connect(axsocket); 3765 sessionid = agentx_open(ax_s, 0, 0, 3766 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 5), __func__); 3767 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3768 OID_ARG(MIB_BACKEND_ERROR, 5), 0); 3769 3770 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3771 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3772 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3773 3774 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3775 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3776 3777 agentx_response(ax_s, buf, GENERR, 1, &varbind, 1); 3778 3779 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3780 &varbind, 1); 3781 } 3782 3783 void 3784 backend_error_get_noaccess(void) 3785 { 3786 struct sockaddr_storage ss; 3787 struct sockaddr *sa = (struct sockaddr *)&ss; 3788 socklen_t salen; 3789 int snmp_s, ax_s; 3790 uint32_t sessionid; 3791 struct varbind varbind = { 3792 .type = TYPE_NULL, 3793 .name = OID_STRUCT(MIB_BACKEND_ERROR, 6, 0), 3794 }; 3795 int32_t requestid; 3796 char buf[1024]; 3797 size_t n; 3798 3799 ax_s = agentx_connect(axsocket); 3800 sessionid = agentx_open(ax_s, 0, 0, 3801 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 6), __func__); 3802 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3803 OID_ARG(MIB_BACKEND_ERROR, 5), 0); 3804 3805 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3806 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3807 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3808 3809 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3810 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3811 3812 agentx_response(ax_s, buf, NOACCESS, 1, &varbind, 1); 3813 3814 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3815 &varbind, 1); 3816 } 3817 3818 void 3819 backend_error_get_wrongtype(void) 3820 { 3821 struct sockaddr_storage ss; 3822 struct sockaddr *sa = (struct sockaddr *)&ss; 3823 socklen_t salen; 3824 int snmp_s, ax_s; 3825 uint32_t sessionid; 3826 struct varbind varbind = { 3827 .type = TYPE_NULL, 3828 .name = OID_STRUCT(MIB_BACKEND_ERROR, 7, 0), 3829 }; 3830 int32_t requestid; 3831 char buf[1024]; 3832 size_t n; 3833 3834 ax_s = agentx_connect(axsocket); 3835 sessionid = agentx_open(ax_s, 0, 0, 3836 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 7), __func__); 3837 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3838 OID_ARG(MIB_BACKEND_ERROR, 7), 0); 3839 3840 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3841 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3842 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3843 3844 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3845 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3846 3847 agentx_response(ax_s, buf, WRONGTYPE, 1, &varbind, 1); 3848 3849 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3850 &varbind, 1); 3851 } 3852 3853 void 3854 backend_error_get_wronglength(void) 3855 { 3856 struct sockaddr_storage ss; 3857 struct sockaddr *sa = (struct sockaddr *)&ss; 3858 socklen_t salen; 3859 int snmp_s, ax_s; 3860 uint32_t sessionid; 3861 struct varbind varbind = { 3862 .type = TYPE_NULL, 3863 .name = OID_STRUCT(MIB_BACKEND_ERROR, 8, 0), 3864 }; 3865 int32_t requestid; 3866 char buf[1024]; 3867 size_t n; 3868 3869 ax_s = agentx_connect(axsocket); 3870 sessionid = agentx_open(ax_s, 0, 0, 3871 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 8), __func__); 3872 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3873 OID_ARG(MIB_BACKEND_ERROR, 8), 0); 3874 3875 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3876 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3877 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3878 3879 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3880 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3881 3882 agentx_response(ax_s, buf, WRONGLENGTH, 1, &varbind, 1); 3883 3884 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3885 &varbind, 1); 3886 } 3887 3888 void 3889 backend_error_get_wrongencoding(void) 3890 { 3891 struct sockaddr_storage ss; 3892 struct sockaddr *sa = (struct sockaddr *)&ss; 3893 socklen_t salen; 3894 int snmp_s, ax_s; 3895 uint32_t sessionid; 3896 struct varbind varbind = { 3897 .type = TYPE_NULL, 3898 .name = OID_STRUCT(MIB_BACKEND_ERROR, 9, 0), 3899 }; 3900 int32_t requestid; 3901 char buf[1024]; 3902 size_t n; 3903 3904 ax_s = agentx_connect(axsocket); 3905 sessionid = agentx_open(ax_s, 0, 0, 3906 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 9), __func__); 3907 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3908 OID_ARG(MIB_BACKEND_ERROR, 9), 0); 3909 3910 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3911 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3912 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3913 3914 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3915 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3916 3917 agentx_response(ax_s, buf, WRONGENCODING, 1, &varbind, 1); 3918 3919 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3920 &varbind, 1); 3921 } 3922 3923 void 3924 backend_error_get_wrongvalue(void) 3925 { 3926 struct sockaddr_storage ss; 3927 struct sockaddr *sa = (struct sockaddr *)&ss; 3928 socklen_t salen; 3929 int snmp_s, ax_s; 3930 uint32_t sessionid; 3931 struct varbind varbind = { 3932 .type = TYPE_NULL, 3933 .name = OID_STRUCT(MIB_BACKEND_ERROR, 10, 0), 3934 }; 3935 int32_t requestid; 3936 char buf[1024]; 3937 size_t n; 3938 3939 ax_s = agentx_connect(axsocket); 3940 sessionid = agentx_open(ax_s, 0, 0, 3941 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 10), __func__); 3942 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3943 OID_ARG(MIB_BACKEND_ERROR, 10), 0); 3944 3945 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3946 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3947 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3948 3949 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3950 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3951 3952 agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1); 3953 3954 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3955 &varbind, 1); 3956 } 3957 3958 void 3959 backend_error_get_nocreation(void) 3960 { 3961 struct sockaddr_storage ss; 3962 struct sockaddr *sa = (struct sockaddr *)&ss; 3963 socklen_t salen; 3964 int snmp_s, ax_s; 3965 uint32_t sessionid; 3966 struct varbind varbind = { 3967 .type = TYPE_NULL, 3968 .name = OID_STRUCT(MIB_BACKEND_ERROR, 11, 0), 3969 }; 3970 int32_t requestid; 3971 char buf[1024]; 3972 size_t n; 3973 3974 ax_s = agentx_connect(axsocket); 3975 sessionid = agentx_open(ax_s, 0, 0, 3976 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 11), __func__); 3977 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 3978 OID_ARG(MIB_BACKEND_ERROR, 11), 0); 3979 3980 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 3981 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 3982 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 3983 3984 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 3985 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 3986 3987 agentx_response(ax_s, buf, NOCREATION, 1, &varbind, 1); 3988 3989 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 3990 &varbind, 1); 3991 } 3992 3993 void 3994 backend_error_get_inconsistentvalue(void) 3995 { 3996 struct sockaddr_storage ss; 3997 struct sockaddr *sa = (struct sockaddr *)&ss; 3998 socklen_t salen; 3999 int snmp_s, ax_s; 4000 uint32_t sessionid; 4001 struct varbind varbind = { 4002 .type = TYPE_NULL, 4003 .name = OID_STRUCT(MIB_BACKEND_ERROR, 12, 0), 4004 }; 4005 int32_t requestid; 4006 char buf[1024]; 4007 size_t n; 4008 4009 ax_s = agentx_connect(axsocket); 4010 sessionid = agentx_open(ax_s, 0, 0, 4011 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 12), __func__); 4012 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4013 OID_ARG(MIB_BACKEND_ERROR, 12), 0); 4014 4015 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4016 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4017 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4018 4019 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4020 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4021 4022 agentx_response(ax_s, buf, INCONSISTENTVALUE, 1, &varbind, 1); 4023 4024 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4025 &varbind, 1); 4026 } 4027 4028 void 4029 backend_error_get_resourceunavailable(void) 4030 { 4031 struct sockaddr_storage ss; 4032 struct sockaddr *sa = (struct sockaddr *)&ss; 4033 socklen_t salen; 4034 int snmp_s, ax_s; 4035 uint32_t sessionid; 4036 struct varbind varbind = { 4037 .type = TYPE_NULL, 4038 .name = OID_STRUCT(MIB_BACKEND_ERROR, 13, 0), 4039 }; 4040 int32_t requestid; 4041 char buf[1024]; 4042 size_t n; 4043 4044 ax_s = agentx_connect(axsocket); 4045 sessionid = agentx_open(ax_s, 0, 0, 4046 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 13), __func__); 4047 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4048 OID_ARG(MIB_BACKEND_ERROR, 13), 0); 4049 4050 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4051 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4052 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4053 4054 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4055 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4056 4057 agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1); 4058 4059 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4060 &varbind, 1); 4061 } 4062 4063 void 4064 backend_error_get_commitfailed(void) 4065 { 4066 struct sockaddr_storage ss; 4067 struct sockaddr *sa = (struct sockaddr *)&ss; 4068 socklen_t salen; 4069 int snmp_s, ax_s; 4070 uint32_t sessionid; 4071 struct varbind varbind = { 4072 .type = TYPE_NULL, 4073 .name = OID_STRUCT(MIB_BACKEND_ERROR, 14, 0), 4074 }; 4075 int32_t requestid; 4076 char buf[1024]; 4077 size_t n; 4078 4079 ax_s = agentx_connect(axsocket); 4080 sessionid = agentx_open(ax_s, 0, 0, 4081 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 14), __func__); 4082 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4083 OID_ARG(MIB_BACKEND_ERROR, 14), 0); 4084 4085 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4086 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4087 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4088 4089 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4090 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4091 4092 agentx_response(ax_s, buf, COMMITFAILED, 1, &varbind, 1); 4093 4094 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4095 &varbind, 1); 4096 } 4097 4098 void 4099 backend_error_get_undofailed(void) 4100 { 4101 struct sockaddr_storage ss; 4102 struct sockaddr *sa = (struct sockaddr *)&ss; 4103 socklen_t salen; 4104 int snmp_s, ax_s; 4105 uint32_t sessionid; 4106 struct varbind varbind = { 4107 .type = TYPE_NULL, 4108 .name = OID_STRUCT(MIB_BACKEND_ERROR, 15, 0), 4109 }; 4110 int32_t requestid; 4111 char buf[1024]; 4112 size_t n; 4113 4114 ax_s = agentx_connect(axsocket); 4115 sessionid = agentx_open(ax_s, 0, 0, 4116 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 15), __func__); 4117 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4118 OID_ARG(MIB_BACKEND_ERROR, 15), 0); 4119 4120 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4121 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4122 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4123 4124 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4125 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4126 4127 agentx_response(ax_s, buf, UNDOFAILED, 1, &varbind, 1); 4128 4129 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4130 &varbind, 1); 4131 } 4132 4133 void 4134 backend_error_get_authorizationerror(void) 4135 { 4136 struct sockaddr_storage ss; 4137 struct sockaddr *sa = (struct sockaddr *)&ss; 4138 socklen_t salen; 4139 int snmp_s, ax_s; 4140 uint32_t sessionid; 4141 struct varbind varbind = { 4142 .type = TYPE_NULL, 4143 .name = OID_STRUCT(MIB_BACKEND_ERROR, 16, 0), 4144 }; 4145 int32_t requestid; 4146 char buf[1024]; 4147 size_t n; 4148 4149 ax_s = agentx_connect(axsocket); 4150 sessionid = agentx_open(ax_s, 0, 0, 4151 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 16), __func__); 4152 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4153 OID_ARG(MIB_BACKEND_ERROR, 16), 0); 4154 4155 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4156 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4157 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4158 4159 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4160 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4161 4162 agentx_response(ax_s, buf, AUTHORIZATIONERROR, 1, &varbind, 1); 4163 4164 snmpv2_response_validate(snmp_s, 1000, community, requestid, AUTHORIZATIONERROR, 1, 4165 &varbind, 1); 4166 } 4167 4168 void 4169 backend_error_get_notwritable(void) 4170 { 4171 struct sockaddr_storage ss; 4172 struct sockaddr *sa = (struct sockaddr *)&ss; 4173 socklen_t salen; 4174 int snmp_s, ax_s; 4175 uint32_t sessionid; 4176 struct varbind varbind = { 4177 .type = TYPE_NULL, 4178 .name = OID_STRUCT(MIB_BACKEND_ERROR, 17, 0), 4179 }; 4180 int32_t requestid; 4181 char buf[1024]; 4182 size_t n; 4183 4184 ax_s = agentx_connect(axsocket); 4185 sessionid = agentx_open(ax_s, 0, 0, 4186 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 17), __func__); 4187 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4188 OID_ARG(MIB_BACKEND_ERROR, 17), 0); 4189 4190 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4191 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4192 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4193 4194 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4195 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4196 4197 agentx_response(ax_s, buf, NOTWRITABLE, 1, &varbind, 1); 4198 4199 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4200 &varbind, 1); 4201 } 4202 4203 void 4204 backend_error_get_inconsistentname(void) 4205 { 4206 struct sockaddr_storage ss; 4207 struct sockaddr *sa = (struct sockaddr *)&ss; 4208 socklen_t salen; 4209 int snmp_s, ax_s; 4210 uint32_t sessionid; 4211 struct varbind varbind = { 4212 .type = TYPE_NULL, 4213 .name = OID_STRUCT(MIB_BACKEND_ERROR, 18, 0), 4214 }; 4215 int32_t requestid; 4216 char buf[1024]; 4217 size_t n; 4218 4219 ax_s = agentx_connect(axsocket); 4220 sessionid = agentx_open(ax_s, 0, 0, 4221 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 18), __func__); 4222 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4223 OID_ARG(MIB_BACKEND_ERROR, 18), 0); 4224 4225 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4226 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4227 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4228 4229 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4230 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4231 4232 agentx_response(ax_s, buf, INCONSISTENTNAME, 1, &varbind, 1); 4233 4234 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4235 &varbind, 1); 4236 } 4237 4238 void 4239 backend_error_get_openfailed(void) 4240 { 4241 struct sockaddr_storage ss; 4242 struct sockaddr *sa = (struct sockaddr *)&ss; 4243 socklen_t salen; 4244 int snmp_s, ax_s; 4245 uint32_t sessionid; 4246 struct varbind varbind = { 4247 .type = TYPE_NULL, 4248 .name = OID_STRUCT(MIB_BACKEND_ERROR, 19, 0), 4249 }; 4250 int32_t requestid; 4251 char buf[1024]; 4252 size_t n; 4253 4254 ax_s = agentx_connect(axsocket); 4255 sessionid = agentx_open(ax_s, 0, 0, 4256 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 19), __func__); 4257 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4258 OID_ARG(MIB_BACKEND_ERROR, 19), 0); 4259 4260 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4261 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4262 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4263 4264 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4265 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4266 4267 agentx_response(ax_s, buf, OPENFAILED, 1, &varbind, 1); 4268 4269 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4270 &varbind, 1); 4271 } 4272 4273 void 4274 backend_error_get_notopen(void) 4275 { 4276 struct sockaddr_storage ss; 4277 struct sockaddr *sa = (struct sockaddr *)&ss; 4278 socklen_t salen; 4279 int snmp_s, ax_s; 4280 uint32_t sessionid; 4281 struct varbind varbind = { 4282 .type = TYPE_NULL, 4283 .name = OID_STRUCT(MIB_BACKEND_ERROR, 20, 0), 4284 }; 4285 int32_t requestid; 4286 char buf[1024]; 4287 size_t n; 4288 4289 ax_s = agentx_connect(axsocket); 4290 sessionid = agentx_open(ax_s, 0, 0, 4291 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 20), __func__); 4292 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4293 OID_ARG(MIB_BACKEND_ERROR, 20), 0); 4294 4295 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4296 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4297 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4298 4299 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4300 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4301 4302 agentx_response(ax_s, buf, NOTOPEN, 1, &varbind, 1); 4303 4304 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4305 &varbind, 1); 4306 } 4307 4308 void 4309 backend_error_get_indexwrongtype(void) 4310 { 4311 struct sockaddr_storage ss; 4312 struct sockaddr *sa = (struct sockaddr *)&ss; 4313 socklen_t salen; 4314 int snmp_s, ax_s; 4315 uint32_t sessionid; 4316 struct varbind varbind = { 4317 .type = TYPE_NULL, 4318 .name = OID_STRUCT(MIB_BACKEND_ERROR, 21, 0), 4319 }; 4320 int32_t requestid; 4321 char buf[1024]; 4322 size_t n; 4323 4324 ax_s = agentx_connect(axsocket); 4325 sessionid = agentx_open(ax_s, 0, 0, 4326 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 21), __func__); 4327 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4328 OID_ARG(MIB_BACKEND_ERROR, 21), 0); 4329 4330 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4331 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4332 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4333 4334 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4335 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4336 4337 agentx_response(ax_s, buf, INDEXWRONGTYPE, 1, &varbind, 1); 4338 4339 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4340 &varbind, 1); 4341 } 4342 4343 void 4344 backend_error_get_indexalreadyallocated(void) 4345 { 4346 struct sockaddr_storage ss; 4347 struct sockaddr *sa = (struct sockaddr *)&ss; 4348 socklen_t salen; 4349 int snmp_s, ax_s; 4350 uint32_t sessionid; 4351 struct varbind varbind = { 4352 .type = TYPE_NULL, 4353 .name = OID_STRUCT(MIB_BACKEND_ERROR, 22, 0), 4354 }; 4355 int32_t requestid; 4356 char buf[1024]; 4357 size_t n; 4358 4359 ax_s = agentx_connect(axsocket); 4360 sessionid = agentx_open(ax_s, 0, 0, 4361 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 22), __func__); 4362 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4363 OID_ARG(MIB_BACKEND_ERROR, 22), 0); 4364 4365 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4366 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4367 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4368 4369 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4370 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4371 4372 agentx_response(ax_s, buf, INDEXALREADYALLOCATED, 1, &varbind, 1); 4373 4374 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4375 &varbind, 1); 4376 } 4377 4378 void 4379 backend_error_get_indexnonavailable(void) 4380 { 4381 struct sockaddr_storage ss; 4382 struct sockaddr *sa = (struct sockaddr *)&ss; 4383 socklen_t salen; 4384 int snmp_s, ax_s; 4385 uint32_t sessionid; 4386 struct varbind varbind = { 4387 .type = TYPE_NULL, 4388 .name = OID_STRUCT(MIB_BACKEND_ERROR, 23, 0), 4389 }; 4390 int32_t requestid; 4391 char buf[1024]; 4392 size_t n; 4393 4394 ax_s = agentx_connect(axsocket); 4395 sessionid = agentx_open(ax_s, 0, 0, 4396 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 23), __func__); 4397 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4398 OID_ARG(MIB_BACKEND_ERROR, 23), 0); 4399 4400 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4401 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4402 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4403 4404 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4405 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4406 4407 agentx_response(ax_s, buf, INDEXNONEAVAILABLE, 1, &varbind, 1); 4408 4409 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4410 &varbind, 1); 4411 } 4412 4413 void 4414 backend_error_get_indexnotallocated(void) 4415 { 4416 struct sockaddr_storage ss; 4417 struct sockaddr *sa = (struct sockaddr *)&ss; 4418 socklen_t salen; 4419 int snmp_s, ax_s; 4420 uint32_t sessionid; 4421 struct varbind varbind = { 4422 .type = TYPE_NULL, 4423 .name = OID_STRUCT(MIB_BACKEND_ERROR, 24, 0), 4424 }; 4425 int32_t requestid; 4426 char buf[1024]; 4427 size_t n; 4428 4429 ax_s = agentx_connect(axsocket); 4430 sessionid = agentx_open(ax_s, 0, 0, 4431 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 24), __func__); 4432 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4433 OID_ARG(MIB_BACKEND_ERROR, 24), 0); 4434 4435 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4436 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4437 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4438 4439 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4440 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4441 4442 agentx_response(ax_s, buf, INDEXNOTALLOCATED, 1, &varbind, 1); 4443 4444 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4445 &varbind, 1); 4446 } 4447 4448 void 4449 backend_error_get_unsupportedcontext(void) 4450 { 4451 struct sockaddr_storage ss; 4452 struct sockaddr *sa = (struct sockaddr *)&ss; 4453 socklen_t salen; 4454 int snmp_s, ax_s; 4455 uint32_t sessionid; 4456 struct varbind varbind = { 4457 .type = TYPE_NULL, 4458 .name = OID_STRUCT(MIB_BACKEND_ERROR, 25, 0), 4459 }; 4460 int32_t requestid; 4461 char buf[1024]; 4462 size_t n; 4463 4464 ax_s = agentx_connect(axsocket); 4465 sessionid = agentx_open(ax_s, 0, 0, 4466 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 25), __func__); 4467 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4468 OID_ARG(MIB_BACKEND_ERROR, 25), 0); 4469 4470 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4471 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4472 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4473 4474 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4475 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4476 4477 agentx_response(ax_s, buf, UNSUPPORTEDCONTEXT, 1, &varbind, 1); 4478 4479 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4480 &varbind, 1); 4481 } 4482 4483 void 4484 backend_error_get_duplicateregistration(void) 4485 { 4486 struct sockaddr_storage ss; 4487 struct sockaddr *sa = (struct sockaddr *)&ss; 4488 socklen_t salen; 4489 int snmp_s, ax_s; 4490 uint32_t sessionid; 4491 struct varbind varbind = { 4492 .type = TYPE_NULL, 4493 .name = OID_STRUCT(MIB_BACKEND_ERROR, 26, 0), 4494 }; 4495 int32_t requestid; 4496 char buf[1024]; 4497 size_t n; 4498 4499 ax_s = agentx_connect(axsocket); 4500 sessionid = agentx_open(ax_s, 0, 0, 4501 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 26), __func__); 4502 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4503 OID_ARG(MIB_BACKEND_ERROR, 26), 0); 4504 4505 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4506 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4507 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4508 4509 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4510 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4511 4512 agentx_response(ax_s, buf, DUPLICATEREGISTRATION, 1, &varbind, 1); 4513 4514 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4515 &varbind, 1); 4516 } 4517 4518 void 4519 backend_error_get_unknownregistration(void) 4520 { 4521 struct sockaddr_storage ss; 4522 struct sockaddr *sa = (struct sockaddr *)&ss; 4523 socklen_t salen; 4524 int snmp_s, ax_s; 4525 uint32_t sessionid; 4526 struct varbind varbind = { 4527 .type = TYPE_NULL, 4528 .name = OID_STRUCT(MIB_BACKEND_ERROR, 27, 0), 4529 }; 4530 int32_t requestid; 4531 char buf[1024]; 4532 size_t n; 4533 4534 ax_s = agentx_connect(axsocket); 4535 sessionid = agentx_open(ax_s, 0, 0, 4536 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 27), __func__); 4537 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4538 OID_ARG(MIB_BACKEND_ERROR, 27), 0); 4539 4540 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4541 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4542 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4543 4544 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4545 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4546 4547 agentx_response(ax_s, buf, UNKNOWNREGISTRATION, 1, &varbind, 1); 4548 4549 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4550 &varbind, 1); 4551 } 4552 4553 void 4554 backend_error_get_parseerror(void) 4555 { 4556 struct sockaddr_storage ss; 4557 struct sockaddr *sa = (struct sockaddr *)&ss; 4558 socklen_t salen; 4559 int snmp_s, ax_s; 4560 uint32_t sessionid; 4561 struct varbind varbind = { 4562 .type = TYPE_NULL, 4563 .name = OID_STRUCT(MIB_BACKEND_ERROR, 28, 0), 4564 }; 4565 int32_t requestid; 4566 char buf[1024]; 4567 size_t n; 4568 4569 ax_s = agentx_connect(axsocket); 4570 sessionid = agentx_open(ax_s, 0, 0, 4571 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 28), __func__); 4572 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4573 OID_ARG(MIB_BACKEND_ERROR, 28), 0); 4574 4575 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4576 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4577 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4578 4579 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4580 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4581 4582 agentx_response(ax_s, buf, PARSEERROR, 1, &varbind, 1); 4583 4584 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4585 &varbind, 1); 4586 } 4587 4588 void 4589 backend_error_get_requestdenied(void) 4590 { 4591 struct sockaddr_storage ss; 4592 struct sockaddr *sa = (struct sockaddr *)&ss; 4593 socklen_t salen; 4594 int snmp_s, ax_s; 4595 uint32_t sessionid; 4596 struct varbind varbind = { 4597 .type = TYPE_NULL, 4598 .name = OID_STRUCT(MIB_BACKEND_ERROR, 29, 0), 4599 }; 4600 int32_t requestid; 4601 char buf[1024]; 4602 size_t n; 4603 4604 ax_s = agentx_connect(axsocket); 4605 sessionid = agentx_open(ax_s, 0, 0, 4606 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 29), __func__); 4607 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4608 OID_ARG(MIB_BACKEND_ERROR, 29), 0); 4609 4610 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4611 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4612 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4613 4614 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4615 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4616 4617 agentx_response(ax_s, buf, REQUESTDENIED, 1, &varbind, 1); 4618 4619 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4620 &varbind, 1); 4621 } 4622 4623 void 4624 backend_error_get_processingerror(void) 4625 { 4626 struct sockaddr_storage ss; 4627 struct sockaddr *sa = (struct sockaddr *)&ss; 4628 socklen_t salen; 4629 int snmp_s, ax_s; 4630 uint32_t sessionid; 4631 struct varbind varbind = { 4632 .type = TYPE_NULL, 4633 .name = OID_STRUCT(MIB_BACKEND_ERROR, 30, 0), 4634 }; 4635 int32_t requestid; 4636 char buf[1024]; 4637 size_t n; 4638 4639 ax_s = agentx_connect(axsocket); 4640 sessionid = agentx_open(ax_s, 0, 0, 4641 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 30), __func__); 4642 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4643 OID_ARG(MIB_BACKEND_ERROR, 30), 0); 4644 4645 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4646 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4647 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4648 4649 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4650 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4651 4652 agentx_response(ax_s, buf, PROCESSINGERROR, 1, &varbind, 1); 4653 4654 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4655 &varbind, 1); 4656 } 4657 4658 void 4659 backend_error_get_nonstandard(void) 4660 { 4661 struct sockaddr_storage ss; 4662 struct sockaddr *sa = (struct sockaddr *)&ss; 4663 socklen_t salen; 4664 int snmp_s, ax_s; 4665 uint32_t sessionid; 4666 struct varbind varbind = { 4667 .type = TYPE_NULL, 4668 .name = OID_STRUCT(MIB_BACKEND_ERROR, 31, 0), 4669 }; 4670 int32_t requestid; 4671 char buf[1024]; 4672 size_t n; 4673 4674 ax_s = agentx_connect(axsocket); 4675 sessionid = agentx_open(ax_s, 0, 0, 4676 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 31), __func__); 4677 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4678 OID_ARG(MIB_BACKEND_ERROR, 31), 0); 4679 4680 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4681 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4682 requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1); 4683 4684 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4685 agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1); 4686 4687 agentx_response(ax_s, buf, 0xFFFF, 1, &varbind, 1); 4688 4689 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4690 &varbind, 1); 4691 } 4692 4693 void 4694 backend_error_getnext_toobig(void) 4695 { 4696 struct sockaddr_storage ss; 4697 struct sockaddr *sa = (struct sockaddr *)&ss; 4698 socklen_t salen; 4699 int snmp_s, ax_s; 4700 uint32_t sessionid; 4701 struct varbind varbind = { 4702 .type = TYPE_NULL, 4703 .name = OID_STRUCT(MIB_BACKEND_ERROR, 32), 4704 }; 4705 int32_t requestid; 4706 char buf[1024]; 4707 size_t n; 4708 4709 ax_s = agentx_connect(axsocket); 4710 sessionid = agentx_open(ax_s, 0, 0, 4711 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 32), __func__); 4712 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4713 OID_ARG(MIB_BACKEND_ERROR, 32), 0); 4714 4715 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4716 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4717 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4718 4719 varbind.name.subid[varbind.name.n_subid++] = 0; 4720 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4721 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4722 varbind.name.n_subid--; 4723 agentx_response(ax_s, buf, TOOBIG, 1, &varbind, 1); 4724 4725 snmpv2_response_validate(snmp_s, 1000, community, requestid, TOOBIG, 1, 4726 &varbind, 1); 4727 } 4728 4729 void 4730 backend_error_getnext_nosuchname(void) 4731 { 4732 struct sockaddr_storage ss; 4733 struct sockaddr *sa = (struct sockaddr *)&ss; 4734 socklen_t salen; 4735 int snmp_s, ax_s; 4736 uint32_t sessionid; 4737 struct varbind varbind = { 4738 .type = TYPE_NULL, 4739 .name = OID_STRUCT(MIB_BACKEND_ERROR, 33), 4740 }; 4741 int32_t requestid; 4742 char buf[1024]; 4743 size_t n; 4744 4745 ax_s = agentx_connect(axsocket); 4746 sessionid = agentx_open(ax_s, 0, 0, 4747 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 33), __func__); 4748 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4749 OID_ARG(MIB_BACKEND_ERROR, 33), 0); 4750 4751 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4752 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4753 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4754 4755 varbind.name.subid[varbind.name.n_subid++] = 0; 4756 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4757 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4758 varbind.name.n_subid--; 4759 agentx_response(ax_s, buf, NOSUCHNAME, 1, &varbind, 1); 4760 4761 snmpv2_response_validate(snmp_s, 1000, community, requestid, NOSUCHNAME, 1, 4762 &varbind, 1); 4763 } 4764 4765 void 4766 backend_error_getnext_badvalue(void) 4767 { 4768 struct sockaddr_storage ss; 4769 struct sockaddr *sa = (struct sockaddr *)&ss; 4770 socklen_t salen; 4771 int snmp_s, ax_s; 4772 uint32_t sessionid; 4773 struct varbind varbind = { 4774 .type = TYPE_NULL, 4775 .name = OID_STRUCT(MIB_BACKEND_ERROR, 34), 4776 }; 4777 int32_t requestid; 4778 char buf[1024]; 4779 size_t n; 4780 4781 ax_s = agentx_connect(axsocket); 4782 sessionid = agentx_open(ax_s, 0, 0, 4783 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 34), __func__); 4784 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4785 OID_ARG(MIB_BACKEND_ERROR, 34), 0); 4786 4787 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4788 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4789 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4790 4791 varbind.name.subid[varbind.name.n_subid++] = 0; 4792 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4793 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4794 varbind.name.n_subid--; 4795 agentx_response(ax_s, buf, BADVALUE, 1, &varbind, 1); 4796 4797 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4798 &varbind, 1); 4799 } 4800 4801 void 4802 backend_error_getnext_readonly(void) 4803 { 4804 struct sockaddr_storage ss; 4805 struct sockaddr *sa = (struct sockaddr *)&ss; 4806 socklen_t salen; 4807 int snmp_s, ax_s; 4808 uint32_t sessionid; 4809 struct varbind varbind = { 4810 .type = TYPE_NULL, 4811 .name = OID_STRUCT(MIB_BACKEND_ERROR, 35), 4812 }; 4813 int32_t requestid; 4814 char buf[1024]; 4815 size_t n; 4816 4817 ax_s = agentx_connect(axsocket); 4818 sessionid = agentx_open(ax_s, 0, 0, 4819 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 35), __func__); 4820 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4821 OID_ARG(MIB_BACKEND_ERROR, 35), 0); 4822 4823 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4824 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4825 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4826 4827 varbind.name.subid[varbind.name.n_subid++] = 0; 4828 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4829 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4830 varbind.name.n_subid--; 4831 agentx_response(ax_s, buf, READONLY, 1, &varbind, 1); 4832 4833 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4834 &varbind, 1); 4835 } 4836 4837 void 4838 backend_error_getnext_generr(void) 4839 { 4840 struct sockaddr_storage ss; 4841 struct sockaddr *sa = (struct sockaddr *)&ss; 4842 socklen_t salen; 4843 int snmp_s, ax_s; 4844 uint32_t sessionid; 4845 struct varbind varbind = { 4846 .type = TYPE_NULL, 4847 .name = OID_STRUCT(MIB_BACKEND_ERROR, 36), 4848 }; 4849 int32_t requestid; 4850 char buf[1024]; 4851 size_t n; 4852 4853 ax_s = agentx_connect(axsocket); 4854 sessionid = agentx_open(ax_s, 0, 0, 4855 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 36), __func__); 4856 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4857 OID_ARG(MIB_BACKEND_ERROR, 36), 0); 4858 4859 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4860 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4861 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4862 4863 varbind.name.subid[varbind.name.n_subid++] = 0; 4864 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4865 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4866 varbind.name.n_subid--; 4867 agentx_response(ax_s, buf, GENERR, 1, &varbind, 1); 4868 4869 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4870 &varbind, 1); 4871 } 4872 4873 void 4874 backend_error_getnext_noaccess(void) 4875 { 4876 struct sockaddr_storage ss; 4877 struct sockaddr *sa = (struct sockaddr *)&ss; 4878 socklen_t salen; 4879 int snmp_s, ax_s; 4880 uint32_t sessionid; 4881 struct varbind varbind = { 4882 .type = TYPE_NULL, 4883 .name = OID_STRUCT(MIB_BACKEND_ERROR, 37), 4884 }; 4885 int32_t requestid; 4886 char buf[1024]; 4887 size_t n; 4888 4889 ax_s = agentx_connect(axsocket); 4890 sessionid = agentx_open(ax_s, 0, 0, 4891 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 37), __func__); 4892 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4893 OID_ARG(MIB_BACKEND_ERROR, 37), 0); 4894 4895 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4896 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4897 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4898 4899 varbind.name.subid[varbind.name.n_subid++] = 0; 4900 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4901 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4902 varbind.name.n_subid--; 4903 agentx_response(ax_s, buf, NOACCESS, 1, &varbind, 1); 4904 4905 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4906 &varbind, 1); 4907 } 4908 4909 void 4910 backend_error_getnext_wrongtype(void) 4911 { 4912 struct sockaddr_storage ss; 4913 struct sockaddr *sa = (struct sockaddr *)&ss; 4914 socklen_t salen; 4915 int snmp_s, ax_s; 4916 uint32_t sessionid; 4917 struct varbind varbind = { 4918 .type = TYPE_NULL, 4919 .name = OID_STRUCT(MIB_BACKEND_ERROR, 38), 4920 }; 4921 int32_t requestid; 4922 char buf[1024]; 4923 size_t n; 4924 4925 ax_s = agentx_connect(axsocket); 4926 sessionid = agentx_open(ax_s, 0, 0, 4927 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 38), __func__); 4928 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4929 OID_ARG(MIB_BACKEND_ERROR, 38), 0); 4930 4931 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4932 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4933 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4934 4935 varbind.name.subid[varbind.name.n_subid++] = 0; 4936 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4937 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4938 varbind.name.n_subid--; 4939 agentx_response(ax_s, buf, WRONGTYPE, 1, &varbind, 1); 4940 4941 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4942 &varbind, 1); 4943 } 4944 4945 void 4946 backend_error_getnext_wronglength(void) 4947 { 4948 struct sockaddr_storage ss; 4949 struct sockaddr *sa = (struct sockaddr *)&ss; 4950 socklen_t salen; 4951 int snmp_s, ax_s; 4952 uint32_t sessionid; 4953 struct varbind varbind = { 4954 .type = TYPE_NULL, 4955 .name = OID_STRUCT(MIB_BACKEND_ERROR, 39), 4956 }; 4957 int32_t requestid; 4958 char buf[1024]; 4959 size_t n; 4960 4961 ax_s = agentx_connect(axsocket); 4962 sessionid = agentx_open(ax_s, 0, 0, 4963 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 39), __func__); 4964 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 4965 OID_ARG(MIB_BACKEND_ERROR, 39), 0); 4966 4967 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 4968 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 4969 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 4970 4971 varbind.name.subid[varbind.name.n_subid++] = 0; 4972 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 4973 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 4974 varbind.name.n_subid--; 4975 agentx_response(ax_s, buf, WRONGLENGTH, 1, &varbind, 1); 4976 4977 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 4978 &varbind, 1); 4979 } 4980 4981 void 4982 backend_error_getnext_wrongencoding(void) 4983 { 4984 struct sockaddr_storage ss; 4985 struct sockaddr *sa = (struct sockaddr *)&ss; 4986 socklen_t salen; 4987 int snmp_s, ax_s; 4988 uint32_t sessionid; 4989 struct varbind varbind = { 4990 .type = TYPE_NULL, 4991 .name = OID_STRUCT(MIB_BACKEND_ERROR, 40), 4992 }; 4993 int32_t requestid; 4994 char buf[1024]; 4995 size_t n; 4996 4997 ax_s = agentx_connect(axsocket); 4998 sessionid = agentx_open(ax_s, 0, 0, 4999 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 40), __func__); 5000 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5001 OID_ARG(MIB_BACKEND_ERROR, 40), 0); 5002 5003 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5004 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5005 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5006 5007 varbind.name.subid[varbind.name.n_subid++] = 0; 5008 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5009 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5010 varbind.name.n_subid--; 5011 agentx_response(ax_s, buf, WRONGENCODING, 1, &varbind, 1); 5012 5013 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5014 &varbind, 1); 5015 } 5016 5017 void 5018 backend_error_getnext_wrongvalue(void) 5019 { 5020 struct sockaddr_storage ss; 5021 struct sockaddr *sa = (struct sockaddr *)&ss; 5022 socklen_t salen; 5023 int snmp_s, ax_s; 5024 uint32_t sessionid; 5025 struct varbind varbind = { 5026 .type = TYPE_NULL, 5027 .name = OID_STRUCT(MIB_BACKEND_ERROR, 41), 5028 }; 5029 int32_t requestid; 5030 char buf[1024]; 5031 size_t n; 5032 5033 ax_s = agentx_connect(axsocket); 5034 sessionid = agentx_open(ax_s, 0, 0, 5035 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 41), __func__); 5036 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5037 OID_ARG(MIB_BACKEND_ERROR, 41), 0); 5038 5039 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5040 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5041 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5042 5043 varbind.name.subid[varbind.name.n_subid++] = 0; 5044 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5045 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5046 varbind.name.n_subid--; 5047 agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1); 5048 5049 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5050 &varbind, 1); 5051 } 5052 5053 void 5054 backend_error_getnext_nocreation(void) 5055 { 5056 struct sockaddr_storage ss; 5057 struct sockaddr *sa = (struct sockaddr *)&ss; 5058 socklen_t salen; 5059 int snmp_s, ax_s; 5060 uint32_t sessionid; 5061 struct varbind varbind = { 5062 .type = TYPE_NULL, 5063 .name = OID_STRUCT(MIB_BACKEND_ERROR, 42), 5064 }; 5065 int32_t requestid; 5066 char buf[1024]; 5067 size_t n; 5068 5069 ax_s = agentx_connect(axsocket); 5070 sessionid = agentx_open(ax_s, 0, 0, 5071 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 42), __func__); 5072 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5073 OID_ARG(MIB_BACKEND_ERROR, 42), 0); 5074 5075 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5076 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5077 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5078 5079 varbind.name.subid[varbind.name.n_subid++] = 0; 5080 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5081 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5082 varbind.name.n_subid--; 5083 agentx_response(ax_s, buf, NOCREATION, 1, &varbind, 1); 5084 5085 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5086 &varbind, 1); 5087 } 5088 5089 void 5090 backend_error_getnext_inconsistentvalue(void) 5091 { 5092 struct sockaddr_storage ss; 5093 struct sockaddr *sa = (struct sockaddr *)&ss; 5094 socklen_t salen; 5095 int snmp_s, ax_s; 5096 uint32_t sessionid; 5097 struct varbind varbind = { 5098 .type = TYPE_NULL, 5099 .name = OID_STRUCT(MIB_BACKEND_ERROR, 43), 5100 }; 5101 int32_t requestid; 5102 char buf[1024]; 5103 size_t n; 5104 5105 ax_s = agentx_connect(axsocket); 5106 sessionid = agentx_open(ax_s, 0, 0, 5107 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 43), __func__); 5108 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5109 OID_ARG(MIB_BACKEND_ERROR, 43), 0); 5110 5111 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5112 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5113 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5114 5115 varbind.name.subid[varbind.name.n_subid++] = 0; 5116 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5117 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5118 varbind.name.n_subid--; 5119 agentx_response(ax_s, buf, INCONSISTENTVALUE, 1, &varbind, 1); 5120 5121 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5122 &varbind, 1); 5123 } 5124 5125 void 5126 backend_error_getnext_resourceunavailable(void) 5127 { 5128 struct sockaddr_storage ss; 5129 struct sockaddr *sa = (struct sockaddr *)&ss; 5130 socklen_t salen; 5131 int snmp_s, ax_s; 5132 uint32_t sessionid; 5133 struct varbind varbind = { 5134 .type = TYPE_NULL, 5135 .name = OID_STRUCT(MIB_BACKEND_ERROR, 44), 5136 }; 5137 int32_t requestid; 5138 char buf[1024]; 5139 size_t n; 5140 5141 ax_s = agentx_connect(axsocket); 5142 sessionid = agentx_open(ax_s, 0, 0, 5143 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 44), __func__); 5144 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5145 OID_ARG(MIB_BACKEND_ERROR, 44), 0); 5146 5147 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5148 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5149 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5150 5151 varbind.name.subid[varbind.name.n_subid++] = 0; 5152 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5153 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5154 varbind.name.n_subid--; 5155 agentx_response(ax_s, buf, RESOURCEUNAVAILABLE, 1, &varbind, 1); 5156 5157 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5158 &varbind, 1); 5159 } 5160 5161 void 5162 backend_error_getnext_commitfailed(void) 5163 { 5164 struct sockaddr_storage ss; 5165 struct sockaddr *sa = (struct sockaddr *)&ss; 5166 socklen_t salen; 5167 int snmp_s, ax_s; 5168 uint32_t sessionid; 5169 struct varbind varbind = { 5170 .type = TYPE_NULL, 5171 .name = OID_STRUCT(MIB_BACKEND_ERROR, 45), 5172 }; 5173 int32_t requestid; 5174 char buf[1024]; 5175 size_t n; 5176 5177 ax_s = agentx_connect(axsocket); 5178 sessionid = agentx_open(ax_s, 0, 0, 5179 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 45), __func__); 5180 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5181 OID_ARG(MIB_BACKEND_ERROR, 45), 0); 5182 5183 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5184 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5185 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5186 5187 varbind.name.subid[varbind.name.n_subid++] = 0; 5188 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5189 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5190 varbind.name.n_subid--; 5191 agentx_response(ax_s, buf, COMMITFAILED, 1, &varbind, 1); 5192 5193 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5194 &varbind, 1); 5195 } 5196 5197 void 5198 backend_error_getnext_undofailed(void) 5199 { 5200 struct sockaddr_storage ss; 5201 struct sockaddr *sa = (struct sockaddr *)&ss; 5202 socklen_t salen; 5203 int snmp_s, ax_s; 5204 uint32_t sessionid; 5205 struct varbind varbind = { 5206 .type = TYPE_NULL, 5207 .name = OID_STRUCT(MIB_BACKEND_ERROR, 46), 5208 }; 5209 int32_t requestid; 5210 char buf[1024]; 5211 size_t n; 5212 5213 ax_s = agentx_connect(axsocket); 5214 sessionid = agentx_open(ax_s, 0, 0, 5215 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 46), __func__); 5216 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5217 OID_ARG(MIB_BACKEND_ERROR, 46), 0); 5218 5219 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5220 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5221 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5222 5223 varbind.name.subid[varbind.name.n_subid++] = 0; 5224 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5225 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5226 varbind.name.n_subid--; 5227 agentx_response(ax_s, buf, UNDOFAILED, 1, &varbind, 1); 5228 5229 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5230 &varbind, 1); 5231 } 5232 5233 void 5234 backend_error_getnext_authorizationerror(void) 5235 { 5236 struct sockaddr_storage ss; 5237 struct sockaddr *sa = (struct sockaddr *)&ss; 5238 socklen_t salen; 5239 int snmp_s, ax_s; 5240 uint32_t sessionid; 5241 struct varbind varbind = { 5242 .type = TYPE_NULL, 5243 .name = OID_STRUCT(MIB_BACKEND_ERROR, 47), 5244 }; 5245 int32_t requestid; 5246 char buf[1024]; 5247 size_t n; 5248 5249 ax_s = agentx_connect(axsocket); 5250 sessionid = agentx_open(ax_s, 0, 0, 5251 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 47), __func__); 5252 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5253 OID_ARG(MIB_BACKEND_ERROR, 47), 0); 5254 5255 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5256 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5257 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5258 5259 varbind.name.subid[varbind.name.n_subid++] = 0; 5260 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5261 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5262 varbind.name.n_subid--; 5263 agentx_response(ax_s, buf, AUTHORIZATIONERROR, 1, &varbind, 1); 5264 5265 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5266 &varbind, 1); 5267 } 5268 5269 void 5270 backend_error_getnext_notwritable(void) 5271 { 5272 struct sockaddr_storage ss; 5273 struct sockaddr *sa = (struct sockaddr *)&ss; 5274 socklen_t salen; 5275 int snmp_s, ax_s; 5276 uint32_t sessionid; 5277 struct varbind varbind = { 5278 .type = TYPE_NULL, 5279 .name = OID_STRUCT(MIB_BACKEND_ERROR, 48), 5280 }; 5281 int32_t requestid; 5282 char buf[1024]; 5283 size_t n; 5284 5285 ax_s = agentx_connect(axsocket); 5286 sessionid = agentx_open(ax_s, 0, 0, 5287 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 48), __func__); 5288 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5289 OID_ARG(MIB_BACKEND_ERROR, 48), 0); 5290 5291 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5292 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5293 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5294 5295 varbind.name.subid[varbind.name.n_subid++] = 0; 5296 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5297 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5298 varbind.name.n_subid--; 5299 agentx_response(ax_s, buf, NOTWRITABLE, 1, &varbind, 1); 5300 5301 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5302 &varbind, 1); 5303 } 5304 5305 void 5306 backend_error_getnext_inconsistentname(void) 5307 { 5308 struct sockaddr_storage ss; 5309 struct sockaddr *sa = (struct sockaddr *)&ss; 5310 socklen_t salen; 5311 int snmp_s, ax_s; 5312 uint32_t sessionid; 5313 struct varbind varbind = { 5314 .type = TYPE_NULL, 5315 .name = OID_STRUCT(MIB_BACKEND_ERROR, 49), 5316 }; 5317 int32_t requestid; 5318 char buf[1024]; 5319 size_t n; 5320 5321 ax_s = agentx_connect(axsocket); 5322 sessionid = agentx_open(ax_s, 0, 0, 5323 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 49), __func__); 5324 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5325 OID_ARG(MIB_BACKEND_ERROR, 49), 0); 5326 5327 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5328 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5329 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5330 5331 varbind.name.subid[varbind.name.n_subid++] = 0; 5332 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5333 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5334 varbind.name.n_subid--; 5335 agentx_response(ax_s, buf, INCONSISTENTNAME, 1, &varbind, 1); 5336 5337 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5338 &varbind, 1); 5339 } 5340 5341 void 5342 backend_error_getnext_openfailed(void) 5343 { 5344 struct sockaddr_storage ss; 5345 struct sockaddr *sa = (struct sockaddr *)&ss; 5346 socklen_t salen; 5347 int snmp_s, ax_s; 5348 uint32_t sessionid; 5349 struct varbind varbind = { 5350 .type = TYPE_NULL, 5351 .name = OID_STRUCT(MIB_BACKEND_ERROR, 50), 5352 }; 5353 int32_t requestid; 5354 char buf[1024]; 5355 size_t n; 5356 5357 ax_s = agentx_connect(axsocket); 5358 sessionid = agentx_open(ax_s, 0, 0, 5359 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 50), __func__); 5360 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5361 OID_ARG(MIB_BACKEND_ERROR, 50), 0); 5362 5363 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5364 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5365 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5366 5367 varbind.name.subid[varbind.name.n_subid++] = 0; 5368 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5369 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5370 varbind.name.n_subid--; 5371 agentx_response(ax_s, buf, OPENFAILED, 1, &varbind, 1); 5372 5373 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5374 &varbind, 1); 5375 } 5376 5377 void 5378 backend_error_getnext_notopen(void) 5379 { 5380 struct sockaddr_storage ss; 5381 struct sockaddr *sa = (struct sockaddr *)&ss; 5382 socklen_t salen; 5383 int snmp_s, ax_s; 5384 uint32_t sessionid; 5385 struct varbind varbind = { 5386 .type = TYPE_NULL, 5387 .name = OID_STRUCT(MIB_BACKEND_ERROR, 51), 5388 }; 5389 int32_t requestid; 5390 char buf[1024]; 5391 size_t n; 5392 5393 ax_s = agentx_connect(axsocket); 5394 sessionid = agentx_open(ax_s, 0, 0, 5395 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 51), __func__); 5396 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5397 OID_ARG(MIB_BACKEND_ERROR, 51), 0); 5398 5399 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5400 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5401 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5402 5403 varbind.name.subid[varbind.name.n_subid++] = 0; 5404 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5405 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5406 varbind.name.n_subid--; 5407 agentx_response(ax_s, buf, NOTOPEN, 1, &varbind, 1); 5408 5409 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5410 &varbind, 1); 5411 } 5412 5413 void 5414 backend_error_getnext_indexwrongtype(void) 5415 { 5416 struct sockaddr_storage ss; 5417 struct sockaddr *sa = (struct sockaddr *)&ss; 5418 socklen_t salen; 5419 int snmp_s, ax_s; 5420 uint32_t sessionid; 5421 struct varbind varbind = { 5422 .type = TYPE_NULL, 5423 .name = OID_STRUCT(MIB_BACKEND_ERROR, 52), 5424 }; 5425 int32_t requestid; 5426 char buf[1024]; 5427 size_t n; 5428 5429 ax_s = agentx_connect(axsocket); 5430 sessionid = agentx_open(ax_s, 0, 0, 5431 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 52), __func__); 5432 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5433 OID_ARG(MIB_BACKEND_ERROR, 52), 0); 5434 5435 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5436 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5437 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5438 5439 varbind.name.subid[varbind.name.n_subid++] = 0; 5440 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5441 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5442 varbind.name.n_subid--; 5443 agentx_response(ax_s, buf, INDEXWRONGTYPE, 1, &varbind, 1); 5444 5445 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5446 &varbind, 1); 5447 } 5448 5449 void 5450 backend_error_getnext_indexalreadyallocated(void) 5451 { 5452 struct sockaddr_storage ss; 5453 struct sockaddr *sa = (struct sockaddr *)&ss; 5454 socklen_t salen; 5455 int snmp_s, ax_s; 5456 uint32_t sessionid; 5457 struct varbind varbind = { 5458 .type = TYPE_NULL, 5459 .name = OID_STRUCT(MIB_BACKEND_ERROR, 53), 5460 }; 5461 int32_t requestid; 5462 char buf[1024]; 5463 size_t n; 5464 5465 ax_s = agentx_connect(axsocket); 5466 sessionid = agentx_open(ax_s, 0, 0, 5467 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 53), __func__); 5468 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5469 OID_ARG(MIB_BACKEND_ERROR, 53), 0); 5470 5471 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5472 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5473 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5474 5475 varbind.name.subid[varbind.name.n_subid++] = 0; 5476 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5477 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5478 varbind.name.n_subid--; 5479 agentx_response(ax_s, buf, INDEXALREADYALLOCATED, 1, &varbind, 1); 5480 5481 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5482 &varbind, 1); 5483 } 5484 5485 void 5486 backend_error_getnext_indexnonavailable(void) 5487 { 5488 struct sockaddr_storage ss; 5489 struct sockaddr *sa = (struct sockaddr *)&ss; 5490 socklen_t salen; 5491 int snmp_s, ax_s; 5492 uint32_t sessionid; 5493 struct varbind varbind = { 5494 .type = TYPE_NULL, 5495 .name = OID_STRUCT(MIB_BACKEND_ERROR, 54), 5496 }; 5497 int32_t requestid; 5498 char buf[1024]; 5499 size_t n; 5500 5501 ax_s = agentx_connect(axsocket); 5502 sessionid = agentx_open(ax_s, 0, 0, 5503 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 54), __func__); 5504 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5505 OID_ARG(MIB_BACKEND_ERROR, 54), 0); 5506 5507 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5508 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5509 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5510 5511 varbind.name.subid[varbind.name.n_subid++] = 0; 5512 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5513 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5514 varbind.name.n_subid--; 5515 agentx_response(ax_s, buf, INDEXNONEAVAILABLE, 1, &varbind, 1); 5516 5517 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5518 &varbind, 1); 5519 } 5520 5521 void 5522 backend_error_getnext_indexnotallocated(void) 5523 { 5524 struct sockaddr_storage ss; 5525 struct sockaddr *sa = (struct sockaddr *)&ss; 5526 socklen_t salen; 5527 int snmp_s, ax_s; 5528 uint32_t sessionid; 5529 struct varbind varbind = { 5530 .type = TYPE_NULL, 5531 .name = OID_STRUCT(MIB_BACKEND_ERROR, 55), 5532 }; 5533 int32_t requestid; 5534 char buf[1024]; 5535 size_t n; 5536 5537 ax_s = agentx_connect(axsocket); 5538 sessionid = agentx_open(ax_s, 0, 0, 5539 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 55), __func__); 5540 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5541 OID_ARG(MIB_BACKEND_ERROR, 55), 0); 5542 5543 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5544 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5545 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5546 5547 varbind.name.subid[varbind.name.n_subid++] = 0; 5548 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5549 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5550 varbind.name.n_subid--; 5551 agentx_response(ax_s, buf, INDEXNOTALLOCATED, 1, &varbind, 1); 5552 5553 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5554 &varbind, 1); 5555 } 5556 5557 void 5558 backend_error_getnext_unsupportedcontext(void) 5559 { 5560 struct sockaddr_storage ss; 5561 struct sockaddr *sa = (struct sockaddr *)&ss; 5562 socklen_t salen; 5563 int snmp_s, ax_s; 5564 uint32_t sessionid; 5565 struct varbind varbind = { 5566 .type = TYPE_NULL, 5567 .name = OID_STRUCT(MIB_BACKEND_ERROR, 56), 5568 }; 5569 int32_t requestid; 5570 char buf[1024]; 5571 size_t n; 5572 5573 ax_s = agentx_connect(axsocket); 5574 sessionid = agentx_open(ax_s, 0, 0, 5575 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 56), __func__); 5576 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5577 OID_ARG(MIB_BACKEND_ERROR, 56), 0); 5578 5579 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5580 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5581 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5582 5583 varbind.name.subid[varbind.name.n_subid++] = 0; 5584 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5585 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5586 varbind.name.n_subid--; 5587 agentx_response(ax_s, buf, UNSUPPORTEDCONTEXT, 1, &varbind, 1); 5588 5589 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5590 &varbind, 1); 5591 } 5592 5593 void 5594 backend_error_getnext_duplicateregistration(void) 5595 { 5596 struct sockaddr_storage ss; 5597 struct sockaddr *sa = (struct sockaddr *)&ss; 5598 socklen_t salen; 5599 int snmp_s, ax_s; 5600 uint32_t sessionid; 5601 struct varbind varbind = { 5602 .type = TYPE_NULL, 5603 .name = OID_STRUCT(MIB_BACKEND_ERROR, 57), 5604 }; 5605 int32_t requestid; 5606 char buf[1024]; 5607 size_t n; 5608 5609 ax_s = agentx_connect(axsocket); 5610 sessionid = agentx_open(ax_s, 0, 0, 5611 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 57), __func__); 5612 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5613 OID_ARG(MIB_BACKEND_ERROR, 57), 0); 5614 5615 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5616 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5617 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5618 5619 varbind.name.subid[varbind.name.n_subid++] = 0; 5620 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5621 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5622 varbind.name.n_subid--; 5623 agentx_response(ax_s, buf, DUPLICATEREGISTRATION, 1, &varbind, 1); 5624 5625 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5626 &varbind, 1); 5627 } 5628 5629 void 5630 backend_error_getnext_unknownregistration(void) 5631 { 5632 struct sockaddr_storage ss; 5633 struct sockaddr *sa = (struct sockaddr *)&ss; 5634 socklen_t salen; 5635 int snmp_s, ax_s; 5636 uint32_t sessionid; 5637 struct varbind varbind = { 5638 .type = TYPE_NULL, 5639 .name = OID_STRUCT(MIB_BACKEND_ERROR, 58), 5640 }; 5641 int32_t requestid; 5642 char buf[1024]; 5643 size_t n; 5644 5645 ax_s = agentx_connect(axsocket); 5646 sessionid = agentx_open(ax_s, 0, 0, 5647 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 58), __func__); 5648 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5649 OID_ARG(MIB_BACKEND_ERROR, 58), 0); 5650 5651 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5652 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5653 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5654 5655 varbind.name.subid[varbind.name.n_subid++] = 0; 5656 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5657 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5658 varbind.name.n_subid--; 5659 agentx_response(ax_s, buf, UNKNOWNREGISTRATION, 1, &varbind, 1); 5660 5661 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5662 &varbind, 1); 5663 } 5664 5665 void 5666 backend_error_getnext_parseerror(void) 5667 { 5668 struct sockaddr_storage ss; 5669 struct sockaddr *sa = (struct sockaddr *)&ss; 5670 socklen_t salen; 5671 int snmp_s, ax_s; 5672 uint32_t sessionid; 5673 struct varbind varbind = { 5674 .type = TYPE_NULL, 5675 .name = OID_STRUCT(MIB_BACKEND_ERROR, 59), 5676 }; 5677 int32_t requestid; 5678 char buf[1024]; 5679 size_t n; 5680 5681 ax_s = agentx_connect(axsocket); 5682 sessionid = agentx_open(ax_s, 0, 0, 5683 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 59), __func__); 5684 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5685 OID_ARG(MIB_BACKEND_ERROR, 59), 0); 5686 5687 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5688 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5689 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5690 5691 varbind.name.subid[varbind.name.n_subid++] = 0; 5692 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5693 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5694 varbind.name.n_subid--; 5695 agentx_response(ax_s, buf, PARSEERROR, 1, &varbind, 1); 5696 5697 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5698 &varbind, 1); 5699 } 5700 5701 void 5702 backend_error_getnext_requestdenied(void) 5703 { 5704 struct sockaddr_storage ss; 5705 struct sockaddr *sa = (struct sockaddr *)&ss; 5706 socklen_t salen; 5707 int snmp_s, ax_s; 5708 uint32_t sessionid; 5709 struct varbind varbind = { 5710 .type = TYPE_NULL, 5711 .name = OID_STRUCT(MIB_BACKEND_ERROR, 60), 5712 }; 5713 int32_t requestid; 5714 char buf[1024]; 5715 size_t n; 5716 5717 ax_s = agentx_connect(axsocket); 5718 sessionid = agentx_open(ax_s, 0, 0, 5719 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 60), __func__); 5720 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5721 OID_ARG(MIB_BACKEND_ERROR, 60), 0); 5722 5723 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5724 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5725 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5726 5727 varbind.name.subid[varbind.name.n_subid++] = 0; 5728 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5729 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5730 varbind.name.n_subid--; 5731 agentx_response(ax_s, buf, REQUESTDENIED, 1, &varbind, 1); 5732 5733 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5734 &varbind, 1); 5735 } 5736 5737 void 5738 backend_error_getnext_processingerror(void) 5739 { 5740 struct sockaddr_storage ss; 5741 struct sockaddr *sa = (struct sockaddr *)&ss; 5742 socklen_t salen; 5743 int snmp_s, ax_s; 5744 uint32_t sessionid; 5745 struct varbind varbind = { 5746 .type = TYPE_NULL, 5747 .name = OID_STRUCT(MIB_BACKEND_ERROR, 61), 5748 }; 5749 int32_t requestid; 5750 char buf[1024]; 5751 size_t n; 5752 5753 ax_s = agentx_connect(axsocket); 5754 sessionid = agentx_open(ax_s, 0, 0, 5755 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 61), __func__); 5756 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5757 OID_ARG(MIB_BACKEND_ERROR, 61), 0); 5758 5759 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5760 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5761 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5762 5763 varbind.name.subid[varbind.name.n_subid++] = 0; 5764 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5765 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5766 varbind.name.n_subid--; 5767 agentx_response(ax_s, buf, PROCESSINGERROR, 1, &varbind, 1); 5768 5769 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5770 &varbind, 1); 5771 } 5772 5773 void 5774 backend_error_getnext_nonstandard(void) 5775 { 5776 struct sockaddr_storage ss; 5777 struct sockaddr *sa = (struct sockaddr *)&ss; 5778 socklen_t salen; 5779 int snmp_s, ax_s; 5780 uint32_t sessionid; 5781 struct varbind varbind = { 5782 .type = TYPE_NULL, 5783 .name = OID_STRUCT(MIB_BACKEND_ERROR, 62), 5784 }; 5785 int32_t requestid; 5786 char buf[1024]; 5787 size_t n; 5788 5789 ax_s = agentx_connect(axsocket); 5790 sessionid = agentx_open(ax_s, 0, 0, 5791 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 62), __func__); 5792 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5793 OID_ARG(MIB_BACKEND_ERROR, 62), 0); 5794 5795 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5796 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5797 requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1); 5798 5799 varbind.name.subid[varbind.name.n_subid++] = 0; 5800 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5801 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5802 varbind.name.n_subid--; 5803 agentx_response(ax_s, buf, 0xFFFF, 1, &varbind, 1); 5804 5805 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5806 &varbind, 1); 5807 } 5808 5809 void 5810 backend_error_getbulk_firstrepetition(void) 5811 { 5812 struct sockaddr_storage ss; 5813 struct sockaddr *sa = (struct sockaddr *)&ss; 5814 socklen_t salen; 5815 int snmp_s, ax_s; 5816 uint32_t sessionid; 5817 struct varbind varbind = { 5818 .type = TYPE_NULL, 5819 .name = OID_STRUCT(MIB_BACKEND_ERROR, 63), 5820 }; 5821 int32_t requestid; 5822 char buf[1024]; 5823 size_t n; 5824 5825 ax_s = agentx_connect(axsocket); 5826 sessionid = agentx_open(ax_s, 0, 0, 5827 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 63), __func__); 5828 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5829 OID_ARG(MIB_BACKEND_ERROR, 63), 0); 5830 5831 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5832 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5833 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1); 5834 5835 varbind.name.subid[varbind.name.n_subid++] = 0; 5836 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5837 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5838 varbind.name.n_subid--; 5839 agentx_response(ax_s, buf, GENERR, 1, &varbind, 1); 5840 5841 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5842 &varbind, 1); 5843 } 5844 5845 void 5846 backend_error_getbulk_secondrepetition(void) 5847 { 5848 struct sockaddr_storage ss; 5849 struct sockaddr *sa = (struct sockaddr *)&ss; 5850 socklen_t salen; 5851 int snmp_s, ax_s; 5852 uint32_t sessionid; 5853 struct varbind varbind = { 5854 .type = TYPE_NULL, 5855 .name = OID_STRUCT(MIB_BACKEND_ERROR, 64), 5856 .data.int32 = 1 5857 }; 5858 int32_t requestid; 5859 char buf[1024]; 5860 size_t n; 5861 5862 ax_s = agentx_connect(axsocket); 5863 sessionid = agentx_open(ax_s, 0, 0, 5864 OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 64), __func__); 5865 agentx_register(ax_s, sessionid, 0, 0, 127, 0, 5866 OID_ARG(MIB_BACKEND_ERROR, 64), 0); 5867 5868 salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa); 5869 snmp_s = snmp_connect(SOCK_DGRAM, sa, salen); 5870 requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1); 5871 5872 varbind.name.subid[varbind.name.n_subid++] = 0; 5873 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5874 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5875 varbind.type = TYPE_INTEGER; 5876 agentx_response(ax_s, buf, 0, NOERROR, &varbind, 1); 5877 varbind.name.subid[varbind.name.n_subid - 1] = 1; 5878 n = agentx_read(ax_s, buf, sizeof(buf), 1000); 5879 agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1); 5880 varbind.name.subid[varbind.name.n_subid - 1] = 0; 5881 varbind.type = TYPE_NULL; 5882 agentx_response(ax_s, buf, 0, GENERR, &varbind, 1); 5883 5884 varbind.name.n_subid--; 5885 snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1, 5886 &varbind, 1); 5887 } 5888