/*      $OpenBSD: printer.c,v 1.4 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/tree.h>
#include <sys/wait.h>

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <pwd.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <vis.h>

#include "lpd.h"
#include "lp.h"
#include "log.h"

#define RETRY_MAX       5

#define JOB_OK          0
#define JOB_AGAIN       1
#define JOB_IGNORE      2
#define JOB_ERROR       3

enum {
        OK = 0,
        ERR_TRANSIENT,  /* transient error */
        ERR_ACCOUNT,    /* account required on the local machine */
        ERR_ACCESS,     /* cannot read file */
        ERR_INODE,      /* inode changed */
        ERR_NOIMPL,     /* unimplemented feature */
        ERR_REJECTED,   /* remote server rejected a job */
        ERR_ERROR,      /* filter report an error */
        ERR_FILTER,     /* filter return invalid status */
};

struct job {
        char    *class;
        char    *host;
        char    *literal;
        char    *mail;
        char    *name;
        char    *person;
        char    *statinfo;
        char    *title;
        int      indent;
        int      pagewidth;
};

struct prnstate {
        int      pfd;           /* printer fd */
        int      ofilter;       /* use output filter when printing */
        int      ofd;           /* output filter fd */
        pid_t    opid;          /* output filter process */
        int      tof;           /* true if at top of form */
        int      count;         /* number of printed files */
        char     efile[64];     /* filename for filter stderr */
};

static void sighandler(int);
static char *xstrdup(const char *);

static int openfile(const char *, const char *, struct stat *, FILE **);
static int printjob(const char *, int);
static void printbanner(struct job *);
static int printfile(struct job *, int, const char *, const char *);
static int sendjob(const char *, int);
static int sendcmd(const char *, ...);
static int sendfile(int, const char *, const char *);
static int recvack(void);
static void mailreport(struct job *, int);

static void prn_open(void);
static int prn_connect(void);
static void prn_close(void);
static int prn_fstart(void);
static void prn_fsuspend(void);
static void prn_fresume(void);
static void prn_fclose(void);
static int prn_formfeed(void);
static int prn_write(const char *, size_t);
static int prn_writefile(FILE *);
static int prn_puts(const char *);
static ssize_t prn_read(char *, size_t);

static struct lp_printer *lp;
static struct prnstate *prn;

