commands/lpd/lpd.c

   1 /*      lpd 1.6 - Printer daemon                        Author: Kees J. Bot
   2  *                                                              3 Dec 1989
   3  */
   4 #define nil 0
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <limits.h>
   8 #include <string.h>
   9 #include <errno.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <dirent.h>
  13 #include <fcntl.h>
  14 #include <unistd.h>
  15 #include <termcap.h>
  16
  17 char PRINTER[] =        "/dev/lp";
  18 char SPOOL[] =          "/usr/spool/lpd";
  19 char LOG[] =            "/dev/log";
  20
  21 void report(char *mess)
  22 {
  23         fprintf(stderr, "lpd: %s: %s\n", mess, strerror(errno));
  24 }
  25
  26 void fatal(char *mess)
  27 {
  28         report(mess);
  29         exit(1);
  30 }
  31
  32 char jobX[] = "jobXXXXXX";
  33 char tmpX[] = "tmpXXXXXX";
  34
  35 void spoolerr(char *file)
  36 {
  37         int e= errno;
  38
  39         unlink(jobX);
  40         unlink(tmpX);
  41         fatal(file);
  42 }
  43
  44 void spool(char *path)
  45 /* Place a file into the spool directory, either by copying it, or by leaving
  46  * a reference.
  47  */
  48 {
  49         char *file;
  50         int j, u;
  51
  52         mktemp(jobX);
  53         file= mktemp(tmpX);
  54
  55         if (path[0] == '/') {
  56                 int f;
  57
  58                 if ((f= open(path, O_RDONLY)) >= 0) {
  59                         close(f);
  60                         file= path;
  61                 }
  62         }
  63         if (file != path) {
  64                 int c;
  65                 FILE *t;
  66
  67                 if ((t= fopen(tmpX, "w")) == nil) spoolerr(tmpX);
  68
  69                 while ((c= getchar()) != EOF && putc(c, t) != EOF) {}
  70
  71                 if (ferror(stdin)) spoolerr(path);
  72
  73                 if (ferror(t) || fclose(t) == EOF) spoolerr(tmpX);
  74
  75                 fclose(stdin);
  76         }
  77
  78         if ((j= open(jobX, O_WRONLY|O_CREAT|O_EXCL, 0000)) < 0) spoolerr(jobX);
  79
  80         u= getuid();
  81         if (write(j, file, strlen(file)+1) < 0
  82                 || write(j, &u, sizeof(u)) < 0
  83                 || write(j, path, strlen(path)+1) < 0
  84                 || close(j) < 0
  85                 || chmod(jobX, 0600) < 0
  86         ) spoolerr(jobX);
  87 }
  88
  89 struct job {
  90         struct job *next;
  91         time_t age;
  92         char name[sizeof(jobX)];
  93 } *jobs = nil;
  94
  95 int job(void)
  96 /* Look for print jobs in the spool directory.  Make a list of them sorted
  97  * by age.  Return true iff the list is nonempty.
  98  */
  99 {
 100         DIR *spool;
 101         struct dirent *entry;
 102         struct job *newjob, **ajob;
 103         struct stat st;
 104
 105         if (jobs != nil) return 1;
 106
 107         if ((spool= opendir(".")) == nil) fatal(SPOOL);
 108
 109         while ((entry= readdir(spool)) != nil) {
 110                 if (strncmp(entry->d_name, "job", 3) != 0) continue;
 111
 112                 if (stat(entry->d_name, &st) < 0
 113                         || (st.st_mode & 0777) == 0000) continue;
 114
 115                 if ((newjob= malloc(sizeof(*newjob))) == nil) fatal("malloc()");
 116                 newjob->age = st.st_mtime;
 117                 strcpy(newjob->name, entry->d_name);
 118
 119                 ajob= &jobs;
 120                 while (*ajob != nil && (*ajob)->age < newjob->age)
 121                         ajob= &(*ajob)->next;
 122
 123                 newjob->next= *ajob;
 124                 *ajob= newjob;
 125         }
 126         closedir(spool);
 127
 128         return jobs != nil;
 129 }
 130
 131 /* What to do with control-X:
 132  * 0 ignore,
 133  * 1 give up on controlling the printer, assume user knows how printer works,
 134  * 2 print.
 135  */
 136 char control[] = {
 137         0, 1, 1, 1, 1, 1, 1, 0,         /* \0, \a  don't show.  */
 138         2, 2, 2, 1, 2, 2, 1, 1,         /* \b, \t, \n, \f, \r   */
 139         1, 1, 1, 1, 1, 1, 1, 1,
 140         1, 1, 1, 1, 1, 1, 1, 1
 141 };
 142
 143 int lp;
 144 char buf[BUFSIZ];
 145 int count, column, line, ncols = 80, nlines = 66;
 146
 147 int flush(void)
 148 /* Copy the characters in the output buffer to the printer, with retries if
 149  * out of paper.
 150  */
 151 {
 152         char *bp= buf;
 153
 154         while (count > 0) {
 155                 int retry = 0, complain = 0;
 156                 int r;
 157
 158                 while ((r= write(lp, bp, count)) < 0) {
 159                         if (errno != EAGAIN) fatal(PRINTER);
 160                         if (retry == complain) {
 161                                 fprintf(stderr,
 162                                         "lpd: %s: Printer out of paper\n",
 163                                         PRINTER);
 164                                 complain= retry + 60;
 165                         }
 166                         sleep(1);
 167                         retry++;
 168                 }
 169                 bp+= r;
 170                 count-= r;
 171         }
 172         count = 0;
 173 }
 174
 175 int put(int c)
 176 /* Send characters to the output buffer to be printed and do so if the buffer
 177  * is full.  Track the position of the write-head in `column' and `line'.
 178  */
 179 {
 180         buf[count++] = c;
 181
 182         switch (c) {
 183         case '\f':
 184                 column = 0;
 185                 line = 0;
 186                 break;
 187         case '\r':
 188                 column = 0;
 189                 break;
 190         case '\n':
 191                 line++;
 192                 break;
 193         case '\b':
 194                 column--;
 195                 break;
 196         default:
 197                 if (++column > ncols) { line++; column= 1; }
 198         }
 199         if (line == nlines) line= 0;
 200
 201         if (count == BUFSIZ) flush();
 202 }
 203
 204 void print(FILE *f)
 205 /* Send the contents of an open file to the printer.  Expand tabs and change
 206  * linefeed to a carriage-return linefeed sequence.  Print a formfeed at the
 207  * end if needed to reach the top of the next page.  If a control character
 208  * is printed that we do not know about, then the user is assumed to know
 209  * what they are doing, so output processing is disabled.
 210  */
 211 {
 212         int c;
 213
 214         count= column= line= 0;
 215
 216         while ((c= getc(f)) != EOF) {
 217                 if (c < ' ') {
 218                         switch (control[c]) {
 219                         case 0: continue;       /* Ignore this one. */
 220                         case 1:
 221                                 /* Can't handle this junk, assume smart user. */
 222                                 do {
 223                                         buf[count++] = c;
 224                                         if (count == BUFSIZ) flush();
 225                                 } while ((c= getc(f)) != EOF);
 226
 227                                 flush();
 228                                 return;
 229                         case 2: /* fine */;
 230                         }
 231                 }
 232
 233                 switch (c) {
 234                 case '\n':
 235                         put('\r');
 236                         put('\n');
 237                         break;
 238                 case '\t':
 239                         do {
 240                                 put(' ');
 241                         } while (column & 07);
 242                         break;
 243                 case '\b':
 244                         if (column > 0) put(c);
 245                         break;
 246                 default:
 247                         put(c);
 248                 }
 249         }
 250         if (column > 0) { put('\r'); put('\n'); }
 251         if (line > 0) put('\f');
 252         flush();
 253         return;
 254 }
 255
 256 void joberr(char *job)
 257 {
 258         fprintf(stderr, "lpd: something is wrong with %s\n", job);
 259
 260         if (unlink(job) < 0) fatal("can't remove it");
 261 }
 262
 263 void work(void)
 264 /* Print all the jobs in the job list. */
 265 {
 266         FILE *j, *f;
 267         char file[PATH_MAX+1], *pf=file;
 268         int c;
 269         struct job *job;
 270
 271         job= jobs;
 272         jobs= jobs->next;
 273
 274         if ((j= fopen(job->name, "r")) == nil) {
 275                 joberr(job->name);
 276                 return;
 277         }
 278
 279         do {
 280                 if (pf == file + sizeof(file) || (c= getc(j)) == EOF) {
 281                         fclose(j);
 282                         joberr(job->name);
 283                         return;
 284                 }
 285                 *pf++ = c;
 286         } while (c != 0);
 287
 288         fclose(j);
 289
 290         if ((f= fopen(file, "r")) == nil)
 291                 fprintf(stderr, "lpd: can't read %s\n", file);
 292         else {
 293                 print(f);
 294                 fclose(f);
 295         }
 296         if (file[0] != '/' && unlink(file) < 0) report(file);
 297
 298         if (unlink(job->name) < 0) fatal(job->name);
 299         free(job);
 300 }
 301
 302 void getcap(void)
 303 /* Find the line printer dimensions in the termcap database under "lp". */
 304 {
 305         char printcap[1024];
 306         int n;
 307
 308         if (tgetent(printcap, "lp") == 1) {
 309                 if ((n= tgetnum("co")) > 0) ncols= n;
 310                 if ((n= tgetnum("li")) > 0) nlines= n;
 311         }
 312 }
 313
 314 void haunt(void)
 315 /* Become a daemon, print jobs while there are any, exit. */
 316 {
 317         int fd;
 318
 319         if ((fd= open("/dev/tty", O_RDONLY)) != -1) {
 320                 /* We have a controlling tty!  Disconnect. */
 321                 close(fd);
 322
 323                 switch(fork()) {
 324                 case -1:        fatal("can't fork");
 325                 case  0:        break;
 326                 default:        exit(0);
 327                 }
 328
 329                 if ((fd= open("/dev/null", O_RDONLY)) < 0) fatal("/dev/null");
 330                 dup2(fd, 0);
 331                 close(fd);
 332                 if ((fd= open(LOG, O_WRONLY)) < 0) fatal(LOG);
 333                 dup2(fd, 1);
 334                 dup2(fd, 2);
 335                 close(fd);
 336                 setsid();
 337         }
 338
 339         getcap();
 340
 341         do {
 342                 if ((lp= open(PRINTER, O_WRONLY)) < 0) {
 343                         /* Another lpd? */
 344                         if (errno == EBUSY) exit(0);
 345                         fatal(PRINTER);
 346                 }
 347
 348                 while (job()) work();
 349
 350                 close(lp);
 351         } while (job());
 352 }
 353
 354 int main(int argc, char **argv)
 355 {
 356         if (argc > 2) {
 357                 fprintf(stderr, "Usage: %s [path | stdin < path]\n", argv[0]);
 358                 exit(1);
 359         }
 360
 361         umask(0077);
 362
 363         if (chdir(SPOOL) < 0) fatal(SPOOL);
 364
 365         if (argc == 2) spool(argv[1]);
 366
 367         haunt();
 368 }