xref: /openbsd/regress/lib/libagentx/main.c (revision c29afb18)

/*	$OpenBSD: main.c,v 1.7 2021/05/01 16:55:14 martijn Exp $	*/

/*
 * Copyright (c) 2019 Martijn van Duren <martijn@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>

#include <arpa/inet.h>

#include <event.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "log.h"
#include <agentx.h>

#define LINKDOWN 1, 3, 6, 1, 6, 3, 1, 1, 5, 3
#define IFINDEX 1, 3, 6, 1, 2, 1, 2, 2, 1, 1
#define IFADMINSTATUS 1, 3, 6, 1, 2, 1, 2, 2, 1, 7
#define IFOPERSTATUS 1, 3, 6, 1, 2, 1, 2, 2, 1, 8

void regress_fd(struct agentx *, void *, int);
void regress_tryconnect(int, short, void *);
void regress_read(int, short, void *);
void regress_usr1(int, short, void *);
void regress_usr2(int, short, void *);
void regress_scalarinteger(struct agentx_varbind *);
void regress_scalarstring(struct agentx_varbind *);
void regress_scalarnull(struct agentx_varbind *);
void regress_scalaroid(struct agentx_varbind *);
void regress_scalaripaddress(struct agentx_varbind *);
void regress_scalarcounter32(struct agentx_varbind *);
void regress_scalargauge32(struct agentx_varbind *);
void regress_scalartimeticks(struct agentx_varbind *);
void regress_scalaropaque(struct agentx_varbind *);
void regress_scalarcounter64(struct agentx_varbind *);
void regress_scalarerror(struct agentx_varbind *);

void regress_intindex(struct agentx_varbind *);
void regress_intindex2(struct agentx_varbind *);

void regress_strindex(struct agentx_varbind *);
void regress_implstrindex(struct agentx_varbind *);
void regress_strindex2(struct agentx_varbind *);

void regress_oidimplindex(struct agentx_varbind *);

void regress_ipaddressindex(struct agentx_varbind *);

void regress_intindexstaticvalueint(struct agentx_varbind *);
void regress_intindexstaticvaluestring(struct agentx_varbind *);
void regress_intindexstaticanyint(struct agentx_varbind *);
void regress_intindexstaticanystring(struct agentx_varbind *);
void regress_intindexstaticnewint(struct agentx_varbind *);
void regress_intindexstaticnewstring(struct agentx_varbind *);

struct agentx *sa;
struct agentx_session *sas;
struct agentx_context *sac;
struct agentx_agentcaps *saa;
struct agentx_region *regress;

struct agentx_index *regressidx_int;
struct agentx_index *regressidx_int2;

struct agentx_index *regressidx_str;
struct agentx_index *regressidx_str2;

struct agentx_index *regressidx_oid;

struct agentx_index *regressidx_ipaddress;

struct agentx_index *regressidx_new;
struct agentx_index *regressidx_any;
struct agentx_index *regressidx_value;

struct agentx_object *regressobj_scalarinteger;
struct agentx_object *regressobj_scalarstring;
struct agentx_object *regressobj_scalarnull;
struct agentx_object *regressobj_scalaroid;
struct agentx_object *regressobj_scalaripaddress;
struct agentx_object *regressobj_scalarcounter32;
struct agentx_object *regressobj_scalargauge32;
struct agentx_object *regressobj_scalartimeticks;
struct agentx_object *regressobj_scalaropaque;
struct agentx_object *regressobj_scalarcounter64;

struct agentx_object *regressobj_intindexint;
struct agentx_object *regressobj_intindexint2;

struct agentx_object *regressobj_strindexstr;
struct agentx_object *regressobj_implstrindexstr;
struct agentx_object *regressobj_strindexstr2;

struct agentx_object *regressobj_oidimplindexoid;

struct agentx_object *regressobj_ipaddressindexipaddress;

struct agentx_object *regressobj_intindexstaticvalueint;
struct agentx_object *regressobj_intindexstaticvaluestring;
struct agentx_object *regressobj_intindexstaticanyint;
struct agentx_object *regressobj_intindexstaticanystring;
struct agentx_object *regressobj_intindexstaticnewint;
struct agentx_object *regressobj_intindexstaticnewstring;

struct agentx_object *regressobj_scalarerror;

char *path = AGENTX_MASTER_PATH;
int fd = -1;
struct event rev;
struct event intev, usr1ev, usr2ev, connev;

int
main(int argc, char *argv[])
{
	struct agentx_index *idx[AGENTX_OID_INDEX_MAX_LEN];
	int ch;
	int dflag = 0;

	log_init(2, 1);

	while ((ch = getopt(argc, argv, "d")) != -1) {
		switch (ch) {
		case 'd':
			dflag = 1;
			break;
		default:
			exit(1);
		}
	}

	argc -= optind;
	argv += optind;

	if (argc >= 1)
		path = argv[0];

	bzero(&rev, sizeof(rev));

	agentx_log_fatal = fatalx;
	agentx_log_warn = log_warnx;
	agentx_log_info = log_info;
	agentx_log_debug = log_debug;

	if ((sa = agentx(regress_fd, (void *)path)) == NULL)
		fatal("agentx");
	sas = agentx_session(sa, NULL, 0, "OpenAgentX regress", 0);
	if (sas == NULL)
		fatal("agentx_session");
	if ((sac = agentx_context(sas, NULL)) == NULL)
		fatal("agentx_context");
	if ((saa = agentx_agentcaps(sac,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 50, 1),
	    "OpenBSD AgentX regress")) == NULL)
		fatal("agentx_agentcaps");
	if ((regress = agentx_region(sac,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100), 0)) == NULL)
		fatal("agentx_region application");
	if ((regressobj_scalarinteger = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 1), NULL, 0,
	    0, regress_scalarinteger)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalarstring = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 2), NULL, 0,
	    0, regress_scalarstring)) == NULL)
		fatal("agentx_object");
/* netsnmp doesn't return NULL-objects */
/*
	if ((regressobj_scalarnull = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 3), NULL, 0,
	    0, regress_scalarnull)) == NULL)
		fatal("agentx_object");
*/
	if ((regressobj_scalaroid = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 4), NULL, 0,
	    0, regress_scalaroid)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalaripaddress = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 5), NULL, 0,
	    0, regress_scalaripaddress)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalarcounter32 = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 6), NULL, 0,
	    0, regress_scalarcounter32)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalargauge32 = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 7), NULL, 0,
	    0, regress_scalargauge32)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalartimeticks = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 8), NULL, 0,
	    0, regress_scalartimeticks)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalaropaque = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 9), NULL, 0,
	    0, regress_scalaropaque)) == NULL)
		fatal("agentx_object");
	if ((regressobj_scalarcounter64 = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 10), NULL, 0,
	    0, regress_scalarcounter64)) == NULL)
		fatal("agentx_object");

	if ((regressidx_int = agentx_index_integer_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 11, 1, 1))) == NULL)
		fatal("agentx_index_integer_dynamic");
	if ((regressobj_intindexint = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 11, 1, 1),
	    &regressidx_int, 1, 0, regress_intindex)) == NULL)
		fatal("agentx_object");

	if ((regressidx_int2 = agentx_index_integer_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 12, 1, 1))) == NULL)
		fatal("agentx_index_integer_dynamic");
	idx[0] = regressidx_int;
	idx[1] = regressidx_int2;
	if ((regressobj_intindexint2 = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 12, 1, 1),
	    idx, 2, 0, regress_intindex2)) == NULL)
		fatal("agentx_object");

	if ((regressidx_str = agentx_index_string_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 13, 1, 1))) == NULL)
		fatal("agentx_index_string_dynamic");
	if ((regressobj_strindexstr = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 13, 1, 1),
	    &regressidx_str, 1, 0, regress_strindex)) == NULL)
		fatal("agentx_object");
	if ((regressobj_implstrindexstr = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 14, 1, 1),
	    &regressidx_str, 1, 1, regress_implstrindex)) == NULL)
		fatal("agentx_object");
	if ((regressidx_str2 = agentx_index_string_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 15, 1, 1))) == NULL)
		fatal("agentx_index_string_dynamic");
	idx[0] = regressidx_str;
	idx[1] = regressidx_str2;
	if ((regressobj_strindexstr = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 15, 1, 1),
	    idx, 2, 0, regress_strindex2)) == NULL)
		fatal("agentx_object");

	if ((regressidx_oid = agentx_index_oid_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 16, 1, 1))) == NULL)
		fatal("agentx_index_oid_dynamic");
	if ((regressobj_oidimplindexoid = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 16, 1, 1),
	    &regressidx_oid, 1, 1, regress_oidimplindex)) == NULL)
		fatal("agentx_object");

	if ((regressidx_ipaddress = agentx_index_ipaddress_dynamic(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 17, 1, 1))) == NULL)
		fatal("agentx_index_oid_dynamic");
	if ((regressobj_oidimplindexoid = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 17, 1, 1),
	    &regressidx_ipaddress, 1, 0, regress_ipaddressindex)) == NULL)
		fatal("agentx_object");

	if ((regressidx_value = agentx_index_integer_value(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 18, 1, 1), 5)) == NULL)
		fatal("agentx_index_oid_dynamic");
	if ((regressobj_intindexstaticvalueint = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 18, 1, 1),
	    &regressidx_value, 1, 0, regress_intindexstaticvalueint)) == NULL)
		fatal("agentx_object");
	if ((regressobj_intindexstaticvaluestring = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 18, 1, 2),
	    &regressidx_value, 1, 0, regress_intindexstaticvaluestring)) == NULL)
		fatal("agentx_object");

	if ((regressidx_any = agentx_index_integer_any(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 19, 1, 1))) == NULL)
		fatal("agentx_index_integer_any");
	if ((regressobj_intindexstaticanyint = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 19, 1, 1),
	    &regressidx_any, 1, 0, regress_intindexstaticanyint)) == NULL)
		fatal("agentx_object");
	if ((regressobj_intindexstaticanystring = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 19, 1, 2),
	    &regressidx_any, 1, 0, regress_intindexstaticanystring)) == NULL)
		fatal("agentx_object");

	if ((regressidx_new = agentx_index_integer_new(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 20, 1, 1))) == NULL)
		fatal("agentx_index_integer_new");
	if ((regressobj_intindexstaticnewint = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 20, 1, 1),
	    &regressidx_new, 1, 0, regress_intindexstaticnewint)) == NULL)
		fatal("agentx_object");
	if ((regressobj_intindexstaticnewstring = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, 20, 1, 2),
	    &regressidx_new, 1, 0, regress_intindexstaticnewstring)) == NULL)
		fatal("agentx_object");

	if ((regressobj_scalarerror = agentx_object(regress,
	    AGENTX_OID(AGENTX_ENTERPRISES, 30155, 100, UINT32_MAX), NULL,
	    0, 0, regress_scalarerror)) == NULL)
		fatal("agentx_object");

	if (!dflag) {
		if (daemon(0, 1) == -1)
			fatalx("daemon");
	}

	event_init();

	event_set(&rev, fd, EV_READ|EV_PERSIST, regress_read, NULL);
	if (event_add(&rev, NULL) == -1)
		fatal("event_add");

	event_dispatch();
	return 0;
}

