/*      $OpenBSD: lp.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/mount.h>
#include <sys/stat.h>

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "lp.h"

#include "log.h"

#define XXX_PID_MAX 99999

struct qentry {
        char *name;
        time_t mtime;
};

static int readent(struct lp_printer *, char *);
static int qentrycmp(const void *, const void *);
static int fullpath(struct lp_printer *, const char *, char *, size_t);
static int checksize(struct lp_printer *, size_t);

static int scanning;
static char *db[] = {
        _PATH_PRINTCAP,
        NULL,
};

/*
 * Fill a printer structure from its /etc/printcap entry.
 * Return 0 on success, or -1 on error.
 */
int
lp_getprinter(struct lp_printer *lp, const char *name)
{
        char *buf = NULL;
        int r;

        memset(lp, 0, sizeof(*lp));

        r = cgetent(&buf, db, name);
        if (r == 0)
                r = readent(lp, buf);
        free(buf);

        switch (r) {
        case -3:
                log_warnx("%s: potential reference loop", name);
                break;
        case -2:
                log_warn("%s", name);
                break;
        case -1:
                log_warnx("%s: unknown printer", name);
                break;
        case 0:
                return 0;
        case 1:
                log_warnx("%s: unresolved tc expansion", name);
                break;
        default:
                log_warnx("%s: unexpected return value %d", name, r);
        }

        lp_clearprinter(lp);
        return -1;
}

/*
 * Iterate over /etc/printcap and fill the printer structure from the next
 * entry, if any.
 *
 * Return 0 if no entry is found.
 *        1 if a printer is filled.
 *       -1 on error, and set errno.
 */
int
lp_scanprinters(struct lp_printer *lp)
{
        char *buf;
        int r, saved_errno;

        if (scanning++ == 0)
                r = cgetfirst(&buf, db);
        else
                r = cgetnext(&buf, db);

        if (r == 0) {
                cgetclose();
                scanning = 0;
                return 0;
        } else if (r == 1) {
                memset(lp, 0, sizeof(*lp));
                r = readent(lp, buf);
                free(buf);
                if (r == -2)
                        goto fail;
                return 1;
        } else if (r == -1) 
                fatal("cannot open %s", _PATH_PRINTCAP);
        else if (r == -2)
                errno = ELOOP; /* potential reference loop */

    fail:
        saved_errno = errno;
        lp_clearprinter(lp);
        cgetclose();
        scanning = 0;
        errno = saved_errno;
        return -1;
}

