d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4cbba6ae24
freebsd-dev/usr.sbin/lpr/lpd/printjob.c
Pedro F. Giffuni 8a16b7a18f General further adoption of SPDX licensing ID tags. 
Mainly focus on files that use BSD 3-Clause license.

The Software Package Data Exchange (SPDX) group provides a specification
to make it easier for automated tools to detect and summarize well known
opensource licenses. We are gradually adopting the specification, noting
that the tags are considered only advisory and do not, in any way,
superceed or replace the license texts.

Special thanks to Wind River for providing access to "The Duke of
Highlander" tool: an older (2014) run over FreeBSD tree was useful as a
starting point.
2017-11-20 19:49:47 +00:00

2023 lines
52 KiB
C
Raw Blame History

/*-
* SPDX-License-Identifier: BSD-3-Clause
*
* Copyright (c) 1983, 1993
* The Regents of the University of California. All rights reserved.
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef lint
static const char copyright[] =
"@(#) Copyright (c) 1983, 1993\n\
The Regents of the University of California. All rights reserved.\n";
#endif /* not lint */
#if 0
#ifndef lint
static char sccsid[] = "@(#)printjob.c 8.7 (Berkeley) 5/10/95";
#endif /* not lint */
#endif
#include "lp.cdefs.h" /* A cross-platform version of <sys/cdefs.h> */
__FBSDID("$FreeBSD$");
/*
* printjob -- print jobs in the queue.
*
* NOTE: the lock file is used to pass information to lpq and lprm.
* it does not need to be removed because file locks are dynamic.
*/
#include <sys/param.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <unistd.h>
#include <signal.h>
#include <syslog.h>
#include <fcntl.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <time.h>
#include "lp.h"
#include "lp.local.h"
#include "pathnames.h"
#include "extern.h"
#define DORETURN 0 /* dofork should return "can't fork" error */
#define DOABORT 1 /* dofork should just die if fork() fails */
/*
* The buffer size to use when reading/writing spool files.
*/
#define SPL_BUFSIZ BUFSIZ
/*
* Error tokens
*/
#define REPRINT -2
#define ERROR -1
#define OK 0
#define FATALERR 1
#define NOACCT 2
#define FILTERERR 3
#define ACCESS 4
static dev_t fdev; /* device of file pointed to by symlink */
static ino_t fino; /* inode of file pointed to by symlink */
static FILE *cfp; /* control file */
static pid_t of_pid; /* process id of output filter, if any */
static int child; /* id of any filters */
static int job_dfcnt; /* count of datafiles in current user job */
static int lfd; /* lock file descriptor */
static int ofd; /* output filter file descriptor */
static int tfd = -1; /* output filter temp file output */
static int pfd; /* prstatic inter file descriptor */
static int prchild; /* id of pr process */
static char title[80]; /* ``pr'' title */
static char locale[80]; /* ``pr'' locale */
/* these two are set from pp->daemon_user, but only if they are needed */
static char *daemon_uname; /* set from pwd->pw_name */
static int daemon_defgid;
static char class[32]; /* classification field */
static char origin_host[MAXHOSTNAMELEN]; /* user's host machine */
/* indentation size in static characters */
static char indent[10] = "-i0";
static char jobname[100]; /* job or file name */
static char length[10] = "-l"; /* page length in lines */
static char logname[32]; /* user's login name */
static char pxlength[10] = "-y"; /* page length in pixels */
static char pxwidth[10] = "-x"; /* page width in pixels */
/* tempstderr is the filename used to catch stderr from exec-ing filters */
static char tempstderr[] = "errs.XXXXXXX";
static char width[10] = "-w"; /* page width in static characters */
#define TFILENAME "fltXXXXXX"
static char tfile[] = TFILENAME; /* file name for filter output */
static void abortpr(int _signo);
static void alarmhandler(int _signo);
static void banner(struct printer *_pp, char *_name1, char *_name2);
static int dofork(const struct printer *_pp, int _action);
static int dropit(int _c);
static int execfilter(struct printer *_pp, char *_f_cmd, char **_f_av,
int _infd, int _outfd);
static void init(struct printer *_pp);
static void openpr(const struct printer *_pp);
static void opennet(const struct printer *_pp);
static void opentty(const struct printer *_pp);
static void openrem(const struct printer *pp);
static int print(struct printer *_pp, int _format, char *_file);
static int printit(struct printer *_pp, char *_file);
static void pstatus(const struct printer *_pp, const char *_msg, ...)
__printflike(2, 3);
static char response(const struct printer *_pp);
static void scan_out(struct printer *_pp, int _scfd, char *_scsp,
int _dlm);
static char *scnline(int _key, char *_p, int _c);
static int sendfile(struct printer *_pp, int _type, char *_file,
char _format, int _copyreq);
static int sendit(struct printer *_pp, char *_file);
static void sendmail(struct printer *_pp, char *_userid, int _bombed);
static void setty(const struct printer *_pp);
static void wait4data(struct printer *_pp, const char *_dfile);
void
printjob(struct printer *pp)
{
struct stat stb;
register struct jobqueue *q, **qp;
struct jobqueue **queue;
register int i, nitems;
off_t pidoff;
pid_t printpid;
int errcnt, jobcount, statok, tempfd;
jobcount = 0;
init(pp); /* set up capabilities */
(void) write(STDOUT_FILENO, "", 1); /* ack that daemon is started */
(void) close(STDERR_FILENO); /* set up log file */
if (open(pp->log_file, O_WRONLY|O_APPEND, LOG_FILE_MODE) < 0) {
syslog(LOG_ERR, "%s: open(%s): %m", pp->printer,
pp->log_file);
(void) open(_PATH_DEVNULL, O_WRONLY);
}
if(setgid(getegid()) != 0) err(1, "setgid() failed");
printpid = getpid(); /* for use with lprm */
setpgid((pid_t)0, printpid);
/*
* At initial lpd startup, printjob may be called with various
* signal handlers in effect. After that initial startup, any
* calls to printjob will have a *different* set of signal-handlers
* in effect. Make sure all handlers are the ones we want.
*/
signal(SIGCHLD, SIG_DFL);
signal(SIGHUP, abortpr);
signal(SIGINT, abortpr);
signal(SIGQUIT, abortpr);
signal(SIGTERM, abortpr);
/*
* uses short form file names
*/
if (chdir(pp->spool_dir) < 0) {
syslog(LOG_ERR, "%s: chdir(%s): %m", pp->printer,
pp->spool_dir);
exit(1);
}
statok = stat(pp->lock_file, &stb);
if (statok == 0 && (stb.st_mode & LFM_PRINT_DIS))
exit(0); /* printing disabled */
umask(S_IWOTH);
lfd = open(pp->lock_file, O_WRONLY|O_CREAT|O_EXLOCK|O_NONBLOCK,
LOCK_FILE_MODE);
if (lfd < 0) {
if (errno == EWOULDBLOCK) /* active daemon present */
exit(0);
syslog(LOG_ERR, "%s: open(%s): %m", pp->printer,
pp->lock_file);
exit(1);
}
/*
* If the initial call to stat() failed, then lock_file will have
* been created by open(). Update &stb to match that new file.
*/
if (statok != 0)
statok = stat(pp->lock_file, &stb);
/* turn off non-blocking mode (was turned on for lock effects only) */
if (fcntl(lfd, F_SETFL, 0) < 0) {
syslog(LOG_ERR, "%s: fcntl(%s): %m", pp->printer,
pp->lock_file);
exit(1);
}
ftruncate(lfd, 0);
/*
* write process id for others to know
*/
sprintf(line, "%u\n", printpid);
pidoff = i = strlen(line);
if (write(lfd, line, i) != i) {
syslog(LOG_ERR, "%s: write(%s): %m", pp->printer,
pp->lock_file);
exit(1);
}
/*
* search the spool directory for work and sort by queue order.
*/
if ((nitems = getq(pp, &queue)) < 0) {
syslog(LOG_ERR, "%s: can't scan %s", pp->printer,
pp->spool_dir);
exit(1);
}
if (nitems == 0) /* no work to do */
exit(0);
if (stb.st_mode & LFM_RESET_QUE) { /* reset queue flag */
if (fchmod(lfd, stb.st_mode & ~LFM_RESET_QUE) < 0)
syslog(LOG_ERR, "%s: fchmod(%s): %m", pp->printer,
pp->lock_file);
}
/* create a file which will be used to hold stderr from filters */
if ((tempfd = mkstemp(tempstderr)) == -1) {
syslog(LOG_ERR, "%s: mkstemp(%s): %m", pp->printer,
tempstderr);
exit(1);
}
if ((i = fchmod(tempfd, 0664)) == -1) {
syslog(LOG_ERR, "%s: fchmod(%s): %m", pp->printer,
tempstderr);
exit(1);
}
/* lpd doesn't need it to be open, it just needs it to exist */
close(tempfd);
openpr(pp); /* open printer or remote */
again:
/*
* we found something to do now do it --
* write the name of the current control file into the lock file
* so the spool queue program can tell what we're working on
*/
for (qp = queue; nitems--; free((char *) q)) {
q = *qp++;
if (stat(q->job_cfname, &stb) < 0)
continue;
errcnt = 0;
restart:
(void) lseek(lfd, pidoff, 0);
(void) snprintf(line, sizeof(line), "%s\n", q->job_cfname);
i = strlen(line);
if (write(lfd, line, i) != i)
syslog(LOG_ERR, "%s: write(%s): %m", pp->printer,
pp->lock_file);
if (!pp->remote)
i = printit(pp, q->job_cfname);
else
i = sendit(pp, q->job_cfname);
/*
* Check to see if we are supposed to stop printing or
* if we are to rebuild the queue.
*/
if (fstat(lfd, &stb) == 0) {
/* stop printing before starting next job? */
if (stb.st_mode & LFM_PRINT_DIS)
goto done;
/* rebuild queue (after lpc topq) */
if (stb.st_mode & LFM_RESET_QUE) {
for (free(q); nitems--; free(q))
q = *qp++;
if (fchmod(lfd, stb.st_mode & ~LFM_RESET_QUE)
< 0)
syslog(LOG_WARNING,
"%s: fchmod(%s): %m",
pp->printer, pp->lock_file);
break;
}
}
if (i == OK) /* all files of this job printed */
jobcount++;
else if (i == REPRINT && ++errcnt < 5) {
/* try reprinting the job */
syslog(LOG_INFO, "restarting %s", pp->printer);
if (of_pid > 0) {
kill(of_pid, SIGCONT); /* to be sure */
(void) close(ofd);
while ((i = wait(NULL)) > 0 && i != of_pid)
;
if (i < 0)
syslog(LOG_WARNING, "%s: after kill(of=%d), wait() returned: %m",
pp->printer, of_pid);
of_pid = 0;
}
(void) close(pfd); /* close printer */
if (ftruncate(lfd, pidoff) < 0)
syslog(LOG_WARNING, "%s: ftruncate(%s): %m",
pp->printer, pp->lock_file);
openpr(pp); /* try to reopen printer */
goto restart;
} else {
syslog(LOG_WARNING, "%s: job could not be %s (%s)",
pp->printer,
pp->remote ? "sent to remote host" : "printed",
q->job_cfname);
if (i == REPRINT) {
/* ensure we don't attempt this job again */
(void) unlink(q->job_cfname);
q->job_cfname[0] = 'd';
(void) unlink(q->job_cfname);
if (logname[0])
sendmail(pp, logname, FATALERR);
}
}
}
free(queue);
/*
* search the spool directory for more work.
*/
if ((nitems = getq(pp, &queue)) < 0) {
syslog(LOG_ERR, "%s: can't scan %s", pp->printer,
pp->spool_dir);
exit(1);
}
if (nitems == 0) { /* no more work to do */
done:
if (jobcount > 0) { /* jobs actually printed */
if (!pp->no_formfeed && !pp->tof)
(void) write(ofd, pp->form_feed,
strlen(pp->form_feed));
if (pp->trailer != NULL) /* output trailer */
(void) write(ofd, pp->trailer,
strlen(pp->trailer));
}
(void) close(ofd);
(void) wait(NULL);
(void) unlink(tempstderr);
exit(0);
}
goto again;
}
char fonts[4][50]; /* fonts for troff */
char ifonts[4][40] = {
_PATH_VFONTR,
_PATH_VFONTI,
_PATH_VFONTB,
_PATH_VFONTS,
};
/*
* The remaining part is the reading of the control file (cf)
* and performing the various actions.
*/
static int
printit(struct printer *pp, char *file)
{
register int i;
char *cp;
int bombed, didignorehdr;
bombed = OK;
didignorehdr = 0;
/*
* open control file; ignore if no longer there.
*/
if ((cfp = fopen(file, "r")) == NULL) {
syslog(LOG_INFO, "%s: fopen(%s): %m", pp->printer, file);
return (OK);
}
/*
* Reset troff fonts.
*/
for (i = 0; i < 4; i++)
strcpy(fonts[i], ifonts[i]);
sprintf(&width[2], "%ld", pp->page_width);
strcpy(indent+2, "0");
/* initialize job-specific count of datafiles processed */
job_dfcnt = 0;
/*
* read the control file for work to do
*
* file format -- first character in the line is a command
* rest of the line is the argument.
* valid commands are:
*
* S -- "stat info" for symbolic link protection
* J -- "job name" on banner page
* C -- "class name" on banner page
* L -- "literal" user's name to print on banner
* T -- "title" for pr
* H -- "host name" of machine where lpr was done
* P -- "person" user's login name
* I -- "indent" amount to indent output
* R -- laser dpi "resolution"
* f -- "file name" name of text file to print
* l -- "file name" text file with control chars
* o -- "file name" postscript file, according to
* the RFC. Here it is treated like an 'f'.
* p -- "file name" text file to print with pr(1)
* t -- "file name" troff(1) file to print
* n -- "file name" ditroff(1) file to print
* d -- "file name" dvi file to print
* g -- "file name" plot(1G) file to print
* v -- "file name" plain raster file to print
* c -- "file name" cifplot file to print
* 1 -- "R font file" for troff
* 2 -- "I font file" for troff
* 3 -- "B font file" for troff
* 4 -- "S font file" for troff
* N -- "name" of file (used by lpq)
* U -- "unlink" name of file to remove
* (after we print it. (Pass 2 only)).
* M -- "mail" to user when done printing
* Z -- "locale" for pr
*
* get_line reads a line and expands tabs to blanks
*/
/* pass 1 */
while (get_line(cfp))
switch (line[0]) {
case 'H':
strlcpy(origin_host, line + 1, sizeof(origin_host));
if (class[0] == '\0') {
strlcpy(class, line+1, sizeof(class));
}
continue;
case 'P':
strlcpy(logname, line + 1, sizeof(logname));
if (pp->restricted) { /* restricted */
if (getpwnam(logname) == NULL) {
bombed = NOACCT;
sendmail(pp, line+1, bombed);
goto pass2;
}
}
continue;
case 'S':
cp = line+1;
i = 0;
while (*cp >= '0' && *cp <= '9')
i = i * 10 + (*cp++ - '0');
fdev = i;
cp++;
i = 0;
while (*cp >= '0' && *cp <= '9')
i = i * 10 + (*cp++ - '0');
fino = i;
continue;
case 'J':
if (line[1] != '\0') {
strlcpy(jobname, line + 1, sizeof(jobname));
} else
strcpy(jobname, " ");
continue;
case 'C':
if (line[1] != '\0')
strlcpy(class, line + 1, sizeof(class));
else if (class[0] == '\0') {
/* XXX - why call gethostname instead of
* just strlcpy'ing local_host? */
gethostname(class, sizeof(class));
class[sizeof(class) - 1] = '\0';
}
continue;
case 'T': /* header title for pr */
strlcpy(title, line + 1, sizeof(title));
continue;
case 'L': /* identification line */
if (!pp->no_header && !pp->header_last)
banner(pp, line+1, jobname);
continue;
case '1': /* troff fonts */
case '2':
case '3':
case '4':
if (line[1] != '\0') {
strlcpy(fonts[line[0]-'1'], line + 1,
(size_t)50);
}
continue;
case 'W': /* page width */
strlcpy(width+2, line + 1, sizeof(width) - 2);
continue;
case 'I': /* indent amount */
strlcpy(indent+2, line + 1, sizeof(indent) - 2);
continue;
case 'Z': /* locale for pr */
strlcpy(locale, line + 1, sizeof(locale));
continue;
default: /* some file to print */
/* only lowercase cmd-codes include a file-to-print */
if ((line[0] < 'a') || (line[0] > 'z')) {
/* ignore any other lines */
if (lflag <= 1)
continue;
if (!didignorehdr) {
syslog(LOG_INFO, "%s: in %s :",
pp->printer, file);
didignorehdr = 1;
}
syslog(LOG_INFO, "%s: ignoring line: '%c' %s",
pp->printer, line[0], &line[1]);
continue;
}
i = print(pp, line[0], line+1);
switch (i) {
case ERROR:
if (bombed == OK)
bombed = FATALERR;
break;
case REPRINT:
(void) fclose(cfp);
return (REPRINT);
case FILTERERR:
case ACCESS:
bombed = i;
sendmail(pp, logname, bombed);
}
title[0] = '\0';
continue;
case 'N':
case 'U':
case 'M':
case 'R':
continue;
}
/* pass 2 */
pass2:
fseek(cfp, 0L, 0);
while (get_line(cfp))
switch (line[0]) {
case 'L': /* identification line */
if (!pp->no_header && pp->header_last)
banner(pp, line+1, jobname);
continue;
case 'M':
if (bombed < NOACCT) /* already sent if >= NOACCT */
sendmail(pp, line+1, bombed);
continue;
case 'U':
if (strchr(line+1, '/'))
continue;
(void) unlink(line+1);
}
/*
* clean-up in case another control file exists
*/
(void) fclose(cfp);
(void) unlink(file);
return (bombed == OK ? OK : ERROR);
}
/*
* Print a file.
* Set up the chain [ PR [ | {IF, OF} ] ] or {IF, RF, TF, NF, DF, CF, VF}.
* Return -1 if a non-recoverable error occurred,
* 2 if the filter detected some errors (but printed the job anyway),
* 1 if we should try to reprint this job and
* 0 if all is well.
* Note: all filters take stdin as the file, stdout as the printer,
* stderr as the log file, and must not ignore SIGINT.
*/
static int
print(struct printer *pp, int format, char *file)
{
register int n, i;
register char *prog;
int fi, fo;
FILE *fp;
char *av[15], buf[SPL_BUFSIZ];
pid_t wpid;
int p[2], retcode, stopped, wstatus, wstatus_set;
struct stat stb;
/* Make sure the entire data file has arrived. */
wait4data(pp, file);
if (lstat(file, &stb) < 0 || (fi = open(file, O_RDONLY)) < 0) {
syslog(LOG_INFO, "%s: unable to open %s ('%c' line)",
pp->printer, file, format);
return (ERROR);
}
/*
* Check to see if data file is a symbolic link. If so, it should
* still point to the same file or someone is trying to print
* something he shouldn't.
*/
if ((stb.st_mode & S_IFMT) == S_IFLNK && fstat(fi, &stb) == 0 &&
(stb.st_dev != fdev || stb.st_ino != fino))
return (ACCESS);
job_dfcnt++; /* increment datafile counter for this job */
stopped = 0; /* output filter is not stopped */
/* everything seems OK, start it up */
if (!pp->no_formfeed && !pp->tof) { /* start on a fresh page */
(void) write(ofd, pp->form_feed, strlen(pp->form_feed));
pp->tof = 1;
}
if (pp->filters[LPF_INPUT] == NULL
&& (format == 'f' || format == 'l' || format == 'o')) {
pp->tof = 0;
while ((n = read(fi, buf, SPL_BUFSIZ)) > 0)
if (write(ofd, buf, n) != n) {
(void) close(fi);
return (REPRINT);
}
(void) close(fi);
return (OK);
}
switch (format) {
case 'p': /* print file using 'pr' */
if (pp->filters[LPF_INPUT] == NULL) { /* use output filter */
prog = _PATH_PR;
i = 0;
av[i++] = "pr";
av[i++] = width;
av[i++] = length;
av[i++] = "-h";
av[i++] = *title ? title : " ";
av[i++] = "-L";
av[i++] = *locale ? locale : "C";
av[i++] = "-F";
av[i] = NULL;
fo = ofd;
goto start;
}
pipe(p);
if ((prchild = dofork(pp, DORETURN)) == 0) { /* child */
dup2(fi, STDIN_FILENO); /* file is stdin */
dup2(p[1], STDOUT_FILENO); /* pipe is stdout */
closelog();
closeallfds(3);
execl(_PATH_PR, "pr", width, length,
"-h", *title ? title : " ",
"-L", *locale ? locale : "C",
"-F", (char *)0);
syslog(LOG_ERR, "cannot execl %s", _PATH_PR);
exit(2);
}
(void) close(p[1]); /* close output side */
(void) close(fi);
if (prchild < 0) {
prchild = 0;
(void) close(p[0]);
return (ERROR);
}
fi = p[0]; /* use pipe for input */
case 'f': /* print plain text file */
prog = pp->filters[LPF_INPUT];
av[1] = width;
av[2] = length;
av[3] = indent;
n = 4;
break;
case 'o': /* print postscript file */
/*
* Treat this as a "plain file with control characters", and
* assume the standard LPF_INPUT filter will recognize that
* the data is postscript and know what to do with it. These
* 'o'-file requests could come from MacOS 10.1 systems.
* (later versions of MacOS 10 will explicitly use 'l')
* A postscript file can contain binary data, which is why 'l'
* is somewhat more appropriate than 'f'.
*/
/* FALLTHROUGH */
case 'l': /* like 'f' but pass control characters */
prog = pp->filters[LPF_INPUT];
av[1] = "-c";
av[2] = width;
av[3] = length;
av[4] = indent;
n = 5;
break;
case 'r': /* print a fortran text file */
prog = pp->filters[LPF_FORTRAN];
av[1] = width;
av[2] = length;
n = 3;
break;
case 't': /* print troff output */
case 'n': /* print ditroff output */
case 'd': /* print tex output */
(void) unlink(".railmag");
if ((fo = creat(".railmag", FILMOD)) < 0) {
syslog(LOG_ERR, "%s: cannot create .railmag",
pp->printer);
(void) unlink(".railmag");
} else {
for (n = 0; n < 4; n++) {
if (fonts[n][0] != '/')
(void) write(fo, _PATH_VFONT,
sizeof(_PATH_VFONT) - 1);
(void) write(fo, fonts[n], strlen(fonts[n]));
(void) write(fo, "\n", 1);
}
(void) close(fo);
}
prog = (format == 't') ? pp->filters[LPF_TROFF]
: ((format == 'n') ? pp->filters[LPF_DITROFF]
: pp->filters[LPF_DVI]);
av[1] = pxwidth;
av[2] = pxlength;
n = 3;
break;
case 'c': /* print cifplot output */
prog = pp->filters[LPF_CIFPLOT];
av[1] = pxwidth;
av[2] = pxlength;
n = 3;
break;
case 'g': /* print plot(1G) output */
prog = pp->filters[LPF_GRAPH];
av[1] = pxwidth;
av[2] = pxlength;
n = 3;
break;
case 'v': /* print raster output */
prog = pp->filters[LPF_RASTER];
av[1] = pxwidth;
av[2] = pxlength;
n = 3;
break;
default:
(void) close(fi);
syslog(LOG_ERR, "%s: illegal format character '%c'",
pp->printer, format);
return (ERROR);
}
if (prog == NULL) {
(void) close(fi);
syslog(LOG_ERR,
"%s: no filter found in printcap for format character '%c'",
pp->printer, format);
return (ERROR);
}
if ((av[0] = strrchr(prog, '/')) != NULL)
av[0]++;
else
av[0] = prog;
av[n++] = "-n";
av[n++] = logname;
av[n++] = "-h";
av[n++] = origin_host;
av[n++] = pp->acct_file;
av[n] = NULL;
fo = pfd;
if (of_pid > 0) { /* stop output filter */
write(ofd, "\031\1", 2);
while ((wpid =
wait3(&wstatus, WUNTRACED, 0)) > 0 && wpid != of_pid)
;
if (wpid < 0)
syslog(LOG_WARNING,
"%s: after stopping 'of', wait3() returned: %m",
pp->printer);
else if (!WIFSTOPPED(wstatus)) {
(void) close(fi);
syslog(LOG_WARNING, "%s: output filter died "
"(pid=%d retcode=%d termsig=%d)",
pp->printer, of_pid, WEXITSTATUS(wstatus),
WTERMSIG(wstatus));
return (REPRINT);
}
stopped++;
}
start:
if ((child = dofork(pp, DORETURN)) == 0) { /* child */
dup2(fi, STDIN_FILENO);
dup2(fo, STDOUT_FILENO);
/* setup stderr for the filter (child process)
* so it goes to our temporary errors file */
n = open(tempstderr, O_WRONLY|O_TRUNC, 0664);
if (n >= 0)
dup2(n, STDERR_FILENO);
closelog();
closeallfds(3);
execv(prog, av);
syslog(LOG_ERR, "%s: cannot execv(%s): %m", pp->printer,
prog);
exit(2);
}
(void) close(fi);
wstatus_set = 0;
if (child < 0)
retcode = 100;
else {
while ((wpid = wait(&wstatus)) > 0 && wpid != child)
;
if (wpid < 0) {
retcode = 100;
syslog(LOG_WARNING,
"%s: after execv(%s), wait() returned: %m",
pp->printer, prog);
} else {
wstatus_set = 1;
retcode = WEXITSTATUS(wstatus);
}
}
child = 0;
prchild = 0;
if (stopped) { /* restart output filter */
if (kill(of_pid, SIGCONT) < 0) {
syslog(LOG_ERR, "cannot restart output filter");
exit(1);
}
}
pp->tof = 0;
/* Copy the filter's output to "lf" logfile */
if ((fp = fopen(tempstderr, "r"))) {
while (fgets(buf, sizeof(buf), fp))
fputs(buf, stderr);
fclose(fp);
}
if (wstatus_set && !WIFEXITED(wstatus)) {
syslog(LOG_WARNING, "%s: filter '%c' terminated (termsig=%d)",
pp->printer, format, WTERMSIG(wstatus));
return (ERROR);
}
switch (retcode) {
case 0:
pp->tof = 1;
return (OK);
case 1:
return (REPRINT);
case 2:
return (ERROR);
default:
syslog(LOG_WARNING, "%s: filter '%c' exited (retcode=%d)",
pp->printer, format, retcode);
return (FILTERERR);
}
}
/*
* Send the daemon control file (cf) and any data files.
* Return -1 if a non-recoverable error occurred, 1 if a recoverable error and
* 0 if all is well.
*/
static int
sendit(struct printer *pp, char *file)
{
int dfcopies, err, i;
char *cp, last[sizeof(line)];
/*
* open control file
*/
if ((cfp = fopen(file, "r")) == NULL)
return (OK);
/* initialize job-specific count of datafiles processed */
job_dfcnt = 0;
/*
* read the control file for work to do
*
* file format -- first character in the line is a command
* rest of the line is the argument.
* commands of interest are:
*
* a-z -- "file name" name of file to print
* U -- "unlink" name of file to remove
* (after we print it. (Pass 2 only)).
*/
/*
* pass 1
*/
err = OK;
while (get_line(cfp)) {
again:
if (line[0] == 'S') {
cp = line+1;
i = 0;
while (*cp >= '0' && *cp <= '9')
i = i * 10 + (*cp++ - '0');
fdev = i;
cp++;
i = 0;
while (*cp >= '0' && *cp <= '9')
i = i * 10 + (*cp++ - '0');
fino = i;
} else if (line[0] == 'H') {
strlcpy(origin_host, line + 1, sizeof(origin_host));
if (class[0] == '\0') {
strlcpy(class, line + 1, sizeof(class));
}
} else if (line[0] == 'P') {
strlcpy(logname, line + 1, sizeof(logname));
if (pp->restricted) { /* restricted */
if (getpwnam(logname) == NULL) {
sendmail(pp, line+1, NOACCT);
err = ERROR;
break;
}
}
} else if (line[0] == 'I') {
strlcpy(indent+2, line + 1, sizeof(indent) - 2);
} else if (line[0] >= 'a' && line[0] <= 'z') {
dfcopies = 1;
strcpy(last, line);
while ((i = get_line(cfp)) != 0) {
if (strcmp(last, line) != 0)
break;
dfcopies++;
}
switch (sendfile(pp, '\3', last+1, *last, dfcopies)) {
case OK:
if (i)
goto again;
break;
case REPRINT:
(void) fclose(cfp);
return (REPRINT);
case ACCESS:
sendmail(pp, logname, ACCESS);
case ERROR:
err = ERROR;
}
break;
}
}
if (err == OK && sendfile(pp, '\2', file, '\0', 1) > 0) {
(void) fclose(cfp);
return (REPRINT);
}
/*
* pass 2
*/
fseek(cfp, 0L, 0);
while (get_line(cfp))
if (line[0] == 'U' && !strchr(line+1, '/'))
(void) unlink(line+1);
/*
* clean-up in case another control file exists
*/
(void) fclose(cfp);
(void) unlink(file);
return (err);
}
/*
* Send a data file to the remote machine and spool it.
* Return positive if we should try resending.
*/
static int
sendfile(struct printer *pp, int type, char *file, char format, int copyreq)
{
int i, amt;
struct stat stb;
char *av[15], *filtcmd;
char buf[SPL_BUFSIZ], opt_c[4], opt_h[4], opt_n[4];
int copycnt, filtstat, narg, resp, sfd, sfres, sizerr, statrc;
/* Make sure the entire data file has arrived. */
wait4data(pp, file);
statrc = lstat(file, &stb);
if (statrc < 0) {
syslog(LOG_ERR, "%s: error from lstat(%s): %m",
pp->printer, file);
return (ERROR);
}
sfd = open(file, O_RDONLY);
if (sfd < 0) {
syslog(LOG_ERR, "%s: error from open(%s,O_RDONLY): %m",
pp->printer, file);
return (ERROR);
}
/*
* Check to see if data file is a symbolic link. If so, it should
* still point to the same file or someone is trying to print something
* he shouldn't.
*/
if ((stb.st_mode & S_IFMT) == S_IFLNK && fstat(sfd, &stb) == 0 &&
(stb.st_dev != fdev || stb.st_ino != fino)) {
close(sfd);
return (ACCESS);
}
/* Everything seems OK for reading the file, now to send it */
filtcmd = NULL;
sizerr = 0;
tfd = -1;
if (type == '\3') {
/*
* Type == 3 means this is a datafile, not a control file.
* Increment the counter of data-files in this job, and
* then check for input or output filters (which are only
* applied to datafiles, not control files).
*/
job_dfcnt++;
/*
* Note that here we are filtering datafiles, one at a time,
* as they are sent to the remote machine. Here, the *only*
* difference between an input filter (`if=') and an output
* filter (`of=') is the argument list that the filter is
* started up with. Here, the output filter is executed
* for each individual file as it is sent. This is not the
* same as local print queues, where the output filter is
* started up once, and then all jobs are passed thru that
* single invocation of the output filter.
*
* Also note that a queue for a remote-machine can have an
* input filter or an output filter, but not both.
*/
if (pp->filters[LPF_INPUT]) {
filtcmd = pp->filters[LPF_INPUT];
av[0] = filtcmd;
narg = 0;
strcpy(opt_c, "-c");
strcpy(opt_h, "-h");
strcpy(opt_n, "-n");
if (format == 'l')
av[++narg] = opt_c;
av[++narg] = width;
av[++narg] = length;
av[++narg] = indent;
av[++narg] = opt_n;
av[++narg] = logname;
av[++narg] = opt_h;
av[++narg] = origin_host;
av[++narg] = pp->acct_file;
av[++narg] = NULL;
} else if (pp->filters[LPF_OUTPUT]) {
filtcmd = pp->filters[LPF_OUTPUT];
av[0] = filtcmd;
narg = 0;
av[++narg] = width;
av[++narg] = length;
av[++narg] = NULL;
}
}
if (filtcmd) {
/*
* If there is an input or output filter, we have to run
* the datafile thru that filter and store the result as
* a temporary spool file, because the protocol requires
* that we send the remote host the file-size before we
* start to send any of the data.
*/
strcpy(tfile, TFILENAME);
tfd = mkstemp(tfile);
if (tfd == -1) {
syslog(LOG_ERR, "%s: mkstemp(%s): %m", pp->printer,
TFILENAME);
sfres = ERROR;
goto return_sfres;
}
filtstat = execfilter(pp, filtcmd, av, sfd, tfd);
/* process the return-code from the filter */
switch (filtstat) {
case 0:
break;
case 1:
sfres = REPRINT;
goto return_sfres;
case 2:
sfres = ERROR;
goto return_sfres;
default:
syslog(LOG_WARNING,
"%s: filter '%c' exited (retcode=%d)",
pp->printer, format, filtstat);
sfres = FILTERERR;
goto return_sfres;
}
statrc = fstat(tfd, &stb); /* to find size of tfile */
if (statrc < 0) {
syslog(LOG_ERR,
"%s: error processing 'if', fstat(%s): %m",
pp->printer, tfile);
sfres = ERROR;
goto return_sfres;
}
close(sfd);
sfd = tfd;
lseek(sfd, 0, SEEK_SET);
}
copycnt = 0;
sendagain:
copycnt++;
if (copycnt < 2)
(void) sprintf(buf, "%c%" PRId64 " %s\n", type, stb.st_size,
file);
else
(void) sprintf(buf, "%c%" PRId64 " %s_c%d\n", type, stb.st_size,
file, copycnt);
amt = strlen(buf);
for (i = 0; ; i++) {
if (write(pfd, buf, amt) != amt ||
(resp = response(pp)) < 0 || resp == '\1') {
sfres = REPRINT;
goto return_sfres;
} else if (resp == '\0')
break;
if (i == 0)
pstatus(pp,
"no space on remote; waiting for queue to drain");
if (i == 10)
syslog(LOG_ALERT, "%s: can't send to %s; queue full",
pp->printer, pp->remote_host);
sleep(5 * 60);
}
if (i)
pstatus(pp, "sending to %s", pp->remote_host);
/*
* XXX - we should change trstat_init()/trstat_write() to include
* the copycnt in the statistics record it may write.
*/
if (type == '\3')
trstat_init(pp, file, job_dfcnt);
for (i = 0; i < stb.st_size; i += SPL_BUFSIZ) {
amt = SPL_BUFSIZ;
if (i + amt > stb.st_size)
amt = stb.st_size - i;
if (sizerr == 0 && read(sfd, buf, amt) != amt)
sizerr = 1;
if (write(pfd, buf, amt) != amt) {
sfres = REPRINT;
goto return_sfres;
}
}
if (sizerr) {
syslog(LOG_INFO, "%s: %s: changed size", pp->printer, file);
/* tell recvjob to ignore this file */
(void) write(pfd, "\1", 1);
sfres = ERROR;
goto return_sfres;
}
if (write(pfd, "", 1) != 1 || response(pp)) {
sfres = REPRINT;
goto return_sfres;
}
if (type == '\3') {
trstat_write(pp, TR_SENDING, stb.st_size, logname,
pp->remote_host, origin_host);
/*
* Usually we only need to send one copy of a datafile,
* because the control-file will simply print the same
* file multiple times. However, some printers ignore
* the control file, and simply print each data file as
* it arrives. For such "remote hosts", we need to
* transfer the same data file multiple times. Such a
* a host is indicated by adding 'rc' to the printcap
* entry.
* XXX - Right now this ONLY works for remote hosts which
* do ignore the name of the data file, because
* this sends the file multiple times with slight
* changes to the filename. To do this right would
* require that we also rewrite the control file
* to match those filenames.
*/
if (pp->resend_copies && (copycnt < copyreq)) {
lseek(sfd, 0, SEEK_SET);
goto sendagain;
}
}
sfres = OK;
return_sfres:
(void)close(sfd);
if (tfd != -1) {
/*
* If tfd is set, then it is the same value as sfd, and
* therefore it is already closed at this point. All
* we need to do is remove the temporary file.
*/
tfd = -1;
unlink(tfile);
}
return (sfres);
}
/*
* Some print servers send the control-file first, and then start sending the
* matching data file(s). That is not the correct order. If some queue is
* already printing an active job, then when that job is finished the queue
* may proceed to the control file of any incoming print job. This turns
* into a race between the process which is receiving the data file, and the
* process which is actively printing the very same file. When the remote
* server sends files in the wrong order, it is even possible that a queue
* will start to print a data file before the file has been created!
*
* So before we start to print() or send() a data file, we call this routine
* to make sure the data file is not still changing in size. Note that this
* problem will only happen for jobs arriving from a remote host, and that
* the process which has decided to print this job (and is thus making this
* check) is *not* the process which is receiving the job.
*
* A second benefit of this is that any incoming job is guaranteed to appear
* in a queue listing for at least a few seconds after it has arrived. Some
* lpr implementations get confused if they send a job and it disappears
* from the queue before they can check on it.
*/
#define MAXWAIT_ARRIVE 16 /* max to wait for the file to *exist* */
#define MAXWAIT_4DATA (20*60) /* max to wait for it to stop changing */
#define MINWAIT_4DATA 4 /* This value must be >= 1 */
#define DEBUG_MINWAIT 1
static void
wait4data(struct printer *pp, const char *dfile)
{
const char *cp;
int statres;
u_int sleepreq;
size_t dlen, hlen;
time_t amtslept, cur_time, prev_mtime;
struct stat statdf;
/* Skip these checks if the print job is from the local host. */
dlen = strlen(dfile);
hlen = strlen(local_host);
if (dlen > hlen) {
cp = dfile + dlen - hlen;
if (strcmp(cp, local_host) == 0)
return;
}
/*
* If this data file does not exist, then wait up to MAXWAIT_ARRIVE
* seconds for it to arrive.
*/
amtslept = 0;
statres = stat(dfile, &statdf);
while (statres < 0 && amtslept < MAXWAIT_ARRIVE) {
if (amtslept == 0)
pstatus(pp, "Waiting for data file from remote host");
amtslept += MINWAIT_4DATA - sleep(MINWAIT_4DATA);
statres = stat(dfile, &statdf);
}
if (statres < 0) {
/* The file still does not exist, so just give up on it. */
syslog(LOG_WARNING, "%s: wait4data() abandoned wait for %s",
pp->printer, dfile);
return;
}
/*
* The file exists, so keep waiting until the data file has not
* changed for some reasonable amount of time. Extra care is
* taken when computing wait-times, just in case there are data
* files with a last-modify time in the future. While that is
* very unlikely to happen, it can happen when the system has
* a flakey time-of-day clock.
*/
prev_mtime = statdf.st_mtime;
cur_time = time(NULL);
if (statdf.st_mtime >= cur_time - MINWAIT_4DATA) {
if (statdf.st_mtime >= cur_time) /* some TOD oddity */
sleepreq = MINWAIT_4DATA;
else
sleepreq = cur_time - statdf.st_mtime;
if (amtslept == 0)
pstatus(pp, "Waiting for data file from remote host");
amtslept += sleepreq - sleep(sleepreq);
statres = stat(dfile, &statdf);
}
sleepreq = MINWAIT_4DATA;
while (statres == 0 && amtslept < MAXWAIT_4DATA) {
if (statdf.st_mtime == prev_mtime)
break;
prev_mtime = statdf.st_mtime;
amtslept += sleepreq - sleep(sleepreq);
statres = stat(dfile, &statdf);
}
if (statres != 0)
syslog(LOG_WARNING, "%s: %s disappeared during wait4data()",
pp->printer, dfile);
else if (amtslept > MAXWAIT_4DATA)
syslog(LOG_WARNING,
"%s: %s still changing after %lu secs in wait4data()",
pp->printer, dfile, (unsigned long)amtslept);
#if DEBUG_MINWAIT
else if (amtslept > MINWAIT_4DATA)
syslog(LOG_INFO, "%s: slept %lu secs in wait4data(%s)",
pp->printer, (unsigned long)amtslept, dfile);
#endif
}
#undef MAXWAIT_ARRIVE
#undef MAXWAIT_4DATA
#undef MINWAIT_4DATA
/*
* This routine is called to execute one of the filters as was
* specified in a printcap entry. While the child-process will read
* all of 'infd', it is up to the caller to close that file descriptor
* in the parent process.
*/
static int
execfilter(struct printer *pp, char *f_cmd, char *f_av[], int infd, int outfd)
{
pid_t fpid, wpid;
int errfd, retcode, wstatus;
FILE *errfp;
char buf[BUFSIZ], *slash;
fpid = dofork(pp, DORETURN);
if (fpid != 0) {
/*
* This is the parent process, which just waits for the child
* to complete and then returns the result. Note that it is
* the child process which reads the input stream.
*/
if (fpid < 0)
retcode = 100;
else {
while ((wpid = wait(&wstatus)) > 0 &&
wpid != fpid)
;
if (wpid < 0) {
retcode = 100;
syslog(LOG_WARNING,
"%s: after execv(%s), wait() returned: %m",
pp->printer, f_cmd);
} else
retcode = WEXITSTATUS(wstatus);
}
/*
* Copy everything the filter wrote to stderr from our
* temporary errors file to the "lf=" logfile.
*/
errfp = fopen(tempstderr, "r");
if (errfp) {
while (fgets(buf, sizeof(buf), errfp))
fputs(buf, stderr);
fclose(errfp);
}
return (retcode);
}
/*
* This is the child process, which is the one that executes the
* given filter.
*/
/*
* If the first parameter has any slashes in it, then change it
* to point to the first character after the last slash.
*/
slash = strrchr(f_av[0], '/');
if (slash != NULL)
f_av[0] = slash + 1;
/*
* XXX - in the future, this should setup an explicit list of
* environment variables and use execve()!
*/
/*
* Setup stdin, stdout, and stderr as we want them when the filter
* is running. Stderr is setup so it points to a temporary errors
* file, and the parent process will copy that temporary file to
* the real logfile after the filter completes.
*/
dup2(infd, STDIN_FILENO);
dup2(outfd, STDOUT_FILENO);
errfd = open(tempstderr, O_WRONLY|O_TRUNC, 0664);
if (errfd >= 0)
dup2(errfd, STDERR_FILENO);
closelog();
closeallfds(3);
execv(f_cmd, f_av);
syslog(LOG_ERR, "%s: cannot execv(%s): %m", pp->printer, f_cmd);
exit(2);
/* NOTREACHED */
}
/*
* Check to make sure there have been no errors and that both programs
* are in sync with eachother.
* Return non-zero if the connection was lost.
*/
static char
response(const struct printer *pp)
{
char resp;
if (read(pfd, &resp, 1) != 1) {
syslog(LOG_INFO, "%s: lost connection", pp->printer);
return (-1);
}
return (resp);
}
/*
* Banner printing stuff
*/
static void
banner(struct printer *pp, char *name1, char *name2)
{
time_t tvec;
time(&tvec);
if (!pp->no_formfeed && !pp->tof)
(void) write(ofd, pp->form_feed, strlen(pp->form_feed));
if (pp->short_banner) { /* short banner only */
if (class[0]) {
(void) write(ofd, class, strlen(class));
(void) write(ofd, ":", 1);
}
(void) write(ofd, name1, strlen(name1));
(void) write(ofd, " Job: ", 7);
(void) write(ofd, name2, strlen(name2));
(void) write(ofd, " Date: ", 8);
(void) write(ofd, ctime(&tvec), 24);
(void) write(ofd, "\n", 1);
} else { /* normal banner */
(void) write(ofd, "\n\n\n", 3);
scan_out(pp, ofd, name1, '\0');
(void) write(ofd, "\n\n", 2);
scan_out(pp, ofd, name2, '\0');
if (class[0]) {
(void) write(ofd,"\n\n\n",3);
scan_out(pp, ofd, class, '\0');
}
(void) write(ofd, "\n\n\n\n\t\t\t\t\tJob: ", 15);
(void) write(ofd, name2, strlen(name2));
(void) write(ofd, "\n\t\t\t\t\tDate: ", 12);
(void) write(ofd, ctime(&tvec), 24);
(void) write(ofd, "\n", 1);
}
if (!pp->no_formfeed)
(void) write(ofd, pp->form_feed, strlen(pp->form_feed));
pp->tof = 1;
}
static char *
scnline(int key, char *p, int c)
{
register int scnwidth;
for (scnwidth = WIDTH; --scnwidth;) {
key <<= 1;
*p++ = key & 0200 ? c : BACKGND;
}
return (p);
}
#define TRC(q) (((q)-' ')&0177)
static void
scan_out(struct printer *pp, int scfd, char *scsp, int dlm)
{
register char *strp;
register int nchrs, j;
char outbuf[LINELEN+1], *sp, c, cc;
int d, scnhgt;
for (scnhgt = 0; scnhgt++ < HEIGHT+DROP; ) {
strp = &outbuf[0];
sp = scsp;
for (nchrs = 0; ; ) {
d = dropit(c = TRC(cc = *sp++));
if ((!d && scnhgt > HEIGHT) || (scnhgt <= DROP && d))
for (j = WIDTH; --j;)
*strp++ = BACKGND;
else
strp = scnline(scnkey[(int)c][scnhgt-1-d], strp, cc);
if (*sp == dlm || *sp == '\0' ||
nchrs++ >= pp->page_width/(WIDTH+1)-1)
break;
*strp++ = BACKGND;
*strp++ = BACKGND;
}
while (*--strp == BACKGND && strp >= outbuf)
;
strp++;
*strp++ = '\n';
(void) write(scfd, outbuf, strp-outbuf);
}
}
static int
dropit(int c)
{
switch(c) {
case TRC('_'):
case TRC(';'):
case TRC(','):
case TRC('g'):
case TRC('j'):
case TRC('p'):
case TRC('q'):
case TRC('y'):
return (DROP);
default:
return (0);
}
}
/*
* sendmail ---
* tell people about job completion
*/
static void
sendmail(struct printer *pp, char *userid, int bombed)
{
register int i;
int p[2], s;
register const char *cp;
struct stat stb;
FILE *fp;
pipe(p);
if ((s = dofork(pp, DORETURN)) == 0) { /* child */
dup2(p[0], STDIN_FILENO);
closelog();
closeallfds(3);
if ((cp = strrchr(_PATH_SENDMAIL, '/')) != NULL)
cp++;
else
cp = _PATH_SENDMAIL;
execl(_PATH_SENDMAIL, cp, "-t", (char *)0);
_exit(0);
} else if (s > 0) { /* parent */
dup2(p[1], STDOUT_FILENO);
printf("To: %s@%s\n", userid, origin_host);
printf("Subject: %s printer job \"%s\"\n", pp->printer,
*jobname ? jobname : "<unknown>");
printf("Reply-To: root@%s\n\n", local_host);
printf("Your printer job ");
if (*jobname)
printf("(%s) ", jobname);
switch (bombed) {
case OK:
cp = "OK";
printf("\ncompleted successfully\n");
break;
default:
case FATALERR:
cp = "FATALERR";
printf("\ncould not be printed\n");
break;
case NOACCT:
cp = "NOACCT";
printf("\ncould not be printed without an account on %s\n",
local_host);
break;
case FILTERERR:
cp = "FILTERERR";
if (stat(tempstderr, &stb) < 0 || stb.st_size == 0
|| (fp = fopen(tempstderr, "r")) == NULL) {
printf("\nhad some errors and may not have printed\n");
break;
}
printf("\nhad the following errors and may not have printed:\n");
while ((i = getc(fp)) != EOF)
putchar(i);
(void) fclose(fp);
break;
case ACCESS:
cp = "ACCESS";
printf("\nwas not printed because it was not linked to the original file\n");
}
fflush(stdout);
(void) close(STDOUT_FILENO);
} else {
syslog(LOG_WARNING, "unable to send mail to %s: %m", userid);
return;
}
(void) close(p[0]);
(void) close(p[1]);
wait(NULL);
syslog(LOG_INFO, "mail sent to user %s about job %s on printer %s (%s)",
userid, *jobname ? jobname : "<unknown>", pp->printer, cp);
}
/*
* dofork - fork with retries on failure
*/
static int
dofork(const struct printer *pp, int action)
{
pid_t forkpid;
int i, fail;
struct passwd *pwd;
forkpid = -1;
if (daemon_uname == NULL) {
pwd = getpwuid(pp->daemon_user);
if (pwd == NULL) {
syslog(LOG_ERR, "%s: Can't lookup default daemon uid (%ld) in password file",
pp->printer, pp->daemon_user);
goto error_ret;
}
daemon_uname = strdup(pwd->pw_name);
daemon_defgid = pwd->pw_gid;
}
for (i = 0; i < 20; i++) {
forkpid = fork();
if (forkpid < 0) {
sleep((unsigned)(i*i));
continue;
}
/*
* Child should run as daemon instead of root
*/
if (forkpid == 0) {
errno = 0;
fail = initgroups(daemon_uname, daemon_defgid);
if (fail) {
syslog(LOG_ERR, "%s: initgroups(%s,%u): %m",
pp->printer, daemon_uname, daemon_defgid);
break;
}
fail = setgid(daemon_defgid);
if (fail) {
syslog(LOG_ERR, "%s: setgid(%u): %m",
pp->printer, daemon_defgid);
break;
}
fail = setuid(pp->daemon_user);
if (fail) {
syslog(LOG_ERR, "%s: setuid(%ld): %m",
pp->printer, pp->daemon_user);
break;
}
}
return (forkpid);
}
/*
* An error occurred. If the error is in the child process, then
* this routine MUST always exit(). DORETURN only effects how
* errors should be handled in the parent process.
*/
error_ret:
if (forkpid == 0) {
syslog(LOG_ERR, "%s: dofork(): aborting child process...",
pp->printer);
exit(1);
}
syslog(LOG_ERR, "%s: dofork(): failure in fork", pp->printer);
sleep(1); /* throttle errors, as a safety measure */
switch (action) {
case DORETURN:
return (-1);
default:
syslog(LOG_ERR, "bad action (%d) to dofork", action);
/* FALLTHROUGH */
case DOABORT:
exit(1);
}
/*NOTREACHED*/
}
/*
* Kill child processes to abort current job.
*/
static void
abortpr(int signo __unused)
{
(void) unlink(tempstderr);
kill(0, SIGINT);
if (of_pid > 0)
kill(of_pid, SIGCONT);
while (wait(NULL) > 0)
;
if (of_pid > 0 && tfd != -1)
unlink(tfile);
exit(0);
}
static void
init(struct printer *pp)
{
char *s;
sprintf(&width[2], "%ld", pp->page_width);
sprintf(&length[2], "%ld", pp->page_length);
sprintf(&pxwidth[2], "%ld", pp->page_pwidth);
sprintf(&pxlength[2], "%ld", pp->page_plength);
if ((s = checkremote(pp)) != NULL) {
syslog(LOG_WARNING, "%s", s);
free(s);
}
}
void
startprinting(const char *printer)
{
struct printer myprinter, *pp = &myprinter;
int status;
init_printer(pp);
status = getprintcap(printer, pp);
switch(status) {
case PCAPERR_OSERR:
syslog(LOG_ERR, "can't open printer description file: %m");
exit(1);
case PCAPERR_NOTFOUND:
syslog(LOG_ERR, "unknown printer: %s", printer);
exit(1);
case PCAPERR_TCLOOP:
fatal(pp, "potential reference loop detected in printcap file");
default:
break;
}
printjob(pp);
}
/*
* Acquire line printer or remote connection.
*/
static void
openpr(const struct printer *pp)
{
int p[2];
char *cp;
if (pp->remote) {
openrem(pp);
/*
* Lpd does support the setting of 'of=' filters for
* jobs going to remote machines, but that does not
* have the same meaning as 'of=' does when handling
* local print queues. For remote machines, all 'of='
* filter processing is handled in sendfile(), and that
* does not use these global "output filter" variables.
*/
ofd = -1;
of_pid = 0;
return;
} else if (*pp->lp) {
if (strchr(pp->lp, '@') != NULL)
opennet(pp);
else
opentty(pp);
} else {
syslog(LOG_ERR, "%s: no line printer device or host name",
pp->printer);
exit(1);
}
/*
* Start up an output filter, if needed.
*/
if (pp->filters[LPF_OUTPUT] && !pp->filters[LPF_INPUT] && !of_pid) {
pipe(p);
if (pp->remote) {
strcpy(tfile, TFILENAME);
tfd = mkstemp(tfile);
}
if ((of_pid = dofork(pp, DOABORT)) == 0) { /* child */
dup2(p[0], STDIN_FILENO); /* pipe is std in */
/* tfile/printer is stdout */
dup2(pp->remote ? tfd : pfd, STDOUT_FILENO);
closelog();
closeallfds(3);
if ((cp = strrchr(pp->filters[LPF_OUTPUT], '/')) == NULL)
cp = pp->filters[LPF_OUTPUT];
else
cp++;
execl(pp->filters[LPF_OUTPUT], cp, width, length,
(char *)0);
syslog(LOG_ERR, "%s: execl(%s): %m", pp->printer,
pp->filters[LPF_OUTPUT]);
exit(1);
}
(void) close(p[0]); /* close input side */
ofd = p[1]; /* use pipe for output */
} else {
ofd = pfd;
of_pid = 0;
}
}
/*
* Printer connected directly to the network
* or to a terminal server on the net
*/
static void
opennet(const struct printer *pp)
{
register int i;
int resp;
u_long port;
char *ep;
void (*savealrm)(int);
port = strtoul(pp->lp, &ep, 0);
if (*ep != '@' || port > 65535) {
syslog(LOG_ERR, "%s: bad port number: %s", pp->printer,
pp->lp);
exit(1);
}
ep++;
for (i = 1; ; i = i < 256 ? i << 1 : i) {
resp = -1;
savealrm = signal(SIGALRM, alarmhandler);
alarm(pp->conn_timeout);
pfd = getport(pp, ep, port);
alarm(0);
(void)signal(SIGALRM, savealrm);
if (pfd < 0 && errno == ECONNREFUSED)
resp = 1;
else if (pfd >= 0) {
/*
* need to delay a bit for rs232 lines
* to stabilize in case printer is
* connected via a terminal server
*/
delay(500);
break;
}
if (i == 1) {
if (resp < 0)
pstatus(pp, "waiting for %s to come up",
pp->lp);
else
pstatus(pp,
"waiting for access to printer on %s",
pp->lp);
}
sleep(i);
}
pstatus(pp, "sending to %s port %lu", ep, port);
}
/*
* Printer is connected to an RS232 port on this host
*/
static void
opentty(const struct printer *pp)
{
register int i;
for (i = 1; ; i = i < 32 ? i << 1 : i) {
pfd = open(pp->lp, pp->rw ? O_RDWR : O_WRONLY);
if (pfd >= 0) {
delay(500);
break;
}
if (errno == ENOENT) {
syslog(LOG_ERR, "%s: %m", pp->lp);
exit(1);
}
if (i == 1)
pstatus(pp,
"waiting for %s to become ready (offline?)",
pp->printer);
sleep(i);
}
if (isatty(pfd))
setty(pp);
pstatus(pp, "%s is ready and printing", pp->printer);
}
/*
* Printer is on a remote host
*/
static void
openrem(const struct printer *pp)
{
register int i;
int resp;
void (*savealrm)(int);
for (i = 1; ; i = i < 256 ? i << 1 : i) {
resp = -1;
savealrm = signal(SIGALRM, alarmhandler);
alarm(pp->conn_timeout);
pfd = getport(pp, pp->remote_host, 0);
alarm(0);
(void)signal(SIGALRM, savealrm);
if (pfd >= 0) {
if ((writel(pfd, "\2", pp->remote_queue, "\n",
(char *)0)
== 2 + strlen(pp->remote_queue))
&& (resp = response(pp)) == 0)
break;
(void) close(pfd);
}
if (i == 1) {
if (resp < 0)
pstatus(pp, "waiting for %s to come up",
pp->remote_host);
else {
pstatus(pp,
"waiting for queue to be enabled on %s",
pp->remote_host);
i = 256;
}
}
sleep(i);
}
pstatus(pp, "sending to %s", pp->remote_host);
}
/*
* setup tty lines.
*/
static void
setty(const struct printer *pp)
{
struct termios ttybuf;
if (ioctl(pfd, TIOCEXCL, (char *)0) < 0) {
syslog(LOG_ERR, "%s: ioctl(TIOCEXCL): %m", pp->printer);
exit(1);
}
if (tcgetattr(pfd, &ttybuf) < 0) {
syslog(LOG_ERR, "%s: tcgetattr: %m", pp->printer);
exit(1);
}
if (pp->baud_rate > 0)
cfsetspeed(&ttybuf, pp->baud_rate);
if (pp->mode_set) {
char *s = strdup(pp->mode_set), *tmp;
while ((tmp = strsep(&s, ",")) != NULL) {
(void) msearch(tmp, &ttybuf);
}
}
if (pp->mode_set != 0 || pp->baud_rate > 0) {
if (tcsetattr(pfd, TCSAFLUSH, &ttybuf) == -1) {
syslog(LOG_ERR, "%s: tcsetattr: %m", pp->printer);
}
}
}
#include <stdarg.h>
static void
pstatus(const struct printer *pp, const char *msg, ...)
{
int fd;
char *buf;
va_list ap;
va_start(ap, msg);
umask(S_IWOTH);
fd = open(pp->status_file, O_WRONLY|O_CREAT|O_EXLOCK, STAT_FILE_MODE);
if (fd < 0) {
syslog(LOG_ERR, "%s: open(%s): %m", pp->printer,
pp->status_file);
exit(1);
}
ftruncate(fd, 0);
vasprintf(&buf, msg, ap);
va_end(ap);
writel(fd, buf, "\n", (char *)0);
close(fd);
free(buf);
}
void
alarmhandler(int signo __unused)
{
/* the signal is ignored */
/* (the '__unused' is just to avoid a compile-time warning) */
}
Reference in New Issue View Git Blame Copy Permalink