void
printer(int debug, int verbose, const char *name)
{
        struct sigaction sa;
        struct passwd *pw;
        struct lp_queue q;
        int fd, jobidx, qstate, r, reload, retry;
        char buf[64], curr[1024];

        /* Early initialisation. */
        log_init(debug, LOG_LPR);
        log_setverbose(verbose);
        snprintf(buf, sizeof(buf), "printer:%s", name);
        log_procinit(buf);
        setproctitle("%s", buf);

        if ((lpd_hostname = malloc(HOST_NAME_MAX+1)) == NULL)
                fatal("%s: malloc", __func__);
        gethostname(lpd_hostname, HOST_NAME_MAX+1);

        /* Detach from lpd session if not in debug mode. */
        if (!debug)
                if (setsid() == -1)
                        fatal("%s: setsid", __func__);

        /* Read printer config. */
        if ((lp = calloc(1, sizeof(*lp))) == NULL)
                fatal("%s: calloc", __func__);
        if (lp_getprinter(lp, name) == -1)
                exit(1);

        /*
         * Redirect stderr if not in debug mode.
         * This must be done before dropping privileges.
         */
        if (!debug) {
                fd = open(LP_LF(lp), O_WRONLY|O_APPEND);
                if (fd == -1)
                        fatal("%s: open: %s", __func__, LP_LF(lp));
                if (fd != STDERR_FILENO) {
                        if (dup2(fd, STDERR_FILENO) == -1)
                                fatalx("%s: dup2", __func__);
                        (void)close(fd);
                }
        }

        /* Drop privileges. */
        if ((pw = getpwnam(LPD_USER)) == NULL)
                fatalx("unknown user " LPD_USER);

        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("cannot drop privileges");

        /* Initialize the printer state. */
        if ((prn = calloc(1, sizeof(*prn))) == NULL)
                fatal("%s: calloc", __func__);
        prn->pfd = -1;
        prn->ofd = -1;

        /* Setup signals */
        memset(&sa, 0, sizeof(sa));
        sa.sa_handler = sighandler;
        sa.sa_flags = SA_RESTART;
        sigemptyset(&sa.sa_mask);
        sigaddset(&sa.sa_mask, SIGINT); /* for kill() in sighandler */
        sigaction(SIGHUP, &sa, NULL);
        sigaction(SIGINT, &sa, NULL);
        sigaction(SIGQUIT, &sa, NULL);
        sigaction(SIGTERM, &sa, NULL);

        /* Grab lock file. */
        if (lp_lock(lp) == -1) {
                if (errno == EWOULDBLOCK) {
                        log_debug("already locked");
                        exit(0);
                }
                fatalx("cannot open lock file");
        }

        /* Pledge. */
        switch (lp->lp_type) {
        case PRN_LOCAL:
                pledge("stdio rpath wpath cpath flock getpw tty proc exec",
                    NULL);
                break;

        case PRN_NET:
                pledge("stdio rpath wpath cpath inet flock dns getpw proc exec",
                    NULL);
                break;

        case PRN_LPR:
                pledge("stdio rpath wpath cpath inet flock dns getpw", NULL);
                break;
        }

        /* Start processing the queue. */
        memset(&q, 0, sizeof(q));
        jobidx = 0;
        reload = 1;
        retry = 0;
        curr[0] = '\0';

        for (;;) {

                /* Check the queue state. */
                if (lp_getqueuestate(lp, 1, &qstate) == -1)
                        fatalx("cannot get queue state");
                if (qstate & LPQ_PRINTER_DOWN) {
                        log_debug("printing disabled");
                        break;
                }
                if (qstate & LPQ_QUEUE_UPDATED) {
                        log_debug("queue updated");
                        if (reload == 0)
                                lp_clearqueue(&q);
                        reload = 1;
                }

                /* Read the queue if needed. */
                if (reload || q.count == 0) {
                        if (lp_readqueue(lp, &q) == -1)
                                fatalx("cannot read queue");
                        jobidx = 0;
                        reload = 0;
                }

                /* If the queue is empty, all done */
                if (q.count <= jobidx) {
                        log_debug("queue empty");
                        break;
                }

                /* Open the printer if needed. */
                if (prn->pfd == -1) {
                        prn_open();
                        /*
                         * Opening the printer might take some time.
                         * Re-read the queue in case its state has changed.
                         */
                        lp_clearqueue(&q);
                        reload = 1;
                        continue;
                }

                if (strcmp(curr, q.cfname[jobidx]))
                        retry = 0;
                else
                        strlcpy(curr, q.cfname[jobidx], sizeof(curr));

                lp_setcurrtask(lp, q.cfname[jobidx]);
                if (lp->lp_type == PRN_LPR)
                        r = sendjob(q.cfname[jobidx], retry);
                else
                        r = printjob(q.cfname[jobidx], retry);
                lp_setcurrtask(lp, NULL);

                switch (r) {
                case JOB_OK:
                        log_info("job %s %s successfully", q.cfname[jobidx],
                            (lp->lp_type == PRN_LPR) ? "relayed" : "printed");
                        break;
                case JOB_AGAIN:
                        retry++;
                        continue;
                case JOB_IGNORE:
                        break;
                case JOB_ERROR:
                        log_warnx("job %s could not be printed",
                            q.cfname[jobidx]);
                        break;
                }
                curr[0] = '\0';
                jobidx++;
                retry = 0;
        }

        if (prn->pfd != -1) {
                if (prn->count) {
                        prn_formfeed();
                        if (lp->lp_tr)
                                prn_puts(lp->lp_tr);
                }
                prn_close();
        }

        exit(0);
}

static void
sighandler(int code)
{
        log_info("got signal %d", code);

        exit(0);
}

static char *
xstrdup(const char *s)
{
        char *r;

        if ((r = strdup(s)) == NULL)
                fatal("strdup");

        return r;
}

/*
 * Open control/data file, and check that the inode information is valid.
 * On success, fill the "st" structure and set "fpp" and return 0 (OK).
 * Return an error code on error.
 */
static int
openfile(const char *fname, const char *inodeinfo, struct stat *st, FILE **fpp)
{
        FILE *fp;
        char buf[64];

        if (inodeinfo) {
                log_warnx("cannot open %s: symlink not implemented", fname);
                return ERR_NOIMPL;
        }
        else {
                if ((fp = lp_fopen(lp, fname)) == NULL) {
                        log_warn("cannot open %s", fname);
                        return ERR_ACCESS;
                }
        }

        if (fstat(fileno(fp), st) == -1) {
                log_warn("%s: fstat: %s", __func__, fname);
                fclose(fp);
                return ERR_ACCESS;
        }

        if (inodeinfo) {
                snprintf(buf, sizeof(buf), "%d %llu", st->st_dev, st->st_ino);
                if (strcmp(inodeinfo, buf)) {
                        log_warnx("inode changed for %s", fname);
                        fclose(fp);
                        return ERR_INODE;
                }
        }

        *fpp = fp;

        return OK;
}

