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