/*      $OpenBSD: agentx_control.c,v 1.8 2026/03/02 19:28:01 rsadowski Exp $    */

/*
 * Copyright (c) 2020 Martijn van Duren <martijn@openbsd.org>
 * Copyright (c) 2008 - 2014 Reyk Floeter <reyk@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/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/time.h>
#include <sys/un.h>

#include <netinet/in.h>

#include <agentx.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <event.h>
#include <imsg.h>

#include "relayd.h"
#include "log.h"

#define RELAYD_MIB      "1.3.6.1.4.1.30155.3"
#define SNMP_ELEMENT(x...)      do {                            \
        if (snmp_element(RELAYD_MIB x) == -1)                   \
                goto done;                                      \
} while (0)

/*
static struct snmp_oid  hosttrapoid = {
        { 1, 3, 6, 1, 4, 1, 30155, 3, 1, 0 },
        10
};
*/

#define RELAYDINFO              AGENTX_ENTERPRISES, 30155, 3, 2
#define RELAYDREDIRECTS         RELAYDINFO, 1
#define RELAYDREDIRECTENTRY     RELAYDREDIRECTS, 1
#define RELAYDREDIRECTINDEX     RELAYDREDIRECTENTRY, 1
#define RELAYDREDIRECTSTATUS    RELAYDREDIRECTENTRY, 2
#define RELAYDREDIRECTNAME      RELAYDREDIRECTENTRY, 3
#define RELAYDREDIRECTCNT       RELAYDREDIRECTENTRY, 4
#define RELAYDREDIRECTAVG       RELAYDREDIRECTENTRY, 5
#define RELAYDREDIRECTLAST      RELAYDREDIRECTENTRY, 6
#define RELAYDREDIRECTAVGHOUR   RELAYDREDIRECTENTRY, 7
#define RELAYDREDIRECTLASTHOUR  RELAYDREDIRECTENTRY, 8
#define RELAYDREDIRECTAVGDAY    RELAYDREDIRECTENTRY, 9
#define RELAYDREDIRECTLASTDAY   RELAYDREDIRECTENTRY, 10
#define RELAYDRELAYS            RELAYDINFO, 2
#define RELAYDRELAYENTRY        RELAYDRELAYS, 1
#define RELAYDRELAYINDEX        RELAYDRELAYENTRY, 1
#define RELAYDRELAYSTATUS       RELAYDRELAYENTRY, 2
#define RELAYDRELAYNAME         RELAYDRELAYENTRY, 3
#define RELAYDRELAYCNT          RELAYDRELAYENTRY, 4
#define RELAYDRELAYAVG          RELAYDRELAYENTRY, 5
#define RELAYDRELAYLAST         RELAYDRELAYENTRY, 6
#define RELAYDRELAYAVGHOUR      RELAYDRELAYENTRY, 7
#define RELAYDRELAYLASTHOUR     RELAYDRELAYENTRY, 8
#define RELAYDRELAYAVGDAY       RELAYDRELAYENTRY, 9
#define RELAYDRELAYLASTDAY      RELAYDRELAYENTRY, 10
#define RELAYDROUTERS           RELAYDINFO, 3
#define RELAYDROUTERENTRY       RELAYDROUTERS, 1
#define RELAYDROUTERINDEX       RELAYDROUTERENTRY, 1
#define RELAYDROUTERTABLEINDEX  RELAYDROUTERENTRY, 2
#define RELAYDROUTERSTATUS      RELAYDROUTERENTRY, 3
#define RELAYDROUTERNAME        RELAYDROUTERENTRY, 4
#define RELAYDROUTERLABEL       RELAYDROUTERENTRY, 5
#define RELAYDROUTERRTABLE      RELAYDROUTERENTRY, 6
#define RELAYDNETROUTES         RELAYDINFO, 4
#define RELAYDNETROUTEENTRY     RELAYDNETROUTES, 1
#define RELAYDNETROUTEINDEX     RELAYDNETROUTEENTRY, 1
#define RELAYDNETROUTEADDR      RELAYDNETROUTEENTRY, 2
#define RELAYDNETROUTEADDRTYPE  RELAYDNETROUTEENTRY, 3
#define RELAYDNETROUTEPREFIXLEN RELAYDNETROUTEENTRY, 4
#define RELAYDNETROUTEROUTERINDEX RELAYDNETROUTEENTRY, 5
#define RELAYDHOSTS             RELAYDINFO, 5
#define RELAYDHOSTENTRY         RELAYDHOSTS, 1
#define RELAYDHOSTINDEX         RELAYDHOSTENTRY, 1
#define RELAYDHOSTPARENTINDEX   RELAYDHOSTENTRY, 2
#define RELAYDHOSTTABLEINDEX    RELAYDHOSTENTRY, 3
#define RELAYDHOSTNAME          RELAYDHOSTENTRY, 4
#define RELAYDHOSTADDRESS       RELAYDHOSTENTRY, 5
#define RELAYDHOSTADDRESSTYPE   RELAYDHOSTENTRY, 6
#define RELAYDHOSTSTATUS        RELAYDHOSTENTRY, 7
#define RELAYDHOSTCHECKCNT      RELAYDHOSTENTRY, 8
#define RELAYDHOSTUPCNT         RELAYDHOSTENTRY, 9
#define RELAYDHOSTERRNO         RELAYDHOSTENTRY, 10
#define RELAYDSESSIONS          RELAYDINFO, 6
#define RELAYDSESSIONENTRY      RELAYDSESSIONS, 1
#define RELAYDSESSIONINDEX      RELAYDSESSIONENTRY, 1
#define RELAYDSESSIONRELAYINDEX RELAYDSESSIONENTRY, 2
#define RELAYDSESSIONINADDR     RELAYDSESSIONENTRY, 3
#define RELAYDSESSIONINADDRTYPE RELAYDSESSIONENTRY, 4
#define RELAYDSESSIONOUTADDR    RELAYDSESSIONENTRY, 5
#define RELAYDSESSIONOUTADDRTYPE RELAYDSESSIONENTRY, 6
#define RELAYDSESSIONPORTIN     RELAYDSESSIONENTRY, 7
#define RELAYDSESSIONPORTOUT    RELAYDSESSIONENTRY, 8
#define RELAYDSESSIONAGE        RELAYDSESSIONENTRY, 9
#define RELAYDSESSIONIDLE       RELAYDSESSIONENTRY, 10
#define RELAYDSESSIONSTATUS     RELAYDSESSIONENTRY, 11
#define RELAYDSESSIONPID        RELAYDSESSIONENTRY, 12
#define RELAYDTABLES            RELAYDINFO, 7
#define RELAYDTABLEENTRY        RELAYDTABLES, 1
#define RELAYDTABLEINDEX        RELAYDTABLEENTRY, 1
#define RELAYDTABLENAME         RELAYDTABLEENTRY, 2
#define RELAYDTABLESTATUS       RELAYDTABLEENTRY, 3