void
regress_fd(struct agentx *sa2, void *cookie, int close)
{
	static int init = 0;
	struct sockaddr_un sun;

	/* For ease of cleanup we take the single run approach */
	if (init) {
		if (!close)
			agentx_free(sa);
		else
			evtimer_del(&rev);
	} else {
		sun.sun_family = AF_UNIX;
		strlcpy(sun.sun_path, path, sizeof(sun.sun_path));

		if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ||
		    connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
			fatal("connect");
		}
		agentx_connect(sa2, fd);
		init = 1;
	}
}

void
regress_read(int fd, short event, void *cookie)
{
	agentx_read(sa);
}

#ifdef notyet

void
regress_usr1(int fd, short event, void *cookie)
{
	struct agentx_notify *san;

	if ((san = agentx_notify(sac, AGENTX_OID(LINKDOWN))) == NULL)
		fatal("agentx_notify");

	agentx_notify_integer(san, AGENTX_OID(IFINDEX), 1);
	agentx_notify_integer(san, AGENTX_OID(IFADMINSTATUS), 3);
	agentx_notify_integer(san, AGENTX_OID(IFOPERSTATUS), 6);
	agentx_notify_send(san);
}

#endif

void
regress_usr2(int fd, short event, void *cookie)
{
}

void
regress_scalarstring(struct agentx_varbind *vb)
{
	agentx_varbind_string(vb, "scalar-string");
}

