#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <endian.h>
#include <err.h>
#include <poll.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "regress.h"
#define AGENTX_SOCKET "/tmp/agentx"
#define SUBAGENT_DESCR(name) name, strlen(name)
#define AGENTX_OPEN_PDU 1
#define AGENTX_CLOSE_PDU 2
#define AGENTX_REGISTER_PDU 3
#define AGENTX_UNREGISTER_PDU 4
#define AGENTX_GET_PDU 5
#define AGENTX_GETNEXT_PDU 6
#define AGENTX_GETBULK_PDU 7
#define AGENTX_TESTSET_PDU 8
#define AGENTX_COMMITSET_PDU 9
#define AGENTX_UNDOSET_PDU 10
#define AGENTX_CLEANUPSET_PDU 11
#define AGENTX_NOTIFY_PDU 12
#define AGENTX_PING_PDU 13
#define AGENTX_INDEXALLOCATE_PDU 14
#define AGENTX_INDEXDEALLOCATE_PDU 15
#define AGENTX_ADDAGENTCAPS_PDU 16
#define AGENTX_REMOVEAGENTCAPS_PDU 17
#define AGENTX_RESPONSE_PDU 18
#define NOAGENTXERROR 0
#define OPENFAILED 256
#define NOTOPEN 257
#define INDEXWRONGTYPE 258
#define INDEXALREADYALLOCATED 259
#define INDEXNONEAVAILABLE 260
#define INDEXNOTALLOCATED 261
#define UNSUPPORTEDCONTEXT 262
#define DUPLICATEREGISTRATION 263
#define UNKNOWNREGISTRATION 264
#define UNKNOWNAGENTCAPS 265
#define PARSEERROR 266
#define REQUESTDENIED 267
#define PROCESSINGERROR 268
#define INSTANCE_REGISTRATION (1 << 0)
#define NEW_INDEX (1 << 1)
#define ANY_INDEX (1 << 2)
#define NON_DEFAULT_CONTEXT (1 << 3)
#define NETWORK_BYTE_ORDER (1 << 4)
#define INTEGER 2
#define OCTETSTRING 4
#define AXNULL 5
#define OBJECTIDENTIFIER 6
#define IPADDRESS 64
#define COUNTER32 65
#define GAUGE32 66
#define TIMETICKS 67
#define OPAQUE 68
#define COUNTER64 70
#define NOSUCHOBJECT 128
#define NOSUCHINSTANCE 129
#define ENDOFMIBVIEW 130
#define MESSAGE_NBO(msg) (((const char *)msg->buf)[2] & NETWORK_BYTE_ORDER)
#define p16toh(header, value) (uint16_t)(header->flags & NETWORK_BYTE_ORDER ? \
be16toh(value) : le16toh(value))
#define p32toh(header, value) (uint32_t)(header->flags & NETWORK_BYTE_ORDER ? \
be32toh(value) : le32toh(value))
#define p64toh(header, value) (uint64_t)(header->flags & NETWORK_BYTE_ORDER ? \
be64toh(value) : le64toh(value))
struct header {
uint8_t version;
uint8_t type;
uint8_t flags;
uint8_t reserved;
uint32_t sessionid;
uint32_t transactionid;
uint32_t packetid;
uint32_t payload_length;
} __attribute__ ((packed));
struct message {
void *buf;
size_t len;
size_t size;
};
void agentx_close_validate(const char *, const void *,
size_t, uint8_t, uint8_t);
static void agentx_response_validate(const char *, const void *, size_t,
uint8_t, uint32_t, enum error, uint16_t, struct varbind *, size_t);
static void message_add_uint8(struct message *, uint8_t);
static void message_add_uint16(struct message *, uint16_t);
static void message_add_uint32(struct message *, uint32_t);
static void message_add_uint64(struct message *, uint64_t);
static void message_add_nstring(struct message *, const void *, uint32_t);
static void message_add_oid(struct message *, const uint32_t[], uint8_t,
uint8_t);
static void message_add_varbind(struct message *, struct varbind *);
static void message_add_header(struct message *, uint8_t, uint8_t, uint8_t,
uint32_t, uint32_t, uint32_t);
static void message_add(struct message *, const void *, size_t);
static void message_release(struct message *);
static size_t poid(const char *, const struct header *, const uint8_t *, size_t,
struct oid *);
void agentx_write(int, struct message *);
void
agentx_open_nnbo(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 1), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_nbo(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, NETWORK_BYTE_ORDER, 0, 0,
packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 2), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, NETWORK_BYTE_ORDER,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_invalidversion(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 0xFF, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 3), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
if (agentx_read(s, repl, sizeof(repl), 1000) != 0)
errx(1, "%s: Unexpected reply", __func__);
close(s);
}
void
agentx_open_ignore_sessionid(void)
{
int s1, s2;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
struct header *header = (struct header *)repl;
s1 = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 4, 1), 0);
message_add_nstring(&msg,
SUBAGENT_DESCR("agentx_open_ignore_sessionid.1"));
agentx_write(s1, &msg);
n = agentx_read(s1, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
sessionid = le32toh(header->sessionid);
s2 = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, sessionid, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 4, 2), 0);
message_add_nstring(&msg,
SUBAGENT_DESCR("agentx_open_ignore_sessionid.2"));
agentx_write(s2, &msg);
n = agentx_read(s2, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
if (sessionid == le32toh(header->sessionid))
errx(1, "%s: sessionid not ignored", __func__);
message_release(&msg);
close(s1);
close(s2);
}
void
agentx_open_invalid_oid(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t oid[129];
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, oid, 129, 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
if ((n = agentx_read(s, repl, sizeof(repl), 1000)) != 0)
errx(1, "unexpected reply");
message_release(&msg);
close(s);
}
void
agentx_open_descr_too_long(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
char descr[256];
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 6), 0);
memset(descr, 'a', sizeof(descr));
message_add_nstring(&msg, descr, sizeof(descr));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_descr_invalid(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, 0, 0, 0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 7), 0);
message_add_nstring(&msg, SUBAGENT_DESCR("a\373a"));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_context(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, NON_DEFAULT_CONTEXT, 0, 0,
packetid);
message_add_nstring(&msg, "ctx", 3);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 8), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_instance_registration(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, INSTANCE_REGISTRATION, 0,
0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 9), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_new_index(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, NEW_INDEX, 0,
0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 10), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_open_any_index(void)
{
int s;
struct message msg = {};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_OPEN_PDU, ANY_INDEX, 0,
0, packetid);
message_add_uint8(&msg, 0);
message_add(&msg, zero, 3);
message_add_oid(&msg, OID_ARG(MIB_SUBAGENT_OPEN, 11), 0);
message_add_nstring(&msg, SUBAGENT_DESCR(__func__));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_notopen(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_PING_PDU, 0, 0, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_invalid_sessionid(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 2), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, 0,
sessionid + 1, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_default(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 3), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, 0,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_context(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 4), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, NON_DEFAULT_CONTEXT,
sessionid, 0, packetid);
message_add_nstring(&msg, "ctx", 3);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, UNSUPPORTEDCONTEXT, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_invalid_version(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 5), __func__);
message_add_header(&msg, 0xFF, AGENTX_PING_PDU, INSTANCE_REGISTRATION,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_close_validate(__func__, repl, n, 0, REASONPROTOCOLERROR);
message_release(&msg);
close(s);
}
void
agentx_ping_instance_registration(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 6), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, INSTANCE_REGISTRATION,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_new_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 7), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, NEW_INDEX,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_any_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 8), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, ANY_INDEX,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_nbo_nnbo(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 9), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, 0,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_nnbo_nbo(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_PING, 9), __func__);
message_add_header(&msg, 1, AGENTX_PING_PDU, NETWORK_BYTE_ORDER,
sessionid, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, NETWORK_BYTE_ORDER,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_ping_invalid_version_close(void)
{
struct sockaddr_storage ss;
struct message msg = {};
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t salen;
int snmp_s, ax_s;
uint32_t sessionid, packetid;
struct varbind varbind = {
.type = TYPE_NULL,
.name = OID_STRUCT(MIB_SUBAGENT_PING, 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_PING, 10), __func__);
message_add_header(&msg, 0xFF, AGENTX_PING_PDU, INSTANCE_REGISTRATION,
sessionid, 0, packetid);
agentx_write(ax_s, &msg);
close(ax_s);
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_NOSUCHOBJECT;
snmpv2_response_validate(snmp_s, 1000, community, requestid, 0, 0,
&varbind, 1);
}
void
agentx_close_notopen(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, 0, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasonother(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 2), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasonparseerror(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONPARSEERROR, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 3), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasonprotocolerror(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONPROTOCOLERROR, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 4), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasontimouts(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONTIMEOUTS, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 5), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasonshutdown(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONSHUTDOWN, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 6), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasonbymanager(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONBYMANAGER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 7), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR,
0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_reasoninvalid(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = 0xFF, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 8), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_close_validate(__func__, repl, n, 0, REASONPROTOCOLERROR);
message_release(&msg);
close(s);
}
void
agentx_close_single(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid1, sessionid2;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid1 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 9, 1), "agentx_close_single.1");
sessionid2 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 9, 2), "agentx_close_single.2");
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid1, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR,
0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_PING_PDU, 0, sessionid2, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_PING_PDU, 0, sessionid1, 0, packetid);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOTOPEN, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_notowned(void)
{
int s1, s2;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid1, sessionid2;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s1 = agentx_connect(axsocket);
s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(s1, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 10, 1), "agentx_close_notowned.1");
sessionid2 = agentx_open(s2, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 10, 2), "agentx_close_notowned.2");
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid1, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s2, &msg);
n = agentx_read(s2, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN,
0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_PING_PDU, 0, sessionid1, 0, packetid);
agentx_write(s1, &msg);
n = agentx_read(s1, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_PING_PDU, 0, sessionid2, 0, packetid);
agentx_write(s2, &msg);
n = agentx_read(s2, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s1);
close(s2);
}
void
agentx_close_invalid_sessionid(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 11), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid + 1, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_context(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 12), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, NON_DEFAULT_CONTEXT,
sessionid, 0, packetid);
message_add_nstring(&msg, "ctx", 3);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, PARSEERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_invalid_version(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 13), __func__);
message_add_header(&msg, 0xFF, AGENTX_CLOSE_PDU, 0, sessionid, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_close_validate(__func__, repl, n, 0, REASONPROTOCOLERROR);
message_release(&msg);
close(s);
}
void
agentx_close_instance_registration(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 14), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, INSTANCE_REGISTRATION,
sessionid, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_new_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 15), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, NEW_INDEX,
sessionid, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_any_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 16), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, ANY_INDEX,
sessionid, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0,
packetid, PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_close_nnbo_nbo(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
const uint8_t reason = REASONOTHER, zero[3] = {0};
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_CLOSE, 17), __func__);
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, NETWORK_BYTE_ORDER,
sessionid, 0, packetid);
message_add(&msg, &reason, sizeof(reason));
message_add(&msg, zero, sizeof(zero));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, NETWORK_BYTE_ORDER,
packetid, NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_notopen(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, 0, 0, packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 1, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_invalid_sessionid(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 2), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid + 1, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 2, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_default(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 3), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 3, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_context(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 4), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, NON_DEFAULT_CONTEXT,
sessionid, 0, packetid);
message_add_nstring(&msg, "ctx", 3);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 4, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNSUPPORTEDCONTEXT, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_invalid_version(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 5), __func__);
message_add_header(&msg, 0xFF, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 5, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_close_validate(__func__, repl, n, 0, REASONPROTOCOLERROR);
message_release(&msg);
close(s);
}
void
agentx_register_instance_registration(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 6), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, INSTANCE_REGISTRATION,
sessionid, 0, packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 6, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_new_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 7), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, NEW_INDEX,
sessionid, 0, packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 7, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_any_index(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 8), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, NEW_INDEX,
sessionid, 0, packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 8, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_duplicate_self(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 9), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 9, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 9, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
DUPLICATEREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_duplicate_twocon(void)
{
int s1, s2;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid1, sessionid2;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s1 = agentx_connect(axsocket);
s2 = agentx_connect(axsocket);
sessionid1 = agentx_open(s1, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 10, 1),
"agentx_register_duplicate_twocon.1");
sessionid2 = agentx_open(s2, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 10, 2),
"agentx_register_duplicate_twocon.2");
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid1, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 10, 0), 0);
agentx_write(s1, &msg);
n = agentx_read(s1, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid2, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 10, 0), 0);
agentx_write(s2, &msg);
n = agentx_read(s2, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
DUPLICATEREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s1);
close(s2);
}
void
agentx_register_duplicate_priority(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 11), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 11, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
priority = 1;
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 11, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_range(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 10;
uint8_t timeout = 0, priority = 127, range_subid = 11, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 12), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 12, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_range_invalidupperbound(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 1;
uint8_t timeout = 0, priority = 127, range_subid = 11, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 13), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 13, 2), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
PARSEERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_range_single(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 1;
uint8_t timeout = 0, priority = 127, range_subid = 11, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 14), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 14, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_range_overlap_single(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 10;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 15), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 15, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
range_subid = 11;
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 15, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
DUPLICATEREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_single_overlap_range(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 10;
uint8_t timeout = 0, priority = 127, range_subid = 11, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 16), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 16, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
range_subid = 0;
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 16, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
DUPLICATEREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_range_overlap_range(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid, upperbound = 10;
uint8_t timeout = 0, priority = 127, range_subid = 11, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 17), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 17, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
upperbound = 15;
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 17, 6), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
DUPLICATEREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_below(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 18), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 18, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 18, 1, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_above(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 19), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 19, 1, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
packetid = arc4random();
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_REGISTER, 19, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_register_restricted(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t timeout = 0, priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_REGISTER, 20), __func__);
message_add_header(&msg, 1, AGENTX_REGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(SYSORTABLE, 1, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
REQUESTDENIED, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_notopen(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, 0, 0, packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 1, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_invalid_sessionid(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 2), __func__);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid + 1, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 2, 0), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOTOPEN, 0,
NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_notregistered(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 3), __func__);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 3), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_single(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 4), __func__);
agentx_register(s, sessionid, 0, 0, 127, 0,
OID_ARG(MIB_UNREGISTER, 4), 0);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 4), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_single_notowned(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid1, sessionid2;
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid1 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 5, 1),
"agentx_unregister_single_notowned.1");
sessionid2 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 5, 2),
"agentx_unregister_single_notowned.2");
agentx_register(s, sessionid1, 0, 0, 127, 0,
OID_ARG(MIB_UNREGISTER, 5, 1), 0);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid2, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 5, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 11, reserved = 0;
uint32_t upperbound = 10;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 6), __func__);
agentx_register(s, sessionid, 0, 0, 127, 11,
OID_ARG(MIB_UNREGISTER, 6, 1), 10);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 6, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
NOAGENTXERROR, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range_single(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 0, reserved = 0;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 7), __func__);
agentx_register(s, sessionid, 0, 0, 127, 11,
OID_ARG(MIB_UNREGISTER, 6, 1), 10);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 7, 1), 0);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range_subset(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 11, reserved = 0;
uint32_t upperbound = 5;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 8), __func__);
agentx_register(s, sessionid, 0, 0, 127, 11,
OID_ARG(MIB_UNREGISTER, 8, 1), 10);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 8, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range_extra(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 11, reserved = 0;
uint32_t upperbound = 10;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 9), __func__);
agentx_register(s, sessionid, 0, 0, 127, 11,
OID_ARG(MIB_UNREGISTER, 9, 1), upperbound);
upperbound = 15;
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 9, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range_priority(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid;
uint8_t priority = 127, range_subid = 11, reserved = 0;
uint32_t upperbound = 10;
s = agentx_connect(axsocket);
sessionid = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 10), __func__);
agentx_register(s, sessionid, 0, 0, priority, 11,
OID_ARG(MIB_UNREGISTER, 10, 1), upperbound);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid, 0,
packetid);
priority = 128;
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 10, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_unregister_range_notowned(void)
{
int s;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint32_t sessionid1, sessionid2;
uint8_t priority = 127, range_subid = 11, reserved = 0;
uint32_t upperbound = 10;
s = agentx_connect(axsocket);
sessionid1 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 11, 1),
"agentx_unregister_range_notowned.1");
sessionid2 = agentx_open(s, 0, 0,
OID_ARG(MIB_SUBAGENT_UNREGISTER, 11, 2),
"agentx_unregister_range_notowned.2");
agentx_register(s, sessionid1, 0, 0, priority, 11,
OID_ARG(MIB_UNREGISTER, 11, 1), upperbound);
message_add_header(&msg, 1, AGENTX_UNREGISTER_PDU, 0, sessionid2, 0,
packetid);
priority = 128;
message_add(&msg, &reserved, sizeof(reserved));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, OID_ARG(MIB_UNREGISTER, 10, 1), 0);
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid,
UNKNOWNREGISTRATION, 0, NULL, 0);
message_release(&msg);
close(s);
}
void
agentx_get_handle(const char *test, const void *buf, size_t len,
uint8_t flags, uint32_t sessionid, struct varbind *varbind,
size_t nvarbind)
{
const struct header *header = buf;
struct oid start, end, zero = {0};
const uint8_t *u8;
uint32_t u32;
uint16_t u16;
size_t sublen, i, j;
char oid1[512], oid2[512];
struct varbind *pool;
if (len < sizeof(*header))
errx(1, "%s: unexpected pdu message size received: %zu", test, len);
if (header->version != 1)
errx(1, "%s: invalid pdu version", test);
if (header->type != AGENTX_GET_PDU)
errx(1, "%s: invalid pdu type received (%hhu/5)", test, header->type);
if (header->flags != flags)
errx(1, "%s: invalid get pdu flags received (%hhu/%hhu)",
test, header->flags, flags);
if (header->reserved != 0)
errx(1, "%s: invalid get pdu reserved received", test);
if (p32toh(header, header->sessionid) != sessionid)
errx(1, "%s: unexpected get pdu sessionid (%u/%u)", test,
p32toh(header, header->sessionid), sessionid);
if (p32toh(header, header->payload_length) > len - sizeof(*header))
errx(1, "%s: unexpected get pdu payload length received",
test);
buf += sizeof(*header);
len = p32toh(header, header->payload_length);
if ((pool = calloc(nvarbind, sizeof(*pool))) == NULL)
err(1, NULL);
memcpy(pool, varbind, nvarbind * sizeof(*pool));
for (i = 0; len > 0; i++) {
sublen = poid(test, header, buf, len, &start);
buf += sublen;
len -= sublen;
sublen = poid(test, header, buf, len, &end);
buf += sublen;
len -= sublen;
if (oid_cmp(&end, &zero) != 0)
errx(1, "%s: unexpected searchrange end: (%s/%s)", test,
oid_print(&end, oid1, sizeof(oid1)),
oid_print(&zero, oid2, sizeof(oid2)));
if (start.include != 0 || end.include != 0)
errx(1, "%s: unexpected searchrange include: (%s)",
test, oid_print(&start, oid1, sizeof(oid1)));
for (j = 0; j < nvarbind; j++) {
if (oid_cmp(&pool[j].name, &start) == 0)
break;
}
if (j == nvarbind)
warnx("%s: unexpected searchrange start: " "(%s)", test,
oid_print(&start, oid1, sizeof(oid1)));
varbind[i] = pool[j];
pool[j].name.n_subid = 0;
}
free(pool);
}
void
agentx_getnext_handle(const char *test, const void *buf, size_t len,
uint8_t flags, uint32_t sessionid, struct searchrange *searchrange,
struct varbind *varbind, size_t nvarbind)
{
const struct header *header = buf;
struct oid start, end, zero = {0};
const uint8_t *u8;
uint32_t u32;
uint16_t u16;
size_t sublen, i, j, match;
char oid1[512], oid2[512], oid3[512], oid4[512];
struct varbind *pool;
if (len < sizeof(*header))
errx(1, "%s: unexpected pdu message size received: %zu", test, len);
if (header->version != 1)
errx(1, "%s: invalid pdu version", test);
if (header->type != AGENTX_GETNEXT_PDU)
errx(1, "%s: invalid pdu type received (%hhu/6)", test, header->type);
if (header->flags != flags)
errx(1, "%s: invalid get pdu flags received (%hhu/%hhu)",
test, header->flags, flags);
if (header->reserved != 0)
errx(1, "%s: invalid get pdu reserved received", test);
if (p32toh(header, header->sessionid) != sessionid)
errx(1, "%s: unexpected get pdu sessionid (%u/%u)", test,
p32toh(header, header->sessionid), sessionid);
if (p32toh(header, header->payload_length) > len - sizeof(*header))
errx(1, "%s: unexpected get pdu payload length received",
test);
buf += sizeof(*header);
len = p32toh(header, header->payload_length);
if ((pool = calloc(nvarbind, sizeof(*pool))) == NULL)
err(1, NULL);
memcpy(pool, varbind, nvarbind * sizeof(*pool));
for (i = 0; len > 0; i++) {
sublen = poid(test, header, buf, len, &start);
buf += sublen;
len -= sublen;
sublen = poid(test, header, buf, len, &end);
buf += sublen;
len -= sublen;
if ((start.include != 1 && start.include != 0) ||
end.include != 0)
errx(1, "%s: unexpected searchrange include: (%s-%s)",
test, oid_print(&start, oid1, sizeof(oid1)),
oid_print(&end, oid2, sizeof(oid2)));
match = (size_t)-1;
for (j = 0; j < nvarbind; j++) {
if (oid_cmp(&pool[j].name, &start) == 0 &&
pool[j].type == TYPE_ENDOFMIBVIEW) {
match = j;
} else if (oid_cmp(&pool[j].name, &start) < 0 ||
(!start.include &&
oid_cmp(&pool[j].name, &start) == 0) ||
oid_cmp(&pool[j].name, &end) >= 0)
continue;
if (match == (size_t)-1)
match = j;
else {
if (oid_cmp(&pool[j].name,
&pool[match].name) < 0)
match = j;
}
}
if (match == (size_t)-1)
errx(1, "%s: unexpected searchrange start: " "(%s-%s)",
test,
oid_print(&start, oid1, sizeof(oid1)),
oid_print(&end, oid2, sizeof(oid2)));
if (searchrange != NULL) {
if (oid_cmp(&searchrange[match].start, &start) != 0 ||
oid_cmp(&searchrange[match].end, &end) != 0 ||
searchrange[match].end.include != end.include ||
searchrange[match].start.include != start.include)
errx(1, "%s: searchrange did not match "
"(%s-%s/%s-%s)", test,
oid_print(&start, oid1, sizeof(oid1)),
oid_print(&end, oid2, sizeof(oid2)),
oid_print(&searchrange[match].start, oid3,
sizeof(oid3)),
oid_print(&searchrange[match].end, oid4,
sizeof(oid4)));
}
varbind[i] = pool[match];
pool[match].name.n_subid = 0;
}
free(pool);
}
size_t
agentx_getbulk_handle(const char *test, const void *buf, size_t len,
uint8_t flags, int32_t sessionid, struct varbind *varbind, size_t nvarbind,
struct varbind *outvarbind)
{
const struct header *header = buf;
struct oid start, end, zero = {0};
const uint8_t *u8;
uint16_t nonrep, maxrep;
uint32_t u32;
uint16_t u16;
size_t sublen, i, j, match;
size_t nout = 0;
char oid1[512], oid2[512], oid3[512], oid4[512];
if (len < sizeof(*header))
errx(1, "%s: unexpected pdu message size received: %zu", test, len);
if (header->version != 1)
errx(1, "%s: invalid pdu version", test);
if (header->type != AGENTX_GETNEXT_PDU &&
header->type != AGENTX_GETBULK_PDU)
errx(1, "%s: invalid pdu type received (%hhu/[67])",
test, header->type);
if (header->flags != flags)
errx(1, "%s: invalid get pdu flags received (%hhu/%hhu)",
test, header->flags, flags);
if (header->reserved != 0)
errx(1, "%s: invalid get pdu reserved received", test);
if (p32toh(header, header->sessionid) != sessionid)
errx(1, "%s: unexpected get pdu sessionid (%u/%u)", test,
p32toh(header, header->sessionid), sessionid);
if (p32toh(header, header->payload_length) > len - sizeof(*header))
errx(1, "%s: unexpected get pdu payload length received",
test);
buf += sizeof(*header);
len = p32toh(header, header->payload_length);
if (header->type == AGENTX_GETBULK_PDU) {
if (len < 4)
errx(1, "%s: missing non_repeaters/max_repititions",
__func__);
memcpy(&u16, buf, sizeof(u16));
nonrep = p16toh(header, u16);
memcpy(&u16, buf + sizeof(u16), sizeof(u16));
maxrep = p16toh(header, u16);
buf += 4;
} else {
nonrep = 0;
maxrep = 1;
}
for (i = 0; len > 0; i++) {
sublen = poid(test, header, buf, len, &start);
buf += sublen;
len -= sublen;
sublen = poid(test, header, buf, len, &end);
buf += sublen;
len -= sublen;
if ((start.include != 1 && start.include != 0) ||
end.include != 0)
errx(1, "%s: unexpected searchrange include: (%s-%s)",
test, oid_print(&start, oid1, sizeof(oid1)),
oid_print(&end, oid2, sizeof(oid2)));
match = (size_t)-1;
for (j = 0; j < nvarbind; j++) {
if (oid_cmp(&varbind[j].name, &start) == 0 &&
varbind[j].type == TYPE_ENDOFMIBVIEW) {
match = j;
} else if (oid_cmp(&varbind[j].name, &start) < 0 ||
(!start.include &&
oid_cmp(&varbind[j].name, &start) == 0) ||
oid_cmp(&varbind[j].name, &end) >= 0)
continue;
if (match == (size_t)-1)
match = j;
else {
if (oid_cmp(&varbind[j].name,
&varbind[match].name) < 0)
match = j;
}
}
if (match == (size_t)-1)
errx(1, "%s: unexpected searchrange start: " "(%s-%s)",
test,
oid_print(&start, oid1, sizeof(oid1)),
oid_print(&end, oid2, sizeof(oid2)));
outvarbind[nout++] = varbind[match];
varbind[match] = varbind[--nvarbind];
varbind[nvarbind] = (struct varbind){};
}
return nout;
}
void
agentx_close_validate(const char *test, const void *buf, size_t len,
uint8_t flags, uint8_t reason)
{
const struct header *header = buf;
const uint8_t *u8;
uint32_t u32;
uint16_t u16;
if (len != sizeof(*header) + 4)
errx(1, "%s: unexpected pdu message size received: %zu", test, len);
if (header->version != 1)
errx(1, "%s: invalid pdu version", test);
if (header->type != AGENTX_CLOSE_PDU)
errx(1, "%s: invalid pdu type received (%hhu/2)", test, header->type);
if (header->flags != flags)
errx(1, "%s: invalid close pdu flags received (%hhu/%hhu)",
test, header->flags, flags);
if (header->reserved != 0)
errx(1, "%s: invalid close pdu reserved received", test);
if (p32toh(header, header->payload_length) != 4)
errx(1, "%s: unexpected response pdu payload length received",
test);
u8 = buf + sizeof(*header);
if (u8[0] != reason)
errx(1, "%s: unexpected close reason (%hhu/%hhu)",
test, u8[0], reason);
if (u8[1] != 0 || u8[2] != 0 || u8[3] != 0)
errx(1, "%s: invalid close pdu reserved received", test);
}
void
agentx_response_validate(const char *test, const void *buf, size_t len,
uint8_t flags, uint32_t packetid, enum error error, uint16_t index,
struct varbind *varbindlist, size_t nvarbind)
{
const struct header *header = buf;
struct oid name, oid;
int32_t i32;
uint32_t u32;
uint16_t u16, type;
size_t i, sublen;
if (len < sizeof(*header) + 8)
errx(1, "%s: unexpected pdu message size received: %zu", test, len);
if (header->version != 1)
errx(1, "%s: invalid pdu version", test);
if (header->type != AGENTX_RESPONSE_PDU)
errx(1, "%s: invalid pdu type received (%hhu/18)", test, header->type);
if (header->flags != flags)
errx(1, "%s: invalid response pdu flags received (%hhu/%hhu)",
test, header->flags, flags);
if (header->reserved != 0)
errx(1, "%s: invalid response pdu reserved received", test);
if (p32toh(header, header->packetid) != packetid)
errx(1, "%s: invalid response pdu packetid received", test);
if (p32toh(header, header->payload_length) < 8 ||
p32toh(header, header->payload_length) > len - sizeof(*header))
errx(1, "%s: unexpected response pdu payload length received",
test);
buf += sizeof(*header);
len = p32toh(header, header->payload_length);
memcpy(&u32, buf, sizeof(u32));
if ((p32toh(header, u32) & 0xF0000000) != 0)
errx(1, "%s: unexpected response pdu sysUptime received",
test);
buf += sizeof(u32);
memcpy(&u16, buf, sizeof(u16));
if (p16toh(header, u16) != error)
errx(1, "%s: unexpected response pdu error (%hu/%u)",
test, p16toh(header, u16), error);
buf += sizeof(u16);
memcpy(&u16, buf, sizeof(u16));
if (p16toh(header, u16) != index)
errx(1, "%s: unexpected response pdu index (%hu/%hu)",
test, p16toh(header, u16), index);
buf += sizeof(u16);
len -= 8;
for (i = 0; len > 0; i++) {
if (len < 4)
errx(1,
"%s: invalid response pdu varbind length", test);
memcpy(&type, buf, sizeof(type));
type = p16toh(header, type);
if (i < nvarbind && type != varbindlist[i].type % 1000)
errx(1, "%s: invalid response pdu varbind type", test);
buf += sizeof(type);
len -= sizeof(type);
memcpy(&u16, buf, sizeof(u16));
if (u16 != 0)
errx(1, "%s: invalid response pdu varbind reserved",
test);
buf += sizeof(u16);
len -= sizeof(u16);
sublen = poid(test, header, buf, len, &name);
if (i < nvarbind && oid_cmp(&varbindlist[i].name, &name) != 0)
errx(1, "%s: invalid response pdu varbind name", test);
buf += sublen;
len -= sublen;
switch (type % 1000) {
case TYPE_INTEGER:
if (len < sizeof(i32))
errx(1,
"%s: invalid response pdu varbind length",
test);
if (i < nvarbind && varbindlist[i].type / 1000 == 0) {
memcpy(&i32, buf, sizeof(i32));
i32 = p32toh(header, i32);
if (i32 != varbindlist[i].data.int32)
errx(1, "%s: invalid response pdu "
"varbind integer", test);
}
break;
default:
errx(1, "%s: Regress test not implemented: %d", test, type);
}
}
if (i != nvarbind)
errx(1, "%s: unexpected response pdu nvarbind: (%zu/%zu)",
test, i, nvarbind);
}
int
agentx_connect(const char *path)
{
struct sockaddr_un sun;
int s;
if (path == NULL)
path = AGENTX_SOCKET;
sun.sun_len = sizeof(sun);
sun.sun_family = AF_UNIX;
strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
err(1, "%s: socket", __func__);
if (connect(s, (struct sockaddr *)&sun, sizeof(sun)) == -1)
err(1, "%s: connect", __func__);
return s;
}
uint32_t
agentx_open(int s, int nbo, uint8_t timeout, uint32_t oid[], size_t oidlen,
const char *descr)
{
struct message msg ={};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
struct header *header = (struct header *)repl;
message_add_header(&msg, 1, AGENTX_OPEN_PDU,
nbo ? NETWORK_BYTE_ORDER : 0, 0, 0, packetid);
message_add_uint8(&msg, timeout);
message_add(&msg, zero, 3);
message_add_oid(&msg, oid, oidlen, 0);
message_add_nstring(&msg, descr, strlen(descr));
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n,
nbo ? NETWORK_BYTE_ORDER : 0, packetid, 0, 0, NULL, 0);
message_release(&msg);
return p32toh(header, header->sessionid);
}
void
agentx_close(int s, uint32_t sessionid, enum close_reason reason)
{
struct message msg ={};
char zero[3] = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
struct header *header = (struct header *)repl;
message_add_header(&msg, 1, AGENTX_CLOSE_PDU, 0, sessionid, 0,
packetid);
message_add_uint8(&msg, reason);
message_add(&msg, zero, 3);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, 0, 0, NULL, 0);
message_release(&msg);
}
void
agentx_register(int s, uint32_t sessionid, uint8_t instance, uint8_t timeout,
uint8_t priority, uint8_t range_subid, uint32_t oid[], size_t oidlen,
uint32_t upperbound)
{
struct message msg = {};
char repl[1024];
size_t n;
uint32_t packetid = arc4random();
uint8_t reserved = 0;
message_add_header(&msg, 1, AGENTX_REGISTER_PDU,
instance ? INSTANCE_REGISTRATION : 0, sessionid, 0, packetid);
message_add(&msg, &timeout, sizeof(timeout));
message_add(&msg, &priority, sizeof(priority));
message_add(&msg, &range_subid, sizeof(range_subid));
message_add(&msg, &reserved, sizeof(reserved));
message_add_oid(&msg, oid, oidlen, 0);
if (range_subid != 0)
message_add_uint32(&msg, upperbound);
agentx_write(s, &msg);
n = agentx_read(s, repl, sizeof(repl), 1000);
agentx_response_validate(__func__, repl, n, 0, packetid, NOAGENTXERROR, 0,
NULL, 0);
message_release(&msg);
}
void
agentx_response(int s, void *buf, enum error error, uint16_t index,
struct varbind *varbindlist, size_t nvarbind)
{
struct header *header = buf;
struct message msg = {};
char repl[1024];
size_t n;
uint32_t sysuptime = 0;
uint16_t reserved = 0;
size_t i;
message_add_header(&msg, 1, AGENTX_RESPONSE_PDU, 0,
p32toh(header, header->sessionid),
p32toh(header, header->transactionid),
p32toh(header, header->packetid));
message_add_uint32(&msg, sysuptime);
message_add_uint16(&msg, error);
message_add_uint16(&msg, index);
for (i = 0; i < nvarbind; i++)
message_add_varbind(&msg, varbindlist + i);
agentx_write(s, &msg);
message_release(&msg);
}
static void
message_add_uint8(struct message *msg, uint8_t n)
{
message_add(msg, &n, 1);
}
static void
message_add_uint16(struct message *msg, uint16_t n)
{
if (MESSAGE_NBO(msg))
n = htobe16(n);
else
n = htole16(n);
message_add(msg, &n, sizeof(n));
}
static void
message_add_uint32(struct message *msg, uint32_t n)
{
if (MESSAGE_NBO(msg))
n = htobe32(n);
else
n = htole32(n);
message_add(msg, &n, sizeof(n));
}
static void
message_add_uint64(struct message *msg, uint64_t n)
{
if (MESSAGE_NBO(msg))
n = htobe64(n);
else
n = htole64(n);
message_add(msg, &n, sizeof(n));
}
static void
message_add_nstring(struct message *msg, const void *src, uint32_t len)
{
char zero[3] = {};
message_add_uint32(msg, len);
if (len == 0)
return;
message_add(msg, src, len);
message_add(msg, zero, (4 - (len % 4)) % 4);
}
static void
message_add_oid(struct message *msg, const uint32_t oid[], uint8_t n_subid,
uint8_t include)
{
uint8_t prefix = 0;
uint8_t i;
if (n_subid > 5 && oid[0] == 1 && oid[1] == 3 && oid[2] == 6 &&
oid[3] == 1 && oid[4] < UINT8_MAX) {
prefix = oid[4];
oid += 5;
n_subid -= 5;
}
message_add_uint8(msg, n_subid);
message_add_uint8(msg, prefix);
message_add_uint8(msg, include);
message_add_uint8(msg, 0);
for (i = 0; i < n_subid; i++)
message_add_uint32(msg, oid[i]);
}
static void
message_add_varbind(struct message *msg, struct varbind *varbind)
{
uint64_t u64;
uint32_t u32;
size_t len;
va_list ap;
message_add_uint16(msg, varbind->type);
message_add_uint16(msg, 0);
message_add_oid(msg, varbind->name.subid, varbind->name.n_subid, 0);
switch (varbind->type) {
case INTEGER:
message_add_uint32(msg, varbind->data.int32);
break;
case COUNTER32:
case GAUGE32:
case TIMETICKS:
message_add_uint32(msg, varbind->data.uint32);
break;
case OCTETSTRING:
case IPADDRESS:
case OPAQUE:
message_add_nstring(msg, varbind->data.octetstring.string,
varbind->data.octetstring.len);
break;
case OBJECTIDENTIFIER:
message_add_oid(msg, varbind->data.oid.subid,
varbind->data.oid.n_subid, 0);
break;
case COUNTER64:
message_add_uint64(msg, varbind->data.uint64);
break;
case AXNULL:
case NOSUCHOBJECT:
case NOSUCHINSTANCE:
case ENDOFMIBVIEW:
break;
default:
errx(1, "%s: unsupported data type: %d", __func__,
varbind->type);
}
}
static void
message_add_header(struct message *msg, uint8_t version, uint8_t type,
uint8_t flags, uint32_t sessionid, uint32_t transactionid,
uint32_t packetid)
{
if (msg->len != 0)
errx(1, "%s: message not new", __func__);
message_add_uint8(msg, version);
message_add_uint8(msg, type);
message_add_uint8(msg, flags);
message_add_uint8(msg, 0);
message_add_uint32(msg, sessionid);
message_add_uint32(msg, transactionid);
message_add_uint32(msg, packetid);
message_add_uint32(msg, 0);
}
static void
message_add(struct message *msg, const void *src, size_t len)
{
if (len == 0)
return;
if (msg->len + len > msg->size) {
if ((msg->buf = recallocarray(msg->buf, msg->size,
(((msg->len + len) % 4096) + 1) * 4096, 1)) == NULL)
err(1, NULL);
msg->size = (((msg->len + len) % 4096) + 1) * 4096;
}
memcpy(msg->buf + msg->len, src, len);
msg->len += len;
}
static void
message_release(struct message *msg)
{
free(msg->buf);
}
static size_t
poid(const char *test, const struct header *header, const uint8_t *buf, size_t len,
struct oid *oid)
{
uint8_t n_subid, i;
uint32_t subid;
if (len < 4)
errx(1, "%s: incomplete oid", test);
n_subid = buf[0];
if (buf[1] != 0) {
*oid = OID_STRUCT(1, 3, 6, 1, buf[1]);
} else
*oid = OID_STRUCT();
oid->include = buf[2];
if (buf[3] != 0)
errx(1, "%s: invalid oid reserved (%hhx)", test, buf[3]);
buf += 4;
len -= 4;
if (oid->n_subid + n_subid > 128)
errx(1, "%s: too many n_subid in oid", test);
if (len < n_subid * sizeof(oid->subid[0]))
errx(1, "%s: incomplete oid: (%zu/%zu)", test,
n_subid * sizeof(oid->subid[0]), len);
for (i = 0; i < n_subid; i++) {
memcpy(&subid, buf, sizeof(subid));
buf += 4;
oid->subid[oid->n_subid++] = p32toh(header, subid);
}
return 4 * (n_subid + 1);
}
size_t
agentx_read(int s, void *buf, size_t len, int timeout)
{
ssize_t n;
size_t i;
int ret;
struct pollfd pfd = {
.fd = s,
.events = POLLIN
};
if ((ret = poll(&pfd, 1, timeout)) == -1)
err(1, "poll");
if (ret == 0)
errx(1, "%s: timeout", __func__);
if ((n = read(s, buf, len)) == -1)
err(1, "agentx read");
if (verbose && n != 0) {
printf("AgentX received(%d):\n", s);
for (i = 0; i < n; i++) {
printf("%s%02hhx", i % 4 == 0 ? "" : " ",
((char *)buf)[i]);
if (i % 4 == 3)
printf("\n");
}
if (i % 4 != 0)
printf("\n");
}
return n;
}
void
agentx_timeout(int s, int timeout)
{
int ret;
struct pollfd pfd = {
.fd = s,
.events = POLLIN
};
if ((ret = poll(&pfd, 1, timeout)) == -1)
err(1, "poll");
if (ret != 0)
errx(1, "%s: unexpected agentx data", __func__);
}
void
agentx_write(int s, struct message *msg)
{
ssize_t n;
char *buf = msg->buf;
size_t len = msg->len;
struct header *header = msg->buf;
size_t i;
msg->len = 16;
message_add_uint32(msg, len - sizeof(*header));
if (verbose) {
printf("AgentX sending(%d):\n", s);
for (i = 0; i < len; i++) {
printf("%s%02hhx", i % 4 == 0 ? "" : " ", buf[i]);
if (i % 4 == 3)
printf("\n");
}
if (i % 4 != 0)
printf("\n");
}
while (len > 0) {
if ((n = write(s, buf, len)) == -1)
err(1, "agentx write");
buf += n;
len -= n;
}
msg->len = 0;
}