void agentx_nofd(struct agentx *, void *, int);

struct relayd *env;

struct agentx *sa = NULL;
struct agentx_index *relaydRedirectIdx, *relaydRelayIdx;
struct agentx_index *relaydRouterIdx, *relaydNetRouteIdx;
struct agentx_index *relaydHostIdx, *relaydSessionRelayIdx;
struct agentx_index *relaydSessionIdx, *relaydTableIdx;

struct agentx_object *relaydRedirectIndex, *relaydRedirectStatus;
struct agentx_object *relaydRedirectName, *relaydRedirectCnt;
struct agentx_object *relaydRedirectAvg, *relaydRedirectLast;
struct agentx_object *relaydRedirectAvgHour, *relaydRedirectLastHour;
struct agentx_object *relaydRedirectAvgDay, *relaydRedirectLastDay;

struct agentx_object *relaydRelayIndex, *relaydRelayStatus;
struct agentx_object *relaydRelayName, *relaydRelayCnt;
struct agentx_object *relaydRelayAvg, *relaydRelayLast;
struct agentx_object *relaydRelayAvgHour, *relaydRelayLastHour;
struct agentx_object *relaydRelayAvgDay, *relaydRelayLastDay;

struct agentx_object *relaydRouterIndex, *relaydRouterTableIndex;
struct agentx_object *relaydRouterStatus, *relaydRouterName;
struct agentx_object *relaydRouterLabel, *relaydRouterRtable;

struct agentx_object *relaydNetRouteIndex, *relaydNetRouteAddr;
struct agentx_object *relaydNetRouteAddrType, *relaydNetRoutePrefixLen;
struct agentx_object *relaydNetRouteRouterIndex;

struct agentx_object *relaydHostIndex, *relaydHostParentIndex;
struct agentx_object *relaydHostTableIndex, *relaydHostName;
struct agentx_object *relaydHostAddress, *relaydHostAddressType;
struct agentx_object *relaydHostStatus, *relaydHostCheckCnt;
struct agentx_object *relaydHostUpCnt, *relaydHostErrno;

struct agentx_object *relaydSessionIndex, *relaydSessionRelayIndex;
struct agentx_object *relaydSessionInAddr, *relaydSessionInAddrType;
struct agentx_object *relaydSessionOutAddr, *relaydSessionOutAddrType;
struct agentx_object *relaydSessionPortIn, *relaydSessionPortOut;
struct agentx_object *relaydSessionAge, *relaydSessionIdle;
struct agentx_object *relaydSessionStatus, *relaydSessionPid;

struct agentx_object *relaydTableIndex, *relaydTableName, *relaydTableStatus;

void    *sstodata(struct sockaddr_storage *);
size_t   sstolen(struct sockaddr_storage *);

struct rdr *agentxctl_rdr_byidx(uint32_t, enum agentx_request_type);
void agentxctl_redirect(struct agentx_varbind *);
struct relay *agentxctl_relay_byidx(uint32_t, enum agentx_request_type);
void agentxctl_relay(struct agentx_varbind *);
struct router *agentxctl_router_byidx(uint32_t, enum agentx_request_type);
void agentxctl_router(struct agentx_varbind *);
struct netroute *agentxctl_netroute_byidx(uint32_t, enum agentx_request_type);
void agentxctl_netroute(struct agentx_varbind *);
struct host *agentxctl_host_byidx(uint32_t, enum agentx_request_type);
void agentxctl_host(struct agentx_varbind *);
struct rsession *agentxctl_session_byidx(uint32_t, uint32_t,
    enum agentx_request_type);
