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