#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <netgroup.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "lpd.h"
#include "lp.h"
#include "log.h"
#include "proc.h"
struct lpr_recvfile {
TAILQ_ENTRY(lpr_recvfile) entry;
char *dfname;
};
struct lpr_recvjob {
TAILQ_ENTRY(lpr_recvjob) entry;
struct lp_printer lp;
uint32_t connid;
char *hostfrom;
char *cfname;
int dfcount;
size_t dfsize;
TAILQ_HEAD(, lpr_recvfile) df;
};
static void lpr_allowedhost(uint32_t, const struct sockaddr *);
static void lpr_allowedhost_res(uint32_t, const char *, const char *);
static int lpr_mkstemp(void);
static void lpr_displayq(uint32_t, const char *, int, struct lp_jobfilter *);
static void lpr_displayq_res(uint32_t, int, const char *, const char *);
static void lpr_rmjob(uint32_t, const char *, const char *,
struct lp_jobfilter *);
static void lpr_rmjob_res(uint32_t, int, const char *, const char *);
static void lpr_recvjob(uint32_t, const char*, const char *);
static void lpr_recvjob_res(uint32_t, int);
static void lpr_recvjob_cf(uint32_t, size_t, const char *);
static void lpr_recvjob_df(uint32_t, size_t, const char *);
static void lpr_recvjob_clear(uint32_t);
static void lpr_recvjob_commit(uint32_t);
static void lpr_recvjob_rollback(uint32_t);
static void lpr_recvjob_free(struct lpr_recvjob *);
static int matchaddr(const char *, const struct sockaddr *, int *);
static int cmpsockaddr(const struct sockaddr *, const struct sockaddr *);
static TAILQ_HEAD(, lpr_recvjob) recvjobs = TAILQ_HEAD_INITIALIZER(recvjobs);
void
lpr_dispatch_frontend(struct imsgproc *proc, struct imsg *imsg)
{
struct sockaddr_storage ss;
struct lp_jobfilter jf;
struct lp_printer lp;
const char *hostfrom, *prn, *filename, *agent;
uint32_t connid;
size_t size;
int lng, i;
connid = imsg->hdr.peerid;
switch (imsg->hdr.type) {
case IMSG_LPR_ALLOWEDHOST:
m_get_sockaddr(proc, (struct sockaddr *)&ss);
m_end(proc);
lpr_allowedhost(connid, (struct sockaddr *)&ss);
break;
case IMSG_LPR_DISPLAYQ:
memset(&jf, 0, sizeof(jf));
m_get_int(proc, &lng);
m_get_string(proc, &jf.hostfrom);
m_get_string(proc, &prn);
m_get_int(proc, &jf.njob);
for (i = 0; i < jf.njob; i++)
m_get_int(proc, &jf.jobs[i]);
m_get_int(proc, &jf.nuser);
for (i = 0; i < jf.nuser; i++)
m_get_string(proc, &jf.users[i]);
m_end(proc);
lpr_displayq(connid, prn, lng, &jf);
break;
case IMSG_LPR_PRINTJOB:
m_get_string(proc, &prn);
m_end(proc);
if (lp_getprinter(&lp, prn) == -1)
break;
lpr_printjob(lp.lp_name);
lp_clearprinter(&lp);
break;
case IMSG_LPR_RECVJOB:
m_get_string(proc, &hostfrom);
m_get_string(proc, &prn);
m_end(proc);
lpr_recvjob(connid, hostfrom, prn);
break;
case IMSG_LPR_RECVJOB_CLEAR:
m_end(proc);
lpr_recvjob_clear(connid);
break;
case IMSG_LPR_RECVJOB_CF:
m_get_size(proc, &size);
m_get_string(proc, &filename);
m_end(proc);
lpr_recvjob_cf(connid, size, filename);
break;
case IMSG_LPR_RECVJOB_DF:
m_get_size(proc, &size);
m_get_string(proc, &filename);
m_end(proc);
lpr_recvjob_df(connid, size, filename);
break;
case IMSG_LPR_RECVJOB_COMMIT:
m_end(proc);
lpr_recvjob_commit(connid);
break;
case IMSG_LPR_RECVJOB_ROLLBACK:
m_end(proc);
lpr_recvjob_rollback(connid);
break;
case IMSG_LPR_RMJOB:
memset(&jf, 0, sizeof(jf));
m_get_string(proc, &jf.hostfrom);
m_get_string(proc, &prn);
m_get_string(proc, &agent);
m_get_int(proc, &jf.njob);
for (i = 0; i < jf.njob; i++)
m_get_int(proc, &jf.jobs[i]);
m_get_int(proc, &jf.nuser);
for (i = 0; i < jf.nuser; i++)
m_get_string(proc, &jf.users[i]);
m_end(proc);
lpr_rmjob(connid, prn, agent, &jf);
break;
default:
fatalx("%s: unexpected imsg %s", __func__,
log_fmt_imsgtype(imsg->hdr.type));
}
}
void
lpr_shutdown()
{
struct lpr_recvjob *j;
while ((j = TAILQ_FIRST(&recvjobs))) {
lpr_recvjob_clear(j->connid);
lpr_recvjob_free(j);
}
}
void
lpr_printjob(const char *prn)
{
m_create(p_priv, IMSG_LPR_PRINTJOB, 0, 0, -1);
m_add_string(p_priv, prn);
m_close(p_priv);
}
static void
lpr_allowedhost(uint32_t connid, const struct sockaddr *sa)
{
FILE *fp;
size_t linesz = 0;
ssize_t linelen;
char host[NI_MAXHOST], addr[NI_MAXHOST], serv[NI_MAXSERV];
char dom[NI_MAXHOST], *lp, *ep, *line = NULL;
int e, rev = 0, ok = 0;
if (sa->sa_family == AF_UNIX) {
lpr_allowedhost_res(connid, lpd_hostname, NULL);
return;
}
host[0] = '\0';
if ((e = getnameinfo(sa, sa->sa_len, addr, sizeof(addr), serv,
sizeof(serv), NI_NUMERICHOST))) {
log_warnx("%s: could not print addr: %s", __func__,
gai_strerror(e));
lpr_allowedhost_res(connid, host, "Malformed address");
return;
}
if ((e = getnameinfo(sa, sa->sa_len, host, sizeof(host), NULL, 0,
NI_NAMEREQD))) {
if (e != EAI_NONAME)
log_warnx("%s: could not resolve %s: %s", __func__,
addr, gai_strerror(e));
lpr_allowedhost_res(connid, host,
"No hostname found for your address");
return;
}
if (!matchaddr(host, sa, &e)) {
if (e)
log_warnx("%s: getaddrinfo: %s: %s", __func__,
host, gai_strerror(e));
lpr_allowedhost_res(connid, host, e ?
"Cannot resolve your hostname" :
"Your hostname and your address do not match");
return;
}
if ((fp = fopen(_PATH_HOSTSLPD, "r")) == NULL) {
log_warn("%s: %s", __func__, _PATH_HOSTSLPD);
lpr_allowedhost_res(connid, host,
"Cannot access " _PATH_HOSTSLPD);
return;
}
dom[0] = '\0';
while ((linelen = getline(&line, &linesz, fp)) != -1) {
for (lp = line; *lp; lp++)
if (!isspace((unsigned char)*lp))
break;
if (*lp == '#' || *lp == '\0')
continue;
for (ep = lp + 1; *ep; ep++)
if (isspace((unsigned char)*ep) || *ep == '#') {
*ep = '\0';
break;
}
rev = 0;
switch (lp[0]) {
case '-':
case '+':
switch (lp[1]) {
case '\0':
ok = 1;
break;
case '@':
if (dom[0] == '\0')
getdomainname(dom, sizeof(dom));
ok = innetgr(lp + 2, host, NULL, dom);
break;
default:
ok = matchaddr(lp + 1, sa, NULL);
break;
}
if (lp[0] == '-')
ok = -ok;
break;
default:
ok = matchaddr(lp, sa, NULL);
break;
}
if (ok)
break;
}
free(line);
fclose(fp);
lpr_allowedhost_res(connid, host,
(ok > 0) ? NULL : "Access denied");
}
static void
lpr_allowedhost_res(uint32_t connid, const char *hostname, const char *reject)
{
m_create(p_frontend, IMSG_LPR_ALLOWEDHOST, connid, 0, -1);
m_add_string(p_frontend, hostname);
m_add_string(p_frontend, reject);
m_close(p_frontend);
}
static int
matchaddr(const char *host, const struct sockaddr *sa, int *gaierrno)
{
struct addrinfo hints, *res, *r;
int e, ok = 0;
memset(&hints, 0, sizeof(hints));
hints.ai_family = sa->sa_family;
hints.ai_socktype = SOCK_DGRAM;
if ((e = getaddrinfo(host, NULL, &hints, &res))) {
if (gaierrno)
*gaierrno = e;
return 0;
}
if (gaierrno)
*gaierrno = 0;
for (r = res; r; r = r->ai_next)
if (cmpsockaddr(sa, r->ai_addr) == 0) {
ok = 1;
break;
}
freeaddrinfo(res);
return ok;
}
static int
cmpsockaddr(const struct sockaddr *a, const struct sockaddr *b)
{
const void *aa, *ab;
size_t l;
if (a->sa_family != b->sa_family)
return (a->sa_family < b->sa_family) ? -1 : 1;
switch (a->sa_family) {
case AF_UNIX:
return 0;
case AF_INET:
aa = &(((const struct sockaddr_in*)a)->sin_addr);
ab = &(((const struct sockaddr_in*)b)->sin_addr);
l = sizeof(((const struct sockaddr_in*)a)->sin_addr);
return memcmp(aa, ab, l);
case AF_INET6:
aa = &(((const struct sockaddr_in6*)a)->sin6_addr);
ab = &(((const struct sockaddr_in6*)b)->sin6_addr);
l = sizeof(((const struct sockaddr_in*)a)->sin_addr);
return memcmp(aa, ab, l);
}
return 0;
}
static int
lpr_mkstemp(void)
{
char path[PATH_MAX];
int fd;
if (strlcpy(path, _PATH_TMP "lpd.XXXXXXXXXX", sizeof(path)) >=
sizeof(path)) {
log_warnx("%s: path too long", __func__);
return -1;
}
if ((fd = mkstemp(path)) == -1) {
log_warn("%s: mkstemp", __func__);
return -1;
}
(void)unlink(path);
return fd;
}
static void
lpr_displayq(uint32_t connid, const char *prn, int lng, struct lp_jobfilter *jf)
{
struct lp_printer lp;
char cmd[LPR_MAXCMDLEN], buf[16];
int fd, i;
if (lp_getprinter(&lp, prn) == -1) {
lpr_displayq_res(connid, -1, NULL, NULL);
return;
}
fd = lpr_mkstemp();
if (fd != -1) {
lp_displayq(fd, &lp, lng, jf);
if (lseek(fd, 0, SEEK_SET) == -1)
log_warn("%s: lseek", __func__);
}
if (lp.lp_type == PRN_LPR) {
snprintf(cmd, sizeof(cmd), "%c%s", lng?'\4':'\3', LP_RP(&lp));
for (i = 0; i < jf->nuser; i++) {
strlcat(cmd, " ", sizeof(cmd));
strlcat(cmd, jf->users[i], sizeof(cmd));
}
for (i = 0; i < jf->njob; i++) {
snprintf(buf, sizeof(buf), " %d", jf->jobs[i]);
strlcat(cmd, buf, sizeof(cmd));
}
lpr_displayq_res(connid, fd, lp.lp_host, cmd);
}
else
lpr_displayq_res(connid, fd, NULL, NULL);
lp_clearprinter(&lp);
}
static void
lpr_displayq_res(uint32_t connid, int fd, const char *host, const char *cmd)
{
m_create(p_frontend, IMSG_LPR_DISPLAYQ, connid, 0, fd);
m_add_string(p_frontend, host);
m_add_string(p_frontend, cmd);
m_close(p_frontend);
}
static void
lpr_rmjob(uint32_t connid, const char *prn, const char *agent,
struct lp_jobfilter *jf)
{
struct lp_printer lp;
char cmd[LPR_MAXCMDLEN], buf[16];
int fd, i, restart = 0;
if (lp_getprinter(&lp, prn) == -1) {
lpr_rmjob_res(connid, -1, NULL, NULL);
return;
}
fd = lpr_mkstemp();
if (fd != -1) {
restart = lp_rmjob(fd, &lp, agent, jf);
if (lseek(fd, 0, SEEK_SET) == -1)
log_warn("%s: lseek", __func__);
}
if (lp.lp_type == PRN_LPR) {
snprintf(cmd, sizeof(cmd), "\5%s %s", LP_RP(&lp), agent);
for (i = 0; i < jf->nuser; i++) {
strlcat(cmd, " ", sizeof(cmd));
strlcat(cmd, jf->users[i], sizeof(cmd));
}
for (i = 0; i < jf->njob; i++) {
snprintf(buf, sizeof(buf), " %d", jf->jobs[i]);
strlcat(cmd, buf, sizeof(cmd));
}
lpr_rmjob_res(connid, fd, lp.lp_host, cmd);
}
else
lpr_rmjob_res(connid, fd, NULL, NULL);
if (restart)
lpr_printjob(lp.lp_name);
lp_clearprinter(&lp);
}
static void
lpr_rmjob_res(uint32_t connid, int fd, const char *host, const char *cmd)
{
m_create(p_frontend, IMSG_LPR_RMJOB, connid, 0, fd);
m_add_string(p_frontend, host);
m_add_string(p_frontend, cmd);
m_close(p_frontend);
}
static void
lpr_recvjob(uint32_t connid, const char *hostfrom, const char *prn)
{
struct lpr_recvjob *j;
int qstate;
if ((j = calloc(1, sizeof(*j))) == NULL) {
log_warn("%s: calloc", __func__);
goto fail;
}
if (lp_getprinter(&j->lp, prn) == -1)
goto fail;
if (lp_getqueuestate(&j->lp, 0, &qstate) == -1) {
log_warnx("cannot get queue state");
goto fail;
}
if (qstate & LPQ_QUEUE_OFF)
goto fail;
if ((j->hostfrom = strdup(hostfrom)) == NULL) {
log_warn("%s: strdup", __func__);
goto fail;
}
j->connid = connid;
TAILQ_INIT(&j->df);
TAILQ_INSERT_TAIL(&recvjobs, j, entry);
lpr_recvjob_res(connid, LPR_ACK);
return;
fail:
if (j) {
lp_clearprinter(&j->lp);
free(j->hostfrom);
}
free(j);
lpr_recvjob_res(connid, LPR_NACK);
}
static void
lpr_recvjob_res(uint32_t connid, int ack)
{
m_create(p_frontend, IMSG_LPR_RECVJOB, connid, 0, -1);
m_add_int(p_frontend, ack);
m_close(p_frontend);
}
static void
lpr_recvjob_cf(uint32_t connid, size_t size, const char *filename)
{
struct lpr_recvjob *j;
char fname[PATH_MAX];
int fd;
fd = -1;
TAILQ_FOREACH(j, &recvjobs, entry)
if (j->connid == connid)
break;
if (j == NULL) {
log_warnx("invalid job id");
goto done;
}
if (j->cfname) {
log_warnx("duplicate control file");
goto done;
}
if (!lp_validfilename(filename, 1)) {
log_warnx("invalid control file name %s", filename);
goto done;
}
(void)strlcpy(fname, filename, 7);
if (strlcat(fname, j->hostfrom, sizeof(fname)) >= sizeof(fname)) {
log_warnx("filename too long");
goto done;
}
if ((j->cfname = strdup(fname)) == NULL) {
log_warn("%s: stdrup", __func__);
goto done;
}
fd = lp_create(&j->lp, 1, size, j->cfname);
if (fd == -1) {
if (errno == EFBIG || errno == ENOSPC)
log_warn("rejected control file");
else
log_warnx("cannot create control file");
free(j->cfname);
j->cfname = NULL;
}
done:
m_create(p_frontend, IMSG_LPR_RECVJOB_CF, connid, 0, fd);
m_add_int(p_frontend, (fd == -1) ? LPR_NACK : LPR_ACK);
m_add_size(p_frontend, size);
m_close(p_frontend);
}
static void
lpr_recvjob_df(uint32_t connid, size_t size, const char *filename)
{
struct lpr_recvfile *f;
struct lpr_recvjob *j;
int fd;
fd = -1;
TAILQ_FOREACH(j, &recvjobs, entry)
if (j->connid == connid)
break;
if (j == NULL) {
log_warnx("invalid job id");
goto done;
}
if (!lp_validfilename(filename, 0)) {
log_warnx("invalid data file name %s", filename);
goto done;
}
if ((f = calloc(1, sizeof(*f))) == NULL) {
log_warn("%s: calloc", __func__);
goto done;
}
if ((f->dfname = strdup(filename)) == NULL) {
log_warn("%s: strdup", __func__);
free(f);
goto done;
}
fd = lp_create(&j->lp, 0, size, f->dfname);
if (fd == -1) {
if (errno == EFBIG || errno == ENOSPC)
log_warn("rejected data file");
else
log_warnx("cannot create data file");
free(f->dfname);
free(f);
goto done;
}
j->dfcount += 1;
j->dfsize += size;
TAILQ_INSERT_TAIL(&j->df, f, entry);
done:
m_create(p_frontend, IMSG_LPR_RECVJOB_DF, connid, 0, fd);
m_add_int(p_frontend, (fd == -1) ? LPR_NACK : LPR_ACK);
m_add_size(p_frontend, size);
m_close(p_frontend);
}
static void
lpr_recvjob_clear(uint32_t connid)
{
struct lpr_recvfile *f;
struct lpr_recvjob *j;
TAILQ_FOREACH(j, &recvjobs, entry)
if (j->connid == connid)
break;
if (j == NULL) {
log_warnx("invalid job id");
return;
}
if (j->cfname) {
j->cfname[0] = 'c';
if (lp_unlink(&j->lp, j->cfname) == -1)
log_warn("cannot unlink %s", j->cfname);
j->cfname[0] = 't';
if (lp_unlink(&j->lp, j->cfname) == 1)
log_warn("cannot unlink %s", j->cfname);
free(j->cfname);
j->cfname = NULL;
}
while ((f = TAILQ_FIRST(&j->df))) {
TAILQ_REMOVE(&j->df, f, entry);
if (lp_unlink(&j->lp, f->dfname) == -1)
log_warn("cannot unlink %s", f->dfname);
free(f->dfname);
free(f);
}
}
static void
lpr_recvjob_commit(uint32_t connid)
{
struct lpr_recvjob *j;
int ack;
ack = LPR_NACK;
TAILQ_FOREACH(j, &recvjobs, entry)
if (j->connid == connid)
break;
if (j == NULL) {
log_warnx("invalid job id");
return;
}
if (!j->cfname) {
log_warnx("no control file received from %s", j->hostfrom);
lpr_recvjob_clear(connid);
lpr_recvjob_free(j);
return;
}
if ((lp_commit(&j->lp, j->cfname) == -1)) {
log_warn("cannot commit %s", j->cfname);
lpr_recvjob_clear(connid);
lpr_recvjob_free(j);
return;
}
log_info("received job %s printer=%s host=%s files=%d size=%zu",
j->cfname, j->lp.lp_name, j->hostfrom, j->dfcount, j->dfsize);
lpr_printjob(j->lp.lp_name);
lpr_recvjob_free(j);
}
static void
lpr_recvjob_rollback(uint32_t connid)
{
struct lpr_recvjob *j;
lpr_recvjob_clear(connid);
TAILQ_FOREACH(j, &recvjobs, entry)
if (j->connid == connid)
break;
if (j == NULL) {
log_warnx("invalid job id");
return;
}
lpr_recvjob_free(j);
}
static void
lpr_recvjob_free(struct lpr_recvjob *j)
{
struct lpr_recvfile *f;
TAILQ_REMOVE(&recvjobs, j, entry);
lp_clearprinter(&j->lp);
free(j->hostfrom);
free(j->cfname);
while ((f = TAILQ_FIRST(&j->df))) {
TAILQ_REMOVE(&j->df, f, entry);
free(f->dfname);
free(f);
}
}