void agentxctl_session(struct agentx_varbind *);
struct table *agentxctl_table_byidx(uint32_t, enum agentx_request_type);
void agentxctl_table(struct agentx_varbind *);

void     agentx_sock(int, short, void *);
#if 0
int      snmp_element(const char *, enum snmp_type, void *, int64_t,
            struct agentx_pdu *);
int      snmp_string2oid(const char *, struct snmp_oid *);
#endif

void
agentx_init(struct relayd *nenv)
{
        struct agentx_session *sas;
        struct agentx_context *sac;
        struct agentx_region *sar;
        struct agentx_index *session_idxs[2];
        static int freed;

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

        env = nenv;

        if ((env->sc_conf.flags & F_AGENTX) == 0) {
                if (sa != NULL && !freed) {
                        agentx_free(sa);
                        freed = 1;
                }
                return;
        }
        if (sa != NULL)
                return;

        freed = 0;
        if ((sa = agentx(agentx_nofd, NULL)) == NULL)
                fatal("%s: agentx alloc", __func__);
        if ((sas = agentx_session(sa, NULL, 0, "relayd", 0)) == NULL)
                fatal("%s: agentx session alloc", __func__);
        if ((sac = agentx_context(sas,
                env->sc_conf.agentx_context[0] == '\0' ? NULL :
                env->sc_conf.agentx_context)) == NULL)
                fatal("%s: agentx context alloc", __func__);
        sar = agentx_region(sac, AGENTX_OID(RELAYDINFO), 0);
        if (sar == NULL)
                fatal("%s: agentx region alloc", __func__);
        if ((relaydRedirectIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDREDIRECTINDEX))) == NULL ||
            (relaydRelayIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDRELAYINDEX))) == NULL ||
            (relaydRouterIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDROUTERINDEX))) == NULL ||
            (relaydNetRouteIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDNETROUTEINDEX))) == NULL ||
            (relaydHostIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDHOSTINDEX))) == NULL ||
            (relaydSessionIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDSESSIONINDEX))) == NULL ||
            (relaydSessionRelayIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDSESSIONRELAYINDEX))) == NULL ||
            (relaydTableIdx = agentx_index_integer_dynamic(sar,
            AGENTX_OID(RELAYDTABLEINDEX))) == NULL)
                fatal("%s: agentx index alloc", __func__);
        session_idxs[0] = relaydSessionRelayIdx;
        session_idxs[1] = relaydSessionIdx;
        if ((relaydRedirectIndex = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTINDEX), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectStatus = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTSTATUS), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectName = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTNAME), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectCnt = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTCNT), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectAvg = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTAVG), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectLast = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTLAST), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectAvgHour = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTAVGHOUR), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectLastHour = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTLASTHOUR), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectAvgDay = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTAVGDAY), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRedirectLastDay = agentx_object(sar,
            AGENTX_OID(RELAYDREDIRECTLASTDAY), &relaydRedirectIdx, 1, 0,
            agentxctl_redirect)) == NULL ||
            (relaydRelayIndex = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYINDEX), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayStatus = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYSTATUS), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayName = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYNAME), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayCnt = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYCNT), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayAvg = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYAVG), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayLast = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYLAST), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayAvgHour = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYAVGHOUR), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayLastHour = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYLASTHOUR), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayAvgDay = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYAVGDAY), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRelayLastDay = agentx_object(sar,
            AGENTX_OID(RELAYDRELAYLASTDAY), &relaydRelayIdx, 1, 0,
            agentxctl_relay)) == NULL ||
            (relaydRouterIndex = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERINDEX), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydRouterTableIndex = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERTABLEINDEX), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydRouterStatus = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERSTATUS), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydRouterName = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERNAME), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydRouterLabel = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERLABEL), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydRouterRtable = agentx_object(sar,
            AGENTX_OID(RELAYDROUTERRTABLE), &relaydRouterIdx, 1, 0,
            agentxctl_router)) == NULL ||
            (relaydNetRouteIndex = agentx_object(sar,
            AGENTX_OID(RELAYDNETROUTEINDEX), &relaydNetRouteIdx, 1, 0,
            agentxctl_netroute)) == NULL ||
            (relaydNetRouteAddr = agentx_object(sar,
            AGENTX_OID(RELAYDNETROUTEADDR), &relaydNetRouteIdx, 1, 0,
            agentxctl_netroute)) == NULL ||
            (relaydNetRouteAddrType = agentx_object(sar,
            AGENTX_OID(RELAYDNETROUTEADDRTYPE), &relaydNetRouteIdx, 1, 0,
            agentxctl_netroute)) == NULL ||
            (relaydNetRoutePrefixLen = agentx_object(sar,
            AGENTX_OID(RELAYDNETROUTEPREFIXLEN), &relaydNetRouteIdx, 1, 0,
            agentxctl_netroute)) == NULL ||
            (relaydNetRouteRouterIndex = agentx_object(sar,
            AGENTX_OID(RELAYDNETROUTEROUTERINDEX), &relaydNetRouteIdx, 1, 0,
            agentxctl_netroute)) == NULL ||
            (relaydHostIndex = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTINDEX), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostParentIndex = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTPARENTINDEX), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostTableIndex = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTTABLEINDEX), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostName = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTNAME), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostAddress = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTADDRESS), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostAddressType = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTADDRESSTYPE), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostStatus = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTSTATUS), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostCheckCnt = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTCHECKCNT), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostUpCnt = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTUPCNT), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydHostErrno = agentx_object(sar,
            AGENTX_OID(RELAYDHOSTERRNO), &relaydHostIdx, 1, 0,
            agentxctl_host)) == NULL ||
            (relaydSessionIndex = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONINDEX), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionRelayIndex = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONRELAYINDEX), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionInAddr = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONINADDR), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionInAddrType = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONINADDRTYPE), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionOutAddr = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONOUTADDR), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionOutAddrType = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONOUTADDRTYPE), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionPortIn = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONPORTIN), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionPortOut = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONPORTOUT), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionAge = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONAGE), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionIdle = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONIDLE), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionStatus = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONSTATUS), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydSessionPid = agentx_object(sar,
            AGENTX_OID(RELAYDSESSIONPID), session_idxs, 2, 0,
            agentxctl_session)) == NULL ||
            (relaydTableIndex = agentx_object(sar,
            AGENTX_OID(RELAYDTABLEINDEX), &relaydTableIdx, 1, 0,
            agentxctl_table)) == NULL ||
            (relaydTableName = agentx_object(sar,
            AGENTX_OID(RELAYDTABLENAME), &relaydTableIdx, 1, 0,
            agentxctl_table)) == NULL ||
            (relaydTableStatus = agentx_object(sar,
            AGENTX_OID(RELAYDTABLESTATUS), &relaydTableIdx, 1, 0,
            agentxctl_table)) == NULL)
                fatal("%s: agentx object alloc", __func__);
}

