commit - 70b4b935ca57bbd9ba5ea767d759579b251a6b67
commit + c74c6691dc039dde5b1e331ff94da6e8ea2bbf41
blob - ac610607f059527ced5fe5d2b1521639694c5289
blob + f3e4c7bfdc6d3687dfb2360558afaf5b2e078e62
--- LICENSE.md
+++ LICENSE.md
-Copyright (c) 2019 Tracey Emery <tracey@traceyemery.net>
+Copyright (c) 2019-2026 Tracey Emery <tracey@openbsd.org>
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
blob - aa6ac9837614cafc73330204ff0b94337a054544
blob + 9143e85aa097b5693ab7c25b0cb24a1cd20541ff
--- README.md
+++ README.md
Prerequisites
-------------
-* OpenBSD 6.4 or higher
+* OpenBSD 7.7 or higher
Files
-----
make
doas make install
- doas addgroup _thingsd
+ doas groupadd _thingsd
doas useradd -d /var/empty -L daemon -g _thingsd -s /sbin/nologin _thingsd
doas cp examples/etc/rc.d/thingsd /etc/rc.d/
doas chown _thingsd /dev/[thingsd.conf devices]
blob - 28a54ea56f7d60965a2f1844dcc18046820f15b8
blob + 7925a64cc6e7a6878bfece959c24e3cdab257e64
--- thingsctl/parser.c
+++ thingsctl/parser.c
/*
- * Copyright (c) 2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2019, 2020-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
*
#include <stdlib.h>
#include <string.h>
-#include "proc.h"
#include "thingsd.h"
#include "parser.h"
case CLIENTNAME:
case SOCKETNAME:
if (!match && word != NULL && strlen(word) > 0) {
- memset(res->name, 0,
- sizeof(res->name));
- memcpy(&res->name, word, sizeof(res->name));
+ if (strlcpy(res->name, word,
+ sizeof(res->name)) >= sizeof(res->name)) {
+ fprintf(stderr, "name too long: %s\n",
+ word);
+ return (NULL);
+ }
match++;
t = &table[i];
if (t->value)
blob - 9653c711f3fe8d54f5ff0c3bbc65424e2710e0e5
blob + 03e6b1e94b5193200b97861e49d591ae6864fbd5
--- thingsctl/parser.h
+++ thingsctl/parser.h
/*
- * Copyright (c) 2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2019, 2020-2021 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
*
blob - 163c4341b7e9445c742f1acf71e5391c6f176492
blob + 9390f3d8d4e77b68d18690320d6758459097005d
--- thingsctl/thingsctl.8
+++ thingsctl/thingsctl.8
.\"
-.\" Copyright (c) 2016-2019 Tracey Emery <tracey@traceyemery.net>
+.\" Copyright (c) 2016-2019 Tracey Emery <tracey@openbsd.org>
.\"
.\" Permission to use, copy, modify, and distribute this software for any
.\" purpose with or without fee is hereby granted, provided that the above
blob - fc82ae778f297bd56c6fea165bbf6365cb2bc28b
blob + a3372f5c0dd0469103b07f87f089faa52f7877af
--- thingsctl/thingsctl.c
+++ thingsctl/thingsctl.c
/*
- * Copyright (c) 2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2019, 2020-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
* Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
* Copyright (c) 2003 Henning Brauer <henning@openbsd.org>
#include <string.h>
#include <unistd.h>
-#include "proc.h"
#include "thingsd.h"
#include "parser.h"
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
- memcpy(&sun.sun_path, sockname, sizeof(sun.sun_path));
+ if (strlcpy(sun.sun_path, sockname, sizeof(sun.sun_path)) >=
+ sizeof(sun.sun_path))
+ errx(1, "socket path too long: %s", sockname);
if (connect(ctl_sock, (struct sockaddr *)&sun, sizeof(sun)) == -1)
err(1, "connect: %s", sockname);
switch (res->action) {
case KILL_CLIENT:
imsg_compose(ibuf, IMSG_KILL_CLIENT, 0, 0, -1,
- res->name, strlen(res->name));
+ res->name, sizeof(res->name));
printf("\nKill request sent for client '%s'.\n", res->name);
done = 1;
break;
errx(1, "imsg_read error");
if (n == 0) {
if (res->action == SHOW_PACKETS)
- errx(1, "Bad thing name request, or thingsd " \
- "shutdown.\n");
+ errx(1, "Bad thing name request, or thingsd "
+ "shutdown.");
else
errx(1, "pipe closed");
}
done = 1;
break;
}
- printf("%s\n", (char *)imsg.data);
+ printf("%.*s\n",
+ (int)(imsg.hdr.len - IMSG_HEADER_SIZE),
+ (char *)imsg.data);
break;
case SHOW_THINGSD:
done = show_parent_msg(&imsg);
printf("\tParity:\t\t\t%s\n", nti->conf.parity);
break;
}
- if (strncmp(nti->conf.tcp_iface, "", PKT_BUFF) == 0)
+ if (nti->conf.tcp_iface[0] == '\0')
printf("\tBind Interface:\t\tall\n");
else
printf("\tBind Interface:\t\t%s\n",
blob - 18a8f5cc7ae4a5d0a1371eb62a70e606b9dfa0b3
blob + c14e674add016add99152a43dbcc68de8fc197e5
--- thingsd/Makefile
+++ thingsd/Makefile
PROG = thingsd
SRCS = parse.y
-SRCS += config.c control.c log.c thingsd.c proc.c
+SRCS += config.c control.c log.c thingsd.c
SRCS += sockets.c tls.c client.c
MAN = thingsd.8 thingsd.conf.5
blob - 7cf3fdc8ae66434c30e781cf46428d9468615549
blob + ab5122d0fd8fa95d2d753f9c7db311ff9975d0a0
--- thingsd/client.c
+++ thingsd/client.c
/*
- * Copyright (c) 2016, 2019, 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2016, 2019, 2020-2026 Tracey Emery <tracey@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include <tls.h>
#include <unistd.h>
-#include "proc.h"
#include "thingsd.h"
-extern volatile int client_inflight;
-extern enum privsep_procid privsep_process;
+#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
void client_write_to_things(struct packages *);
client_del(struct client *client)
{
struct socket *sock = client->sock;
- struct socket *psock = NULL, *csock = NULL;
- struct client *tclient, *uclient;
+ struct package *package, *tpkg;
- TAILQ_FOREACH_SAFE(tclient, sock->clients, entry, uclient) {
- if (client->id == tclient->id)
- TAILQ_REMOVE(sock->clients, client, entry);
- }
- log_debug("%s: disconnecting client %s (%d)", __func__, client->name,
- client->fd);
- if (client->tls)
- tls_free(client->tls_ctx);
+ TAILQ_REMOVE(sock->clients, client, entry);
- if (evtimer_initialized(&client->timeout))
- evtimer_del(&client->timeout);
-
if (client->subscribed == 0)
- log_debug("%s: client disconnected", __func__);
+ log_debug("%s: unsubscribed client disconnected (%d)", __func__,
+ client->fd);
else
log_debug("client disconnected: %s", client->name);
+ if (evtimer_initialized(&client->timeout))
+ evtimer_del(&client->timeout);
+
if (client->bev != NULL)
bufferevent_free(client->bev);
- client_inflight--;
+ if (client->tls) {
+ tls_close(client->tls_ctx);
+ tls_free(client->tls_ctx);
+ }
- if (client->subscribed == 0)
- goto done;
-
- /* account for parent/child client counts */
- if (sock->conf.child_id) {
- TAILQ_FOREACH(csock, thingsd_env->sockets, entry)
- if (csock->conf.id == sock->conf.child_id)
- break;
+ if (client->packages != NULL) {
+ TAILQ_FOREACH_SAFE(package, client->packages, entry, tpkg) {
+ TAILQ_REMOVE(client->packages, package, entry);
+ free(package);
+ }
+ free(client->packages);
}
- if (sock->conf.parent_id) {
- TAILQ_FOREACH(psock, thingsd_env->sockets, entry)
- if (psock->conf.id == sock->conf.parent_id)
- break;
- }
- sock->client_cnt--;
- if (csock != NULL)
- csock->client_cnt--;
- if (psock != NULL)
- psock->client_cnt--;
-done:
+
+ if (client->subscribed)
+ sock->client_cnt--;
+
close(client->fd);
free(client);
}
client_rd(struct bufferevent *bev, void *arg)
{
struct client *client = (struct client *)arg;
- size_t len;
- char *pkt = NULL, *npkt = NULL;
- struct package *package = NULL;
+ struct evbuffer *evb = EVBUFFER_INPUT(bev);
+ struct package *package;
+ size_t len, n;
+ u_char *pkt;
+ len = EVBUFFER_LENGTH(evb);
- client->evb = EVBUFFER_INPUT(bev);
- len = EVBUFFER_LENGTH(client->evb);
-
if (client->subscribed == 0) {
log_debug("%s: client connection established (%d)", __func__,
client->fd);
/* allow one shot at subscription so we don't get hammered */
- pkt = calloc(len, sizeof(*pkt));
- if (pkt == NULL)
- return;
-
- npkt = calloc(len, sizeof(*npkt));
- if (npkt == NULL) {
- free(pkt);
- return;
- }
-
bufferevent_disable(client->bev, EV_READ);
- evbuffer_remove(client->evb, pkt, len);
- /* peak into packet and ensure it's a subscription packet */
- if (pkt[0] == 0x7E && pkt[1] == 0x7E && pkt[2] == 0x7E) {
+ /* parse_buf() needs a NUL terminated buffer */
+ if ((pkt = calloc(1, len + 1)) == NULL) {
+ evbuffer_drain(evb, len);
+ return;
+ }
+ evbuffer_remove(evb, pkt, len);
+
+ if (len >= 3 && pkt[0] == 0x7E && pkt[1] == 0x7E &&
+ pkt[2] == 0x7E) {
log_debug("%s: subscription packet received", __func__);
- memmove(npkt, pkt+3, len-3);
- parse_buf(client, npkt, len-3);
+ parse_buf(client, pkt + 3);
if (client->subscribed) {
bufferevent_enable(client->bev,
EV_READ | EV_WRITE);
if (evtimer_initialized(&client->timeout))
- evtimer_del(&client->timeout);
+ evtimer_del(&client->timeout);
}
}
- } else if (client->subscribed) {
- /* write to things */
- if ((package = calloc(1, sizeof(*package))) == NULL)
+ free(pkt);
+ return;
+ }
+
+ while ((len = EVBUFFER_LENGTH(evb)) > 0) {
+ if ((package = calloc(1, sizeof(*package))) == NULL) {
+ evbuffer_drain(evb, len);
return;
- evbuffer_remove(client->evb, package->pkt, len);
+ }
+ n = MINIMUM(len, sizeof(package->pkt));
+ evbuffer_remove(evb, package->pkt, n);
package->thing_id = client->thing_id;
- package->len = len;
+ package->len = n;
TAILQ_INSERT_TAIL(thingsd_env->packages, package, entry);
- client_write_to_things(thingsd_env->packages);
- evbuffer_drain(client->evb, len);
}
- free(pkt);
- free(npkt);
+ client_write_to_things(thingsd_env->packages);
}
void
client_write_to_things(struct packages *packages)
{
- struct privsep *ps = thingsd_env->thingsd_ps;
- struct package *package, *tpkg, p;
- unsigned int id, what;
- int fd = -1, n, m;
- struct iovec iov[6];
- size_t c;
+ struct package *package, *tpkg;
TAILQ_FOREACH_SAFE(package, packages, entry, tpkg) {
- for (id = 0; id < PROC_MAX; id++) {
- what = ps->ps_what[id];
-
- if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
- continue;
-
- memcpy(&p, package, sizeof(p));
-
- c = 0;
- iov[c].iov_base = &p;
- iov[c++].iov_len = sizeof(p);
- if (id == PROC_PARENT) {
- /* XXX imsg code will close the fd after 1st call */
- n = -1;
- proc_range(ps, id, &n, &m);
- for (n = 0; n < m; n++) {
- /* send thing fd */
- if (proc_composev_imsg(ps, id, n,
- IMSG_DIST_CLIENT_PACKAGE, -1, fd,
- iov, c) != 0) {
- log_warn("%s: failed to compose"
- " IMSG_DIST_THING_PACKAGE"
- " imsg",
- __func__);
- return;
- }
- if (proc_flush_imsg(ps, id, n) == -1) {
- log_warn("%s: failed to flush "
- "IMSG_DIST_CLIENT_PACKAGE "
- "imsg",
- __func__);
- return;
- }
- }
- }
+ if (imsg_compose_event(socks_iev_parent,
+ IMSG_DIST_CLIENT_PACKAGE, 0, 0, -1, package,
+ sizeof(*package)) == -1) {
+ log_warn("%s: failed to compose "
+ "IMSG_DIST_CLIENT_PACKAGE imsg", __func__);
+ return;
}
+
TAILQ_REMOVE(packages, package, entry);
free(package);
}
blob - 19cc2b7944e2e1ab2aa381ca7646b44f698218ae
blob + 9e795c88908f44330fea214c5c8cc7b10b01a90d
--- thingsd/config.c
+++ thingsd/config.c
/*
- * Copyright (c) 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2020-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2015 Reyk Floeter <reyk@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
#include <errno.h>
#include <imsg.h>
-#include "proc.h"
#include "thingsd.h"
-extern enum privsep_procid privsep_process;
-
int config_setsocks_tls(struct thingsd *, struct socket *);
static int
config_settls(struct thingsd *, struct socket *,
int
config_init(struct thingsd *env)
{
- struct privsep *ps = env->thingsd_ps;
- unsigned int what;
+ if ((env->things = calloc(1, sizeof(*env->things))) == NULL)
+ return (-1);
+ if ((env->sockets = calloc(1, sizeof(*env->sockets))) == NULL)
+ return (-1);
+ if ((env->packages = calloc(1, sizeof(*env->packages))) == NULL)
+ return (-1);
+ if ((env->dead_things = calloc(1, sizeof(*env->dead_things))) == NULL)
+ return (-1);
+ env->packet_clients = calloc(1, sizeof(*env->packet_clients));
+ if (env->packet_clients == NULL)
+ return (-1);
+ TAILQ_INIT(env->things);
+ TAILQ_INIT(env->sockets);
+ TAILQ_INIT(env->packages);
+ TAILQ_INIT(env->dead_things);
+ TAILQ_INIT(env->packet_clients);
- /* Global configuration. */
- if (privsep_process == PROC_PARENT)
- env->prefork_socks = SOCKS_NUMPROC;
-
- ps->ps_what[PROC_PARENT] = CONFIG_ALL;
- ps->ps_what[PROC_SOCKS] = CONFIG_SOCKS;
-
- /* Other configuration. */
- what = ps->ps_what[privsep_process];
- if (what & CONFIG_SOCKS) {
- if ((env->things = calloc(1, sizeof(*env->things))) == NULL)
- return (-1);
- if ((env->sockets = calloc(1, sizeof(*env->sockets))) == NULL)
- return (-1);
- if ((env->packages = calloc(1, sizeof(*env->packages))) == NULL)
- return (-1);
- if ((env->dead_things = calloc(1,
- sizeof(*env->dead_things))) == NULL)
- return (-1);
- env->packet_clients = calloc(1, sizeof(*env->packet_clients));
- if (env->packet_clients == NULL)
- return (-1);
- TAILQ_INIT(env->things);
- TAILQ_INIT(env->sockets);
- TAILQ_INIT(env->packages);
- TAILQ_INIT(env->dead_things);
- TAILQ_INIT(env->packet_clients);
- }
return (0);
}
config_getcfg(struct thingsd *env, struct imsg *imsg)
{
/* nothing to do but tell parent configuration is done */
- if (privsep_process != PROC_PARENT)
- proc_compose(env->thingsd_ps, PROC_PARENT,
- IMSG_CFG_DONE, NULL, 0);
+ imsg_compose_event(socks_iev_parent, IMSG_CFG_DONE, 0, 0, -1, NULL, 0);
return (0);
}
return (-1);
}
- /* create a new socket */
if ((sock = calloc(1, sizeof(*sock))) == NULL)
return (-1);
+ if ((sock->clients = calloc(1, sizeof(*sock->clients))) == NULL) {
+ free(sock);
+ return (-1);
+ }
+ TAILQ_INIT(sock->clients);
memcpy(&sock->conf, &sock_conf, sizeof(sock->conf));
- sock->fd = imsg_get_fd(imsg);
+ /*
+ * The pointers in the config belong to the parent's address space.
+ * TLS material arrives separately via IMSG_CFG_TLS, the file names
+ * are only ever used by the parent.
+ */
+ sock->conf.tls_cert = NULL;
+ sock->conf.tls_cert_file = NULL;
+ sock->conf.tls_cert_len = 0;
+ sock->conf.tls_key = NULL;
+ sock->conf.tls_key_file = NULL;
+ sock->conf.tls_key_len = 0;
+ sock->conf.tls_ca = NULL;
+ sock->conf.tls_ca_file = NULL;
+ sock->conf.tls_ca_len = 0;
+ sock->conf.tls_crl = NULL;
+ sock->conf.tls_crl_file = NULL;
+ sock->conf.tls_crl_len = 0;
+ sock->conf.tls_ocsp_staple = NULL;
+ sock->conf.tls_ocsp_staple_file = NULL;
+ sock->conf.tls_ocsp_staple_len = 0;
+
+ if ((sock->fd = imsg_get_fd(imsg)) == -1) {
+ log_warnx("%s: listener %d arrived without a descriptor",
+ __func__, sock->conf.id);
+ free(sock->clients);
+ free(sock);
+ return (-1);
+ }
+
TAILQ_INSERT_TAIL(env->sockets, sock, entry);
return (0);
int
config_setsocks(struct thingsd *env, struct socket *sock)
{
- struct privsep *ps = env->thingsd_ps;
struct socket_config u;
- int fd = -1, n, m;
- struct iovec iov[6];
- size_t c;
- unsigned int id, what;
+ int fd, n, ret;
/* setup socket in priv process */
if (sockets_privinit(sock) == -1)
return (-1);
- for (id = 0; id < PROC_MAX; id++) {
- what = ps->ps_what[id];
+ memcpy(&u, &sock->conf, sizeof(u));
- if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
- continue;
-
- memcpy(&u, &sock->conf, sizeof(u));
-
- c = 0;
- iov[c].iov_base = &u;
- iov[c++].iov_len = sizeof(u);
- if (id == PROC_SOCKS) {
- /* XXX imsg code will close the fd after 1st call */
- n = -1;
- proc_range(ps, id, &n, &m);
- for (n = 0; n < m; n++) {
- /* send thing fd */
- if (sock->fd == -1)
- fd = -1;
- else if ((fd = dup(sock->fd)) == -1)
- return (-1);
- if (proc_composev_imsg(ps, id, n,
- IMSG_CFG_SOCKS, -1, fd, iov,
- c) != 0) {
- log_warn("%s: failed to compose "
- "IMSG_CFG_SOCKS imsg",
- __func__);
- return (-1);
- }
- if (proc_flush_imsg(ps, id, n) == -1) {
- log_warn("%s: failed to flush "
- "IMSG_CFG_SOCKS imsg",
- __func__);
- return (-1);
- }
- }
- /* Configure TLS if necessary. */
- config_setsocks_tls(env, sock);
+ /*
+ * imsg closes the passed descriptor once sent, so every sockets
+ * process gets its own dup. The flush is synchronous because the
+ * parent pledges without sendfd once configuration is finished.
+ */
+ for (n = 0; n < env->prefork_socks; n++) {
+ if (sock->fd == -1)
+ fd = -1;
+ else if ((fd = dup(sock->fd)) == -1)
+ return (-1);
+ if (imsg_compose(&parent_iev_socks[n].ibuf, IMSG_CFG_SOCKS, 0,
+ 0, fd, &u, sizeof(u)) == -1) {
+ log_warn("%s: failed to compose IMSG_CFG_SOCKS imsg",
+ __func__);
+ return (-1);
}
+ do
+ ret = imsgbuf_flush(&parent_iev_socks[n].ibuf);
+ while (ret == -1 && errno == EAGAIN);
+ if (ret == -1) {
+ log_warn("%s: failed to flush IMSG_CFG_SOCKS imsg",
+ __func__);
+ return (-1);
+ }
}
+ /* Configure TLS if necessary. */
+ config_setsocks_tls(env, sock);
+
/* Close thing socket early to prevent fd exhaustion in thingsd. */
if (sock->fd != -1) {
close(sock->fd);
config_settls(struct thingsd *env, struct socket *sock,
enum tls_config_type type, const char *label, uint8_t *data, size_t len)
{
- struct privsep *ps = env->thingsd_ps;
struct socket_config *sock_conf = &sock->conf;
struct tls_config tls;
struct iovec iov[2];
size_t c;
+ int n;
if (data == NULL || len == 0)
return (0);
- DPRINTF("%s: sending tls %s for \"%s[%u]\" to %s fd %d", __func__,
- label, sock_conf->name, sock_conf->id, ps->ps_title[PROC_SOCKS],
- sock->fd);
+ log_debug("%s: sending tls %s for \"%s[%u]\" to sockets fd %d",
+ __func__, label, sock_conf->name, sock_conf->id, sock->fd);
memset(&tls, 0, sizeof(tls));
tls.id = sock_conf->id;
iov[c].iov_base = data;
iov[c++].iov_len = tls.tls_chunk_len;
- if (proc_composev(ps, PROC_SOCKS, IMSG_CFG_TLS, iov, c) != 0) {
- log_warn("%s: failed to compose IMSG_CFG_TLS imsg for "
- "`%s'", __func__, sock_conf->name);
- return (-1);
+ for (n = 0; n < env->prefork_socks; n++) {
+ if (imsg_composev_event(&parent_iev_socks[n],
+ IMSG_CFG_TLS, 0, 0, -1, iov, c) == -1) {
+ log_warn("%s: failed to compose IMSG_CFG_TLS "
+ "imsg for `%s'", __func__,
+ sock_conf->name);
+ return (-1);
+ }
}
tls.tls_chunk_offset += tls.tls_chunk_len;
struct tls_config *tls_conf, const char *label, uint8_t *data, size_t len,
uint8_t **outdata, size_t *outlen)
{
-#ifdef DEBUG
- struct privsep *ps = env->thingsd_ps;
-#endif
+ log_debug("%s: getting tls %s (%zu:%zu@%zu) for \"%s[%u]\"",
+ __func__, label, tls_conf->tls_len, len,
+ tls_conf->tls_chunk_offset, sock_conf->name, sock_conf->id);
- DPRINTF("%s: %s %d getting tls %s (%zu:%zu@%zu) for \"%s[%u]\"",
- __func__, ps->ps_title[privsep_process], ps->ps_instance, label,
- tls_conf->tls_len, len, tls_conf->tls_chunk_offset, sock_conf->name,
- sock_conf->id);
-
if (tls_conf->tls_chunk_offset == 0) {
- *outdata = NULL;
free(*outdata);
+ *outdata = NULL;
*outlen = 0;
if ((*outdata = calloc(1, tls_conf->tls_len)) == NULL)
goto fail;
fail:
return (-1);
}
-
-void
-config_purge(struct thingsd *env, unsigned int reset)
-{
- struct privsep *ps = env->thingsd_ps;
- struct thing *thing;
- unsigned int what;
-
- what = ps->ps_what[privsep_process];
- if (what & CONFIG_SOCKS) {
- while ((thing = TAILQ_FIRST(env->things)) != NULL) {
- TAILQ_REMOVE(env->things, thing, entry);
- free(thing);
- }
- }
-}
-
-int
-config_setreset(struct thingsd *env, unsigned int reset)
-{
- struct privsep *ps = env->thingsd_ps;
- unsigned int id;
-
- for (id = 0; id < PROC_MAX; id++) {
- if (id == privsep_process)
- continue;
- proc_compose(ps, id, IMSG_CTL_RESET, &reset, sizeof(reset));
- }
-
- return (0);
-}
-
-int
-config_getreset(struct thingsd *env, struct imsg *imsg)
-{
- unsigned int mode;
-
- IMSG_SIZE_CHECK(imsg, &mode);
- memcpy(&mode, imsg->data, sizeof(mode));
-
- config_purge(env, mode);
-
- return (0);
-}
blob - d7fa4f99c86b4ee296c19214dc9ec022480622b5
blob + b787c8badc63e179b4331ace198c4de19d658f54
--- thingsd/control.c
+++ thingsd/control.c
/*
- * Copyright (c) 2020-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2020-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2010-2015 Reyk Floeter <reyk@openbsd.org>
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
*
#include <event.h>
#include <fcntl.h>
#include <imsg.h>
+#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
-#include "proc.h"
#include "thingsd.h"
#define CONTROL_BACKLOG 5
-int sockets_proc, clients_proc;
+struct control_sock {
+ const char *cs_name;
+ struct event cs_ev;
+ struct event cs_evt;
+ int cs_fd;
+ int cs_restricted;
+};
-struct ctl_connlist ctl_conns;
+struct ctl_conn {
+ TAILQ_ENTRY(ctl_conn) entry;
+ uint8_t flags;
+#define CTL_CONN_NOTIFY 0x01
+ struct imsgev iev;
+ struct sockpeercred peercred;
+ /* sockets processes still to answer this conn's list request */
+ int pending_sockets;
+ int pending_clients;
+};
+TAILQ_HEAD(ctl_connlist, ctl_conn);
+
+static struct ctl_connlist ctl_conns;
+static struct control_sock control_cs;
+static struct imsgev *control_iev_parent;
+static struct imsgev *control_iev_socks;
+static struct event ev_sigint;
+static struct event ev_sigterm;
+static struct event ev_sighup;
+static struct event ev_sigpipe;
+static struct event ev_sigusr1;
+
struct ctl_conn *control_connbyfd(int);
+int control_init(struct control_sock *);
+int control_listen(struct control_sock *);
+void control_cleanup(struct control_sock *);
void control_accept(int, short, void *);
-void control_close(struct privsep *, struct imsg *, int,
- struct control_sock *);
+void control_close(int, struct control_sock *);
void control_dispatch_imsg(int, short, void *);
-int control_dispatch_thingsd(int, struct privsep_proc *, struct imsg *);
-int control_dispatch_sockets(int, struct privsep_proc *, struct imsg *);
+void control_dispatch_thingsd(int, short, void *);
+void control_dispatch_sockets(int, short, void *);
void control_imsg_forward(struct imsg *);
-void control_run(struct privsep *, struct privsep_proc *, void *);
+void control_sighdlr(int, short, void *);
+__dead void
+ control_shutdown(void);
-static struct privsep_proc procs[] = {
- { "thingsd", PROC_PARENT, control_dispatch_thingsd },
- { "sockets", PROC_SOCKS, control_dispatch_sockets },
-};
-
-void
-control(struct privsep *ps, struct privsep_proc *p)
+__dead void
+control(int fd_parent, int *fd_socks)
{
- proc_run(ps, p, procs, nitems(procs), control_run, NULL);
-}
+ struct passwd *pw;
+ int n;
-void
-control_run(struct privsep *ps, struct privsep_proc *p, void *arg)
-{
- if (pledge("stdio cpath unix recvfd", NULL) == -1)
+ log_procinit("control");
+
+ /* the socket is bound as root, before the chroot */
+ control_cs.cs_name = THINGSD_SOCKET;
+ if (control_init(&control_cs) == -1)
+ fatalx("%s: control_init", __func__);
+
+ if ((pw = getpwnam(THINGSD_USER)) == NULL)
+ fatal("unknown user %s", THINGSD_USER);
+
+ if (chroot(pw->pw_dir) == -1)
+ fatal("%s: chroot", __func__);
+ if (chdir("/") == -1)
+ fatal("%s: chdir(\"/\")", __func__);
+
+ setproctitle("%s", "control");
+
+ if (setgroups(1, &pw->pw_gid) ||
+ setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
+ setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
+ fatal("%s: cannot drop privileges", __func__);
+
+ event_init();
+
+ signal_set(&ev_sigint, SIGINT, control_sighdlr, NULL);
+ signal_set(&ev_sigterm, SIGTERM, control_sighdlr, NULL);
+ signal_set(&ev_sighup, SIGHUP, control_sighdlr, NULL);
+ signal_set(&ev_sigpipe, SIGPIPE, control_sighdlr, NULL);
+ signal_set(&ev_sigusr1, SIGUSR1, control_sighdlr, NULL);
+ signal_add(&ev_sigint, NULL);
+ signal_add(&ev_sigterm, NULL);
+ signal_add(&ev_sighup, NULL);
+ signal_add(&ev_sigpipe, NULL);
+ signal_add(&ev_sigusr1, NULL);
+
+ if ((control_iev_parent = calloc(1, sizeof(*control_iev_parent)))
+ == NULL)
+ fatal("%s: calloc", __func__);
+ imsg_event_init(control_iev_parent, fd_parent,
+ control_dispatch_thingsd);
+
+ if ((control_iev_socks = calloc(thingsd_env->prefork_socks,
+ sizeof(*control_iev_socks))) == NULL)
+ fatal("%s: calloc", __func__);
+ for (n = 0; n < thingsd_env->prefork_socks; n++)
+ imsg_event_init(&control_iev_socks[n], fd_socks[n],
+ control_dispatch_sockets);
+
+ TAILQ_INIT(&ctl_conns);
+ if (control_listen(&control_cs) == -1)
+ fatalx("%s: control_listen", __func__);
+
+ if (pledge("stdio cpath unix", NULL) == -1)
fatal("pledge");
+
+ event_dispatch();
+
+ control_shutdown();
}
-int
-control_dispatch_sockets(int fd, struct privsep_proc *p, struct imsg *imsg)
+void
+control_sighdlr(int sig, short event, void *arg)
{
- struct ctl_conn *c;
- struct privsep *ps = p->p_ps;
- struct control_sock cs = ps->ps_csock;
- int bad = 0;
+ switch (sig) {
+ case SIGINT:
+ case SIGTERM:
+ control_shutdown();
+ break;
+ case SIGHUP:
+ case SIGPIPE:
+ case SIGUSR1:
+ /* ignore */
+ break;
+ default:
+ fatalx("%s: unexpected signal", __func__);
+ }
+}
- switch (imsg->hdr.type) {
- case IMSG_BAD_THING:
- bad = 1;
- case IMSG_GET_INFO_SOCKETS_END_DATA:
- case IMSG_GET_INFO_CLIENTS_END_DATA:
- if (imsg->hdr.type == IMSG_GET_INFO_SOCKETS_END_DATA)
- sockets_proc++;
- if (imsg->hdr.type == IMSG_GET_INFO_CLIENTS_END_DATA)
- clients_proc++;
+__dead void
+control_shutdown(void)
+{
+ struct ctl_conn *c;
+ int n;
- if (sockets_proc == thingsd_env->prefork_socks) {
- sockets_proc = 0;
- goto dispatch;
- }
+ control_cleanup(&control_cs);
- if (clients_proc == thingsd_env->prefork_socks) {
- clients_proc = 0;
- goto dispatch;
+ while ((c = TAILQ_FIRST(&ctl_conns)) != NULL) {
+ TAILQ_REMOVE(&ctl_conns, c, entry);
+ event_del(&c->iev.ev);
+ imsgbuf_clear(&c->iev.ibuf);
+ close(c->iev.ibuf.fd);
+ free(c);
+ }
+
+ event_del(&control_iev_parent->ev);
+ imsgbuf_clear(&control_iev_parent->ibuf);
+ close(control_iev_parent->ibuf.fd);
+ free(control_iev_parent);
+ for (n = 0; n < thingsd_env->prefork_socks; n++) {
+ event_del(&control_iev_socks[n].ev);
+ imsgbuf_clear(&control_iev_socks[n].ibuf);
+ close(control_iev_socks[n].ibuf.fd);
+ }
+ free(control_iev_socks);
+
+ log_info("control exiting, pid %d", getpid());
+ exit(0);
+}
+
+void
+control_dispatch_sockets(int fd, short event, void *arg)
+{
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ struct ctl_conn *c;
+ int n;
+
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost sockets process", __func__);
+ control_shutdown();
}
- break;
-dispatch:
- c = control_connbyfd(imsg->hdr.peerid);
- if (c == NULL) {
- log_warnx("%s: fd %d: not found",
- __func__, imsg->hdr.peerid);
- return (-1);
+ }
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost sockets process", __func__);
+ control_shutdown();
+ }
+ fatal("%s: imsgbuf_write", __func__);
}
+ }
- if (bad) {
- control_close(ps, imsg, imsg->hdr.peerid, &cs);
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
break;
- }
- imsg_compose_event(&c->iev, imsg->hdr.type,
- 0, 0, -1, imsg->data, IMSG_DATA_SIZE(imsg));
- break;
- case IMSG_GET_INFO_SOCKETS_DATA:
- case IMSG_GET_INFO_CLIENTS_DATA:
- c = control_connbyfd(imsg->hdr.peerid);
- if (c == NULL) {
- log_warnx("%s: fd %d: not found",
- __func__, imsg->hdr.peerid);
- return (-1);
- }
+ switch (imsg.hdr.type) {
+ case IMSG_GET_INFO_SOCKETS_END_DATA:
+ case IMSG_GET_INFO_CLIENTS_END_DATA:
+ case IMSG_GET_INFO_SOCKETS_DATA:
+ case IMSG_GET_INFO_CLIENTS_DATA:
+ c = control_connbyfd(imsg.hdr.peerid);
+ if (c == NULL) {
+ log_warnx("%s: fd %d: not found",
+ __func__, imsg.hdr.peerid);
+ break;
+ }
- if (bad) {
- control_close(ps, imsg, imsg->hdr.peerid, &cs);
+ /*
+ * Every sockets process answers the request, so the
+ * end marker is only passed on once all have replied.
+ */
+ if (imsg.hdr.type == IMSG_GET_INFO_SOCKETS_END_DATA &&
+ --c->pending_sockets > 0)
+ break;
+ if (imsg.hdr.type == IMSG_GET_INFO_CLIENTS_END_DATA &&
+ --c->pending_clients > 0)
+ break;
+
+ imsg_compose_event(&c->iev, imsg.hdr.type,
+ 0, 0, -1, imsg.data, IMSG_DATA_SIZE(&imsg));
break;
+ default:
+ log_warnx("%s: unexpected imsg %d from sockets",
+ __func__, imsg.hdr.type);
+ break;
}
-
- imsg_compose_event(&c->iev, imsg->hdr.type,
- 0, 0, -1, imsg->data, IMSG_DATA_SIZE(imsg));
- break;
- default:
- return (-1);
+ imsg_free(&imsg);
}
- return (0);
+ imsg_event_add(iev);
}
-int
-control_dispatch_thingsd(int fd, struct privsep_proc *p, struct imsg *imsg)
+void
+control_dispatch_thingsd(int fd, short event, void *arg)
{
- struct ctl_conn *c;
- struct privsep *ps = p->p_ps;
- struct control_sock cs = ps->ps_csock;
- int bad = 0;
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ struct ctl_conn *c;
+ int n, bad;
- switch (imsg->hdr.type) {
- case IMSG_BAD_THING:
- bad = 1;
- case IMSG_SHOW_PACKETS_DATA:
- case IMSG_SHOW_PACKETS_END_DATA:
- case IMSG_GET_INFO_THINGSD_DATA:
- case IMSG_GET_INFO_THINGSD_END_DATA:
- case IMSG_GET_INFO_THINGS_DATA:
- case IMSG_GET_INFO_THINGS_END_DATA:
- c = control_connbyfd(imsg->hdr.peerid);
- if (c == NULL) {
- log_warnx("%s: fd %d: not found",
- __func__, imsg->hdr.peerid);
- return (-1);
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost parent process", __func__);
+ control_shutdown();
}
+ }
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost parent process", __func__);
+ control_shutdown();
+ }
+ fatal("%s: imsgbuf_write", __func__);
+ }
+ }
- if (bad) {
- control_close(ps, imsg, imsg->hdr.peerid, &cs);
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
break;
- }
- imsg_compose_event(&c->iev, imsg->hdr.type,
- 0, 0, -1, imsg->data, IMSG_DATA_SIZE(imsg));
- break;
- case IMSG_CTL_RESET:
- case IMSG_CFG_DONE:
- case IMSG_CTL_START:
- /* don't do anything */
- break;
- default:
- return (-1);
+ bad = 0;
+ switch (imsg.hdr.type) {
+ case IMSG_BAD_THING:
+ bad = 1;
+ /* FALLTHROUGH */
+ case IMSG_SHOW_PACKETS_DATA:
+ case IMSG_SHOW_PACKETS_END_DATA:
+ case IMSG_GET_INFO_THINGSD_DATA:
+ case IMSG_GET_INFO_THINGSD_END_DATA:
+ case IMSG_GET_INFO_THINGS_DATA:
+ case IMSG_GET_INFO_THINGS_END_DATA:
+ c = control_connbyfd(imsg.hdr.peerid);
+ if (c == NULL) {
+ log_warnx("%s: fd %d: not found",
+ __func__, imsg.hdr.peerid);
+ break;
+ }
+
+ if (bad) {
+ control_close(imsg.hdr.peerid, &control_cs);
+ break;
+ }
+
+ imsg_compose_event(&c->iev, imsg.hdr.type,
+ 0, 0, -1, imsg.data, IMSG_DATA_SIZE(&imsg));
+ break;
+ case IMSG_CFG_DONE:
+ case IMSG_CTL_START:
+ /* don't do anything */
+ break;
+ default:
+ log_warnx("%s: unexpected imsg %d from parent",
+ __func__, imsg.hdr.type);
+ break;
+ }
+ imsg_free(&imsg);
}
- return (0);
+ imsg_event_add(iev);
}
int
-control_init(struct privsep *ps, struct control_sock *cs)
+control_init(struct control_sock *cs)
{
struct sockaddr_un sun;
int fd;
return (-1);
}
+ memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
- memcpy(&sun.sun_path, cs->cs_name, sizeof(sun.sun_path));
+ if (strlcpy(sun.sun_path, cs->cs_name, sizeof(sun.sun_path)) >=
+ sizeof(sun.sun_path)) {
+ log_warnx("%s: socket path too long: %s", __func__,
+ cs->cs_name);
+ close(fd);
+ return (-1);
+ }
if (unlink(cs->cs_name) == -1)
if (errno != ENOENT) {
}
cs->cs_fd = fd;
- cs->cs_env = ps;
return (0);
}
event_del(&cs->cs_ev);
event_del(&cs->cs_evt);
+ close(cs->cs_fd);
}
/* ARGSUSED */
return;
}
+ len = sizeof(c->peercred);
if (getsockopt(connfd, SOL_SOCKET, SO_PEERCRED,
&c->peercred, &len) != 0) {
log_warn("%s: failed to get peer credentials", __func__);
c->iev.handler = control_dispatch_imsg;
c->iev.events = EV_READ;
- c->iev.data = cs;
event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
- c->iev.handler, c->iev.data);
+ c->iev.handler, &c->iev);
event_add(&c->iev.ev, NULL);
TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
}
void
-control_close(struct privsep *ps, struct imsg *imsg, int fd,
- struct control_sock *cs)
+control_close(int fd, struct control_sock *cs)
{
struct ctl_conn *c;
return;
}
- if (proc_compose_imsg(ps, PROC_PARENT, -1,
- IMSG_SHOW_PACKETS_END_DATA, 0, -1,
- &fd, sizeof(fd)) == -1)
+ /* let the parent drop any packet echo registered for this conn */
+ if (imsg_compose_event(control_iev_parent, IMSG_SHOW_PACKETS_END_DATA,
+ 0, 0, -1, &fd, sizeof(fd)) == -1)
log_warn("fd not sent to thingsd to close");
imsgbuf_clear(&c->iev.ibuf);
void
control_dispatch_imsg(int fd, short event, void *arg)
{
- struct thingsd_control_info nci;
+ struct thingsd_control_info nci;
+ struct control_sock *cs = &control_cs;
+ struct ctl_conn *c;
+ struct imsg imsg;
+ int n, v, ret = 0;
+ uid_t euid;
+ gid_t egid;
- struct control_sock *cs = arg;
- struct privsep *ps = cs->cs_env;
- struct ctl_conn *c;
- struct imsg imsg;
- int n, v, ret = 0;
- uid_t euid;
- gid_t egid;
-
if (getpeereid(fd, &euid, &egid) == -1)
return;
if (event & EV_READ) {
n = imsgbuf_read(&c->iev.ibuf);
if (n == -1 || n == 0) {
- control_close(ps, &imsg, fd, cs);
+ control_close(fd, cs);
return;
}
}
if (event & EV_WRITE) {
if (imsgbuf_write(&c->iev.ibuf) == -1) {
- control_close(ps, &imsg, fd, cs);
+ control_close(fd, cs);
return;
}
}
for (;;) {
n = imsgbuf_get(&c->iev.ibuf, &imsg);
if (n == -1) {
- control_close(ps, &imsg, fd, cs);
+ control_close(fd, cs);
return;
}
IMSG_SIZE_CHECK(&imsg, &v);
memcpy(&v, imsg.data, sizeof(v));
log_setverbose(v);
- proc_forward_imsg(ps, &imsg, PROC_PARENT, -1);
+ imsg_forward_event(control_iev_parent, &imsg);
break;
case IMSG_GET_INFO_CONTROL_REQUEST:
nci.verbose = log_getverbose();
case IMSG_GET_INFO_THINGS_REQUEST:
case IMSG_GET_INFO_CLIENTS_REQUEST:
case IMSG_GET_INFO_SOCKETS_REQUEST:
+ /* the conn fd is the peerid replies are routed by */
imsg.hdr.peerid = fd;
if (euid == 0 &&
- imsg.hdr.type ==
- IMSG_GET_INFO_THINGS_REQUEST)
- imsg.hdr.type =
- IMSG_GET_INFO_THINGS_REQUEST_ROOT;
+ imsg.hdr.type == IMSG_GET_INFO_THINGS_REQUEST)
+ imsg.hdr.type = IMSG_GET_INFO_THINGS_REQUEST_ROOT;
- if (proc_compose_imsg(ps, PROC_PARENT, -1,
- imsg.hdr.type, imsg.hdr.peerid, -1,
- imsg.data, IMSG_DATA_SIZE(&imsg)) == -1) {
- control_close(ps, &imsg, fd, cs);
+ if (imsg.hdr.type == IMSG_GET_INFO_SOCKETS_REQUEST)
+ c->pending_sockets = thingsd_env->prefork_socks;
+ if (imsg.hdr.type == IMSG_GET_INFO_CLIENTS_REQUEST)
+ c->pending_clients = thingsd_env->prefork_socks;
+
+ if (imsg_forward_event(control_iev_parent,
+ &imsg) == -1) {
+ imsg_free(&imsg);
+ control_close(fd, cs);
return;
}
break;
- case IMSG_CTL_RESET:
- proc_forward_imsg(ps, &imsg, PROC_PARENT, -1);
- break;
default:
log_debug("%s: error handling imsg %d",
__func__, imsg.hdr.type);
- control_close(ps, &imsg, fd, cs);
- break;
+ imsg_free(&imsg);
+ control_close(fd, cs);
+ return;
}
imsg_free(&imsg);
}
return;
fail:
+ imsg_free(&imsg);
imsg_compose_event(&c->iev, IMSG_CTL_FAIL,
0, 0, -1, &ret, sizeof(ret));
imsgbuf_flush(&c->iev.ibuf);
- control_close(ps, &imsg, fd, cs);
+ control_close(fd, cs);
}
void
blob - eb88d359aff455ebbdc09e5aa12643167ac9ba59
blob + e032b2cec8e8ee36e30fda2bb5118da98a1e8f56
--- thingsd/examples/etc/thingsd.conf
+++ thingsd/examples/etc/thingsd.conf
udp "my_listener" {
receive on port 8080
listen on port 51000
- bing udp interface "re0"
+ bind udp interface "re0"
password "Sister"
}
}
blob - 313037de26dee3679d4f939d6491c516725611eb
blob + fca5f21b6415bca631faf17c607243db62428de0
--- thingsd/parse.y
+++ thingsd/parse.y
/*
- * Copyright (c) 2016-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2016-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2020 Matthias Pressfreund <mpfr@fn.de>
* Copyright (c) 2007 - 2015 Reyk Floeter <reyk@openbsd.org>
* Copyright (c) 2008 Gilles Chehade <gilles@openbsd.org>
#include <tls.h>
#include <unistd.h>
-#include "proc.h"
#include "thingsd.h"
TAILQ_HEAD(files, file) files = TAILQ_HEAD_INITIALIZER(files);
int symset(const char *, const char *, int);
char *symget(const char *);
-void clear_config(struct thingsd *xconf);
-
static int errors;
int get_addrs(const char *, struct addresslist *, in_port_t);
static struct thingsd *thingsd;
static struct thing *new_thing;
-const int baudrates[18] = {50, 75, 110, 134, 150, 200,
+const int baudrates[] = {50, 75, 110, 134, 150, 200,
300, 600, 1200, 1800, 2400, 4800, 9600,
- 38400, 57600, 76800, 115200};
-const char *parity[4] = {"none", "odd", "even", "space"};
-struct client *pclient, *tclient;
-char my_name[THINGSD_MAXTEXT];
-int my_fd, pkt_len;
+ 19200, 38400, 57600, 76800, 115200};
+const char *parity[] = {"none", "odd", "even"};
+struct client *pclient;
+/*
+ * The same grammar parses thingsd.conf in the parent and subscription
+ * packets in the sockets processes. yylex() hands out one of these
+ * before anything else so a packet can only ever reach the subscribe
+ * rule.
+ */
+static int start_token;
+static int parsing_pkt;
+
typedef struct {
union {
long long number;
%}
+%token CONFIG_START PKT_START
%token BAUD BIND CA CERTIFICATE CIPHERS CLIENT CLIENTS CONNECT CONNECTION CRL
%token DATA DHE ECDHE ERROR HARDWARE INCLUDE INTERFACE IPADDR KEY
%token LISTEN LOCATION MAX NAME OCSP ON OPTIONAL PARITY PASSWORD PERSISTENT
%%
-grammar : /* empty */
- | grammar include '\n'
- | grammar '\n'
- | grammar conf_main '\n'
- | grammar dosub
- | grammar error '\n' { file->errors++; }
- | grammar thing '\n'
- | grammar varset '\n'
+grammar : CONFIG_START config
+ | PKT_START optnl dosub optnl
;
+config : /* empty */
+ | config include '\n'
+ | config '\n'
+ | config conf_main '\n'
+ | config error '\n' { file->errors++; }
+ | config thing '\n'
+ | config varset '\n'
+ ;
+
conf_main : bindopts1
| maxclients
| PREFORK NUMBER {
- thingsd->prefork_socks = $2;
- if ($2 <= 0 || $2 > PROC_MAX_INSTANCES) {
+ if ($2 <= 0 || $2 > THINGSD_MAX_PREFORK) {
yyerror("invalid number of preforked "
"sockets: %lld", $2);
YYERROR;
}
+ thingsd->prefork_socks = $2;
}
| thingretry
;
yyerror("%s: thingsd tcp_iface truncated",
__func__);
free($4);
- free(thingsd);
YYERROR;
}
if (strlcpy(thingsd->udp_iface, $4,
yyerror("%s: thingsd udp_iface truncated",
__func__);
free($4);
- free(thingsd);
YYERROR;
}
free($4);
yyerror("%s: thingsd udp_iface truncated",
__func__);
free($4);
- free(thingsd);
YYERROR;
}
free($4);
yyerror("%s: new_thing tcp_iface truncated",
__func__);
free($4);
- free(new_thing);
YYERROR;
}
if (strlen(new_thing->conf.udp_iface) == 0) {
yyerror("%s: new_thing udp_iface "
"truncated", __func__);
free($4);
- free(new_thing);
YYERROR;
}
}
yyerror("%s: new_thing udp_iface truncated",
__func__);
free($4);
- free(new_thing);
YYERROR;
}
free($4);
locationopts1 : bindopts2
| BAUD NUMBER {
- int bc;
- const int bauds = (sizeof(baudrates) /
- sizeof(const int));
+ size_t bc;
+ const size_t bauds = (sizeof(baudrates) /
+ sizeof(baudrates[0]));
new_thing->conf.baud = -1;
for (bc = 0; bc < bauds; bc++) {
yyerror("%s: new_thing password truncated",
__func__);
free($2);
- free(new_thing);
YYERROR;
}
free($2);
}
| PARITY STRING {
- int pc;
- const int parities = (sizeof(parity) /
- sizeof(const char *));
+ size_t pc;
+ const size_t parities = (sizeof(parity) /
+ sizeof(parity[0]));
for (pc = 0; pc < parities; pc++) {
if (strcmp($2, parity[pc]) == 0) {
yyerror("%s: new_thing parity "
"truncated", __func__);
free($2);
- free(new_thing);
YYERROR;
}
continue;
if ($2 > 1 || $2 < 0) {
yyerror("software syntax error");
YYERROR;
- } else
+ } else if ($2 > 0)
new_thing->conf.sw_ctl = 1;
}
| STOP NUMBER {
;
maxclients : MAX CLIENTS NUMBER {
+ if ($3 < 0) {
+ yyerror("invalid max clients: %lld", $3);
+ YYERROR;
+ }
thingsd->max_clients = $3;
}
;
maxclientssub : MAX CLIENTS NUMBER {
+ if ($3 < 0) {
+ yyerror("invalid max clients: %lld", $3);
+ YYERROR;
+ }
new_thing->conf.max_clients = $3;
}
;
name : NAME optcomma STRING {
- memset(&my_name, 0, sizeof(my_name));
- memcpy(&pclient->name, $3, sizeof(pclient->name));
- memcpy(&my_name, $3, sizeof(my_name));
+ if (strlcpy(pclient->name, $3,
+ sizeof(pclient->name)) >= sizeof(pclient->name)) {
+ yyerror("client name too long");
+ free($3);
+ YYERROR;
+ }
free($3);
}
;
yyerror("%s: new_thing password truncated",
__func__);
free($2);
- free(new_thing);
YYERROR;
}
free($2);
subthings : THING '{' STRING optcomma STRING '}' {
struct socket *sock = pclient->sock, *tsock;
- struct socket *psock = NULL, *csock = NULL;
struct client *clt;
+ if (pclient->subscribed)
+ goto done;
+
+ if (pclient->name[0] == '\0') {
+ log_debug("subscription without client name");
+ goto done;
+ }
+
/* check thing name */
if ((strcmp(sock->conf.thing_name, $3)) != 0)
goto done;
/* check we have the password */
- if (strcmp(sock->conf.password, $5) != 0)
+ if (strlen(sock->conf.password) != strlen($5) ||
+ timingsafe_bcmp(sock->conf.password, $5,
+ strlen($5)) != 0)
goto done;
- /* check that ports match */
- if (sock->conf.port != pclient->port)
- goto done;
-
/*
- * XXX: check from here down don't actually work
- * when prefork is > 1
- * come back and figure this out later
- * probably a way to loop through the processes and
- * check all
+ * XXX: the duplicate name and max clients checks
+ * only see this sockets process, so with prefork
+ * greater than one they are per process limits.
*/
-
- /* check for duplicate name on socket */
TAILQ_FOREACH(tsock, thingsd_env->sockets, entry) {
TAILQ_FOREACH(clt, tsock->clients, entry) {
- if (strcmp(clt->name, my_name) == 0 &&
- clt->subscribed) {
- log_warnx("client exists");
+ if (clt->subscribed && strcmp(clt->name,
+ pclient->name) == 0) {
+ log_warnx("client exists: %s",
+ pclient->name);
goto done;
}
}
}
- /* check parent/child counts */
- if (sock->conf.child_id) {
- TAILQ_FOREACH(csock, thingsd_env->sockets,
- entry)
- if (csock->conf.id ==
- sock->conf.child_id)
- break;
- }
- if (sock->conf.parent_id) {
- TAILQ_FOREACH(psock, thingsd_env->sockets,
- entry)
- if (psock->conf.id ==
- sock->conf.parent_id)
- break;
- }
-
- /* if counts are fine, subscribe client */
if (sock->conf.max_clients > 0 &&
- (sock->client_cnt + 1 >
- sock->conf.max_clients)) {
+ sockets_thing_client_cnt(sock->conf.thing_id) >=
+ sock->conf.max_clients) {
log_debug("max clients reached for listener %d",
sock->conf.id);
- } else {
- pclient->subscribed = 1;
-
- sock->client_cnt++;
- if (csock != NULL)
- csock->client_cnt++;
- if (psock != NULL)
- psock->client_cnt++;
-
- log_debug("client %s subscribed to %s",
- pclient->name, $3);
+ goto done;
}
+
+ pclient->subscribed = 1;
+ sock->client_cnt++;
+
+ log_debug("client %s subscribed to %s",
+ pclient->name, $3);
done:
free($3);
free($5);
;
thing : THING STRING {
- thing_id++;
+ if (strlen($2) >= THINGSD_MAXNAME) {
+ yyerror("thing name too long: %s", $2);
+ free($2);
+ YYERROR;
+ }
+
+ thing_id++;
new_thing = thingsd_conf_new_thing(thingsd_env, NULL,
$2, thing_id);
-
- if (strlcpy(new_thing->conf.name, $2,
- sizeof(new_thing->conf.name)) >=
- sizeof(new_thing->conf.name)) {
- yyerror("thing name truncated");
+ if (new_thing == NULL) {
+ yyerror("thing %s already defined", $2);
free($2);
- free(new_thing);
YYERROR;
}
sizeof(new_thing->conf.name)) {
yyerror("thing name truncated");
free($2);
- free(new_thing);
YYERROR;
}
yyerror("%s: new_thing tcp_iface "
"truncated",
__func__);
- free(new_thing);
YYERROR;
}
} else
yyerror("%s: new_thing udp_iface "
"truncated",
__func__);
- free(new_thing);
YYERROR;
}
} else
yyerror("%s: new_thing ipaddr truncated",
__func__);
free($2);
- free(new_thing);
YYERROR;
}
new_thing->conf.type = S_TCP;
yyerror("%s: new_thing location truncated",
__func__);
free($2);
- free(new_thing);
YYERROR;
}
new_thing->conf.type = S_DEV;
yyerror("%s: new_thing udp truncated",
__func__);
free($2);
- free(new_thing);
YYERROR;
}
new_thing->conf.type = S_UDP;
if (vasprintf(&msg, fmt, ap) == -1)
fatalx("yyerror vasprintf");
va_end(ap);
- logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
+ if (parsing_pkt)
+ log_debug("%s: %s", file->name, msg);
+ else
+ logit(LOG_CRIT, "%s:%d: %s", file->name, yylval.lineno, msg);
free(msg);
return (0);
}
if (parsebuf) {
/* Read character from the parsebuffer instead of input. */
if (parseindex >= 0) {
- if (parsebuf == NULL)
- return (0);
- if (parseindex > pkt_len)
- return (0);
- if ((c = parsebuf[parseindex++]) != '\0')
+ c = parsebuf[parseindex++];
+ if (c != '\0')
return (c);
parsebuf = NULL;
} else
if (pushback_index)
return (pushback_buffer[--pushback_index]);
- if (quotec) {
- if (parseindex > 0) {
- /* malformed packet */
+ /* a packet has no stream behind it, the buffer is all there is */
+ if (parsing_pkt) {
+ if (quotec)
yyerror("reached end of packet while parsing "
- "quoted string");
- return (-1);
- }
+ "quoted string");
+ return (EOF);
+ }
+
+ if (quotec) {
c = getc(file->stream);
if (c == EOF)
yyerror("reached end of file while parsing "
int quotec, next, c;
int token;
+ if (start_token) {
+ token = start_token;
+ start_token = 0;
+ return (token);
+ }
+
top:
p = buf;
while ((c = lgetc(0)) == ' ' || c == '\t')
thingsd = env;
thingsd->conn_retry = CONN_RETRY;
- /* thingsd->dead_things->run = 1; */
+ thingsd->prefork_socks = SOCKS_NUMPROC;
thingsd->run = 1;
+ parsing_pkt = 0;
+ start_token = CONFIG_START;
yyparse();
errors = file->errors;
closefile(file);
if ((sym = malloc(len)) == NULL)
fatal("%s: malloc", __func__);
- memcpy(&sym, s, len);
+ memcpy(sym, s, len - 1);
+ sym[len - 1] = '\0';
ret = symset(sym, val + 1, 1);
free(sym);
}
int
-parse_buf(struct client *client, u_char *pkt, int len)
+parse_buf(struct client *client, u_char *pkt)
{
- pkt_len = len;
pclient = client;
- my_fd = client->fd;
if ((file = newbuff(pkt)) == NULL)
return (-1);
+ /* nothing from a previous packet may leak into this one */
+ pushback_index = 0;
+ parseindex = 0;
+ parsing_pkt = 1;
+ start_token = PKT_START;
+
yyparse();
errors = file->errors;
closebuff(file);
+ parsebuf = NULL;
+ pclient = NULL;
return (errors ? -1 : 0);
}
-void
-clear_config(struct thingsd *xconf)
-{
- struct thing *thing;
-
- while ((thing = TAILQ_FIRST(xconf->things)) != NULL) {
- TAILQ_REMOVE(xconf->things, thing, entry);
- free(thing);
- }
-
- free(xconf);
-}
-
int
getservice(char *n)
{
blob - 4417dd0e55b3c89efebb76345cd94e981c439a68 (mode 644)
blob + /dev/null
--- thingsd/proc.c
+++ /dev/null
-/*
- * Copyright (c) 2010 - 2016 Reyk Floeter <reyk@openbsd.org>
- * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-#include <sys/queue.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
-#include <paths.h>
-#include <pwd.h>
-#include <event.h>
-#include <imsg.h>
-
-#include "proc.h"
-#include "thingsd.h"
-
-void proc_exec(struct privsep *, struct privsep_proc *, unsigned int, int,
- int, char **);
-void proc_setup(struct privsep *, struct privsep_proc *, unsigned int);
-void proc_open(struct privsep *, int, int);
-void proc_accept(struct privsep *, int, enum privsep_procid,
- unsigned int);
-void proc_close(struct privsep *);
-int proc_ispeer(struct privsep_proc *, unsigned int, enum privsep_procid);
-void proc_shutdown(struct privsep_proc *);
-void proc_sig_handler(int, short, void *);
-void proc_range(struct privsep *, enum privsep_procid, int *, int *);
-int proc_dispatch_null(int, struct privsep_proc *, struct imsg *);
-
-enum privsep_procid privsep_process;
-
-int
-proc_ispeer(struct privsep_proc *procs, unsigned int nproc,
- enum privsep_procid type)
-{
- unsigned int i;
-
- for (i = 0; i < nproc; i++)
- if (procs[i].p_id == type)
- return (1);
- return (0);
-}
-
-enum privsep_procid
-proc_getid(struct privsep_proc *procs, unsigned int nproc,
- const char *proc_name)
-{
- struct privsep_proc *p;
- unsigned int proc;
-
- for (proc = 0; proc < nproc; proc++) {
- p = &procs[proc];
- if (strcmp(p->p_title, proc_name))
- continue;
-
- return (p->p_id);
- }
-
- return (PROC_MAX);
-}
-
-void
-proc_exec(struct privsep *ps, struct privsep_proc *procs, unsigned int nproc,
- int debug, int argc, char **argv)
-{
- unsigned int proc, nargc, i, proc_i;
- char **nargv;
- struct privsep_proc *p;
- char num[32];
- int fd;
-
- /* Prepare the new process argv. */
- nargv = calloc(argc + 5, sizeof(char *));
- if (nargv == NULL)
- fatal("%s: calloc", __func__);
-
- /* Copy call argument first. */
- nargc = 0;
- nargv[nargc++] = argv[0];
-
- /* Set process name argument and save the position. */
- nargv[nargc++] = "-P";
- proc_i = nargc;
- nargc++;
-
- /* Point process instance arg to stack and copy the original args. */
- nargv[nargc++] = "-I";
- nargv[nargc++] = num;
- for (i = 1; i < (unsigned int) argc; i++)
- nargv[nargc++] = argv[i];
-
- nargv[nargc] = NULL;
-
- for (proc = 0; proc < nproc; proc++) {
- p = &procs[proc];
-
- /* Update args with process title. */
- nargv[proc_i] = (char *)(uintptr_t)p->p_title;
-
- /* Fire children processes. */
- for (i = 0; i < ps->ps_instances[p->p_id]; i++) {
- /* Update the process instance number. */
- snprintf(num, sizeof(num), "%u", i);
-
- fd = ps->ps_pipes[p->p_id][i].pp_pipes[PROC_PARENT][0];
- ps->ps_pipes[p->p_id][i].pp_pipes[PROC_PARENT][0] = -1;
-
- switch (fork()) {
- case -1:
- fatal("%s: fork", __func__);
- break;
- case 0:
- /* First create a new session */
- if (setsid() == -1)
- fatal("setsid");
-
- /* Prepare parent socket. */
- if (fd != PROC_PARENT_SOCK_FILENO) {
- if (dup2(fd, PROC_PARENT_SOCK_FILENO)
- == -1)
- fatal("dup2");
- } else if (fcntl(fd, F_SETFD, 0) == -1)
- fatal("fcntl");
-
- /* Daemons detach from terminal. */
- if (!debug && (fd =
- open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
- (void)dup2(fd, STDIN_FILENO);
- (void)dup2(fd, STDOUT_FILENO);
- (void)dup2(fd, STDERR_FILENO);
- if (fd > 2)
- (void)close(fd);
- }
-
- execvp(argv[0], nargv);
- fatal("%s: execvp", __func__);
- break;
- default:
- /* Close child end. */
- close(fd);
- break;
- }
- }
- }
- free(nargv);
-}
-
-void
-proc_connect(struct privsep *ps)
-{
- struct imsgev *iev;
- unsigned int src, dst, inst;
-
- /* Don't distribute any sockets if we are not really going to run. */
- if (ps->ps_noaction)
- return;
-
- for (dst = 0; dst < PROC_MAX; dst++) {
- /* We don't communicate with ourselves. */
- if (dst == PROC_PARENT)
- continue;
-
- for (inst = 0; inst < ps->ps_instances[dst]; inst++) {
- iev = &ps->ps_ievs[dst][inst];
- if (imsgbuf_init(&iev->ibuf,
- ps->ps_pp->pp_pipes[dst][inst]) == -1)
- fatal(NULL);
- imsgbuf_allow_fdpass(&iev->ibuf);
- event_set(&iev->ev, iev->ibuf.fd, iev->events,
- iev->handler, iev->data);
- event_add(&iev->ev, NULL);
- }
- }
-
- /* Distribute the socketpair()s for everyone. */
- for (src = 0; src < PROC_MAX; src++)
- for (dst = src; dst < PROC_MAX; dst++) {
- /* Parent already distributed its fds. */
- if (src == PROC_PARENT || dst == PROC_PARENT)
- continue;
-
- proc_open(ps, src, dst);
- }
-}
-
-void
-proc_init(struct privsep *ps, struct privsep_proc *procs, unsigned int nproc,
- int debug, int argc, char **argv, enum privsep_procid proc_id)
-{
- struct privsep_proc *p = NULL;
- struct privsep_pipes *pa, *pb;
- unsigned int proc;
- unsigned int dst;
- int fds[2];
-
- /* Don't initiate anything if we are not really going to run. */
- if (ps->ps_noaction)
- return;
-
- if (proc_id == PROC_PARENT) {
- privsep_process = PROC_PARENT;
- proc_setup(ps, procs, nproc);
-
- /*
- * Create the children sockets so we can use them
- * to distribute the rest of the socketpair()s using
- * proc_connect() later.
- */
- for (dst = 0; dst < PROC_MAX; dst++) {
- /* Don't create socket for ourselves. */
- if (dst == PROC_PARENT)
- continue;
-
- for (proc = 0; proc < ps->ps_instances[dst]; proc++) {
- pa = &ps->ps_pipes[PROC_PARENT][0];
- pb = &ps->ps_pipes[dst][proc];
- if (socketpair(AF_UNIX,
- SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
- PF_UNSPEC, fds) == -1)
- fatal("%s: socketpair", __func__);
-
- pa->pp_pipes[dst][proc] = fds[0];
- pb->pp_pipes[PROC_PARENT][0] = fds[1];
- }
- }
-
- /* Engage! */
- proc_exec(ps, procs, nproc, debug, argc, argv);
- return;
- }
-
- /* Initialize a child */
- for (proc = 0; proc < nproc; proc++) {
- if (procs[proc].p_id != proc_id)
- continue;
- p = &procs[proc];
- break;
- }
- if (p == NULL || p->p_init == NULL)
- fatalx("%s: process %d missing process initialization",
- __func__, proc_id);
-
- p->p_init(ps, p);
-
- fatalx("failed to initiate child process");
-}
-
-void
-proc_accept(struct privsep *ps, int fd, enum privsep_procid dst,
- unsigned int n)
-{
- struct privsep_pipes *pp = ps->ps_pp;
- struct imsgev *iev;
-
- if (ps->ps_ievs[dst] == NULL) {
-#if DEBUG > 1
- log_debug("%s: %s src %d %d to dst %d %d not connected",
- __func__, ps->ps_title[privsep_process],
- privsep_process, ps->ps_instance + 1,
- dst, n + 1);
-#endif
- close(fd);
- return;
- }
-
- if (pp->pp_pipes[dst][n] != -1) {
- log_warnx("%s: duplicated descriptor", __func__);
- close(fd);
- return;
- } else
- pp->pp_pipes[dst][n] = fd;
-
- iev = &ps->ps_ievs[dst][n];
- if (imsgbuf_init(&iev->ibuf, fd) == -1)
- fatal(NULL);
- imsgbuf_allow_fdpass(&iev->ibuf);
- event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev->data);
- event_add(&iev->ev, NULL);
-}
-
-void
-proc_setup(struct privsep *ps, struct privsep_proc *procs, unsigned int nproc)
-{
- unsigned int i, j, src, dst, id;
- struct privsep_pipes *pp;
-
- /* Initialize parent title, ps_instances and procs. */
- ps->ps_title[PROC_PARENT] = "parent";
-
- for (src = 0; src < PROC_MAX; src++)
- /* Default to 1 process instance */
- if (ps->ps_instances[src] < 1)
- ps->ps_instances[src] = 1;
-
- for (src = 0; src < nproc; src++) {
- procs[src].p_ps = ps;
- if (procs[src].p_cb == NULL)
- procs[src].p_cb = proc_dispatch_null;
-
- id = procs[src].p_id;
- ps->ps_title[id] = procs[src].p_title;
- if ((ps->ps_ievs[id] = calloc(ps->ps_instances[id],
- sizeof(struct imsgev))) == NULL)
- fatal("%s: calloc", __func__);
-
- /* With this set up, we are ready to call imsg_init(). */
- for (i = 0; i < ps->ps_instances[id]; i++) {
- ps->ps_ievs[id][i].handler = proc_dispatch;
- ps->ps_ievs[id][i].events = EV_READ;
- ps->ps_ievs[id][i].proc = &procs[src];
- ps->ps_ievs[id][i].data = &ps->ps_ievs[id][i];
- }
- }
-
- /*
- * Allocate pipes for all process instances (incl. parent)
- *
- * - ps->ps_pipes: N:M mapping
- * N source processes connected to M destination processes:
- * [src][instances][dst][instances], for example
- * [PROC_RELAY][3][PROC_CA][3]
- *
- * - ps->ps_pp: per-process 1:M part of ps->ps_pipes
- * Each process instance has a destination array of socketpair fds:
- * [dst][instances], for example
- * [PROC_PARENT][0]
- */
- for (src = 0; src < PROC_MAX; src++) {
- /* Allocate destination array for each process */
- if ((ps->ps_pipes[src] = calloc(ps->ps_instances[src],
- sizeof(struct privsep_pipes))) == NULL)
- fatal("%s: calloc", __func__);
-
- for (i = 0; i < ps->ps_instances[src]; i++) {
- pp = &ps->ps_pipes[src][i];
-
- for (dst = 0; dst < PROC_MAX; dst++) {
- /* Allocate maximum fd integers */
- if ((pp->pp_pipes[dst] =
- calloc(ps->ps_instances[dst],
- sizeof(int))) == NULL)
- fatal("%s: calloc", __func__);
-
- /* Mark fd as unused */
- for (j = 0; j < ps->ps_instances[dst]; j++)
- pp->pp_pipes[dst][j] = -1;
- }
- }
- }
-
- ps->ps_pp = &ps->ps_pipes[privsep_process][ps->ps_instance];
-}
-
-void
-proc_kill(struct privsep *ps)
-{
- char *cause;
- pid_t pid;
- int len, status;
-
- if (privsep_process != PROC_PARENT)
- return;
-
- proc_close(ps);
-
- do {
- pid = waitpid(WAIT_ANY, &status, 0);
- if (pid <= 0)
- continue;
-
- if (WIFSIGNALED(status)) {
- len = asprintf(&cause, "terminated; signal %d",
- WTERMSIG(status));
- } else if (WIFEXITED(status)) {
- if (WEXITSTATUS(status) != 0)
- len = asprintf(&cause, "exited abnormally");
- else
- len = 0;
- } else
- len = -1;
-
- if (len == 0) {
- /* child exited OK, don't print a warning message */
- } else if (len != -1) {
- log_warnx("lost child: pid %u %s", pid, cause);
- free(cause);
- } else
- log_warnx("lost child: pid %u", pid);
- } while (pid != -1 || errno == EINTR);
-}
-
-void
-proc_open(struct privsep *ps, int src, int dst)
-{
- struct privsep_pipes *pa, *pb;
- struct privsep_fd pf;
- int fds[2];
- unsigned int i, j;
-
- /* Exchange pipes between process. */
- for (i = 0; i < ps->ps_instances[src]; i++) {
- for (j = 0; j < ps->ps_instances[dst]; j++) {
- /* Don't create sockets for ourself. */
- if (src == dst && i == j)
- continue;
-
- pa = &ps->ps_pipes[src][i];
- pb = &ps->ps_pipes[dst][j];
- if (socketpair(AF_UNIX,
- SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC,
- PF_UNSPEC, fds) == -1)
- fatal("%s: socketpair", __func__);
-
- pa->pp_pipes[dst][j] = fds[0];
- pb->pp_pipes[src][i] = fds[1];
-
- pf.pf_procid = src;
- pf.pf_instance = i;
- if (proc_compose_imsg(ps, dst, j, IMSG_CTL_PROCFD,
- -1, pb->pp_pipes[src][i], &pf, sizeof(pf)) == -1)
- fatal("%s: proc_compose_imsg", __func__);
-
- pf.pf_procid = dst;
- pf.pf_instance = j;
- if (proc_compose_imsg(ps, src, i, IMSG_CTL_PROCFD,
- -1, pa->pp_pipes[dst][j], &pf, sizeof(pf)) == -1)
- fatal("%s: proc_compose_imsg", __func__);
-
- /*
- * We have to flush to send the descriptors and close
- * them to avoid the fd ramp on startup.
- */
- if (proc_flush_imsg(ps, src, i) == -1 ||
- proc_flush_imsg(ps, dst, j) == -1)
- fatal("%s: imsg_flush", __func__);
- }
- }
-}
-
-void
-proc_close(struct privsep *ps)
-{
- unsigned int dst, n;
- struct privsep_pipes *pp;
-
- if (ps == NULL)
- return;
-
- pp = ps->ps_pp;
-
- for (dst = 0; dst < PROC_MAX; dst++) {
- if (ps->ps_ievs[dst] == NULL)
- continue;
-
- for (n = 0; n < ps->ps_instances[dst]; n++) {
- if (pp->pp_pipes[dst][n] == -1)
- continue;
-
- /* Cancel the fd, close and invalidate the fd */
- event_del(&(ps->ps_ievs[dst][n].ev));
- imsgbuf_clear(&(ps->ps_ievs[dst][n].ibuf));
- close(pp->pp_pipes[dst][n]);
- pp->pp_pipes[dst][n] = -1;
- }
- free(ps->ps_ievs[dst]);
- }
-}
-
-void
-proc_shutdown(struct privsep_proc *p)
-{
- struct privsep *ps = p->p_ps;
-
- if (p->p_id == PROC_CONTROL && ps)
- control_cleanup(&ps->ps_csock);
-
- if (p->p_shutdown != NULL)
- (*p->p_shutdown)();
-
- proc_close(ps);
-
- log_info("%s exiting, pid %d", p->p_title, getpid());
-
- exit(0);
-}
-
-void
-proc_sig_handler(int sig, short event, void *arg)
-{
- struct privsep_proc *p = arg;
-
- switch (sig) {
- case SIGINT:
- case SIGTERM:
- proc_shutdown(p);
- break;
- case SIGCHLD:
- case SIGHUP:
- case SIGPIPE:
- case SIGUSR1:
- /* ignore */
- break;
- default:
- fatalx("%s: unexpected signal", __func__);
- /* NOTREACHED */
- }
-}
-
-void
-proc_run(struct privsep *ps, struct privsep_proc *p,
- struct privsep_proc *procs, unsigned int nproc,
- void (*run)(struct privsep *, struct privsep_proc *, void *), void *arg)
-{
- struct passwd *pw;
- const char *root;
- struct control_sock *rcs;
-
- log_procinit(p->p_title);
-
- /* Set the process group of the current process */
- setpgid(0, 0);
-
- if (p->p_id == PROC_CONTROL && ps->ps_instance == 0) {
- if (control_init(ps, &ps->ps_csock) == -1)
- fatalx("%s: control_init", __func__);
- TAILQ_FOREACH(rcs, &ps->ps_rcsocks, cs_entry)
- if (control_init(ps, rcs) == -1)
- fatalx("%s: control_init", __func__);
- }
-
- /* Use non-standard user */
- if (p->p_pw != NULL)
- pw = p->p_pw;
- else
- pw = ps->ps_pw;
-
- /* Change root directory */
- if (p->p_chroot != NULL)
- root = p->p_chroot;
- else
- root = pw->pw_dir;
-
- if (chroot(root) == -1)
- fatal("%s: chroot", __func__);
- if (chdir("/") == -1)
- fatal("%s: chdir(\"/\")", __func__);
-
- privsep_process = p->p_id;
-
- setproctitle("%s", p->p_title);
-
- if (setgroups(1, &pw->pw_gid) ||
- setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
- setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
- fatal("%s: cannot drop privileges", __func__);
-
- event_init();
-
- signal_set(&ps->ps_evsigint, SIGINT, proc_sig_handler, p);
- signal_set(&ps->ps_evsigterm, SIGTERM, proc_sig_handler, p);
- signal_set(&ps->ps_evsigchld, SIGCHLD, proc_sig_handler, p);
- signal_set(&ps->ps_evsighup, SIGHUP, proc_sig_handler, p);
- signal_set(&ps->ps_evsigpipe, SIGPIPE, proc_sig_handler, p);
- signal_set(&ps->ps_evsigusr1, SIGUSR1, proc_sig_handler, p);
-
- signal_add(&ps->ps_evsigint, NULL);
- signal_add(&ps->ps_evsigterm, NULL);
- signal_add(&ps->ps_evsigchld, NULL);
- signal_add(&ps->ps_evsighup, NULL);
- signal_add(&ps->ps_evsigpipe, NULL);
- signal_add(&ps->ps_evsigusr1, NULL);
-
- proc_setup(ps, procs, nproc);
- proc_accept(ps, PROC_PARENT_SOCK_FILENO, PROC_PARENT, 0);
- if (p->p_id == PROC_CONTROL && ps->ps_instance == 0) {
- TAILQ_INIT(&ctl_conns);
- if (control_listen(&ps->ps_csock) == -1)
- fatalx("%s: control_listen", __func__);
- TAILQ_FOREACH(rcs, &ps->ps_rcsocks, cs_entry)
- if (control_listen(rcs) == -1)
- fatalx("%s: control_listen", __func__);
- }
-
- DPRINTF("%s: %s %d/%d, pid %d", __func__, p->p_title,
- ps->ps_instance + 1, ps->ps_instances[p->p_id], getpid());
-
- if (run != NULL)
- run(ps, p, arg);
-
- event_dispatch();
-
- proc_shutdown(p);
-}
-
-void
-proc_dispatch(int fd, short event, void *arg)
-{
- struct imsgev *iev = arg;
- struct privsep_proc *p = iev->proc;
- struct privsep *ps = p->p_ps;
- struct imsgbuf *ibuf;
- struct imsg imsg;
- int n, verbose;
- const char *title;
- struct privsep_fd pf;
-
- title = ps->ps_title[privsep_process];
- ibuf = &iev->ibuf;
-
- if (event & EV_READ) {
- if ((n = imsgbuf_read(ibuf)) == -1)
- fatal("%s: imsg_read", __func__);
- if (n == 0) {
- /* this pipe is dead, so remove the event handler */
- event_del(&iev->ev);
- event_loopexit(NULL);
- return;
- }
- }
-
- if (event & EV_WRITE) {
- if ((n = imsgbuf_write(ibuf)) == -1) {
- if (errno == EPIPE) {
- /* this pipe is dead */
- event_del(&iev->ev);
- event_loopexit(NULL);
- return;
- }
- fatal("%s: msgbuf_write", __func__);
- }
- }
-
- for (;;) {
- if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
- fatal("%s: imsgbuf_get", __func__);
- if (n == 0)
- break;
-
-#if DEBUG > 1
- log_debug("%s: %s %d got imsg %d peerid %d from %s %d",
- __func__, title, ps->ps_instance + 1,
- imsg.hdr.type, imsg.hdr.peerid, p->p_title, imsg.hdr.pid);
-#endif
-
- /*
- * Check the message with the program callback
- */
- if ((p->p_cb)(fd, p, &imsg) == 0) {
- /* Message was handled by the callback, continue */
- imsg_free(&imsg);
- continue;
- }
-
- /*
- * Generic message handling
- */
- switch (imsg.hdr.type) {
- case IMSG_CTL_VERBOSE:
- IMSG_SIZE_CHECK(&imsg, &verbose);
- memcpy(&verbose, imsg.data, sizeof(verbose));
- log_setverbose(verbose);
- break;
- case IMSG_CTL_PROCFD:
- IMSG_SIZE_CHECK(&imsg, &pf);
- memcpy(&pf, imsg.data, sizeof(pf));
- proc_accept(ps, imsg_get_fd(&imsg), pf.pf_procid,
- pf.pf_instance);
- break;
- default:
- /*
- * change from fatalx
- * just because it's bad doesn't mean we should crash
- */
- log_warnx("%s: %s %d got invalid imsg %d peerid %d "
- "from %s %d",
- __func__, title, ps->ps_instance + 1,
- imsg.hdr.type, imsg.hdr.peerid,
- p->p_title, imsg.hdr.pid);
- }
- imsg_free(&imsg);
- }
- imsg_event_add(iev);
-}
-
-int
-proc_dispatch_null(int fd, struct privsep_proc *p, struct imsg *imsg)
-{
- return (-1);
-}
-
-/*
- * imsg helper functions
- */
-
-void
-imsg_event_add(struct imsgev *iev)
-{
- if (iev->handler == NULL) {
- imsgbuf_flush(&iev->ibuf);
- return;
- }
-
- iev->events = EV_READ;
- if (imsgbuf_queuelen(&iev->ibuf) > 0)
- iev->events |= EV_WRITE;
-
- event_del(&iev->ev);
- event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev->data);
- event_add(&iev->ev, NULL);
-}
-
-int
-imsg_compose_event(struct imsgev *iev, uint16_t type, uint32_t peerid,
- pid_t pid, int fd, void *data, uint16_t datalen)
-{
- int ret;
-
- if ((ret = imsg_compose(&iev->ibuf, type, peerid,
- pid, fd, data, datalen)) == -1)
- return (ret);
- imsg_event_add(iev);
- return (ret);
-}
-
-int
-imsg_composev_event(struct imsgev *iev, uint16_t type, uint32_t peerid,
- pid_t pid, int fd, const struct iovec *iov, int iovcnt)
-{
- int ret;
-
- if ((ret = imsg_composev(&iev->ibuf, type, peerid,
- pid, fd, iov, iovcnt)) == -1)
- return (ret);
- imsg_event_add(iev);
- return (ret);
-}
-
-void
-proc_range(struct privsep *ps, enum privsep_procid id, int *n, int *m)
-{
- if (*n == -1) {
- /* Use a range of all target instances */
- *n = 0;
- *m = ps->ps_instances[id];
- } else {
- /* Use only a single slot of the specified peer process */
- *m = *n + 1;
- }
-}
-
-int
-proc_compose_imsg(struct privsep *ps, enum privsep_procid id, int n,
- uint16_t type, uint32_t peerid, int fd, void *data, uint16_t datalen)
-{
- int m;
-
- proc_range(ps, id, &n, &m);
- for (; n < m; n++) {
- if (imsg_compose_event(&ps->ps_ievs[id][n],
- type, peerid, ps->ps_instance + 1, fd, data, datalen) == -1)
- return (-1);
- }
-
- return (0);
-}
-
-int
-proc_compose(struct privsep *ps, enum privsep_procid id,
- uint16_t type, void *data, uint16_t datalen)
-{
- return (proc_compose_imsg(ps, id, -1, type, -1, -1, data, datalen));
-}
-
-int
-proc_composev_imsg(struct privsep *ps, enum privsep_procid id, int n,
- uint16_t type, uint32_t peerid, int fd, const struct iovec *iov, int iovcnt)
-{
- int m;
-
- proc_range(ps, id, &n, &m);
- for (; n < m; n++)
- if (imsg_composev_event(&ps->ps_ievs[id][n],
- type, peerid, ps->ps_instance + 1, fd, iov, iovcnt) == -1)
- return (-1);
-
- return (0);
-}
-
-int
-proc_composev(struct privsep *ps, enum privsep_procid id,
- uint16_t type, const struct iovec *iov, int iovcnt)
-{
- return (proc_composev_imsg(ps, id, -1, type, -1, -1, iov, iovcnt));
-}
-
-int
-proc_forward_imsg(struct privsep *ps, struct imsg *imsg,
- enum privsep_procid id, int n)
-{
- return (proc_compose_imsg(ps, id, n, imsg->hdr.type,
- imsg->hdr.peerid, imsg_get_fd(imsg), imsg->data,
- IMSG_DATA_SIZE(imsg)));
-}
-
-struct imsgbuf *
-proc_ibuf(struct privsep *ps, enum privsep_procid id, int n)
-{
- int m;
-
- proc_range(ps, id, &n, &m);
- return (&ps->ps_ievs[id][n].ibuf);
-}
-
-struct imsgev *
-proc_iev(struct privsep *ps, enum privsep_procid id, int n)
-{
- int m;
-
- proc_range(ps, id, &n, &m);
- return (&ps->ps_ievs[id][n]);
-}
-
-/* This function should only be called with care as it breaks async I/O */
-int
-proc_flush_imsg(struct privsep *ps, enum privsep_procid id, int n)
-{
- struct imsgbuf *ibuf;
- int m, ret = 0;
-
- proc_range(ps, id, &n, &m);
- for (; n < m; n++) {
- if ((ibuf = proc_ibuf(ps, id, n)) == NULL)
- return (-1);
- do {
- ret = imsgbuf_flush(ibuf);
- } while (ret == -1 && errno == EAGAIN);
- if (ret == -1)
- break;
- imsg_event_add(&ps->ps_ievs[id][n]);
- }
-
- return (ret);
-}
blob - 99340c3a5cf75f7edec9d22a35af02b89678136e (mode 644)
blob + /dev/null
--- thingsd/proc.h
+++ /dev/null
-/*
- * Copyright (c) 2010-2015 Reyk Floeter <reyk@openbsd.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-enum {
- IMSG_NONE,
- IMSG_CTL_OK,
- IMSG_CTL_FAIL,
- IMSG_CTL_VERBOSE,
- IMSG_CTL_NOTIFY,
- IMSG_CTL_RESET,
- IMSG_CTL_PROCFD,
- IMSG_PROC_MAX
-};
-
-/* imsg */
-struct imsgev {
- struct imsgbuf ibuf;
- void (*handler)(int, short, void *);
- struct event ev;
- struct privsep_proc *proc;
- void *data;
- short events;
-};
-
-#define IMSG_SIZE_CHECK(imsg, p) do { \
- if (IMSG_DATA_SIZE(imsg) < sizeof(*p)) \
- fatalx("bad length imsg received (%s)", #p); \
-} while (0)
-#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE)
-
-/* control socket */
-struct control_sock {
- const char *cs_name;
- struct event cs_ev;
- struct event cs_evt;
- int cs_fd;
- int cs_restricted;
- void *cs_env;
-
- TAILQ_ENTRY(control_sock) cs_entry;
-};
-TAILQ_HEAD(control_socks, control_sock);
-
-struct ctl_conn {
- TAILQ_ENTRY(ctl_conn) entry;
- uint8_t flags;
- unsigned int waiting;
-#define CTL_CONN_NOTIFY 0x01
- struct imsgev iev;
- struct sockpeercred peercred;
-
-};
-TAILQ_HEAD(ctl_connlist, ctl_conn);
-extern struct ctl_connlist ctl_conns;
-
-/* privsep */
-enum privsep_procid {
- PROC_PARENT = 0,
- PROC_CONTROL,
- PROC_SOCKS,
- PROC_MAX,
-};
-
-#define CONFIG_RELOAD 0x00
-#define CONFIG_SOCKS 0x01
-#define CONFIG_ALL 0xff
-
-struct privsep_pipes {
- int *pp_pipes[PROC_MAX];
-};
-
-struct privsep {
- struct privsep_pipes *ps_pipes[PROC_MAX];
- struct privsep_pipes *ps_pp;
-
- struct imsgev *ps_ievs[PROC_MAX];
- const char *ps_title[PROC_MAX];
- uint8_t ps_what[PROC_MAX];
-
- struct passwd *ps_pw;
- int ps_noaction;
-
- struct control_sock ps_csock;
- struct control_socks ps_rcsocks;
-
- unsigned int ps_instances[PROC_MAX];
- unsigned int ps_instance;
-
- /* Event and signal handlers */
- struct event ps_evsigint;
- struct event ps_evsigterm;
- struct event ps_evsigchld;
- struct event ps_evsighup;
- struct event ps_evsigpipe;
- struct event ps_evsigusr1;
-
- void *ps_env;
-};
-
-struct privsep_proc {
- const char *p_title;
- enum privsep_procid p_id;
- int (*p_cb)(int, struct privsep_proc *,
- struct imsg *);
- void (*p_init)(struct privsep *,
- struct privsep_proc *);
- void (*p_shutdown)(void);
- const char *p_chroot;
- struct passwd *p_pw;
- struct privsep *p_ps;
-};
-
-struct privsep_fd {
- enum privsep_procid pf_procid;
- unsigned int pf_instance;
-};
-
-#if DEBUG
-#define DPRINTF log_debug
-#else
-#define DPRINTF(x...) do {} while(0)
-#endif
-
-#define PROC_PARENT_SOCK_FILENO 3
-#define PROC_MAX_INSTANCES 32
-
-/* proc.c */
-void proc_range(struct privsep *, enum privsep_procid, int *, int *);
-void proc_init(struct privsep *, struct privsep_proc *, unsigned int,
- int, int, char **, enum privsep_procid);
-void proc_kill(struct privsep *);
-void proc_connect(struct privsep *ps);
-void proc_dispatch(int, short event, void *);
-void proc_run(struct privsep *, struct privsep_proc *,
- struct privsep_proc *, unsigned int,
- void (*)(struct privsep *, struct privsep_proc *, void *), void *);
-void imsg_event_add(struct imsgev *);
-int imsg_compose_event(struct imsgev *, uint16_t, uint32_t,
- pid_t, int, void *, uint16_t);
-int imsg_composev_event(struct imsgev *, uint16_t, uint32_t,
- pid_t, int, const struct iovec *, int);
-int proc_compose_imsg(struct privsep *, enum privsep_procid, int,
- uint16_t, uint32_t, int, void *, uint16_t);
-int proc_compose(struct privsep *, enum privsep_procid,
- uint16_t, void *data, uint16_t);
-int proc_composev_imsg(struct privsep *, enum privsep_procid, int,
- uint16_t, uint32_t, int, const struct iovec *, int);
-int proc_composev(struct privsep *, enum privsep_procid,
- uint16_t, const struct iovec *, int);
-int proc_forward_imsg(struct privsep *, struct imsg *,
- enum privsep_procid, int);
-struct imsgbuf *
- proc_ibuf(struct privsep *, enum privsep_procid, int);
-struct imsgev *
- proc_iev(struct privsep *, enum privsep_procid, int);
-enum privsep_procid
- proc_getid(struct privsep_proc *, unsigned int, const char *);
-int proc_flush_imsg(struct privsep *, enum privsep_procid, int);
-
-/* control.c */
-void control(struct privsep *, struct privsep_proc *);
-int control_init(struct privsep *, struct control_sock *);
-int control_listen(struct control_sock *);
-void control_cleanup(struct control_sock *);
-
-/* log.c */
-void log_init(int, int);
-void log_procinit(const char *);
-void log_setverbose(int);
-int log_getverbose(void);
-void log_warn(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
-void log_warnx(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
-void log_info(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
-void log_debug(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
-void logit(int, const char *, ...)
- __attribute__((__format__ (printf, 2, 3)));
-void vlog(int, const char *, va_list)
- __attribute__((__format__ (printf, 2, 0)));
-__dead void fatal(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
-__dead void fatalx(const char *, ...)
- __attribute__((__format__ (printf, 1, 2)));
blob - 36badfe0b651edfe3804aa06235601cd44ee1411
blob + ec20c295457b4f7fcc1f5b5c6f631b4a97249234
--- thingsd/sockets.c
+++ thingsd/sockets.c
/*
- * Copyright (c) 2016, 2019-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2016, 2019-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2015 Mike Larkin <mlarkin@openbsd.org>
* Copyright (c) 2007 - 2015 Reyk Floeter <reyk@openbsd.org>
*
#include <fcntl.h>
#include <imsg.h>
#include <netdb.h>
+#include <pwd.h>
+#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <tls.h>
#include <unistd.h>
-#include "proc.h"
#include "thingsd.h"
-#define MAXIMUM(a, b) (((a) > (b)) ? (a) : (b))
+#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
#define FD_RESERVE 5
-#define FD_NEEDED 6
-volatile int client_inflight = 0;
-
void bufferevent_read_pressure_cb(struct evbuffer *, size_t, size_t,
void *);
-int sockets_dispatch_thingsd(int, struct privsep_proc *, struct imsg *);
int sockets_socket_af(struct sockaddr_storage *, in_port_t);
-int sockets_accept_reserve(int, struct sockaddr *, socklen_t *, int,
- volatile int *);
-int sockets_dispatch_control(int, struct privsep_proc *, struct imsg *);
+int sockets_accept_reserve(int, struct sockaddr *, socklen_t *, int);
-void sockets_dup_new_socket(struct socket *, struct socket *);
-void sockets_run(struct privsep *, struct privsep_proc *, void *);
+void sockets_dispatch_thingsd(int, short, void *);
+void sockets_dispatch_control(int, short, void *);
+void sockets_sighdlr(int, short, void *);
+__dead void
+ sockets_shutdown(void);
void sockets_socket_conn(int, short, void *);
void sockets_launch(void);
void sockets_client_sub_timeout(int, short, void *);
void sockets_client_accept_paused(int, short, void *);
void sockets_write_to_clients(struct package *);
-void sockets_show_info(struct privsep *, struct imsg *);
-void sockets_show_clients_info(struct privsep *, struct imsg *);
-void sockets_kill_client(struct privsep *, struct imsg *);
+void sockets_show_info(struct imsg *);
+void sockets_show_clients_info(struct imsg *);
+void sockets_kill_client(struct imsg *);
void sockets_tls_readcb(int, short, void *);
void sockets_tls_writecb(int, short, void *);
struct socket
- *sockets_conf_new_socket(struct thingsd *, struct thing *, int, int);
+ *sockets_conf_new_socket(struct thingsd *, struct thing *, int,
+ struct address *, int);
+struct imsgev *socks_iev_parent;
+static struct imsgev *socks_iev_control;
-extern enum privsep_procid privsep_process;
+static struct event ev_sigint;
+static struct event ev_sigterm;
+static struct event ev_sighup;
+static struct event ev_sigpipe;
+static struct event ev_sigusr1;
-static struct privsep_proc procs[] = {
- { "control", PROC_CONTROL, sockets_dispatch_control, control },
- { "thingsd", PROC_PARENT, sockets_dispatch_thingsd },
-};
-
-void
-sockets(struct privsep *ps, struct privsep_proc *p)
+__dead void
+sockets(int fd_parent, int fd_control)
{
- proc_run(ps, p, procs, nitems(procs), sockets_run, NULL);
-}
+ struct passwd *pw;
-void
-sockets_run(struct privsep *ps, struct privsep_proc *p, void *arg)
-{
- if (config_init(ps->ps_env) == -1)
+ log_procinit("sockets");
+
+ if ((pw = getpwnam(THINGSD_USER)) == NULL)
+ fatal("unknown user %s", THINGSD_USER);
+
+ if (chroot(pw->pw_dir) == -1)
+ fatal("%s: chroot", __func__);
+ if (chdir("/") == -1)
+ fatal("%s: chdir(\"/\")", __func__);
+
+ setproctitle("%s", "sockets");
+
+ if (setgroups(1, &pw->pw_gid) ||
+ setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
+ setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
+ fatal("%s: cannot drop privileges", __func__);
+
+ /* start from empty lists, the listeners arrive from the parent */
+ if (config_init(thingsd_env) == -1)
fatal("failed to initialize configuration");
- p->p_shutdown = sockets_shutdown;
+ sockets_socket_rlimit();
- sockets_socket_rlimit(-1);
+ event_init();
- signal_del(&ps->ps_evsigchld);
- signal_set(&ps->ps_evsigchld, SIGCHLD, sockets_sighdlr, ps);
- signal_add(&ps->ps_evsigchld, NULL);
+ signal_set(&ev_sigint, SIGINT, sockets_sighdlr, NULL);
+ signal_set(&ev_sigterm, SIGTERM, sockets_sighdlr, NULL);
+ signal_set(&ev_sighup, SIGHUP, sockets_sighdlr, NULL);
+ signal_set(&ev_sigpipe, SIGPIPE, sockets_sighdlr, NULL);
+ signal_set(&ev_sigusr1, SIGUSR1, sockets_sighdlr, NULL);
+ signal_add(&ev_sigint, NULL);
+ signal_add(&ev_sigterm, NULL);
+ signal_add(&ev_sighup, NULL);
+ signal_add(&ev_sigpipe, NULL);
+ signal_add(&ev_sigusr1, NULL);
+ if ((socks_iev_parent = calloc(1, sizeof(*socks_iev_parent))) == NULL)
+ fatal("%s: calloc", __func__);
+ imsg_event_init(socks_iev_parent, fd_parent, sockets_dispatch_thingsd);
+
+ if ((socks_iev_control = calloc(1, sizeof(*socks_iev_control)))
+ == NULL)
+ fatal("%s: calloc", __func__);
+ imsg_event_init(socks_iev_control, fd_control,
+ sockets_dispatch_control);
+
if (pledge("stdio inet recvfd", NULL) == -1)
fatal("pledge");
+
+ event_dispatch();
+
+ sockets_shutdown();
}
void
log_debug("%s: configuring thing listener %d (%d)", __func__,
sock->conf.id, sock->fd);
- socket_tls_init(sock);
+ if (socket_tls_init(sock) == -1)
+ fatalx("%s: tls init failed for listener %d", __func__,
+ sock->conf.id);
- if ((sock->clients = calloc(1, sizeof(*sock->clients))) == NULL)
- fatalx("%s: calloc", __func__);
- TAILQ_INIT(sock->clients);
-
event_set(&sock->ev, sock->fd, EV_READ | EV_PERSIST,
sockets_socket_conn, sock);
log_debug("%s: initializing thing listener %d", __func__,
sock->conf.id);
- if ((sock->fd = sockets_create_socket(sock->conf.al, sock->conf.port,
+ if ((sock->fd = sockets_create_socket(&sock->conf.ss, sock->conf.port,
S_TCP)) == -1) {
log_warnx("%s: create sock socket failed", __func__);
return (-1);
return (0);
}
-int
-sockets_dispatch_control(int fd, struct privsep_proc *p, struct imsg *imsg)
+void
+sockets_dispatch_control(int fd, short event, void *arg)
{
- struct privsep *ps = p->p_ps;
- int res = 0, cmd = 0;
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ int n;
- switch (imsg->hdr.type) {
- default:
- return (-1);
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost control process", __func__);
+ sockets_shutdown();
+ }
}
-
- switch (cmd) {
- case 0:
- break;
- default:
- if (proc_compose_imsg(ps, PROC_CONTROL, -1, cmd,
- imsg->hdr.peerid, -1, &res, sizeof(res)) == -1)
- return (-1);
- break;
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost control process", __func__);
+ sockets_shutdown();
+ }
+ fatal("%s: imsgbuf_write", __func__);
+ }
}
- return (0);
+ /* control only ever listens to us, requests arrive via the parent */
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
+ break;
+
+ log_warnx("%s: unexpected imsg %d from control", __func__,
+ imsg.hdr.type);
+ imsg_free(&imsg);
+ }
+ imsg_event_add(iev);
}
+/*
+ * Every bound address gets its own listener. The first one for a thing is
+ * the parent, the rest point back at it so thingsctl can group them.
+ */
void
sockets_parse_sockets(struct thingsd *env)
{
struct thing *thing;
- struct socket *sock, *new_sock = NULL;
+ struct socket *sock, *parent;
struct address *a;
- int sock_id = 0, ipv4 = 0, ipv6 = 0;
+ int sock_id = 0, n;
TAILQ_FOREACH(thing, env->things, entry) {
- sock_id++;
- new_sock = sockets_conf_new_socket(env, thing, sock_id, 0);
- TAILQ_INSERT_TAIL(env->sockets, new_sock, entry);
-
- /* add ipv6 children */
- TAILQ_FOREACH(sock, env->sockets, entry) {
- ipv4 = ipv6 = 0;
-
- TAILQ_FOREACH(a, sock->conf.al, entry) {
- if (a->ss.ss_family == AF_INET)
- ipv4 = 1;
- if (a->ss.ss_family == AF_INET6)
- ipv6 = 1;
+ parent = NULL;
+ n = 0;
+ TAILQ_FOREACH(a, thing->conf.tcp_al, entry) {
+ sock = sockets_conf_new_socket(env, thing, ++sock_id,
+ a, n++);
+ if (parent == NULL) {
+ parent = sock;
+ thing->conf.sock_id = sock->conf.id;
+ } else {
+ sock->conf.parent_id = parent->conf.id;
+ parent->conf.child_id = sock->conf.id;
}
-
- /* create ipv6 sock */
- if (ipv4 == 1 && ipv6 == 1) {
- sock_id++;
- sock->conf.child_id = sock_id;
- new_sock = sockets_conf_new_socket(env, thing,
- sock_id, 1);
- sockets_dup_new_socket(sock, new_sock);
- TAILQ_INSERT_TAIL(env->sockets, new_sock,
- entry);
- continue;
- }
+ TAILQ_INSERT_TAIL(env->sockets, sock, entry);
}
}
}
-void
-sockets_dup_new_socket(struct socket *p_sock, struct socket *sock)
-{
- struct address *a, *acp;
-
- sock->conf.parent_id = p_sock->conf.id;
- sock->conf.thing_id = p_sock->conf.thing_id;
- sock->conf.ipv4 = 0;
- sock->conf.ipv6 = 1;
-
- if (strlcpy(sock->conf.password, p_sock->conf.password,
- sizeof(sock->conf.password)) >= sizeof(sock->conf.password))
- fatalx("%s: strlcpy", __func__);
-
- sock->conf.port = p_sock->conf.port;
-
- sock->conf.tls = p_sock->conf.tls;
- sock->conf.tls_protocols = p_sock->conf.tls_protocols;
- sock->conf.tls_flags = p_sock->conf.tls_flags;
- sock->conf.max_clients = p_sock->conf.max_clients;
-
- memcpy(&sock->conf.thing_name, p_sock->conf.thing_name,
- sizeof(sock->conf.thing_name));
-
- snprintf(sock->conf.name, THINGSD_MAXTEXT, "%s_child",
- p_sock->conf.thing_name);
-
- TAILQ_FOREACH(a, p_sock->conf.al, entry) {
- if (a->ss.ss_family == AF_INET)
- continue;
-
- if ((acp = calloc(1, sizeof(*acp))) == NULL)
- fatal("%s: calloc", __func__);
- memcpy(&acp->ss, &a->ss, sizeof(acp->ss));
- acp->ipproto = a->ipproto;
- acp->prefixlen = a->prefixlen;
- acp->port = a->port;
- if (strlen(a->ifname) != 0) {
- if (strlcpy(acp->ifname, a->ifname,
- sizeof(acp->ifname)) >= sizeof(acp->ifname)) {
- fatalx("%s: interface name truncated",
- __func__);
- }
- }
-
- TAILQ_INSERT_TAIL(sock->conf.al, acp, entry);
- }
-
- if(sock->conf.tls == 0)
- return;
-
- if((sock->conf.tls_cert_file =
- strdup(p_sock->conf.tls_cert_file)) == NULL)
- fatal("%s: strdup", __func__);
-
- if((sock->conf.tls_key_file =
- strdup(p_sock->conf.tls_key_file)) == NULL)
- fatal("%s: strdup", __func__);
-
- if (strlcpy(sock->conf.tls_ciphers, p_sock->conf.tls_ciphers,
- sizeof(sock->conf.tls_ciphers)) >= sizeof(sock->conf.tls_ciphers))
- fatalx("%s: strlcpy", __func__);
-
- if (strlcpy(sock->conf.tls_dhe_params, p_sock->conf.tls_dhe_params,
- sizeof(sock->conf.tls_dhe_params)) >=
- sizeof(sock->conf.tls_dhe_params))
- fatalx("%s: strlcpy", __func__);
-
- if (strlcpy(sock->conf.tls_ecdhe_curves, p_sock->conf.tls_ecdhe_curves,
- sizeof(sock->conf.tls_ecdhe_curves)) >=
- sizeof(sock->conf.tls_ecdhe_curves))
- fatalx("%s: strlcpy", __func__);
-}
-
struct socket *
sockets_conf_new_socket(struct thingsd *env, struct thing *thing, int id,
- int is_dup)
+ struct address *a, int n)
{
struct socket *sock;
- struct address *a, *acp;
if ((sock = calloc(1, sizeof(*sock))) == NULL)
fatal("%s: calloc", __func__);
- if ((sock->conf.al = calloc(1,
- sizeof(*sock->conf.al))) == NULL)
+ if ((sock->clients = calloc(1, sizeof(*sock->clients))) == NULL)
fatal("%s: calloc", __func__);
+ TAILQ_INIT(sock->clients);
- TAILQ_INIT(sock->conf.al);
-
- sock->conf.parent_id = 0;
+ sock->fd = -1;
sock->conf.id = id;
- sock->conf.ipv4 = 1;
sock->conf.thing_id = thing->conf.id;
sock->conf.max_clients = thing->conf.max_clients;
- memset(sock->conf.tls_ciphers, 0,
- sizeof(sock->conf.tls_ciphers));
- memset(sock->conf.tls_dhe_params, 0,
- sizeof(sock->conf.tls_dhe_params));
- memset(sock->conf.tls_ecdhe_curves, 0,
- sizeof(sock->conf.tls_ecdhe_curves));
+ memcpy(&sock->conf.ss, &a->ss, sizeof(sock->conf.ss));
+ sock->conf.ipv4 = (a->ss.ss_family == AF_INET);
+ sock->conf.ipv6 = (a->ss.ss_family == AF_INET6);
- if (is_dup)
- goto done;
+ if (strlcpy(sock->conf.iface, a->ifname, sizeof(sock->conf.iface)) >=
+ sizeof(sock->conf.iface))
+ fatalx("%s: interface name truncated", __func__);
- snprintf(sock->conf.name, THINGSD_MAXTEXT, "%s_parent",
- thing->conf.name);
+ if (n == 0)
+ snprintf(sock->conf.name, sizeof(sock->conf.name), "%s_parent",
+ thing->conf.name);
+ else
+ snprintf(sock->conf.name, sizeof(sock->conf.name), "%s_child%d",
+ thing->conf.name, n);
if (strlcpy(sock->conf.thing_name, thing->conf.name,
- sizeof(sock->conf.thing_name)) >= sizeof(sock->conf.thing_name)) {
- free(sock->conf.al);
- free(sock);
+ sizeof(sock->conf.thing_name)) >= sizeof(sock->conf.thing_name))
fatalx("%s: strlcpy", __func__);
- }
- TAILQ_FOREACH(a, thing->conf.tcp_al, entry) {
- if ((acp = calloc(1, sizeof(*acp))) == NULL)
- fatal("%s: calloc", __func__);
- memcpy(&acp->ss, &a->ss, sizeof(acp->ss));
- acp->ipproto = a->ipproto;
- acp->prefixlen = a->prefixlen;
- acp->port = a->port;
- if (strlen(a->ifname) != 0) {
- if (strlcpy(acp->ifname, a->ifname,
- sizeof(acp->ifname)) >= sizeof(acp->ifname)) {
- fatalx("%s: interface name truncated",
- __func__);
- }
- }
-
- TAILQ_INSERT_TAIL(sock->conf.al, acp, entry);
- }
-
- thing->conf.sock_id = id;
-
if (strlcpy(sock->conf.password, thing->conf.password,
sizeof(sock->conf.password)) >= sizeof(sock->conf.password))
fatalx("%s: strlcpy", __func__);
sock->conf.tls_protocols = thing->conf.tls_protocols;
sock->conf.tls_flags = thing->conf.tls_flags;
- if(sock->conf.tls == 0)
- goto done;
+ if (sock->conf.tls == 0)
+ return (sock);
- if((sock->conf.tls_cert_file =
+ if ((sock->conf.tls_cert_file =
strdup(thing->conf.tls_cert_file)) == NULL)
fatal("%s: strdup", __func__);
- if((sock->conf.tls_key_file =
+ if ((sock->conf.tls_key_file =
strdup(thing->conf.tls_key_file)) == NULL)
fatal("%s: strdup", __func__);
+ if (thing->conf.tls_ca_file != NULL &&
+ (sock->conf.tls_ca_file = strdup(thing->conf.tls_ca_file)) == NULL)
+ fatal("%s: strdup", __func__);
+
+ if (thing->conf.tls_crl_file != NULL &&
+ (sock->conf.tls_crl_file =
+ strdup(thing->conf.tls_crl_file)) == NULL)
+ fatal("%s: strdup", __func__);
+
+ if (thing->conf.tls_ocsp_staple_file != NULL &&
+ (sock->conf.tls_ocsp_staple_file =
+ strdup(thing->conf.tls_ocsp_staple_file)) == NULL)
+ fatal("%s: strdup", __func__);
+
if (strlcpy(sock->conf.tls_ciphers, thing->conf.tls_ciphers,
sizeof(sock->conf.tls_ciphers)) >= sizeof(sock->conf.tls_ciphers))
fatalx("%s: strlcpy", __func__);
sizeof(sock->conf.tls_ecdhe_curves)) >=
sizeof(sock->conf.tls_ecdhe_curves))
fatalx("%s: strlcpy", __func__);
-done:
+
return (sock);
}
}
int
-sockets_create_socket(struct addresslist *al, in_port_t port, int type)
+sockets_create_socket(struct sockaddr_storage *ss, in_port_t port, int type)
{
- struct addrinfo hints;
- struct address *a;
- int fd = -1, o_val = 1, flags;
+ char hbuf[NI_MAXHOST];
+ int fd, o_val = 1, socktype;
+ if (sockets_socket_af(ss, port) == -1) {
+ log_warnx("%s: unsupported address family %d", __func__,
+ ss->ss_family);
+ return (-1);
+ }
+
+ socktype = (type == S_UDP) ? SOCK_DGRAM : SOCK_STREAM;
+
+ if ((fd = socket(ss->ss_family, socktype | SOCK_NONBLOCK, 0)) == -1) {
+ log_warn("%s: socket", __func__);
+ return (-1);
+ }
+
+ if (getnameinfo((struct sockaddr *)ss, ss->ss_len, hbuf, sizeof(hbuf),
+ NULL, 0, NI_NUMERICHOST) != 0)
+ strlcpy(hbuf, "?", sizeof(hbuf));
+ log_debug("%s: opening socket (%d) on %s port %d", __func__, fd, hbuf,
+ ntohs(port));
+
+ if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &o_val,
+ sizeof(o_val)) == -1) {
+ log_warn("%s: setsockopt", __func__);
+ close(fd);
+ return (-1);
+ }
+
+ if (bind(fd, (struct sockaddr *)ss, ss->ss_len) == -1) {
+ log_warn("%s: can't bind %s port %d", __func__, hbuf,
+ ntohs(port));
+ close(fd);
+ return (-1);
+ }
+
+ if (type == S_TCP && listen(fd, SOMAXCONN) == -1) {
+ log_warn("%s: unable to listen on %s port %d", __func__, hbuf,
+ ntohs(port));
+ close(fd);
+ return (-1);
+ }
+
+ return (fd);
+}
+
+/*
+ * Start a non-blocking connect to a thing. The caller learns about the
+ * outcome through the fd becoming writable (or erroring), so the event
+ * loop is never stalled by an unreachable host.
+ */
+int
+sockets_open_client(const char *host, in_port_t port)
+{
+ struct addrinfo hints, *res0, *res;
+ char serv[NI_MAXSERV];
+ int fd = -1, error, save_errno;
+
+ snprintf(serv, sizeof(serv), "%u", ntohs(port));
+
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
- switch (type) {
- case S_UDP:
- hints.ai_socktype = SOCK_DGRAM;
- hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;
- hints.ai_protocol = 0;
- break;
- case S_TCP:
- default:
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags |= AI_PASSIVE;
- break;
- }
+ hints.ai_socktype = SOCK_STREAM;
- TAILQ_FOREACH(a, al, entry) {
- if (sockets_socket_af(&a->ss, port) == -1) {
- log_warnx("%s: sockets_socket_af", __func__);
- goto fail;
- }
-
- fd = socket(a->ss.ss_family, hints.ai_socktype,
- a->ipproto);
- log_debug("%s: opening socket (%d) for %s", __func__,
- fd, a->ifname);
-
- if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &o_val,
- sizeof(int)) == -1) {
- log_warn("%s: setsockopt error", __func__);
- return (-1);
- }
-
- /* non-blocking */
- flags = fcntl(fd, F_GETFL);
- flags |= O_NONBLOCK;
- fcntl(fd, F_SETFL, flags);
-
- if (bind(fd, (struct sockaddr *)&a->ss, a->ss.ss_len) == -1) {
- close(fd);
- log_info("%s: can't bind to port %d", __func__,
- ntohs(port));
- goto fail;
- }
- if (type == S_TCP) {
- if (listen(fd, SOMAXCONN) == -1) {
- log_warn("%s, unable to listen on socket",
- __func__);
- goto fail;
- }
- }
- }
-
- free(a);
- return (fd);
-fail:
- free(a);
- return (-1);
-}
-
-int
-sockets_open_client(char *ip_addr, in_port_t port)
-{
- int fd = -1;
-
- struct addresslist al;
- struct address *a;
-
- TAILQ_INIT(&al);
- if (host(ip_addr, &al, 1, port, ip_addr, -1) <= 0) {
- log_warnx("invalid listen ip: %s", ip_addr);
+ if ((error = getaddrinfo(host, serv, &hints, &res0)) != 0) {
+ log_warnx("%s: %s: %s", __func__, host, gai_strerror(error));
return (-1);
}
- TAILQ_FOREACH(a, &al, entry) {
- if (sockets_socket_af(&a->ss, port) == -1) {
- log_warnx("%s: sockets_socket_af", __func__);
- return (-1);
- }
-
- if ((fd = socket(a->ss.ss_family, SOCK_STREAM,
- a->ipproto)) == -1)
+ for (res = res0; res != NULL; res = res->ai_next) {
+ if ((fd = socket(res->ai_family,
+ res->ai_socktype | SOCK_NONBLOCK, res->ai_protocol)) == -1)
continue;
- if ((connect(fd, (struct sockaddr *)&a->ss,
- a->ss.ss_len)) == -1) {
- if (errno != EINPROGRESS) {
- close(fd);
- return (-1);
- }
- }
+ if (connect(fd, res->ai_addr, res->ai_addrlen) == 0 ||
+ errno == EINPROGRESS)
+ break;
+
+ save_errno = errno;
+ close(fd);
+ fd = -1;
+ errno = save_errno;
}
if (fd == -1)
- log_warnx("can't connect ip: %s", ip_addr);
+ log_warn("%s: can't connect to %s port %u", __func__, host,
+ ntohs(port));
- free(a);
- return fd;
+ freeaddrinfo(res0);
+ return (fd);
}
struct socket *
-sockets_new_socket(char *port)
-{
- struct socket *sock;
-
- if ((sock = calloc(1, sizeof(*sock))) == NULL)
- fatal("%s: calloc", __func__);
-
- return (sock);
-};
-
-struct socket *
-sockets_get_socket(struct thingsd *env, int val)
-{
- struct socket *sock = NULL;
-
- TAILQ_FOREACH(sock, env->sockets, entry) {
- if (sock->fd == val)
- return sock;
- }
-
- return NULL;
-}
-
-struct socket *
sockets_get_socket_byid(struct thingsd *env, int val)
{
struct socket *sock = NULL;
return NULL;
}
+/* subscribed clients across every listener of a thing in this process */
+size_t
+sockets_thing_client_cnt(int id)
+{
+ struct socket *sock;
+ size_t cnt = 0;
+
+ TAILQ_FOREACH(sock, thingsd_env->sockets, entry)
+ if (sock->conf.thing_id == id)
+ cnt += sock->client_cnt;
+
+ return (cnt);
+}
+
void
sockets_write_to_clients(struct package *package)
{
struct client *client = NULL;
TAILQ_FOREACH(sock, thingsd_env->sockets, entry) {
- if (sock->conf.thing_id == package->thing_id &&
- sock->client_cnt > 0) {
- TAILQ_FOREACH(client, sock->clients, entry) {
- if (client->subscribed) {
- bufferevent_write(client->bev,
- package->pkt, package->len);
- }
- }
+ if (sock->conf.thing_id != package->thing_id)
+ continue;
+ TAILQ_FOREACH(client, sock->clients, entry) {
+ if (client->subscribed)
+ bufferevent_write(client->bev, package->pkt,
+ package->len);
}
}
}
void
-sockets_show_clients_info(struct privsep *ps, struct imsg *imsg)
+sockets_show_clients_info(struct imsg *imsg)
{
- char filter[THINGSD_MAXNAME];
struct client *client, nci;
struct socket *sock;
+ char filter[THINGSD_MAXNAME];
- memcpy(filter, imsg->data, sizeof(filter));
+ memset(&nci, 0, sizeof(nci));
+ imsg_get_string(imsg, filter, sizeof(filter));
TAILQ_FOREACH(sock, thingsd_env->sockets, entry) {
- if (sock->client_cnt == 0)
- continue;
TAILQ_FOREACH(client, sock->clients, entry) {
- if (filter[0] == '\0' || strcmp(filter,
- client->name) == 0) {
+ if (filter[0] != '\0' &&
+ strcmp(filter, client->name) != 0)
+ continue;
- memcpy(&nci.name, client->name,
- sizeof(nci.name));
+ memcpy(nci.name, client->name, sizeof(nci.name));
- nci.subscribed = client->subscribed;
- nci.fd = client->fd;
- nci.port = client->port;
- nci.tls = client->tls;
+ nci.subscribed = client->subscribed;
+ nci.fd = client->fd;
+ nci.port = client->port;
+ nci.tls = client->tls;
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_CLIENTS_DATA,
- imsg->hdr.peerid, -1, &nci,
- sizeof(nci)) == -1)
- return;
-
- }
+ if (imsg_compose_event(socks_iev_control,
+ IMSG_GET_INFO_CLIENTS_DATA, imsg->hdr.peerid, 0,
+ -1, &nci, sizeof(nci)) == -1)
+ return;
}
}
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_CLIENTS_END_DATA, imsg->hdr.peerid,
- -1, &nci, sizeof(nci)) == -1)
- return;
+ imsg_compose_event(socks_iev_control, IMSG_GET_INFO_CLIENTS_END_DATA,
+ imsg->hdr.peerid, 0, -1, &nci, sizeof(nci));
}
void
-sockets_show_info(struct privsep *ps, struct imsg *imsg)
+sockets_show_info(struct imsg *imsg)
{
- char filter[THINGSD_MAXNAME];
struct socket *socket, nsi;
+ char filter[THINGSD_MAXNAME];
- memcpy(filter, imsg->data, sizeof(filter));
+ memset(&nsi, 0, sizeof(nsi));
+ imsg_get_string(imsg, filter, sizeof(filter));
TAILQ_FOREACH(socket, thingsd_env->sockets, entry) {
- if (filter[0] == '\0' || strcmp(filter,
- socket->conf.name) == 0) {
+ if (filter[0] != '\0' && strcmp(filter, socket->conf.name) != 0)
+ continue;
- memcpy(&nsi.conf.name, socket->conf.name,
- sizeof(nsi.conf.name));
+ memcpy(nsi.conf.name, socket->conf.name,
+ sizeof(nsi.conf.name));
- nsi.fd = socket->fd;
- nsi.conf.port = socket->conf.port;
- nsi.conf.tls = socket->conf.tls;
- nsi.client_cnt = socket->client_cnt;
- nsi.conf.max_clients = socket->conf.max_clients;
+ nsi.fd = socket->fd;
+ nsi.conf.port = socket->conf.port;
+ nsi.conf.tls = socket->conf.tls;
+ nsi.client_cnt = socket->client_cnt;
+ nsi.conf.max_clients = socket->conf.max_clients;
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_SOCKETS_DATA,
- imsg->hdr.peerid, -1, &nsi,
- sizeof(nsi)) == -1)
- return;
-
- }
- }
-
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_SOCKETS_END_DATA, imsg->hdr.peerid,
+ if (imsg_compose_event(socks_iev_control,
+ IMSG_GET_INFO_SOCKETS_DATA, imsg->hdr.peerid, 0,
-1, &nsi, sizeof(nsi)) == -1)
return;
+ }
+
+ imsg_compose_event(socks_iev_control, IMSG_GET_INFO_SOCKETS_END_DATA,
+ imsg->hdr.peerid, 0, -1, &nsi, sizeof(nsi));
}
void
-sockets_socket_rlimit(int maxfd)
+sockets_socket_rlimit(void)
{
struct rlimit rl;
* Allow the maximum number of open file descriptors for this
* login class (which should be the class "daemon" by default).
*/
- if (maxfd == -1)
- rl.rlim_cur = rl.rlim_max;
- else
- rl.rlim_cur = MAXIMUM(rl.rlim_max, (rlim_t)maxfd);
+ rl.rlim_cur = rl.rlim_max;
if (setrlimit(RLIMIT_NOFILE, &rl) == -1)
fatal("%s: failed to set resource limit", __func__);
}
void
-sockets_kill_client(struct privsep *ps, struct imsg *imsg)
+sockets_kill_client(struct imsg *imsg)
{
struct socket *sock;
struct client *client;
- char client_name[THINGSD_MAXTEXT];
+ char client_name[THINGSD_MAXNAME];
- memcpy(client_name, imsg->data, sizeof(client_name));
+ imsg_get_string(imsg, client_name, sizeof(client_name));
+ if (client_name[0] == '\0')
+ return;
TAILQ_FOREACH(sock, thingsd_env->sockets, entry) {
TAILQ_FOREACH(client, sock->clients, entry) {
log_debug("Control killed client: %s",
client_name);
client_del(client);
- break;
+ return;
}
}
}
}
-int
-sockets_dispatch_thingsd(int fd, struct privsep_proc *p, struct imsg *imsg)
+void
+sockets_dispatch_thingsd(int fd, short event, void *arg)
{
- struct package *package = NULL;
- struct privsep *ps = p->p_ps;
- int res = 0, cmd = 0, verbose;
- unsigned int mode;
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ struct package *package;
+ int n, verbose;
- switch (imsg->hdr.type) {
- case IMSG_KILL_CLIENT:
- sockets_kill_client(ps, imsg);
- break;
- case IMSG_DIST_THING_PACKAGE:
- IMSG_SIZE_CHECK(imsg, package);
- package = (struct package *)imsg->data;
- sockets_write_to_clients(package);
- break;
- case IMSG_CFG_SOCKS:
- config_getsocks(thingsd_env, imsg);
- break;
- case IMSG_CFG_DONE:
- config_getcfg(thingsd_env, imsg);
- break;
- case IMSG_CTL_RESET:
- IMSG_SIZE_CHECK(imsg, &mode);
- memcpy(&mode, imsg->data, sizeof(mode));
-
- config_getreset(thingsd_env, imsg);
- break;
- case IMSG_CFG_TLS:
- config_getsocks_tls(thingsd_env, imsg);
- break;
- case IMSG_CTL_VERBOSE:
- IMSG_SIZE_CHECK(imsg, &verbose);
- memcpy(&verbose, imsg->data, sizeof(verbose));
- log_setverbose(verbose);
- break;
- case IMSG_CTL_START:
- sockets_launch();
- break;
- case IMSG_GET_INFO_CLIENTS_REQUEST:
- sockets_show_clients_info(ps, imsg);
- break;
- case IMSG_GET_INFO_SOCKETS_REQUEST:
- sockets_show_info(ps, imsg);
- break;
- default:
- return (-1);
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost parent process", __func__);
+ sockets_shutdown();
+ }
}
-
- switch (cmd) {
- case 0:
- break;
- default:
- if (proc_compose_imsg(ps, PROC_PARENT, -1, cmd,
- imsg->hdr.peerid, -1, &res, sizeof(res)) == -1)
- return (-1);
- break;
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost parent process", __func__);
+ sockets_shutdown();
+ }
+ fatal("%s: imsgbuf_write", __func__);
+ }
}
- return (0);
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
+ break;
+
+ switch (imsg.hdr.type) {
+ case IMSG_KILL_CLIENT:
+ sockets_kill_client(&imsg);
+ break;
+ case IMSG_DIST_THING_PACKAGE:
+ IMSG_SIZE_CHECK(&imsg, package);
+ package = (struct package *)imsg.data;
+ if (package->len < 0 ||
+ (size_t)package->len > sizeof(package->pkt))
+ fatalx("%s: bad package length", __func__);
+ sockets_write_to_clients(package);
+ break;
+ case IMSG_CFG_SOCKS:
+ config_getsocks(thingsd_env, &imsg);
+ break;
+ case IMSG_CFG_DONE:
+ config_getcfg(thingsd_env, &imsg);
+ break;
+ case IMSG_CFG_TLS:
+ config_getsocks_tls(thingsd_env, &imsg);
+ break;
+ case IMSG_CTL_VERBOSE:
+ IMSG_SIZE_CHECK(&imsg, &verbose);
+ memcpy(&verbose, imsg.data, sizeof(verbose));
+ log_setverbose(verbose);
+ break;
+ case IMSG_CTL_START:
+ sockets_launch();
+ break;
+ case IMSG_GET_INFO_CLIENTS_REQUEST:
+ sockets_show_clients_info(&imsg);
+ break;
+ case IMSG_GET_INFO_SOCKETS_REQUEST:
+ sockets_show_info(&imsg);
+ break;
+ default:
+ log_warnx("%s: unexpected imsg %d from parent",
+ __func__, imsg.hdr.type);
+ break;
+ }
+ imsg_free(&imsg);
+ }
+ imsg_event_add(iev);
}
void
sockets_sighdlr(int sig, short event, void *arg)
{
switch (sig) {
+ case SIGINT:
+ case SIGTERM:
+ sockets_shutdown();
+ break;
+ case SIGHUP:
+ case SIGPIPE:
+ case SIGUSR1:
+ /* ignore */
+ break;
default:
- fatalx("unexpected signal");
+ fatalx("%s: unexpected signal", __func__);
}
}
-void
+__dead void
sockets_shutdown(void)
{
struct socket *sock = NULL, *tsock;
struct client *client, *tclient;
- /* clean up sockets */
TAILQ_FOREACH_SAFE(sock, thingsd_env->sockets, entry, tsock) {
- /* clean up clients */
- TAILQ_FOREACH_SAFE(client, sock->clients, entry, tclient) {
- if (client->tls) {
- if (event_initialized(&client->ev))
- event_del(&client->ev);
- tls_free(client->tls_ctx);
- } else {
- if (client->bev != NULL)
- bufferevent_disable(client->bev,
- EV_READ | EV_WRITE);
- if (client->bev != NULL)
- bufferevent_free(client->bev);
- }
- close(client->fd);
- TAILQ_REMOVE(sock->clients, client, entry);
- free(client);
- }
+ TAILQ_FOREACH_SAFE(client, sock->clients, entry, tclient)
+ client_del(client);
+ free(sock->clients);
if (sock->conf.tls) {
tls_config_free(sock->tls_config);
free(sock->conf.tls_cert);
free(sock->conf.tls_key);
free(sock->conf.tls_ca);
- free(sock->conf.tls_ca_file);
free(sock->conf.tls_crl);
- free(sock->conf.tls_crl_file);
free(sock->conf.tls_ocsp_staple);
- free(sock->conf.tls_ocsp_staple_file);
}
if (event_initialized(&sock->ev))
event_del(&sock->ev);
- evtimer_del(&sock->pause);
- close(sock->fd);
+ if (evtimer_initialized(&sock->pause))
+ evtimer_del(&sock->pause);
+ if (sock->fd != -1)
+ close(sock->fd);
TAILQ_REMOVE(thingsd_env->sockets, sock, entry);
free(sock);
}
free(thingsd_env->sockets);
-}
+ event_del(&socks_iev_parent->ev);
+ imsgbuf_clear(&socks_iev_parent->ibuf);
+ close(socks_iev_parent->ibuf.fd);
+ free(socks_iev_parent);
+ event_del(&socks_iev_control->ev);
+ imsgbuf_clear(&socks_iev_control->ibuf);
+ close(socks_iev_control->ibuf.fd);
+ free(socks_iev_control);
-int
-sockets_client_cmp(struct client *a, struct client *b)
-{
- return ((int)a->id - b->id);
+ log_info("sockets exiting, pid %d", getpid());
+ exit(0);
}
int
sockets_accept_reserve(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
- int reserve, volatile int *counter)
+ int reserve)
{
- int ret;
-
- if (getdtablecount() + reserve +
- ((*counter + 1) * FD_NEEDED) >= getdtablesize()) {
- log_debug("inflight fds exceeded");
+ if (getdtablecount() + reserve >= getdtablesize()) {
+ log_debug("%s: descriptor table nearly full", __func__);
errno = EMFILE;
- return -1;
+ return (-1);
}
- if ((ret = accept4(sockfd, addr, addrlen, SOCK_NONBLOCK | SOCK_CLOEXEC))
- > -1) {
- (*counter)++;
- log_debug("inflight incremented, now %d", *counter);
- }
- return ret;
+ return (accept4(sockfd, addr, addrlen, SOCK_NONBLOCK | SOCK_CLOEXEC));
}
void
struct socket *sock = (struct socket *)arg;
int client_fd;
socklen_t len = sizeof(ss);
- evbuffercb clientrd = client_rd;
- evbuffercb clientwr = client_wr;
backoff.tv_sec = 1;
backoff.tv_usec = 0;
subtime.tv_sec = CLIENT_SUB_TIME_SEC;
subtime.tv_usec = CLIENT_SUB_TIME_USEC;
- sock = sockets_get_socket(thingsd_env, fd);
- if (sock == NULL)
- return;
-
log_debug("%s: client connection started on listener %d", __func__,
sock->conf.id);
- event_add(&sock->ev, NULL);
-
client_fd = sockets_accept_reserve(fd, (struct sockaddr *)&ss, &len,
- FD_RESERVE, &client_inflight);
+ FD_RESERVE);
if (client_fd == -1) {
switch (errno) {
case EINTR:
case EWOULDBLOCK:
case ECONNABORTED:
- return;
+ break;
case EMFILE:
case ENFILE:
event_del(&sock->ev);
evtimer_add(&sock->pause, &backoff);
- return;
+ break;
default:
- log_warnx("client accept failed");
+ log_warn("%s: accept", __func__);
}
+ return;
}
- client = calloc(1, sizeof(*client));
- if (client == NULL)
- goto err2;
+ if (sock->conf.max_clients > 0 &&
+ sockets_thing_client_cnt(sock->conf.thing_id) >=
+ sock->conf.max_clients) {
+ log_debug("%s: listener %d max clients reached", __func__,
+ sock->conf.id);
+ close(client_fd);
+ return;
+ }
+ if ((client = calloc(1, sizeof(*client))) == NULL)
+ goto err;
+
+ client->fd = client_fd;
client->port = sock->conf.port;
-
- memset(&client->timeout, 0, sizeof(struct event));
- evtimer_set(&client->timeout, sockets_client_sub_timeout, client);
-
- if (sock->conf.tls) {
- if (tls_accept_socket(sock->tls_ctx, &client->tls_ctx,
- client_fd) == -1) {
- log_warnx("tls accept failed: %s",
- tls_error(sock->tls_ctx));
- goto err;
- }
- }
-
- client->packages = calloc(1, sizeof(*client->packages));
- if (client->packages == NULL)
- goto err2;
-
- TAILQ_INIT(client->packages);
-
- if (sock->conf.max_clients > 0)
- if (sock->client_cnt > sock->conf.max_clients) {
- log_debug("%s: listener %d max clients reached",
- __func__, sock->conf.id);
- goto err;
- }
-
client->sock_id = sock->conf.id;
client->thing_id = sock->conf.thing_id;
client->sock = sock;
- client->sock_conf = &sock->conf;
- client->subscribed = 0;
- client->evb = evbuffer_new();
-
- evtimer_pending(&client->timeout, NULL);
- log_debug("%s: started client timer", __func__);
- evtimer_add(&client->timeout, &subtime);
-
- if (client->evb == NULL)
- goto err;
-
- client->fd = client_fd;
client->join_time = time(NULL);
+ if ((client->packages = calloc(1, sizeof(*client->packages))) == NULL)
+ goto err;
+ TAILQ_INIT(client->packages);
+
if (sock->conf.tls) {
+ if (tls_accept_socket(sock->tls_ctx, &client->tls_ctx,
+ client_fd) == -1) {
+ log_warnx("tls accept failed: %s",
+ tls_error(sock->tls_ctx));
+ goto err;
+ }
client->tls = 1;
- event_del(&client->ev);
- event_set(&client->ev, client->fd, EV_READ | EV_PERSIST,
- socket_tls_handshake, client);
- event_add(&client->ev, NULL);
}
- client->bev = bufferevent_new(client->fd, clientrd, clientwr,
+ client->bev = bufferevent_new(client->fd, client_rd, client_wr,
client_err, client);
-
if (client->bev == NULL)
goto err;
+ /*
+ * libtls completes the handshake from within tls_read/tls_write,
+ * so the regular bufferevent callbacks are simply replaced.
+ */
if (client->tls) {
event_set(&client->bev->ev_read, client->fd, EV_READ,
sockets_tls_readcb, client->bev);
}
bufferevent_setwatermark(client->bev, EV_READ, 0, PKT_BUFF);
- bufferevent_enable(client->bev, EV_READ|EV_WRITE);
+ bufferevent_enable(client->bev, EV_READ | EV_WRITE);
+
+ evtimer_set(&client->timeout, sockets_client_sub_timeout, client);
+ evtimer_add(&client->timeout, &subtime);
+
TAILQ_INSERT_TAIL(sock->clients, client, entry);
log_debug("%s: client connected (%d)", __func__, client->fd);
return;
err:
- sock->client_cnt--;
-err2:
- log_debug("%s: client error", __func__);
- client_inflight--;
- if (client_fd != -1)
- close(client_fd);
+ log_debug("%s: client setup error", __func__);
+ close(client_fd);
if (client != NULL) {
- if (sock->conf.tls)
+ if (client->tls)
tls_free(client->tls_ctx);
+ free(client->packages);
free(client);
}
}
size_t len;
int toread = EVBUFFER_READ;
- memset(pkt, 0, sizeof(pkt));
-
- ret = tls_read(client->tls_ctx, pkt, PKT_BUFF);
+ ret = tls_read(client->tls_ctx, pkt, sizeof(pkt));
if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) {
goto retry;
} else if (ret < 0) {
+ log_debug("%s: %s", __func__, tls_error(client->tls_ctx));
toread |= EVBUFFER_ERROR;
goto err;
}
int towrite = EVBUFFER_WRITE;
if (EVBUFFER_LENGTH(bufev->output)) {
- if (client == NULL)
- return;
-
ret = tls_write(client->tls_ctx,
EVBUFFER_DATA(bufev->output),
EVBUFFER_LENGTH(bufev->output));
if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) {
goto retry;
} else if (ret < 0) {
+ log_debug("%s: %s", __func__,
+ tls_error(client->tls_ctx));
towrite |= EVBUFFER_ERROR;
goto err;
}
err:
(*bufev->errorcb)(bufev, towrite, bufev->cbarg);
}
-
blob - 7f4a2ee4b47f6889c937c000e0c2d3ff05432d11
blob + 042078270683874257a4f044f8c7b7220e967c12
--- thingsd/thingsd.8
+++ thingsd/thingsd.8
.\"
-.\" Copyright (c) 2016-2019 Tracey Emery <tracey@traceyemery.net>
+.\" Copyright (c) 2016-2026 Tracey Emery <tracey@openbsd.org>
.\"
.\" Permission to use, copy, modify, and distribute this software for any
.\" purpose with or without fee is hereby granted, provided that the above
The
.Nm
program was written by
-.An Tracey Emery Aq Mt tracey@traceyemery.net .
+.An Tracey Emery Aq Mt tracey@openbsd.org .
blob - a97f89935b64e35507abe857e5432c61dace37d4
blob + 0a2f08cf8ae42a3f3b9fd2484c6b17552ce2812f
--- thingsd/thingsd.c
+++ thingsd/thingsd.c
/*
- * Copyright (c) 2016, 2019-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2016, 2019-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2015 Reyk Floeter <reyk@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
#include <sys/queue.h>
#include <sys/resource.h>
#include <sys/socket.h>
+#include <sys/uio.h>
#include <sys/wait.h>
#include <sys/cdefs.h>
#include <ctype.h>
#include <util.h>
-#include "proc.h"
#include "thingsd.h"
__dead void usage(void);
int main(int, char **);
int thingsd_configure(struct thingsd *);
-int thingsd_control_run(void);
-int thingsd_dispatch_control(int, struct privsep_proc *, struct imsg *);
-int thingsd_dispatch_sockets(int, struct privsep_proc *, struct imsg *);
+void thingsd_dispatch_control(int, short, void *);
+void thingsd_dispatch_sockets(int, short, void *);
void thingsd_sighdlr(int sig, short event, void *arg);
-void thingsd_shutdown(struct thingsd *);
+__dead void
+ thingsd_shutdown(struct thingsd *);
void thingsd_parent_shutdown(struct thingsd *);
void thingsd_configure_done(struct thingsd *);
-void thingsd_thing_serial_open(struct thing *, int);
-void thingsd_thing_setup(struct thingsd *, struct thing *, int);
-void thingsd_show_info(struct privsep *, struct imsg *);
-void thingsd_show_thing_info(struct privsep *, struct imsg *);
+int thingsd_thing_serial_open(struct thing *);
+int thingsd_thing_connect(struct thingsd *, struct thing *, int);
+void thingsd_thing_disconnect(struct thing *);
+void thingsd_show_info(struct imsg *);
+void thingsd_show_thing_info(struct imsg *);
void thingsd_thing_udp_event(int, short, void *);
void thingsd_thing_read(struct bufferevent *, void *);
void thingsd_thing_write(struct bufferevent *, void *);
void thingsd_thing_err(struct bufferevent *, short, void *);
+void thingsd_oneshot_cb(int, short, void *);
void thingsd_add_reconn(struct thing *);
void thingsd_do_reconn(struct thingsd *);
void thingsd_write_to_socks(struct packages *);
void thingsd_write_to_things(struct package *);
-void thingsd_echo_pkt(struct privsep *, struct imsg *);
-void thingsd_stop_pkt(struct privsep *, struct imsg *);
+void thingsd_echo_pkt(struct imsg *);
+void thingsd_stop_pkt(struct imsg *);
struct thing
thingsd_compose_thing(struct thing *, enum imsg_type);
-struct dead_thing
- *thingsd_new_dead_thing(struct thing *);
-extern enum privsep_procid privsep_process;
+/* a packet on its way to a non-persistent thing */
+struct oneshot {
+ struct event ev;
+ int fd;
+ int len;
+ char pkt[PKT_BUFF];
+ char name[THINGSD_MAXNAME];
+};
struct thingsd *thingsd_env;
int thing_id;
+struct imsgev *parent_iev_control;
+struct imsgev *parent_iev_socks;
-static struct privsep_proc procs[] = {
- { "control", PROC_CONTROL, thingsd_dispatch_control, control },
- { "sockets", PROC_SOCKS, thingsd_dispatch_sockets, sockets,
- sockets_shutdown },
-};
+static struct event ev_sigint;
+static struct event ev_sigterm;
+static struct event ev_sighup;
+static struct event ev_sigpipe;
+static struct event ev_sigusr1;
+void
+imsg_event_init(struct imsgev *iev, int fd, void (*handler)(int, short,
+ void *))
+{
+ if (imsgbuf_init(&iev->ibuf, fd) == -1)
+ fatal("%s: imsgbuf_init", __func__);
+ imsgbuf_allow_fdpass(&iev->ibuf);
+ iev->handler = handler;
+ iev->events = EV_READ;
+ event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
+ event_add(&iev->ev, NULL);
+}
+
+void
+imsg_event_add(struct imsgev *iev)
+{
+ iev->events = EV_READ;
+ if (imsgbuf_queuelen(&iev->ibuf) > 0)
+ iev->events |= EV_WRITE;
+
+ event_del(&iev->ev);
+ event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
+ event_add(&iev->ev, NULL);
+}
+
int
-thingsd_dispatch_control(int fd, struct privsep_proc *p, struct imsg *imsg)
+imsg_compose_event(struct imsgev *iev, uint32_t type, uint32_t peerid,
+ pid_t pid, int fd, void *data, size_t datalen)
{
- struct privsep *ps = p->p_ps;
- int res = 0, cmd = 0, verbose, exists = 0;
- unsigned int v = 0;
+ int ret;
+
+ if ((ret = imsg_compose(&iev->ibuf, type, peerid, pid, fd, data,
+ datalen)) == -1)
+ return (ret);
+ imsg_event_add(iev);
+ return (ret);
+}
+
+int
+imsg_composev_event(struct imsgev *iev, uint32_t type, uint32_t peerid,
+ pid_t pid, int fd, const struct iovec *iov, int iovcnt)
+{
+ int ret;
+
+ if ((ret = imsg_composev(&iev->ibuf, type, peerid, pid, fd, iov,
+ iovcnt)) == -1)
+ return (ret);
+ imsg_event_add(iev);
+ return (ret);
+}
+
+int
+imsg_forward_event(struct imsgev *iev, struct imsg *imsg)
+{
+ return (imsg_compose_event(iev, imsg->hdr.type, imsg->hdr.peerid,
+ imsg->hdr.pid, -1, imsg->data, IMSG_DATA_SIZE(imsg)));
+}
+
+/*
+ * Copy a string payload out of an imsg, bounded by both the payload and
+ * the destination so a short or unterminated message can't over-read.
+ */
+void
+imsg_get_string(struct imsg *imsg, char *buf, size_t len)
+{
+ size_t n = IMSG_DATA_SIZE(imsg);
+
+ if (n >= len)
+ n = len - 1;
+ if (n > 0)
+ memcpy(buf, imsg->data, n);
+ buf[n] = '\0';
+}
+
+void
+thingsd_dispatch_control(int fd, short event, void *arg)
+{
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ struct thing *thing;
+ int i, n, res = 0, verbose, exists;
+ unsigned int v;
char thing_name[THINGSD_MAXNAME];
- struct thing *thing;
+ char client_name[THINGSD_MAXNAME];
- switch (imsg->hdr.type) {
- case IMSG_SHOW_PACKETS_END_DATA:
- IMSG_SIZE_CHECK(imsg, &v);
- if (imsg->data == NULL)
- break;
- thingsd_stop_pkt(ps, imsg);
- break;
- case IMSG_SHOW_PACKETS_REQUEST:
- IMSG_SIZE_CHECK(imsg, &v);
- if (imsg->data == NULL)
- break;
- memcpy(thing_name, imsg->data, sizeof(thing_name));
- TAILQ_FOREACH(thing, thingsd_env->things, entry) {
- if (strcmp(thing->conf.name, thing_name) == 0) {
- thingsd_echo_pkt(ps, imsg);
- exists = 1;
- break;
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost control process", __func__);
+ thingsd_shutdown(thingsd_env);
+ }
+ }
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost control process", __func__);
+ thingsd_shutdown(thingsd_env);
}
+ fatal("%s: imsgbuf_write", __func__);
}
- if (!exists)
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_BAD_THING,
- imsg->hdr.peerid, -1, &res, sizeof(res)) == -1)
- return (-1);
- break;
- case IMSG_KILL_CLIENT:
- IMSG_SIZE_CHECK(imsg, &v);
- if (imsg->data == NULL)
- break;
- proc_forward_imsg(ps, imsg, PROC_SOCKS, -1);
- break;
- case IMSG_GET_INFO_CLIENTS_REQUEST:
- proc_forward_imsg(ps, imsg, PROC_SOCKS, -1);
- break;
- case IMSG_GET_INFO_SOCKETS_REQUEST:
- proc_forward_imsg(ps, imsg, PROC_SOCKS, -1);
- break;
- case IMSG_GET_INFO_THINGS_REQUEST:
- case IMSG_GET_INFO_THINGS_REQUEST_ROOT:
- thingsd_show_thing_info(ps, imsg);
- break;
- case IMSG_GET_INFO_THINGSD_REQUEST:
- thingsd_show_info(ps, imsg);
- break;
- case IMSG_CTL_VERBOSE:
- IMSG_SIZE_CHECK(imsg, &verbose);
- memcpy(&verbose, imsg->data, sizeof(verbose));
- log_setverbose(verbose);
- proc_forward_imsg(ps, imsg, PROC_SOCKS, -1);
- break;
- default:
- return (-1);
}
- switch (cmd) {
- case 0:
- break;
- default:
- if (proc_compose_imsg(ps, PROC_CONTROL, -1, cmd,
- imsg->hdr.peerid, -1, &res, sizeof(res)) == -1)
- return (-1);
- break;
- }
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
+ break;
- return (0);
+ switch (imsg.hdr.type) {
+ case IMSG_SHOW_PACKETS_END_DATA:
+ IMSG_SIZE_CHECK(&imsg, &v);
+ if (imsg.data == NULL)
+ break;
+ thingsd_stop_pkt(&imsg);
+ break;
+ case IMSG_SHOW_PACKETS_REQUEST:
+ exists = 0;
+ imsg_get_string(&imsg, thing_name, sizeof(thing_name));
+ TAILQ_FOREACH(thing, thingsd_env->things, entry) {
+ if (strcmp(thing->conf.name, thing_name) == 0) {
+ thingsd_echo_pkt(&imsg);
+ exists = 1;
+ break;
+ }
+ }
+ if (!exists)
+ imsg_compose_event(parent_iev_control,
+ IMSG_BAD_THING, imsg.hdr.peerid, 0, -1,
+ &res, sizeof(res));
+ break;
+ case IMSG_KILL_CLIENT:
+ imsg_get_string(&imsg, client_name,
+ sizeof(client_name));
+ if (client_name[0] == '\0')
+ break;
+ /* FALLTHROUGH */
+ case IMSG_GET_INFO_CLIENTS_REQUEST:
+ case IMSG_GET_INFO_SOCKETS_REQUEST:
+ for (i = 0; i < thingsd_env->prefork_socks; i++)
+ imsg_forward_event(&parent_iev_socks[i], &imsg);
+ break;
+ case IMSG_GET_INFO_THINGS_REQUEST:
+ case IMSG_GET_INFO_THINGS_REQUEST_ROOT:
+ thingsd_show_thing_info(&imsg);
+ break;
+ case IMSG_GET_INFO_THINGSD_REQUEST:
+ thingsd_show_info(&imsg);
+ break;
+ case IMSG_CTL_VERBOSE:
+ IMSG_SIZE_CHECK(&imsg, &verbose);
+ memcpy(&verbose, imsg.data, sizeof(verbose));
+ log_setverbose(verbose);
+ for (i = 0; i < thingsd_env->prefork_socks; i++)
+ imsg_forward_event(&parent_iev_socks[i], &imsg);
+ break;
+ default:
+ log_warnx("%s: unexpected imsg %d from control",
+ __func__, imsg.hdr.type);
+ break;
+ }
+ imsg_free(&imsg);
+ }
+ imsg_event_add(iev);
}
-int
-thingsd_dispatch_sockets(int fd, struct privsep_proc *p, struct imsg *imsg)
+void
+thingsd_dispatch_sockets(int fd, short event, void *arg)
{
- struct package *package = NULL;
- struct privsep *ps = p->p_ps;
- struct thingsd *env = ps->ps_env;
+ struct imsgev *iev = arg;
+ struct imsgbuf *ibuf = &iev->ibuf;
+ struct imsg imsg;
+ struct package *package;
+ int n;
- switch (imsg->hdr.type) {
- case IMSG_DIST_CLIENT_PACKAGE:
- IMSG_SIZE_CHECK(imsg, package);
- package = (struct package *)imsg->data;
- thingsd_write_to_things(package);
- break;
- case IMSG_CFG_DONE:
- thingsd_configure_done(env);
- break;
- default:
- return (-1);
+ if (event & EV_READ) {
+ if ((n = imsgbuf_read(ibuf)) == -1)
+ fatal("%s: imsgbuf_read", __func__);
+ if (n == 0) {
+ log_warnx("%s: lost sockets process", __func__);
+ thingsd_shutdown(thingsd_env);
+ }
}
+ if (event & EV_WRITE) {
+ if (imsgbuf_write(ibuf) == -1) {
+ if (errno == EPIPE) {
+ log_warnx("%s: lost sockets process", __func__);
+ thingsd_shutdown(thingsd_env);
+ }
+ fatal("%s: imsgbuf_write", __func__);
+ }
+ }
- return (0);
+ for (;;) {
+ if ((n = imsgbuf_get(ibuf, &imsg)) == -1)
+ fatal("%s: imsgbuf_get", __func__);
+ if (n == 0)
+ break;
+
+ switch (imsg.hdr.type) {
+ case IMSG_DIST_CLIENT_PACKAGE:
+ IMSG_SIZE_CHECK(&imsg, package);
+ package = (struct package *)imsg.data;
+ if (package->len < 0 ||
+ (size_t)package->len > sizeof(package->pkt))
+ fatalx("%s: bad package length", __func__);
+ thingsd_write_to_things(package);
+ break;
+ case IMSG_CFG_DONE:
+ thingsd_configure_done(thingsd_env);
+ break;
+ default:
+ log_warnx("%s: unexpected imsg %d from sockets",
+ __func__, imsg.hdr.type);
+ break;
+ }
+ imsg_free(&imsg);
+ }
+ imsg_event_add(iev);
}
void
thingsd_sighdlr(int sig, short event, void *arg)
{
- struct privsep *ps = arg;
+ struct thingsd *env = arg;
- if (privsep_process != PROC_PARENT)
- return;
-
switch (sig) {
case SIGHUP:
log_info("%s: ignoring SIGHUP", __func__);
break;
case SIGTERM:
case SIGINT:
- thingsd_shutdown(ps->ps_env);
+ thingsd_shutdown(env);
break;
default:
fatalx("unexpected signal");
main(int argc, char **argv)
{
struct thingsd *env;
- struct privsep *ps;
struct timeval eb_timeout;
- const char *errp, *title = NULL;
const char *conffile = THINGSD_CONF;
- int proc_instance = 0;
- int ch;
- int argc0 = argc;
- enum privsep_procid proc_id = PROC_PARENT;
+ int ch, i, n;
+ int pipe_control[2];
+ int pipe_socks[THINGSD_MAX_PREFORK][2];
+ int pipe_control_socks[THINGSD_MAX_PREFORK][2];
+ int fd_socks[THINGSD_MAX_PREFORK];
if ((env = calloc(1, sizeof(*env))) == NULL)
fatal("%s: calloc", __func__);
- while ((ch = getopt(argc, argv, "D:P:I:df:vn")) != -1) {
+ while ((ch = getopt(argc, argv, "D:df:vn")) != -1) {
switch (ch) {
case 'D':
if (cmdline_symset(optarg) < 0)
env->thingsd_debug = 2;
env->thingsd_noaction = 1;
break;
- case 'P':
- title = optarg;
- proc_id = proc_getid(procs, nitems(procs), title);
- if (proc_id == PROC_MAX)
- fatalx("invalid process name");
- break;
- case 'I':
- proc_instance = strtonum(optarg, 0,
- PROC_MAX_INSTANCES, &errp);
- if (errp)
- fatalx("invalid process instance");
- break;
default:
usage();
}
if (argc > 0)
usage();
- if ((ps = calloc(1, sizeof(*ps))) == NULL)
- fatal("%s: calloc", __func__);
-
thingsd_env = env;
- env->thingsd_ps = ps;
- ps->ps_env = env;
- TAILQ_INIT(&ps->ps_rcsocks);
env->thingsd_conffile = conffile;
if (parse_config(env->thingsd_conffile, env) == -1)
fatalx("need root privileges");
}
- if ((ps->ps_pw = getpwnam(THINGSD_USER)) == NULL)
+ if (getpwnam(THINGSD_USER) == NULL)
fatal("unknown user %s", THINGSD_USER);
- /* Configure the control socket */
- ps->ps_csock.cs_name = THINGSD_SOCKET;
+ if (env->thingsd_noaction) {
+ fprintf(stderr, "configuration OK\n");
+ exit(0);
+ }
log_init(env->thingsd_debug, LOG_DAEMON);
log_setverbose(env->thingsd_verbose);
-
- if (env->thingsd_noaction)
- ps->ps_noaction = 1;
-
- ps->ps_instances[PROC_SOCKS] = env->prefork_socks;
- ps->ps_instance = proc_instance;
- if (title != NULL)
- ps->ps_title[proc_id] = title;
-
- /* only the thingsd returns */
- proc_init(ps, procs, nitems(procs), env->thingsd_debug, argc0,
- argv, proc_id);
-
log_procinit("thingsd");
+
if (!env->thingsd_debug && daemon(0, 0) == -1)
fatal("can't daemonize");
- if (ps->ps_noaction == 0)
- log_info("%s startup", getprogname());
+ log_info("%s startup", getprogname());
+ /*
+ * All pipes are created before forking so the children inherit
+ * them and no descriptor passing is needed to wire the processes
+ * together. Each child closes the ends it does not own.
+ */
+ if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, PF_UNSPEC,
+ pipe_control) == -1)
+ fatal("%s: socketpair", __func__);
+ for (i = 0; i < env->prefork_socks; i++) {
+ if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, PF_UNSPEC,
+ pipe_socks[i]) == -1)
+ fatal("%s: socketpair", __func__);
+ if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, PF_UNSPEC,
+ pipe_control_socks[i]) == -1)
+ fatal("%s: socketpair", __func__);
+ }
+
+ switch (fork()) {
+ case -1:
+ fatal("%s: fork", __func__);
+ case 0:
+ close(pipe_control[0]);
+ for (i = 0; i < env->prefork_socks; i++) {
+ close(pipe_socks[i][0]);
+ close(pipe_socks[i][1]);
+ close(pipe_control_socks[i][1]);
+ fd_socks[i] = pipe_control_socks[i][0];
+ }
+ control(pipe_control[1], fd_socks);
+ /* NOTREACHED */
+ }
+
+ for (n = 0; n < env->prefork_socks; n++) {
+ switch (fork()) {
+ case -1:
+ fatal("%s: fork", __func__);
+ case 0:
+ close(pipe_control[0]);
+ close(pipe_control[1]);
+ for (i = 0; i < env->prefork_socks; i++) {
+ close(pipe_socks[i][0]);
+ close(pipe_control_socks[i][0]);
+ if (i == n)
+ continue;
+ close(pipe_socks[i][1]);
+ close(pipe_control_socks[i][1]);
+ }
+ sockets(pipe_socks[n][1], pipe_control_socks[n][1]);
+ /* NOTREACHED */
+ }
+ }
+
+ close(pipe_control[1]);
+ for (i = 0; i < env->prefork_socks; i++) {
+ close(pipe_socks[i][1]);
+ close(pipe_control_socks[i][0]);
+ close(pipe_control_socks[i][1]);
+ }
+
env->thingsd_eb = event_init();
- signal_set(&ps->ps_evsigint, SIGINT, thingsd_sighdlr, ps);
- signal_set(&ps->ps_evsigterm, SIGTERM, thingsd_sighdlr, ps);
- signal_set(&ps->ps_evsighup, SIGHUP, thingsd_sighdlr, ps);
- signal_set(&ps->ps_evsigpipe, SIGPIPE, thingsd_sighdlr, ps);
- signal_set(&ps->ps_evsigusr1, SIGUSR1, thingsd_sighdlr, ps);
+ signal_set(&ev_sigint, SIGINT, thingsd_sighdlr, env);
+ signal_set(&ev_sigterm, SIGTERM, thingsd_sighdlr, env);
+ signal_set(&ev_sighup, SIGHUP, thingsd_sighdlr, env);
+ signal_set(&ev_sigpipe, SIGPIPE, thingsd_sighdlr, env);
+ signal_set(&ev_sigusr1, SIGUSR1, thingsd_sighdlr, env);
- signal_add(&ps->ps_evsigint, NULL);
- signal_add(&ps->ps_evsigterm, NULL);
- signal_add(&ps->ps_evsighup, NULL);
- signal_add(&ps->ps_evsigpipe, NULL);
- signal_add(&ps->ps_evsigusr1, NULL);
+ signal_add(&ev_sigint, NULL);
+ signal_add(&ev_sigterm, NULL);
+ signal_add(&ev_sighup, NULL);
+ signal_add(&ev_sigpipe, NULL);
+ signal_add(&ev_sigusr1, NULL);
- if (!env->thingsd_noaction)
- proc_connect(ps);
+ if ((parent_iev_control = calloc(1, sizeof(*parent_iev_control)))
+ == NULL)
+ fatal("%s: calloc", __func__);
+ imsg_event_init(parent_iev_control, pipe_control[0],
+ thingsd_dispatch_control);
+ if ((parent_iev_socks = calloc(env->prefork_socks,
+ sizeof(*parent_iev_socks))) == NULL)
+ fatal("%s: calloc", __func__);
+ for (i = 0; i < env->prefork_socks; i++)
+ imsg_event_init(&parent_iev_socks[i], pipe_socks[i][0],
+ thingsd_dispatch_sockets);
+
if (thingsd_configure(env) == -1)
fatalx("configuration failed");
eb_timeout.tv_sec = EB_TIMEOUT;
eb_timeout.tv_usec = 0;
- if (unveil(THINGSD_CONF, "r") == -1)
- err(1, "unveil");
+ /* serial things are reopened from here on, nothing else is */
if (unveil("/dev", "rw") == -1)
err(1, "unveil");
if (unveil(NULL, NULL) != 0)
env->run = 1;
while (env->run) {
- if (env->exists)
+ if (!TAILQ_EMPTY(env->dead_things))
thingsd_do_reconn(env);
event_base_loopexit(env->thingsd_eb, &eb_timeout);
event_base_dispatch(env->thingsd_eb);
{
struct thing *thing;
struct socket *sock;
- unsigned int id;
+ int n;
- if (env->thingsd_noaction) {
- fprintf(stderr, "configuration OK\n");
- proc_kill(env->thingsd_ps);
- exit(0);
- }
-
env->socks_reload = env->prefork_socks;
/* setup our things, which run privileged */
- TAILQ_FOREACH(thing, env->things, entry) {
- /* setup serial things */
- thingsd_thing_serial_open(thing, 0);
+ TAILQ_FOREACH(thing, env->things, entry)
+ thingsd_thing_connect(env, thing, 0);
- /* setup udp/tcp things */
- thingsd_thing_setup(env, thing, 0);
- }
-
-
TAILQ_FOREACH(sock, env->sockets, entry) {
socket_tls_load(sock);
if (config_setsocks(env, sock) == -1)
fatalx("%s: send socket error", __func__);
}
- for (id = 0; id < PROC_MAX; id++) {
- if (id == privsep_process)
- continue;
- proc_compose(env->thingsd_ps, id, IMSG_CFG_DONE, NULL, 0);
- }
+ imsg_compose_event(parent_iev_control, IMSG_CFG_DONE, 0, 0, -1,
+ NULL, 0);
+ for (n = 0; n < env->prefork_socks; n++)
+ imsg_compose_event(&parent_iev_socks[n], IMSG_CFG_DONE, 0, 0,
+ -1, NULL, 0);
return (0);
}
void
thingsd_configure_done(struct thingsd *env)
{
- unsigned int id;
+ int n;
+
if (env->socks_reload == 0) {
log_warnx("%s: configuration already finished", __func__);
return;
env->socks_reload--;
if (env->socks_reload == 0) {
- for (id = 0; id < PROC_MAX; id++) {
- if (id == privsep_process)
- continue;
- proc_compose(env->thingsd_ps, id, IMSG_CTL_START,
- NULL, 0);
- }
+ imsg_compose_event(parent_iev_control, IMSG_CTL_START, 0, 0,
+ -1, NULL, 0);
+ for (n = 0; n < env->prefork_socks; n++)
+ imsg_compose_event(&parent_iev_socks[n],
+ IMSG_CTL_START, 0, 0, -1, NULL, 0);
}
}
-void
+__dead void
thingsd_shutdown(struct thingsd *env)
{
- proc_kill(env->thingsd_ps);
- control_cleanup(&env->thingsd_ps->ps_csock);
+ pid_t pid;
+ int n, status;
+ /* closing the pipes tells the children to exit */
+ event_del(&parent_iev_control->ev);
+ imsgbuf_clear(&parent_iev_control->ibuf);
+ close(parent_iev_control->ibuf.fd);
+ for (n = 0; n < env->prefork_socks; n++) {
+ event_del(&parent_iev_socks[n].ev);
+ imsgbuf_clear(&parent_iev_socks[n].ibuf);
+ close(parent_iev_socks[n].ibuf.fd);
+ }
+ free(parent_iev_control);
+ free(parent_iev_socks);
+
+ log_debug("waiting for children to terminate");
+ do {
+ pid = wait(&status);
+ if (pid == -1) {
+ if (errno != EINTR && errno != ECHILD)
+ fatal("wait");
+ } else if (WIFSIGNALED(status))
+ log_warnx("lost child: pid %d terminated; signal %d",
+ pid, WTERMSIG(status));
+ else if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
+ log_warnx("lost child: pid %d exited abnormally", pid);
+ } while (pid != -1 || (pid == -1 && errno == EINTR));
+
thingsd_parent_shutdown(env);
log_warnx("thingsd terminating");
}
void
-thingsd_show_info(struct privsep *ps, struct imsg *imsg)
+thingsd_show_info(struct imsg *imsg)
{
struct thingsd_thingsd_info npi;
switch (imsg->hdr.type) {
case IMSG_GET_INFO_THINGSD_REQUEST:
npi.verbose = log_getverbose();
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_THINGSD_DATA, imsg->hdr.peerid,
- -1, &npi, sizeof(npi)) == -1)
+ if (imsg_compose_event(parent_iev_control,
+ IMSG_GET_INFO_THINGSD_DATA, imsg->hdr.peerid, 0, -1,
+ &npi, sizeof(npi)) == -1)
return;
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_THINGSD_END_DATA, imsg->hdr.peerid,
- -1, &npi, sizeof(npi)) == -1)
+ if (imsg_compose_event(parent_iev_control,
+ IMSG_GET_INFO_THINGSD_END_DATA, imsg->hdr.peerid, 0, -1,
+ &npi, sizeof(npi)) == -1)
return;
break;
default:
struct package *package, *tpkg;
struct dead_thing *dead_thing, *tdead_thing;
struct packet_client *pclt, *tpclt;
+ int n;
log_debug("thingsd parent shutting down");
}
if (event_initialized(&sock->ev))
event_del(&sock->ev);
- close(sock->fd);
+ if (sock->fd != -1)
+ close(sock->fd);
TAILQ_REMOVE(env->sockets, sock, entry);
free(sock);
}
free(thing->conf.tls_ocsp_staple_file);
}
- if (event_initialized(&thing->udp_ev))
- event_del(&thing->udp_ev);
+ for (n = 0; n < thing->udp_nfd; n++) {
+ event_del(&thing->udp_ev[n]);
+ close(thing->udp_fd[n]);
+ }
if (thing->bev != NULL)
- bufferevent_disable(thing->bev, EV_READ | EV_WRITE);
- if (thing->bev != NULL)
bufferevent_free(thing->bev);
if (thing->fd != -1)
{
struct thing *thing;
- /* check if thing already exists */
+ /* duplicate names are a config error */
TAILQ_FOREACH(thing, env->things, entry) {
if (strcmp(name, thing->conf.name) == 0)
- return (thing);
+ return (NULL);
}
if ((thing = calloc(1, sizeof(*thing))) == NULL)
thing->conf.ipv4 = 1;
thing->conf.id = id;
+ thing->fd = -1;
TAILQ_INSERT_TAIL(env->things, thing, entry);
return (thing);
}
-void
-thingsd_thing_serial_open(struct thing *thing, int reconn)
+int
+thingsd_thing_serial_open(struct thing *thing)
{
- struct dead_thing *dead_thing;
struct termios s_opts;
- int baudrate = 0, stop = 0;
+ int baudrate = 0, csize = 0;
- if (thing->conf.type == S_DEV) {
+ /*
+ * Just a reminder to set the ownership of your serial
+ * devices to _thingsd. Otherwise, a thing will not be
+ * able to successfully open(2) the file descriptor.
+ */
+ if ((thing->fd = open(thing->conf.location, O_RDWR |
+ O_NONBLOCK | O_NOCTTY | O_NDELAY)) == -1) {
+ log_warn("failed to open %s", thing->conf.location);
+ return (-1);
+ }
- /*
- * Just a reminder to set the ownership of your serial
- * devices to _thingsd. Otherwise, a thing will not be
- * able to successfully open(2) the file descriptor.
- */
- if ((thing->fd = open(thing->conf.location, O_RDWR |
- O_NONBLOCK | O_NOCTTY | O_NDELAY)) == -1) {
- log_warnx("failed to open %s", thing->conf.location);
+ if (tcgetattr(thing->fd, &s_opts) == -1) {
+ log_warn("%s: tcgetattr %s", __func__, thing->conf.location);
+ close(thing->fd);
+ thing->fd = -1;
+ return (-1);
+ }
- if (reconn)
- return;
+ switch (thing->conf.baud) {
+ case 50:
+ baudrate = B50;
+ break;
+ case 75:
+ baudrate = B75;
+ break;
+ case 110:
+ baudrate = B110;
+ break;
+ case 134:
+ baudrate = B134;
+ break;
+ case 150:
+ baudrate = B150;
+ break;
+ case 200:
+ baudrate = B200;
+ break;
+ case 300:
+ baudrate = B300;
+ break;
+ case 600:
+ baudrate = B600;
+ break;
+ case 1200:
+ baudrate = B1200;
+ break;
+ case 1800:
+ baudrate = B1800;
+ break;
+ case 2400:
+ baudrate = B2400;
+ break;
+ case 4800:
+ baudrate = B4800;
+ break;
+ case 9600:
+ baudrate = B9600;
+ break;
+ case 19200:
+ baudrate = B19200;
+ break;
+ case 38400:
+ baudrate = B38400;
+ break;
+ case 57600:
+ baudrate = B57600;
+ break;
+ case 76800:
+ baudrate = B76800;
+ break;
+ case 115200:
+ baudrate = B115200;
+ break;
+ }
- dead_thing = thingsd_new_dead_thing(thing);
+ cfsetispeed(&s_opts, baudrate);
+ cfsetospeed(&s_opts, baudrate);
- thingsd_env->exists = 1;
- thingsd_env->dcount++;
+ /* enable and set local */
+ s_opts.c_cflag |= (CLOCAL | CREAD);
- TAILQ_INSERT_TAIL(thingsd_env->dead_things,
- dead_thing, entry);
+ if (thing->conf.data_bits != -1) {
+ s_opts.c_cflag &= ~CSIZE;
+ switch (thing->conf.data_bits) {
+ case 5:
+ csize = CS5;
+ break;
+ case 6:
+ csize = CS6;
+ break;
+ case 7:
+ csize = CS7;
+ break;
+ case 8:
+ csize = CS8;
+ break;
+ }
+ s_opts.c_cflag |= csize;
+ }
- return;
- } else {
- /* load current s_opts */
- tcgetattr(thing->fd, &s_opts);
+ if (strlen(thing->conf.parity) != 0) {
+ s_opts.c_cflag &= ~PARENB;
- /* set baud */
- switch (thing->conf.baud) {
- case 50:
- baudrate = B50;
- break;
- case 75:
- baudrate = B75;
- break;
- case 110:
- baudrate = B110;
- break;
- case 134:
- baudrate = B134;
- break;
- case 150:
- baudrate = B150;
- break;
- case 200:
- baudrate = B200;
- break;
- case 300:
- baudrate = B300;
- break;
- case 600:
- baudrate = B600;
- break;
- case 1200:
- baudrate = B1200;
- break;
- case 1800:
- baudrate = B1800;
- break;
- case 2400:
- baudrate = B2400;
- break;
- case 4800:
- baudrate = B4800;
- break;
- case 9600:
- baudrate = B9600;
- break;
- case 19200:
- baudrate = B19200;
- break;
- case 38400:
- baudrate = B38400;
- break;
- case 57600:
- baudrate = B57600;
- break;
- case 76800:
- baudrate = B76800;
- break;
- case 115200:
- baudrate = B115200;
- break;
- }
+ if (strcmp(thing->conf.parity, "odd") == 0) {
+ s_opts.c_cflag |= PARENB;
+ s_opts.c_cflag |= PARODD;
+ s_opts.c_iflag |= (INPCK | ISTRIP);
+ } else if (strcmp(thing->conf.parity, "even") == 0) {
+ s_opts.c_cflag |= PARENB;
+ s_opts.c_cflag &= ~PARODD;
+ s_opts.c_iflag |= (INPCK | ISTRIP);
+ }
+ }
- cfsetispeed(&s_opts, baudrate);
- cfsetospeed(&s_opts, baudrate);
+ if (thing->conf.stop_bits != -1) {
+ if (thing->conf.stop_bits == 2)
+ s_opts.c_cflag |= CSTOPB;
+ else
+ s_opts.c_cflag &= ~CSTOPB;
+ }
- /* enable and set local */
- s_opts.c_cflag |= (CLOCAL | CREAD);
+ if (thing->conf.hw_ctl == 0)
+ s_opts.c_cflag &= ~CRTSCTS;
+ else
+ s_opts.c_cflag |= CRTSCTS;
- /* set data bits */
- if (thing->conf.data_bits != -1) {
- s_opts.c_cflag &= ~CSIZE;
- switch(thing->conf.data_bits) {
- case 5:
- stop = CS5;
- break;
- case 6:
- stop = CS6;
- break;
- case 7:
- stop = CS7;
- break;
- case 8:
- stop = CS8;
- break;
- }
- s_opts.c_cflag |= stop;
- }
+ if (thing->conf.sw_ctl == 0)
+ s_opts.c_iflag &= ~(IXON | IXOFF | IXANY);
+ else
+ s_opts.c_iflag |= (IXON | IXOFF | IXANY);
- /* set parity */
- if (strlen(thing->conf.parity) != 0) {
- s_opts.c_cflag &= ~PARENB;
+ /* raw input/output */
+ s_opts.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
+ s_opts.c_oflag &= ~OPOST;
- /* enable parity checking */
- if (strcmp(thing->conf.parity, "odd") == 0) {
- s_opts.c_cflag |= PARENB;
- s_opts.c_cflag |= PARODD;
- s_opts.c_iflag |= (INPCK |
- ISTRIP);
- } else if (strcmp(thing->conf.parity,
- "even") == 0) {
- s_opts.c_cflag |= PARENB;
- s_opts.c_cflag &= ~PARODD;
- s_opts.c_iflag |= (INPCK |
- ISTRIP);
- }
+ if (tcsetattr(thing->fd, TCSANOW, &s_opts) == -1) {
+ log_warn("%s: tcsetattr %s", __func__, thing->conf.location);
+ close(thing->fd);
+ thing->fd = -1;
+ return (-1);
+ }
- }
+ return (0);
+}
- /* set stop bits */
- if (thing->conf.stop_bits != -1) {
- if (thing->conf.stop_bits == 2)
- s_opts.c_cflag |= CSTOPB;
- else
- s_opts.c_cflag &= ~CSTOPB;
- }
+/*
+ * Open the thing's descriptor(s) and hook them into the event loop.
+ * On failure the thing is queued for a retry unless this already is one.
+ */
+int
+thingsd_thing_connect(struct thingsd *env, struct thing *thing, int reconn)
+{
+ struct address *a;
+ int fd, n;
- /* set hardware control */
- if (thing->conf.hw_ctl == 0) {
- s_opts.c_cflag &= ~CRTSCTS;
- } else {
- s_opts.c_cflag |= CRTSCTS;
- }
+ thing->conf.env = env;
- /* set software control */
- if (thing->conf.sw_ctl == 0) {
- s_opts.c_iflag &= ~(IXON | IXOFF |
- IXANY);
- } else {
- s_opts.c_iflag |= (IXON | IXOFF |
- IXANY);
- }
-
- /* set input/output as raw */
- s_opts.c_lflag &= ~(ICANON | ECHO | ECHOE |
- ISIG);
-
- s_opts.c_oflag &= ~OPOST;
-
- /* Set the new options for the port */
- tcsetattr(thing->fd, TCSANOW, &s_opts);
-
- if (thing->fd == '\0') {
- log_warnx("serial device not opened");
- if (reconn)
- return;
- thingsd_add_reconn(thing);
- return;
- }
+ switch (thing->conf.type) {
+ case S_DEV:
+ if (thingsd_thing_serial_open(thing) == -1)
+ goto fail;
+ break;
+ case S_TCP:
+ if (thing->conf.persist == 0) {
+ /* connections are made per packet */
+ thing->fd = -1;
thing->exists = 1;
+ return (0);
}
-
- if (reconn && thing->exists)
- log_info("reconnected: %s", thing->conf.name);
- }
-}
-
-void
-thingsd_thing_setup(struct thingsd *env, struct thing *thing, int reconn)
-{
- evbuffercb thingrd = thingsd_thing_read;
- evbuffercb thingwr = thingsd_thing_write;
-
- if (thing->conf.type == S_TCP) {
- if (thing->conf.persist == 1) {
- if ((thing->fd = sockets_open_client(thing->conf.ipaddr,
- thing->conf.tcp_conn_port)) == -1) {
- log_warnx("%s: ipaddr connection failed",
- __func__);
- if (reconn)
- return;
- thingsd_add_reconn(thing);
- return;
+ if ((thing->fd = sockets_open_client(thing->conf.ipaddr,
+ thing->conf.tcp_conn_port)) == -1) {
+ log_warnx("%s: ipaddr connection failed for %s",
+ __func__, thing->conf.name);
+ goto fail;
+ }
+ thing->connecting = 1;
+ break;
+ case S_UDP:
+ /* udp things never go away, so this only runs at startup */
+ n = 0;
+ TAILQ_FOREACH(a, thing->conf.udp_al, entry) {
+ if (n >= THINGSD_MAXIFACE) {
+ log_warnx("%s: too many udp addresses for %s",
+ __func__, thing->conf.name);
+ break;
}
- } else
- /* 0 indicates non-persistent socket */
- thing->fd = 0;
+ if ((fd = sockets_create_socket(&a->ss,
+ thing->conf.udp_rcv_port, S_UDP)) == -1)
+ fatalx("%s: create udp socket failed for %s",
+ __func__, thing->conf.name);
+ thing->udp_fd[n] = fd;
+ event_set(&thing->udp_ev[n], fd, EV_READ | EV_PERSIST,
+ thingsd_thing_udp_event, thing);
+ if (event_add(&thing->udp_ev[n], NULL))
+ fatalx("%s: udp ev error", __func__);
+ n++;
+ }
+ if (n == 0)
+ fatalx("%s: no udp address for %s", __func__,
+ thing->conf.name);
+ thing->udp_nfd = n;
+ thing->exists = 1;
+ log_debug("%s: running udp thing %s", __func__,
+ thing->conf.name);
+ return (0);
+ default:
+ fatalx("%s: unknown thing type %d", __func__,
+ thing->conf.type);
}
- if (thing->conf.type == S_UDP) {
- if ((thing->fd = sockets_create_socket(thing->conf.udp_al,
- thing->conf.udp_rcv_port, S_UDP)) == -1)
- fatalx("%s: create udp socket failed", __func__);
- }
-
log_debug("%s: configuring thing %s (%d)", __func__, thing->conf.name,
thing->fd);
- if (thing->conf.type == S_UDP) {
- event_set(&thing->udp_ev, thing->fd, EV_READ |
- EV_PERSIST, thingsd_thing_udp_event, thing);
+ thing->bev = bufferevent_new(thing->fd, thingsd_thing_read,
+ thingsd_thing_write, thingsd_thing_err, thing);
+ if (thing->bev == NULL)
+ fatalx("%s: bufferevent_new", __func__);
- if (event_add(&thing->udp_ev, NULL))
- fatalx("%s: udp ev error", __func__);
- } else {
- thing->bev = bufferevent_new(thing->fd,
- thingrd, thingwr, thingsd_thing_err, thing);
+ /* never buffer more than one package worth of input */
+ bufferevent_setwatermark(thing->bev, EV_READ, 0, PKT_BUFF);
+ bufferevent_enable(thing->bev, EV_READ | EV_WRITE);
- if (thing->bev == NULL)
- fatalx("%s: ipaddr bev error", __func__);
-
- thing->evb = evbuffer_new();
-
- if (thing->evb == NULL)
- fatalx("ipaddr evb error");
-
- bufferevent_enable(thing->bev, EV_READ | EV_WRITE);
- }
-
- log_debug("%s: running thing %s", __func__, thing->conf.name);
-
- thing->conf.env = env;
thing->exists = 1;
- if (reconn)
- log_info("reconnected: %s", thing->conf.name);
+ if (thing->conf.type == S_DEV)
+ log_info("%s: %s", reconn ? "reconnected" : "connected",
+ thing->conf.name);
+
+ return (0);
+
+fail:
+ if (!reconn)
+ thingsd_add_reconn(thing);
+ return (-1);
}
void
+thingsd_thing_disconnect(struct thing *thing)
+{
+ if (thing->bev != NULL) {
+ bufferevent_free(thing->bev);
+ thing->bev = NULL;
+ }
+ if (thing->fd != -1) {
+ close(thing->fd);
+ thing->fd = -1;
+ }
+ thing->connecting = 0;
+ thingsd_add_reconn(thing);
+}
+
+void
+thingsd_oneshot_cb(int fd, short event, void *arg)
+{
+ struct oneshot *os = arg;
+ socklen_t len = sizeof(int);
+ int error = 0;
+
+ if (event & EV_TIMEOUT)
+ log_warnx("%s: connection to %s timed out", __func__,
+ os->name);
+ else if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) == -1 ||
+ error != 0) {
+ errno = error ? error : errno;
+ log_warn("%s: connection to %s failed", __func__, os->name);
+ } else if (write(fd, os->pkt, os->len) == -1)
+ log_warn("%s: write to %s failed", __func__, os->name);
+
+ close(fd);
+ free(os);
+}
+
+void
thingsd_write_to_things(struct package *package)
{
struct thing *thing = NULL;
+ struct oneshot *os;
+ struct timeval tv;
TAILQ_FOREACH(thing, thingsd_env->things, entry)
if (thing->conf.id == package->thing_id)
if (thing == NULL)
return;
- switch (thing->conf.type) {
- case S_TCP:
- case S_DEV:
- if (thing->conf.persist == 0) {
- if ((thing->fd = sockets_open_client(thing->conf.ipaddr,
- thing->conf.tcp_conn_port)) == -1) {
- log_warnx("%s: temporary ipaddr connection"
- " failed", __func__);
- return;
- }
- write(thing->fd, package->pkt, package->len);
- close(thing->fd);
- thing->fd = -1;
- } else {
- if (thing->fd != -1) {
- bufferevent_write(thing->bev, package->pkt,
- package->len);
- }
- }
- break;
- case S_UDP:
- default:
- write(thing->fd, package->pkt, package->len);
- break;
+ if (thing->conf.type == S_UDP) {
+ /* udp things are receive only */
+ log_debug("%s: dropping packet for udp thing %s", __func__,
+ thing->conf.name);
+ return;
}
+
+ if (thing->conf.type == S_DEV || thing->conf.persist) {
+ if (thing->bev != NULL)
+ bufferevent_write(thing->bev, package->pkt,
+ package->len);
+ return;
+ }
+
+ if ((os = calloc(1, sizeof(*os))) == NULL) {
+ log_warn("%s: calloc", __func__);
+ return;
+ }
+ if ((os->fd = sockets_open_client(thing->conf.ipaddr,
+ thing->conf.tcp_conn_port)) == -1) {
+ free(os);
+ return;
+ }
+ memcpy(os->pkt, package->pkt, package->len);
+ os->len = package->len;
+ strlcpy(os->name, thing->conf.name, sizeof(os->name));
+
+ /* fires once the non-blocking connect has settled */
+ tv.tv_sec = ONESHOT_TIMEOUT;
+ tv.tv_usec = 0;
+ event_set(&os->ev, os->fd, EV_WRITE, thingsd_oneshot_cb, os);
+ if (event_add(&os->ev, &tv) == -1) {
+ log_warn("%s: event_add", __func__);
+ close(os->fd);
+ free(os);
+ }
}
void
thingsd_write_to_socks(struct packages *packages)
{
- struct privsep *ps = thingsd_env->thingsd_ps;
struct package *package, *tpkg, p;
struct packet_client *packet_client;
struct thing *thing = NULL;
- unsigned int id, what;
- int fd = -1, n, m;
- struct iovec iov[6];
- size_t c;
+ int n;
TAILQ_FOREACH_SAFE(package, packages, entry, tpkg) {
- for (id = 0; id < PROC_MAX; id++) {
- what = ps->ps_what[id];
+ memcpy(&p, package, sizeof(p));
- if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
- continue;
-
- memcpy(&p, package, sizeof(p));
-
- c = 0;
- iov[c].iov_base = &p;
- iov[c++].iov_len = sizeof(p);
- if (id == PROC_SOCKS) {
- /* XXX imsg code will close the fd after 1st call */
- n = -1;
- proc_range(ps, id, &n, &m);
- for (n = 0; n < m; n++) {
- /* send thing fd */
- if (proc_composev_imsg(ps, id, n,
- IMSG_DIST_THING_PACKAGE, -1, fd,
- iov, c) != 0) {
- log_warn("%s: failed to compose"
- " IMSG_DIST_THING_PACKAGE"
- " imsg",
- __func__);
- return;
- }
- if (proc_flush_imsg(ps, id, n) == -1) {
- log_warn("%s: failed to flush "
- "IMSG_DIST_THING_PACKAGE "
- "imsg",
- __func__);
- return;
- }
- }
+ for (n = 0; n < thingsd_env->prefork_socks; n++) {
+ if (imsg_compose_event(&parent_iev_socks[n],
+ IMSG_DIST_THING_PACKAGE, 0, 0, -1, &p,
+ sizeof(p)) == -1) {
+ log_warn("%s: failed to compose "
+ "IMSG_DIST_THING_PACKAGE imsg", __func__);
+ return;
}
}
TAILQ_FOREACH(packet_client, thingsd_env->packet_clients,
entry) {
- if (strlen(packet_client->name) != 0) {
- if (strcmp(thing->conf.name,
- packet_client->name) == 0)
- if (proc_compose_imsg(
- &packet_client->ps,
- PROC_CONTROL, -1,
- IMSG_SHOW_PACKETS_DATA,
- packet_client->imsg.hdr.peerid, -1,
- package->pkt, package->len) == -1)
- break;
- }
+ if (strlen(packet_client->name) == 0)
+ continue;
+ if (strcmp(thing->conf.name, packet_client->name) != 0)
+ continue;
+ if (imsg_compose_event(parent_iev_control,
+ IMSG_SHOW_PACKETS_DATA, packet_client->peerid, 0,
+ -1, package->pkt, package->len) == -1)
+ break;
}
free:
TAILQ_REMOVE(packages, package, entry);
thingsd_thing_read(struct bufferevent *bev, void *arg)
{
struct thing *thing = (struct thing *)arg;
- struct package *package = NULL;
+ struct evbuffer *evb = EVBUFFER_INPUT(bev);
+ struct package *package;
+ size_t len;
+ while ((len = EVBUFFER_LENGTH(evb)) > 0) {
+ if ((package = calloc(1, sizeof(*package))) == NULL)
+ fatalx("%s: calloc", __func__);
- if ((package = calloc(1, sizeof(*package))) == NULL)
- fatalx("%s: calloc", __func__);
+ if (len > sizeof(package->pkt))
+ len = sizeof(package->pkt);
+ evbuffer_remove(evb, package->pkt, len);
+ package->len = len;
+ package->thing_id = thing->conf.id;
- thing->evb = EVBUFFER_INPUT(bev);
- package->len = EVBUFFER_LENGTH(thing->evb);
+ TAILQ_INSERT_TAIL(thingsd_env->packages, package, entry);
+ }
- evbuffer_remove(thing->evb, package->pkt, package->len);
- package->thing_id = thing->conf.id;
-
- TAILQ_INSERT_TAIL(thingsd_env->packages, package, entry);
thingsd_write_to_socks(thingsd_env->packages);
}
void
thingsd_thing_write(struct bufferevent *bev, void *arg)
{
+ struct thing *thing = (struct thing *)arg;
+ socklen_t len = sizeof(int);
+ int error = 0;
+
+ if (!thing->connecting)
+ return;
+
+ /* first writable event after a non-blocking connect */
+ thing->connecting = 0;
+ if (getsockopt(thing->fd, SOL_SOCKET, SO_ERROR, &error, &len) == -1 ||
+ error != 0) {
+ errno = error ? error : errno;
+ log_warn("thing %s: connection failed", thing->conf.name);
+ thingsd_thing_disconnect(thing);
+ return;
+ }
+
+ log_info("connected: %s", thing->conf.name);
}
void
{
struct thing *thing = (struct thing *)arg;
- if ((error & EVBUFFER_ERROR) == 0 || error & EVBUFFER_TIMEOUT) {
- if (thing->fd != -1) {
- if (thing->bev != NULL)
- bufferevent_disable(thing->bev,
- EV_READ | EV_WRITE);
- if (thing->bev != NULL)
- bufferevent_free(thing->bev);
+ if (error & EVBUFFER_EOF)
+ log_warnx("thing %s disconnected", thing->conf.name);
+ else if (error & EVBUFFER_TIMEOUT)
+ log_warnx("thing %s timed out", thing->conf.name);
+ else
+ log_warnx("thing %s error, disconnecting", thing->conf.name);
- thing->evb = NULL;
- thing->bev = NULL;
-
- close(thing->fd);
- thing->fd = -1;
-
- thingsd_add_reconn(thing);
-
- log_warnx("thing error: %s disconnected",
- thing->conf.name);
- }
- }
+ thingsd_thing_disconnect(thing);
}
void
{
struct dead_thing *dead_thing;
- dead_thing = thingsd_new_dead_thing(thing);
+ thing->exists = 0;
- thingsd_env->exists = 1;
- thingsd_env->dcount++;
+ /* already waiting for a retry */
+ TAILQ_FOREACH(dead_thing, thingsd_env->dead_things, entry)
+ if (strcmp(dead_thing->name, thing->conf.name) == 0)
+ return;
- TAILQ_INSERT_TAIL(thingsd_env->dead_things, dead_thing, entry);
-
-}
-
-struct dead_thing
-*thingsd_new_dead_thing(struct thing *thing)
-{
- struct dead_thing *dead_thing;
-
- dead_thing = calloc(1, sizeof(*dead_thing));
- if (dead_thing == NULL)
+ if ((dead_thing = calloc(1, sizeof(*dead_thing))) == NULL)
fatal("%s: calloc", __func__);
log_debug("%s: adding detached thing, %s", __func__, thing->conf.name);
dead_thing->type = thing->conf.type;
dead_thing->dtime = time(NULL);
- thing->exists = 0;
-
- return dead_thing;
+ TAILQ_INSERT_TAIL(thingsd_env->dead_things, dead_thing, entry);
}
void
thingsd_do_reconn(struct thingsd *env)
{
- struct dead_thing *dead_thing = NULL;
- struct thing *thing = NULL;
- int found = 0;
+ struct dead_thing *dead_thing, *tdead;
+ struct thing *thing;
+ time_t now = time(NULL);
- TAILQ_FOREACH(thing, env->things, entry) {
- TAILQ_FOREACH(dead_thing, env->dead_things, entry)
- if (strcmp(thing->conf.name, dead_thing->name) == 0) {
- found = 1;
+ TAILQ_FOREACH_SAFE(dead_thing, env->dead_things, entry, tdead) {
+ if ((size_t)(now - dead_thing->dtime) <= env->conn_retry)
+ continue;
+
+ TAILQ_FOREACH(thing, env->things, entry)
+ if (strcmp(thing->conf.name, dead_thing->name) == 0)
break;
- }
- if (found)
- break;
- }
- if (thing == NULL || dead_thing == NULL)
- return;
+ if (thing == NULL || thing->exists) {
+ TAILQ_REMOVE(env->dead_things, dead_thing, entry);
+ free(dead_thing);
+ continue;
+ }
- if ((size_t)(time(NULL) - dead_thing->dtime) > env->conn_retry) {
- dead_thing->dtime = time(NULL);
-
log_debug("attempting to reconnect %s", dead_thing->name);
+ dead_thing->dtime = now;
- if (dead_thing->type == S_DEV)
- thingsd_thing_serial_open(thing, 1);
-
- thingsd_thing_setup(env, thing, 1);
+ if (thingsd_thing_connect(env, thing, 1) == 0) {
+ TAILQ_REMOVE(env->dead_things, dead_thing, entry);
+ free(dead_thing);
+ }
}
-
- if (thing->exists) {
- TAILQ_REMOVE(env->dead_things, dead_thing, entry);
- env->dcount--;
- free(dead_thing);
- }
-
- if (env->dcount == 0)
- env->exists = 0;
}
void
-thingsd_echo_pkt(struct privsep *ps, struct imsg *imsg)
+thingsd_echo_pkt(struct imsg *imsg)
{
struct packet_client *packet_client;
thingsd_env->packet_client_count++;
- packet_client->ps = *ps;
- packet_client->imsg = *imsg;
+ packet_client->peerid = imsg->hdr.peerid;
- memcpy(packet_client->name, imsg->data, sizeof(packet_client->name));
+ imsg_get_string(imsg, packet_client->name,
+ sizeof(packet_client->name));
log_debug("control packet echo request for %s", packet_client->name);
}
void
-thingsd_stop_pkt(struct privsep *ps, struct imsg *imsg)
+thingsd_stop_pkt(struct imsg *imsg)
{
struct packet_client *packet_client, *tpacket_client;
uint32_t fd;
TAILQ_FOREACH_SAFE(packet_client, thingsd_env->packet_clients, entry,
tpacket_client) {
- if (fd == packet_client->imsg.hdr.peerid) {
+ if (fd == packet_client->peerid) {
TAILQ_REMOVE(thingsd_env->packet_clients,
packet_client, entry);
log_debug("control packet echo request stopping for %s",
}
void
-thingsd_show_thing_info(struct privsep *ps, struct imsg *imsg)
+thingsd_show_thing_info(struct imsg *imsg)
{
- char filter[THINGSD_MAXNAME];
- struct thing *thing, nti;
+ struct thing *thing, nti;
+ char filter[THINGSD_MAXNAME];
- memcpy(filter, imsg->data, sizeof(filter));
+ memset(&nti, 0, sizeof(nti));
+ imsg_get_string(imsg, filter, sizeof(filter));
TAILQ_FOREACH(thing, thingsd_env->things, entry) {
if (filter[0] == '\0' || strcmp(filter,
thing->conf.name) == 0) {
- nti = thingsd_compose_thing(thing,
- imsg->hdr.type);
+ nti = thingsd_compose_thing(thing, imsg->hdr.type);
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_THINGS_DATA,
- imsg->hdr.peerid, -1, &nti,
- sizeof(nti)) == -1)
+ if (imsg_compose_event(parent_iev_control,
+ IMSG_GET_INFO_THINGS_DATA, imsg->hdr.peerid, 0,
+ -1, &nti, sizeof(nti)) == -1)
return;
}
}
- if (proc_compose_imsg(ps, PROC_CONTROL, -1,
- IMSG_GET_INFO_THINGS_END_DATA, imsg->hdr.peerid,
- -1, &nti, sizeof(nti)) == -1)
- return;
+ imsg_compose_event(parent_iev_control, IMSG_GET_INFO_THINGS_END_DATA,
+ imsg->hdr.peerid, 0, -1, &nti, sizeof(nti));
}
struct thing
blob - e4722aa14179afb58334fa47f72516170908b851
blob + 57ccb9e6b192312cb14e5de02adaec541ced1636
--- thingsd/thingsd.conf.5
+++ thingsd/thingsd.conf.5
.\"
-.\" Copyright (c) 2016-2019 Tracey Emery <tracey@traceyemery.net>
+.\" Copyright (c) 2016-2026 Tracey Emery <tracey@openbsd.org>
.\"
.\" Permission to use, copy, modify, and distribute this software for any
.\" purpose with or without fee is hereby granted, provided that the above
.It Ic parity Ar string
Set the parity for a serial thing
.Ar location .
-Parity options are none, odd, even, or space.
+Parity options are none, odd, or even.
.It Ic password Ar string
Set the subscription password for a thing
.Ar location
The
.Xr thingsd 8
program was written by
-.An Tracey Emery Aq Mt tracey@traceyemery.net .
+.An Tracey Emery Aq Mt tracey@openbsd.org .
blob - c63f48d8b2595640c015476949de5126e4a531fe
blob + c23ff1460f49a68f37e772087bca8431ab54536d
--- thingsd/thingsd.h
+++ thingsd/thingsd.h
/*
- * Copyright (c) 2016, 2019-2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2016, 2019-2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2015 Mike Larkin <mlarkin@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
#define CLIENT_SUB_TIME_USEC 100
#define CLIENT_SUB_CHK 1
#define EB_TIMEOUT 1
+#define ONESHOT_TIMEOUT 10
#define TLS_CONFIG_MAX 511
#define TLS_CERT "/etc/ssl/thing.crt"
#define PKT_BUFF 2048
+#define THINGSD_MAX_PREFORK 32
+
#define MAX_IMSG_DATA_SIZE (MAX_IMSGSIZE - IMSG_HEADER_SIZE)
+#define IMSG_DATA_SIZE(imsg) ((imsg)->hdr.len - IMSG_HEADER_SIZE)
+#define IMSG_SIZE_CHECK(imsg, p) do { \
+ if (IMSG_DATA_SIZE(imsg) < sizeof(*p)) \
+ fatalx("bad length imsg received (%s)", #p); \
+} while (0)
enum imsg_type {
- IMSG_GET_INFO_THINGSD_REQUEST = IMSG_PROC_MAX,
+ IMSG_NONE,
+ IMSG_CTL_OK,
+ IMSG_CTL_FAIL,
+ IMSG_CTL_VERBOSE,
+ IMSG_CTL_NOTIFY,
+
+ IMSG_GET_INFO_THINGSD_REQUEST,
IMSG_GET_INFO_THINGSD_DATA,
IMSG_GET_INFO_THINGSD_END_DATA,
IMSG_DIST_CLIENT_PACKAGE,
};
+struct imsgev {
+ struct imsgbuf ibuf;
+ void (*handler)(int, short, void *);
+ struct event ev;
+ short events;
+};
+
/*
* parse.y contains TCP and UDP
* so, these have to be different
};
TAILQ_HEAD(packages, package);
+struct socket;
+
struct client {
TAILQ_ENTRY(client) entry;
struct packages *packages;
- int id;
int thing_id;
int sock_id;
- void *sock;
- void *sock_conf;
+ struct socket *sock;
- struct clt_time *clt;
- struct evbuffer *evb;
struct bufferevent *bev;
- struct event ev;
struct event timeout;
int subscribed;
TAILQ_HEAD(clientlist, client);
struct socket_config {
- struct addresslist *al;
char iface[THINGSD_MAXTEXT];
char name[THINGSD_MAXTEXT];
char thing_name[THINGSD_MAXTEXT];
struct thing_config conf;
int exists;
- /* either DEV, TCP conn, or UDP rcv fd */
+ /* DEV or persistent TCP fd, -1 when not connected */
int fd;
-
- /* event for TCP thing fd */
+ int connecting;
struct bufferevent *bev;
- struct evbuffer *evb;
- /* event for UDP thing fd */
- struct event udp_ev;
+ /* one receiving socket per bound UDP address */
+ int udp_fd[THINGSD_MAXIFACE];
+ struct event udp_ev[THINGSD_MAXIFACE];
+ int udp_nfd;
};
TAILQ_HEAD(thinglist, thing);
struct packet_client {
TAILQ_ENTRY(packet_client) entry;
- struct privsep ps;
- struct imsg imsg;
- int fd;
+ uint32_t peerid;
char name[THINGSD_MAXNAME];
};
TAILQ_HEAD(packetclientlist, packet_client);
struct socketlist *sockets;
struct packages *packages;
- struct privsep *thingsd_ps;
const char *thingsd_conffile;
int thingsd_debug;
char udp_iface[THINGSD_MAXTEXT];
size_t max_clients;
- size_t client_cnt;
size_t conn_retry;
uint16_t prefork_socks;
int run;
- /* disconnected things parts */
struct deadthinglist *dead_things;
- int exists;
- int dcount;
/* things */
struct event_base *thingsd_eb;
extern struct thingsd *thingsd_env;
extern int thing_id;
+/* parent process pipes, indexed by prefork instance for sockets */
+extern struct imsgev *parent_iev_control;
+extern struct imsgev *parent_iev_socks;
+
+/* sockets process pipe to the parent */
+extern struct imsgev *socks_iev_parent;
+
/* client.c */
void client_del(struct client *);
void client_rd(struct bufferevent *, void *);
/* sockets.c */
struct socket
- *sockets_new_socket(char *);
-struct socket
- *sockets_get_socket(struct thingsd *, int);
-struct socket
*sockets_get_socket_byid(struct thingsd *, int);
-int sockets_create_socket(struct addresslist *, in_port_t, int);
-int sockets_open_client(char *, in_port_t);
+int sockets_create_socket(struct sockaddr_storage *, in_port_t, int);
+int sockets_open_client(const char *, in_port_t);
int sockets_privinit(struct socket *);
-int sockets_client_cmp(struct client *, struct client *);
+size_t sockets_thing_client_cnt(int);
void sockets_parse_sockets(struct thingsd *);
-void sockets_socket_rlimit(int);
-void sockets_sighdlr(int, short, void *);
-void sockets_shutdown(void);
-void sockets(struct privsep *, struct privsep_proc *);
+void sockets_socket_rlimit(void);
+__dead void
+ sockets(int, int);
/* thingsd.c */
struct thing *thingsd_conf_new_thing(struct thingsd *, struct thing *,
char *, int);
+void imsg_event_init(struct imsgev *, int, void (*)(int, short, void *));
+void imsg_event_add(struct imsgev *);
+int imsg_compose_event(struct imsgev *, uint32_t, uint32_t, pid_t, int,
+ void *, size_t);
+int imsg_composev_event(struct imsgev *, uint32_t, uint32_t, pid_t, int,
+ const struct iovec *, int);
+int imsg_forward_event(struct imsgev *, struct imsg *);
+void imsg_get_string(struct imsg *, char *, size_t);
+/* control.c */
+__dead void
+ control(int, int *);
+
/* config.c */
int config_init(struct thingsd *);
-void config_purge(struct thingsd *, unsigned int);
-int config_setreset(struct thingsd *, unsigned int);
-int config_getreset(struct thingsd *, struct imsg *);
int config_setsocks(struct thingsd *, struct socket *);
int config_getsocks(struct thingsd *, struct imsg *);
int config_getcfg(struct thingsd *, struct imsg *);
/* parse.y */
int parse_config(const char *, struct thingsd *);
-int parse_buf(struct client *, u_char *, int);
+int parse_buf(struct client *, u_char *);
int cmdline_symset(char *);
struct address *host_v4(const char *);
struct address *host_v6(const char *);
int tls_load_ocsp(struct socket *);
void socket_tls_load(struct socket *);
int socket_tls_init(struct socket *);
-void socket_tls_handshake(int, short, void *);
+
+/* log.c */
+void log_init(int, int);
+void log_procinit(const char *);
+void log_setverbose(int);
+int log_getverbose(void);
+void log_warn(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
+void log_warnx(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
+void log_info(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
+void log_debug(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
+void logit(int, const char *, ...)
+ __attribute__((__format__ (printf, 2, 3)));
+void vlog(int, const char *, va_list)
+ __attribute__((__format__ (printf, 2, 0)));
+__dead void fatal(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
+__dead void fatalx(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)));
blob - 775cb1b60baf43498aceabb1e4fad58b706947ab
blob + 40a9aa938fcb2162e992ea0698180e76667c7b61
--- thingsd/tls.c
+++ thingsd/tls.c
/*
- * Copyright (c) 2019 - 2021 Tracey Emery <tracey@traceyemery.net>
+ * Copyright (c) 2019 - 2026 Tracey Emery <tracey@openbsd.org>
* Copyright (c) 2006 - 2015 Reyk Floeter <reyk@openbsd.org>
* (snippets from httpd functions)
*
#include <event.h>
#include <tls.h>
-#include "proc.h"
#include "thingsd.h"
int
log_warnx("%s: failed to add ca cert(s)", __func__);
return (-1);
}
- if (tls_config_set_crl_mem(sock->tls_config,
+ if (sock->conf.tls_crl != NULL &&
+ tls_config_set_crl_mem(sock->tls_config,
sock->conf.tls_crl, sock->conf.tls_crl_len) != 0) {
log_warnx("%s: failed to add crl(s)", __func__);
return (-1);
tls_config_verify_client(sock->tls_config);
}
- log_debug("%s: adding keypair for listener %s", __func__,
- sock->conf.name);
-
- if (tls_config_add_keypair_ocsp_mem(sock->tls_config,
- sock->conf.tls_cert, sock->conf.tls_cert_len,
- sock->conf.tls_key, sock->conf.tls_key_len,
- sock->conf.tls_ocsp_staple,
- sock->conf.tls_ocsp_staple_len) != 0) {
- log_warnx("%s: failed to add tls keypair", __func__);
- return (-1);
- }
-
if (tls_configure(sock->tls_ctx, sock->tls_config) != 0) {
log_warnx("%s: failed to configure tls - %s", __func__,
tls_error(sock->tls_ctx));
}
void
-socket_tls_handshake(int fd, short event, void *arg)
-{
- struct client *client = (struct client *)arg;
- struct socket *sock = client->sock;
- ssize_t ret = 0;
-
- if (client == NULL)
- return;
-
- if (sock->tls_ctx == NULL || client->tls_ctx == NULL)
- fatalx("NULL tls context");
-
- ret = tls_handshake(client->tls_ctx);
-
- if (ret == 0) {
- event_del(&client->ev);
- log_debug("%s: tls handshake success", __func__);
- } else if (ret == TLS_WANT_POLLIN) {
- event_del(&client->ev);
- event_set(&client->ev, client->fd, EV_READ|EV_PERSIST,
- socket_tls_handshake, client);
- if (event_add(&client->ev, NULL))
- log_debug("%s: event add client", __func__);
- } else if (ret == TLS_WANT_POLLOUT) {
- event_del(&client->ev);
- event_set(&client->ev, client->fd, EV_WRITE|EV_PERSIST,
- socket_tls_handshake, client);
- if (event_add(&client->ev, NULL))
- log_debug("%s: event add client", __func__);
- } else {
- event_del(&client->ev);
- log_debug("%s: tls handshake failed - %s", __func__,
- tls_error(client->tls_ctx));
- }
-}
-
-void
socket_tls_load(struct socket *sock)
{
log_debug("%s: setup TLS for listener %d", __func__, sock->conf.id);