minix/commands/lpd/lpd.c
2010-05-12 16:28:54 +00:00

368 lines
6.6 KiB
C

/* lpd 1.6 - Printer daemon Author: Kees J. Bot
* 3 Dec 1989
*/
#define nil 0
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <termcap.h>
char PRINTER[] = "/dev/lp";
char SPOOL[] = "/usr/spool/lpd";
char LOG[] = "/dev/log";
void report(char *mess)
{
fprintf(stderr, "lpd: %s: %s\n", mess, strerror(errno));
}
void fatal(char *mess)
{
report(mess);
exit(1);
}
char jobX[] = "jobXXXXXX";
char tmpX[] = "tmpXXXXXX";
void spoolerr(char *file)
{
int e= errno;
unlink(jobX);
unlink(tmpX);
fatal(file);
}
void spool(char *path)
/* Place a file into the spool directory, either by copying it, or by leaving
* a reference.
*/
{
char *file;
int j, u;
mktemp(jobX);
file= mktemp(tmpX);
if (path[0] == '/') {
int f;
if ((f= open(path, O_RDONLY)) >= 0) {
close(f);
file= path;
}
}
if (file != path) {
int c;
FILE *t;
if ((t= fopen(tmpX, "w")) == nil) spoolerr(tmpX);
while ((c= getchar()) != EOF && putc(c, t) != EOF) {}
if (ferror(stdin)) spoolerr(path);
if (ferror(t) || fclose(t) == EOF) spoolerr(tmpX);
fclose(stdin);
}
if ((j= open(jobX, O_WRONLY|O_CREAT|O_EXCL, 0000)) < 0) spoolerr(jobX);
u= getuid();
if (write(j, file, strlen(file)+1) < 0
|| write(j, &u, sizeof(u)) < 0
|| write(j, path, strlen(path)+1) < 0
|| close(j) < 0
|| chmod(jobX, 0600) < 0
) spoolerr(jobX);
}
struct job {
struct job *next;
time_t age;
char name[sizeof(jobX)];
} *jobs = nil;
int job(void)
/* Look for print jobs in the spool directory. Make a list of them sorted
* by age. Return true iff the list is nonempty.
*/
{
DIR *spool;
struct dirent *entry;
struct job *newjob, **ajob;
struct stat st;
if (jobs != nil) return 1;
if ((spool= opendir(".")) == nil) fatal(SPOOL);
while ((entry= readdir(spool)) != nil) {
if (strncmp(entry->d_name, "job", 3) != 0) continue;
if (stat(entry->d_name, &st) < 0
|| (st.st_mode & 0777) == 0000) continue;
if ((newjob= malloc(sizeof(*newjob))) == nil) fatal("malloc()");
newjob->age = st.st_mtime;
strcpy(newjob->name, entry->d_name);
ajob= &jobs;
while (*ajob != nil && (*ajob)->age < newjob->age)
ajob= &(*ajob)->next;
newjob->next= *ajob;
*ajob= newjob;
}
closedir(spool);
return jobs != nil;
}
/* What to do with control-X:
* 0 ignore,
* 1 give up on controlling the printer, assume user knows how printer works,
* 2 print.
*/
char control[] = {
0, 1, 1, 1, 1, 1, 1, 0, /* \0, \a don't show. */
2, 2, 2, 1, 2, 2, 1, 1, /* \b, \t, \n, \f, \r */
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1
};
int lp;
char buf[BUFSIZ];
int count, column, line, ncols = 80, nlines = 66;
int flush(void)
/* Copy the characters in the output buffer to the printer, with retries if
* out of paper.
*/
{
char *bp= buf;
while (count > 0) {
int retry = 0, complain = 0;
int r;
while ((r= write(lp, bp, count)) < 0) {
if (errno != EAGAIN) fatal(PRINTER);
if (retry == complain) {
fprintf(stderr,
"lpd: %s: Printer out of paper\n",
PRINTER);
complain= retry + 60;
}
sleep(1);
retry++;
}
bp+= r;
count-= r;
}
count = 0;
}
int put(int c)
/* Send characters to the output buffer to be printed and do so if the buffer
* is full. Track the position of the write-head in `column' and `line'.
*/
{
buf[count++] = c;
switch (c) {
case '\f':
column = 0;
line = 0;
break;
case '\r':
column = 0;
break;
case '\n':
line++;
break;
case '\b':
column--;
break;
default:
if (++column > ncols) { line++; column= 1; }
}
if (line == nlines) line= 0;
if (count == BUFSIZ) flush();
}
void print(FILE *f)
/* Send the contents of an open file to the printer. Expand tabs and change
* linefeed to a carriage-return linefeed sequence. Print a formfeed at the
* end if needed to reach the top of the next page. If a control character
* is printed that we do not know about, then the user is assumed to know
* what they are doing, so output processing is disabled.
*/
{
int c;
count= column= line= 0;
while ((c= getc(f)) != EOF) {
if (c < ' ') {
switch (control[c]) {
case 0: continue; /* Ignore this one. */
case 1:
/* Can't handle this junk, assume smart user. */
do {
buf[count++] = c;
if (count == BUFSIZ) flush();
} while ((c= getc(f)) != EOF);
flush();
return;
case 2: /* fine */;
}
}
switch (c) {
case '\n':
put('\r');
put('\n');
break;
case '\t':
do {
put(' ');
} while (column & 07);
break;
case '\b':
if (column > 0) put(c);
break;
default:
put(c);
}
}
if (column > 0) { put('\r'); put('\n'); }
if (line > 0) put('\f');
flush();
return;
}
void joberr(char *job)
{
fprintf(stderr, "lpd: something is wrong with %s\n", job);
if (unlink(job) < 0) fatal("can't remove it");
}
void work(void)
/* Print all the jobs in the job list. */
{
FILE *j, *f;
char file[PATH_MAX+1], *pf=file;
int c;
struct job *job;
job= jobs;
jobs= jobs->next;
if ((j= fopen(job->name, "r")) == nil) {
joberr(job->name);
return;
}
do {
if (pf == file + sizeof(file) || (c= getc(j)) == EOF) {
fclose(j);
joberr(job->name);
return;
}
*pf++ = c;
} while (c != 0);
fclose(j);
if ((f= fopen(file, "r")) == nil)
fprintf(stderr, "lpd: can't read %s\n", file);
else {
print(f);
fclose(f);
}
if (file[0] != '/' && unlink(file) < 0) report(file);
if (unlink(job->name) < 0) fatal(job->name);
free(job);
}
void getcap(void)
/* Find the line printer dimensions in the termcap database under "lp". */
{
char printcap[1024];
int n;
if (tgetent(printcap, "lp") == 1) {
if ((n= tgetnum("co")) > 0) ncols= n;
if ((n= tgetnum("li")) > 0) nlines= n;
}
}
void haunt(void)
/* Become a daemon, print jobs while there are any, exit. */
{
int fd;
if ((fd= open("/dev/tty", O_RDONLY)) != -1) {
/* We have a controlling tty! Disconnect. */
close(fd);
switch(fork()) {
case -1: fatal("can't fork");
case 0: break;
default: exit(0);
}
if ((fd= open("/dev/null", O_RDONLY)) < 0) fatal("/dev/null");
dup2(fd, 0);
close(fd);
if ((fd= open(LOG, O_WRONLY)) < 0) fatal(LOG);
dup2(fd, 1);
dup2(fd, 2);
close(fd);
setsid();
}
getcap();
do {
if ((lp= open(PRINTER, O_WRONLY)) < 0) {
/* Another lpd? */
if (errno == EBUSY) exit(0);
fatal(PRINTER);
}
while (job()) work();
close(lp);
} while (job());
}
int main(int argc, char **argv)
{
if (argc > 2) {
fprintf(stderr, "Usage: %s [path | stdin < path]\n", argv[0]);
exit(1);
}
umask(0077);
if (chdir(SPOOL) < 0) fatal(SPOOL);
if (argc == 2) spool(argv[1]);
haunt();
}