void
agentx_nofd(struct agentx *usa, void *cookie, int close)
{
        if (!close)
                proc_compose(env->sc_ps, PROC_PARENT, IMSG_AGENTXSOCK, NULL, 0);
        else {
                sa = NULL;
                agentx_init(env);
                event_del(&(env->sc_agentxev));
        }
}

void
agentx_setsock(struct relayd *lenv, enum privsep_procid id)
{
        struct sockaddr_un       sun;
        int                      s = -1;

        if ((s = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1)
                goto done;

        bzero(&sun, sizeof(sun));
        sun.sun_family = AF_UNIX;
        if (strlcpy(sun.sun_path, lenv->sc_conf.agentx_path,
            sizeof(sun.sun_path)) >= sizeof(sun.sun_path))
                fatalx("invalid socket path");

        if (connect(s, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
                close(s);
                s = -1;
        }
 done:
        proc_compose_imsg(lenv->sc_ps, id, -1, IMSG_AGENTXSOCK, -1, s, NULL, 0);
}

void
agentx_getsock(struct imsg *imsg)
{
        struct timeval           tv = AGENTX_RECONNECT_TIMEOUT;
        int                      fd;

        fd = imsg_get_fd(imsg);
        if (fd == -1)
                goto retry;

        event_del(&(env->sc_agentxev));
        event_set(&(env->sc_agentxev), fd, EV_READ | EV_PERSIST,
            agentx_sock, env);
        event_add(&(env->sc_agentxev), NULL);

        agentx_connect(sa, fd);

 retry:
        evtimer_set(&env->sc_agentxev, agentx_sock, env);
        evtimer_add(&env->sc_agentxev, &tv);
}

void
agentx_sock(int fd, short event, void *arg)
{
        if (event & EV_TIMEOUT) {
                proc_compose(env->sc_ps, PROC_PARENT, IMSG_AGENTXSOCK, NULL, 0);
                return;
        }
        if (event & EV_WRITE) {
                event_del(&(env->sc_agentxev));
                event_set(&(env->sc_agentxev), fd, EV_READ | EV_PERSIST,
                    agentx_sock, NULL);
                event_add(&(env->sc_agentxev), NULL);
                agentx_write(sa);
        }
        if (event & EV_READ)
                agentx_read(sa);
        return;
}

void *
sstodata(struct sockaddr_storage *ss)
{
        if (ss->ss_family == AF_INET)
                return &((struct sockaddr_in *)ss)->sin_addr;
        if (ss->ss_family == AF_INET6)
                return &((struct sockaddr_in6 *)ss)->sin6_addr;
        return NULL;
}

size_t
sstolen(struct sockaddr_storage *ss)
{
        if (ss->ss_family == AF_INET)
                return sizeof(((struct sockaddr_in *)ss)->sin_addr);
        if (ss->ss_family == AF_INET6)
                return sizeof(((struct sockaddr_in6 *)ss)->sin6_addr);
        return 0;
}

struct rdr *
agentxctl_rdr_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct rdr      *rdr;

        TAILQ_FOREACH(rdr, env->sc_rdrs, entry) {
                if (rdr->conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return rdr;
                        else
                                return TAILQ_NEXT(rdr, entry);
                } else if (rdr->conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return rdr;
                }
        }

        return NULL;
}


void
agentxctl_redirect(struct agentx_varbind *sav)
{
        struct rdr      *rdr;

        rdr = agentxctl_rdr_byidx(agentx_varbind_get_index_integer(sav,
            relaydRedirectIdx), agentx_varbind_request(sav));
        if (rdr == NULL || rdr->conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydRedirectIdx,
            rdr->conf.id);
        if (agentx_varbind_get_object(sav) == relaydRedirectIndex)
                agentx_varbind_integer(sav, rdr->conf.id);
        else if (agentx_varbind_get_object(sav) == relaydRedirectStatus) {
                if (rdr->conf.flags & F_DISABLE)
                        agentx_varbind_integer(sav, 1);
                else if (rdr->conf.flags & F_DOWN)
                        agentx_varbind_integer(sav, 2);
                else if (rdr->conf.flags & F_BACKUP)
                        agentx_varbind_integer(sav, 3);
                else
                        agentx_varbind_integer(sav, 0);
        } else if (agentx_varbind_get_object(sav) == relaydRedirectName)
                agentx_varbind_string(sav, rdr->conf.name);
        else if (agentx_varbind_get_object(sav) == relaydRedirectCnt)
                agentx_varbind_counter64(sav, rdr->stats.cnt);
        else if (agentx_varbind_get_object(sav) == relaydRedirectAvg)
                agentx_varbind_gauge32(sav, rdr->stats.avg);
        else if (agentx_varbind_get_object(sav) == relaydRedirectLast)
                agentx_varbind_gauge32(sav, rdr->stats.last);
        else if (agentx_varbind_get_object(sav) == relaydRedirectAvgHour)
                agentx_varbind_gauge32(sav, rdr->stats.avg_hour);
        else if (agentx_varbind_get_object(sav) == relaydRedirectLastHour)
                agentx_varbind_gauge32(sav, rdr->stats.last_hour);
        else if (agentx_varbind_get_object(sav) == relaydRedirectAvgDay)
                agentx_varbind_gauge32(sav, rdr->stats.avg_day);
        else if (agentx_varbind_get_object(sav) == relaydRedirectLastDay)
                agentx_varbind_gauge32(sav, rdr->stats.last_day);
}

struct relay *
agentxctl_relay_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct relay    *rly;

        TAILQ_FOREACH(rly, env->sc_relays, rl_entry) {
                if (rly->rl_conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return rly;
                        else
                                return TAILQ_NEXT(rly, rl_entry);
                } else if (rly->rl_conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return rly;
                }
        }

        return NULL;
}

