/*	$OpenBSD: lpd.c,v 1.3 2022/12/28 21:30:17 jmc Exp $	*/

/*
 * Copyright (c) 2017 Eric Faurot <eric@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/stat.h>
#include <sys/un.h>
#include <sys/wait.h>

#include <errno.h>
#include <getopt.h>
#include <pwd.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

#include "lpd.h"

#include "log.h"
#include "proc.h"

struct lpd_conf *env;
struct imsgproc *p_control;
struct imsgproc *p_engine;
struct imsgproc *p_frontend;
struct imsgproc *p_priv;

static void priv_dispatch_control(struct imsgproc *, struct imsg *, void *);
static void priv_dispatch_engine(struct imsgproc *, struct imsg *, void *);
static void priv_dispatch_frontend(struct imsgproc *, struct imsg *, void *);
static void priv_dispatch_printer(struct imsgproc *, struct imsg *, void *);
static void priv_open_listener(struct listener *);
static void priv_send_config(void);
static void priv_sighandler(int, short, void *);
static void priv_shutdown(void);
static void priv_run_printer(const char *);

static char **saved_argv;
static int saved_argc;

static void
usage(void)
{
	extern char *__progname;

	fprintf(stderr, "usage: %s [-dnv] [-D macro=value]  [-f file]\n",
	    __progname);
	exit(1);
}

int
main(int argc, char **argv)
{
	struct listener *l;
	struct event evt_sigchld, evt_sigint, evt_sigterm, evt_sighup;
	const char *conffile = LPD_CONFIG, *reexec = NULL;
	int sp[2], ch, debug = 0, nflag = 0, verbose = 1;

	saved_argv = argv;
	saved_argc = argc;

	log_init(1, LOG_LPR);
	log_setverbose(0);

	while ((ch = getopt(argc, argv, "D:df:nvX:")) != -1) {
		switch (ch) {
		case 'D':
			if (cmdline_symset(optarg) < 0)
				log_warnx("could not parse macro definition %s",
				    optarg);
			break;
		case 'd':
			debug = 1;
			break;
		case 'f':
			conffile = optarg;
			break;
		case 'n':
			nflag = 1;
			break;
		case 'v':
			verbose++;
			break;
		case 'X':
			reexec = optarg;
			break;
		default:
			usage();
		}
	}

	argv += optind;
	argc -= optind;

	if (argc || *argv)
		usage();

	if (reexec) {
		if (!strcmp(reexec, "control"))
			control(debug, verbose);
		if (!strcmp(reexec, "engine"))
			engine(debug, verbose);
		if (!strcmp(reexec, "frontend"))
			frontend(debug, verbose);
		if (!strncmp(reexec, "printer:", 8))
			printer(debug, verbose, strchr(reexec, ':') + 1);
		fatalx("unknown process %s", reexec);
	}

	/* Parse config file. */
	env = parse_config(conffile, verbose);
	if (env == NULL)
		exit(1);

	if (nflag) {
		fprintf(stderr, "configuration OK\n");
		exit(0);
	}

	/* Check for root privileges. */
	if (geteuid())
		fatalx("need root privileges");

	/* Check for assigned daemon user. */
	if (getpwnam(LPD_USER) == NULL)
		fatalx("unknown user %s", LPD_USER);

	log_init(debug, LOG_LPR);
	log_setverbose(verbose);
	log_procinit("priv");
	setproctitle("priv");

	if (!debug)
		if (daemon(1, 0) == -1)
			fatal("daemon");

        log_info("startup");

	TAILQ_FOREACH(l, &env->listeners, entry)
		priv_open_listener(l);

	event_init();

	signal_set(&evt_sigint, SIGINT, priv_sighandler, NULL);
	signal_add(&evt_sigint, NULL);
	signal_set(&evt_sigterm, SIGTERM, priv_sighandler, NULL);
	signal_add(&evt_sigterm, NULL);
	signal_set(&evt_sigchld, SIGCHLD, priv_sighandler, NULL);
	signal_add(&evt_sigchld, NULL);
	signal_set(&evt_sighup, SIGHUP, priv_sighandler, NULL);
	signal_add(&evt_sighup, NULL);
	signal(SIGPIPE, SIG_IGN);

	/* Fork and exec unprivileged processes. */
	argv = calloc(saved_argc + 3, sizeof(*argv));
	if (argv == NULL)
		fatal("calloc");
	for (argc = 0; argc < saved_argc; argc++)
		argv[argc] = saved_argv[argc];
	argv[argc++] = "-X";
	argv[argc++] = "";
	argv[argc++] = NULL;

	argv[argc - 2] = "control";
	p_control = proc_exec(PROC_CONTROL, argv);
	if (p_control == NULL)
		fatalx("cannot exec control process");
	proc_setcallback(p_control, priv_dispatch_control, NULL);
	proc_enable(p_control);

	argv[argc - 2] = "engine";
	p_engine = proc_exec(PROC_ENGINE, argv);
	if (p_engine == NULL)
		fatalx("cannot exec engine process");
	proc_setcallback(p_engine, priv_dispatch_engine, NULL);
	proc_enable(p_engine);

	argv[argc - 2] = "frontend";
	p_frontend = proc_exec(PROC_FRONTEND, argv);
	if (p_frontend == NULL)
		fatalx("cannot exec frontend process");
	proc_setcallback(p_frontend, priv_dispatch_frontend, NULL);
	proc_enable(p_frontend);

	/* Connect processes. */
	if (socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK, PF_UNSPEC, sp) == -1)
		fatal("socketpair");
	m_compose(p_engine, IMSG_SOCK_FRONTEND, 0, 0, sp[1], NULL, 0);
	m_compose(p_frontend, IMSG_SOCK_ENGINE, 0, 0, sp[0], NULL, 0);

	priv_send_config();

	if (pledge("stdio sendfd proc exec", NULL) == -1)
		fatal("pledge");

	event_dispatch();

	priv_shutdown();

	return (0);
}

