void
snmp_agentx_process(struct agentx_handle *h, struct agentx_pdu *pdu, void *arg)
{
struct agentx_close_request_data close_hdr;
struct relayd *env = arg;
switch (pdu->request->hdr->type) {
case AGENTX_NOTIFY:
if (snmp_agentx_response(h, pdu) == -1)
break;
break;
case AGENTX_OPEN:
if (snmp_agentx_open_response(h, pdu) == -1)
break;
break;
case AGENTX_CLOSE:
snmp_agentx_read_raw(pdu, &close_hdr, sizeof(close_hdr));
log_info("snmp: agentx master has closed connection (%i)",
close_hdr.reason);
snmp_agentx_free(snmp_agentx);
env->sc_snmp = -1;
snmp_agentx = NULL;
proc_compose_imsg(env->sc_ps, snmp_procid, -1,
IMSG_SNMPSOCK, -1, NULL, 0);
break;
default:
if (snmp_agentx_response(h, pdu) == -1)
break;
break;
}
snmp_agentx_pdu_free(pdu);
return;
}
void
snmpctl_trap(int ctl_sock, struct parse_result *res)
{
struct snmp_oid oid, oid1;
struct parse_varbind *vb;
struct agentx_handle *h;
struct agentx_pdu *pdu;
void *ptr;
if ((h = snmp_agentx_fdopen(ctl_sock, "snmpctl", NULL)) == NULL)
err(1, "agentx socket");
if (ber_string2oid(res->trapoid, (struct ber_oid *)&oid) == -1)
errx(1, "bad trap oid %s", res->trapoid);
if ((pdu = snmp_agentx_notify_pdu(&oid)) == NULL)
errx(1, "notify start");
while ((vb = TAILQ_FIRST(&res->varbinds)) != NULL) {
if (ber_string2oid(vb->sm.snmp_oid,
(struct ber_oid *)&oid) == -1)
errx(1, "bad oid %s", vb->sm.snmp_oid);
switch (vb->sm.snmp_type) {
/* SNMP_GAUGE32 is handled here */
case SNMP_INTEGER32:
case SNMP_NSAPADDR:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_INTEGER,
&vb->u.d, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_OPAQUE:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_OPAQUE,
&vb->u.d, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_COUNTER32:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_COUNTER32,
&vb->u.d, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_TIMETICKS:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_TIME_TICKS,
&vb->u.d, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_UINTEGER32:
case SNMP_UNSIGNED32:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_INTEGER,
&vb->u.u, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_COUNTER64:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_COUNTER64,
&vb->u.l, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_IPADDR:
if (vb->sm.snmp_len == sizeof(struct in6_addr))
ptr = &vb->u.in6;
else
ptr = &vb->u.in4;
if (snmp_agentx_varbind(pdu, &oid, AGENTX_OPAQUE,
ptr, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_OBJECT:
if (ber_string2oid(vb->u.str,
(struct ber_oid *)&oid1) == -1)
errx(1, "invalid OID %s", vb->u.str);
if (snmp_agentx_varbind(pdu, &oid,
AGENTX_OBJECT_IDENTIFIER, &oid1,
sizeof(oid1)) == -1)
errx(1, "varbind");
break;
case SNMP_BITSTRING:
case SNMP_OCTETSTRING:
if (snmp_agentx_varbind(pdu, &oid, AGENTX_OCTET_STRING,
vb->u.str, vb->sm.snmp_len) == -1)
errx(1, "varbind");
break;
case SNMP_NULL:
/* no data beyond the OID itself */
if (snmp_agentx_varbind(pdu, &oid, AGENTX_NULL,
NULL, 0) == -1)
errx(1, "varbind");
break;
}
TAILQ_REMOVE(&res->varbinds, vb, vb_entry);
free(vb);
}
if ((pdu = snmp_agentx_request(h, pdu)) == NULL)
err(1, "request: %i", h->error);
if (snmp_agentx_response(h, pdu) == -1)
errx(1, "response: %i", h->error);
snmp_agentx_pdu_free(pdu);
if (snmp_agentx_close(h, AGENTX_CLOSE_SHUTDOWN) == -1)
err(1, "close");
}
/* ARGSUSED */
void
control_dispatch_agentx(int fd, short event, void *arg)
{
struct ctl_conn *c = arg;
struct agentx_handle *h = c->handle;
struct agentx_pdu *pdu;
struct timeval tv;
struct agentx_open_timeout to;
struct ber_oid oid;
struct agentx_close_request_data clhdr;
int closing = 0;
int evflags = 0;
int timer = 0;
int error = AGENTX_ERR_NONE;
int idx = 0, vcpylen, dlen, uptime;
char *descr, *varcpy;
varcpy = descr = NULL;
if (h->timeout != 0)
tv.tv_sec = h->timeout;
else
tv.tv_sec = AGENTX_DEFAULT_TIMEOUT;
tv.tv_usec = 0;
if (event & EV_TIMEOUT) {
log_info("subagent session '%i' timed out after %i seconds",
h->sessionid, h->timeout);
goto teardown;
}
if (event & EV_WRITE) {
if (snmp_agentx_send(h, NULL) == -1) {
if (errno != EAGAIN)
goto teardown;
/* short write */
evflags |= EV_WRITE;
timer = 1;
}
}
if (event & EV_READ) {
if ((pdu = snmp_agentx_recv(h)) == NULL) {
if (h->error) {
error = h->error;
goto respond;
}
if (errno != EAGAIN)
goto teardown;
/* short read */
timer = 1;
goto done;
}
switch (pdu->hdr->type) {
case AGENTX_OPEN:
if (snmp_agentx_read_raw(pdu, &to, sizeof(to)) == -1 ||
snmp_agentx_read_oid(pdu,
(struct snmp_oid *)&oid) == -1 ||
(descr =
snmp_agentx_read_octetstr(pdu, &dlen)) == NULL) {
error = AGENTX_ERR_PARSE_ERROR;
break;
}
log_info("opening AgentX socket for '%.*s'",
dlen, descr);
h->sessionid = pdu->hdr->sessionid =
agentx_sessionid++;
if (to.timeout != 0)
h->timeout = to.timeout;
else
h->timeout = AGENTX_DEFAULT_TIMEOUT;
break;
case AGENTX_CLOSE:
if (snmp_agentx_read_raw(pdu,
&clhdr, sizeof(clhdr)) == -1) {
error = AGENTX_ERR_PARSE_ERROR;
break;
}
closing = 1;
break;
case AGENTX_NOTIFY:
error = trap_agentx(h, pdu, &idx, &varcpy, &vcpylen);
break;
case AGENTX_PING:
/* no processing, just an empty response */
break;
case AGENTX_REGISTER: {
struct agentx_register_hdr rhdr;
struct oidlist oids;
struct oid *miboid;
uint32_t ubound = 0;
TAILQ_INIT(&oids);
if (snmp_agentx_read_raw(pdu,
&rhdr, sizeof(rhdr)) == -1 ||
snmp_agentx_read_oid(pdu,
(struct snmp_oid *)&oid) == -1) {
error = AGENTX_ERR_PARSE_ERROR;
break;
}
do {
if ((miboid = calloc(1, sizeof(*miboid))) == NULL) {
purge_registered_oids(&oids);
error = AGENTX_ERR_PARSE_ERROR;
goto dodone;
}
bcopy(&oid, &miboid->o_id, sizeof(oid));
miboid->o_flags = OID_RD|OID_WR|OID_REGISTERED;
miboid->o_session = c;
if (smi_insert(miboid) == -1) {
purge_registered_oids(&oids);
error = AGENTX_ERR_DUPLICATE_REGISTRATION;
goto dodone;
}
TAILQ_INSERT_TAIL(&oids, miboid, o_list);
} while (++oid.bo_id[rhdr.subrange] <= ubound);
while ((miboid = TAILQ_FIRST(&oids)) != NULL) {
TAILQ_REMOVE(&oids, miboid, o_list);
TAILQ_INSERT_TAIL(&c->oids, miboid, o_list);
}
dodone:
break;
}
case AGENTX_UNREGISTER: {
struct agentx_unregister_hdr uhdr;
struct oid *miboid;
uint32_t ubound = 0;
if (snmp_agentx_read_raw(pdu,
&uhdr, sizeof(uhdr)) == -1 ||
snmp_agentx_read_oid(pdu,
(struct snmp_oid *)&oid) == -1) {
error = AGENTX_ERR_PARSE_ERROR;
break;
}
do {
if ((miboid = smi_find((struct oid *)&oid)) == NULL) {
log_warnx("attempting to remove unregistered MIB");
continue;
}
if (miboid->o_session != c) {
log_warnx("attempting to remove MIB registered by other session");
continue;
}
smi_delete(miboid);
} while (++oid.bo_id[uhdr.subrange] <= ubound);
break;
}
case AGENTX_RESPONSE: {
struct snmp_message *msg = pdu->request->cookie;
struct agentx_response_data resp;
struct agentx_varbind_hdr vbhdr;
struct ber_element **elm, **iter;
if (snmp_agentx_read_response(pdu, &resp) == -1) {
msg->sm_error = SNMP_ERROR_GENERR;
goto dispatch;
}
switch (resp.error) {
case AGENTX_ERR_NONE:
break;
/* per RFC, resp.error may be an SNMP error value */
case SNMP_ERROR_TOOBIG:
case SNMP_ERROR_NOSUCHNAME:
case SNMP_ERROR_BADVALUE:
case SNMP_ERROR_READONLY:
case SNMP_ERROR_GENERR:
case SNMP_ERROR_NOACCESS:
case SNMP_ERROR_WRONGTYPE:
case SNMP_ERROR_WRONGLENGTH:
case SNMP_ERROR_WRONGENC:
case SNMP_ERROR_WRONGVALUE:
case SNMP_ERROR_NOCREATION:
case SNMP_ERROR_INCONVALUE:
case SNMP_ERROR_RESUNAVAIL:
case SNMP_ERROR_COMMITFAILED:
case SNMP_ERROR_UNDOFAILED:
case SNMP_ERROR_AUTHERROR:
case SNMP_ERROR_NOTWRITABLE:
case SNMP_ERROR_INCONNAME:
msg->sm_error = resp.error;
msg->sm_errorindex = resp.index;
break;
case AGENTX_ERR_INDEX_WRONG_TYPE:
case AGENTX_ERR_UNSUPPORTED_CONTEXT:
case AGENTX_ERR_PARSE_ERROR:
case AGENTX_ERR_REQUEST_DENIED:
case AGENTX_ERR_PROCESSING_ERROR:
default:
msg->sm_error = SNMP_ERROR_GENERR;
msg->sm_errorindex = resp.index;
break;
}
iter = elm = &msg->sm_varbindresp;
while (pdu->datalen > sizeof(struct agentx_hdr)) {
if (snmp_agentx_read_raw(pdu, &vbhdr, sizeof(vbhdr)) == -1 ||
varbind_convert(pdu, &vbhdr, elm, iter)
!= AGENTX_ERR_NONE) {
msg->sm_error = SNMP_ERROR_GENERR;
msg->sm_errorindex = msg->sm_i;
goto dispatch;
}
}
dispatch:
snmpe_dispatchmsg(msg);
break;
}
/* unimplemented, but parse and accept for now */
case AGENTX_ADD_AGENT_CAPS:
case AGENTX_REMOVE_AGENT_CAPS:
break;
/* unimplemented */
case AGENTX_GET:
case AGENTX_GET_NEXT:
case AGENTX_GET_BULK:
case AGENTX_TEST_SET:
case AGENTX_COMMIT_SET:
case AGENTX_UNDO_SET:
case AGENTX_CLEANUP_SET:
case AGENTX_INDEX_ALLOCATE:
case AGENTX_INDEX_DEALLOCATE:
error = AGENTX_ERR_REQUEST_DENIED;
break;
/* NB: by RFC, this should precede all other checks. */
default:
log_info("unknown AgentX type '%i'", pdu->hdr->type);
error = AGENTX_ERR_PARSE_ERROR;
break;
}
respond:
if (pdu)
snmp_agentx_pdu_free(pdu);
uptime = smi_getticks();
if ((pdu = snmp_agentx_response_pdu(uptime, error, idx)) == NULL) {
log_debug("failed to generate response");
free(varcpy);
control_event_add(c, fd, EV_WRITE, NULL); /* XXX -- EV_WRITE? */
return;
}
if (varcpy) {
snmp_agentx_raw(pdu, varcpy, vcpylen); /* XXX */
free(varcpy);
}
snmp_agentx_send(h, pdu);
/* Request processed, now write out response */
evflags |= EV_WRITE;
}
if (closing)
goto teardown;
done:
control_event_add(c, fd, evflags, timer ? &tv : NULL);
return;
teardown:
log_debug("subagent session '%i' destroyed", h->sessionid);
snmp_agentx_free(h);
purge_registered_oids(&c->oids);
free(varcpy);
control_close(c, "agentx teardown", NULL);
}