/*
 * Print the job described by the control file.
 */
static int
printjob(const char *cfname, int retry)
{
        struct job job;
        FILE *fp;
        ssize_t len;
        size_t linesz = 0;
        char *line = NULL;
        const char *errstr;
        long long num;
        int r, ret = JOB_OK;

        log_debug("printing job %s...", cfname);

        prn->efile[0] = '\0';
        memset(&job, 0, sizeof(job));
        job.pagewidth = lp->lp_pw;

        if ((fp = lp_fopen(lp, cfname)) == NULL) {
                if (errno == ENOENT) {
                        log_info("missing control file %s", cfname);
                        return JOB_IGNORE;
                }
                /* XXX no fatal? */
                fatal("cannot open %s", cfname);
        }

        /* First pass: setup the job structure, print banner and print data. */
        while ((len = getline(&line, &linesz, fp)) != -1) {
                if (line[len-1] == '\n')
                        line[len-1] = '\0';

                switch (line[0]) {
                case 'C':               /* Classification */
                        if (line[1]) {
                                free(job.class);
                                job.class = xstrdup(line + 1);
                        }
                        else if (job.class == NULL)
                                job.class = xstrdup(lpd_hostname);
                        break;

                case 'H':                /* Host name */
                        free(job.host);
                        job.host = xstrdup(line + 1);
                        if (job.class == NULL)
                                job.class = xstrdup(line + 1);
                        break;

                case 'I':                /* Indent */
                        errstr = NULL;
                        num = strtonum(line + 1, 0, INT_MAX, &errstr);
                        if (errstr == NULL)
                                job.indent = num;
                        else
                                log_warnx("strtonum: %s", errstr);
                        break;

                case 'J':                /* Job Name */
                        free(job.name);
                        if (line[1])
                                job.name = strdup(line + 1);
                        else
                                job.name = strdup(" ");
                        break;

                case 'L':                /* Literal */
                        free(job.literal);
                        job.literal = xstrdup(line + 1);
                        if (!lp->lp_sh && !lp->lp_hl)
                                printbanner(&job);
                        break;

                case 'M':               /* Send mail to the specified user */
                        free(job.mail);
                        job.mail = xstrdup(line + 1);
                        break;

                case 'N':               /* Filename */
                        break;

                case 'P':                /* Person */
                        free(job.person);
                        job.person = xstrdup(line + 1);
                        if (lp->lp_rs && getpwnam(job.person) == NULL) {
                                mailreport(&job, ERR_ACCOUNT);
                                ret = JOB_ERROR;
                                goto remove;
                        }
                        break;

                case 'S':                /* Stat info for symlink protection */
                        job.statinfo = xstrdup(line + 1);
                        break;

                case 'T':               /* Title for pr */
                        job.title = xstrdup(line + 1);
                        break;

                case 'U':                /* Unlink */
                        break;

                case 'W':                /* Width */
                        errstr = NULL;
                        num = strtonum(line + 1, 0, INT_MAX, &errstr);
                        if (errstr == NULL)
                                job.pagewidth = num;
                        else
                                log_warnx("strtonum: %s", errstr);
                        break;

                case '1':               /* troff fonts */
                case '2':
                case '3':
                case '4':
                        /* XXX not implemented */
                        break;

                default:
                        if (line[0] < 'a' || line[0] > 'z')
                                break;

                        r = printfile(&job, line[0], line+1, job.statinfo);
                        free(job.statinfo);
                        job.statinfo = NULL;
                        free(job.title);
                        job.title = NULL;
                        if (r) {
                                if (r == ERR_TRANSIENT && retry < RETRY_MAX) {
                                        ret = JOB_AGAIN;
                                        goto done;
                                }
                                mailreport(&job, r);
                                ret = JOB_ERROR;
                                goto remove;
                        }
                }
        }

    remove:
        if (lp_unlink(lp, cfname) == -1)
                log_warn("cannot unlink %s", cfname);

        /* Second pass: print trailing banner, mail report, and remove files. */
        rewind(fp);
        while ((len = getline(&line, &linesz, fp)) != -1) {
                if (line[len-1] == '\n')
                        line[len-1] = '\0';

                switch (line[0]) {
                case 'L':               /* Literal */
                        if (ret != JOB_OK)
                                break;
                        if (!lp->lp_sh && lp->lp_hl)
                                printbanner(&job);
                        break;

                case 'M':               /* Send mail to the specified user */
                        if (ret == JOB_OK)
                                mailreport(&job, ret);
                        break;

                case 'U':               /* Unlink */
                        if (lp_unlink(lp, line + 1) == -1)
                                log_warn("cannot unlink %s", line + 1);
                        break;
                }
        }

    done:
        if (prn->efile[0])
                unlink(prn->efile);
        (void)fclose(fp);
        free(job.class);
        free(job.host);
        free(job.literal);
        free(job.mail);
        free(job.name);
        free(job.person);
        free(job.statinfo);
        free(job.title);
        return ret;
}