void
regress_scalarinteger(struct agentx_varbind *vb)
{
	agentx_varbind_integer(vb, 1);
}

void
regress_scalarnull(struct agentx_varbind *vb)
{
	agentx_varbind_null(vb);
}

void
regress_scalaroid(struct agentx_varbind *vb)
{
	agentx_varbind_oid(vb, AGENTX_OID(AGENTX_ENTERPRISES, 30155));
}

void
regress_scalaripaddress(struct agentx_varbind *vb)
{
	struct in_addr addr;

	inet_aton("127.0.0.1", &addr);

	agentx_varbind_ipaddress(vb, &addr);
}

void
regress_scalarcounter32(struct agentx_varbind *vb)
{
	agentx_varbind_counter32(vb, 1);
}

void
regress_scalargauge32(struct agentx_varbind *vb)
{
	agentx_varbind_gauge32(vb, 1);
}

void
regress_scalartimeticks(struct agentx_varbind *vb)
{
	agentx_varbind_timeticks(vb, 1);
}

void
regress_scalaropaque(struct agentx_varbind *vb)
{
	agentx_varbind_opaque(vb, "abc", 3);
}

void
regress_scalarcounter64(struct agentx_varbind *vb)
{
	agentx_varbind_counter64(vb, 1);
}

void
regress_intindex(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_int);
	switch (agentx_varbind_request(vb)) {
	case AGENTX_REQUEST_TYPE_GET:
		if (idx == 0) {
			agentx_varbind_notfound(vb);
			return;
		}
		break;
	case AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE:
		if (idx == 0)
			idx++;
		break;
	case AGENTX_REQUEST_TYPE_GETNEXT:
		idx++;
		break;
	}
	if (idx > 0xf)
		agentx_varbind_notfound(vb);
	else {
		agentx_varbind_set_index_integer(vb, regressidx_int, idx);
		agentx_varbind_integer(vb, idx);
	}
}