void
agentxctl_relay(struct agentx_varbind *sav)
{
        struct relay    *rly;
        uint64_t         value = 0;
        int              i, nrelay = env->sc_conf.prefork_relay;

        rly = agentxctl_relay_byidx(agentx_varbind_get_index_integer(sav,
            relaydRelayIdx), agentx_varbind_request(sav));
        if (rly == NULL || rly->rl_conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydRelayIdx,
            rly->rl_conf.id);
        if (agentx_varbind_get_object(sav) == relaydRelayIndex)
                agentx_varbind_integer(sav, rly->rl_conf.id);
        else if (agentx_varbind_get_object(sav) == relaydRelayStatus) {
                if (rly->rl_up == HOST_UP)
                        agentx_varbind_integer(sav, 1);
                else
                        agentx_varbind_integer(sav, 0);
        } else if (agentx_varbind_get_object(sav) == relaydRelayName)
                agentx_varbind_string(sav, rly->rl_conf.name);
        else if (agentx_varbind_get_object(sav) == relaydRelayCnt) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].cnt;
                agentx_varbind_counter64(sav, value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayAvg) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].avg;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayLast) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].last;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayAvgHour) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].avg_hour;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayLastHour) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].last_hour;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayAvgDay) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].avg_day;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        } else if (agentx_varbind_get_object(sav) == relaydRelayLastDay) {
                for (i = 0; i < nrelay; i++)
                        value += rly->rl_stats[i].last_day;
                agentx_varbind_gauge32(sav, (uint32_t)value);
        }
}

struct router *
agentxctl_router_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct router   *router;

        TAILQ_FOREACH(router, env->sc_rts, rt_entry) {
                if (router->rt_conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return router;
                        else
                                return TAILQ_NEXT(router, rt_entry);
                } else if (router->rt_conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return router;
                }
        }

        return NULL;
}

void
agentxctl_router(struct agentx_varbind *sav)
{
        struct router   *router;

        router = agentxctl_router_byidx(agentx_varbind_get_index_integer(sav,
            relaydRouterIdx), agentx_varbind_request(sav));
        if (router == NULL || router->rt_conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydRouterIdx,
            router->rt_conf.id);
        if (agentx_varbind_get_object(sav) == relaydRouterIndex)
                agentx_varbind_integer(sav, router->rt_conf.id);
        else if (agentx_varbind_get_object(sav) == relaydRouterTableIndex) {
                if (router->rt_conf.gwtable > INT32_MAX)
                        agentx_varbind_integer(sav, -1);
                else
                        agentx_varbind_integer(sav, router->rt_conf.gwtable);
        } else if (agentx_varbind_get_object(sav) == relaydRouterStatus) {
                if (router->rt_conf.flags & F_DISABLE)
                        agentx_varbind_integer(sav, 1);
                else
                        agentx_varbind_integer(sav, 0);
        } else if (agentx_varbind_get_object(sav) == relaydRouterName)
                agentx_varbind_string(sav, router->rt_conf.name);
        else if (agentx_varbind_get_object(sav) == relaydRouterLabel)
                agentx_varbind_string(sav, router->rt_conf.label);
        else if (agentx_varbind_get_object(sav) == relaydRouterRtable)
                agentx_varbind_integer(sav, router->rt_conf.rtable);
}