static void
printbanner(struct job *job)
{
        time_t t;

        time(&t);

        prn_formfeed();

        if (lp->lp_sb) {
                if (job->class) {
                        prn_puts(job->class);
                        prn_puts(":");
                }
                prn_puts(job->literal);
                prn_puts("  Job: ");
                prn_puts(job->name);
                prn_puts("  Date: ");
                prn_puts(ctime(&t));
                prn_puts("\n");
        } else {
                prn_puts("\n\n\n");
                lp_banner(prn->pfd, job->literal, lp->lp_pw);
                prn_puts("\n\n");
                lp_banner(prn->pfd, job->name, lp->lp_pw);
                if (job->class) {
                        prn_puts("\n\n\n");
                        lp_banner(prn->pfd, job->class, lp->lp_pw);
                }
                prn_puts("\n\n\n\n\t\t\t\t\tJob:  ");
                prn_puts(job->name);
                prn_puts("\n\t\t\t\t\tDate: ");
                prn_puts(ctime(&t));
                prn_puts("\n");
        }

        prn_formfeed();
}

static int
printfile(struct job *job, int fmt, const char *fname, const char *inodeinfo)
{
        pid_t pid;
        struct stat st;
        FILE *fp;
        size_t n;
        int ret, argc, efd, status;
        char *argv[16], *prog, width[16], length[16], indent[16], tmp[512];

        log_debug("printing file %s...", fname);

        switch (fmt) {
        case 'f':       /* print file as-is */
        case 'o':       /* print postscript file */
        case 'l':       /* print file as-is but pass control chars */
                break;

        case 'p':       /* print using pr(1) */
        case 'r':       /* print fortran text file */
        case 't':       /* print troff output */
        case 'n':       /* print ditroff output */
        case 'd':       /* print tex output */
        case 'c':       /* print cifplot output */
        case 'g':       /* print plot output */
        case 'v':       /* print raster output */
        default:
                log_warn("unrecognized output format '%c'", fmt);
                return ERR_NOIMPL;
        }

        if ((ret = openfile(fname, inodeinfo, &st, &fp)) != OK)
                return ret;

        prn_formfeed();

        /*
         * No input filter, just write the raw file.
         */
        if (!lp->lp_if) {
                if (prn_writefile(fp) == -1)
                        ret = ERR_TRANSIENT;
                else
                        ret = OK;
                (void)fclose(fp);
                return ret;
        }

        /*
         * Otherwise, run the input filter with proper plumbing.
         */

        /* Prepare filter arguments. */
        snprintf(width, sizeof(width), "-w%d", job->pagewidth);
        snprintf(length, sizeof(length), "-l%ld", lp->lp_pl);
        snprintf(indent, sizeof(indent), "-i%d", job->indent);
        prog = strrchr(lp->lp_if, '/');

        argc = 0;
        argv[argc++] =  prog ? (prog + 1) : lp->lp_if;
        if (fmt == 'l')
                argv[argc++] = "-c";
        argv[argc++] = width;
        argv[argc++] = length;
        argv[argc++] = indent;
        argv[argc++] = "-n";
        argv[argc++] = job->person;
        if (job->name) {
                argv[argc++] = "-j";
                argv[argc++]= job->name;
        }
        argv[argc++] = "-h";
        argv[argc++] = job->host;
        argv[argc++] = lp->lp_af;
        argv[argc++] = NULL;

        /* Open the stderr file. */
        strlcpy(prn->efile, "/tmp/prn.XXXXXXXX", sizeof(prn->efile));
        if ((efd = mkstemp(prn->efile)) == -1) {
                log_warn("%s: mkstemp", __func__);
                (void)fclose(fp);
                return ERR_TRANSIENT;
        }

        /* Disable output filter. */
        prn_fsuspend();

        /* Run input filter */
        switch ((pid = fork())) {
        case -1:
                log_warn("%s: fork", __func__);
                close(efd);
                prn_fresume();
                return ERR_TRANSIENT;

        case 0:
                if (dup2(fileno(fp), STDIN_FILENO) == -1)
                        fatal("%s:, dup2", __func__);
                if (dup2(prn->pfd, STDOUT_FILENO) == -1)
                        fatal("%s:, dup2", __func__);
                if (dup2(efd, STDERR_FILENO) == -1)
                        fatal("%s:, dup2", __func__);
                if (closefrom(3) == -1)
                        fatal("%s:, closefrom", __func__);
                execv(lp->lp_if, argv);
                log_warn("%s:, execv", __func__);
                exit(2);

        default:
                break;
        }

        log_debug("waiting for ifilter...");

        /* Wait for input filter to finish. */
        while (waitpid(pid, &status, 0) == -1)
                log_warn("%s: waitpid", __func__);

        log_debug("ifilter done, status %d", status);

        /* Resume output filter */
        prn_fresume();
        prn->tof = 0;

        /* Copy efd to stderr */
        if (lseek(efd, 0, SEEK_SET) == -1)
                log_warn("%s: lseek", __func__);
        while ((n = read(efd, tmp, sizeof(tmp))) > 0)
                (void)write(STDERR_FILENO, tmp, n);
        close(efd);

        if (!WIFEXITED(status)) {
                log_warn("filter terminated (termsig=%d)", WTERMSIG(status));
                return ERR_FILTER;
        }

        switch (WEXITSTATUS(status)) {
        case 0:
                prn->tof = 1;
                return OK;

        case 1:
                return ERR_TRANSIENT;

        case 2:
                return ERR_ERROR;

        default:
                log_warn("filter exited (exitstatus=%d)", WEXITSTATUS(status));
                return ERR_FILTER;
        }
}

