gotwebd/config.c

   1 /*
   2  * Copyright (c) 2020-2021 Tracey Emery <tracey@traceyemery.net>
   3  * Copyright (c) 2015 Reyk Floeter <reyk@openbsd.org>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include <sys/types.h>
  19 #include <sys/queue.h>
  20 #include <sys/time.h>
  21 #include <sys/uio.h>
  22 #include <sys/socket.h>
  23
  24 #include <net/if.h>
  25 #include <netinet/in.h>
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <termios.h>
  30 #include <unistd.h>
  31 #include <limits.h>
  32 #include <string.h>
  33 #include <event.h>
  34 #include <fcntl.h>
  35 #include <errno.h>
  36
  37 #include "got_opentemp.h"
  38 #include "got_reference.h"
  39
  40 #include "got_compat.h"
  41
  42 #include "proc.h"
  43 #include "gotwebd.h"
  44
  45 int
  46 config_init(struct gotwebd *env)
  47 {
  48         struct privsep *ps = env->gotwebd_ps;
  49         unsigned int what;
  50
  51         strlcpy(env->httpd_chroot, D_HTTPD_CHROOT, sizeof(env->httpd_chroot));
  52
  53         /* Global configuration. */
  54         if (privsep_process == PROC_GOTWEBD)
  55                 env->prefork_gotwebd = GOTWEBD_NUMPROC;
  56
  57         ps->ps_what[PROC_GOTWEBD] = CONFIG_ALL;
  58         ps->ps_what[PROC_SOCKS] = CONFIG_SOCKS;
  59
  60         /* Other configuration. */
  61         what = ps->ps_what[privsep_process];
  62         if (what & CONFIG_SOCKS) {
  63                 env->server_cnt = 0;
  64                 TAILQ_INIT(&env->servers);
  65                 TAILQ_INIT(&env->sockets);
  66         }
  67         return 0;
  68 }
  69
  70 int
  71 config_getcfg(struct gotwebd *env, struct imsg *imsg)
  72 {
  73         /* nothing to do but tell gotwebd configuration is done */
  74         if (privsep_process != PROC_GOTWEBD)
  75                 proc_compose(env->gotwebd_ps, PROC_GOTWEBD,
  76                     IMSG_CFG_DONE, NULL, 0);
  77
  78         return 0;
  79 }
  80
  81 int
  82 config_setserver(struct gotwebd *env, struct server *srv)
  83 {
  84         struct server ssrv;
  85         struct privsep *ps = env->gotwebd_ps;
  86
  87         memcpy(&ssrv, srv, sizeof(ssrv));
  88         if (proc_compose(ps, PROC_SOCKS, IMSG_CFG_SRV, &ssrv, sizeof(ssrv))
  89             == -1)
  90                 fatal("proc_compose");
  91         return 0;
  92 }
  93
  94 int
  95 config_getserver(struct gotwebd *env, struct imsg *imsg)
  96 {
  97         struct server *srv;
  98         uint8_t *p = imsg->data;
  99
 100         IMSG_SIZE_CHECK(imsg, &srv);
 101
 102         srv = calloc(1, sizeof(*srv));
 103         if (srv == NULL)
 104                 fatalx("%s: calloc", __func__);
 105
 106         if (IMSG_DATA_SIZE(imsg) != sizeof(*srv)) {
 107                 log_debug("%s: imsg size error", __func__);
 108                 free(srv);
 109                 return 1;
 110         }
 111
 112         memcpy(srv, p, sizeof(*srv));
 113         srv->cached_repos = calloc(GOTWEBD_REPO_CACHESIZE,
 114             sizeof(*srv->cached_repos));
 115         if (srv->cached_repos == NULL)
 116                 fatal("%s: calloc", __func__);
 117         srv->ncached_repos = 0;
 118
 119         /* log server info */
 120         log_debug("%s: server=%s fcgi_socket=%s unix_socket=%s", __func__,
 121             srv->name, srv->fcgi_socket ? "yes" : "no", srv->unix_socket ?
 122             "yes" : "no");
 123
 124         TAILQ_INSERT_TAIL(&env->servers, srv, entry);
 125
 126         return 0;
 127 }
 128
 129 int
 130 config_setsock(struct gotwebd *env, struct socket *sock)
 131 {
 132         struct privsep *ps = env->gotwebd_ps;
 133         struct socket_conf s;
 134         int id;
 135         int fd = -1, n, m;
 136         struct iovec iov[6];
 137         size_t c;
 138         unsigned int what;
 139
 140         /* open listening sockets */
 141         if (sockets_privinit(env, sock) == -1)
 142                 return -1;
 143
 144         for (id = 0; id < PROC_MAX; id++) {
 145                 what = ps->ps_what[id];
 146
 147                 if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
 148                         continue;
 149
 150                 memcpy(&s, &sock->conf, sizeof(s));
 151
 152                 c = 0;
 153                 iov[c].iov_base = &s;
 154                 iov[c++].iov_len = sizeof(s);
 155
 156                 if (id == PROC_SOCKS) {
 157                         /* XXX imsg code will close the fd after 1st call */
 158                         n = -1;
 159                         proc_range(ps, id, &n, &m);
 160                         for (n = 0; n < m; n++) {
 161                                 if (sock->fd == -1)
 162                                         fd = -1;
 163                                 else if ((fd = dup(sock->fd)) == -1)
 164                                         return 1;
 165                                 if (proc_composev_imsg(ps, id, n, IMSG_CFG_SOCK,
 166                                     -1, fd, iov, c) != 0) {
 167                                         log_warn("%s: failed to compose "
 168                                             "IMSG_CFG_SOCK imsg",
 169                                             __func__);
 170                                         return 1;
 171                                 }
 172                                 if (proc_flush_imsg(ps, id, n) == -1) {
 173                                         log_warn("%s: failed to flush "
 174                                             "IMSG_CFG_SOCK imsg",
 175                                             __func__);
 176                                         return 1;
 177                                 }
 178                         }
 179                 }
 180         }
 181
 182         /* Close socket early to prevent fd exhaustion in gotwebd. */
 183         if (sock->fd != -1) {
 184                 close(sock->fd);
 185                 sock->fd = -1;
 186         }
 187
 188         return 0;
 189 }
 190
 191 int
 192 config_getsock(struct gotwebd *env, struct imsg *imsg)
 193 {
 194         struct socket *sock = NULL;
 195         struct socket_conf sock_conf;
 196         uint8_t *p = imsg->data;
 197         int i;
 198
 199         IMSG_SIZE_CHECK(imsg, &sock_conf);
 200         memcpy(&sock_conf, p, sizeof(sock_conf));
 201
 202         if (IMSG_DATA_SIZE(imsg) != sizeof(sock_conf)) {
 203                 log_debug("%s: imsg size error", __func__);
 204                 return 1;
 205         }
 206
 207         /* create a new socket */
 208         if ((sock = calloc(1, sizeof(*sock))) == NULL) {
 209                 if (imsg->fd != -1)
 210                         close(imsg->fd);
 211                 return 1;
 212         }
 213
 214         memcpy(&sock->conf, &sock_conf, sizeof(sock->conf));
 215         sock->fd = imsg->fd;
 216
 217         TAILQ_INSERT_TAIL(&env->sockets, sock, entry);
 218
 219         for (i = 0; i < PRIV_FDS__MAX; i++)
 220                 sock->priv_fd[i] = -1;
 221
 222         for (i = 0; i < GOTWEB_PACK_NUM_TEMPFILES; i++)
 223                 sock->pack_fds[i] = -1;
 224
 225         /* log new socket info */
 226         log_debug("%s: name=%s id=%d server=%s af_type=%s socket_path=%s",
 227             __func__, sock->conf.name, sock->conf.id, sock->conf.srv_name,
 228             sock->conf.af_type == AF_UNIX ? "unix" :
 229             (sock->conf.af_type == AF_INET ? "inet" :
 230             (sock->conf.af_type == AF_INET6 ? "inet6" : "unknown")),
 231             *sock->conf.unix_socket_name != '\0' ?
 232             sock->conf.unix_socket_name : "none");
 233
 234         return 0;
 235 }
 236
 237 int
 238 config_setfd(struct gotwebd *env, struct socket *sock)
 239 {
 240         struct privsep *ps = env->gotwebd_ps;
 241         int id, s;
 242         int fd = -1, n, m, j;
 243         struct iovec iov[6];
 244         size_t c;
 245         unsigned int what;
 246
 247         log_debug("%s: Allocating %d file descriptors",
 248             __func__, PRIV_FDS__MAX + GOTWEB_PACK_NUM_TEMPFILES);
 249
 250         for (j = 0; j < PRIV_FDS__MAX + GOTWEB_PACK_NUM_TEMPFILES; j++) {
 251                 for (id = 0; id < PROC_MAX; id++) {
 252                         what = ps->ps_what[id];
 253
 254                         if ((what & CONFIG_SOCKS) == 0 || id == privsep_process)
 255                                 continue;
 256
 257                         s = sock->conf.id;
 258                         c = 0;
 259                         iov[c].iov_base = &s;
 260                         iov[c++].iov_len = sizeof(s);
 261
 262                         if (id == PROC_SOCKS) {
 263                                 /*
 264                                  * XXX imsg code will close the fd
 265                                  * after 1st call
 266                                  */
 267                                 n = -1;
 268                                 proc_range(ps, id, &n, &m);
 269                                 for (n = 0; n < m; n++) {
 270                                         fd = got_opentempfd();
 271                                         if (fd == -1)
 272                                                 return 1;
 273                                         if (proc_composev_imsg(ps, id, n,
 274                                             IMSG_CFG_FD, -1, fd, iov, c) != 0) {
 275                                                 log_warn("%s: failed to compose "
 276                                                     "IMSG_CFG_FD imsg",
 277                                                     __func__);
 278                                                 return 1;
 279                                         }
 280                                         if (proc_flush_imsg(ps, id, n) == -1) {
 281                                                 log_warn("%s: failed to flush "
 282                                                     "IMSG_CFG_FD imsg",
 283                                                     __func__);
 284                                                 return 1;
 285                                         }
 286                                 }
 287                         }
 288                 }
 289
 290                 /* Close fd early to prevent fd exhaustion in gotwebd. */
 291                 if (fd != -1)
 292                         close(fd);
 293         }
 294         return 0;
 295 }
 296
 297 int
 298 config_getfd(struct gotwebd *env, struct imsg *imsg)
 299 {
 300         struct socket *sock;
 301         uint8_t *p = imsg->data;
 302         int sock_id, match = 0, i;
 303
 304         IMSG_SIZE_CHECK(imsg, &sock_id);
 305         memcpy(&sock_id, p, sizeof(sock_id));
 306
 307         TAILQ_FOREACH(sock, &env->sockets, entry) {
 308                 const int nfds = (GOTWEB_PACK_NUM_TEMPFILES + PRIV_FDS__MAX);
 309                 for (i = 0; i < nfds; i++) {
 310                         if (i < PRIV_FDS__MAX && sock->priv_fd[i] == -1) {
 311                                 log_debug("%s: assigning socket %d priv_fd %d",
 312                                     __func__, sock_id, imsg->fd);
 313                                 sock->priv_fd[i] = imsg->fd;
 314                                 match = 1;
 315                                 break;
 316                         }
 317                         if (sock->pack_fds[i - PRIV_FDS__MAX] == -1) {
 318                                 log_debug("%s: assigning socket %d pack_fd %d",
 319                                     __func__, sock_id, imsg->fd);
 320                                 sock->pack_fds[i - PRIV_FDS__MAX] = imsg->fd;
 321                                 match = 1;
 322                                 break;
 323                         }
 324                 }
 325         }
 326
 327         if (match)
 328                 return 0;
 329         else
 330                 return 1;
 331 }