struct netroute *
agentxctl_netroute_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct netroute         *nr;

        TAILQ_FOREACH(nr, env->sc_routes, nr_route) {
                if (nr->nr_conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return nr;
                        else
                                return TAILQ_NEXT(nr, nr_entry);
                } else if (nr->nr_conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return nr;
                }
        }

        return NULL;
}

void
agentxctl_netroute(struct agentx_varbind *sav)
{
        struct netroute *nr;

        nr = agentxctl_netroute_byidx(agentx_varbind_get_index_integer(sav,
            relaydNetRouteIdx), agentx_varbind_request(sav));
        if (nr == NULL || nr->nr_conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydNetRouteIdx,
            nr->nr_conf.id);
        if (agentx_varbind_get_object(sav) == relaydNetRouteIndex)
                agentx_varbind_integer(sav, nr->nr_conf.id);
        else if (agentx_varbind_get_object(sav) == relaydNetRouteAddr)
                agentx_varbind_nstring(sav, sstodata(&nr->nr_conf.ss),
                    sstolen(&nr->nr_conf.ss));
        else if (agentx_varbind_get_object(sav) == relaydNetRouteAddrType) {
                if (nr->nr_conf.ss.ss_family == AF_INET)
                        agentx_varbind_integer(sav, 1);
                else if (nr->nr_conf.ss.ss_family == AF_INET6)
                        agentx_varbind_integer(sav, 2);
        } else if (agentx_varbind_get_object(sav) == relaydNetRoutePrefixLen)
                agentx_varbind_integer(sav, nr->nr_conf.prefixlen);
        else if (agentx_varbind_get_object(sav) == relaydNetRouteRouterIndex) {
                if (nr->nr_conf.routerid > INT32_MAX)
                        agentx_varbind_integer(sav, -1);
                else
                        agentx_varbind_integer(sav, nr->nr_conf.routerid);
        }
}

struct host *
agentxctl_host_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct host             *host;

        TAILQ_FOREACH(host, &(env->sc_hosts), globalentry) {
                if (host->conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return host;
                        else
                                return TAILQ_NEXT(host, globalentry);
                } else if (host->conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return host;
                }
        }

        return NULL;
}

void
agentxctl_host(struct agentx_varbind *sav)
{
        struct host     *host;

        host = agentxctl_host_byidx(agentx_varbind_get_index_integer(sav,
            relaydHostIdx), agentx_varbind_request(sav));
        if (host == NULL || host->conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydHostIdx,
            host->conf.id);
        if (agentx_varbind_get_object(sav) == relaydHostIndex)
                agentx_varbind_integer(sav, host->conf.id);
        else if (agentx_varbind_get_object(sav) == relaydHostParentIndex) {
                if (host->conf.parentid > INT32_MAX)
                        agentx_varbind_integer(sav, -1);
                else
                        agentx_varbind_integer(sav, host->conf.parentid);
        } else if (agentx_varbind_get_object(sav) == relaydHostTableIndex) {
                if (host->conf.tableid > INT32_MAX)
                        agentx_varbind_integer(sav, -1);
                else
                        agentx_varbind_integer(sav, host->conf.tableid);
        } else if (agentx_varbind_get_object(sav) == relaydHostName)
                agentx_varbind_string(sav, host->conf.name);
        else if (agentx_varbind_get_object(sav) == relaydHostAddress)
                agentx_varbind_nstring(sav, sstodata(&host->conf.ss),
                    sstolen(&host->conf.ss));
        else if (agentx_varbind_get_object(sav) == relaydHostAddressType) {
                if (host->conf.ss.ss_family == AF_INET)
                        agentx_varbind_integer(sav, 1);
                else if (host->conf.ss.ss_family == AF_INET6)
                        agentx_varbind_integer(sav, 2);
        } else if (agentx_varbind_get_object(sav) == relaydHostStatus) {
                if (host->flags & F_DISABLE)
                        agentx_varbind_integer(sav, 1);
                else if (host->up == HOST_UP)
                        agentx_varbind_integer(sav, 0);
                else if (host->up == HOST_DOWN)
                        agentx_varbind_integer(sav, 2);
                else
                        agentx_varbind_integer(sav, 3);
        } else if (agentx_varbind_get_object(sav) == relaydHostCheckCnt)
                agentx_varbind_counter64(sav, host->check_cnt);
        else if (agentx_varbind_get_object(sav) == relaydHostUpCnt)
                agentx_varbind_counter64(sav, host->up_cnt);
        else if (agentx_varbind_get_object(sav) == relaydHostErrno)
                agentx_varbind_integer(sav, host->he);
}