void
regress_intindex2(struct agentx_varbind *vb)
{
	uint32_t idx1, idx2;
	enum agentx_request_type type;

	idx1 = agentx_varbind_get_index_integer(vb, regressidx_int);
	idx2 = agentx_varbind_get_index_integer(vb, regressidx_int2);
	type = agentx_varbind_request(vb);
	if (type == AGENTX_REQUEST_TYPE_GETNEXT)
		idx2++;
	if (type == AGENTX_REQUEST_TYPE_GETNEXT ||
	    type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
		if (idx2 > 1) {
			idx1++;
			idx2 = 0;
		}
	}
	if (idx2 > 1 || idx1 > 8)
		agentx_varbind_notfound(vb);
	else {
		agentx_varbind_set_index_integer(vb, regressidx_int, idx1);
		agentx_varbind_set_index_integer(vb, regressidx_int2, idx2);
		agentx_varbind_integer(vb, (idx1 << 1) + idx2);
	}
}

void
regress_strindex(struct agentx_varbind *vb)
{
	const unsigned char *idx;
	size_t slen;
	int implied;
	enum agentx_request_type request = agentx_varbind_request(vb);

	idx = agentx_varbind_get_index_string(vb, regressidx_str, &slen,
	    &implied);

	if (implied)
		fatalx("%s: string length should not be implied", __func__);

	if (slen == 0) {
		if (request == AGENTX_REQUEST_TYPE_GET) {
			log_warnx("%s: 0 index should be handled in agentx.c",
			    __func__);
			agentx_varbind_error(vb);
			return;
		}
	}
	/* !implied first needs a length check before content check */
	if (slen > 1) {
		agentx_varbind_notfound(vb);
		return;
	}
	if (request == AGENTX_REQUEST_TYPE_GETNEXT) {
		if (idx[0] == 'a')
			idx = (unsigned char *)"b";
		else if (idx[0] == 'b')
			idx = (unsigned char *)"c";
		else if (idx[0] >= 'c') {
			agentx_varbind_notfound(vb);
			return;
		}
	}
	if (idx == NULL || idx[0] < 'a') {
		if (request == AGENTX_REQUEST_TYPE_GET) {
			agentx_varbind_notfound(vb);
			return;
		}
		idx = (unsigned char *)"a";
	}

	agentx_varbind_set_index_string(vb, regressidx_str,
	    (const char *)idx);
	agentx_varbind_string(vb, (const char *)idx);
}