static void
priv_sighandler(int sig, short ev, void *arg)
{
	pid_t pid;
	int status;

	switch (sig) {
	case SIGTERM:
	case SIGINT:
		event_loopbreak();
		break;
	case SIGCHLD:
		do {
			pid = waitpid(-1, &status, WNOHANG);
			if (pid <= 0)
				continue;
			if (WIFSIGNALED(status))
				log_warnx("process %d terminated by signal %d",
				    (int)pid, WTERMSIG(status));
			else if (WIFEXITED(status) && WEXITSTATUS(status))
				log_warnx("process %d exited with status %d",
				    (int)pid, WEXITSTATUS(status));
			else if (WIFEXITED(status))
				log_debug("process %d exited normally",
				    (int)pid);
			else
				/* WIFSTOPPED or WIFCONTINUED */
				continue;
		} while (pid > 0 || (pid == -1 && errno == EINTR));
		break;
	default:
		fatalx("signal %d", sig);
	}
}

static void
priv_shutdown(void)
{
	pid_t pid;

	proc_free(p_control);
	proc_free(p_engine);
	proc_free(p_frontend);

	do {
		pid = waitpid(WAIT_MYPGRP, NULL, 0);
	} while (pid != -1 || (pid == -1 && errno == EINTR));

	log_info("exiting");

	exit(0);
}

static void
priv_open_listener(struct listener *l)
{
	struct sockaddr_un *su;
	struct sockaddr *sa;
	const char *path;
	mode_t old_umask;
	int opt, sock, r;

	sa = (struct sockaddr *)&l->ss;

	sock = socket(sa->sa_family, SOCK_STREAM | SOCK_NONBLOCK, 0);
	if (sock == -1) {
		if (errno == EAFNOSUPPORT) {
			log_warn("%s: socket", __func__);
			return;
		}
		fatal("%s: socket", __func__);
	}

	switch (sa->sa_family) {
	case AF_LOCAL:
		su = (struct sockaddr_un *)sa;
		path = su->sun_path;
		if (connect(sock, sa, sa->sa_len) == 0)
			fatalx("%s already in use", path);

		if (unlink(path) == -1)
			if (errno != ENOENT)
				fatal("unlink: %s", path);

		old_umask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
		r = bind(sock, sa, sizeof(*su));
		(void)umask(old_umask);

		if (r == -1)
			fatal("bind: %s", path);
		break;

	case AF_INET:
	case AF_INET6:
		opt = 1;
		if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt,
		    sizeof(opt)) == -1)
			fatal("setsockopt: %s", log_fmt_sockaddr(sa));

		if (bind(sock, sa, sa->sa_len) == -1)
			fatal("bind: %s", log_fmt_sockaddr(sa));
		break;

	default:
		fatalx("bad address family %d", sa->sa_family);
	}

	l->sock = sock;
}

