gotwebd/gotwebd.c

   1 /*
   2  * Copyright (c) 2016, 2019, 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/param.h>
  19 #include <sys/queue.h>
  20 #include <sys/socket.h>
  21 #include <sys/wait.h>
  22 #include <sys/cdefs.h>
  23
  24 #include <net/if.h>
  25 #include <netinet/in.h>
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <termios.h>
  31 #include <err.h>
  32 #include <errno.h>
  33 #include <event.h>
  34 #include <fcntl.h>
  35 #include <pwd.h>
  36 #include <signal.h>
  37 #include <syslog.h>
  38 #include <unistd.h>
  39 #include <ctype.h>
  40
  41 #include "got_compat.h"
  42 #include "got_opentemp.h"
  43 #include "got_reference.h"
  44
  45 #include "proc.h"
  46 #include "gotwebd.h"
  47
  48 __dead void usage(void);
  49
  50 int      main(int, char **);
  51 int      gotwebd_configure(struct gotwebd *);
  52 void     gotwebd_configure_done(struct gotwebd *);
  53 void     gotwebd_sighdlr(int sig, short event, void *arg);
  54 void     gotwebd_shutdown(void);
  55 int      gotwebd_dispatch_sockets(int, struct privsep_proc *, struct imsg *);
  56
  57 struct gotwebd  *gotwebd_env;
  58
  59 static struct privsep_proc procs[] = {
  60         { "sockets",    PROC_SOCKS,     gotwebd_dispatch_sockets, sockets,
  61             sockets_shutdown },
  62 };
  63
  64 int
  65 gotwebd_dispatch_sockets(int fd, struct privsep_proc *p, struct imsg *imsg)
  66 {
  67         struct privsep          *ps = p->p_ps;
  68         struct gotwebd          *env = ps->ps_env;
  69
  70         switch (imsg->hdr.type) {
  71         case IMSG_CFG_DONE:
  72                 gotwebd_configure_done(env);
  73                 break;
  74         default:
  75                 return (-1);
  76         }
  77
  78         return (0);
  79 }
  80
  81 void
  82 gotwebd_sighdlr(int sig, short event, void *arg)
  83 {
  84         /* struct privsep       *ps = arg; */
  85
  86         if (privsep_process != PROC_GOTWEBD)
  87                 return;
  88
  89         switch (sig) {
  90         case SIGHUP:
  91                 log_info("%s: ignoring SIGHUP", __func__);
  92                 break;
  93         case SIGPIPE:
  94                 log_info("%s: ignoring SIGPIPE", __func__);
  95                 break;
  96         case SIGUSR1:
  97                 log_info("%s: ignoring SIGUSR1", __func__);
  98                 break;
  99         case SIGTERM:
 100         case SIGINT:
 101                 gotwebd_shutdown();
 102                 break;
 103         default:
 104                 fatalx("unexpected signal");
 105         }
 106 }
 107
 108 __dead void
 109 usage(void)
 110 {
 111         fprintf(stderr, "usage: %s [-dnv] [-D macro=value] [-f file]\n",
 112             getprogname());
 113         exit(1);
 114 }
 115
 116 int
 117 main(int argc, char **argv)
 118 {
 119         struct gotwebd *env;
 120         struct privsep *ps;
 121         unsigned int proc;
 122         int ch;
 123         const char *conffile = GOTWEBD_CONF;
 124         enum privsep_procid proc_id = PROC_GOTWEBD;
 125         int proc_instance = 0;
 126         const char *errp, *title = NULL;
 127         int argc0 = argc;
 128
 129         env = calloc(1, sizeof(*env));
 130         if (env == NULL)
 131                 fatal("%s: calloc", __func__);
 132
 133         /* XXX: add s and S for both sockets */
 134         while ((ch = getopt(argc, argv, "D:df:I:nP:v")) != -1) {
 135                 switch (ch) {
 136                 case 'D':
 137                         if (cmdline_symset(optarg) < 0)
 138                                 log_warnx("could not parse macro definition %s",
 139                                     optarg);
 140                         break;
 141                 case 'd':
 142                         env->gotwebd_debug = 2;
 143                         break;
 144                 case 'f':
 145                         conffile = optarg;
 146                         break;
 147                 case 'I':
 148                         proc_instance = strtonum(optarg, 0,
 149                             PROC_MAX_INSTANCES, &errp);
 150                         if (errp)
 151                                 fatalx("invalid process instance");
 152                         break;
 153                 case 'n':
 154                         env->gotwebd_debug = 2;
 155                         env->gotwebd_noaction = 1;
 156                         break;
 157                 case 'P':
 158                         title = optarg;
 159                         proc_id = proc_getid(procs, nitems(procs), title);
 160                         if (proc_id == PROC_MAX)
 161                                 fatalx("invalid process name");
 162                         break;
 163                 case 'v':
 164                         env->gotwebd_verbose++;
 165                         break;
 166                 default:
 167                         usage();
 168                 }
 169         }
 170
 171         /* log to stderr until daemonized */
 172         log_init(env->gotwebd_debug ? env->gotwebd_debug : 1, LOG_DAEMON);
 173
 174         argc -= optind;
 175         if (argc > 0)
 176                 usage();
 177
 178         ps = calloc(1, sizeof(*ps));
 179         if (ps == NULL)
 180                 fatal("%s: calloc:", __func__);
 181
 182         gotwebd_env = env;
 183         env->gotwebd_ps = ps;
 184         ps->ps_env = env;
 185         env->gotwebd_conffile = conffile;
 186
 187         if (parse_config(env->gotwebd_conffile, env) == -1)
 188                 exit(1);
 189
 190         if (env->gotwebd_noaction && !env->gotwebd_debug)
 191                 env->gotwebd_debug = 1;
 192
 193         /* check for root privileges */
 194         if (env->gotwebd_noaction == 0) {
 195                 if (geteuid())
 196                         fatalx("need root privileges");
 197         }
 198
 199         ps->ps_pw = getpwnam(GOTWEBD_USER);
 200         if (ps->ps_pw == NULL)
 201                 fatalx("unknown user %s", GOTWEBD_USER);
 202
 203         log_init(env->gotwebd_debug, LOG_DAEMON);
 204         log_setverbose(env->gotwebd_verbose);
 205
 206         if (env->gotwebd_noaction)
 207                 ps->ps_noaction = 1;
 208
 209         ps->ps_instances[PROC_SOCKS] = env->prefork_gotwebd;
 210         ps->ps_instance = proc_instance;
 211         if (title != NULL)
 212                 ps->ps_title[proc_id] = title;
 213
 214         for (proc = 0; proc < nitems(procs); proc++)
 215                 procs[proc].p_chroot = strlen(env->httpd_chroot) ?
 216                     env->httpd_chroot : D_HTTPD_CHROOT;
 217
 218         /* only the gotwebd returns */
 219         proc_init(ps, procs, nitems(procs), argc0, argv, proc_id);
 220
 221         log_procinit("gotwebd");
 222         if (!env->gotwebd_debug && daemon(0, 0) == -1)
 223                 fatal("can't daemonize");
 224
 225         if (ps->ps_noaction == 0)
 226                 log_info("%s startup", getprogname());
 227
 228         event_init();
 229
 230         signal_set(&ps->ps_evsigint, SIGINT, gotwebd_sighdlr, ps);
 231         signal_set(&ps->ps_evsigterm, SIGTERM, gotwebd_sighdlr, ps);
 232         signal_set(&ps->ps_evsighup, SIGHUP, gotwebd_sighdlr, ps);
 233         signal_set(&ps->ps_evsigpipe, SIGPIPE, gotwebd_sighdlr, ps);
 234         signal_set(&ps->ps_evsigusr1, SIGUSR1, gotwebd_sighdlr, ps);
 235
 236         signal_add(&ps->ps_evsigint, NULL);
 237         signal_add(&ps->ps_evsigterm, NULL);
 238         signal_add(&ps->ps_evsighup, NULL);
 239         signal_add(&ps->ps_evsigpipe, NULL);
 240         signal_add(&ps->ps_evsigusr1, NULL);
 241
 242         if (!env->gotwebd_noaction)
 243                 proc_connect(ps);
 244
 245         if (gotwebd_configure(env) == -1)
 246                 fatalx("configuration failed");
 247
 248 #ifdef PROFILE
 249         if (unveil("gmon.out", "rwc") != 0)
 250                 err(1, "gmon.out");
 251 #endif
 252
 253         if (unveil(strlen(env->httpd_chroot) > 0 ? env->httpd_chroot :
 254             D_HTTPD_CHROOT, "rwc") == -1)
 255                 err(1, "unveil");
 256
 257         if (unveil(GOT_TMPDIR_STR, "rw") == -1)
 258                 err(1, "unveil");
 259
 260         if (unveil(GOTWEBD_CONF, "r") == -1)
 261                 err(1, "unveil");
 262
 263         if (unveil(NULL, NULL) != 0)
 264                 err(1, "unveil");
 265
 266 #ifndef PROFILE
 267         if (pledge("stdio rpath wpath cpath inet unix", NULL) == -1)
 268                 err(1, "pledge");
 269 #endif
 270
 271         event_dispatch();
 272
 273         log_debug("%s gotwebd exiting", getprogname());
 274
 275         return (0);
 276 }
 277
 278 int
 279 gotwebd_configure(struct gotwebd *env)
 280 {
 281         struct server *srv;
 282         struct socket *sock;
 283         int id;
 284
 285         if (env->gotwebd_noaction) {
 286                 fprintf(stderr, "configuration OK\n");
 287                 proc_kill(env->gotwebd_ps);
 288                 exit(0);
 289         }
 290
 291         /* gotweb need to reload its config. */
 292         env->gotwebd_reload = env->prefork_gotwebd;
 293
 294         /* send our gotweb servers */
 295         TAILQ_FOREACH(srv, &env->servers, entry) {
 296                 if (config_setserver(env, srv) == -1)
 297                         fatalx("%s: send server error", __func__);
 298         }
 299
 300         /* send our sockets */
 301         TAILQ_FOREACH(sock, &env->sockets, entry) {
 302                 if (config_setsock(env, sock) == -1)
 303                         fatalx("%s: send socket error", __func__);
 304                 if (config_setfd(env, sock) == -1)
 305                         fatalx("%s: send priv_fd error", __func__);
 306         }
 307
 308         for (id = 0; id < PROC_MAX; id++) {
 309                 if (id == privsep_process)
 310                         continue;
 311                 proc_compose(env->gotwebd_ps, id, IMSG_CFG_DONE, NULL, 0);
 312         }
 313
 314         return (0);
 315 }
 316
 317 void
 318 gotwebd_configure_done(struct gotwebd *env)
 319 {
 320         int id;
 321
 322         if (env->gotwebd_reload == 0) {
 323                 log_warnx("%s: configuration already finished", __func__);
 324                 return;
 325         }
 326
 327         env->gotwebd_reload--;
 328         if (env->gotwebd_reload == 0) {
 329                 for (id = 0; id < PROC_MAX; id++) {
 330                         if (id == privsep_process)
 331                                 continue;
 332                         proc_compose(env->gotwebd_ps, id, IMSG_CTL_START,
 333                             NULL, 0);
 334                 }
 335         }
 336 }
 337
 338 void
 339 gotwebd_shutdown(void)
 340 {
 341         proc_kill(gotwebd_env->gotwebd_ps);
 342
 343         /* unlink(gotwebd_env->gotweb->gotweb_conf.gotweb_unix_socket_name); */
 344         /* free(gotwebd_env->gotweb); */
 345         free(gotwebd_env);
 346
 347         log_warnx("gotwebd terminating");
 348         exit(0);
 349 }