/*
 * Every session is spawned in one of multiple processes.
 * However, there is no central session id registration, so not every session
 * is shown here
 */
struct rsession *
agentxctl_session_byidx(uint32_t sessidx, uint32_t relayidx,
    enum agentx_request_type type)
{
        struct rsession         *session;

        TAILQ_FOREACH(session, &(env->sc_sessions), se_entry) {
                if (session->se_id == sessidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET) {
                                if (relayidx != session->se_relayid)
                                        return NULL;
                                return session;
                        }
                        if (type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
                                if (relayidx <= session->se_relayid)
                                        return session;
                                return TAILQ_NEXT(session, se_entry);
                        }
                        if (relayidx < session->se_relayid)
                                return session;
                        return TAILQ_NEXT(session, se_entry);
                } else if (session->se_id > sessidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return session;
                }
        }

        return NULL;
}

void
agentxctl_session(struct agentx_varbind *sav)
{
        struct timeval   tv, now;
        struct rsession *session;

        session = agentxctl_session_byidx(agentx_varbind_get_index_integer(sav,
            relaydSessionIdx), agentx_varbind_get_index_integer(sav,
            relaydSessionRelayIdx), agentx_varbind_request(sav));
        if (session == NULL || session->se_id > INT32_MAX ||
            session->se_relayid > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }

        agentx_varbind_set_index_integer(sav, relaydSessionIdx,
            session->se_id);
        agentx_varbind_set_index_integer(sav, relaydSessionRelayIdx,
            session->se_relayid);
        if (agentx_varbind_get_object(sav) == relaydSessionIndex)
                agentx_varbind_integer(sav, session->se_id);
        else if (agentx_varbind_get_object(sav) == relaydSessionRelayIndex)
                agentx_varbind_integer(sav, session->se_relayid);
        else if (agentx_varbind_get_object(sav) == relaydSessionInAddr)
                agentx_varbind_nstring(sav, sstodata(&(session->se_in.ss)),
                    sstolen(&(session->se_in.ss)));
        else if (agentx_varbind_get_object(sav) == relaydSessionInAddrType) {
                if (session->se_in.ss.ss_family == AF_INET)
                        agentx_varbind_integer(sav, 1);
                else if (session->se_in.ss.ss_family == AF_INET6)
                        agentx_varbind_integer(sav, 2);
        } else if (agentx_varbind_get_object(sav) == relaydSessionOutAddr)
                agentx_varbind_nstring(sav, sstodata(&(session->se_out.ss)),
                    sstolen(&(session->se_out.ss)));
        else if (agentx_varbind_get_object(sav) == relaydSessionOutAddrType) {
                if (session->se_out.ss.ss_family == AF_INET)
                        agentx_varbind_integer(sav, 1);
                else if (session->se_out.ss.ss_family == AF_INET6)
                        agentx_varbind_integer(sav, 2);
                else
                        agentx_varbind_integer(sav, 0);
        } else if (agentx_varbind_get_object(sav) == relaydSessionPortIn)
                agentx_varbind_integer(sav, session->se_in.port);
        else if (agentx_varbind_get_object(sav) == relaydSessionPortOut)
                agentx_varbind_integer(sav, session->se_out.port);
        else if (agentx_varbind_get_object(sav) == relaydSessionAge) {
                getmonotime(&now);
                timersub(&now, &session->se_tv_start, &tv);
                agentx_varbind_timeticks(sav,
                    tv.tv_sec * 100 + tv.tv_usec / 10000);
        } else if (agentx_varbind_get_object(sav) == relaydSessionIdle) {
                getmonotime(&now);
                timersub(&now, &session->se_tv_last, &tv);
                agentx_varbind_timeticks(sav,
                    tv.tv_sec * 100 + tv.tv_usec / 10000);
        } else if (agentx_varbind_get_object(sav) == relaydSessionStatus) {
                if (session->se_done)
                        agentx_varbind_integer(sav, 1);
                else
                        agentx_varbind_integer(sav, 0);
        } else if (agentx_varbind_get_object(sav) == relaydSessionPid)
                agentx_varbind_integer(sav, session->se_pid);
}

struct table *
agentxctl_table_byidx(uint32_t instanceidx, enum agentx_request_type type)
{
        struct table            *table;

        TAILQ_FOREACH(table, env->sc_tables, entry) {
                if (table->conf.id == instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET ||
                            type == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE)
                                return table;
                        else
                                return TAILQ_NEXT(table, entry);
                } else if (table->conf.id > instanceidx) {
                        if (type == AGENTX_REQUEST_TYPE_GET)
                                return NULL;
                        return table;
                }
        }

        return NULL;
}

void
agentxctl_table(struct agentx_varbind *sav)
{
        struct table    *table;

        table = agentxctl_table_byidx(agentx_varbind_get_index_integer(sav,
            relaydTableIdx), agentx_varbind_request(sav));
        if (table == NULL || table->conf.id > INT32_MAX) {
                agentx_varbind_notfound(sav);
                return;
        }
        agentx_varbind_set_index_integer(sav, relaydTableIdx,
            table->conf.id);
        if (agentx_varbind_get_object(sav) == relaydTableIndex)
                agentx_varbind_integer(sav, table->conf.id);
        else if (agentx_varbind_get_object(sav) == relaydTableName)
                agentx_varbind_string(sav, table->conf.name);
        else if (agentx_varbind_get_object(sav) == relaydTableStatus) {
                if (TAILQ_EMPTY(&table->hosts))
                        agentx_varbind_integer(sav, 1);
                else if (table->conf.flags & F_DISABLE)
                        agentx_varbind_integer(sav, 2);
                else
                        agentx_varbind_integer(sav, 0);
        }

}
#if 0

