#include <sys/socket.h>
#include <sys/time.h>
#include <ber.h>
#include <err.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include "regress.h"
#define MIB_BACKEND_GET MIB_BACKEND, 1
#define MIB_BACKEND_GETNEXT MIB_BACKEND, 2
#define MIB_BACKEND_GETBULK MIB_BACKEND, 3
#define MIB_BACKEND_ERROR MIB_BACKEND, 4
#define MIB_SUBAGENT_BACKEND_GET MIB_SUBAGENT_BACKEND, 1
#define MIB_SUBAGENT_BACKEND_GETNEXT MIB_SUBAGENT_BACKEND, 2
#define MIB_SUBAGENT_BACKEND_GETBULK MIB_SUBAGENT_BACKEND, 3
#define MIB_SUBAGENT_BACKEND_ERROR MIB_SUBAGENT_BACKEND, 4
#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
void
backend_get_integer(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 1, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 1), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_octetstring(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 2, 0),
.data.octetstring.string = "test",
.data.octetstring.len = 4
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 2), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_OCTETSTRING;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_objectidentifier(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 3, 0),
.data.oid = OID_STRUCT(MIB_BACKEND_GET, 3, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 3), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 3), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_OBJECTIDENTIFIER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_ipaddress(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 4, 0),
.data.octetstring.string = "\0\0\0\0",
.data.octetstring.len = 4
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 4), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 4), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_IPADDRESS;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_counter32(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 5, 0),
.data.uint32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 5), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 5), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_COUNTER32;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_gauge32(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 6, 0),
.data.uint32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 6), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 6), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_GAUGE32;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_timeticks(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 7, 0),
.data.uint32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 7), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 7), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_TIMETICKS;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_opaque(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 8, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct ber ber = {};
struct ber_element *elm;
ssize_t len;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 8), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 8), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
if ((elm = ober_add_integer(NULL, 1)) == NULL)
err(1, "ober_add_integer");
if (ober_write_elements(&ber, elm) == -1)
err(1, "ober_write_elements");
varbind.data.octetstring.len = ober_get_writebuf(
&ber, (void **)&varbind.data.octetstring.string);
ober_free_elements(elm);
varbind.type = TYPE_OPAQUE;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
ober_free(&ber);
}
void
backend_get_counter64(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 9, 0),
.data.uint64 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 9), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 9), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_COUNTER64;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_nosuchobject(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 10, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 10), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 10), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_NOSUCHOBJECT;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_nosuchinstance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 11, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 11), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 11), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_NOSUCHINSTANCE;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_endofmibview(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 12, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 12), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 12), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_ENDOFMIBVIEW;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_get_two_single_backend(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 13, 1),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 13, 2),
.data.int32 = 2
}
};
struct varbind varbind_ax[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 13, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 13, 2),
.data.int32 = 2
}
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 13), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 13), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, varbind, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2);
varbind[0].type = varbind[1].type = TYPE_INTEGER;
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 2);
}
void
backend_get_two_double_backend(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s1, ax_s2;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 14, 1),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 14, 2),
.data.int32 = 2
}
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s1 = agentx_connect(axsocket);
ax_s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s1, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 14, 1),
"backend_get_two_double_backend.1");
sessionid2 = agentx_open(ax_s2, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 14, 2),
"backend_get_two_double_backend.2");
agentx_register(ax_s1, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 14, 1), 0);
agentx_register(ax_s2, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 14, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, varbind, 2);
varbind[0].type = varbind[1].type = TYPE_INTEGER;
n = agentx_read(ax_s1, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid1, varbind, 1);
agentx_response(ax_s1, buf, NOERROR, 0, varbind, 1);
n = agentx_read(ax_s2, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, varbind + 1, 1);
agentx_response(ax_s2, buf, NOERROR, 0, varbind + 1, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 2);
}
void
backend_get_wrongorder(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 15, 1),
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 15, 2),
}
};
struct varbind varbind_ax[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 15, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 15, 2),
.data.int32 = 2
}
}, tmpvarbind;
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 15), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 15), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, varbind, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2);
tmpvarbind = varbind_ax[0];
varbind_ax[0] = varbind_ax[1];
varbind_ax[1] = tmpvarbind;
agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2,
varbind, 2);
}
void
backend_get_toofew(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 16, 1),
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 16, 2),
}
};
struct varbind varbind_ax[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 16, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 16, 2),
.data.int32 = 2
}
}, tmpvarbind;
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 16), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 16), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, varbind, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2,
varbind, 2);
}
void
backend_get_toomany(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 17, 1),
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 17, 2),
}
};
struct varbind varbind_ax[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 17, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 17, 2),
.data.int32 = 2
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GET, 17, 3),
.data.int32 = 3
}
}, tmpvarbind;
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 17), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 17), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, varbind, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, varbind_ax, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 3);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2,
varbind, 2);
}
void
backend_get_instance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 18, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 18), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 18, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_instance_below(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 19, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 19), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 19), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_NOSUCHINSTANCE;
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_timeout_default(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 20, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct timespec start, end, diff;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 20), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 20), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
err(1, "clock_gettime");
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1,
&varbind, 1);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
err(1, "clock_gettime");
timespecsub(&end, &start, &diff);
if (diff.tv_sec != 5)
errx(1, "%s: unexpected timeout (%lld.%09ld/5)", __func__,
diff.tv_sec, diff.tv_nsec);
}
void
backend_get_timeout_session_lower(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 21, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct timespec start, end, diff;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 1,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 21), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 21), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
err(1, "clock_gettime");
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1,
&varbind, 1);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
err(1, "clock_gettime");
timespecsub(&end, &start, &diff);
if (diff.tv_sec != 1)
errx(1, "%s: unexpected timeout (%lld.%09ld/1)", __func__,
diff.tv_sec, diff.tv_nsec);
}
void
backend_get_timeout_session_higher(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 22, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct timespec start, end, diff;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 6,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 22), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 22), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
err(1, "clock_gettime");
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 7000, community, requestid, GENERR, 1,
&varbind, 1);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
err(1, "clock_gettime");
timespecsub(&end, &start, &diff);
if (diff.tv_sec != 6)
errx(1, "%s: unexpected timeout (%lld.%09ld/6)", __func__,
diff.tv_sec, diff.tv_nsec);
}
void
backend_get_timeout_region_lower(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 23, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct timespec start, end, diff;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 4,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 23), __func__);
agentx_register(ax_s, sessionid, 0, 1, 127, 0,
OID_ARG(MIB_BACKEND_GET, 23), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
err(1, "clock_gettime");
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 6000, community, requestid, GENERR, 1,
&varbind, 1);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
err(1, "clock_gettime");
timespecsub(&end, &start, &diff);
if (diff.tv_sec != 1)
errx(1, "%s: unexpected timeout (%lld.%09ld/1)", __func__,
diff.tv_sec, diff.tv_nsec);
}
void
backend_get_timeout_region_higher(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 24, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
struct timespec start, end, diff;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 7,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 24), __func__);
agentx_register(ax_s, sessionid, 0, 6, 127, 0,
OID_ARG(MIB_BACKEND_GET, 24), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
err(1, "clock_gettime");
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 8000, community, requestid, GENERR, 1,
&varbind, 1);
if (clock_gettime(CLOCK_MONOTONIC, &end) == -1)
err(1, "clock_gettime");
timespecsub(&end, &start, &diff);
if (diff.tv_sec != 6)
errx(1, "%s: unexpected timeout (%lld.%09ld/6)", __func__,
diff.tv_sec, diff.tv_nsec);
}
void
backend_get_priority_lower(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 25, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 25, 1), "backend_get_priority.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 25, 2), "backend_get_priority.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 25), 0);
agentx_register(ax_s, sessionid2, 0, 0, 126, 0,
OID_ARG(MIB_BACKEND_GET, 25), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_priority_higher(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 26, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 26, 1),
"backend_get_priority_higher.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 26, 2),
"backend_get_priority_higher.2");
agentx_register(ax_s, sessionid1, 0, 0, 126, 0,
OID_ARG(MIB_BACKEND_GET, 26), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 26), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_priority_below_lower(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 27, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 27, 1),
"backend_get_priority_below_lower.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 27, 2),
"backend_get_priority_below_lower.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 27), 0);
agentx_register(ax_s, sessionid2, 0, 0, 126, 0,
OID_ARG(MIB_BACKEND_GET, 27, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_priority_below_higher(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 28, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 28, 1),
"backend_get_priority_below_higher.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 28, 2),
"backend_get_priority_below_higher.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 28), 0);
agentx_register(ax_s, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GET, 28, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_close(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 29, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 29), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 29), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_close(ax_s, sessionid, REASONOTHER);
varbind.type = TYPE_NOSUCHOBJECT;
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_close_overlap(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s1, ax_s2;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 30, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s1 = agentx_connect(axsocket);
ax_s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s1, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 30, 1),
"backend_get_close_overlap.1");
sessionid2 = agentx_open(ax_s2, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 30, 1),
"backend_get_close_overlap.2");
agentx_register(ax_s1, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 30), 0);
agentx_register(ax_s2, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GET, 30), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s1, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1);
agentx_close(ax_s1, sessionid1, REASONOTHER);
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s2, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1);
agentx_response(ax_s2, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_disappear(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 31, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 31), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 31), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
close(ax_s);
varbind.type = TYPE_NOSUCHOBJECT;
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_disappear_overlap(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s1, ax_s2;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 32, 0),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s1 = agentx_connect(axsocket);
ax_s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s1, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 32, 1),
"backend_get_close_overlap.1");
sessionid2 = agentx_open(ax_s2, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 32, 1),
"backend_get_close_overlap.2");
agentx_register(ax_s1, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 32), 0);
agentx_register(ax_s2, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GET, 32), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s1, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1);
close(ax_s1);
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s2, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid2, &varbind, 1);
agentx_response(ax_s2, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_disappear_doublesession(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 33, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 33, 1),
"backend_get_disappear_doublesession.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 33, 2),
"backend_get_disappear_doublesession.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 33), 0);
agentx_register(ax_s, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GET, 33), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid1, &varbind, 1);
close(ax_s);
varbind.type = TYPE_NOSUCHOBJECT;
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_octetstring_max(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
char vbbuf[65535] = {};
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 34, 0),
.data.octetstring.string = vbbuf,
.data.octetstring.len = sizeof(vbbuf)
};
int32_t requestid;
char buf[1024];
size_t n;
memset(vbbuf, 'a', sizeof(vbbuf));
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 34), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 34), 0);
salen = snmp_resolve(SOCK_STREAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_STREAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_OCTETSTRING;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_get_octetstring_too_long(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
char vbbuf[65536];
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 35, 0),
.data.octetstring.string = vbbuf,
.data.octetstring.len = sizeof(vbbuf)
};
int32_t requestid;
char buf[1024];
size_t n;
memset(vbbuf, 'a', sizeof(vbbuf));
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 35), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 35), 0);
salen = snmp_resolve(SOCK_STREAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_STREAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_OCTETSTRING;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_get_ipaddress_too_short(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 36, 0),
.data.octetstring.string = "\0\0\0",
.data.octetstring.len = 3
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 36), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 36), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_IPADDRESS;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_get_ipaddress_too_long(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 37, 0),
.data.octetstring.string = "\0\0\0\0\0",
.data.octetstring.len = 5
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 37), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 37), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_IPADDRESS;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_get_opaque_non_ber(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 38, 0),
.data.octetstring.string = "\1",
.data.octetstring.len = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ssize_t len;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 38), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 38), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
varbind.type = TYPE_OPAQUE;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_get_opaque_double_value(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
char vbbuf[1024];
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GET, 39, 0),
.data.octetstring.string = vbbuf
};
int32_t requestid;
void *berdata;
char buf[1024];
size_t n;
struct ber ber = {};
struct ber_element *elm;
ssize_t len;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GET, 39), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GET, 39), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
if ((elm = ober_add_integer(NULL, 1)) == NULL)
err(1, "ober_add_integer");
if (ober_write_elements(&ber, elm) == -1)
err(1, "ober_write_elements");
len = ober_get_writebuf(&ber, &berdata);
ober_free_elements(elm);
memcpy(vbbuf, berdata, len);
memcpy(vbbuf + len, berdata, len);
varbind.data.octetstring.len = 2 * len;
varbind.type = TYPE_OPAQUE;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
ober_free(&ber);
}
void
backend_getnext_selfbound(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 1),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 1), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_lowerbound(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 2),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 2),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 2, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 2, 1),
"backend_getnext_lowerbound.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 2, 2),
"backend_getnext_lowerbound.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 2), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 2, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_lowerbound_self(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 3),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 3),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 4)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 3), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 3), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_lowerbound_highprio(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 4),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 4),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 4, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 4, 1),
"backend_getnext_lowerbound_highprio.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 4, 2),
"backend_getnext_lowerbound_highprio.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 4), 0);
agentx_register(ax_s, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 4, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_lowerbound_lowprio(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 5),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 5),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 5, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 5, 1),
"backend_getnext_lowerbound_lowprio.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 5, 2),
"backend_getnext_lowerbound_lowprio.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 5), 0);
agentx_register(ax_s, sessionid2, 0, 0, 128, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 5, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_sibling(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 6),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 6),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 8)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 6), 0);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 7), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_child_gap(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 7),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 7),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 7, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6, 1),
"backend_getnext_child_gap.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 6, 2),
"backend_getnext_child_gap.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 7), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 7, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_nosuchobject(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 8),
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 8),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 9)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 8), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 8), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_NOSUCHOBJECT;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name.n_subid--;
varbind.type = TYPE_NULL;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_nosuchinstance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 9),
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 9),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 10)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 9), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 9), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_NOSUCHINSTANCE;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name.n_subid--;
varbind.type = TYPE_NULL;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_endofmibview(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(2, 0),
};
struct searchrange searchrange = {
.start = OID_STRUCT(2, 0),
.end = OID_STRUCT(2, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 10), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(2, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
&varbind, 1);
}
void
backend_getnext_inclusive(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 11),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 11, 0),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 11, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
searchrange.start.include = 1;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 11), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 11, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
backend_getnext_jumpnext(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind1 = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 12)
}, varbind2 = {
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1),
.data.int32 = 1
};
struct searchrange searchrange1 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 12),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1)
}, searchrange2 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 12, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 12, 1),
"backend_getnext_jumpnext.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 12, 2),
"backend_getnext_jumpnext.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 12), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 12, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1);
varbind1.type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1,
&varbind1, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1);
searchrange2.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2,
&varbind2, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind2, 1);
}
void
backend_getnext_jumpnext_endofmibview(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind1 = {
.type = TYPE_NULL,
.name = OID_STRUCT(2, 0)
}, varbind2 = {
.type = TYPE_ENDOFMIBVIEW,
.name = OID_STRUCT(2, 1),
};
struct searchrange searchrange1 = {
.start = OID_STRUCT(2, 0),
.end = OID_STRUCT(2, 1)
}, searchrange2 = {
.start = OID_STRUCT(2, 1),
.end = OID_STRUCT(2, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 13, 1),
"backend_getnext_jumpnext_endofmibview.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 13, 2),
"backend_getnext_jumpnext_endofmibview.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(2, 0), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(2, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1);
varbind1.type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1,
&varbind1, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1);
searchrange2.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2,
&varbind2, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind1, 1);
}
void
backend_getnext_jump_up(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind1 = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 1)
}, varbind2 = {
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2),
.data.int32 = 1
};
struct searchrange searchrange1 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2)
}, searchrange2 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 14, 2),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 15)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 14, 1),
"backend_getnext_jump_up.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 14, 2),
"backend_getnext_jump_up.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 14), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 14, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind1, 1);
varbind1.type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange1,
&varbind1, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind1, 1);
searchrange2.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange2,
&varbind2, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind2, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind2, 1);
}
void
backend_getnext_two_single_backend(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 0),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1),
.data.int32 = 2
}
};
struct varbind varbind_ax[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 2),
.data.int32 = 2
}
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 0),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16)
},
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 15, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16)
}
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 15), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 15), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange,
varbind_ax, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind_ax, 2);
varbind[0].type = varbind[1].type = TYPE_INTEGER;
varbind[0].name.subid[varbind[0].name.n_subid -1]++;
varbind[1].name.subid[varbind[1].name.n_subid - 1]++;
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 2);
}
void
backend_getnext_two_double_backend(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s1, ax_s2;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 1),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2),
.data.int32 = 2
}
};
struct searchrange searchrange1 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2)
}, searchrange2 = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 2),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 16, 3)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s1 = agentx_connect(axsocket);
ax_s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s1, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 16, 1),
"backend_getnext_two_double_backend.1");
sessionid2 = agentx_open(ax_s2, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 16, 2),
"backend_getnext_two_double_backend.2");
agentx_register(ax_s1, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 16, 1), 0);
agentx_register(ax_s2, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 16, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2);
varbind[0].name.subid[varbind[0].name.n_subid++] = 0;
varbind[1].name.subid[varbind[1].name.n_subid++] = 0;
varbind[0].type = varbind[1].type = TYPE_INTEGER;
n = agentx_read(ax_s1, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, &searchrange1,
varbind + 0, 1);
agentx_response(ax_s1, buf, NOERROR, 0, varbind + 0, 1);
n = agentx_read(ax_s2, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid2, &searchrange2,
varbind + 1, 1);
agentx_response(ax_s2, buf, NOERROR, 0, varbind + 1, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 2);
}
void
backend_getnext_instance_below(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 1, 1),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 2),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 3)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 17), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 17, 1), 0);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 17, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 17, 2);
searchrange.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
&varbind, 1);
}
void
backend_getnext_instance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 18),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 18), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 18, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 18, 1);
searchrange.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
&varbind, 1);
}
void
backend_getnext_instance_exact(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 1),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 2),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 3)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 19), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 19, 1), 0);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 19, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 19, 2);
searchrange.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
&varbind, 1);
}
void
backend_getnext_instance_ignore(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 20), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 20, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20, 1, 0);
searchrange.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
varbind.name.n_subid -= 2;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_backwards(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 21),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 22)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 21), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 21), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 20);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 21);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_stale(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 22),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 23)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 22), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 22), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_inclusive_backwards(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23),
.data.int32 = 1
};
struct searchrange searchrange = {
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 2)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 23), __func__);
agentx_register(ax_s, sessionid, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 23, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.type = TYPE_INTEGER;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23, 1);
searchrange.start.include = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 22);
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
varbind.type = TYPE_NULL;
varbind.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 23);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_getnext_toofew(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1),
.data.int32 = 2
}
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 25)
},
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 25)
}
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 24), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 24), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2);
varbind[0].name.subid[varbind[0].name.n_subid - 1]++;
varbind[1].name.subid[varbind[1].name.n_subid - 1]++;
varbind[0].type = varbind[1].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange,
varbind, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
varbind[0].type = varbind[1].type = TYPE_NULL;
varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 0),
varbind[1].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 24, 1),
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2,
varbind, 2);
}
void
backend_getnext_toomany(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1),
.data.int32 = 2
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 3),
.data.int32 = 3
}
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26)
},
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26)
}
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 25), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 25), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 2);
varbind[0].name.subid[varbind[0].name.n_subid - 1]++;
varbind[1].name.subid[varbind[1].name.n_subid - 1]++;
varbind[0].type = varbind[1].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange,
varbind, 2);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 3);
varbind[0].type = varbind[1].type = TYPE_NULL;
varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 0),
varbind[1].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 25, 1),
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 2,
varbind, 2);
}
void
backend_getnext_response_equal_end(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 26),
.data.int32 = 1
},
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 26),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 26, 1, 1)
},
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 26, 1),
"backend_getnext_end_equal.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 26, 2),
"backend_getnext_end_equal.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 26), 0);
agentx_register(ax_s, sessionid2, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 26, 1, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1);
varbind[0].name.subid[varbind[0].name.n_subid++] = 1;
varbind[0].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange,
varbind, 1);
varbind[0].name = searchrange[0].end;
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
varbind[0].type = TYPE_NULL;
varbind[0].name = OID_STRUCT(MIB_BACKEND_GETNEXT, 26),
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
varbind, 1);
}
void
backend_getnext_instance_below_region_before_instance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 27),
.data.int32 = 1
},
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 27),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 27, 1, 0)
},
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 27, 1),
"backend_getnext_instance_below_region_before_instance.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 27, 2),
"backend_getnext_instance_below_region_before_instance.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 27), 0);
agentx_register(ax_s, sessionid2, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 27, 1, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
varbind[0].type = TYPE_ENDOFMIBVIEW;
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange,
varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
varbind[0].name = searchrange[0].end;
varbind[0].type = TYPE_INTEGER;
searchrange[0].start = searchrange[0].end;
searchrange[0].start.include = 1;
searchrange[0].end.subid[searchrange[0].end.n_subid - 1]++;
agentx_getnext_handle(__func__, buf, n, 0, sessionid2, searchrange,
varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 1);
}
void
backend_getnext_instance_below_region_on_instance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 28, 1, 0),
.data.int32 = 1
},
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 28, 1, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 29)
},
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 28, 1),
"backend_getnext_instance_below_region_on_instance.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 28, 2),
"backend_getnext_instance_below_region_on_instance.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 28), 0);
agentx_register(ax_s, sessionid2, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 28, 1, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1);
searchrange[0].start.include = 1;
varbind[0].name = searchrange[0].start;
varbind[0].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange,
varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 1);
}
void
backend_getnext_instance_below_region_below_instance(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid1, sessionid2;
struct varbind varbind[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETNEXT, 29, 1, 0, 1),
.data.int32 = 1
},
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(MIB_BACKEND_GETNEXT, 29, 1, 1),
.end = OID_STRUCT(MIB_BACKEND_GETNEXT, 30)
},
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid1 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 29, 1),
"backend_getnext_instance_below_region_below_instance.1");
sessionid2 = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETNEXT, 29, 2),
"backend_getnext_instance_below_region_below_instance.2");
agentx_register(ax_s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 29), 0);
agentx_register(ax_s, sessionid2, 1, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETNEXT, 29, 1, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, varbind, 1);
searchrange[0].start.include = 1;
varbind[0].name = searchrange[0].start;
varbind[0].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid1, searchrange,
varbind, 1);
agentx_response(ax_s, buf, NOERROR, 0, varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
varbind, 1);
}
void
backend_getbulk_nonrep_zero_maxrep_one(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 1)
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 1, 0),
.data.int32 = 1
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 1), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 1, &request, 1);
memcpy(response, ax_request, sizeof(ax_request));
while (nvarbind > 0) {
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
nout = agentx_getbulk_handle(__func__, buf, n, 0,
sessionid, ax_request, nvarbind, ax_response);
agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout);
nvarbind -= nout;
}
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
response, nitems(response));
}
void
backend_getbulk_nonrep_zero_maxrep_two(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 2)
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 2, 1),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 2, 2),
.data.int32 = 2
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 2), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &request, 1);
memcpy(response, ax_request, sizeof(ax_request));
while (nvarbind > 0) {
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
nout = agentx_getbulk_handle(__func__, buf, n, 0,
sessionid, ax_request, nvarbind, ax_response);
agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout);
nvarbind -= nout;
}
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
response, nitems(response));
}
void
backend_getbulk_nonrep_one_maxrep_one(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 1)
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 2)
}
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 1, 0),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 3, 2, 0),
.data.int32 = 2
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 3), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 3), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 1, 1, request, 2);
memcpy(response, ax_request, sizeof(ax_request));
while (nvarbind > 0) {
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
nout = agentx_getbulk_handle(__func__, buf, n, 0,
sessionid, ax_request, nvarbind, ax_response);
agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout);
nvarbind -= nout;
}
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
response, nitems(response));
}
void
backend_getbulk_nonrep_one_maxrep_two(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 1)
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2)
}
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 1, 0),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2, 2),
.data.int32 = 2
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 4, 2, 3),
.data.int32 = 3
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 4), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 4), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 1, 2, request, 2);
memcpy(response, ax_request, sizeof(ax_request));
while (nvarbind > 0) {
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
nout = agentx_getbulk_handle(__func__, buf, n, 0,
sessionid, ax_request, nvarbind, ax_response);
agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout);
nvarbind -= nout;
}
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
response, nitems(response));
}
void
backend_getbulk_nonrep_two_maxrep_two(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 1)
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 2)
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3)
}
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 1, 0),
.data.int32 = 1
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 2, 0),
.data.int32 = 2
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3, 3),
.data.int32 = 3
},
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 5, 3, 4),
.data.int32 = 4
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 5), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 5), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 2, 2, request, 3);
memcpy(response, ax_request, sizeof(ax_request));
while (nvarbind > 0) {
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
nout = agentx_getbulk_handle(__func__, buf, n, 0,
sessionid, ax_request, nvarbind, ax_response);
agentx_response(ax_s, buf, NOERROR, 0, ax_response, nout);
nvarbind -= nout;
}
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
response, nitems(response));
}
void
backend_getbulk_nonrep_negative(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 6)
}, ax_request[] = {
{
.type = TYPE_INTEGER,
.name = OID_STRUCT(MIB_BACKEND_GETBULK, 6),
.data.int32 = 1
}
}, ax_response[nitems(ax_request)], response[nitems(ax_request)];
int32_t requestid;
char buf[1024];
size_t n, nvarbind = nitems(ax_request), nout;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 6), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_GETBULK, 6), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, -1, 1, &request, 1);
agentx_timeout(ax_s, 1000);
snmp_timeout(snmp_s, 1);
}
void
backend_getbulk_endofmibview(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(2, 0),
};
struct searchrange searchrange = {
.start = OID_STRUCT(2, 0),
.end = OID_STRUCT(2, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 7), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(2, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
varbind.type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOERROR, 0, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
&varbind, 1);
}
void
backend_getbulk_endofmibview_second_rep(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(2 ,0),
.data.int32 = 1
},
{
.type = TYPE_ENDOFMIBVIEW,
.name = OID_STRUCT(2, 0, 0),
}
};
struct searchrange searchrange = {
.start = OID_STRUCT(2, 0),
.end = OID_STRUCT(2, 1)
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 8), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(2, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, request, 1);
request[0].name.subid[request[0].name.n_subid++] = 0;
request[0].type = TYPE_INTEGER;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
request, 1);
agentx_response(ax_s, buf, NOERROR, 0, request, 1);
searchrange.start = request[0].name;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange,
&request[1], 1);
agentx_response(ax_s, buf, NOERROR, 0, &request[1], 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
request, 2);
}
void
backend_getbulk_endofmibview_two_varbinds(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind request[] = {
{
.type = TYPE_NULL,
.name = OID_STRUCT(2 ,0),
.data.int32 = 1
},
{
.type = TYPE_NULL,
.name = OID_STRUCT(2, 0, 0),
},
{
.type = TYPE_ENDOFMIBVIEW,
.name = OID_STRUCT(2, 0, 0),
},
{
.type = TYPE_ENDOFMIBVIEW,
.name = OID_STRUCT(2, 0, 0),
}
};
struct searchrange searchrange[] = {
{
.start = OID_STRUCT(2, 0),
.end = OID_STRUCT(2, 1)
},
{
.start = OID_STRUCT(2, 0, 0),
.end = OID_STRUCT(2, 1)
},
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_GETBULK, 9), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(2, 0), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, request, 2);
request[0].name.subid[request[0].name.n_subid++] = 0;
request[0].type = TYPE_INTEGER;
request[1].type = TYPE_ENDOFMIBVIEW;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, searchrange,
request, 2);
agentx_response(ax_s, buf, NOERROR, 0, request, 2);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, &searchrange[1],
&request[1], 1);
agentx_response(ax_s, buf, NOERROR, 0, &request[1], 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOERROR, 0,
request, 4);
}
void
backend_error_get_toobig(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 1, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 1), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 1), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, TOOBIG, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, TOOBIG, 1,
&varbind, 1);
}
void
backend_error_get_nosuchname(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 2, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 2), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 2), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, NOSUCHNAME, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOSUCHNAME, 1,
&varbind, 1);
}
void
backend_error_get_badvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 3, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 3), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 3), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, BADVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_readonly(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 4, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 4), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 4), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, READONLY, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_generr(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 5, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 5), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 5), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, GENERR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_noaccess(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 6, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 6), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 5), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, NOACCESS, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_wrongtype(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 7, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 7), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 7), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, WRONGTYPE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_wronglength(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 8, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 8), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 8), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, WRONGLENGTH, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_wrongencoding(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 9, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 9), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 9), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, WRONGENCODING, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_wrongvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 10, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 10), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 10), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_nocreation(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 11, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 11), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 11), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, NOCREATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_inconsistentvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 12, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 12), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 12), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INCONSISTENTVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_resourceunavailable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 13, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 13), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 13), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_commitfailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 14, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 14), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 14), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, COMMITFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_undofailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 15, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 15), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 15), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, UNDOFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_authorizationerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 16, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 16), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 16), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, AUTHORIZATIONERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, AUTHORIZATIONERROR, 1,
&varbind, 1);
}
void
backend_error_get_notwritable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 17, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 17), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 17), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, NOTWRITABLE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_inconsistentname(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 18, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 18), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 18), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INCONSISTENTNAME, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_openfailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 19, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 19), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 19), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, OPENFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_notopen(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 20, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 20), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 20), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, NOTOPEN, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_indexwrongtype(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 21, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 21), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 21), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INDEXWRONGTYPE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_indexalreadyallocated(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 22, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 22), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 22), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INDEXALREADYALLOCATED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_indexnonavailable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 23, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 23), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 23), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INDEXNONEAVAILABLE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_indexnotallocated(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 24, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 24), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 24), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, INDEXNOTALLOCATED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_unsupportedcontext(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 25, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 25), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 25), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, UNSUPPORTEDCONTEXT, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_duplicateregistration(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 26, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 26), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 26), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, DUPLICATEREGISTRATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_unknownregistration(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 27, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 27), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 27), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, UNKNOWNREGISTRATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_parseerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 28, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 28), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 28), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, PARSEERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_requestdenied(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 29, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 29), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 29), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, REQUESTDENIED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_processingerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 30, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 30), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 30), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, PROCESSINGERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_get_nonstandard(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 31, 0),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 31), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 31), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_get(snmp_s, community, 0, &varbind, 1);
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_get_handle(__func__, buf, n, 0, sessionid, &varbind, 1);
agentx_response(ax_s, buf, 0xFFFF, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_toobig(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 32),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 32), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 32), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, TOOBIG, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, TOOBIG, 1,
&varbind, 1);
}
void
backend_error_getnext_nosuchname(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 33),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 33), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 33), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOSUCHNAME, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, NOSUCHNAME, 1,
&varbind, 1);
}
void
backend_error_getnext_badvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 34),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 34), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 34), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, BADVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_readonly(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 35),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 35), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 35), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, READONLY, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_generr(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 36),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 36), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 36), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, GENERR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_noaccess(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 37),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 37), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 37), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOACCESS, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_wrongtype(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 38),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 38), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 38), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, WRONGTYPE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_wronglength(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 39),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 39), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 39), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, WRONGLENGTH, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_wrongencoding(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 40),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 40), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 40), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, WRONGENCODING, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_wrongvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 41),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 41), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 41), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, WRONGVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_nocreation(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 42),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 42), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 42), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOCREATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_inconsistentvalue(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 43),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 43), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 43), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INCONSISTENTVALUE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_resourceunavailable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 44),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 44), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 44), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, RESOURCEUNAVAILABLE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_commitfailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 45),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 45), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 45), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, COMMITFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_undofailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 46),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 46), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 46), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, UNDOFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_authorizationerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 47),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 47), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 47), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, AUTHORIZATIONERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_notwritable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 48),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 48), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 48), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOTWRITABLE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_inconsistentname(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 49),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 49), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 49), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INCONSISTENTNAME, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_openfailed(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 50),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 50), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 50), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, OPENFAILED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_notopen(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 51),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 51), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 51), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, NOTOPEN, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_indexwrongtype(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 52),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 52), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 52), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INDEXWRONGTYPE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_indexalreadyallocated(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 53),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 53), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 53), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INDEXALREADYALLOCATED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_indexnonavailable(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 54),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 54), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 54), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INDEXNONEAVAILABLE, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_indexnotallocated(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 55),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 55), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 55), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, INDEXNOTALLOCATED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_unsupportedcontext(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 56),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 56), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 56), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, UNSUPPORTEDCONTEXT, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_duplicateregistration(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 57),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 57), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 57), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, DUPLICATEREGISTRATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_unknownregistration(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 58),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 58), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 58), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, UNKNOWNREGISTRATION, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_parseerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 59),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 59), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 59), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, PARSEERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_requestdenied(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 60),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 60), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 60), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, REQUESTDENIED, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_processingerror(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 61),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 61), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 61), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, PROCESSINGERROR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getnext_nonstandard(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 62),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 62), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 62), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getnext(snmp_s, community, 0, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, 0xFFFF, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getbulk_firstrepetition(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 63),
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 63), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 63), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.n_subid--;
agentx_response(ax_s, buf, GENERR, 1, &varbind, 1);
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
void
backend_error_getbulk_secondrepetition(void)
{
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_BACKEND_ERROR, 64),
.data.int32 = 1
};
int32_t requestid;
char buf[1024];
size_t n;
ax_s = agentx_connect(axsocket);
sessionid = agentx_open(ax_s, 0, 0,
OID_ARG(MIB_SUBAGENT_BACKEND_ERROR, 64), __func__);
agentx_register(ax_s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_BACKEND_ERROR, 64), 0);
salen = snmp_resolve(SOCK_DGRAM, hostname, servname, sa);
snmp_s = snmp_connect(SOCK_DGRAM, sa, salen);
requestid = snmpv2_getbulk(snmp_s, community, 0, 0, 2, &varbind, 1);
varbind.name.subid[varbind.name.n_subid++] = 0;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.type = TYPE_INTEGER;
agentx_response(ax_s, buf, 0, NOERROR, &varbind, 1);
varbind.name.subid[varbind.name.n_subid - 1] = 1;
n = agentx_read(ax_s, buf, sizeof(buf), 1000);
agentx_getnext_handle(__func__, buf, n, 0, sessionid, NULL, &varbind, 1);
varbind.name.subid[varbind.name.n_subid - 1] = 0;
varbind.type = TYPE_NULL;
agentx_response(ax_s, buf, 0, GENERR, &varbind, 1);
varbind.name.n_subid--;
snmpv2_response_validate(snmp_s, 1000, community, requestid, GENERR, 1,
&varbind, 1);
}
