int
snmp_getsock(struct relayd *env, struct imsg *imsg)
{
struct timeval tv = SNMP_RECONNECT_TIMEOUT;
struct agentx_pdu *pdu;
if (imsg->fd == -1)
goto retry;
env->sc_snmp = imsg->fd;
log_debug("%s: got new snmp socket %d", __func__, imsg->fd);
if ((snmp_agentx = snmp_agentx_alloc(env->sc_snmp)) == NULL)
fatal("snmp_getsock: agentx alloc");
if ((pdu = snmp_agentx_open_pdu(snmp_agentx, "relayd", NULL)) == NULL)
fatal("snmp_getsock: agentx pdu");
(void)snmp_agentx_send(snmp_agentx, pdu);
snmp_agentx_set_callback(snmp_agentx, snmp_agentx_process, env);
snmp_event_add(env, EV_WRITE);
return (0);
retry:
evtimer_set(&env->sc_snmpto, snmp_sock, env);
evtimer_add(&env->sc_snmpto, &tv);
return (0);
}
/* ARGSUSED */
void
control_accept(int listenfd, short event, void *arg)
{
struct control_sock *cs = arg;
int connfd;
socklen_t len;
struct sockaddr_un sun;
struct ctl_conn *c;
event_add(&cs->cs_ev, NULL);
if ((event & EV_TIMEOUT))
return;
len = sizeof(sun);
if ((connfd = accept4(listenfd,
(struct sockaddr *)&sun, &len, SOCK_NONBLOCK)) == -1) {
/*
* Pause accept if we are out of file descriptors, or
* libevent will haunt us here too.
*/
if (errno == ENFILE || errno == EMFILE) {
struct timeval evtpause = { 1, 0 };
event_del(&cs->cs_ev);
evtimer_add(&cs->cs_evt, &evtpause);
} else if (errno != EWOULDBLOCK && errno != EINTR &&
errno != ECONNABORTED)
log_warn("%s: accept", __func__);
return;
}
if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
close(connfd);
log_warn("%s: calloc", __func__);
return;
}
imsg_init(&c->iev.ibuf, connfd);
if (cs->cs_agentx) {
c->handle = snmp_agentx_alloc(c->iev.ibuf.fd);
if (c->handle == NULL) {
free(c);
log_warn("%s: agentx", __func__);
return;
}
c->flags |= CTL_CONN_LOCKED;
c->iev.handler = control_dispatch_agentx;
TAILQ_INIT(&c->oids);
} else
c->iev.handler = control_dispatch_imsg;
c->iev.events = EV_READ;
c->iev.data = c;
c->cs = cs;
event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
c->iev.handler, c->iev.data);
event_add(&c->iev.ev, NULL);
TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
}
/* ARGSUSED */
void
control_dispatch_imsg(int fd, short event, void *arg)
{
struct ctl_conn *c = arg;
struct control_sock *cs = c->cs;
struct snmpd *env = cs->cs_env;
struct imsg imsg;
int n, v, i;
if (event & EV_READ) {
if (((n = imsg_read_nofd(&c->iev.ibuf)) == -1 &&
errno != EAGAIN) || n == 0) {
control_close(c, "could not read imsg", NULL);
return;
}
}
if (event & EV_WRITE) {
if (msgbuf_write(&c->iev.ibuf.w) <= 0 && errno != EAGAIN) {
control_close(c, "could not write imsg", NULL);
return;
}
}
for (;;) {
if ((n = imsg_get(&c->iev.ibuf, &imsg)) == -1) {
control_close(c, "could not get imsg", NULL);
return;
}
if (n == 0)
break;
if (cs->cs_restricted || (c->flags & CTL_CONN_LOCKED)) {
switch (imsg.hdr.type) {
case IMSG_SNMP_AGENTX:
case IMSG_SNMP_ELEMENT:
case IMSG_SNMP_END:
case IMSG_SNMP_LOCK:
break;
default:
control_close(c,
"client requested restricted command",
&imsg);
return;
}
}
control_imsg_forward(&imsg);
switch (imsg.hdr.type) {
case IMSG_CTL_NOTIFY:
if (IMSG_DATA_SIZE(&imsg))
return control_close(c, "invalid size", &imsg);
if (c->flags & CTL_CONN_NOTIFY) {
log_debug("%s: "
"client requested notify more than once",
__func__);
imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
0, 0, -1, NULL, 0);
break;
}
c->flags |= CTL_CONN_NOTIFY;
break;
case IMSG_SNMP_LOCK:
if (IMSG_DATA_SIZE(&imsg))
return control_close(c, "invalid size", &imsg);
/* enable restricted control mode */
c->flags |= CTL_CONN_LOCKED;
break;
case IMSG_SNMP_AGENTX:
if (IMSG_DATA_SIZE(&imsg))
return control_close(c, "invalid size", &imsg);
/* rendezvous with the client */
imsg_compose_event(&c->iev, IMSG_CTL_OK, 0, 0, -1, NULL, 0);
if (imsg_flush(&c->iev.ibuf) == -1) {
control_close(c,
"could not rendezvous with agentx client",
&imsg);
return;
}
/* enable AgentX socket */
c->handle = snmp_agentx_alloc(c->iev.ibuf.fd);
if (c->handle == NULL) {
control_close(c,
"could not allocate agentx socket",
&imsg);
return;
}
/* disable IMSG notifications */
c->flags &= ~CTL_CONN_NOTIFY;
c->flags |= CTL_CONN_LOCKED;
c->iev.handler = control_dispatch_agentx;
break;
case IMSG_CTL_VERBOSE:
if (IMSG_DATA_SIZE(&imsg) != sizeof(v))
return control_close(c, "invalid size", &imsg);
memcpy(&v, imsg.data, sizeof(v));
log_verbose(v);
for (i = 0; i < PROC_MAX; i++) {
if (privsep_process == PROC_CONTROL)
continue;
proc_forward_imsg(&env->sc_ps, &imsg, i, -1);
}
break;
case IMSG_CTL_RELOAD:
if (IMSG_DATA_SIZE(&imsg))
return control_close(c, "invalid size", &imsg);
proc_forward_imsg(&env->sc_ps, &imsg, PROC_PARENT, -1);
break;
default:
control_close(c, "invalid type", &imsg);
return;
}
imsg_free(&imsg);
}
imsg_event_add(&c->iev);
}