static int
sendjob(const char *cfname, int retry)
{
        struct job job;
        FILE *fp;
        ssize_t len;
        size_t linesz = 0;
        char *line = NULL;
        int ret = JOB_OK, r;

        log_debug("sending job %s...", cfname);

        memset(&job, 0, sizeof(job));

        if ((fp = lp_fopen(lp, cfname)) == NULL) {
                if (errno == ENOENT) {
                        log_info("missing control file %s", cfname);
                        return JOB_IGNORE;
                }
                /* XXX no fatal? */
                fatal("cannot open %s", cfname);
        }

        /* First pass: setup the job structure, and forward data files. */
        while ((len = getline(&line, &linesz, fp)) != -1) {
                if (line[len-1] == '\n')
                        line[len-1] = '\0';

                switch (line[0]) {
                case 'P':
                        free(job.person);
                        job.person = xstrdup(line + 1);
                        break;

                case 'S':
                        free(job.statinfo);
                        job.statinfo = xstrdup(line + 1);
                        break;

                default:
                        if (line[0] < 'a' || line[0] > 'z')
                                break;

                        r = sendfile('\3', line+1, job.statinfo);
                        free(job.statinfo);
                        job.statinfo = NULL;
                        if (r) {
                                if (r == ERR_TRANSIENT && retry < RETRY_MAX) {
                                        ret = JOB_AGAIN;
                                        goto done;
                                }
                                mailreport(&job, r);
                                ret = JOB_ERROR;
                                goto remove;
                        }
                }
        }

        /* Send the control file. */
        if ((r = sendfile('\2', cfname, ""))) {
                if (r == ERR_TRANSIENT && retry < RETRY_MAX) {
                        ret = JOB_AGAIN;
                        goto done;
                }
                mailreport(&job, r);
                ret = JOB_ERROR;
        }

    remove:
        if (lp_unlink(lp, cfname) == -1)
                log_warn("cannot unlink %s", cfname);

        /* Second pass: remove files. */
        rewind(fp);
        while ((len = getline(&line, &linesz, fp)) != -1) {
                if (line[len-1] == '\n')
                        line[len-1] = '\0';

                switch (line[0]) {
                case 'U':
                        if (lp_unlink(lp, line + 1) == -1)
                                log_warn("cannot unlink %s", line + 1);
                        break;
                }
        }

    done:
        (void)fclose(fp);
        free(line);
        free(job.person);
        free(job.statinfo);
        return ret;
}

/*
 * Send a LPR command to the remote lpd server and return the ack.
 * Return 0 for ack, 1 or nack, -1 and set errno on error.
 */