int
snmp_element(const char *oidstr, enum snmp_type type, void *buf, int64_t val,
    struct agentx_pdu *pdu)
{
        u_int32_t                d;
        u_int64_t                l;
        struct snmp_oid          oid;

        DPRINTF("%s: oid %s type %d buf %p val %lld", __func__,
            oidstr, type, buf, val);

        if (snmp_string2oid(oidstr, &oid) == -1)
                return -1;

        switch (type) {
        case SNMP_GAUGE32:
        case SNMP_NSAPADDR:
        case SNMP_INTEGER32:
        case SNMP_UINTEGER32:
                d = (u_int32_t)val;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_INTEGER,
                    &d, sizeof(d)) == -1)
                        return -1;
                break;

        case SNMP_COUNTER32:
                d = (u_int32_t)val;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_COUNTER32,
                    &d, sizeof(d)) == -1)
                        return -1;
                break;

        case SNMP_TIMETICKS:
                d = (u_int32_t)val;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_TIME_TICKS,
                    &d, sizeof(d)) == -1)
                        return -1;
                break;

        case SNMP_COUNTER64:
                l = (u_int64_t)val;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_COUNTER64,
                    &l, sizeof(l)) == -1)
                        return -1;
                break;

        case SNMP_IPADDR:
        case SNMP_OPAQUE:
                d = (u_int32_t)val;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_OPAQUE,
                    buf, strlen(buf)) == -1)
                        return -1;
                break;

        case SNMP_OBJECT: {
                struct snmp_oid         oid1;

                if (snmp_string2oid(buf, &oid1) == -1)
                        return -1;
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_OBJECT_IDENTIFIER,
                    &oid1, sizeof(oid1)) == -1)
                        return -1;
        }

        case SNMP_BITSTRING:
        case SNMP_OCTETSTRING:
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_OCTET_STRING,
                    buf, strlen(buf)) == -1)
                        return -1;
                break;

        case SNMP_NULL:
                /* no data beyond the OID itself */
                if (snmp_agentx_varbind(pdu, &oid, AGENTX_NULL,
                    NULL, 0) == -1)
                        return -1;
        }

        return 0;
}

/*
 * SNMP traps for relayd
 */

void
snmp_hosttrap(struct relayd *env, struct table *table, struct host *host)
{
        struct agentx_pdu *pdu;

        if (snmp_agentx == NULL || env->sc_snmp == -1)
                return;

        /*
         * OPENBSD-RELAYD-MIB host status trap
         * XXX The trap format needs some tweaks and other OIDs
         */

        if ((pdu = snmp_agentx_notify_pdu(&hosttrapoid)) == NULL)
                return;

        SNMP_ELEMENT(".1.0", SNMP_NULL, NULL, 0, pdu);
        SNMP_ELEMENT(".1.1.0", SNMP_OCTETSTRING, host->conf.name, 0, pdu);
        SNMP_ELEMENT(".1.2.0", SNMP_INTEGER32, NULL, host->up, pdu);
        SNMP_ELEMENT(".1.3.0", SNMP_INTEGER32, NULL, host->last_up, pdu);
        SNMP_ELEMENT(".1.4.0", SNMP_INTEGER32, NULL, host->up_cnt, pdu);
        SNMP_ELEMENT(".1.5.0", SNMP_INTEGER32, NULL, host->check_cnt, pdu);
        SNMP_ELEMENT(".1.6.0", SNMP_OCTETSTRING, table->conf.name, 0, pdu);
        SNMP_ELEMENT(".1.7.0", SNMP_INTEGER32, NULL, table->up, pdu);
        if (!host->conf.retry)
                goto done;
        SNMP_ELEMENT(".1.8.0", SNMP_INTEGER32, NULL, host->conf.retry, pdu);
        SNMP_ELEMENT(".1.9.0", SNMP_INTEGER32, NULL, host->retry_cnt, pdu);

 done:
        snmp_agentx_send(snmp_agentx, pdu);
        snmp_event_add(env, EV_WRITE);
}

int
snmp_string2oid(const char *oidstr, struct snmp_oid *o)
{
        char                    *sp, *p, str[BUFSIZ];
        const char              *errstr;

        if (strlcpy(str, oidstr, sizeof(str)) >= sizeof(str))
                return -1;
        bzero(o, sizeof(*o));

        for (p = sp = str; p != NULL; sp = p) {
                if ((p = strpbrk(p, ".-")) != NULL)
                        *p++ = '\0';
                o->o_id[o->o_n++] = strtonum(sp, 0, UINT_MAX, &errstr);
                if (errstr || o->o_n > SNMP_MAX_OID_LEN)
                        return -1;
        }

        return 0;
}
#endif