static void
priv_send_config(void)
{
	struct listener *l;

	m_compose(p_control, IMSG_CONF_START, 0, 0, -1, NULL, 0);
	m_compose(p_control, IMSG_CONF_END, 0, 0, -1, NULL, 0);

	m_compose(p_engine, IMSG_CONF_START, 0, 0, -1, NULL, 0);
	m_compose(p_engine, IMSG_CONF_END, 0, 0, -1, NULL, 0);

	m_compose(p_frontend, IMSG_CONF_START, 0, 0, -1, NULL, 0);
	TAILQ_FOREACH(l, &env->listeners, entry) {
		m_create(p_frontend, IMSG_CONF_LISTENER, 0, 0, l->sock);
		m_add_int(p_frontend, l->proto);
		m_add_sockaddr(p_frontend, (struct sockaddr *)(&l->ss));
		m_close(p_frontend);
	}
	m_compose(p_frontend, IMSG_CONF_END, 0, 0, -1, NULL, 0);
}

static void
priv_dispatch_control(struct imsgproc *proc, struct imsg *imsg, void *arg)
{
	if (imsg == NULL)
		fatalx("%s: imsg connection lost", __func__);

	if (log_getverbose() > LOGLEVEL_IMSG)
		log_imsg(proc, imsg);

	switch (imsg->hdr.type) {
	default:
		fatalx("%s: unexpected imsg %s", __func__,
		    log_fmt_imsgtype(imsg->hdr.type));
	}
}

static void
priv_dispatch_engine(struct imsgproc *proc, struct imsg *imsg, void *arg)
{
	const char *prn;

	if (imsg == NULL)
		fatalx("%s: imsg connection lost", __func__);

	if (log_getverbose() > LOGLEVEL_IMSG)
		log_imsg(proc, imsg);

	switch (imsg->hdr.type) {
	case IMSG_LPR_PRINTJOB:
		m_get_string(proc, &prn);
		m_end(proc);
		priv_run_printer(prn);
		break;
	default:
		fatalx("%s: unexpected imsg %s", __func__,
		    log_fmt_imsgtype(imsg->hdr.type));
	}
}

static void
priv_dispatch_frontend(struct imsgproc *proc, struct imsg *imsg, void *arg)
{
	if (imsg == NULL)
		fatalx("%s: imsg connection lost", __func__);

	if (log_getverbose() > LOGLEVEL_IMSG)
		log_imsg(proc, imsg);

	switch (imsg->hdr.type) {
	default:
		fatalx("%s: unexpected imsg %s", __func__,
		    log_fmt_imsgtype(imsg->hdr.type));
	}
}

static void
priv_dispatch_printer(struct imsgproc *proc, struct imsg *imsg, void *arg)
{
	if (imsg == NULL) {
		log_debug("printer process ended, pid=%d, printer=%s",
		     proc_getpid(proc), proc_gettitle(proc));
		proc_free(proc);
		return;
	}

	if (log_getverbose() > LOGLEVEL_IMSG)
		log_imsg(proc, imsg);

	switch (imsg->hdr.type) {
	default:
		fatalx("%s: unexpected imsg %s", __func__,
		    log_fmt_imsgtype(imsg->hdr.type));
	}
}

static void
priv_run_printer(const char *prn)
{
	struct imsgproc *p;
	char **argv, *buf;
	int argc;

	if (asprintf(&buf, "printer:%s", prn) == -1) {
		log_warn("%s: asprintf", __func__);
		return;
	}

	argv = calloc(saved_argc + 4, sizeof(*argv));
	if (argv == NULL) {
		log_warn("%s: calloc", __func__);
		free(buf);
		return;
	}
	for (argc = 0; argc < saved_argc; argc++)
		argv[argc] = saved_argv[argc];
	argv[argc++] = "-X";
	argv[argc++] = buf;
	argv[argc++] = NULL;

	p = proc_exec(PROC_PRINTER, argv);
	if (p == NULL)
		log_warnx("%s: cannot exec printer process", __func__);
	else {
		proc_settitle(p, prn);
		proc_setcallback(p, priv_dispatch_printer, p);
		proc_enable(p);
	}

	free(argv);
	free(buf);
}