static int
sendcmd(const char *fmt, ...)
{
        va_list ap;
        unsigned char line[1024];
        int len;

        va_start(ap, fmt);
        len = vsnprintf(line, sizeof(line), fmt, ap);
        va_end(ap);

        if (len < 0) {
                log_warn("%s: vsnprintf", __func__);
                return -1;
        }

        if (prn_puts(line) == -1)
                return -1;

        return recvack();
}

static int
sendfile(int type, const char *fname, const char *inodeinfo)
{
        struct stat st;
        FILE *fp = NULL;
        int ret;

        log_debug("sending file %s...", fname);

        if ((ret = openfile(fname, inodeinfo, &st, &fp)) != OK)
                return ret;

        ret = ERR_TRANSIENT;
        if (sendcmd("%c%lld %s\n", type, (long long)st.st_size, fname)) {
                if (errno == 0)
                        ret = ERR_REJECTED;
                goto fail;
        }

        lp_setstatus(lp, "sending %s to %s", fname, lp->lp_rm);
        if (prn_writefile(fp) == -1 || prn_write("\0", 1) == -1)
                goto fail;
        if (recvack()) {
                if (errno == 0)
                        ret = ERR_REJECTED;
                goto fail;
        }

        ret = OK;

    fail:
        (void)fclose(fp);

        if (ret == ERR_REJECTED)
                log_warnx("%s rejected by remote host", fname);

        return ret;
}

/*
 * Read a ack response from the server.
 * Return 0 for ack, 1 or nack, -1 and set errno on error.
 */
static int
recvack(void)
{
        char visbuf[256 * 4 + 1];
        unsigned char line[1024];
        ssize_t n;

        if ((n = prn_read(line, sizeof(line))) == -1)
                return -1;

        if (n == 1) {
                errno = 0;
                if (line[0])
                        log_warnx("%s: \\%d", lp->lp_host, line[0]);
                return line[0] ? 1 : 0;
        }

        if (n > 256)
                n = 256;
        line[n] = '\0';
        if (line[n-1] == '\n')
                line[--n] = '\0';

        strvisx(visbuf, line, n, VIS_NL | VIS_CSTYLE);
        log_warnx("%s: %s", lp->lp_host, visbuf);

        errno = 0;
        return -1;
}

static void
mailreport(struct job *job, int result)
{
        struct stat st;
        FILE *fp = NULL, *efp;
        const char *user;
        char *cp;
        int p[2], c;

        if (job->mail)
                user =  job->mail;
        else
                user =  job->person;
        if (user == NULL) {
                log_warnx("no user to send report to");
                return;
        }

        if (pipe(p) == -1) {
                log_warn("pipe");
                return;
        }

        switch (fork()) {
        case -1:
                (void)close(p[0]);
                (void)close(p[1]);
                log_warn("fork");
                return;

        case 0:
                if (dup2(p[0], 0) == -1)
                        fatal("%s: dup2", __func__);
                (void)closefrom(3);
                if ((cp = strrchr(_PATH_SENDMAIL, '/')))
                        cp++;
                else
                        cp = _PATH_SENDMAIL;
                execl(_PATH_SENDMAIL, cp, "-t", (char *)NULL);
                fatal("%s: execl: %s", __func__, _PATH_SENDMAIL);

        default:
                (void)close(p[0]);
                if ((fp = fdopen(p[1], "w")) == NULL) {
                        (void)close(p[1]);
                        log_warn("fdopen");
                        return;
                }
        }

        fprintf(fp, "Auto-Submitted: auto-generated\n");
        fprintf(fp, "To: %s@%s\n", user, job->host);
        fprintf(fp, "Subject: %s printer job \"%s\"\n", lp->lp_name,
            job->name ? job->name : "<unknown>");
        fprintf(fp, "Reply-To: root@%s\n\n", lpd_hostname);
        fprintf(fp, "Your printer job ");
        if (job->name)
                fprintf(fp, " (%s) ", job->name);

        fprintf(fp, "\n");

        switch (result) {
        case OK:
                fprintf(fp, "completed successfully");
                break;

        case ERR_ACCOUNT:
                fprintf(fp, "could not be printed without an account on %s",
                    lpd_hostname);
                break;

        case ERR_ACCESS:
                fprintf(fp, "could not be printed because the file could "
                    " not be read");
                break;

        case ERR_INODE:
                fprintf(fp, "was not printed because it was not linked to"
                    " the original file");
                break;

        case ERR_NOIMPL:
                fprintf(fp, "was not printed because some feature is missing");
                break;

        case ERR_FILTER:
                efp = fopen(prn->efile, "r");
                if (efp && fstat(fileno(efp), &st) == 0 && st.st_size) {
                        fprintf(fp,
                            "had the following errors and may not have printed:\n");
                        while ((c = getc(efp)) != EOF)
                                putc(c, fp);
                }
                else
                        fprintf(fp,
                            "had some errors and may not have printed\n");

                if (efp)
                        fclose(efp);
                break;

        default:
                printf("could not be printed");
                break;
        }

        fprintf(fp, "\n");
        fclose(fp);

        wait(NULL);
}

