#include <netinet/in.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include "agentx_internal.h"
#include <agentx.h>
enum agentx_index_type {
AXI_TYPE_NEW,
AXI_TYPE_ANY,
AXI_TYPE_VALUE,
AXI_TYPE_DYNAMIC
};
#define AGENTX_CONTEXT_CTX(axc) (axc->axc_name_default ? NULL : \
&(axc->axc_name))
struct agentx_agentcaps {
struct agentx_context *axa_axc;
struct ax_oid axa_oid;
struct ax_ostring axa_descr;
enum agentx_cstate axa_cstate;
enum agentx_dstate axa_dstate;
TAILQ_ENTRY(agentx_agentcaps) axa_axc_agentcaps;
};
struct agentx_region {
struct agentx_context *axr_axc;
struct ax_oid axr_oid;
uint8_t axr_timeout;
uint8_t axr_priority;
enum agentx_cstate axr_cstate;
enum agentx_dstate axr_dstate;
TAILQ_HEAD(, agentx_index) axr_indices;
TAILQ_HEAD(, agentx_object) axr_objects;
TAILQ_ENTRY(agentx_region) axr_axc_regions;
};
struct agentx_index {
struct agentx_region *axi_axr;
enum agentx_index_type axi_type;
struct ax_varbind axi_vb;
struct agentx_object **axi_object;
size_t axi_objectlen;
size_t axi_objectsize;
enum agentx_cstate axi_cstate;
enum agentx_dstate axi_dstate;
TAILQ_ENTRY(agentx_index) axi_axr_indices;
};
struct agentx_object {
struct agentx_region *axo_axr;
struct ax_oid axo_oid;
struct agentx_index *axo_index[AGENTX_OID_INDEX_MAX_LEN];
size_t axo_indexlen;
int axo_implied;
uint8_t axo_timeout;
uint32_t axo_lock;
void (*axo_get)(struct agentx_varbind *);
enum agentx_cstate axo_cstate;
enum agentx_dstate axo_dstate;
RB_ENTRY(agentx_object) axo_axc_objects;
TAILQ_ENTRY(agentx_object) axo_axr_objects;
};
struct agentx_varbind {
struct agentx_get *axv_axg;
struct agentx_object *axv_axo;
struct agentx_varbind_index {
struct agentx_index *axv_axi;
union ax_data axv_idata;
} axv_index[AGENTX_OID_INDEX_MAX_LEN];
size_t axv_indexlen;
int axv_initialized;
int axv_include;
struct ax_varbind axv_vb;
struct ax_oid axv_start;
struct ax_oid axv_end;
enum ax_pdu_error axv_error;
};
#define AGENTX_GET_CTX(axg) (axg->axg_context_default ? NULL : \
&(axg->axg_context))
struct agentx_request {
uint32_t axr_packetid;
int (*axr_cb)(struct ax_pdu *, void *);
void *axr_cookie;
RB_ENTRY(agentx_request) axr_ax_requests;
};
static void agentx_start(struct agentx *);
static void agentx_finalize(struct agentx *, int);
static void agentx_wantwritenow(struct agentx *, int);
void (*agentx_wantwrite)(struct agentx *, int) =
agentx_wantwritenow;
static void agentx_reset(struct agentx *);
static void agentx_free_finalize(struct agentx *);
static int agentx_session_retry(struct agentx_session *);
static int agentx_session_start(struct agentx_session *);
static int agentx_session_finalize(struct ax_pdu *, void *);
static int agentx_session_close(struct agentx_session *,
enum ax_close_reason);
static int agentx_session_close_finalize(struct ax_pdu *, void *);
static void agentx_session_free_finalize(struct agentx_session *);
static void agentx_session_reset(struct agentx_session *);
static int agentx_context_retry(struct agentx_context *);
static void agentx_context_start(struct agentx_context *);
static void agentx_context_free_finalize(struct agentx_context *);
static void agentx_context_reset(struct agentx_context *);
static int agentx_agentcaps_start(struct agentx_agentcaps *);
static int agentx_agentcaps_finalize(struct ax_pdu *, void *);
static int agentx_agentcaps_close(struct agentx_agentcaps *);
static int agentx_agentcaps_close_finalize(struct ax_pdu *, void *);
static void agentx_agentcaps_free_finalize(struct agentx_agentcaps *);
static void agentx_agentcaps_reset(struct agentx_agentcaps *);
static int agentx_region_retry(struct agentx_region *);
static int agentx_region_start(struct agentx_region *);
static int agentx_region_finalize(struct ax_pdu *, void *);
static int agentx_region_close(struct agentx_region *);
static int agentx_region_close_finalize(struct ax_pdu *, void *);
static void agentx_region_free_finalize(struct agentx_region *);
static void agentx_region_reset(struct agentx_region *);
static struct agentx_index *agentx_index(struct agentx_region *,
struct ax_varbind *, enum agentx_index_type);
static int agentx_index_start(struct agentx_index *);
static int agentx_index_finalize(struct ax_pdu *, void *);
static void agentx_index_free_finalize(struct agentx_index *);
static void agentx_index_reset(struct agentx_index *);
static int agentx_index_close(struct agentx_index *);
static int agentx_index_close_finalize(struct ax_pdu *, void *);
static int agentx_object_start(struct agentx_object *);
static int agentx_object_finalize(struct ax_pdu *, void *);
static int agentx_object_lock(struct agentx_object *);
static void agentx_object_unlock(struct agentx_object *);
static int agentx_object_close(struct agentx_object *);
static int agentx_object_close_finalize(struct ax_pdu *, void *);
static void agentx_object_free_finalize(struct agentx_object *);
static void agentx_object_reset(struct agentx_object *);
static int agentx_object_cmp(struct agentx_object *,
struct agentx_object *);
static void agentx_get_start(struct agentx_context *,
struct ax_pdu *);
static void agentx_get_finalize(struct agentx_get *);
static void agentx_get_free(struct agentx_get *);
static void agentx_varbind_start(struct agentx_varbind *);
static void agentx_varbind_finalize(struct agentx_varbind *);
static void agentx_varbind_nosuchobject(struct agentx_varbind *);
static void agentx_varbind_nosuchinstance(struct agentx_varbind *);
static void agentx_varbind_endofmibview(struct agentx_varbind *);
static void agentx_varbind_error_type(struct agentx_varbind *,
enum ax_pdu_error, int);
static int agentx_request(struct agentx *, uint32_t,
int (*)(struct ax_pdu *, void *), void *);
static int agentx_request_cmp(struct agentx_request *,
struct agentx_request *);
static int agentx_strcat(char **, const char *);
static int agentx_oidfill(struct ax_oid *, const uint32_t[], size_t,
const char **);
RB_PROTOTYPE_STATIC(ax_requests, agentx_request, axr_ax_requests,
agentx_request_cmp)
RB_PROTOTYPE_STATIC(axc_objects, agentx_object, axo_axc_objects,
agentx_object_cmp)
struct agentx *
agentx(void (*nofd)(struct agentx *, void *, int), void *cookie)
{
struct agentx *ax;
if ((ax = calloc(1, sizeof(*ax))) == NULL)
return NULL;
ax->ax_nofd = nofd;
ax->ax_cookie = cookie;
ax->ax_fd = -1;
ax->ax_cstate = AX_CSTATE_CLOSE;
ax->ax_dstate = AX_DSTATE_OPEN;
TAILQ_INIT(&(ax->ax_sessions));
TAILQ_INIT(&(ax->ax_getreqs));
RB_INIT(&(ax->ax_requests));
agentx_start(ax);
return ax;
}
void
agentx_connect(struct agentx *ax, int fd)
{
agentx_finalize(ax, fd);
}
void
agentx_retry(struct agentx *ax)
{
struct agentx_session *axs;
if (ax->ax_fd == -1)
return;
TAILQ_FOREACH(axs, &(ax->ax_sessions), axs_ax_sessions) {
if (axs->axs_cstate == AX_CSTATE_OPEN) {
if (agentx_session_retry(axs) == -1)
return;
} else if (axs->axs_cstate == AX_CSTATE_CLOSE) {
if (agentx_session_start(axs) == -1)
return;
}
}
}
static void
agentx_start(struct agentx *ax)
{
#ifdef AX_DEBUG
if (ax->ax_cstate != AX_CSTATE_CLOSE ||
ax->ax_dstate != AX_DSTATE_OPEN)
agentx_log_ax_fatalx(ax, "%s: unexpected connect", __func__);
#endif
ax->ax_cstate = AX_CSTATE_WAITOPEN;
ax->ax_nofd(ax, ax->ax_cookie, 0);
}
static void
agentx_finalize(struct agentx *ax, int fd)
{
struct agentx_session *axs;
if (ax->ax_cstate != AX_CSTATE_WAITOPEN) {
#ifdef AX_DEBUG
agentx_log_ax_fatalx(ax, "%s: agentx unexpected connect",
__func__);
#else
agentx_log_ax_warnx(ax,
"%s: agentx unexpected connect: ignoring", __func__);
return;
#endif
}
if ((ax->ax_ax = ax_new(fd)) == NULL) {
agentx_log_ax_warn(ax, "failed to initialize");
close(fd);
agentx_reset(ax);
return;
}
agentx_log_ax_info(ax, "new connection: %d", fd);
ax->ax_fd = fd;
ax->ax_cstate = AX_CSTATE_OPEN;
TAILQ_FOREACH(axs, &(ax->ax_sessions), axs_ax_sessions) {
if (agentx_session_start(axs) == -1)
break;
}
}
static void
agentx_wantwritenow(struct agentx *ax, int fd)
{
agentx_write(ax);
}
static void
agentx_reset(struct agentx *ax)
{
struct agentx_session *axs, *taxs;
struct agentx_request *axr;
struct agentx_get *axg;
int axfree = ax->ax_free;
ax_free(ax->ax_ax);
ax->ax_ax = NULL;
ax->ax_fd = -1;
ax->ax_free = 1;
ax->ax_cstate = AX_CSTATE_CLOSE;
while ((axr = RB_MIN(ax_requests, &(ax->ax_requests))) != NULL) {
RB_REMOVE(ax_requests, &(ax->ax_requests), axr);
free(axr);
}
TAILQ_FOREACH_SAFE(axs, &(ax->ax_sessions), axs_ax_sessions, taxs)
agentx_session_reset(axs);
while (!TAILQ_EMPTY(&(ax->ax_getreqs))) {
axg = TAILQ_FIRST(&(ax->ax_getreqs));
axg->axg_axc = NULL;
TAILQ_REMOVE(&(ax->ax_getreqs), axg, axg_ax_getreqs);
}
if (ax->ax_dstate == AX_DSTATE_OPEN)
agentx_start(ax);
if (!axfree)
agentx_free_finalize(ax);
}
void
agentx_free(struct agentx *ax)
{
struct agentx_session *axs, *taxs;
int axfree;
if (ax == NULL)
return;
axfree = ax->ax_free;
ax->ax_free = 1;
if (ax->ax_dstate == AX_DSTATE_CLOSE)
agentx_log_ax_fatalx(ax, "%s: double free", __func__);
ax->ax_dstate = AX_DSTATE_CLOSE;
TAILQ_FOREACH_SAFE(axs, &(ax->ax_sessions), axs_ax_sessions, taxs) {
if (axs->axs_dstate != AX_DSTATE_CLOSE)
agentx_session_free(axs);
}
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_free_finalize(struct agentx *ax)
{
struct agentx_session *axs, *taxs;
ax->ax_free = 0;
TAILQ_FOREACH_SAFE(axs, &(ax->ax_sessions), axs_ax_sessions, taxs)
agentx_session_free_finalize(axs);
if (!TAILQ_EMPTY(&(ax->ax_sessions)) ||
!RB_EMPTY(&(ax->ax_requests)) ||
ax->ax_dstate != AX_DSTATE_CLOSE)
return;
ax_free(ax->ax_ax);
ax->ax_nofd(ax, ax->ax_cookie, 1);
free(ax);
}
struct agentx_session *
agentx_session(struct agentx *ax, uint32_t oid[],
size_t oidlen, const char *descr, uint8_t timeout)
{
struct agentx_session *axs;
const char *errstr;
if ((axs = calloc(1, sizeof(*axs))) == NULL)
return NULL;
axs->axs_ax = ax;
axs->axs_timeout = timeout;
if (oidlen == 0)
axs->axs_oid.aoi_idlen = oidlen;
else {
if (agentx_oidfill((&axs->axs_oid), oid, oidlen,
&errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_ax_fatalx(ax, "%s: %s", __func__, errstr);
#else
free(axs);
return NULL;
#endif
}
}
axs->axs_descr.aos_string = (unsigned char *)strdup(descr);
if (axs->axs_descr.aos_string == NULL) {
free(axs);
return NULL;
}
axs->axs_descr.aos_slen = strlen(descr);
axs->axs_cstate = AX_CSTATE_CLOSE;
axs->axs_dstate = AX_DSTATE_OPEN;
TAILQ_INIT(&(axs->axs_contexts));
TAILQ_INSERT_HEAD(&(ax->ax_sessions), axs, axs_ax_sessions);
if (ax->ax_cstate == AX_CSTATE_OPEN)
(void) agentx_session_start(axs);
return axs;
}
static int
agentx_session_retry(struct agentx_session *axs)
{
struct agentx_context *axc;
#ifdef AX_DEBUG
if (axs->axs_cstate != AX_CSTATE_OPEN)
agentx_log_axs_fatalx(axs, "%s: unexpected retry", __func__);
#endif
TAILQ_FOREACH(axc, &(axs->axs_contexts), axc_axs_contexts) {
if (axc->axc_cstate == AX_CSTATE_OPEN) {
if (agentx_context_retry(axc) == -1)
return -1;
} else if (axc->axc_cstate == AX_CSTATE_CLOSE)
agentx_context_start(axc);
}
return 0;
}
static int
agentx_session_start(struct agentx_session *axs)
{
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (ax->ax_cstate != AX_CSTATE_OPEN ||
axs->axs_cstate != AX_CSTATE_CLOSE ||
axs->axs_dstate != AX_DSTATE_OPEN)
agentx_log_ax_fatalx(ax, "%s: unexpected session open",
__func__);
#endif
packetid = ax_open(ax->ax_ax, axs->axs_timeout, &(axs->axs_oid),
&(axs->axs_descr));
if (packetid == 0) {
agentx_log_ax_warn(ax, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_OPEN));
agentx_reset(ax);
return -1;
}
axs->axs_packetid = packetid;
agentx_log_ax_info(ax, "opening session");
axs->axs_cstate = AX_CSTATE_WAITOPEN;
return agentx_request(ax, packetid, agentx_session_finalize, axs);
}
static int
agentx_session_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_session *axs = cookie;
struct agentx *ax = axs->axs_ax;
struct agentx_context *axc;
#ifdef AX_DEBUG
if (axs->axs_cstate != AX_CSTATE_WAITOPEN)
agentx_log_ax_fatalx(ax, "%s: not expecting new session",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_ax_warnx(ax, "failed to open session: %s",
ax_error2string(pdu->ap_payload.ap_response.ap_error));
axs->axs_cstate = AX_CSTATE_CLOSE;
return -1;
}
axs->axs_id = pdu->ap_header.aph_sessionid;
axs->axs_cstate = AX_CSTATE_OPEN;
if (axs->axs_dstate == AX_DSTATE_CLOSE) {
agentx_session_close(axs, AX_CLOSE_SHUTDOWN);
return 0;
}
agentx_log_axs_info(axs, "open");
TAILQ_FOREACH(axc, &(axs->axs_contexts), axc_axs_contexts)
agentx_context_start(axc);
return 0;
}
static int
agentx_session_close(struct agentx_session *axs,
enum ax_close_reason reason)
{
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axs->axs_cstate != AX_CSTATE_OPEN)
agentx_log_ax_fatalx(ax, "%s: unexpected session close",
__func__);
#endif
if ((packetid = ax_close(ax->ax_ax, axs->axs_id, reason)) == 0) {
agentx_log_axs_warn(axs, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_CLOSE));
agentx_reset(ax);
return -1;
}
agentx_log_axs_info(axs, "closing session: %s",
ax_closereason2string(reason));
axs->axs_cstate = AX_CSTATE_WAITCLOSE;
return agentx_request(ax, packetid, agentx_session_close_finalize,
axs);
}
static int
agentx_session_close_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_session *axs = cookie;
struct agentx *ax = axs->axs_ax;
struct agentx_context *axc, *taxc;
int axfree = ax->ax_free;
#ifdef AX_DEBUG
if (axs->axs_cstate != AX_CSTATE_WAITCLOSE)
agentx_log_axs_fatalx(axs, "%s: not expecting session close",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_axs_warnx(axs, "failed to close session: %s",
ax_error2string(pdu->ap_payload.ap_response.ap_error));
agentx_reset(ax);
return -1;
}
axs->axs_cstate = AX_CSTATE_CLOSE;
ax->ax_free = 1;
agentx_log_axs_info(axs, "closed");
TAILQ_FOREACH_SAFE(axc, &(axs->axs_contexts), axc_axs_contexts, taxc)
agentx_context_reset(axc);
if (ax->ax_cstate == AX_CSTATE_OPEN &&
axs->axs_dstate == AX_DSTATE_OPEN)
agentx_session_start(axs);
if (!axfree)
agentx_free_finalize(ax);
return 0;
}
void
agentx_session_free(struct agentx_session *axs)
{
struct agentx_context *axc, *taxc;
struct agentx *ax;
int axfree;
if (axs == NULL)
return;
ax = axs->axs_ax;
axfree = ax->ax_free;
ax->ax_free = 1;
if (axs->axs_dstate == AX_DSTATE_CLOSE)
agentx_log_axs_fatalx(axs, "%s: double free", __func__);
axs->axs_dstate = AX_DSTATE_CLOSE;
if (axs->axs_cstate == AX_CSTATE_OPEN)
(void) agentx_session_close(axs, AX_CLOSE_SHUTDOWN);
TAILQ_FOREACH_SAFE(axc, &(axs->axs_contexts), axc_axs_contexts, taxc) {
if (axc->axc_dstate != AX_DSTATE_CLOSE)
agentx_context_free(axc);
}
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_session_free_finalize(struct agentx_session *axs)
{
struct agentx *ax = axs->axs_ax;
struct agentx_context *axc, *taxc;
TAILQ_FOREACH_SAFE(axc, &(axs->axs_contexts), axc_axs_contexts, taxc)
agentx_context_free_finalize(axc);
if (!TAILQ_EMPTY(&(axs->axs_contexts)) ||
axs->axs_cstate != AX_CSTATE_CLOSE ||
axs->axs_dstate != AX_DSTATE_CLOSE)
return;
TAILQ_REMOVE(&(ax->ax_sessions), axs, axs_ax_sessions);
free(axs->axs_descr.aos_string);
free(axs);
}
static void
agentx_session_reset(struct agentx_session *axs)
{
struct agentx_context *axc, *taxc;
struct agentx *ax = axs->axs_ax;
int axfree = ax->ax_free;
ax->ax_free = 1;
axs->axs_cstate = AX_CSTATE_CLOSE;
TAILQ_FOREACH_SAFE(axc, &(axs->axs_contexts), axc_axs_contexts, taxc)
agentx_context_reset(axc);
if (!axfree)
agentx_free_finalize(ax);
}
struct agentx_context *
agentx_context(struct agentx_session *axs, const char *name)
{
struct agentx_context *axc;
if (axs->axs_dstate == AX_DSTATE_CLOSE)
agentx_log_axs_fatalx(axs, "%s: use after free", __func__);
if ((axc = calloc(1, sizeof(*axc))) == NULL)
return NULL;
axc->axc_axs = axs;
axc->axc_name_default = (name == NULL);
if (name != NULL) {
axc->axc_name.aos_string = (unsigned char *)strdup(name);
if (axc->axc_name.aos_string == NULL) {
free(axc);
return NULL;
}
axc->axc_name.aos_slen = strlen(name);
}
axc->axc_cstate = axs->axs_cstate == AX_CSTATE_OPEN ?
AX_CSTATE_OPEN : AX_CSTATE_CLOSE;
axc->axc_dstate = AX_DSTATE_OPEN;
TAILQ_INIT(&(axc->axc_agentcaps));
TAILQ_INIT(&(axc->axc_regions));
TAILQ_INSERT_HEAD(&(axs->axs_contexts), axc, axc_axs_contexts);
return axc;
}
static int
agentx_context_retry(struct agentx_context *axc)
{
struct agentx_agentcaps *axa;
struct agentx_region *axr;
#ifdef AX_DEBUG
if (axc->axc_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc, "%s: unexpected retry", __func__);
#endif
TAILQ_FOREACH(axa, &(axc->axc_agentcaps), axa_axc_agentcaps) {
if (axa->axa_cstate == AX_CSTATE_CLOSE) {
if (agentx_agentcaps_start(axa) == -1)
return -1;
}
}
TAILQ_FOREACH(axr, &(axc->axc_regions), axr_axc_regions) {
if (axr->axr_cstate == AX_CSTATE_OPEN) {
if (agentx_region_retry(axr) == -1)
return -1;
} else if (axr->axr_cstate == AX_CSTATE_CLOSE) {
if (agentx_region_start(axr) == -1)
return -1;
}
}
return 0;
}
static void
agentx_context_start(struct agentx_context *axc)
{
struct agentx_agentcaps *axa;
struct agentx_region *axr;
#ifdef AX_DEBUG
if (axc->axc_cstate != AX_CSTATE_CLOSE)
agentx_log_axc_fatalx(axc, "%s: unexpected context start",
__func__);
#endif
axc->axc_cstate = AX_CSTATE_OPEN;
TAILQ_FOREACH(axa, &(axc->axc_agentcaps), axa_axc_agentcaps) {
if (agentx_agentcaps_start(axa) == -1)
return;
}
TAILQ_FOREACH(axr, &(axc->axc_regions), axr_axc_regions) {
if (agentx_region_start(axr) == -1)
return;
}
}
uint32_t
agentx_context_uptime(struct agentx_context *axc)
{
struct timespec cur, res;
if (axc->axc_sysuptimespec.tv_sec == 0 &&
axc->axc_sysuptimespec.tv_nsec == 0)
return 0;
(void) clock_gettime(CLOCK_MONOTONIC, &cur);
timespecsub(&cur, &(axc->axc_sysuptimespec), &res);
return axc->axc_sysuptime +
(uint32_t) ((res.tv_sec * 100) + (res.tv_nsec / 10000000));
}
struct agentx_object *
agentx_context_object_find(struct agentx_context *axc,
const uint32_t oid[], size_t oidlen, int active, int instance)
{
struct agentx_object *axo, axo_search;
const char *errstr;
if (agentx_oidfill(&(axo_search.axo_oid), oid, oidlen, &errstr) == -1) {
if (oidlen > AGENTX_OID_MIN_LEN) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axc, "%s: %s", __func__, errstr);
return NULL;
}
#endif
if (oidlen == 1)
axo_search.axo_oid.aoi_id[0] = oid[0];
axo_search.axo_oid.aoi_idlen = oidlen;
}
axo = RB_FIND(axc_objects, &(axc->axc_objects), &axo_search);
while (axo == NULL && !instance && axo_search.axo_oid.aoi_idlen > 0) {
axo = RB_FIND(axc_objects, &(axc->axc_objects), &axo_search);
axo_search.axo_oid.aoi_idlen--;
}
if (active && axo != NULL && axo->axo_cstate != AX_CSTATE_OPEN)
return NULL;
return axo;
}
struct agentx_object *
agentx_context_object_nfind(struct agentx_context *axc,
const uint32_t oid[], size_t oidlen, int active, int inclusive)
{
struct agentx_object *axo, axo_search;
const char *errstr;
if (agentx_oidfill(&(axo_search.axo_oid), oid, oidlen, &errstr) == -1) {
if (oidlen > AGENTX_OID_MIN_LEN) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
if (oidlen == 1)
axo_search.axo_oid.aoi_id[0] = oid[0];
axo_search.axo_oid.aoi_idlen = oidlen;
}
axo = RB_NFIND(axc_objects, &(axc->axc_objects), &axo_search);
if (!inclusive && axo != NULL &&
ax_oid_cmp(&(axo->axo_oid), &(axo_search.axo_oid)) <= 0) {
axo = RB_NEXT(axc_objects, &(axc->axc_objects), axo);
}
while (active && axo != NULL && axo->axo_cstate != AX_CSTATE_OPEN)
axo = RB_NEXT(axc_objects, &(axc->axc_objects), axo);
return axo;
}
void
agentx_context_free(struct agentx_context *axc)
{
struct agentx_agentcaps *axa, *taxa;
struct agentx_region *axr, *taxr;
if (axc == NULL)
return;
#ifdef AX_DEBUG
if (axc->axc_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axc, "%s: double free", __func__);
#endif
axc->axc_dstate = AX_DSTATE_CLOSE;
TAILQ_FOREACH_SAFE(axa, &(axc->axc_agentcaps), axa_axc_agentcaps,
taxa) {
if (axa->axa_dstate != AX_DSTATE_CLOSE)
agentx_agentcaps_free(axa);
}
TAILQ_FOREACH_SAFE(axr, &(axc->axc_regions), axr_axc_regions, taxr) {
if (axr->axr_dstate != AX_DSTATE_CLOSE)
agentx_region_free(axr);
}
}
static void
agentx_context_free_finalize(struct agentx_context *axc)
{
struct agentx_session *axs = axc->axc_axs;
struct agentx_region *axr, *taxr;
struct agentx_agentcaps *axa, *taxa;
TAILQ_FOREACH_SAFE(axa, &(axc->axc_agentcaps), axa_axc_agentcaps, taxa)
agentx_agentcaps_free_finalize(axa);
TAILQ_FOREACH_SAFE(axr, &(axc->axc_regions), axr_axc_regions, taxr)
agentx_region_free_finalize(axr);
if (!TAILQ_EMPTY(&(axc->axc_regions)) ||
!TAILQ_EMPTY(&(axc->axc_agentcaps)) ||
axc->axc_cstate != AX_CSTATE_CLOSE ||
axc->axc_dstate != AX_DSTATE_CLOSE)
return;
TAILQ_REMOVE(&(axs->axs_contexts), axc, axc_axs_contexts);
free(axc->axc_name.aos_string);
free(axc);
}
static void
agentx_context_reset(struct agentx_context *axc)
{
struct agentx_agentcaps *axa, *taxa;
struct agentx_region *axr, *taxr;
struct agentx *ax = axc->axc_axs->axs_ax;
int axfree = ax->ax_free;
ax->ax_free = 1;
axc->axc_cstate = AX_CSTATE_CLOSE;
axc->axc_sysuptimespec.tv_sec = 0;
axc->axc_sysuptimespec.tv_nsec = 0;
TAILQ_FOREACH_SAFE(axa, &(axc->axc_agentcaps), axa_axc_agentcaps, taxa)
agentx_agentcaps_reset(axa);
TAILQ_FOREACH_SAFE(axr, &(axc->axc_regions), axr_axc_regions, taxr)
agentx_region_reset(axr);
if (!axfree)
agentx_free_finalize(ax);
}
struct agentx_agentcaps *
agentx_agentcaps(struct agentx_context *axc, uint32_t oid[],
size_t oidlen, const char *descr)
{
struct agentx_agentcaps *axa;
const char *errstr;
if (axc->axc_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axc, "%s: use after free", __func__);
if ((axa = calloc(1, sizeof(*axa))) == NULL)
return NULL;
axa->axa_axc = axc;
if (agentx_oidfill(&(axa->axa_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axc, "%s: %s", __func__, errstr);
free(axa);
return NULL;
#endif
}
axa->axa_descr.aos_string = (unsigned char *)strdup(descr);
if (axa->axa_descr.aos_string == NULL) {
free(axa);
return NULL;
}
axa->axa_descr.aos_slen = strlen(descr);
axa->axa_cstate = AX_CSTATE_CLOSE;
axa->axa_dstate = AX_DSTATE_OPEN;
TAILQ_INSERT_TAIL(&(axc->axc_agentcaps), axa, axa_axc_agentcaps);
if (axc->axc_cstate == AX_CSTATE_OPEN)
agentx_agentcaps_start(axa);
return axa;
}
static int
agentx_agentcaps_start(struct agentx_agentcaps *axa)
{
struct agentx_context *axc = axa->axa_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axc->axc_cstate != AX_CSTATE_OPEN ||
axa->axa_cstate != AX_CSTATE_CLOSE ||
axa->axa_dstate != AX_DSTATE_OPEN)
agentx_log_axc_fatalx(axc,
"%s: unexpected region registration", __func__);
#endif
packetid = ax_addagentcaps(ax->ax_ax, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), &(axa->axa_oid), &(axa->axa_descr));
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_ADDAGENTCAPS));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "agentcaps %s: opening",
ax_oid2string(&(axa->axa_oid)));
axa->axa_cstate = AX_CSTATE_WAITOPEN;
return agentx_request(ax, packetid, agentx_agentcaps_finalize,
axa);
}
static int
agentx_agentcaps_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_agentcaps *axa = cookie;
struct agentx_context *axc = axa->axa_axc;
#ifdef AX_DEBUG
if (axa->axa_cstate != AX_CSTATE_WAITOPEN)
agentx_log_axc_fatalx(axc,
"%s: not expecting agentcaps open", __func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_axc_warn(axc, "agentcaps %s: %s",
ax_oid2string(&(axa->axa_oid)),
ax_error2string(pdu->ap_payload.ap_response.ap_error));
axa->axa_cstate = AX_CSTATE_CLOSE;
return 0;
}
axa->axa_cstate = AX_CSTATE_OPEN;
agentx_log_axc_info(axc, "agentcaps %s: open",
ax_oid2string(&(axa->axa_oid)));
if (axa->axa_dstate == AX_DSTATE_CLOSE)
agentx_agentcaps_close(axa);
return 0;
}
static int
agentx_agentcaps_close(struct agentx_agentcaps *axa)
{
struct agentx_context *axc = axa->axa_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axa->axa_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc, "%s: unexpected agentcaps close",
__func__);
#endif
axa->axa_cstate = AX_CSTATE_WAITCLOSE;
if (axs->axs_cstate == AX_CSTATE_WAITCLOSE)
return 0;
packetid = ax_removeagentcaps(ax->ax_ax, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), &(axa->axa_oid));
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_REMOVEAGENTCAPS));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "agentcaps %s: closing",
ax_oid2string(&(axa->axa_oid)));
return agentx_request(ax, packetid,
agentx_agentcaps_close_finalize, axa);
}
static int
agentx_agentcaps_close_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_agentcaps *axa = cookie;
struct agentx_context *axc = axa->axa_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
int axfree = ax->ax_free;
#ifdef AX_DEBUG
if (axa->axa_cstate != AX_CSTATE_WAITCLOSE)
agentx_log_axc_fatalx(axc, "%s: unexpected agentcaps close",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_axc_warnx(axc, "agentcaps %s: %s",
ax_oid2string(&(axa->axa_oid)),
ax_error2string(pdu->ap_payload.ap_response.ap_error));
agentx_reset(ax);
return -1;
}
axa->axa_cstate = AX_CSTATE_CLOSE;
ax->ax_free = 1;
agentx_log_axc_info(axc, "agentcaps %s: closed",
ax_oid2string(&(axa->axa_oid)));
if (axc->axc_cstate == AX_CSTATE_OPEN &&
axa->axa_dstate == AX_DSTATE_OPEN)
agentx_agentcaps_start(axa);
if (!axfree)
agentx_free_finalize(ax);
return 0;
}
void
agentx_agentcaps_free(struct agentx_agentcaps *axa)
{
struct agentx *ax;
int axfree;
if (axa == NULL)
return;
ax = axa->axa_axc->axc_axs->axs_ax;
axfree = ax->ax_free;
ax->ax_free = 1;
if (axa->axa_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axa->axa_axc, "%s: double free",
__func__);
axa->axa_dstate = AX_DSTATE_CLOSE;
if (axa->axa_cstate == AX_CSTATE_OPEN)
agentx_agentcaps_close(axa);
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_agentcaps_free_finalize(struct agentx_agentcaps *axa)
{
struct agentx_context *axc = axa->axa_axc;
if (axa->axa_dstate != AX_DSTATE_CLOSE ||
axa->axa_cstate != AX_CSTATE_CLOSE)
return;
TAILQ_REMOVE(&(axc->axc_agentcaps), axa, axa_axc_agentcaps);
free(axa->axa_descr.aos_string);
free(axa);
}
static void
agentx_agentcaps_reset(struct agentx_agentcaps *axa)
{
struct agentx *ax = axa->axa_axc->axc_axs->axs_ax;
axa->axa_cstate = AX_CSTATE_CLOSE;
if (!ax->ax_free)
agentx_free_finalize(ax);
}
struct agentx_region *
agentx_region(struct agentx_context *axc, uint32_t oid[],
size_t oidlen, uint8_t timeout)
{
struct agentx_region *axr;
struct ax_oid tmpoid;
const char *errstr;
if (axc->axc_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axc, "%s: use after free", __func__);
if (agentx_oidfill(&tmpoid, oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axc, "%s: %s", __func__, errstr);
#else
return NULL;
#endif
}
TAILQ_FOREACH(axr, &(axc->axc_regions), axr_axc_regions) {
if (ax_oid_cmp(&(axr->axr_oid), &tmpoid) == 0) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axc,
"%s: duplicate region registration", __func__);
#else
errno = EINVAL;
return NULL;
#endif
}
}
if ((axr = calloc(1, sizeof(*axr))) == NULL)
return NULL;
axr->axr_axc = axc;
axr->axr_timeout = timeout;
axr->axr_priority = AX_PRIORITY_DEFAULT;
bcopy(&tmpoid, &(axr->axr_oid), sizeof(axr->axr_oid));
axr->axr_cstate = AX_CSTATE_CLOSE;
axr->axr_dstate = AX_DSTATE_OPEN;
TAILQ_INIT(&(axr->axr_indices));
TAILQ_INIT(&(axr->axr_objects));
TAILQ_INSERT_HEAD(&(axc->axc_regions), axr, axr_axc_regions);
if (axc->axc_cstate == AX_CSTATE_OPEN)
(void) agentx_region_start(axr);
return axr;
}
static int
agentx_region_retry(struct agentx_region *axr)
{
struct agentx_index *axi;
struct agentx_object *axo;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axr->axr_axc,
"%s: unexpected retry", __func__);
#endif
TAILQ_FOREACH(axi, &(axr->axr_indices), axi_axr_indices) {
if (axi->axi_cstate == AX_CSTATE_CLOSE) {
if (agentx_index_start(axi) == -1)
return -1;
}
}
TAILQ_FOREACH(axo, &(axr->axr_objects), axo_axr_objects) {
if (axo->axo_cstate == AX_CSTATE_CLOSE) {
if (agentx_object_start(axo) == -1)
return -1;
}
}
return 0;
}
static int
agentx_region_start(struct agentx_region *axr)
{
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axc->axc_cstate != AX_CSTATE_OPEN ||
axr->axr_cstate != AX_CSTATE_CLOSE ||
axr->axr_dstate != AX_DSTATE_OPEN)
agentx_log_axc_fatalx(axc,
"%s: unexpected region registration", __func__);
#endif
packetid = ax_register(ax->ax_ax, 0, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), axr->axr_timeout, axr->axr_priority,
0, &(axr->axr_oid), 0);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_REGISTER));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "region %s: opening",
ax_oid2string(&(axr->axr_oid)));
axr->axr_cstate = AX_CSTATE_WAITOPEN;
return agentx_request(ax, packetid, agentx_region_finalize, axr);
}
static int
agentx_region_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_region *axr = cookie;
struct agentx_context *axc = axr->axr_axc;
struct agentx_index *axi;
struct agentx_object *axo;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_WAITOPEN)
agentx_log_axc_fatalx(axc, "%s: not expecting region open",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error == AX_PDU_ERROR_NOERROR) {
axr->axr_cstate = AX_CSTATE_OPEN;
agentx_log_axc_info(axc, "region %s: open",
ax_oid2string(&(axr->axr_oid)));
} else if (pdu->ap_payload.ap_response.ap_error ==
AX_PDU_ERROR_DUPLICATEREGISTRATION) {
axr->axr_cstate = AX_CSTATE_CLOSE;
if ((++axr->axr_priority) != 0) {
agentx_log_axc_warnx(axc, "region %s: duplicate, "
"reducing priority",
ax_oid2string(&(axr->axr_oid)));
return agentx_region_start(axr);
}
agentx_log_axc_info(axc, "region %s: duplicate, can't "
"reduce priority, ignoring",
ax_oid2string(&(axr->axr_oid)));
} else {
axr->axr_cstate = AX_CSTATE_CLOSE;
agentx_log_axc_warnx(axc, "region %s: %s",
ax_oid2string(&(axr->axr_oid)),
ax_error2string(pdu->ap_payload.ap_response.ap_error));
return -1;
}
if (axr->axr_dstate == AX_DSTATE_CLOSE) {
if (agentx_region_close(axr) == -1)
return -1;
} else {
TAILQ_FOREACH(axi, &(axr->axr_indices), axi_axr_indices) {
if (agentx_index_start(axi) == -1)
return -1;
}
TAILQ_FOREACH(axo, &(axr->axr_objects), axo_axr_objects) {
if (agentx_object_start(axo) == -1)
return -1;
}
}
return 0;
}
static int
agentx_region_close(struct agentx_region *axr)
{
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc, "%s: unexpected region close",
__func__);
#endif
axr->axr_cstate = AX_CSTATE_WAITCLOSE;
if (axs->axs_cstate == AX_CSTATE_WAITCLOSE)
return 0;
packetid = ax_unregister(ax->ax_ax, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), axr->axr_priority, 0, &(axr->axr_oid),
0);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_UNREGISTER));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "region %s: closing",
ax_oid2string(&(axr->axr_oid)));
return agentx_request(ax, packetid, agentx_region_close_finalize,
axr);
}
static int
agentx_region_close_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_region *axr = cookie;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
int axfree = ax->ax_free;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_WAITCLOSE)
agentx_log_axc_fatalx(axc, "%s: unexpected region close",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_axc_warnx(axc, "closing %s: %s",
ax_oid2string(&(axr->axr_oid)),
ax_error2string(pdu->ap_payload.ap_response.ap_error));
agentx_reset(ax);
return -1;
}
ax->ax_free = 1;
axr->axr_priority = AX_PRIORITY_DEFAULT;
axr->axr_cstate = AX_CSTATE_CLOSE;
agentx_log_axc_info(axc, "region %s: closed",
ax_oid2string(&(axr->axr_oid)));
if (axc->axc_cstate == AX_CSTATE_OPEN &&
axr->axr_dstate == AX_DSTATE_OPEN)
agentx_region_start(axr);
if (!axfree)
agentx_free_finalize(ax);
return 0;
}
void
agentx_region_free(struct agentx_region *axr)
{
struct agentx_index *axi, *taxi;
struct agentx_object *axo, *taxo;
struct agentx *ax;
int axfree;
if (axr == NULL)
return;
ax = axr->axr_axc->axc_axs->axs_ax;
axfree = ax->ax_free;
ax->ax_free = 1;
if (axr->axr_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axr->axr_axc, "%s: double free",
__func__);
axr->axr_dstate = AX_DSTATE_CLOSE;
TAILQ_FOREACH_SAFE(axi, &(axr->axr_indices), axi_axr_indices, taxi) {
if (axi->axi_dstate != AX_DSTATE_CLOSE)
agentx_index_free(axi);
}
TAILQ_FOREACH_SAFE(axo, &(axr->axr_objects), axo_axr_objects, taxo) {
if (axo->axo_dstate != AX_DSTATE_CLOSE)
agentx_object_free(axo);
}
if (axr->axr_cstate == AX_CSTATE_OPEN)
agentx_region_close(axr);
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_region_free_finalize(struct agentx_region *axr)
{
struct agentx_context *axc = axr->axr_axc;
struct agentx_index *axi, *taxi;
struct agentx_object *axo, *taxo;
TAILQ_FOREACH_SAFE(axo, &(axr->axr_objects), axo_axr_objects, taxo)
agentx_object_free_finalize(axo);
TAILQ_FOREACH_SAFE(axi, &(axr->axr_indices), axi_axr_indices, taxi)
agentx_index_free_finalize(axi);
if (!TAILQ_EMPTY(&(axr->axr_indices)) ||
!TAILQ_EMPTY(&(axr->axr_objects)) ||
axr->axr_cstate != AX_CSTATE_CLOSE ||
axr->axr_dstate != AX_DSTATE_CLOSE)
return;
TAILQ_REMOVE(&(axc->axc_regions), axr, axr_axc_regions);
free(axr);
}
static void
agentx_region_reset(struct agentx_region *axr)
{
struct agentx_index *axi, *taxi;
struct agentx_object *axo, *taxo;
struct agentx *ax = axr->axr_axc->axc_axs->axs_ax;
int axfree = ax->ax_free;
axr->axr_cstate = AX_CSTATE_CLOSE;
axr->axr_priority = AX_PRIORITY_DEFAULT;
ax->ax_free = 1;
TAILQ_FOREACH_SAFE(axi, &(axr->axr_indices), axi_axr_indices, taxi)
agentx_index_reset(axi);
TAILQ_FOREACH_SAFE(axo, &(axr->axr_objects), axo_axr_objects, taxo)
agentx_object_reset(axo);
if (!axfree)
agentx_free_finalize(ax);
}
struct agentx_index *
agentx_index_integer_new(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_INTEGER;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_int32 = 0;
return agentx_index(axr, &vb, AXI_TYPE_NEW);
}
struct agentx_index *
agentx_index_integer_any(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_INTEGER;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_int32 = 0;
return agentx_index(axr, &vb, AXI_TYPE_ANY);
}
struct agentx_index *
agentx_index_integer_value(struct agentx_region *axr, uint32_t oid[],
size_t oidlen, int32_t value)
{
struct ax_varbind vb;
const char *errstr;
if (value < 0) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: value < 0", __func__);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: value < 0", __func__);
errno = EINVAL;
return NULL;
#endif
}
vb.avb_type = AX_DATA_TYPE_INTEGER;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_int32 = value;
return agentx_index(axr, &vb, AXI_TYPE_VALUE);
}
struct agentx_index *
agentx_index_integer_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_INTEGER;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
struct agentx_index *
agentx_index_string_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_OCTETSTRING;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_ostring.aos_slen = 0;
vb.avb_data.avb_ostring.aos_string = NULL;
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
struct agentx_index *
agentx_index_nstring_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen, size_t vlen)
{
struct ax_varbind vb;
const char *errstr;
if (vlen == 0 || vlen > AGENTX_OID_MAX_LEN) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: invalid string "
"length: %zu\n", __func__, vlen);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: invalid string "
"length: %zu\n", __func__, vlen);
errno = EINVAL;
return NULL;
#endif
}
vb.avb_type = AX_DATA_TYPE_OCTETSTRING;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_ostring.aos_slen = vlen;
vb.avb_data.avb_ostring.aos_string = NULL;
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
struct agentx_index *
agentx_index_oid_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_OID;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_oid.aoi_idlen = 0;
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
struct agentx_index *
agentx_index_noid_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen, size_t vlen)
{
struct ax_varbind vb;
const char *errstr;
if (vlen < AGENTX_OID_MIN_LEN || vlen > AGENTX_OID_MAX_LEN) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: invalid string "
"length: %zu\n", __func__, vlen);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: invalid string "
"length: %zu\n", __func__, vlen);
errno = EINVAL;
return NULL;
#endif
}
vb.avb_type = AX_DATA_TYPE_OID;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_oid.aoi_idlen = vlen;
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
struct agentx_index *
agentx_index_ipaddress_dynamic(struct agentx_region *axr, uint32_t oid[],
size_t oidlen)
{
struct ax_varbind vb;
const char *errstr;
vb.avb_type = AX_DATA_TYPE_IPADDRESS;
if (agentx_oidfill(&(vb.avb_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
vb.avb_data.avb_ostring.aos_string = NULL;
return agentx_index(axr, &vb, AXI_TYPE_DYNAMIC);
}
static struct agentx_index *
agentx_index(struct agentx_region *axr, struct ax_varbind *vb,
enum agentx_index_type type)
{
struct agentx_index *axi;
if (axr->axr_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axr->axr_axc, "%s: use after free",
__func__);
if (ax_oid_cmp(&(axr->axr_oid), &(vb->avb_oid)) != -2) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: oid is not child "
"of region %s", __func__,
ax_oid2string(&(vb->avb_oid)));
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: oid is not child of "
"region %s", __func__, ax_oid2string(&(vb->avb_oid)));
errno = EINVAL;
return NULL;
#endif
}
if ((axi = calloc(1, sizeof(*axi))) == NULL)
return NULL;
axi->axi_axr = axr;
axi->axi_type = type;
bcopy(vb, &(axi->axi_vb), sizeof(*vb));
axi->axi_cstate = AX_CSTATE_CLOSE;
axi->axi_dstate = AX_DSTATE_OPEN;
TAILQ_INSERT_HEAD(&(axr->axr_indices), axi, axi_axr_indices);
if (axr->axr_cstate == AX_CSTATE_OPEN)
agentx_index_start(axi);
return axi;
}
static int
agentx_index_start(struct agentx_index *axi)
{
struct agentx_region *axr = axi->axi_axr;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
int flags = 0;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_OPEN ||
axi->axi_cstate != AX_CSTATE_CLOSE ||
axi->axi_dstate != AX_DSTATE_OPEN)
agentx_log_axc_fatalx(axc, "%s: unexpected index allocation",
__func__);
#endif
axi->axi_cstate = AX_CSTATE_WAITOPEN;
if (axi->axi_type == AXI_TYPE_NEW)
flags = AX_PDU_FLAG_NEW_INDEX;
else if (axi->axi_type == AXI_TYPE_ANY)
flags = AX_PDU_FLAG_ANY_INDEX;
else if (axi->axi_type == AXI_TYPE_DYNAMIC) {
agentx_index_finalize(NULL, axi);
return 0;
}
packetid = ax_indexallocate(ax->ax_ax, flags, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), &(axi->axi_vb), 1);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_INDEXDEALLOCATE));
agentx_reset(ax);
return -1;
}
if (axi->axi_type == AXI_TYPE_VALUE)
agentx_log_axc_info(axc, "index %s: allocating '%d'",
ax_oid2string(&(axi->axi_vb.avb_oid)),
axi->axi_vb.avb_data.avb_int32);
else if (axi->axi_type == AXI_TYPE_ANY)
agentx_log_axc_info(axc, "index %s: allocating any index",
ax_oid2string(&(axi->axi_vb.avb_oid)));
else if (axi->axi_type == AXI_TYPE_NEW)
agentx_log_axc_info(axc, "index %s: allocating new index",
ax_oid2string(&(axi->axi_vb.avb_oid)));
return agentx_request(ax, packetid, agentx_index_finalize, axi);
}
static int
agentx_index_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_index *axi = cookie;
struct agentx_region *axr = axi->axi_axr;
struct agentx_context *axc = axr->axr_axc;
struct ax_pdu_response *resp;
size_t i;
#ifdef AX_DEBUG
if (axi->axi_cstate != AX_CSTATE_WAITOPEN)
agentx_log_axc_fatalx(axc,
"%s: not expecting index allocate", __func__);
#endif
if (axi->axi_type == AXI_TYPE_DYNAMIC) {
axi->axi_cstate = AX_CSTATE_OPEN;
goto objects_start;
}
resp = &(pdu->ap_payload.ap_response);
if (resp->ap_error != AX_PDU_ERROR_NOERROR) {
axi->axi_cstate = AX_CSTATE_CLOSE;
agentx_log_axc_warnx(axc, "index %s: %s",
ax_oid2string(&(axr->axr_oid)),
ax_error2string(resp->ap_error));
return 0;
}
axi->axi_cstate = AX_CSTATE_OPEN;
if (resp->ap_nvarbind != 1) {
agentx_log_axc_warnx(axc, "index %s: unexpected number of "
"indices", ax_oid2string(&(axr->axr_oid)));
axi->axi_cstate = AX_CSTATE_CLOSE;
return -1;
}
if (resp->ap_varbindlist[0].avb_type != axi->axi_vb.avb_type) {
agentx_log_axc_warnx(axc, "index %s: unexpected index type",
ax_oid2string(&(axr->axr_oid)));
axi->axi_cstate = AX_CSTATE_CLOSE;
return -1;
}
if (ax_oid_cmp(&(resp->ap_varbindlist[0].avb_oid),
&(axi->axi_vb.avb_oid)) != 0) {
agentx_log_axc_warnx(axc, "index %s: unexpected oid",
ax_oid2string(&(axr->axr_oid)));
axi->axi_cstate = AX_CSTATE_CLOSE;
return -1;
}
switch (axi->axi_vb.avb_type) {
case AX_DATA_TYPE_INTEGER:
if (axi->axi_type == AXI_TYPE_NEW ||
axi->axi_type == AXI_TYPE_ANY)
axi->axi_vb.avb_data.avb_int32 =
resp->ap_varbindlist[0].avb_data.avb_int32;
else if (axi->axi_vb.avb_data.avb_int32 !=
resp->ap_varbindlist[0].avb_data.avb_int32) {
agentx_log_axc_warnx(axc, "index %s: unexpected "
"index value", ax_oid2string(&(axr->axr_oid)));
axi->axi_cstate = AX_CSTATE_CLOSE;
return -1;
}
agentx_log_axc_info(axc, "index %s: allocated '%d'",
ax_oid2string(&(axi->axi_vb.avb_oid)),
axi->axi_vb.avb_data.avb_int32);
break;
default:
agentx_log_axc_fatalx(axc, "%s: Unsupported index type",
__func__);
}
if (axi->axi_dstate == AX_DSTATE_CLOSE)
return agentx_index_close(axi);
objects_start:
for (i = 0; i < axi->axi_objectlen; i++) {
if (axi->axi_object[i]->axo_dstate == AX_DSTATE_OPEN) {
if (agentx_object_start(axi->axi_object[i]) == -1)
return -1;
}
}
return 0;
}
void
agentx_index_free(struct agentx_index *axi)
{
size_t i;
struct agentx_object *axo;
struct agentx *ax;
int axfree;
if (axi == NULL)
return;
ax = axi->axi_axr->axr_axc->axc_axs->axs_ax;
axfree = ax->ax_free;
ax->ax_free = 1;
if (axi->axi_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axi->axi_axr->axr_axc,
"%s: double free", __func__);
for (i = 0; i < axi->axi_objectlen; i++) {
axo = axi->axi_object[i];
if (axo->axo_dstate != AX_DSTATE_CLOSE) {
agentx_object_free(axo);
if (axi->axi_object[i] != axo)
i--;
}
}
axi->axi_dstate = AX_DSTATE_CLOSE;
if (axi->axi_cstate == AX_CSTATE_OPEN)
(void) agentx_index_close(axi);
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_index_free_finalize(struct agentx_index *axi)
{
struct agentx_region *axr = axi->axi_axr;
if (axi->axi_cstate != AX_CSTATE_CLOSE ||
axi->axi_dstate != AX_DSTATE_CLOSE ||
axi->axi_objectlen != 0)
return;
TAILQ_REMOVE(&(axr->axr_indices), axi, axi_axr_indices);
ax_varbind_free(&(axi->axi_vb));
free(axi->axi_object);
free(axi);
}
static void
agentx_index_reset(struct agentx_index *axi)
{
struct agentx *ax = axi->axi_axr->axr_axc->axc_axs->axs_ax;
axi->axi_cstate = AX_CSTATE_CLOSE;
if (!ax->ax_free)
agentx_free_finalize(ax);
}
static int
agentx_index_close(struct agentx_index *axi)
{
struct agentx_region *axr = axi->axi_axr;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
uint32_t packetid;
#ifdef AX_DEBUG
if (axi->axi_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc,
"%s: unexpected index deallocation", __func__);
#endif
axi->axi_cstate = AX_CSTATE_WAITCLOSE;
if (axs->axs_cstate == AX_CSTATE_WAITCLOSE)
return 0;
packetid = ax_indexdeallocate(ax->ax_ax, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), &(axi->axi_vb), 1);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_INDEXDEALLOCATE));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "index %s: deallocating",
ax_oid2string(&(axi->axi_vb.avb_oid)));
return agentx_request(ax, packetid, agentx_index_close_finalize,
axi);
}
static int
agentx_index_close_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_index *axi = cookie;
struct agentx_region *axr = axi->axi_axr;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
struct ax_pdu_response *resp = &(pdu->ap_payload.ap_response);
int axfree = ax->ax_free;
#ifdef AX_DEBUG
if (axi->axi_cstate != AX_CSTATE_WAITCLOSE)
agentx_log_axc_fatalx(axc, "%s: unexpected indexdeallocate",
__func__);
#endif
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
agentx_log_axc_warnx(axc,
"index %s: couldn't deallocate: %s",
ax_oid2string(&(axi->axi_vb.avb_oid)),
ax_error2string(resp->ap_error));
agentx_reset(ax);
return -1;
}
if (resp->ap_nvarbind != 1) {
agentx_log_axc_warnx(axc,
"index %s: unexpected number of indices",
ax_oid2string(&(axr->axr_oid)));
agentx_reset(ax);
return -1;
}
if (resp->ap_varbindlist[0].avb_type != axi->axi_vb.avb_type) {
agentx_log_axc_warnx(axc, "index %s: unexpected index type",
ax_oid2string(&(axr->axr_oid)));
agentx_reset(ax);
return -1;
}
if (ax_oid_cmp(&(resp->ap_varbindlist[0].avb_oid),
&(axi->axi_vb.avb_oid)) != 0) {
agentx_log_axc_warnx(axc, "index %s: unexpected oid",
ax_oid2string(&(axr->axr_oid)));
agentx_reset(ax);
return -1;
}
switch (axi->axi_vb.avb_type) {
case AX_DATA_TYPE_INTEGER:
if (axi->axi_vb.avb_data.avb_int32 !=
resp->ap_varbindlist[0].avb_data.avb_int32) {
agentx_log_axc_warnx(axc,
"index %s: unexpected index value",
ax_oid2string(&(axr->axr_oid)));
agentx_reset(ax);
return -1;
}
break;
default:
agentx_log_axc_fatalx(axc, "%s: Unsupported index type",
__func__);
}
axi->axi_cstate = AX_CSTATE_CLOSE;
ax->ax_free = 1;
agentx_log_axc_info(axc, "index %s: deallocated",
ax_oid2string(&(axi->axi_vb.avb_oid)));
if (axr->axr_cstate == AX_CSTATE_OPEN &&
axi->axi_dstate == AX_DSTATE_OPEN)
agentx_index_start(axi);
if (!axfree)
agentx_free_finalize(ax);
return 0;
}
struct agentx_object *
agentx_object(struct agentx_region *axr, uint32_t oid[], size_t oidlen,
struct agentx_index *axi[], size_t axilen, int implied,
void (*get)(struct agentx_varbind *))
{
struct agentx_object *axo, **taxo, axo_search;
struct agentx_index *laxi;
const char *errstr;
int ready = 1;
size_t i, j;
if (axr->axr_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axr->axr_axc, "%s: use after free",
__func__);
if (axilen > AGENTX_OID_INDEX_MAX_LEN) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: indexlen > %d",
__func__, AGENTX_OID_INDEX_MAX_LEN);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: indexlen > %d",
__func__, AGENTX_OID_INDEX_MAX_LEN);
errno = EINVAL;
return NULL;
#endif
}
if (agentx_oidfill(&(axo_search.axo_oid), oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: %s", __func__, errstr);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: %s", __func__, errstr);
return NULL;
#endif
}
do {
if (RB_FIND(axc_objects, &(axr->axr_axc->axc_objects),
&axo_search) != NULL) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: invalid "
"parent child object relationship", __func__);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: invalid "
"parent child object relationship", __func__);
errno = EINVAL;
return NULL;
#endif
}
axo_search.axo_oid.aoi_idlen--;
} while (axo_search.axo_oid.aoi_idlen > 0);
axo_search.axo_oid.aoi_idlen = oidlen;
axo = RB_NFIND(axc_objects, &(axr->axr_axc->axc_objects), &axo_search);
if (axo != NULL &&
ax_oid_cmp(&(axo->axo_oid), &(axo_search.axo_oid)) == 2) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: invalid parent "
"child object relationship", __func__);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: invalid parent "
"child object relationship", __func__);
errno = EINVAL;
return NULL;
#endif
}
if (implied == 1) {
laxi = axi[axilen - 1];
if (laxi->axi_vb.avb_type == AX_DATA_TYPE_OCTETSTRING) {
if (laxi->axi_vb.avb_data.avb_ostring.aos_slen != 0) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc,
"%s: implied can only be used on strings "
"of dynamic length", __func__);
#else
agentx_log_axc_warnx(axr->axr_axc,
"%s: implied can only be used on strings "
"of dynamic length", __func__);
errno = EINVAL;
return NULL;
#endif
}
} else if (laxi->axi_vb.avb_type == AX_DATA_TYPE_OID) {
if (laxi->axi_vb.avb_data.avb_oid.aoi_idlen != 0) {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc,
"%s: implied can only be used on oids of "
"dynamic length", __func__);
#else
agentx_log_axc_warnx(axr->axr_axc,
"%s: implied can only be used on oids of "
"dynamic length", __func__);
errno = EINVAL;
return NULL;
#endif
}
} else {
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axr->axr_axc, "%s: implied "
"can only be set on oid and string indices",
__func__);
#else
agentx_log_axc_warnx(axr->axr_axc, "%s: implied can "
"only be set on oid and string indices", __func__);
errno = EINVAL;
return NULL;
#endif
}
}
ready = axr->axr_cstate == AX_CSTATE_OPEN;
if ((axo = calloc(1, sizeof(*axo))) == NULL)
return NULL;
axo->axo_axr = axr;
bcopy(&(axo_search.axo_oid), &(axo->axo_oid), sizeof(axo->axo_oid));
for (i = 0; i < axilen; i++) {
axo->axo_index[i] = axi[i];
if (axi[i]->axi_objectlen == axi[i]->axi_objectsize) {
taxo = recallocarray(axi[i]->axi_object,
axi[i]->axi_objectlen, axi[i]->axi_objectlen + 1,
sizeof(*axi[i]->axi_object));
if (taxo == NULL) {
free(axo);
return NULL;
}
axi[i]->axi_object = taxo;
axi[i]->axi_objectsize = axi[i]->axi_objectlen + 1;
}
for (j = 0; j < axi[i]->axi_objectlen; j++) {
if (ax_oid_cmp(&(axo->axo_oid),
&(axi[i]->axi_object[j]->axo_oid)) < 0) {
memmove(&(axi[i]->axi_object[j + 1]),
&(axi[i]->axi_object[j]),
sizeof(*(axi[i]->axi_object)) *
(axi[i]->axi_objectlen - j));
break;
}
}
axi[i]->axi_object[j] = axo;
axi[i]->axi_objectlen++;
if (axi[i]->axi_cstate != AX_CSTATE_OPEN)
ready = 0;
}
axo->axo_indexlen = axilen;
axo->axo_implied = implied;
axo->axo_timeout = 0;
axo->axo_lock = 0;
axo->axo_get = get;
axo->axo_cstate = AX_CSTATE_CLOSE;
axo->axo_dstate = AX_DSTATE_OPEN;
TAILQ_INSERT_TAIL(&(axr->axr_objects), axo, axo_axr_objects);
RB_INSERT(axc_objects, &(axr->axr_axc->axc_objects), axo);
if (ready)
agentx_object_start(axo);
return axo;
}
static int
agentx_object_start(struct agentx_object *axo)
{
struct agentx_region *axr = axo->axo_axr;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
struct ax_oid oid;
char oids[1024];
size_t i;
int needregister = 0;
uint32_t packetid;
uint8_t flags = AX_PDU_FLAG_INSTANCE_REGISTRATION;
#ifdef AX_DEBUG
if (axr->axr_cstate != AX_CSTATE_OPEN ||
axo->axo_cstate != AX_CSTATE_CLOSE ||
axo->axo_dstate != AX_DSTATE_OPEN)
agentx_log_axc_fatalx(axc,
"%s: unexpected object registration", __func__);
#endif
if (axo->axo_timeout != 0)
needregister = 1;
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i]->axi_cstate != AX_CSTATE_OPEN)
return 0;
if (axo->axo_index[i]->axi_type != AXI_TYPE_DYNAMIC)
needregister = 1;
}
if (!needregister) {
axo->axo_cstate = AX_CSTATE_WAITOPEN;
agentx_object_finalize(NULL, axo);
return 0;
}
bcopy(&(axo->axo_oid), &(oid), sizeof(oid));
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i]->axi_type == AXI_TYPE_DYNAMIC) {
flags = 0;
break;
}
#ifdef AX_DEBUG
if (axo->axo_index[i]->axi_vb.avb_type !=
AX_DATA_TYPE_INTEGER)
agentx_log_axc_fatalx(axc,
"%s: Unsupported allocated index type", __func__);
#endif
oid.aoi_id[oid.aoi_idlen++] =
axo->axo_index[i]->axi_vb.avb_data.avb_int32;
}
packetid = ax_register(ax->ax_ax, flags, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), axo->axo_timeout,
AX_PRIORITY_DEFAULT, 0, &oid, 0);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_REGISTER));
agentx_reset(ax);
return -1;
}
strlcpy(oids, ax_oid2string(&(axo->axo_oid)), sizeof(oids));
agentx_log_axc_info(axc, "object %s (%s %s): opening",
oids, flags ? "instance" : "region", ax_oid2string(&(oid)));
axo->axo_cstate = AX_CSTATE_WAITOPEN;
return agentx_request(ax, packetid, agentx_object_finalize, axo);
}
static int
agentx_object_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_object *axo = cookie;
struct agentx_context *axc = axo->axo_axr->axr_axc;
struct ax_oid oid;
char oids[1024];
size_t i;
uint8_t flags = 1;
#ifdef AX_DEBUG
if (axo->axo_cstate != AX_CSTATE_WAITOPEN)
agentx_log_axc_fatalx(axc, "%s: not expecting object open",
__func__);
#endif
if (pdu == NULL) {
axo->axo_cstate = AX_CSTATE_OPEN;
return 0;
}
bcopy(&(axo->axo_oid), &oid, sizeof(oid));
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i]->axi_type == AXI_TYPE_DYNAMIC) {
flags = 0;
break;
}
#ifdef AX_DEBUG
if (axo->axo_index[i]->axi_vb.avb_type !=
AX_DATA_TYPE_INTEGER)
agentx_log_axc_fatalx(axc,
"%s: Unsupported allocated index type", __func__);
#endif
oid.aoi_id[oid.aoi_idlen++] =
axo->axo_index[i]->axi_vb.avb_data.avb_int32;
}
strlcpy(oids, ax_oid2string(&(axo->axo_oid)), sizeof(oids));
if (pdu->ap_payload.ap_response.ap_error != AX_PDU_ERROR_NOERROR) {
axo->axo_cstate = AX_CSTATE_CLOSE;
agentx_log_axc_info(axc, "object %s (%s %s): %s",
oids, flags ? "instance" : "region", ax_oid2string(&oid),
ax_error2string(pdu->ap_payload.ap_response.ap_error));
return 0;
}
axo->axo_cstate = AX_CSTATE_OPEN;
agentx_log_axc_info(axc, "object %s (%s %s): open", oids,
flags ? "instance" : "region", ax_oid2string(&oid));
if (axo->axo_dstate == AX_DSTATE_CLOSE)
return agentx_object_close(axo);
return 0;
}
static int
agentx_object_lock(struct agentx_object *axo)
{
if (axo->axo_lock == UINT32_MAX) {
agentx_log_axc_warnx(axo->axo_axr->axr_axc,
"%s: axo_lock == %u", __func__, UINT32_MAX);
return -1;
}
axo->axo_lock++;
return 0;
}
static void
agentx_object_unlock(struct agentx_object *axo)
{
struct agentx *ax = axo->axo_axr->axr_axc->axc_axs->axs_ax;
#ifdef AX_DEBUG
if (axo->axo_lock == 0)
agentx_log_axc_fatalx(axo->axo_axr->axr_axc,
"%s: axo_lock == 0", __func__);
#endif
axo->axo_lock--;
if (axo->axo_lock == 0) {
if (!ax->ax_free)
agentx_free_finalize(ax);
}
}
static int
agentx_object_close(struct agentx_object *axo)
{
struct agentx_context *axc = axo->axo_axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
struct ax_oid oid;
char oids[1024];
size_t i;
int needclose = 0;
uint32_t packetid;
uint8_t flags = 1;
#ifdef AX_DEBUG
if (axo->axo_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc, "%s: unexpected object close",
__func__);
#endif
for (i = 0; i < axo->axo_indexlen; i++) {
#ifdef AX_DEBUG
if (axo->axo_index[i]->axi_cstate != AX_CSTATE_OPEN)
agentx_log_axc_fatalx(axc,
"%s: Object open while index closed", __func__);
#endif
if (axo->axo_index[i]->axi_type != AXI_TYPE_DYNAMIC)
needclose = 1;
}
axo->axo_cstate = AX_CSTATE_WAITCLOSE;
if (axs->axs_cstate == AX_CSTATE_WAITCLOSE)
return 0;
if (!needclose) {
agentx_object_close_finalize(NULL, axo);
return 0;
}
bcopy(&(axo->axo_oid), &(oid), sizeof(oid));
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i]->axi_type == AXI_TYPE_DYNAMIC) {
flags = 0;
break;
}
#ifdef AX_DEBUG
if (axo->axo_index[i]->axi_vb.avb_type !=
AX_DATA_TYPE_INTEGER)
agentx_log_axc_fatalx(axc,
"%s: Unsupported allocated index type", __func__);
#endif
oid.aoi_id[oid.aoi_idlen++] =
axo->axo_index[i]->axi_vb.avb_data.avb_int32;
}
packetid = ax_unregister(ax->ax_ax, axs->axs_id,
AGENTX_CONTEXT_CTX(axc), AX_PRIORITY_DEFAULT, 0, &oid, 0);
if (packetid == 0) {
agentx_log_axc_warn(axc, "couldn't generate %s",
ax_pdutype2string(AX_PDU_TYPE_UNREGISTER));
agentx_reset(ax);
return -1;
}
strlcpy(oids, ax_oid2string(&(axo->axo_oid)), sizeof(oids));
agentx_log_axc_info(axc, "object %s (%s %s): closing",
oids, flags ? "instance" : "region", ax_oid2string(&(oid)));
return agentx_request(ax, packetid, agentx_object_close_finalize,
axo);
}
static int
agentx_object_close_finalize(struct ax_pdu *pdu, void *cookie)
{
struct agentx_object *axo = cookie;
struct agentx_region *axr = axo->axo_axr;
struct agentx_context *axc = axr->axr_axc;
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
struct ax_oid oid;
char oids[1024];
uint8_t flags = 1;
size_t i;
int axfree = ax->ax_free;
#ifdef AX_DEBUG
if (axo->axo_cstate != AX_CSTATE_WAITCLOSE)
agentx_log_axc_fatalx(axc,
"%s: unexpected object unregister", __func__);
#endif
if (pdu != NULL) {
bcopy(&(axo->axo_oid), &(oid), sizeof(oid));
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i]->axi_type == AXI_TYPE_DYNAMIC) {
flags = 0;
break;
}
#ifdef AX_DEBUG
if (axo->axo_index[i]->axi_vb.avb_type !=
AX_DATA_TYPE_INTEGER)
agentx_log_axc_fatalx(axc,
"%s: Unsupported allocated index type",
__func__);
#endif
oid.aoi_id[oid.aoi_idlen++] =
axo->axo_index[i]->axi_vb.avb_data.avb_int32;
}
strlcpy(oids, ax_oid2string(&(axo->axo_oid)), sizeof(oids));
if (pdu->ap_payload.ap_response.ap_error !=
AX_PDU_ERROR_NOERROR) {
agentx_log_axc_warnx(axc,
"closing object %s (%s %s): %s", oids,
flags ? "instance" : "region",
ax_oid2string(&oid), ax_error2string(
pdu->ap_payload.ap_response.ap_error));
agentx_reset(ax);
return -1;
}
agentx_log_axc_info(axc, "object %s (%s %s): closed", oids,
flags ? "instance" : "region", ax_oid2string(&oid));
}
ax->ax_free = 1;
if (axr->axr_cstate == AX_CSTATE_OPEN &&
axo->axo_dstate == AX_DSTATE_OPEN)
agentx_object_start(axo);
if (!axfree)
agentx_free_finalize(ax);
return 0;
}
void
agentx_object_free(struct agentx_object *axo)
{
struct agentx *ax;
int axfree;
if (axo == NULL)
return;
ax = axo->axo_axr->axr_axc->axc_axs->axs_ax;
axfree = ax->ax_free;
ax->ax_free = 1;
if (axo->axo_dstate == AX_DSTATE_CLOSE)
agentx_log_axc_fatalx(axo->axo_axr->axr_axc,
"%s: double free", __func__);
axo->axo_dstate = AX_DSTATE_CLOSE;
if (axo->axo_cstate == AX_CSTATE_OPEN)
agentx_object_close(axo);
if (!axfree)
agentx_free_finalize(ax);
}
static void
agentx_object_free_finalize(struct agentx_object *axo)
{
#ifdef AX_DEBUG
struct agentx *ax = axo->axo_axr->axr_axc->axc_axs->axs_ax;
#endif
size_t i, j;
int found;
if (axo->axo_dstate != AX_DSTATE_CLOSE ||
axo->axo_cstate != AX_CSTATE_CLOSE ||
axo->axo_lock != 0)
return;
RB_REMOVE(axc_objects, &(axo->axo_axr->axr_axc->axc_objects), axo);
TAILQ_REMOVE(&(axo->axo_axr->axr_objects), axo, axo_axr_objects);
for (i = 0; i < axo->axo_indexlen; i++) {
found = 0;
for (j = 0; j < axo->axo_index[i]->axi_objectlen; j++) {
if (axo->axo_index[i]->axi_object[j] == axo)
found = 1;
if (found && j + 1 != axo->axo_index[i]->axi_objectlen)
axo->axo_index[i]->axi_object[j] =
axo->axo_index[i]->axi_object[j + 1];
}
#ifdef AX_DEBUG
if (!found)
agentx_log_axc_fatalx(axo->axo_axr->axr_axc,
"%s: object not found in index", __func__);
#endif
axo->axo_index[i]->axi_objectlen--;
}
free(axo);
}
static void
agentx_object_reset(struct agentx_object *axo)
{
struct agentx *ax = axo->axo_axr->axr_axc->axc_axs->axs_ax;
axo->axo_cstate = AX_CSTATE_CLOSE;
if (!ax->ax_free)
agentx_free_finalize(ax);
}
static int
agentx_object_cmp(struct agentx_object *o1, struct agentx_object *o2)
{
return ax_oid_cmp(&(o1->axo_oid), &(o2->axo_oid));
}
static int
agentx_object_implied(struct agentx_object *axo,
struct agentx_index *axi)
{
size_t i = 0;
struct ax_varbind *vb;
for (i = 0; i < axo->axo_indexlen; i++) {
if (axo->axo_index[i] == axi) {
vb = &axi->axi_vb;
if (vb->avb_type == AX_DATA_TYPE_OCTETSTRING &&
vb->avb_data.avb_ostring.aos_slen != 0)
return 1;
else if (vb->avb_type == AX_DATA_TYPE_OID &&
vb->avb_data.avb_oid.aoi_idlen != 0)
return 1;
else if (i == axo->axo_indexlen - 1)
return axo->axo_implied;
return 0;
}
}
#ifdef AX_DEBUG
agentx_log_axc_fatalx(axo->axo_axr->axr_axc, "%s: unsupported index",
__func__);
#endif
return 0;
}
static void
agentx_get_start(struct agentx_context *axc, struct ax_pdu *pdu)
{
struct agentx_session *axs = axc->axc_axs;
struct agentx *ax = axs->axs_ax;
struct agentx_get *axg, taxg;
struct ax_pdu_searchrangelist *srl;
char *logmsg = NULL;
size_t i, j;
int fail = 0;
if ((axg = calloc(1, sizeof(*axg))) == NULL) {
taxg.axg_sessionid = pdu->ap_header.aph_sessionid;
taxg.axg_transactionid = pdu->ap_header.aph_transactionid;
taxg.axg_packetid = pdu->ap_header.aph_packetid;
taxg.axg_context_default = axc->axc_name_default;
taxg.axg_fd = axc->axc_axs->axs_ax->ax_fd;
agentx_log_axg_warn(&taxg, "Couldn't parse request");
agentx_reset(ax);
return;
}
axg->axg_sessionid = pdu->ap_header.aph_sessionid;
axg->axg_transactionid = pdu->ap_header.aph_transactionid;
axg->axg_packetid = pdu->ap_header.aph_packetid;
axg->axg_context_default = axc->axc_name_default;
axg->axg_fd = axc->axc_axs->axs_ax->ax_fd;
if (!axc->axc_name_default) {
axg->axg_context.aos_string =
(unsigned char *)strdup((char *)axc->axc_name.aos_string);
if (axg->axg_context.aos_string == NULL) {
agentx_log_axg_warn(axg, "Couldn't parse request");
free(axg);
agentx_reset(ax);
return;
}
}
axg->axg_context.aos_slen = axc->axc_name.aos_slen;
axg->axg_type = pdu->ap_header.aph_type;
axg->axg_axc = axc;
TAILQ_INSERT_TAIL(&(ax->ax_getreqs), axg, axg_ax_getreqs);
if (axg->axg_type == AX_PDU_TYPE_GET ||
axg->axg_type == AX_PDU_TYPE_GETNEXT) {
srl = &(pdu->ap_payload.ap_srl);
axg->axg_nvarbind = srl->ap_nsr;
} else {
axg->axg_nonrep = pdu->ap_payload.ap_getbulk.ap_nonrep;
axg->axg_maxrep = pdu->ap_payload.ap_getbulk.ap_maxrep;
srl = &(pdu->ap_payload.ap_getbulk.ap_srl);
axg->axg_nvarbind = ((srl->ap_nsr - axg->axg_nonrep) *
axg->axg_maxrep) + axg->axg_nonrep;
}
if ((axg->axg_varbind = calloc(axg->axg_nvarbind,
sizeof(*(axg->axg_varbind)))) == NULL) {
agentx_log_axg_warn(axg, "Couldn't parse request");
agentx_get_free(axg);
agentx_reset(ax);
return;
}
for (i = 0; i < srl->ap_nsr; i++) {
if (i < axg->axg_nonrep ||
axg->axg_type != AX_PDU_TYPE_GETBULK)
j = i;
else if (axg->axg_maxrep == 0)
break;
else
j = (axg->axg_maxrep * i) + axg->axg_nonrep;
bcopy(&(srl->ap_sr[i].asr_start),
&(axg->axg_varbind[j].axv_vb.avb_oid),
sizeof(srl->ap_sr[i].asr_start));
bcopy(&(srl->ap_sr[i].asr_start),
&(axg->axg_varbind[j].axv_start),
sizeof(srl->ap_sr[i].asr_start));
bcopy(&(srl->ap_sr[i].asr_stop),
&(axg->axg_varbind[j].axv_end),
sizeof(srl->ap_sr[i].asr_stop));
axg->axg_varbind[j].axv_initialized = 1;
axg->axg_varbind[j].axv_axg = axg;
axg->axg_varbind[j].axv_include =
srl->ap_sr[i].asr_start.aoi_include;
if (j == 0)
fail |= agentx_strcat(&logmsg, " {");
else
fail |= agentx_strcat(&logmsg, ",{");
fail |= agentx_strcat(&logmsg,
ax_oid2string(&(srl->ap_sr[i].asr_start)));
if (srl->ap_sr[i].asr_start.aoi_include)
fail |= agentx_strcat(&logmsg, " (inclusive)");
if (srl->ap_sr[i].asr_stop.aoi_idlen != 0) {
fail |= agentx_strcat(&logmsg, " - ");
fail |= agentx_strcat(&logmsg,
ax_oid2string(&(srl->ap_sr[i].asr_stop)));
}
fail |= agentx_strcat(&logmsg, "}");
if (fail) {
agentx_log_axg_warn(axg, "Couldn't parse request");
free(logmsg);
agentx_get_free(axg);
agentx_reset(ax);
return;
}
}
agentx_log_axg_debug(axg, "%s:%s",
ax_pdutype2string(axg->axg_type), logmsg);
free(logmsg);
for (i = 0; i < srl->ap_nsr; i++) {
if (i < axg->axg_nonrep ||
axg->axg_type != AX_PDU_TYPE_GETBULK)
j = i;
else if (axg->axg_maxrep == 0)
break;
else
j = (axg->axg_maxrep * i) + axg->axg_nonrep;
agentx_varbind_start(&(axg->axg_varbind[j]));
}
}
static void
agentx_get_finalize(struct agentx_get *axg)
{
struct agentx_context *axc = axg->axg_axc;
struct agentx_session *axs;
struct agentx *ax;
size_t i, j, nvarbind = 0;
uint16_t error = 0, index = 0;
struct ax_varbind *vbl;
char *logmsg = NULL;
int fail = 0;
for (i = 0; i < axg->axg_nvarbind; i++) {
if (axg->axg_varbind[i].axv_initialized) {
if (axg->axg_varbind[i].axv_vb.avb_type == 0)
return;
nvarbind++;
}
}
if (axc == NULL) {
agentx_get_free(axg);
return;
}
axs = axc->axc_axs;
ax = axs->axs_ax;
if ((vbl = calloc(nvarbind, sizeof(*vbl))) == NULL) {
agentx_log_axg_warn(axg, "Couldn't parse request");
agentx_get_free(axg);
agentx_reset(ax);
return;
}
for (i = 0, j = 0; i < axg->axg_nvarbind; i++) {
if (axg->axg_varbind[i].axv_initialized) {
memcpy(&(vbl[j]), &(axg->axg_varbind[i].axv_vb),
sizeof(*vbl));
if (error == 0 && axg->axg_varbind[i].axv_error !=
AX_PDU_ERROR_NOERROR) {
error = axg->axg_varbind[i].axv_error;
index = j + 1;
}
if (j == 0)
fail |= agentx_strcat(&logmsg, " {");
else
fail |= agentx_strcat(&logmsg, ",{");
fail |= agentx_strcat(&logmsg,
ax_varbind2string(&(vbl[j])));
if (axg->axg_varbind[i].axv_error !=
AX_PDU_ERROR_NOERROR) {
fail |= agentx_strcat(&logmsg, "(");
fail |= agentx_strcat(&logmsg,
ax_error2string(
axg->axg_varbind[i].axv_error));
fail |= agentx_strcat(&logmsg, ")");
}
fail |= agentx_strcat(&logmsg, "}");
if (fail) {
agentx_log_axg_warn(axg,
"Couldn't parse request");
free(logmsg);
agentx_get_free(axg);
return;
}
j++;
}
}
agentx_log_axg_debug(axg, "response:%s", logmsg);
free(logmsg);
if (ax_response(ax->ax_ax, axs->axs_id, axg->axg_transactionid,
axg->axg_packetid, 0, error, index, vbl, nvarbind) == -1) {
agentx_log_axg_warn(axg, "Couldn't parse request");
agentx_reset(ax);
} else
agentx_wantwrite(ax, ax->ax_fd);
free(vbl);
agentx_get_free(axg);
}
void
agentx_get_free(struct agentx_get *axg)
{
struct agentx_varbind *axv;
struct agentx_object *axo;
struct agentx *ax;
struct agentx_varbind_index *index;
size_t i, j;
if (axg->axg_axc != NULL) {
ax = axg->axg_axc->axc_axs->axs_ax;
TAILQ_REMOVE(&(ax->ax_getreqs), axg, axg_ax_getreqs);
}
for (i = 0; i < axg->axg_nvarbind; i++) {
axv = &(axg->axg_varbind[i]);
for (j = 0; axv->axv_axo != NULL &&
j < axv->axv_axo->axo_indexlen; j++) {
axo = axv->axv_axo;
index = &(axv->axv_index[j]);
if (axo->axo_index[j]->axi_vb.avb_type ==
AX_DATA_TYPE_OCTETSTRING ||
axo->axo_index[j]->axi_vb.avb_type ==
AX_DATA_TYPE_IPADDRESS)
free(index->axv_idata.avb_ostring.aos_string);
}
ax_varbind_free(&(axg->axg_varbind[i].axv_vb));
}
free(axg->axg_context.aos_string);
free(axg->axg_varbind);
free(axg);
}
static void
agentx_varbind_start(struct agentx_varbind *axv)
{
struct agentx_get *axg = axv->axv_axg;
struct agentx_context *axc = axg->axg_axc;
struct agentx_object *axo, axo_search;
struct agentx_varbind_index *index;
struct ax_oid *oid;
union ax_data *data;
struct in_addr *ipaddress;
unsigned char *ipbytes;
size_t i, j, k;
int overflow = 0, dynamic;
#ifdef AX_DEBUG
if (!axv->axv_initialized)
agentx_log_axg_fatalx(axv->axv_axg,
"%s: axv_initialized not set", __func__);
#endif
if (axc == NULL) {
agentx_varbind_error_type(axv, AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
bcopy(&(axv->axv_vb.avb_oid), &(axo_search.axo_oid),
sizeof(axo_search.axo_oid));
do {
axo = RB_FIND(axc_objects, &(axc->axc_objects), &axo_search);
if (axo_search.axo_oid.aoi_idlen > 0)
axo_search.axo_oid.aoi_idlen--;
} while (axo == NULL && axo_search.axo_oid.aoi_idlen > 0);
if (axo == NULL || axo->axo_cstate != AX_CSTATE_OPEN) {
axv->axv_include = 1;
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET) {
agentx_varbind_nosuchobject(axv);
return;
}
bcopy(&(axv->axv_vb.avb_oid), &(axo_search.axo_oid),
sizeof(axo_search.axo_oid));
axo = RB_NFIND(axc_objects, &(axc->axc_objects), &axo_search);
getnext:
while (axo != NULL && axo->axo_cstate != AX_CSTATE_OPEN)
axo = RB_NEXT(axc_objects, &(axc->axc_objects), axo);
if (axo == NULL ||
ax_oid_cmp(&(axo->axo_oid), &(axv->axv_end)) >= 0) {
agentx_varbind_endofmibview(axv);
return;
}
bcopy(&(axo->axo_oid), &(axv->axv_vb.avb_oid),
sizeof(axo->axo_oid));
}
axv->axv_axo = axo;
axv->axv_indexlen = axo->axo_indexlen;
if (agentx_object_lock(axo) == -1) {
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
oid = &(axv->axv_vb.avb_oid);
if (axo->axo_indexlen == 0) {
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET) {
if (oid->aoi_idlen != axo->axo_oid.aoi_idlen + 1 ||
oid->aoi_id[oid->aoi_idlen - 1] != 0) {
agentx_varbind_nosuchinstance(axv);
return;
}
} else {
if (oid->aoi_idlen == axo->axo_oid.aoi_idlen) {
oid->aoi_id[oid->aoi_idlen++] = 0;
axv->axv_include = 1;
} else {
axv->axv_axo = NULL;
agentx_object_unlock(axo);
axo = RB_NEXT(axc_objects, &(axc->axc_objects),
axo);
goto getnext;
}
}
j = oid->aoi_idlen;
} else
j = axo->axo_oid.aoi_idlen;
for (dynamic = 0, i = 0; i < axo->axo_indexlen; i++, j++) {
index = &(axv->axv_index[i]);
index->axv_axi = axo->axo_index[i];
data = &(index->axv_idata);
if (axo->axo_index[i]->axi_type == AXI_TYPE_DYNAMIC)
dynamic = 1;
switch (axo->axo_index[i]->axi_vb.avb_type) {
case AX_DATA_TYPE_INTEGER:
if (index->axv_axi->axi_type != AXI_TYPE_DYNAMIC) {
index->axv_idata.avb_int32 =
index->axv_axi->axi_vb.avb_data.avb_int32;
if (overflow == 0) {
if ((uint32_t)index->axv_idata.avb_int32 >
oid->aoi_id[j])
overflow = -1;
else if ((uint32_t)index->axv_idata.avb_int32 <
oid->aoi_id[j])
overflow = 1;
}
} else if (overflow == 1)
index->axv_idata.avb_int32 = INT32_MAX;
else if (j >= oid->aoi_idlen || overflow == -1)
index->axv_idata.avb_int32 = 0;
else {
if (oid->aoi_id[j] > INT32_MAX) {
index->axv_idata.avb_int32 = INT32_MAX;
overflow = 1;
} else
index->axv_idata.avb_int32 =
oid->aoi_id[j];
}
break;
case AX_DATA_TYPE_OCTETSTRING:
if (overflow == 1) {
data->avb_ostring.aos_slen = UINT32_MAX;
data->avb_ostring.aos_string = NULL;
continue;
} else if (j >= oid->aoi_idlen || overflow == -1) {
data->avb_ostring.aos_slen = 0;
data->avb_ostring.aos_string = NULL;
continue;
}
if (agentx_object_implied(axo, index->axv_axi))
data->avb_ostring.aos_slen = oid->aoi_idlen - j;
else {
data->avb_ostring.aos_slen = oid->aoi_id[j++];
if (data->avb_ostring.aos_slen >=
AGENTX_OID_MAX_LEN - j) {
data->avb_ostring.aos_slen = UINT32_MAX;
overflow = 1;
}
}
if (data->avb_ostring.aos_slen == UINT32_MAX ||
data->avb_ostring.aos_slen == 0) {
data->avb_ostring.aos_string = NULL;
continue;
}
data->avb_ostring.aos_string =
malloc(data->avb_ostring.aos_slen + 1);
if (data->avb_ostring.aos_string == NULL) {
agentx_log_axg_warn(axg,
"Failed to bind string index");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
for (k = 0; k < data->avb_ostring.aos_slen; k++, j++) {
if (j < oid->aoi_idlen && oid->aoi_id[j] > 0xff)
overflow = 1;
if (overflow == 1)
data->avb_ostring.aos_string[k] = 0xff;
else if (j >= oid->aoi_idlen || overflow == -1)
data->avb_ostring.aos_string[k] = '\0';
else
data->avb_ostring.aos_string[k] =
oid->aoi_id[j];
}
data->avb_ostring.aos_string[k] = '\0';
j--;
break;
case AX_DATA_TYPE_OID:
if (overflow == 1) {
data->avb_oid.aoi_idlen = UINT32_MAX;
continue;
} else if (j >= oid->aoi_idlen || overflow == -1) {
data->avb_oid.aoi_idlen = 0;
continue;
}
if (agentx_object_implied(axo, index->axv_axi))
data->avb_oid.aoi_idlen = oid->aoi_idlen - j;
else {
data->avb_oid.aoi_idlen = oid->aoi_id[j++];
if (data->avb_oid.aoi_idlen >=
AGENTX_OID_MAX_LEN - j) {
data->avb_oid.aoi_idlen = UINT32_MAX;
overflow = 1;
}
}
if (data->avb_oid.aoi_idlen == UINT32_MAX ||
data->avb_oid.aoi_idlen == 0)
continue;
for (k = 0; k < data->avb_oid.aoi_idlen; k++, j++) {
if (overflow == 1)
data->avb_oid.aoi_id[k] = UINT32_MAX;
else if (j >= oid->aoi_idlen || overflow == -1)
data->avb_oid.aoi_id[k] = 0;
else
data->avb_oid.aoi_id[k] =
oid->aoi_id[j];
}
j--;
break;
case AX_DATA_TYPE_IPADDRESS:
ipaddress = malloc(sizeof(*ipaddress));
if (ipaddress == NULL) {
agentx_log_axg_warn(axg,
"Failed to bind ipaddress index");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
ipbytes = (unsigned char *)ipaddress;
for (k = 0; k < 4; k++, j++) {
if (j < oid->aoi_idlen && oid->aoi_id[j] > 255)
overflow = 1;
if (overflow == 1)
ipbytes[k] = 255;
else if (j >= oid->aoi_idlen || overflow == -1)
ipbytes[k] = 0;
else
ipbytes[k] = oid->aoi_id[j];
}
j--;
data->avb_ostring.aos_slen = sizeof(*ipaddress);
data->avb_ostring.aos_string =
(unsigned char *)ipaddress;
break;
default:
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axg,
"%s: unexpected index type", __func__);
#else
agentx_log_axg_warnx(axg,
"%s: unexpected index type", __func__);
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
#endif
}
}
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET) {
if (j != oid->aoi_idlen || overflow) {
agentx_varbind_nosuchinstance(axv);
return;
}
}
if (overflow == 1) {
axv->axv_include = 0;
} else if (overflow == -1) {
axv->axv_include = 1;
} else if (j < oid->aoi_idlen)
axv->axv_include = 0;
else if (j > oid->aoi_idlen)
axv->axv_include = 1;
if (agentx_varbind_request(axv) == AGENTX_REQUEST_TYPE_GETNEXT &&
!dynamic) {
agentx_varbind_endofmibview(axv);
return;
}
axo->axo_get(axv);
}
void
agentx_varbind_integer(struct agentx_varbind *axv, int32_t value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_INTEGER;
axv->axv_vb.avb_data.avb_int32 = value;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_string(struct agentx_varbind *axv, const char *value)
{
agentx_varbind_nstring(axv, (const unsigned char *)value,
strlen(value));
}
void
agentx_varbind_nstring(struct agentx_varbind *axv,
const unsigned char *value, size_t slen)
{
axv->axv_vb.avb_data.avb_ostring.aos_string = malloc(slen);
if (axv->axv_vb.avb_data.avb_ostring.aos_string == NULL) {
agentx_log_axg_warn(axv->axv_axg, "Couldn't bind string");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
axv->axv_vb.avb_type = AX_DATA_TYPE_OCTETSTRING;
memcpy(axv->axv_vb.avb_data.avb_ostring.aos_string, value, slen);
axv->axv_vb.avb_data.avb_ostring.aos_slen = slen;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_printf(struct agentx_varbind *axv, const char *fmt, ...)
{
va_list ap;
int r;
axv->axv_vb.avb_type = AX_DATA_TYPE_OCTETSTRING;
va_start(ap, fmt);
r = vasprintf((char **)&(axv->axv_vb.avb_data.avb_ostring.aos_string),
fmt, ap);
va_end(ap);
if (r == -1) {
axv->axv_vb.avb_data.avb_ostring.aos_string = NULL;
agentx_log_axg_warn(axv->axv_axg, "Couldn't bind string");
agentx_varbind_error_type(axv, AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
axv->axv_vb.avb_data.avb_ostring.aos_slen = r;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_null(struct agentx_varbind *axv)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_NULL;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_oid(struct agentx_varbind *axv, const uint32_t oid[],
size_t oidlen)
{
const char *errstr;
axv->axv_vb.avb_type = AX_DATA_TYPE_OID;
if (agentx_oidfill(&(axv->axv_vb.avb_data.avb_oid),
oid, oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "%s: %s", __func__, errstr);
#else
agentx_log_axg_warnx(axv->axv_axg, "%s: %s", __func__, errstr);
agentx_varbind_error_type(axv, AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
#endif
}
agentx_varbind_finalize(axv);
}
void
agentx_varbind_object(struct agentx_varbind *axv,
struct agentx_object *axo)
{
agentx_varbind_oid(axv, axo->axo_oid.aoi_id,
axo->axo_oid.aoi_idlen);
}
void
agentx_varbind_index(struct agentx_varbind *axv,
struct agentx_index *axi)
{
agentx_varbind_oid(axv, axi->axi_vb.avb_oid.aoi_id,
axi->axi_vb.avb_oid.aoi_idlen);
}
void
agentx_varbind_ipaddress(struct agentx_varbind *axv,
const struct in_addr *value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_IPADDRESS;
axv->axv_vb.avb_data.avb_ostring.aos_string = malloc(4);
if (axv->axv_vb.avb_data.avb_ostring.aos_string == NULL) {
agentx_log_axg_warn(axv->axv_axg, "Couldn't bind ipaddress");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
memcpy(axv->axv_vb.avb_data.avb_ostring.aos_string, value, 4);
axv->axv_vb.avb_data.avb_ostring.aos_slen = 4;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_counter32(struct agentx_varbind *axv, uint32_t value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_COUNTER32;
axv->axv_vb.avb_data.avb_uint32 = value;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_gauge32(struct agentx_varbind *axv, uint32_t value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_GAUGE32;
axv->axv_vb.avb_data.avb_uint32 = value;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_unsigned32(struct agentx_varbind *axv, uint32_t value)
{
agentx_varbind_gauge32(axv, value);
}
void
agentx_varbind_timeticks(struct agentx_varbind *axv, uint32_t value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_TIMETICKS;
axv->axv_vb.avb_data.avb_uint32 = value;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_opaque(struct agentx_varbind *axv, const char *string,
size_t strlen)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_OPAQUE;
axv->axv_vb.avb_data.avb_ostring.aos_string = malloc(strlen);
if (axv->axv_vb.avb_data.avb_ostring.aos_string == NULL) {
agentx_log_axg_warn(axv->axv_axg, "Couldn't bind opaque");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
}
memcpy(axv->axv_vb.avb_data.avb_ostring.aos_string, string, strlen);
axv->axv_vb.avb_data.avb_ostring.aos_slen = strlen;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_counter64(struct agentx_varbind *axv, uint64_t value)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_COUNTER64;
axv->axv_vb.avb_data.avb_uint64 = value;
agentx_varbind_finalize(axv);
}
void
agentx_varbind_notfound(struct agentx_varbind *axv)
{
if (axv->axv_indexlen == 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "%s invalid call",
__func__);
#else
agentx_log_axg_warnx(axv->axv_axg, "%s invalid call",
__func__);
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 1);
#endif
} else if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET)
agentx_varbind_nosuchinstance(axv);
else
agentx_varbind_endofmibview(axv);
}
void
agentx_varbind_error(struct agentx_varbind *axv)
{
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 1);
}
static void
agentx_varbind_error_type(struct agentx_varbind *axv,
enum ax_pdu_error error, int done)
{
if (axv->axv_error == AX_PDU_ERROR_NOERROR) {
axv->axv_error = error;
}
if (done) {
axv->axv_vb.avb_type = AX_DATA_TYPE_NULL;
agentx_varbind_finalize(axv);
}
}
static void
agentx_varbind_finalize(struct agentx_varbind *axv)
{
struct agentx_get *axg = axv->axv_axg;
struct ax_oid oid;
union ax_data *data;
size_t i, j;
int cmp;
if (axv->axv_error != AX_PDU_ERROR_NOERROR) {
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
goto done;
}
bcopy(&(axv->axv_axo->axo_oid), &oid, sizeof(oid));
if (axv->axv_indexlen == 0)
ax_oid_add(&oid, 0);
for (i = 0; i < axv->axv_indexlen; i++) {
data = &(axv->axv_index[i].axv_idata);
switch (axv->axv_index[i].axv_axi->axi_vb.avb_type) {
case AX_DATA_TYPE_INTEGER:
if (ax_oid_add(&oid, data->avb_int32) == -1)
goto fail;
break;
case AX_DATA_TYPE_OCTETSTRING:
if (!agentx_object_implied(axv->axv_axo,
axv->axv_index[i].axv_axi)) {
if (ax_oid_add(&oid,
data->avb_ostring.aos_slen) == -1)
goto fail;
}
for (j = 0; j < data->avb_ostring.aos_slen; j++) {
if (ax_oid_add(&oid,
(uint8_t)data->avb_ostring.aos_string[j]) ==
-1)
goto fail;
}
break;
case AX_DATA_TYPE_OID:
if (!agentx_object_implied(axv->axv_axo,
axv->axv_index[i].axv_axi)) {
if (ax_oid_add(&oid,
data->avb_oid.aoi_idlen) == -1)
goto fail;
}
for (j = 0; j < data->avb_oid.aoi_idlen; j++) {
if (ax_oid_add(&oid,
data->avb_oid.aoi_id[j]) == -1)
goto fail;
}
break;
case AX_DATA_TYPE_IPADDRESS:
for (j = 0; j < 4; j++) {
if (ax_oid_add(&oid,
data->avb_ostring.aos_string == NULL ? 0 :
(uint8_t)data->avb_ostring.aos_string[j]) ==
-1)
goto fail;
}
break;
default:
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axg,
"%s: unsupported index type", __func__);
#else
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_error = AX_PDU_ERROR_PROCESSINGERROR;
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
return;
#endif
}
}
cmp = ax_oid_cmp(&oid, &(axv->axv_vb.avb_oid));
switch (agentx_varbind_request(axv)) {
case AGENTX_REQUEST_TYPE_GET:
if (cmp != 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axg, "index changed");
#else
agentx_log_axg_warnx(axg, "index changed");
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_error = AX_PDU_ERROR_GENERR;
break;
#endif
}
break;
case AGENTX_REQUEST_TYPE_GETNEXT:
if (cmp <= 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axg, "indices not incremented");
#else
agentx_log_axg_warnx(axg, "indices not incremented");
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_error = AX_PDU_ERROR_GENERR;
break;
#endif
}
case AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE:
if (cmp < 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axg, "index decremented");
#else
agentx_log_axg_warnx(axg, "index decremented");
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_error = AX_PDU_ERROR_GENERR;
break;
#endif
}
if (axv->axv_end.aoi_idlen != 0 &&
ax_oid_cmp(&oid, &(axv->axv_end)) >= 0) {
agentx_varbind_endofmibview(axv);
return;
}
bcopy(&oid, &(axv->axv_vb.avb_oid), sizeof(oid));
}
done:
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
return;
fail:
agentx_log_axg_warnx(axg, "oid too large");
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_error = AX_PDU_ERROR_GENERR;
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
}
static void
agentx_varbind_nosuchobject(struct agentx_varbind *axv)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_NOSUCHOBJECT;
if (axv->axv_axo != NULL)
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
}
static void
agentx_varbind_nosuchinstance(struct agentx_varbind *axv)
{
axv->axv_vb.avb_type = AX_DATA_TYPE_NOSUCHINSTANCE;
if (axv->axv_axo != NULL)
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
}
static void
agentx_varbind_endofmibview(struct agentx_varbind *axv)
{
struct agentx_object *axo;
struct ax_varbind *vb;
struct agentx_varbind_index *index;
size_t i;
#ifdef AX_DEBUG
if (axv->axv_axg->axg_type != AX_PDU_TYPE_GETNEXT &&
axv->axv_axg->axg_type != AX_PDU_TYPE_GETBULK)
agentx_log_axg_fatalx(axv->axv_axg,
"%s: invalid request type", __func__);
#endif
if (axv->axv_axo != NULL &&
(axo = RB_NEXT(axc_objects, &(axc->axc_objects),
axv->axv_axo)) != NULL &&
ax_oid_cmp(&(axo->axo_oid), &(axv->axv_end)) < 0) {
bcopy(&(axo->axo_oid), &(axv->axv_vb.avb_oid),
sizeof(axo->axo_oid));
axv->axv_include = 1;
for (i = 0; i < axv->axv_indexlen; i++) {
index = &(axv->axv_index[i]);
vb = &(index->axv_axi->axi_vb);
if (vb->avb_type == AX_DATA_TYPE_OCTETSTRING ||
vb->avb_type == AX_DATA_TYPE_IPADDRESS)
free(index->axv_idata.avb_ostring.aos_string);
}
bzero(&(axv->axv_index), sizeof(axv->axv_index));
agentx_object_unlock(axv->axv_axo);
agentx_varbind_start(axv);
return;
}
bcopy(&(axv->axv_start), &(axv->axv_vb.avb_oid),
sizeof(axv->axv_start));
axv->axv_vb.avb_type = AX_DATA_TYPE_ENDOFMIBVIEW;
if (axv->axv_axo != NULL)
agentx_object_unlock(axv->axv_axo);
agentx_get_finalize(axv->axv_axg);
}
enum agentx_request_type
agentx_varbind_request(struct agentx_varbind *axv)
{
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET)
return AGENTX_REQUEST_TYPE_GET;
if (axv->axv_include)
return AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE;
return AGENTX_REQUEST_TYPE_GETNEXT;
}
struct agentx_object *
agentx_varbind_get_object(struct agentx_varbind *axv)
{
return axv->axv_axo;
}
int32_t
agentx_varbind_get_index_integer(struct agentx_varbind *axv,
struct agentx_index *axi)
{
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_INTEGER) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return 0;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi)
return axv->axv_index[i].axv_idata.avb_int32;
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return 0;
#endif
}
const unsigned char *
agentx_varbind_get_index_string(struct agentx_varbind *axv,
struct agentx_index *axi, size_t *slen, int *implied)
{
struct agentx_varbind_index *index;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_OCTETSTRING) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
*slen = 0;
*implied = 0;
return NULL;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
index = &(axv->axv_index[i]);
*slen = index->axv_idata.avb_ostring.aos_slen;
*implied = agentx_object_implied(axv->axv_axo, axi);
return index->axv_idata.avb_ostring.aos_string;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
*slen = 0;
*implied = 0;
return NULL;
#endif
}
const uint32_t *
agentx_varbind_get_index_oid(struct agentx_varbind *axv,
struct agentx_index *axi, size_t *oidlen, int *implied)
{
struct agentx_varbind_index *index;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_OID) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
*oidlen = 0;
*implied = 0;
return NULL;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
index = &(axv->axv_index[i]);
*oidlen = index->axv_idata.avb_oid.aoi_idlen;
*implied = agentx_object_implied(axv->axv_axo, axi);
return index->axv_idata.avb_oid.aoi_id;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
*oidlen = 0;
*implied = 0;
return NULL;
#endif
}
const struct in_addr *
agentx_varbind_get_index_ipaddress(struct agentx_varbind *axv,
struct agentx_index *axi)
{
static struct in_addr nuladdr = {0};
struct agentx_varbind_index *index;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_IPADDRESS) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return NULL;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
index = &(axv->axv_index[i]);
if (index->axv_idata.avb_ostring.aos_string == NULL)
return &nuladdr;
return (struct in_addr *)
index->axv_idata.avb_ostring.aos_string;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return NULL;
#endif
}
void
agentx_varbind_set_index_integer(struct agentx_varbind *axv,
struct agentx_index *axi, int32_t value)
{
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_INTEGER) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
if (value < 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index value");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index value");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET &&
axv->axv_index[i].axv_idata.avb_int32 != value) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"can't change index on GET");
#else
agentx_log_axg_warnx(axv->axv_axg,
"can't change index on GET");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
axv->axv_index[i].axv_idata.avb_int32 = value;
return;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
#endif
}
void
agentx_varbind_set_index_string(struct agentx_varbind *axv,
struct agentx_index *axi, const char *value)
{
agentx_varbind_set_index_nstring(axv, axi,
(const unsigned char *)value, strlen(value));
}
void
agentx_varbind_set_index_nstring(struct agentx_varbind *axv,
struct agentx_index *axi, const unsigned char *value, size_t slen)
{
struct ax_ostring *curvalue;
unsigned char *nstring;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_OCTETSTRING) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
if (axi->axi_vb.avb_data.avb_ostring.aos_slen != 0 &&
axi->axi_vb.avb_data.avb_ostring.aos_slen != slen) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"invalid string length on explicit length "
"string");
#else
agentx_log_axg_warnx(axv->axv_axg,
"invalid string length on explicit length "
"string");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
curvalue = &(axv->axv_index[i].axv_idata.avb_ostring);
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET &&
(curvalue->aos_slen != slen ||
memcmp(curvalue->aos_string, value, slen) != 0)) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"can't change index on GET");
#else
agentx_log_axg_warnx(axv->axv_axg,
"can't change index on GET");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
if ((nstring = recallocarray(curvalue->aos_string,
curvalue->aos_slen + 1, slen + 1, 1)) == NULL) {
agentx_log_axg_warn(axv->axv_axg,
"Failed to bind string index");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 0);
return;
}
curvalue->aos_string = nstring;
memcpy(nstring, value, slen);
curvalue->aos_slen = slen;
return;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
#endif
}
void
agentx_varbind_set_index_oid(struct agentx_varbind *axv,
struct agentx_index *axi, const uint32_t *value, size_t oidlen)
{
struct ax_oid *curvalue, oid;
const char *errstr;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_OID) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
if (axi->axi_vb.avb_data.avb_oid.aoi_idlen != 0 &&
axi->axi_vb.avb_data.avb_oid.aoi_idlen != oidlen) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"invalid oid length on explicit length "
"oid");
#else
agentx_log_axg_warnx(axv->axv_axg,
"invalid oid length on explicit length "
"oid");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
curvalue = &(axv->axv_index[i].axv_idata.avb_oid);
if (agentx_oidfill(&oid, value,
oidlen, &errstr) == -1) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "%s: %s",
__func__, errstr);
#else
agentx_log_axg_warnx(axv->axv_axg, "%s: %s",
__func__, errstr);
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 1);
return;
#endif
}
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET &&
ax_oid_cmp(&oid, curvalue) != 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"can't change index on GET");
#else
agentx_log_axg_warnx(axv->axv_axg,
"can't change index on GET");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
*curvalue = oid;
return;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
#endif
}
void
agentx_varbind_set_index_object(struct agentx_varbind *axv,
struct agentx_index *axi, struct agentx_object *axo)
{
agentx_varbind_set_index_oid(axv, axi, axo->axo_oid.aoi_id,
axo->axo_oid.aoi_idlen);
}
void
agentx_varbind_set_index_ipaddress(struct agentx_varbind *axv,
struct agentx_index *axi, const struct in_addr *addr)
{
struct ax_ostring *curvalue;
size_t i;
if (axi->axi_vb.avb_type != AX_DATA_TYPE_IPADDRESS) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index type");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index type");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
for (i = 0; i < axv->axv_indexlen; i++) {
if (axv->axv_index[i].axv_axi == axi) {
curvalue = &(axv->axv_index[i].axv_idata.avb_ostring);
if (curvalue->aos_string == NULL)
curvalue->aos_string = calloc(1, sizeof(*addr));
if (curvalue->aos_string == NULL) {
agentx_log_axg_warn(axv->axv_axg,
"Failed to bind ipaddress index");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_PROCESSINGERROR, 0);
return;
}
if (axv->axv_axg->axg_type == AX_PDU_TYPE_GET &&
memcmp(addr, curvalue->aos_string,
sizeof(*addr)) != 0) {
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg,
"can't change index on GET");
#else
agentx_log_axg_warnx(axv->axv_axg,
"can't change index on GET");
agentx_varbind_error_type(axv,
AX_PDU_ERROR_GENERR, 0);
return;
#endif
}
bcopy(addr, curvalue->aos_string, sizeof(*addr));
return;
}
}
#ifdef AX_DEBUG
agentx_log_axg_fatalx(axv->axv_axg, "invalid index");
#else
agentx_log_axg_warnx(axv->axv_axg, "invalid index");
agentx_varbind_error_type(axv, AX_PDU_ERROR_GENERR, 0);
#endif
}
static int
agentx_request(struct agentx *ax, uint32_t packetid,
int (*cb)(struct ax_pdu *, void *), void *cookie)
{
struct agentx_request *axr;
#ifdef AX_DEBUG
if (ax->ax_ax->ax_wblen == 0)
agentx_log_ax_fatalx(ax, "%s: no data to be written",
__func__);
#endif
if ((axr = calloc(1, sizeof(*axr))) == NULL) {
agentx_log_ax_warn(ax, "couldn't create request context");
agentx_reset(ax);
return -1;
}
axr->axr_packetid = packetid;
axr->axr_cb = cb;
axr->axr_cookie = cookie;
if (RB_INSERT(ax_requests, &(ax->ax_requests), axr) != NULL) {
#ifdef AX_DEBUG
agentx_log_ax_fatalx(ax, "%s: duplicate packetid", __func__);
#else
agentx_log_ax_warnx(ax, "%s: duplicate packetid", __func__);
free(axr);
agentx_reset(ax);
return -1;
#endif
}
agentx_wantwrite(ax, ax->ax_fd);
return 0;
}
static int
agentx_request_cmp(struct agentx_request *r1,
struct agentx_request *r2)
{
return r1->axr_packetid < r2->axr_packetid ? -1 :
r1->axr_packetid > r2->axr_packetid;
}
static int
agentx_strcat(char **dst, const char *src)
{
char *tmp;
size_t dstlen = 0, buflen = 0, srclen, nbuflen;
if (*dst != NULL) {
dstlen = strlen(*dst);
buflen = ((dstlen / 512) + 1) * 512;
}
srclen = strlen(src);
if (*dst == NULL || dstlen + srclen > buflen) {
nbuflen = (((dstlen + srclen) / 512) + 1) * 512;
tmp = recallocarray(*dst, buflen, nbuflen, sizeof(*tmp));
if (tmp == NULL)
return -1;
*dst = tmp;
buflen = nbuflen;
}
(void)strlcat(*dst, src, buflen);
return 0;
}
static int
agentx_oidfill(struct ax_oid *oid, const uint32_t oidval[], size_t oidlen,
const char **errstr)
{
size_t i;
if (oidlen < AGENTX_OID_MIN_LEN) {
*errstr = "oidlen < 2";
errno = EINVAL;
return -1;
}
if (oidlen > AGENTX_OID_MAX_LEN) {
*errstr = "oidlen > 128";
errno = EINVAL;
return -1;
}
for (i = 0; i < oidlen; i++)
oid->aoi_id[i] = oidval[i];
oid->aoi_idlen = oidlen;
return 0;
}
void
agentx_read(struct agentx *ax)
{
struct agentx_session *axs;
struct agentx_context *axc;
struct agentx_request axr_search, *axr;
struct ax_pdu *pdu;
int error;
if ((pdu = ax_recv(ax->ax_ax)) == NULL) {
if (errno == EAGAIN)
return;
agentx_log_ax_warn(ax, "lost connection");
agentx_reset(ax);
return;
}
TAILQ_FOREACH(axs, &(ax->ax_sessions), axs_ax_sessions) {
if (axs->axs_id == pdu->ap_header.aph_sessionid)
break;
if (axs->axs_cstate == AX_CSTATE_WAITOPEN &&
axs->axs_packetid == pdu->ap_header.aph_packetid)
break;
}
if (axs == NULL) {
agentx_log_ax_warnx(ax, "received unexpected session: %d",
pdu->ap_header.aph_sessionid);
ax_pdu_free(pdu);
agentx_reset(ax);
return;
}
TAILQ_FOREACH(axc, &(axs->axs_contexts), axc_axs_contexts) {
if ((pdu->ap_header.aph_flags &
AX_PDU_FLAG_NON_DEFAULT_CONTEXT) == 0 &&
axc->axc_name_default == 1)
break;
if (pdu->ap_header.aph_flags &
AX_PDU_FLAG_NON_DEFAULT_CONTEXT &&
axc->axc_name_default == 0 &&
pdu->ap_context.aos_slen == axc->axc_name.aos_slen &&
memcmp(pdu->ap_context.aos_string,
axc->axc_name.aos_string, axc->axc_name.aos_slen) == 0)
break;
}
if (pdu->ap_header.aph_type != AX_PDU_TYPE_RESPONSE) {
if (axc == NULL) {
agentx_log_ax_warnx(ax, "%s: invalid context",
pdu->ap_context.aos_string);
ax_pdu_free(pdu);
agentx_reset(ax);
return;
}
}
switch (pdu->ap_header.aph_type) {
case AX_PDU_TYPE_GET:
case AX_PDU_TYPE_GETNEXT:
case AX_PDU_TYPE_GETBULK:
agentx_get_start(axc, pdu);
break;
case AX_PDU_TYPE_TESTSET:
case AX_PDU_TYPE_COMMITSET:
case AX_PDU_TYPE_UNDOSET:
if (pdu->ap_header.aph_type == AX_PDU_TYPE_TESTSET)
error = AX_PDU_ERROR_NOTWRITABLE;
else if (pdu->ap_header.aph_type == AX_PDU_TYPE_COMMITSET)
error = AX_PDU_ERROR_COMMITFAILED;
else
error = AX_PDU_ERROR_UNDOFAILED;
agentx_log_axc_debug(axc, "unsupported call: %s",
ax_pdutype2string(pdu->ap_header.aph_type));
if (ax_response(ax->ax_ax, axs->axs_id,
pdu->ap_header.aph_transactionid,
pdu->ap_header.aph_packetid,
0, error, 1, NULL, 0) == -1)
agentx_log_axc_warn(axc,
"transaction: %u packetid: %u: failed to send "
"reply", pdu->ap_header.aph_transactionid,
pdu->ap_header.aph_packetid);
if (ax->ax_ax->ax_wblen > 0)
agentx_wantwrite(ax, ax->ax_fd);
break;
case AX_PDU_TYPE_CLEANUPSET:
agentx_log_ax_debug(ax, "unsupported call: %s",
ax_pdutype2string(pdu->ap_header.aph_type));
break;
case AX_PDU_TYPE_RESPONSE:
axr_search.axr_packetid = pdu->ap_header.aph_packetid;
axr = RB_FIND(ax_requests, &(ax->ax_requests), &axr_search);
if (axr == NULL) {
if (axc == NULL)
agentx_log_ax_warnx(ax, "received "
"response on non-request");
else
agentx_log_axc_warnx(axc, "received "
"response on non-request");
break;
}
if (axc != NULL && pdu->ap_payload.ap_response.ap_error == 0) {
axc->axc_sysuptime =
pdu->ap_payload.ap_response.ap_uptime;
(void) clock_gettime(CLOCK_MONOTONIC,
&(axc->axc_sysuptimespec));
}
RB_REMOVE(ax_requests, &(ax->ax_requests), axr);
(void) axr->axr_cb(pdu, axr->axr_cookie);
free(axr);
break;
default:
if (axc == NULL)
agentx_log_ax_warnx(ax, "unsupported call: %s",
ax_pdutype2string(pdu->ap_header.aph_type));
else
agentx_log_axc_warnx(axc, "unsupported call: %s",
ax_pdutype2string(pdu->ap_header.aph_type));
agentx_reset(ax);
break;
}
ax_pdu_free(pdu);
}
void
agentx_write(struct agentx *ax)
{
ssize_t send;
if ((send = ax_send(ax->ax_ax)) == -1) {
if (errno == EAGAIN) {
agentx_wantwrite(ax, ax->ax_fd);
return;
}
agentx_log_ax_warn(ax, "lost connection");
agentx_reset(ax);
return;
}
if (send > 0)
agentx_wantwrite(ax, ax->ax_fd);
}
RB_GENERATE_STATIC(ax_requests, agentx_request, axr_ax_requests,
agentx_request_cmp)
RB_GENERATE_STATIC(axc_objects, agentx_object, axo_axc_objects,
agentx_object_cmp)