static int
readent(struct lp_printer *lp, char *buf)
{
        char *s;

        s = strchr(buf, ':');
        if (s)
                *s = '\0';
        lp->lp_name = strdup(buf);
        if (s)
                *s = ':';
        if (lp->lp_name == NULL)
                return -2;

        s = lp->lp_name;
        while ((s = strchr(s, '|'))) {
                *s++ = '\0';
                if (lp->lp_aliascount < LP_MAXALIASES)
                        lp->lp_aliases[lp->lp_aliascount++] = s;
        }

#define CGETSTR(x)      if (cgetstr(buf, #x, &(lp->lp_ ## x)) == -2) \
                                goto fail
#define CGETNUM(x, d)   if (cgetnum(buf, #x, &(lp->lp_ ## x)) == -1) \
                                (lp->lp_ ## x) = d;
#define CGETBOOL(x) lp->lp_ ## x = cgetcap(buf, #x, ':') ? 1 : 0

        CGETSTR(af);
        CGETNUM(br, 0);
        CGETSTR(cf);
        CGETSTR(df);
        CGETSTR(ff);
        CGETBOOL(fo);
        CGETSTR(gf);
        CGETBOOL(hl);
        CGETBOOL(ic);
        CGETSTR(if);
        CGETSTR(lf);
        CGETSTR(lo);
        CGETSTR(lp);
        CGETNUM(mc, 0);
        CGETSTR(ms);
        CGETNUM(mx, 0);
        CGETSTR(nd);
        CGETSTR(nf);
        CGETSTR(of);
        CGETNUM(pc, DEFAULT_PC);
        CGETNUM(pl, DEFAULT_PL);
        CGETNUM(pw, DEFAULT_PW);
        CGETNUM(px, 0);
        CGETNUM(py, 0);
        CGETSTR(rf);
        CGETSTR(rg);
        CGETSTR(rm);
        CGETSTR(rp);
        CGETBOOL(rs);
        CGETBOOL(rw);
        CGETBOOL(sb);
        CGETBOOL(sc);
        CGETSTR(sd);
        CGETBOOL(sf);
        CGETBOOL(sh);
        CGETSTR(st);
        CGETSTR(tf);
        CGETSTR(tr);
        CGETSTR(vf);

        if (lp->lp_rm && lp->lp_rm[0]) {
                lp->lp_type = PRN_LPR;
                lp->lp_host = lp->lp_rm;
                lp->lp_port = NULL;
        }
        else if (strchr(LP_LP(lp), '@')) {
                lp->lp_type = PRN_NET;
                lp->lp_port = strdup(LP_LP(lp));
                lp->lp_host = strchr(lp->lp_port, '@');
                *lp->lp_host++ = '\0';
        }
        else {
                lp->lp_type = PRN_LOCAL;
        }

        return 0;
    fail:
        return -2;
}

void
lp_clearprinter(struct lp_printer *lp)
{
        free(lp->lp_name);
        free(lp->lp_port);
        if (lp->lp_lock)
                fclose(lp->lp_lock);
        free(lp->lp_af);
        free(lp->lp_cf);
        free(lp->lp_df);
        free(lp->lp_ff);
        free(lp->lp_gf);
        free(lp->lp_if);
        free(lp->lp_lf);
        free(lp->lp_lo);
        free(lp->lp_lp);
        free(lp->lp_ms);
        free(lp->lp_nd);
        free(lp->lp_nf);
        free(lp->lp_of);
        free(lp->lp_rf);
        free(lp->lp_rg);
        free(lp->lp_rm);
        free(lp->lp_rp);
        free(lp->lp_sd);
        free(lp->lp_st);
        free(lp->lp_tf);
        free(lp->lp_tr);
        free(lp->lp_vf);
        memset(lp, 0, sizeof(*lp));
}

static int
qentrycmp(const void *aa, const void *bb)
{
        const struct qentry *a = aa, *b = bb;

        if (a->mtime < b->mtime)
                return -1;
        if (a->mtime > b->mtime)
                return 1;

        return strcmp(a->name, b->name);
}

/*
 * Read the printer queue content.
 * Return the task count, or -1 on error.
 */
int
lp_readqueue(struct lp_printer *lp, struct lp_queue *q)
{
        struct qentry *qe = NULL, *tqe;
        struct dirent *d;
        struct stat st;
        size_t len, sz, nqi, nqe = 0, nqa = 0, n, i;
        char path[PATH_MAX], *end;
        DIR *dp= NULL;

        len = strlcpy(path, LP_SD(lp), sizeof(path));
        if (len == 0 || len >= sizeof(path)) {
                log_warn("%s: %s: invalid spool directory name",
                    __func__, LP_SD(lp));
                goto fail;
        }

        if ((dp = opendir(path)) == NULL) {
                log_warn("%s: opendir", __func__);
                goto fail;
        }

        if (fstat(dirfd(dp), &st) == -1) {
                log_warn("%s: fstat", __func__);
                goto fail;
        }
        /* Assume half the files are cf files. */
        nqi = st.st_nlink / 2;

        if (path[len-1] != '/') {
                len = strlcat(path, "/", sizeof(path));
                if (len >= sizeof(path)) {
                        errno = ENAMETOOLONG;
                        log_warn("%s: strlcat", __func__);
                        goto fail;
                }
        }
        end = path + len;
        sz = sizeof(path) - len;

        errno = 0;
        while ((d = readdir(dp))) {
                if (d->d_name[0] != 'c' || d->d_name[1] != 'f')
                        continue;

                if (strlen(d->d_name) < 7)
                        continue;

                if (!isdigit((unsigned char)d->d_name[3]) ||
                    !isdigit((unsigned char)d->d_name[4]) ||
                    !isdigit((unsigned char)d->d_name[5]))
                        continue;

                if (strlcpy(end, d->d_name, sz) >= sz) {
                        errno = ENAMETOOLONG;
                        log_warn("%s: strlcat", __func__);
                        goto fail;
                }

                if (stat(path, &st) == -1) {
                        log_warn("%s: stat", __func__);
                        goto fail;
                }

                if (nqe == nqa) {
                        n = nqa ? (nqa + 5) : nqi;
                        tqe = recallocarray(qe, nqa, n, sizeof(*qe));
                        if (tqe == NULL) {
                                log_warn("%s: recallocarray", __func__);
                                goto fail;
                        }
                        qe = tqe;
                        nqa = n;
                }

                if ((qe[nqe].name = strdup(d->d_name)) == NULL) {
                        log_warn("%s: strdup", __func__);
                        goto fail;
                }
                qe[nqe].mtime = st.st_mtime;
                nqe++;
        }
        if (errno) {
                log_warn("%s: readdir", __func__);
                goto fail;
        }
        closedir(dp);
        dp = NULL;

        qsort(qe, nqe, sizeof(*qe), qentrycmp);

        q->count = nqe;
        q->cfname = calloc(nqe, sizeof(*q->cfname));
        if (q->cfname == NULL) {
                log_warn("%s: calloc", __func__);
                goto fail;
        }
        for (i = 0; i < nqe; i++)
                q->cfname[i] = qe[i].name;

        free(qe);
        return nqe;

    fail:
        if (dp)
                closedir(dp);
        for (i = 0; i < nqe; i++)
                free(qe[i].name);
        free(qe);
        lp_clearqueue(q);
        return -1;
}

void
lp_clearqueue(struct lp_queue *q)
{
        int i;

        for (i = 0; i < q->count; i++)
                free(q->cfname[i]);
        free(q->cfname);
}

static int
fullpath(struct lp_printer *lp, const char *fname, char *dst, size_t sz)
{
        int r;

        r = snprintf(dst, sz, "%s/%s", LP_SD(lp), fname);
        if (r < 0 || (size_t)r >= sz) {
                errno = ENAMETOOLONG;
                return -1;
        }

        return 0;
}

/*
 * fopen(3) a file in the printer spooldir for reading.
 */
FILE *
lp_fopen(struct lp_printer *lp, const char *fname)
{
        char path[PATH_MAX];

        if (fullpath(lp, fname, path, sizeof(path)) == -1)
                return NULL;

        return fopen(path, "r");
}

/*
 * unlink(2) a file in the printer spooldir.
 */
int
lp_unlink(struct lp_printer *lp, const char *fname)
{
        char path[PATH_MAX];

        if (fullpath(lp, fname, path, sizeof(path)) == -1)
                return -1;

        return unlink(path);
}

/*
 * stat(2) a file in the printer spooldir.
 */
int
lp_stat(struct lp_printer *lp, const char *fname, struct stat *st)
{
        char path[PATH_MAX];

        if (fullpath(lp, fname, path, sizeof(path)) == -1)
                return -1;

        return stat(path, st);
}

/*
 * Grab the lockfile for this printer, and associate it to the printer.
 * Return -1 on error or 0 otherwise.
 */
int
lp_lock(struct lp_printer *lp)
{
        char path[PATH_MAX];
        struct stat st;
        int fd, saved_errno;

        if (lp->lp_lock) {
                errno = EWOULDBLOCK;
                return -1;
        }

        if (fullpath(lp, LP_LO(lp), path, sizeof(path)) == -1) {
                log_warn("%s: %s", __func__, LP_LO(lp));
                return -1;
        }

        fd = open(path, O_WRONLY|O_CREAT|O_NOFOLLOW|O_NONBLOCK|O_EXLOCK|O_TRUNC,
            0640);
        if (fd == -1) {
                if (errno != EWOULDBLOCK)
                        log_warn("%s: open", __func__);
                return -1;
        }

        if (fstat(fd, &st) == -1) {
                log_warn("%s: fstat", __func__);
                saved_errno = errno;
                (void)close(fd);
                errno = saved_errno;
                return -1;
        }

        if (!S_ISREG(st.st_mode)) {
                errno = EFTYPE;
                log_warnx("%s: %s: Not a regular file", __func__, path);
                (void)close(fd);
                return -1;
        }

        if ((lp->lp_lock = fdopen(fd, "w")) == NULL) {
                log_warn("%s: fdopen", __func__);
                saved_errno = errno;
                (void)close(fd);
                errno = saved_errno;
                return -1;
        }

        lp_setcurrtask(lp, NULL);

        return 0;
}

/*
 * Truncate the lock file and close it.
 */
void
lp_unlock(struct lp_printer *lp)
{
        if (ftruncate(fileno(lp->lp_lock), 0) == -1)
                log_warn("%s: ftruncate", __func__);
        if (fclose(lp->lp_lock) == EOF)
                log_warn("%s: fclose", __func__);
        lp->lp_lock = NULL;
}

int
lp_getqueuestate(struct lp_printer *lp, int reset, int *qstate)
{
        FILE *fp;
        struct stat st;
        int saved_errno;

        *qstate = 0;

        fp = lp->lp_lock;
        if (lp->lp_lock == NULL) {
                fp = lp_fopen(lp, LP_LO(lp));
                if (fp == NULL) {
                        if (errno == ENOENT)
                                return 0;
                        log_warn("%s: lp_fopen", __func__);
                        return -1;
                }
        }

        if (fstat(fileno(fp), &st) == -1) {
                log_warn("%s: fstat", __func__);
                if (lp->lp_lock == NULL) {
                        saved_errno = errno;
                        (void)fclose(fp);
                        errno = saved_errno;
                }
                return -1;
        }

        if (st.st_mode & S_IXUSR)
                *qstate |= LPQ_PRINTER_DOWN;
        if (st.st_mode & S_IXGRP)
                *qstate |= LPQ_QUEUE_OFF;
        if (st.st_mode & S_IXOTH) {
                *qstate |= LPQ_QUEUE_UPDATED;
                if (reset) {
                        st.st_mode &= ~S_IXOTH & 0777;
                        if (fchmod(fileno(lp->lp_lock), st.st_mode) == -1)
                                log_warn("%s: fchmod", __func__);
                }
        }

        if (lp->lp_lock == NULL)
                fclose(fp);

        return 0;
}

/*
 * Update the current task description in the lock file.
 * The lock file must be opened.
 */
void
lp_setcurrtask(struct lp_printer *lp, const char *cfile)
{
        int r;

        if (ftruncate(fileno(lp->lp_lock), 0) == -1)
                log_warn("%s: ftruncate", __func__);

        if (cfile)
                r = fprintf(lp->lp_lock, "%d\n%s\n", (int)getpid(), cfile);
        else
                r = fprintf(lp->lp_lock, "%d\n", (int)getpid());
        if (r < 0)
                log_warn("%s: fprintf", __func__);

        if (fflush(lp->lp_lock) != 0)
                log_warn("%s: fflush", __func__);
}

/*
 * Find the pid of the running process if any, and the task being printed.
 *
 * Returns -1 on error (errno set).
 *          0 if no process is running.
 *          1 if a printer process is up.
 *          2 if a printer process is up and a file is being printed.
 */
int
lp_getcurrtask(struct lp_printer *lp, pid_t *ppid, char *dst, size_t dstsz)
{
        FILE *fp;
        const char *errstr;
        char *line = NULL;
        size_t linesz = 0;
        ssize_t len;
        pid_t pid;
        int r, saved_errno;

        pid = *ppid = 0;
        dst[0] = '\0';
        r = -1;

        fp = lp_fopen(lp, LP_LO(lp));
        if (fp == NULL) {
                if (errno == ENOENT)
                        return 0;
                log_warn("%s: lp_fopen", __func__);
                return -1;
        }

        while ((len = getline(&line, &linesz, fp)) != -1) {
                if (line[len-1] == '\n')
                        line[len-1] = '\0';

                /* Read filename. */
                if (pid) {
                        (void)strlcpy(dst, line, dstsz);
                        break;
                }

                pid = strtonum(line, 2, XXX_PID_MAX, &errstr);
                if (errstr) {
                        log_warn("%s: strtonum", __func__);
                        goto done;
                }
        }

        if ((errno = ferror(fp))) {
                log_warn("%s: getline", __func__);
                goto done;
        }

        r = 0;
        if (pid == 0)
                goto done;

        if (kill(pid, 0) == -1 && errno != EPERM) {
                if (errno != ESRCH)
                        log_warn("%s: kill", __func__);
                goto done;
        }

        *ppid = pid;
        r = dst[0] ? 2 : 1;

    done:
        free(line);
        saved_errno = errno;
        (void)fclose(fp);
        errno = saved_errno;
        return r;
}

/*
 * Read the current printer status file.
 * Return -1 on error, 0 on success.
 */
int
lp_getstatus(struct lp_printer *lp, char *buf, size_t bufsz)
{
        size_t len;
        char *line;
        FILE *fp;
        int saved_errno;

        buf[0] = '\0';

        fp = lp_fopen(lp, LP_ST(lp));
        if (fp == NULL) {
                if (errno == ENOENT)
                        return 0;
                log_warn("%s: lp_fopen", __func__);
                return -1;
        }

        line = fgetln(fp, &len);
        if (line) {
                if (len >= bufsz)
                        len = bufsz - 1;
                else if (line[len - 1] == '\n')
                        len--;
                memmove(buf, line, len);
                buf[len] = '\0';
        }
        else if ((errno = ferror(fp))) {
                log_warn("%s: fgetln", __func__);
                saved_errno = errno;
                (void)fclose(fp);
                errno = saved_errno;
                return -1;
        }

        (void)fclose(fp);
        return 0;
}

/*
 * Update the current printer status.
 */
void
lp_setstatus(struct lp_printer *lp, const char *fmt, ...)
{
        va_list ap;
        FILE *fp;
        char path[PATH_MAX], *s;
        int fd = -1, r, saved_errno;

        va_start(ap, fmt);
        r = vasprintf(&s, fmt, ap);
        va_end(ap);

        if (r == -1) {
                log_warn("%s: vasprintf", __func__);
                return;
        }

        if (fullpath(lp, LP_ST(lp), path, sizeof(path)) == -1) {
                log_warn("%s: fullpath", __func__);
                free(s);
                return;
        }

        fd = open(path, O_WRONLY|O_CREAT|O_NOFOLLOW|O_EXLOCK|O_TRUNC, 0660);
        if (fd == -1) {
                log_warn("%s: open", __func__);
                free(s);
                return;
        }

        fp = fdopen(fd, "w");
        if (fp == NULL) {
                log_warn("%s: fdopen", __func__);
                saved_errno = errno;
                (void)close(fd);
                free(s);
                errno = saved_errno;
                return;
        }

        r = fprintf(fp, "%s\n", s);

        if (r <= 0) {
                log_warn("%s: fprintf", __func__);
                saved_errno = errno;
                (void)fclose(fp);
                free(s);
                errno = saved_errno;
                return;
        }

        (void)fclose(fp);
        free(s);
}

/*
 * Check that the given string is a valid filename for the spooler.
 */
int
lp_validfilename(const char *fname, int cf)
{
        size_t len, i;

        len = strlen(fname);
        if (len <= 6) /* strlen("cfA000") */
                return 0;

        if (fname[0] != (cf ? 'c' : 'd') ||
            fname[1] != 'f' ||
            fname[2] < 'A' ||
            fname[2] > 'Z' ||
            !isdigit((unsigned char)fname[3]) ||
            !isdigit((unsigned char)fname[4]) ||
            !isdigit((unsigned char)fname[5]))
                return 0;

        for (i = 6; i < len; i++)
                if (!isalpha((unsigned char)fname[i]) &&
                    !isdigit((unsigned char)fname[i]) &&
                    strchr("-_.", (unsigned char)fname[i]) == NULL)
                        return 0;

        return 1;
}

/*
 * Create a new control or data file in the printer spooldir.
 * Control files have there name changed to a temporary name. They are renamed
 * to their final name by lp_commit().
 */
int
lp_create(struct lp_printer *lp, int cf, size_t sz, const char *fname)
{
        struct stat st;
        char path[PATH_MAX];
        int fd;

        /* Make sure the file size is acceptable. */
        if (checksize(lp, sz) == -1)
                return -1;

        if (fullpath(lp, fname, path, sizeof(path)) == -1) {
                log_warn("%s: %s", __func__, fname);
                return -1;
        }

        if (cf) {
                /*
                 * Create a temporary file, but we want to avoid
                 * a collision with the final cf filename.
                 */
                /* XXX this would require a lock on .seq */
                path[strlen(LP_SD(lp)) + 1] = 'c';
                if (stat(path, &st) == 0) {
                        errno = EEXIST;
                        log_warn("%s: %s", __func__, fname);
                        return -1;
                }
                path[strlen(LP_SD(lp)) + 1] = 't';
        }

        fd = open(path, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW, 0660);
        if (fd == -1)
                log_warn("%s: open", __func__);

        return fd;
}

/*
 * Commit the job given by its temporary CF name.
 * This is done by renaming the temporary CF file name to its final name.
 * The functions return 0 on success, or -1 on error and set errno.
 */
int
lp_commit(struct lp_printer *lp, const char *cf)
{
        char ipath[PATH_MAX], opath[PATH_MAX];

        if (fullpath(lp, cf, ipath, sizeof(ipath)) == -1 ||
            fullpath(lp, cf, opath, sizeof(opath)) == -1)
                return -1;

        ipath[strlen(LP_SD(lp)) + 1] = 't';
        opath[strlen(LP_SD(lp)) + 1] = 'c';

        return rename(ipath, opath);
}

/*
 * Check if a file size is acceptable.
 * Return -1 on error or if false (EFBIG or ENOSPC), 0 otherwise.
 */
static int
checksize(struct lp_printer *lp, size_t sz)
{
        struct statfs st;
        ssize_t len;
        size_t linesz = 0;
        off_t req, avail, minfree;
        char *line = NULL;
        const char *errstr;
        FILE *fp;
        int saved_errno;

        if (sz == 0) {
                errno = EINVAL;
                return -1;
        }

        /* Check printer limit. */
        if (lp->lp_mx && sz > (size_t)lp->lp_mx) {
                errno = EFBIG;
                return -1;
        }

        /*
         * Check for minfree.  Note that it does not really guarantee the
         * directory will not be filled up anyway, since it's not taking
         * other incoming files into account.
         */
        fp = lp_fopen(lp, "minfree");
        if (fp == NULL) {
                if (errno == ENOENT)
                        return 0;
                log_warn("%s: lp_fopen", __func__);
                return -1;
        }

        len = getline(&line, &linesz, fp);
        saved_errno = errno;
        (void)fclose(fp);
        if (len == -1) {
                errno = saved_errno;
                return 0;
        }

        if (line[len - 1] == '\n')
                line[len - 1] = '\0';
        minfree = strtonum(line, 0, INT_MAX, &errstr);
        free(line);

        if (errstr)
                return 0;

        if (statfs(LP_SD(lp), &st) == -1)
                return 0;

        req = sz / 512 + (sz % 512) ? 1 : 0;
        avail = st.f_bavail * (st.f_bsize / 512);
        if (avail < minfree || (avail - minfree) < req) {
                errno = ENOSPC;
                return -1;
        }

        return 0;
}