static void
prn_open(void)
{
        const char *status, *oldstatus;
        int i;

        switch (lp->lp_type) {
        case PRN_LOCAL:
                lp_setstatus(lp, "opening %s", LP_LP(lp));
                break;

        case PRN_NET:
        case PRN_LPR:
                lp_setstatus(lp, "connecting to %s:%s", lp->lp_host,
                    lp->lp_port ? lp->lp_port : "printer");
                break;
        }

        status = oldstatus = NULL;
        for (i = 0; prn->pfd == -1; i += (i < 6) ? 1 : 0) {

                if (status != oldstatus) {
                        lp_setstatus(lp, "%s", status);
                        oldstatus = status;
                }

                if (i)
                        sleep(1 << i);

                if ((prn->pfd = prn_connect()) == -1) {
                        status = "waiting for printer to come up";
                        continue;
                }

                if (lp->lp_type == PRN_LPR) {
                        /* Send a recvjob request. */
                        if (sendcmd("\2%s\n", LP_RP(lp))) {
                                if (errno == 0)
                                        log_warnx("remote queue is disabled");
                                (void)close(prn->pfd);
                                prn->pfd = -1;
                                status = "waiting for queue to be enabled";
                        }
                }
        }

        switch (lp->lp_type) {
        case PRN_LOCAL:
                lp_setstatus(lp, "printing to %s", LP_LP(lp));
                break;

        case PRN_NET:
                lp_setstatus(lp, "printing to %s:%s", lp->lp_host, lp->lp_port);
                break;

        case PRN_LPR:
                lp_setstatus(lp, "sending to %s", lp->lp_host);
                break;
        }

        prn->tof = lp->lp_fo ? 0 : 1;
        prn->count = 0;

        prn_fstart();
}

/*
 * Open the printer device, or connect to the remote host.
 * Return the printer file descriptor, or -1 on error.
 */
static int
prn_connect(void)
{
        struct addrinfo hints, *res, *res0;
        int save_errno;
        int fd, e, mode;
        const char *cause = NULL, *host, *port;

        if (lp->lp_type == PRN_LOCAL) {
                mode = lp->lp_rw ? O_RDWR : O_WRONLY;
                if ((fd = open(LP_LP(lp), mode)) == -1) {
                        log_warn("failed to open %s", LP_LP(lp));
                        return -1;
                }

                if (isatty(fd)) {
                        lp_stty(lp, fd);
                        return -1;
                }

                return fd;
        }

        host = lp->lp_host;
        port = lp->lp_port ? lp->lp_port : "printer";

        memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;
        if ((e = getaddrinfo(host, port, &hints, &res0))) {
                log_warnx("%s:%s: %s", host, port, gai_strerror(e));
                return -1;
        }

        fd = -1;
        for (res = res0; res && fd == -1; res = res->ai_next) {
                fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
                if (fd == -1)
                        cause = "socket";
                else if (connect(fd, res->ai_addr, res->ai_addrlen) == -1) {
                        cause = "connect";
                        save_errno = errno;
                        (void)close(fd);
                        errno = save_errno;
                        fd = -1;
                }
        }

        if (fd == -1)
                log_warn("%s", cause);
        else
                log_debug("connected to %s:%s", host, port);

        freeaddrinfo(res0);
        return fd;
}

static void
prn_close(void)
{
        prn_fclose();

        (void)close(prn->pfd);
        prn->pfd = -1;
}

/*
 * Fork the output filter process if needed.
 */