void
regress_implstrindex(struct agentx_varbind *vb)
{
	const unsigned char *idx;
	size_t slen;
	int implied;
	enum agentx_request_type request = agentx_varbind_request(vb);

	idx = agentx_varbind_get_index_string(vb, regressidx_str, &slen,
	    &implied);

	if (!implied)
		fatalx("%s: string length should be implied", __func__);

	if (slen == 0) {
		if (request == AGENTX_REQUEST_TYPE_GET)
			fatalx("%s: 0 index should be handled in agentx.c",
			    __func__);
	}
	if (request == AGENTX_REQUEST_TYPE_GET && (slen != 1 ||
	    (idx[0] != 'a' && idx[0] != 'b' && idx[0] != 'c'))) {
		agentx_varbind_notfound(vb);
		return;
	}
	/* implied doesn't needs a length check before content check */
	if (request == AGENTX_REQUEST_TYPE_GETNEXT) {
		if (idx[0] == 'a')
			idx = (const unsigned char *)"b";
		else if (idx[0] == 'b')
			idx = (const unsigned char *)"c";
		else if (idx[0] >= 'c') {
			agentx_varbind_notfound(vb);
			return;
		}
	}
	if (idx == NULL || idx[0] < 'a')
		idx = (const unsigned char *)"a";

	agentx_varbind_set_index_string(vb, regressidx_str,
	    (const char *)idx);
	agentx_varbind_string(vb, (const char *)idx);
}

void
regress_strindex2(struct agentx_varbind *vb)
{
	/* Opt is !implied sorted */
	const char *opt1[] = {"a", "b", "c"};
	const char *opt2[] = {"b", "aa", "bb"};
	size_t opt1len, opt2len;
	size_t opt1i, opt2i;
	const unsigned char *idx1, *idx2;
	size_t slen1, slen2;
	int implied1, implied2;
	enum agentx_request_type request = agentx_varbind_request(vb);
	int match;

	idx1 = agentx_varbind_get_index_string(vb, regressidx_str, &slen1,
	    &implied1);
	idx2 = agentx_varbind_get_index_string(vb, regressidx_str2, &slen2,
	    &implied2);

	/* agentx.c debugging checks */
	if (implied1 || implied2)
		fatalx("%s: string length should not be implied", __func__);
	if (slen1 == 0 || slen2 == 0) {
		if (request == AGENTX_REQUEST_TYPE_GET)
			fatalx("%s: 0 index should be handled in agentx.c",
			    __func__);
	}

	opt1len = sizeof(opt1) / sizeof(*opt1);
	match = 0;
	for (opt1i = 0; opt1i < opt1len; opt1i++) {
		if (strlen(opt1[opt1i]) < slen1 ||
		    (strlen(opt1[opt1i]) == slen1 &&
		    memcmp(opt1[opt1i], idx1, slen1) < 0)) {
			continue;
		}
		if (strlen(opt1[opt1i]) == slen1 &&
		    memcmp(opt1[opt1i], idx1, slen1) == 0)
			match = 1;
		break;
	}
	if (opt1i == opt1len) {
		agentx_varbind_notfound(vb);
		return;
	}
	opt2len = sizeof(opt2) / sizeof(*opt2);
	for (opt2i = 0; opt2i < opt2len; opt2i++) {
		if (!match)
			break;
		if (strlen(opt2[opt2i]) < slen2 ||
		    (strlen(opt2[opt2i]) == slen2 &&
		    memcmp(opt2[opt2i], idx2, slen2) < 0)) {
			continue;
		}
		if (strlen(opt2[opt2i]) != slen2 ||
		    memcmp(opt2[opt2i], idx2, slen2) > 0)
			match = 0;
		break;
	}
	if (opt2i == opt2len)
		match = 0;
	if (request == AGENTX_REQUEST_TYPE_GET) {
		if (!match) {
			agentx_varbind_notfound(vb);
			return;
		}
	} else {
		if (AGENTX_REQUEST_TYPE_GETNEXT && match)
			opt2i++;
		if (opt2i >= opt2len) {
			if (++opt1i == opt1len) {
				agentx_varbind_notfound(vb);
				return;
			}
			opt2i = 0;
		}
	}

	agentx_varbind_set_index_string(vb, regressidx_str, opt1[opt1i]);
	agentx_varbind_set_index_string(vb, regressidx_str2, opt2[opt2i]);
	agentx_varbind_printf(vb, "%s - %s", opt1[opt1i], opt2[opt2i]);
}

