void
mproc_enable(struct mproc *p)
{
if (p->enable == 0) {
log_trace(TRACE_MPROC, "mproc: %s -> %s: enabled",
proc_name(smtpd_process),
proc_name(p->proc));
p->enable = 1;
}
mproc_event_add(p);
}
void
m_close(struct mproc *p)
{
if (imsg_compose(&p->imsgbuf, p->m_type, p->m_peerid, p->m_pid, p->m_fd,
p->m_buf, p->m_pos) == -1)
fatal("imsg_compose");
log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
proc_name(smtpd_process),
proc_name(p->proc),
p->m_pos,
imsg_to_str(p->m_type));
mproc_event_add(p);
}
void
m_compose(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid, int fd,
void *data, size_t len)
{
imsg_compose(&p->imsgbuf, type, peerid, pid, fd, data, len);
if (type != IMSG_STAT_DECREMENT &&
type != IMSG_STAT_INCREMENT)
log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
proc_name(smtpd_process),
proc_name(p->proc),
len,
imsg_to_str(type));
mproc_event_add(p);
}
void
m_forward(struct mproc *p, struct imsg *imsg)
{
imsg_compose(&p->imsgbuf, imsg->hdr.type, imsg->hdr.peerid,
imsg->hdr.pid, imsg->fd, imsg->data,
imsg->hdr.len - sizeof(imsg->hdr));
if (imsg->hdr.type != IMSG_STAT_DECREMENT &&
imsg->hdr.type != IMSG_STAT_INCREMENT)
log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s (forward)",
proc_name(smtpd_process),
proc_name(p->proc),
imsg->hdr.len - sizeof(imsg->hdr),
imsg_to_str(imsg->hdr.type));
mproc_event_add(p);
}
void
m_composev(struct mproc *p, uint32_t type, uint32_t peerid, pid_t pid,
int fd, const struct iovec *iov, int n)
{
size_t len;
int i;
imsg_composev(&p->imsgbuf, type, peerid, pid, fd, iov, n);
len = 0;
for (i = 0; i < n; i++)
len += iov[i].iov_len;
if (type != IMSG_STAT_DECREMENT &&
type != IMSG_STAT_INCREMENT)
log_trace(TRACE_MPROC, "mproc: %s -> %s : %zu %s",
proc_name(smtpd_process),
proc_name(p->proc),
len,
imsg_to_str(type));
mproc_event_add(p);
}
static void
mproc_dispatch(int fd, short event, void *arg)
{
struct mproc *p = arg;
struct imsg imsg;
ssize_t n;
p->events = 0;
if (event & EV_READ) {
if (p->proc == PROC_CLIENT)
n = imsg_read_nofd(&p->imsgbuf);
else
n = imsg_read(&p->imsgbuf);
switch (n) {
case -1:
if (errno == EAGAIN)
break;
log_warn("warn: %s -> %s: imsg_read",
proc_name(smtpd_process), p->name);
fatal("exiting");
/* NOTREACHED */
case 0:
/* this pipe is dead, so remove the event handler */
log_debug("debug: %s -> %s: pipe closed",
proc_name(smtpd_process), p->name);
p->handler(p, NULL);
return;
default:
break;
}
}
if (event & EV_WRITE) {
n = msgbuf_write(&p->imsgbuf.w);
if (n == 0 || (n == -1 && errno != EAGAIN)) {
/* this pipe is dead, so remove the event handler */
log_debug("debug: %s -> %s: pipe closed",
proc_name(smtpd_process), p->name);
p->handler(p, NULL);
return;
}
}
for (;;) {
if ((n = imsg_get(&p->imsgbuf, &imsg)) == -1) {
if (smtpd_process == PROC_CONTROL &&
p->proc == PROC_CLIENT) {
log_warnx("warn: client sent invalid imsg "
"over control socket");
p->handler(p, NULL);
return;
}
log_warn("fatal: %s: error in imsg_get for %s",
proc_name(smtpd_process), p->name);
fatalx(NULL);
}
if (n == 0)
break;
p->handler(p, &imsg);
imsg_free(&imsg);
}
mproc_event_add(p);
}
static int
rsae_send_imsg(int flen, const unsigned char *from, unsigned char *to,
RSA *rsa, int padding, unsigned int cmd)
{
int ret = 0;
struct imsgbuf *ibuf;
struct imsg imsg;
int n, done = 0;
const void *toptr;
char *pkiname;
size_t tlen;
struct msg m;
uint64_t id;
if ((pkiname = RSA_get_ex_data(rsa, 0)) == NULL)
return (0);
/*
* Send a synchronous imsg because we cannot defer the RSA
* operation in OpenSSL's engine layer.
*/
m_create(p_ca, cmd, 0, 0, -1);
rsae_reqid++;
m_add_id(p_ca, rsae_reqid);
m_add_string(p_ca, pkiname);
m_add_data(p_ca, (const void *)from, (size_t)flen);
m_add_size(p_ca, (size_t)RSA_size(rsa));
m_add_size(p_ca, (size_t)padding);
m_flush(p_ca);
ibuf = &p_ca->imsgbuf;
while (!done) {
if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
fatalx("imsg_read");
if (n == 0)
fatalx("pipe closed");
while (!done) {
if ((n = imsg_get(ibuf, &imsg)) == -1)
fatalx("imsg_get error");
if (n == 0)
break;
log_imsg(PROC_PONY, PROC_CA, &imsg);
switch (imsg.hdr.type) {
case IMSG_CA_PRIVENC:
case IMSG_CA_PRIVDEC:
break;
default:
/* Another imsg is queued up in the buffer */
pony_imsg(p_ca, &imsg);
imsg_free(&imsg);
continue;
}
m_msg(&m, &imsg);
m_get_id(&m, &id);
if (id != rsae_reqid)
fatalx("invalid response id");
m_get_int(&m, &ret);
if (ret > 0)
m_get_data(&m, &toptr, &tlen);
m_end(&m);
if (ret > 0)
memcpy(to, toptr, tlen);
done = 1;
imsg_free(&imsg);
}
}
mproc_event_add(p_ca);
return (ret);
}