static int
prn_fstart(void)
{
        char width[32], length[32], *cp;
        int fildes[2], i;

        if (lp->lp_type == PRN_LPR || (!lp->lp_of))
                return 0;

        pipe(fildes);

        for (i = 0; i < 20; i++) {
                if (i)
                        sleep(i);
                if ((prn->opid = fork()) != -1)
                        break;
                log_warn("%s: fork", __func__);
        }

        if (prn->opid == -1) {
                log_warnx("cannot fork output filter");
                return -1;
        }

        if (prn->opid == 0) {
                /* child */
                dup2(fildes[0], 0);
                dup2(prn->pfd, 1);
                (void)closefrom(3);
                cp = strrchr(lp->lp_of, '/');
                if (cp)
                        cp += 1;
                else
                        cp = lp->lp_of;
                snprintf(width, sizeof(width), "-w%ld", lp->lp_pw);
                snprintf(length, sizeof(length), "-l%ld", lp->lp_pl);
                execl(lp->lp_of, cp, width, length, (char *)NULL);
                log_warn("%s: execl", __func__);
                exit(1);
        }

        close(fildes[0]);
        prn->ofd = fildes[1];
        prn->ofilter = 1;

        return 0;
}

/*
 * Suspend the output filter process.
 */
static void
prn_fsuspend(void)
{
        pid_t pid;
        int status;

        if (prn->opid == 0)
                return;

        prn_puts("\031\1");
        while ((pid = waitpid(WAIT_ANY, &status, WUNTRACED)) && pid != prn->opid)
                ;

        prn->ofilter = 0;
        if (!WIFSTOPPED(status)) {
                log_warn("output filter died (exitstatus=%d termsig=%d)",
                    WEXITSTATUS(status), WTERMSIG(status));
                prn->opid = 0;
                prn_fclose();
        }
}

/*
 * Resume the output filter process.
 */
static void
prn_fresume(void)
{
        if (prn->opid == 0)
                return;

        if (kill(prn->opid, SIGCONT) == -1)
                fatal("cannot restart output filter");
        prn->ofilter = 1;
}

/*
 * Close the output filter socket and wait for the process to terminate
 * if currently running.
 */
static void
prn_fclose(void)
{
        pid_t pid;

        close(prn->ofd);
        prn->ofd = -1;

        while (prn->opid) {
                pid = wait(NULL);
                if (pid == -1)
                        log_warn("%s: wait", __func__);
                else if (pid == prn->opid)
                        prn->opid = 0;
        }
}

/*
 * Write a form-feed if the printer cap requires it, and if not currently
 * at top of form. Return 0 on success, or -1 on error and set errno.
 */
static int
prn_formfeed(void)
{
        if (!lp->lp_sf && !prn->tof)
                if (prn_puts(LP_FF(lp)) == -1)
                        return -1;
        prn->tof = 1;
        return 0;
}

/*
 * Write data to the printer (or output filter process).
 * Return 0 on success, or -1 and set errno.
 */
static int
prn_write(const char *buf, size_t len)
{
        ssize_t n;
        int fd;

        fd = prn->ofilter ? prn->ofd : prn->pfd;

        log_debug("prn_write(fd=%d len=%zu, of=%d pfd=%d ofd=%d)", fd, len,
            prn->ofilter, prn->pfd, prn->ofd);

        if (fd == -1) {
                log_warnx("printer socket not opened");
                errno = EPIPE;
                return -1;
        }

        while (len) {
                if ((n = write(fd, buf, len)) == -1) {
                        if (errno == EINTR)
                                continue;
                        log_warn("%s: write", __func__);
                        /* XXX close the printer */
                        return -1;
                }
                len -= n;
                buf += n;
                prn->tof = 0;
        }

        return 0;
}

/*
 * Write a string to the printer (or output filter process).
 * Return 0 on success, or -1 and set errno.
 */
static int
prn_puts(const char *buf)
{
        return prn_write(buf, strlen(buf));
}

/*
 * Write the FILE content to the printer (or output filter process).
 * Return 0 on success, or -1 and set errno.
 */
static int
prn_writefile(FILE *fp)
{
        char buf[BUFSIZ];
        size_t r;

        while (!feof(fp)) {
                r = fread(buf, 1, sizeof(buf), fp);
                if (ferror(fp)) {
                        log_warn("%s: fread", __func__);
                        return -1;
                }
                if (r && (prn_write(buf, r) == -1))
                        return -1;
        }

        return 0;
}

/*
 * Read data from the printer socket into the given buffer.
 * Return 0 on success, or -1 and set errno.
 */
static ssize_t
prn_read(char *buf, size_t sz)
{
        ssize_t n;

        for (;;) {
                if ((n = read(prn->pfd, buf, sz)) == 0) {
                        errno = ECONNRESET;
                        n = -1;
                }
                if (n == -1) {
                        if (errno == EINTR)
                                continue;
                        /* XXX close printer? */
                        log_warn("%s: read", __func__);
                        return -1;
                }
                return n;
        }
}