void
regress_oidimplindex(struct agentx_varbind *vb)
{
	struct agentx_object *obj;
	const uint32_t *idx;
	size_t oidlen;
	int implied;
	enum agentx_request_type request = agentx_varbind_request(vb);

	idx = agentx_varbind_get_index_oid(vb, regressidx_oid, &oidlen,
	    &implied);

	if (!implied)
		fatalx("%s: string length should be implied", __func__);

	if (request == AGENTX_REQUEST_TYPE_GET)
		obj = agentx_context_object_find(sac, idx, oidlen, 1, 1);
	else
		obj = agentx_context_object_nfind(sac, idx, oidlen, 1,
		    request == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE);

	if (obj == NULL) {
		agentx_varbind_notfound(vb);
		return;
	}

	agentx_varbind_set_index_object(vb, regressidx_oid, obj);
	agentx_varbind_object(vb, obj);
}

void
regress_ipaddressindex(struct agentx_varbind *vb)
{
	const struct in_addr *addr;
	struct in_addr addrlist[4];
	enum agentx_request_type request = agentx_varbind_request(vb);
	size_t i;
	int cmp;

	inet_pton(AF_INET, "10.0.0.0", &(addrlist[0]));
	inet_pton(AF_INET, "127.0.0.1", &(addrlist[1]));
	inet_pton(AF_INET, "172.16.0.0", &(addrlist[2]));
	inet_pton(AF_INET, "192.168.0.0", &(addrlist[3]));

	addr = agentx_varbind_get_index_ipaddress(vb, regressidx_ipaddress);

	for (i = 0; i < 4; i++) {
		if ((cmp = memcmp(&(addrlist[i]), addr, sizeof(*addr))) == 0) {
			if (request == AGENTX_REQUEST_TYPE_GET ||
			    request == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
				break;
		} else if (cmp > 0) {
			if (request == AGENTX_REQUEST_TYPE_GET) {
				agentx_varbind_notfound(vb);
				return;
			}
			break;
		}
	}
	if (i == 4) {
		agentx_varbind_notfound(vb);
		return;
	}

	agentx_varbind_set_index_ipaddress(vb, regressidx_ipaddress,
	    &(addrlist[i]));
	agentx_varbind_ipaddress(vb, &(addrlist[i]));
}

void
regress_intindexstaticvalueint(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_value);
	agentx_varbind_integer(vb, idx);
}

void
regress_intindexstaticvaluestring(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_value);
	agentx_varbind_printf(vb, "%u", idx);
}

void
regress_intindexstaticanyint(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_any);
	agentx_varbind_integer(vb, idx);
}

void
regress_intindexstaticanystring(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_any);
	agentx_varbind_printf(vb, "%u", idx);
}

void
regress_intindexstaticnewint(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_new);
	agentx_varbind_integer(vb, idx);
}

void
regress_intindexstaticnewstring(struct agentx_varbind *vb)
{
	uint32_t idx;

	idx = agentx_varbind_get_index_integer(vb, regressidx_new);
	agentx_varbind_printf(vb, "%u", idx);
}

void
regress_scalarerror(struct agentx_varbind *vb)
{
	agentx_varbind_error(vb);
}