1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by the University of 17 * California, Berkeley and its contributors. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #ifndef lint 36 static const char copyright[] = 37 "@(#) Copyright (c) 1983, 1993\n\ 38 The Regents of the University of California. All rights reserved.\n"; 39 #endif /* not lint */ 40 41 #ifndef lint 42 /* 43 static char sccsid[] = "@(#)printjob.c 8.7 (Berkeley) 5/10/95"; 44 */ 45 static const char rcsid[] = 46 "$FreeBSD: src/usr.sbin/lpr/lpd/printjob.c,v 1.22.2.32 2002/06/19 23:58:16 gad Exp $"; 47 #endif /* not lint */ 48 49 50 /* 51 * printjob -- print jobs in the queue. 52 * 53 * NOTE: the lock file is used to pass information to lpq and lprm. 54 * it does not need to be removed because file locks are dynamic. 55 */ 56 57 #include <sys/param.h> 58 #include <sys/wait.h> 59 #include <sys/stat.h> 60 #include <sys/types.h> 61 62 #include <pwd.h> 63 #include <unistd.h> 64 #include <signal.h> 65 #include <syslog.h> 66 #include <fcntl.h> 67 #include <dirent.h> 68 #include <errno.h> 69 #include <stdio.h> 70 #include <string.h> 71 #include <stdlib.h> 72 #include <sys/ioctl.h> 73 #include <termios.h> 74 #include <time.h> 75 #include "lp.h" 76 #include "lp.local.h" 77 #include "pathnames.h" 78 #include "extern.h" 79 80 #define DORETURN 0 /* dofork should return "can't fork" error */ 81 #define DOABORT 1 /* dofork should just die if fork() fails */ 82 83 /* 84 * Error tokens 85 */ 86 #define REPRINT -2 87 #define ERROR -1 88 #define OK 0 89 #define FATALERR 1 90 #define NOACCT 2 91 #define FILTERERR 3 92 #define ACCESS 4 93 94 static dev_t fdev; /* device of file pointed to by symlink */ 95 static ino_t fino; /* inode of file pointed to by symlink */ 96 static FILE *cfp; /* control file */ 97 static pid_t of_pid; /* process id of output filter, if any */ 98 static int child; /* id of any filters */ 99 static int job_dfcnt; /* count of datafiles in current user job */ 100 static int lfd; /* lock file descriptor */ 101 static int ofd; /* output filter file descriptor */ 102 static int tfd = -1; /* output filter temp file output */ 103 static int pfd; /* prstatic inter file descriptor */ 104 static int prchild; /* id of pr process */ 105 static char title[80]; /* ``pr'' title */ 106 static char locale[80]; /* ``pr'' locale */ 107 108 /* these two are set from pp->daemon_user, but only if they are needed */ 109 static char *daemon_uname; /* set from pwd->pw_name */ 110 static int daemon_defgid; 111 112 static char class[32]; /* classification field */ 113 static char origin_host[MAXHOSTNAMELEN]; /* user's host machine */ 114 /* indentation size in static characters */ 115 static char indent[10] = "-i0"; 116 static char jobname[100]; /* job or file name */ 117 static char length[10] = "-l"; /* page length in lines */ 118 static char logname[32]; /* user's login name */ 119 static char pxlength[10] = "-y"; /* page length in pixels */ 120 static char pxwidth[10] = "-x"; /* page width in pixels */ 121 /* tempstderr is the filename used to catch stderr from exec-ing filters */ 122 static char tempstderr[] = "errs.XXXXXXX"; 123 static char width[10] = "-w"; /* page width in static characters */ 124 #define TFILENAME "fltXXXXXX" 125 static char tfile[] = TFILENAME; /* file name for filter output */ 126 127 static void abortpr(int _signo); 128 static void alarmhandler(int _signo); 129 static void banner(struct printer *_pp, char *_name1, char *_name2); 130 static int dofork(const struct printer *_pp, int _action); 131 static int dropit(int _c); 132 static int execfilter(struct printer *_pp, char *_f_cmd, char **_f_av, 133 int _infd, int _outfd); 134 static void init(struct printer *_pp); 135 static void openpr(const struct printer *_pp); 136 static void opennet(const struct printer *_pp); 137 static void opentty(const struct printer *_pp); 138 static void openrem(const struct printer *pp); 139 static int print(struct printer *_pp, int _format, char *_file); 140 static int printit(struct printer *_pp, char *_file); 141 static void pstatus(const struct printer *_pp, const char *_msg, ...) 142 __printflike(2, 3); 143 static char response(const struct printer *_pp); 144 static void scan_out(struct printer *_pp, int _scfd, char *_scsp, 145 int _dlm); 146 static char *scnline(int _key, char *_p, int _c); 147 static int sendfile(struct printer *_pp, int _type, char *_file, 148 char _format, int _copyreq); 149 static int sendit(struct printer *_pp, char *_file); 150 static void sendmail(struct printer *_pp, char *_userid, int _bombed); 151 static void setty(const struct printer *_pp); 152 153 void 154 printjob(struct printer *pp) 155 { 156 struct stat stb; 157 register struct jobqueue *q, **qp; 158 struct jobqueue **queue; 159 register int i, nitems; 160 off_t pidoff; 161 pid_t printpid; 162 int errcnt, jobcount, tempfd; 163 164 jobcount = 0; 165 init(pp); /* set up capabilities */ 166 (void) write(1, "", 1); /* ack that daemon is started */ 167 (void) close(2); /* set up log file */ 168 if (open(pp->log_file, O_WRONLY|O_APPEND, LOG_FILE_MODE) < 0) { 169 syslog(LOG_ERR, "%s: open(%s): %m", pp->printer, 170 pp->log_file); 171 (void) open(_PATH_DEVNULL, O_WRONLY); 172 } 173 setgid(getegid()); 174 printpid = getpid(); /* for use with lprm */ 175 setpgrp(0, printpid); 176 177 /* 178 * At initial lpd startup, printjob may be called with various 179 * signal handlers in effect. After that initial startup, any 180 * calls to printjob will have a *different* set of signal-handlers 181 * in effect. Make sure all handlers are the ones we want. 182 */ 183 signal(SIGCHLD, SIG_DFL); 184 signal(SIGHUP, abortpr); 185 signal(SIGINT, abortpr); 186 signal(SIGQUIT, abortpr); 187 signal(SIGTERM, abortpr); 188 189 /* 190 * uses short form file names 191 */ 192 if (chdir(pp->spool_dir) < 0) { 193 syslog(LOG_ERR, "%s: chdir(%s): %m", pp->printer, 194 pp->spool_dir); 195 exit(1); 196 } 197 if (stat(pp->lock_file, &stb) == 0 && (stb.st_mode & LFM_PRINT_DIS)) 198 exit(0); /* printing disabled */ 199 lfd = open(pp->lock_file, O_WRONLY|O_CREAT|O_EXLOCK|O_NONBLOCK, 200 LOCK_FILE_MODE); 201 if (lfd < 0) { 202 if (errno == EWOULDBLOCK) /* active daemon present */ 203 exit(0); 204 syslog(LOG_ERR, "%s: open(%s): %m", pp->printer, 205 pp->lock_file); 206 exit(1); 207 } 208 /* turn off non-blocking mode (was turned on for lock effects only) */ 209 if (fcntl(lfd, F_SETFL, 0) < 0) { 210 syslog(LOG_ERR, "%s: fcntl(%s): %m", pp->printer, 211 pp->lock_file); 212 exit(1); 213 } 214 ftruncate(lfd, 0); 215 /* 216 * write process id for others to know 217 */ 218 sprintf(line, "%u\n", printpid); 219 pidoff = i = strlen(line); 220 if (write(lfd, line, i) != i) { 221 syslog(LOG_ERR, "%s: write(%s): %m", pp->printer, 222 pp->lock_file); 223 exit(1); 224 } 225 /* 226 * search the spool directory for work and sort by queue order. 227 */ 228 if ((nitems = getq(pp, &queue)) < 0) { 229 syslog(LOG_ERR, "%s: can't scan %s", pp->printer, 230 pp->spool_dir); 231 exit(1); 232 } 233 if (nitems == 0) /* no work to do */ 234 exit(0); 235 if (stb.st_mode & LFM_RESET_QUE) { /* reset queue flag */ 236 if (fchmod(lfd, stb.st_mode & ~LFM_RESET_QUE) < 0) 237 syslog(LOG_ERR, "%s: fchmod(%s): %m", pp->printer, 238 pp->lock_file); 239 } 240 241 /* create a file which will be used to hold stderr from filters */ 242 if ((tempfd = mkstemp(tempstderr)) == -1) { 243 syslog(LOG_ERR, "%s: mkstemp(%s): %m", pp->printer, 244 tempstderr); 245 exit(1); 246 } 247 if ((i = fchmod(tempfd, 0664)) == -1) { 248 syslog(LOG_ERR, "%s: fchmod(%s): %m", pp->printer, 249 tempstderr); 250 exit(1); 251 } 252 /* lpd doesn't need it to be open, it just needs it to exist */ 253 close(tempfd); 254 255 openpr(pp); /* open printer or remote */ 256 again: 257 /* 258 * we found something to do now do it -- 259 * write the name of the current control file into the lock file 260 * so the spool queue program can tell what we're working on 261 */ 262 for (qp = queue; nitems--; free((char *) q)) { 263 q = *qp++; 264 if (stat(q->job_cfname, &stb) < 0) 265 continue; 266 errcnt = 0; 267 restart: 268 (void) lseek(lfd, pidoff, 0); 269 (void) snprintf(line, sizeof(line), "%s\n", q->job_cfname); 270 i = strlen(line); 271 if (write(lfd, line, i) != i) 272 syslog(LOG_ERR, "%s: write(%s): %m", pp->printer, 273 pp->lock_file); 274 if (!pp->remote) 275 i = printit(pp, q->job_cfname); 276 else 277 i = sendit(pp, q->job_cfname); 278 /* 279 * Check to see if we are supposed to stop printing or 280 * if we are to rebuild the queue. 281 */ 282 if (fstat(lfd, &stb) == 0) { 283 /* stop printing before starting next job? */ 284 if (stb.st_mode & LFM_PRINT_DIS) 285 goto done; 286 /* rebuild queue (after lpc topq) */ 287 if (stb.st_mode & LFM_RESET_QUE) { 288 for (free(q); nitems--; free(q)) 289 q = *qp++; 290 if (fchmod(lfd, stb.st_mode & ~LFM_RESET_QUE) 291 < 0) 292 syslog(LOG_WARNING, 293 "%s: fchmod(%s): %m", 294 pp->printer, pp->lock_file); 295 break; 296 } 297 } 298 if (i == OK) /* all files of this job printed */ 299 jobcount++; 300 else if (i == REPRINT && ++errcnt < 5) { 301 /* try reprinting the job */ 302 syslog(LOG_INFO, "restarting %s", pp->printer); 303 if (of_pid > 0) { 304 kill(of_pid, SIGCONT); /* to be sure */ 305 (void) close(ofd); 306 while ((i = wait(NULL)) > 0 && i != of_pid) 307 ; 308 if (i < 0) 309 syslog(LOG_WARNING, "%s: after kill(of=%d), wait() returned: %m", 310 pp->printer, of_pid); 311 of_pid = 0; 312 } 313 (void) close(pfd); /* close printer */ 314 if (ftruncate(lfd, pidoff) < 0) 315 syslog(LOG_WARNING, "%s: ftruncate(%s): %m", 316 pp->printer, pp->lock_file); 317 openpr(pp); /* try to reopen printer */ 318 goto restart; 319 } else { 320 syslog(LOG_WARNING, "%s: job could not be %s (%s)", 321 pp->printer, 322 pp->remote ? "sent to remote host" : "printed", 323 q->job_cfname); 324 if (i == REPRINT) { 325 /* ensure we don't attempt this job again */ 326 (void) unlink(q->job_cfname); 327 q->job_cfname[0] = 'd'; 328 (void) unlink(q->job_cfname); 329 if (logname[0]) 330 sendmail(pp, logname, FATALERR); 331 } 332 } 333 } 334 free(queue); 335 /* 336 * search the spool directory for more work. 337 */ 338 if ((nitems = getq(pp, &queue)) < 0) { 339 syslog(LOG_ERR, "%s: can't scan %s", pp->printer, 340 pp->spool_dir); 341 exit(1); 342 } 343 if (nitems == 0) { /* no more work to do */ 344 done: 345 if (jobcount > 0) { /* jobs actually printed */ 346 if (!pp->no_formfeed && !pp->tof) 347 (void) write(ofd, pp->form_feed, 348 strlen(pp->form_feed)); 349 if (pp->trailer != NULL) /* output trailer */ 350 (void) write(ofd, pp->trailer, 351 strlen(pp->trailer)); 352 } 353 (void) close(ofd); 354 (void) wait(NULL); 355 (void) unlink(tempstderr); 356 exit(0); 357 } 358 goto again; 359 } 360 361 char fonts[4][50]; /* fonts for troff */ 362 363 char ifonts[4][40] = { 364 _PATH_VFONTR, 365 _PATH_VFONTI, 366 _PATH_VFONTB, 367 _PATH_VFONTS, 368 }; 369 370 /* 371 * The remaining part is the reading of the control file (cf) 372 * and performing the various actions. 373 */ 374 static int 375 printit(struct printer *pp, char *file) 376 { 377 register int i; 378 char *cp; 379 int bombed, didignorehdr; 380 381 bombed = OK; 382 didignorehdr = 0; 383 /* 384 * open control file; ignore if no longer there. 385 */ 386 if ((cfp = fopen(file, "r")) == NULL) { 387 syslog(LOG_INFO, "%s: fopen(%s): %m", pp->printer, file); 388 return (OK); 389 } 390 /* 391 * Reset troff fonts. 392 */ 393 for (i = 0; i < 4; i++) 394 strcpy(fonts[i], ifonts[i]); 395 sprintf(&width[2], "%ld", pp->page_width); 396 strcpy(indent+2, "0"); 397 398 /* initialize job-specific count of datafiles processed */ 399 job_dfcnt = 0; 400 401 /* 402 * read the control file for work to do 403 * 404 * file format -- first character in the line is a command 405 * rest of the line is the argument. 406 * valid commands are: 407 * 408 * S -- "stat info" for symbolic link protection 409 * J -- "job name" on banner page 410 * C -- "class name" on banner page 411 * L -- "literal" user's name to print on banner 412 * T -- "title" for pr 413 * H -- "host name" of machine where lpr was done 414 * P -- "person" user's login name 415 * I -- "indent" amount to indent output 416 * R -- laser dpi "resolution" 417 * f -- "file name" name of text file to print 418 * l -- "file name" text file with control chars 419 * o -- "file name" postscript file, according to 420 * the RFC. Here it is treated like an 'f'. 421 * p -- "file name" text file to print with pr(1) 422 * t -- "file name" troff(1) file to print 423 * n -- "file name" ditroff(1) file to print 424 * d -- "file name" dvi file to print 425 * g -- "file name" plot(1G) file to print 426 * v -- "file name" plain raster file to print 427 * c -- "file name" cifplot file to print 428 * 1 -- "R font file" for troff 429 * 2 -- "I font file" for troff 430 * 3 -- "B font file" for troff 431 * 4 -- "S font file" for troff 432 * N -- "name" of file (used by lpq) 433 * U -- "unlink" name of file to remove 434 * (after we print it. (Pass 2 only)). 435 * M -- "mail" to user when done printing 436 * Z -- "locale" for pr 437 * 438 * getline reads a line and expands tabs to blanks 439 */ 440 441 /* pass 1 */ 442 443 while (getline(cfp)) 444 switch (line[0]) { 445 case 'H': 446 strlcpy(origin_host, line + 1, sizeof(origin_host)); 447 if (class[0] == '\0') { 448 strlcpy(class, line+1, sizeof(class)); 449 } 450 continue; 451 452 case 'P': 453 strlcpy(logname, line + 1, sizeof(logname)); 454 if (pp->restricted) { /* restricted */ 455 if (getpwnam(logname) == NULL) { 456 bombed = NOACCT; 457 sendmail(pp, line+1, bombed); 458 goto pass2; 459 } 460 } 461 continue; 462 463 case 'S': 464 cp = line+1; 465 i = 0; 466 while (*cp >= '0' && *cp <= '9') 467 i = i * 10 + (*cp++ - '0'); 468 fdev = i; 469 cp++; 470 i = 0; 471 while (*cp >= '0' && *cp <= '9') 472 i = i * 10 + (*cp++ - '0'); 473 fino = i; 474 continue; 475 476 case 'J': 477 if (line[1] != '\0') { 478 strlcpy(jobname, line + 1, sizeof(jobname)); 479 } else 480 strcpy(jobname, " "); 481 continue; 482 483 case 'C': 484 if (line[1] != '\0') 485 strlcpy(class, line + 1, sizeof(class)); 486 else if (class[0] == '\0') { 487 /* XXX - why call gethostname instead of 488 * just strlcpy'ing local_host? */ 489 gethostname(class, sizeof(class)); 490 class[sizeof(class) - 1] = '\0'; 491 } 492 continue; 493 494 case 'T': /* header title for pr */ 495 strlcpy(title, line + 1, sizeof(title)); 496 continue; 497 498 case 'L': /* identification line */ 499 if (!pp->no_header && !pp->header_last) 500 banner(pp, line+1, jobname); 501 continue; 502 503 case '1': /* troff fonts */ 504 case '2': 505 case '3': 506 case '4': 507 if (line[1] != '\0') { 508 strlcpy(fonts[line[0]-'1'], line + 1, 509 (size_t)50); 510 } 511 continue; 512 513 case 'W': /* page width */ 514 strlcpy(width+2, line + 1, sizeof(width) - 2); 515 continue; 516 517 case 'I': /* indent amount */ 518 strlcpy(indent+2, line + 1, sizeof(indent) - 2); 519 continue; 520 521 case 'Z': /* locale for pr */ 522 strlcpy(locale, line + 1, sizeof(locale)); 523 continue; 524 525 default: /* some file to print */ 526 /* only lowercase cmd-codes include a file-to-print */ 527 if ((line[0] < 'a') || (line[0] > 'z')) { 528 /* ignore any other lines */ 529 if (lflag <= 1) 530 continue; 531 if (!didignorehdr) { 532 syslog(LOG_INFO, "%s: in %s :", 533 pp->printer, file); 534 didignorehdr = 1; 535 } 536 syslog(LOG_INFO, "%s: ignoring line: '%c' %s", 537 pp->printer, line[0], &line[1]); 538 continue; 539 } 540 i = print(pp, line[0], line+1); 541 switch (i) { 542 case ERROR: 543 if (bombed == OK) 544 bombed = FATALERR; 545 break; 546 case REPRINT: 547 (void) fclose(cfp); 548 return (REPRINT); 549 case FILTERERR: 550 case ACCESS: 551 bombed = i; 552 sendmail(pp, logname, bombed); 553 } 554 title[0] = '\0'; 555 continue; 556 557 case 'N': 558 case 'U': 559 case 'M': 560 case 'R': 561 continue; 562 } 563 564 /* pass 2 */ 565 566 pass2: 567 fseek(cfp, 0L, 0); 568 while (getline(cfp)) 569 switch (line[0]) { 570 case 'L': /* identification line */ 571 if (!pp->no_header && pp->header_last) 572 banner(pp, line+1, jobname); 573 continue; 574 575 case 'M': 576 if (bombed < NOACCT) /* already sent if >= NOACCT */ 577 sendmail(pp, line+1, bombed); 578 continue; 579 580 case 'U': 581 if (strchr(line+1, '/')) 582 continue; 583 (void) unlink(line+1); 584 } 585 /* 586 * clean-up in case another control file exists 587 */ 588 (void) fclose(cfp); 589 (void) unlink(file); 590 return (bombed == OK ? OK : ERROR); 591 } 592 593 /* 594 * Print a file. 595 * Set up the chain [ PR [ | {IF, OF} ] ] or {IF, RF, TF, NF, DF, CF, VF}. 596 * Return -1 if a non-recoverable error occured, 597 * 2 if the filter detected some errors (but printed the job anyway), 598 * 1 if we should try to reprint this job and 599 * 0 if all is well. 600 * Note: all filters take stdin as the file, stdout as the printer, 601 * stderr as the log file, and must not ignore SIGINT. 602 */ 603 static int 604 print(struct printer *pp, int format, char *file) 605 { 606 register int n, i; 607 register char *prog; 608 int fi, fo; 609 FILE *fp; 610 char *av[15], buf[BUFSIZ]; 611 pid_t wpid; 612 int p[2], retcode, stopped, wstatus, wstatus_set; 613 struct stat stb; 614 615 if (lstat(file, &stb) < 0 || (fi = open(file, O_RDONLY)) < 0) { 616 syslog(LOG_INFO, "%s: unable to open %s ('%c' line)", 617 pp->printer, file, format); 618 return (ERROR); 619 } 620 /* 621 * Check to see if data file is a symbolic link. If so, it should 622 * still point to the same file or someone is trying to print 623 * something he shouldn't. 624 */ 625 if ((stb.st_mode & S_IFMT) == S_IFLNK && fstat(fi, &stb) == 0 && 626 (stb.st_dev != fdev || stb.st_ino != fino)) 627 return (ACCESS); 628 629 job_dfcnt++; /* increment datafile counter for this job */ 630 stopped = 0; /* output filter is not stopped */ 631 632 /* everything seems OK, start it up */ 633 if (!pp->no_formfeed && !pp->tof) { /* start on a fresh page */ 634 (void) write(ofd, pp->form_feed, strlen(pp->form_feed)); 635 pp->tof = 1; 636 } 637 if (pp->filters[LPF_INPUT] == NULL 638 && (format == 'f' || format == 'l' || format == 'o')) { 639 pp->tof = 0; 640 while ((n = read(fi, buf, BUFSIZ)) > 0) 641 if (write(ofd, buf, n) != n) { 642 (void) close(fi); 643 return (REPRINT); 644 } 645 (void) close(fi); 646 return (OK); 647 } 648 switch (format) { 649 case 'p': /* print file using 'pr' */ 650 if (pp->filters[LPF_INPUT] == NULL) { /* use output filter */ 651 prog = _PATH_PR; 652 i = 0; 653 av[i++] = "pr"; 654 av[i++] = width; 655 av[i++] = length; 656 av[i++] = "-h"; 657 av[i++] = *title ? title : " "; 658 av[i++] = "-L"; 659 av[i++] = *locale ? locale : "C"; 660 av[i++] = "-F"; 661 av[i] = 0; 662 fo = ofd; 663 goto start; 664 } 665 pipe(p); 666 if ((prchild = dofork(pp, DORETURN)) == 0) { /* child */ 667 dup2(fi, 0); /* file is stdin */ 668 dup2(p[1], 1); /* pipe is stdout */ 669 closelog(); 670 closeallfds(3); 671 execl(_PATH_PR, "pr", width, length, 672 "-h", *title ? title : " ", 673 "-L", *locale ? locale : "C", 674 "-F", (char *)0); 675 syslog(LOG_ERR, "cannot execl %s", _PATH_PR); 676 exit(2); 677 } 678 (void) close(p[1]); /* close output side */ 679 (void) close(fi); 680 if (prchild < 0) { 681 prchild = 0; 682 (void) close(p[0]); 683 return (ERROR); 684 } 685 fi = p[0]; /* use pipe for input */ 686 case 'f': /* print plain text file */ 687 prog = pp->filters[LPF_INPUT]; 688 av[1] = width; 689 av[2] = length; 690 av[3] = indent; 691 n = 4; 692 break; 693 case 'o': /* print postscript file */ 694 /* 695 * Treat this as a "plain file with control characters", and 696 * assume the standard LPF_INPUT filter will recognize that 697 * the data is postscript and know what to do with it. These 698 * 'o'-file requests could come from MacOS 10.1 systems. 699 * (later versions of MacOS 10 will explicitly use 'l') 700 * A postscript file can contain binary data, which is why 'l' 701 * is somewhat more appropriate than 'f'. 702 */ 703 /* FALLTHROUGH */ 704 case 'l': /* like 'f' but pass control characters */ 705 prog = pp->filters[LPF_INPUT]; 706 av[1] = "-c"; 707 av[2] = width; 708 av[3] = length; 709 av[4] = indent; 710 n = 5; 711 break; 712 case 'r': /* print a fortran text file */ 713 prog = pp->filters[LPF_FORTRAN]; 714 av[1] = width; 715 av[2] = length; 716 n = 3; 717 break; 718 case 't': /* print troff output */ 719 case 'n': /* print ditroff output */ 720 case 'd': /* print tex output */ 721 (void) unlink(".railmag"); 722 if ((fo = creat(".railmag", FILMOD)) < 0) { 723 syslog(LOG_ERR, "%s: cannot create .railmag", 724 pp->printer); 725 (void) unlink(".railmag"); 726 } else { 727 for (n = 0; n < 4; n++) { 728 if (fonts[n][0] != '/') 729 (void) write(fo, _PATH_VFONT, 730 sizeof(_PATH_VFONT) - 1); 731 (void) write(fo, fonts[n], strlen(fonts[n])); 732 (void) write(fo, "\n", 1); 733 } 734 (void) close(fo); 735 } 736 prog = (format == 't') ? pp->filters[LPF_TROFF] 737 : ((format == 'n') ? pp->filters[LPF_DITROFF] 738 : pp->filters[LPF_DVI]); 739 av[1] = pxwidth; 740 av[2] = pxlength; 741 n = 3; 742 break; 743 case 'c': /* print cifplot output */ 744 prog = pp->filters[LPF_CIFPLOT]; 745 av[1] = pxwidth; 746 av[2] = pxlength; 747 n = 3; 748 break; 749 case 'g': /* print plot(1G) output */ 750 prog = pp->filters[LPF_GRAPH]; 751 av[1] = pxwidth; 752 av[2] = pxlength; 753 n = 3; 754 break; 755 case 'v': /* print raster output */ 756 prog = pp->filters[LPF_RASTER]; 757 av[1] = pxwidth; 758 av[2] = pxlength; 759 n = 3; 760 break; 761 default: 762 (void) close(fi); 763 syslog(LOG_ERR, "%s: illegal format character '%c'", 764 pp->printer, format); 765 return (ERROR); 766 } 767 if (prog == NULL) { 768 (void) close(fi); 769 syslog(LOG_ERR, 770 "%s: no filter found in printcap for format character '%c'", 771 pp->printer, format); 772 return (ERROR); 773 } 774 if ((av[0] = strrchr(prog, '/')) != NULL) 775 av[0]++; 776 else 777 av[0] = prog; 778 av[n++] = "-n"; 779 av[n++] = logname; 780 av[n++] = "-h"; 781 av[n++] = origin_host; 782 av[n++] = pp->acct_file; 783 av[n] = 0; 784 fo = pfd; 785 if (of_pid > 0) { /* stop output filter */ 786 write(ofd, "\031\1", 2); 787 while ((wpid = 788 wait3(&wstatus, WUNTRACED, 0)) > 0 && wpid != of_pid) 789 ; 790 if (wpid < 0) 791 syslog(LOG_WARNING, 792 "%s: after stopping 'of', wait3() returned: %m", 793 pp->printer); 794 else if (!WIFSTOPPED(wstatus)) { 795 (void) close(fi); 796 syslog(LOG_WARNING, "%s: output filter died " 797 "(pid=%d retcode=%d termsig=%d)", 798 pp->printer, of_pid, WEXITSTATUS(wstatus), 799 WTERMSIG(wstatus)); 800 return (REPRINT); 801 } 802 stopped++; 803 } 804 start: 805 if ((child = dofork(pp, DORETURN)) == 0) { /* child */ 806 dup2(fi, 0); 807 dup2(fo, 1); 808 /* setup stderr for the filter (child process) 809 * so it goes to our temporary errors file */ 810 n = open(tempstderr, O_WRONLY|O_TRUNC, 0664); 811 if (n >= 0) 812 dup2(n, 2); 813 closelog(); 814 closeallfds(3); 815 execv(prog, av); 816 syslog(LOG_ERR, "%s: cannot execv(%s): %m", pp->printer, 817 prog); 818 exit(2); 819 } 820 (void) close(fi); 821 wstatus_set = 0; 822 if (child < 0) 823 retcode = 100; 824 else { 825 while ((wpid = wait(&wstatus)) > 0 && wpid != child) 826 ; 827 if (wpid < 0) { 828 retcode = 100; 829 syslog(LOG_WARNING, 830 "%s: after execv(%s), wait() returned: %m", 831 pp->printer, prog); 832 } else { 833 wstatus_set = 1; 834 retcode = WEXITSTATUS(wstatus); 835 } 836 } 837 child = 0; 838 prchild = 0; 839 if (stopped) { /* restart output filter */ 840 if (kill(of_pid, SIGCONT) < 0) { 841 syslog(LOG_ERR, "cannot restart output filter"); 842 exit(1); 843 } 844 } 845 pp->tof = 0; 846 847 /* Copy the filter's output to "lf" logfile */ 848 if ((fp = fopen(tempstderr, "r"))) { 849 while (fgets(buf, sizeof(buf), fp)) 850 fputs(buf, stderr); 851 fclose(fp); 852 } 853 854 if (wstatus_set && !WIFEXITED(wstatus)) { 855 syslog(LOG_WARNING, "%s: filter '%c' terminated (termsig=%d)", 856 pp->printer, format, WTERMSIG(wstatus)); 857 return (ERROR); 858 } 859 switch (retcode) { 860 case 0: 861 pp->tof = 1; 862 return (OK); 863 case 1: 864 return (REPRINT); 865 case 2: 866 return (ERROR); 867 default: 868 syslog(LOG_WARNING, "%s: filter '%c' exited (retcode=%d)", 869 pp->printer, format, retcode); 870 return (FILTERERR); 871 } 872 } 873 874 /* 875 * Send the daemon control file (cf) and any data files. 876 * Return -1 if a non-recoverable error occured, 1 if a recoverable error and 877 * 0 if all is well. 878 */ 879 static int 880 sendit(struct printer *pp, char *file) 881 { 882 int dfcopies, err, i; 883 char *cp, last[BUFSIZ]; 884 885 /* 886 * open control file 887 */ 888 if ((cfp = fopen(file, "r")) == NULL) 889 return (OK); 890 891 /* initialize job-specific count of datafiles processed */ 892 job_dfcnt = 0; 893 894 /* 895 * read the control file for work to do 896 * 897 * file format -- first character in the line is a command 898 * rest of the line is the argument. 899 * commands of interest are: 900 * 901 * a-z -- "file name" name of file to print 902 * U -- "unlink" name of file to remove 903 * (after we print it. (Pass 2 only)). 904 */ 905 906 /* 907 * pass 1 908 */ 909 err = OK; 910 while (getline(cfp)) { 911 again: 912 if (line[0] == 'S') { 913 cp = line+1; 914 i = 0; 915 while (*cp >= '0' && *cp <= '9') 916 i = i * 10 + (*cp++ - '0'); 917 fdev = i; 918 cp++; 919 i = 0; 920 while (*cp >= '0' && *cp <= '9') 921 i = i * 10 + (*cp++ - '0'); 922 fino = i; 923 } else if (line[0] == 'H') { 924 strlcpy(origin_host, line + 1, sizeof(origin_host)); 925 if (class[0] == '\0') { 926 strlcpy(class, line + 1, sizeof(class)); 927 } 928 } else if (line[0] == 'P') { 929 strlcpy(logname, line + 1, sizeof(logname)); 930 if (pp->restricted) { /* restricted */ 931 if (getpwnam(logname) == NULL) { 932 sendmail(pp, line+1, NOACCT); 933 err = ERROR; 934 break; 935 } 936 } 937 } else if (line[0] == 'I') { 938 strlcpy(indent+2, line + 1, sizeof(indent) - 2); 939 } else if (line[0] >= 'a' && line[0] <= 'z') { 940 dfcopies = 1; 941 strcpy(last, line); 942 while ((i = getline(cfp)) != 0) { 943 if (strcmp(last, line) != 0) 944 break; 945 dfcopies++; 946 } 947 switch (sendfile(pp, '\3', last+1, *last, dfcopies)) { 948 case OK: 949 if (i) 950 goto again; 951 break; 952 case REPRINT: 953 (void) fclose(cfp); 954 return (REPRINT); 955 case ACCESS: 956 sendmail(pp, logname, ACCESS); 957 case ERROR: 958 err = ERROR; 959 } 960 break; 961 } 962 } 963 if (err == OK && sendfile(pp, '\2', file, '\0', 1) > 0) { 964 (void) fclose(cfp); 965 return (REPRINT); 966 } 967 /* 968 * pass 2 969 */ 970 fseek(cfp, 0L, 0); 971 while (getline(cfp)) 972 if (line[0] == 'U' && !strchr(line+1, '/')) 973 (void) unlink(line+1); 974 /* 975 * clean-up in case another control file exists 976 */ 977 (void) fclose(cfp); 978 (void) unlink(file); 979 return (err); 980 } 981 982 /* 983 * Send a data file to the remote machine and spool it. 984 * Return positive if we should try resending. 985 */ 986 static int 987 sendfile(struct printer *pp, int type, char *file, char format, int copyreq) 988 { 989 int i, amt; 990 struct stat stb; 991 char *av[15], *filtcmd; 992 char buf[BUFSIZ], opt_c[4], opt_h[4], opt_n[4]; 993 int copycnt, filtstat, narg, resp, sfd, sfres, sizerr, statrc; 994 995 statrc = lstat(file, &stb); 996 if (statrc < 0) { 997 syslog(LOG_ERR, "%s: error from lstat(%s): %m", 998 pp->printer, file); 999 return (ERROR); 1000 } 1001 sfd = open(file, O_RDONLY); 1002 if (sfd < 0) { 1003 syslog(LOG_ERR, "%s: error from open(%s,O_RDONLY): %m", 1004 pp->printer, file); 1005 return (ERROR); 1006 } 1007 /* 1008 * Check to see if data file is a symbolic link. If so, it should 1009 * still point to the same file or someone is trying to print something 1010 * he shouldn't. 1011 */ 1012 if ((stb.st_mode & S_IFMT) == S_IFLNK && fstat(sfd, &stb) == 0 && 1013 (stb.st_dev != fdev || stb.st_ino != fino)) { 1014 close(sfd); 1015 return (ACCESS); 1016 } 1017 1018 /* Everything seems OK for reading the file, now to send it */ 1019 filtcmd = NULL; 1020 sizerr = 0; 1021 tfd = -1; 1022 if (type == '\3') { 1023 /* 1024 * Type == 3 means this is a datafile, not a control file. 1025 * Increment the counter of data-files in this job, and 1026 * then check for input or output filters (which are only 1027 * applied to datafiles, not control files). 1028 */ 1029 job_dfcnt++; 1030 1031 /* 1032 * Note that here we are filtering datafiles, one at a time, 1033 * as they are sent to the remote machine. Here, the *only* 1034 * difference between an input filter (`if=') and an output 1035 * filter (`of=') is the argument list that the filter is 1036 * started up with. Here, the output filter is executed 1037 * for each individual file as it is sent. This is not the 1038 * same as local print queues, where the output filter is 1039 * started up once, and then all jobs are passed thru that 1040 * single invocation of the output filter. 1041 * 1042 * Also note that a queue for a remote-machine can have an 1043 * input filter or an output filter, but not both. 1044 */ 1045 if (pp->filters[LPF_INPUT]) { 1046 filtcmd = pp->filters[LPF_INPUT]; 1047 av[0] = filtcmd; 1048 narg = 0; 1049 strcpy(opt_c, "-c"); 1050 strcpy(opt_h, "-h"); 1051 strcpy(opt_n, "-n"); 1052 if (format == 'l') 1053 av[++narg] = opt_c; 1054 av[++narg] = width; 1055 av[++narg] = length; 1056 av[++narg] = indent; 1057 av[++narg] = opt_n; 1058 av[++narg] = logname; 1059 av[++narg] = opt_h; 1060 av[++narg] = origin_host; 1061 av[++narg] = pp->acct_file; 1062 av[++narg] = NULL; 1063 } else if (pp->filters[LPF_OUTPUT]) { 1064 filtcmd = pp->filters[LPF_OUTPUT]; 1065 av[0] = filtcmd; 1066 narg = 0; 1067 av[++narg] = width; 1068 av[++narg] = length; 1069 av[++narg] = NULL; 1070 } 1071 } 1072 if (filtcmd) { 1073 /* 1074 * If there is an input or output filter, we have to run 1075 * the datafile thru that filter and store the result as 1076 * a temporary spool file, because the protocol requires 1077 * that we send the remote host the file-size before we 1078 * start to send any of the data. 1079 */ 1080 strcpy(tfile, TFILENAME); 1081 tfd = mkstemp(tfile); 1082 if (tfd == -1) { 1083 syslog(LOG_ERR, "%s: mkstemp(%s): %m", pp->printer, 1084 TFILENAME); 1085 sfres = ERROR; 1086 goto return_sfres; 1087 } 1088 filtstat = execfilter(pp, filtcmd, av, sfd, tfd); 1089 1090 /* process the return-code from the filter */ 1091 switch (filtstat) { 1092 case 0: 1093 break; 1094 case 1: 1095 sfres = REPRINT; 1096 goto return_sfres; 1097 case 2: 1098 sfres = ERROR; 1099 goto return_sfres; 1100 default: 1101 syslog(LOG_WARNING, 1102 "%s: filter '%c' exited (retcode=%d)", 1103 pp->printer, format, filtstat); 1104 sfres = FILTERERR; 1105 goto return_sfres; 1106 } 1107 statrc = fstat(tfd, &stb); /* to find size of tfile */ 1108 if (statrc < 0) { 1109 syslog(LOG_ERR, 1110 "%s: error processing 'if', fstat(%s): %m", 1111 pp->printer, tfile); 1112 sfres = ERROR; 1113 goto return_sfres; 1114 } 1115 close(sfd); 1116 sfd = tfd; 1117 lseek(sfd, 0, SEEK_SET); 1118 } 1119 1120 copycnt = 0; 1121 sendagain: 1122 copycnt++; 1123 1124 if (copycnt < 2) 1125 (void) sprintf(buf, "%c%qd %s\n", type, stb.st_size, file); 1126 else 1127 (void) sprintf(buf, "%c%qd %s_c%d\n", type, stb.st_size, 1128 file, copycnt); 1129 amt = strlen(buf); 1130 for (i = 0; ; i++) { 1131 if (write(pfd, buf, amt) != amt || 1132 (resp = response(pp)) < 0 || resp == '\1') { 1133 sfres = REPRINT; 1134 goto return_sfres; 1135 } else if (resp == '\0') 1136 break; 1137 if (i == 0) 1138 pstatus(pp, 1139 "no space on remote; waiting for queue to drain"); 1140 if (i == 10) 1141 syslog(LOG_ALERT, "%s: can't send to %s; queue full", 1142 pp->printer, pp->remote_host); 1143 sleep(5 * 60); 1144 } 1145 if (i) 1146 pstatus(pp, "sending to %s", pp->remote_host); 1147 /* 1148 * XXX - we should change trstat_init()/trstat_write() to include 1149 * the copycnt in the statistics record it may write. 1150 */ 1151 if (type == '\3') 1152 trstat_init(pp, file, job_dfcnt); 1153 for (i = 0; i < stb.st_size; i += BUFSIZ) { 1154 amt = BUFSIZ; 1155 if (i + amt > stb.st_size) 1156 amt = stb.st_size - i; 1157 if (sizerr == 0 && read(sfd, buf, amt) != amt) 1158 sizerr = 1; 1159 if (write(pfd, buf, amt) != amt) { 1160 sfres = REPRINT; 1161 goto return_sfres; 1162 } 1163 } 1164 1165 if (sizerr) { 1166 syslog(LOG_INFO, "%s: %s: changed size", pp->printer, file); 1167 /* tell recvjob to ignore this file */ 1168 (void) write(pfd, "\1", 1); 1169 sfres = ERROR; 1170 goto return_sfres; 1171 } 1172 if (write(pfd, "", 1) != 1 || response(pp)) { 1173 sfres = REPRINT; 1174 goto return_sfres; 1175 } 1176 if (type == '\3') { 1177 trstat_write(pp, TR_SENDING, stb.st_size, logname, 1178 pp->remote_host, origin_host); 1179 /* 1180 * Usually we only need to send one copy of a datafile, 1181 * because the control-file will simply print the same 1182 * file multiple times. However, some printers ignore 1183 * the control file, and simply print each data file as 1184 * it arrives. For such "remote hosts", we need to 1185 * transfer the same data file multiple times. Such a 1186 * a host is indicated by adding 'rc' to the printcap 1187 * entry. 1188 * XXX - Right now this ONLY works for remote hosts which 1189 * do ignore the name of the data file, because 1190 * this sends the file multiple times with slight 1191 * changes to the filename. To do this right would 1192 * require that we also rewrite the control file 1193 * to match those filenames. 1194 */ 1195 if (pp->resend_copies && (copycnt < copyreq)) { 1196 lseek(sfd, 0, SEEK_SET); 1197 goto sendagain; 1198 } 1199 } 1200 sfres = OK; 1201 1202 return_sfres: 1203 (void)close(sfd); 1204 if (tfd != -1) { 1205 /* 1206 * If tfd is set, then it is the same value as sfd, and 1207 * therefore it is already closed at this point. All 1208 * we need to do is remove the temporary file. 1209 */ 1210 tfd = -1; 1211 unlink(tfile); 1212 } 1213 return (sfres); 1214 } 1215 1216 /* 1217 * This routine is called to execute one of the filters as was 1218 * specified in a printcap entry. While the child-process will read 1219 * all of 'infd', it is up to the caller to close that file descriptor 1220 * in the parent process. 1221 */ 1222 static int 1223 execfilter(struct printer *pp, char *f_cmd, char *f_av[], int infd, int outfd) 1224 { 1225 pid_t fpid, wpid; 1226 int errfd, retcode, wstatus; 1227 FILE *errfp; 1228 char buf[BUFSIZ], *slash; 1229 1230 fpid = dofork(pp, DORETURN); 1231 if (fpid != 0) { 1232 /* 1233 * This is the parent process, which just waits for the child 1234 * to complete and then returns the result. Note that it is 1235 * the child process which reads the input stream. 1236 */ 1237 if (fpid < 0) 1238 retcode = 100; 1239 else { 1240 while ((wpid = wait(&wstatus)) > 0 && 1241 wpid != fpid) 1242 ; 1243 if (wpid < 0) { 1244 retcode = 100; 1245 syslog(LOG_WARNING, 1246 "%s: after execv(%s), wait() returned: %m", 1247 pp->printer, f_cmd); 1248 } else 1249 retcode = WEXITSTATUS(wstatus); 1250 } 1251 1252 /* 1253 * Copy everything the filter wrote to stderr from our 1254 * temporary errors file to the "lf=" logfile. 1255 */ 1256 errfp = fopen(tempstderr, "r"); 1257 if (errfp) { 1258 while (fgets(buf, sizeof(buf), errfp)) 1259 fputs(buf, stderr); 1260 fclose(errfp); 1261 } 1262 1263 return (retcode); 1264 } 1265 1266 /* 1267 * This is the child process, which is the one that executes the 1268 * given filter. 1269 */ 1270 /* 1271 * If the first parameter has any slashes in it, then change it 1272 * to point to the first character after the last slash. 1273 */ 1274 slash = strrchr(f_av[0], '/'); 1275 if (slash != NULL) 1276 f_av[0] = slash + 1; 1277 /* 1278 * XXX - in the future, this should setup an explicit list of 1279 * environment variables and use execve()! 1280 */ 1281 1282 /* 1283 * Setup stdin, stdout, and stderr as we want them when the filter 1284 * is running. Stderr is setup so it points to a temporary errors 1285 * file, and the parent process will copy that temporary file to 1286 * the real logfile after the filter completes. 1287 */ 1288 dup2(infd, 0); 1289 dup2(outfd, 1); 1290 errfd = open(tempstderr, O_WRONLY|O_TRUNC, 0664); 1291 if (errfd >= 0) 1292 dup2(errfd, 2); 1293 closelog(); 1294 closeallfds(3); 1295 execv(f_cmd, f_av); 1296 syslog(LOG_ERR, "%s: cannot execv(%s): %m", pp->printer, f_cmd); 1297 exit(2); 1298 /* NOTREACHED */ 1299 } 1300 1301 /* 1302 * Check to make sure there have been no errors and that both programs 1303 * are in sync with eachother. 1304 * Return non-zero if the connection was lost. 1305 */ 1306 static char 1307 response(const struct printer *pp) 1308 { 1309 char resp; 1310 1311 if (read(pfd, &resp, 1) != 1) { 1312 syslog(LOG_INFO, "%s: lost connection", pp->printer); 1313 return (-1); 1314 } 1315 return (resp); 1316 } 1317 1318 /* 1319 * Banner printing stuff 1320 */ 1321 static void 1322 banner(struct printer *pp, char *name1, char *name2) 1323 { 1324 time_t tvec; 1325 1326 time(&tvec); 1327 if (!pp->no_formfeed && !pp->tof) 1328 (void) write(ofd, pp->form_feed, strlen(pp->form_feed)); 1329 if (pp->short_banner) { /* short banner only */ 1330 if (class[0]) { 1331 (void) write(ofd, class, strlen(class)); 1332 (void) write(ofd, ":", 1); 1333 } 1334 (void) write(ofd, name1, strlen(name1)); 1335 (void) write(ofd, " Job: ", 7); 1336 (void) write(ofd, name2, strlen(name2)); 1337 (void) write(ofd, " Date: ", 8); 1338 (void) write(ofd, ctime(&tvec), 24); 1339 (void) write(ofd, "\n", 1); 1340 } else { /* normal banner */ 1341 (void) write(ofd, "\n\n\n", 3); 1342 scan_out(pp, ofd, name1, '\0'); 1343 (void) write(ofd, "\n\n", 2); 1344 scan_out(pp, ofd, name2, '\0'); 1345 if (class[0]) { 1346 (void) write(ofd,"\n\n\n",3); 1347 scan_out(pp, ofd, class, '\0'); 1348 } 1349 (void) write(ofd, "\n\n\n\n\t\t\t\t\tJob: ", 15); 1350 (void) write(ofd, name2, strlen(name2)); 1351 (void) write(ofd, "\n\t\t\t\t\tDate: ", 12); 1352 (void) write(ofd, ctime(&tvec), 24); 1353 (void) write(ofd, "\n", 1); 1354 } 1355 if (!pp->no_formfeed) 1356 (void) write(ofd, pp->form_feed, strlen(pp->form_feed)); 1357 pp->tof = 1; 1358 } 1359 1360 static char * 1361 scnline(int key, char *p, int c) 1362 { 1363 register int scnwidth; 1364 1365 for (scnwidth = WIDTH; --scnwidth;) { 1366 key <<= 1; 1367 *p++ = key & 0200 ? c : BACKGND; 1368 } 1369 return (p); 1370 } 1371 1372 #define TRC(q) (((q)-' ')&0177) 1373 1374 static void 1375 scan_out(struct printer *pp, int scfd, char *scsp, int dlm) 1376 { 1377 register char *strp; 1378 register int nchrs, j; 1379 char outbuf[LINELEN+1], *sp, c, cc; 1380 int d, scnhgt; 1381 1382 for (scnhgt = 0; scnhgt++ < HEIGHT+DROP; ) { 1383 strp = &outbuf[0]; 1384 sp = scsp; 1385 for (nchrs = 0; ; ) { 1386 d = dropit(c = TRC(cc = *sp++)); 1387 if ((!d && scnhgt > HEIGHT) || (scnhgt <= DROP && d)) 1388 for (j = WIDTH; --j;) 1389 *strp++ = BACKGND; 1390 else 1391 strp = scnline(scnkey[(int)c][scnhgt-1-d], strp, cc); 1392 if (*sp == dlm || *sp == '\0' || 1393 nchrs++ >= pp->page_width/(WIDTH+1)-1) 1394 break; 1395 *strp++ = BACKGND; 1396 *strp++ = BACKGND; 1397 } 1398 while (*--strp == BACKGND && strp >= outbuf) 1399 ; 1400 strp++; 1401 *strp++ = '\n'; 1402 (void) write(scfd, outbuf, strp-outbuf); 1403 } 1404 } 1405 1406 static int 1407 dropit(int c) 1408 { 1409 switch(c) { 1410 1411 case TRC('_'): 1412 case TRC(';'): 1413 case TRC(','): 1414 case TRC('g'): 1415 case TRC('j'): 1416 case TRC('p'): 1417 case TRC('q'): 1418 case TRC('y'): 1419 return (DROP); 1420 1421 default: 1422 return (0); 1423 } 1424 } 1425 1426 /* 1427 * sendmail --- 1428 * tell people about job completion 1429 */ 1430 static void 1431 sendmail(struct printer *pp, char *userid, int bombed) 1432 { 1433 register int i; 1434 int p[2], s; 1435 register const char *cp; 1436 struct stat stb; 1437 FILE *fp; 1438 1439 pipe(p); 1440 if ((s = dofork(pp, DORETURN)) == 0) { /* child */ 1441 dup2(p[0], 0); 1442 closelog(); 1443 closeallfds(3); 1444 if ((cp = strrchr(_PATH_SENDMAIL, '/')) != NULL) 1445 cp++; 1446 else 1447 cp = _PATH_SENDMAIL; 1448 execl(_PATH_SENDMAIL, cp, "-t", (char *)0); 1449 _exit(0); 1450 } else if (s > 0) { /* parent */ 1451 dup2(p[1], 1); 1452 printf("To: %s@%s\n", userid, origin_host); 1453 printf("Subject: %s printer job \"%s\"\n", pp->printer, 1454 *jobname ? jobname : "<unknown>"); 1455 printf("Reply-To: root@%s\n\n", local_host); 1456 printf("Your printer job "); 1457 if (*jobname) 1458 printf("(%s) ", jobname); 1459 1460 switch (bombed) { 1461 case OK: 1462 cp = "OK"; 1463 printf("\ncompleted successfully\n"); 1464 break; 1465 default: 1466 case FATALERR: 1467 cp = "FATALERR"; 1468 printf("\ncould not be printed\n"); 1469 break; 1470 case NOACCT: 1471 cp = "NOACCT"; 1472 printf("\ncould not be printed without an account on %s\n", 1473 local_host); 1474 break; 1475 case FILTERERR: 1476 cp = "FILTERERR"; 1477 if (stat(tempstderr, &stb) < 0 || stb.st_size == 0 1478 || (fp = fopen(tempstderr, "r")) == NULL) { 1479 printf("\nhad some errors and may not have printed\n"); 1480 break; 1481 } 1482 printf("\nhad the following errors and may not have printed:\n"); 1483 while ((i = getc(fp)) != EOF) 1484 putchar(i); 1485 (void) fclose(fp); 1486 break; 1487 case ACCESS: 1488 cp = "ACCESS"; 1489 printf("\nwas not printed because it was not linked to the original file\n"); 1490 } 1491 fflush(stdout); 1492 (void) close(1); 1493 } else { 1494 syslog(LOG_WARNING, "unable to send mail to %s: %m", userid); 1495 return; 1496 } 1497 (void) close(p[0]); 1498 (void) close(p[1]); 1499 wait(NULL); 1500 syslog(LOG_INFO, "mail sent to user %s about job %s on printer %s (%s)", 1501 userid, *jobname ? jobname : "<unknown>", pp->printer, cp); 1502 } 1503 1504 /* 1505 * dofork - fork with retries on failure 1506 */ 1507 static int 1508 dofork(const struct printer *pp, int action) 1509 { 1510 pid_t forkpid; 1511 int i, fail; 1512 struct passwd *pwd; 1513 1514 forkpid = -1; 1515 if (daemon_uname == NULL) { 1516 pwd = getpwuid(pp->daemon_user); 1517 if (pwd == NULL) { 1518 syslog(LOG_ERR, "%s: Can't lookup default daemon uid (%ld) in password file", 1519 pp->printer, pp->daemon_user); 1520 goto error_ret; 1521 } 1522 daemon_uname = strdup(pwd->pw_name); 1523 daemon_defgid = pwd->pw_gid; 1524 } 1525 1526 for (i = 0; i < 20; i++) { 1527 forkpid = fork(); 1528 if (forkpid < 0) { 1529 sleep((unsigned)(i*i)); 1530 continue; 1531 } 1532 /* 1533 * Child should run as daemon instead of root 1534 */ 1535 if (forkpid == 0) { 1536 errno = 0; 1537 fail = initgroups(daemon_uname, daemon_defgid); 1538 if (fail) { 1539 syslog(LOG_ERR, "%s: initgroups(%s,%u): %m", 1540 pp->printer, daemon_uname, daemon_defgid); 1541 break; 1542 } 1543 fail = setgid(daemon_defgid); 1544 if (fail) { 1545 syslog(LOG_ERR, "%s: setgid(%u): %m", 1546 pp->printer, daemon_defgid); 1547 break; 1548 } 1549 fail = setuid(pp->daemon_user); 1550 if (fail) { 1551 syslog(LOG_ERR, "%s: setuid(%ld): %m", 1552 pp->printer, pp->daemon_user); 1553 break; 1554 } 1555 } 1556 return (forkpid); 1557 } 1558 1559 /* 1560 * An error occurred. If the error is in the child process, then 1561 * this routine MUST always exit(). DORETURN only effects how 1562 * errors should be handled in the parent process. 1563 */ 1564 error_ret: 1565 if (forkpid == 0) { 1566 syslog(LOG_ERR, "%s: dofork(): aborting child process...", 1567 pp->printer); 1568 exit(1); 1569 } 1570 syslog(LOG_ERR, "%s: dofork(): failure in fork", pp->printer); 1571 1572 sleep(1); /* throttle errors, as a safety measure */ 1573 switch (action) { 1574 case DORETURN: 1575 return (-1); 1576 default: 1577 syslog(LOG_ERR, "bad action (%d) to dofork", action); 1578 /* FALLTHROUGH */ 1579 case DOABORT: 1580 exit(1); 1581 } 1582 /*NOTREACHED*/ 1583 } 1584 1585 /* 1586 * Kill child processes to abort current job. 1587 */ 1588 static void 1589 abortpr(int signo __unused) 1590 { 1591 1592 (void) unlink(tempstderr); 1593 kill(0, SIGINT); 1594 if (of_pid > 0) 1595 kill(of_pid, SIGCONT); 1596 while (wait(NULL) > 0) 1597 ; 1598 if (of_pid > 0 && tfd != -1) 1599 unlink(tfile); 1600 exit(0); 1601 } 1602 1603 static void 1604 init(struct printer *pp) 1605 { 1606 char *s; 1607 1608 sprintf(&width[2], "%ld", pp->page_width); 1609 sprintf(&length[2], "%ld", pp->page_length); 1610 sprintf(&pxwidth[2], "%ld", pp->page_pwidth); 1611 sprintf(&pxlength[2], "%ld", pp->page_plength); 1612 if ((s = checkremote(pp)) != 0) { 1613 syslog(LOG_WARNING, "%s", s); 1614 free(s); 1615 } 1616 } 1617 1618 void 1619 startprinting(const char *printer) 1620 { 1621 struct printer myprinter, *pp = &myprinter; 1622 int status; 1623 1624 init_printer(pp); 1625 status = getprintcap(printer, pp); 1626 switch(status) { 1627 case PCAPERR_OSERR: 1628 syslog(LOG_ERR, "can't open printer description file: %m"); 1629 exit(1); 1630 case PCAPERR_NOTFOUND: 1631 syslog(LOG_ERR, "unknown printer: %s", printer); 1632 exit(1); 1633 case PCAPERR_TCLOOP: 1634 fatal(pp, "potential reference loop detected in printcap file"); 1635 default: 1636 break; 1637 } 1638 printjob(pp); 1639 } 1640 1641 /* 1642 * Acquire line printer or remote connection. 1643 */ 1644 static void 1645 openpr(const struct printer *pp) 1646 { 1647 int p[2]; 1648 char *cp; 1649 1650 if (pp->remote) { 1651 openrem(pp); 1652 /* 1653 * Lpd does support the setting of 'of=' filters for 1654 * jobs going to remote machines, but that does not 1655 * have the same meaning as 'of=' does when handling 1656 * local print queues. For remote machines, all 'of=' 1657 * filter processing is handled in sendfile(), and that 1658 * does not use these global "output filter" variables. 1659 */ 1660 ofd = -1; 1661 of_pid = 0; 1662 return; 1663 } else if (*pp->lp) { 1664 if ((cp = strchr(pp->lp, '@')) != NULL) 1665 opennet(pp); 1666 else 1667 opentty(pp); 1668 } else { 1669 syslog(LOG_ERR, "%s: no line printer device or host name", 1670 pp->printer); 1671 exit(1); 1672 } 1673 1674 /* 1675 * Start up an output filter, if needed. 1676 */ 1677 if (pp->filters[LPF_OUTPUT] && !pp->filters[LPF_INPUT] && !of_pid) { 1678 pipe(p); 1679 if (pp->remote) { 1680 strcpy(tfile, TFILENAME); 1681 tfd = mkstemp(tfile); 1682 } 1683 if ((of_pid = dofork(pp, DOABORT)) == 0) { /* child */ 1684 dup2(p[0], 0); /* pipe is std in */ 1685 /* tfile/printer is stdout */ 1686 dup2(pp->remote ? tfd : pfd, 1); 1687 closelog(); 1688 closeallfds(3); 1689 if ((cp = strrchr(pp->filters[LPF_OUTPUT], '/')) == NULL) 1690 cp = pp->filters[LPF_OUTPUT]; 1691 else 1692 cp++; 1693 execl(pp->filters[LPF_OUTPUT], cp, width, length, 1694 (char *)0); 1695 syslog(LOG_ERR, "%s: execl(%s): %m", pp->printer, 1696 pp->filters[LPF_OUTPUT]); 1697 exit(1); 1698 } 1699 (void) close(p[0]); /* close input side */ 1700 ofd = p[1]; /* use pipe for output */ 1701 } else { 1702 ofd = pfd; 1703 of_pid = 0; 1704 } 1705 } 1706 1707 /* 1708 * Printer connected directly to the network 1709 * or to a terminal server on the net 1710 */ 1711 static void 1712 opennet(const struct printer *pp) 1713 { 1714 register int i; 1715 int resp; 1716 u_long port; 1717 char *ep; 1718 void (*savealrm)(int); 1719 1720 port = strtoul(pp->lp, &ep, 0); 1721 if (*ep != '@' || port > 65535) { 1722 syslog(LOG_ERR, "%s: bad port number: %s", pp->printer, 1723 pp->lp); 1724 exit(1); 1725 } 1726 ep++; 1727 1728 for (i = 1; ; i = i < 256 ? i << 1 : i) { 1729 resp = -1; 1730 savealrm = signal(SIGALRM, alarmhandler); 1731 alarm(pp->conn_timeout); 1732 pfd = getport(pp, ep, port); 1733 alarm(0); 1734 (void)signal(SIGALRM, savealrm); 1735 if (pfd < 0 && errno == ECONNREFUSED) 1736 resp = 1; 1737 else if (pfd >= 0) { 1738 /* 1739 * need to delay a bit for rs232 lines 1740 * to stabilize in case printer is 1741 * connected via a terminal server 1742 */ 1743 delay(500); 1744 break; 1745 } 1746 if (i == 1) { 1747 if (resp < 0) 1748 pstatus(pp, "waiting for %s to come up", 1749 pp->lp); 1750 else 1751 pstatus(pp, 1752 "waiting for access to printer on %s", 1753 pp->lp); 1754 } 1755 sleep(i); 1756 } 1757 pstatus(pp, "sending to %s port %lu", ep, port); 1758 } 1759 1760 /* 1761 * Printer is connected to an RS232 port on this host 1762 */ 1763 static void 1764 opentty(const struct printer *pp) 1765 { 1766 register int i; 1767 1768 for (i = 1; ; i = i < 32 ? i << 1 : i) { 1769 pfd = open(pp->lp, pp->rw ? O_RDWR : O_WRONLY); 1770 if (pfd >= 0) { 1771 delay(500); 1772 break; 1773 } 1774 if (errno == ENOENT) { 1775 syslog(LOG_ERR, "%s: %m", pp->lp); 1776 exit(1); 1777 } 1778 if (i == 1) 1779 pstatus(pp, 1780 "waiting for %s to become ready (offline?)", 1781 pp->printer); 1782 sleep(i); 1783 } 1784 if (isatty(pfd)) 1785 setty(pp); 1786 pstatus(pp, "%s is ready and printing", pp->printer); 1787 } 1788 1789 /* 1790 * Printer is on a remote host 1791 */ 1792 static void 1793 openrem(const struct printer *pp) 1794 { 1795 register int i; 1796 int resp; 1797 void (*savealrm)(int); 1798 1799 for (i = 1; ; i = i < 256 ? i << 1 : i) { 1800 resp = -1; 1801 savealrm = signal(SIGALRM, alarmhandler); 1802 alarm(pp->conn_timeout); 1803 pfd = getport(pp, pp->remote_host, 0); 1804 alarm(0); 1805 (void)signal(SIGALRM, savealrm); 1806 if (pfd >= 0) { 1807 if ((writel(pfd, "\2", pp->remote_queue, "\n", 1808 (char *)0) 1809 == 2 + strlen(pp->remote_queue)) 1810 && (resp = response(pp)) == 0) 1811 break; 1812 (void) close(pfd); 1813 } 1814 if (i == 1) { 1815 if (resp < 0) 1816 pstatus(pp, "waiting for %s to come up", 1817 pp->remote_host); 1818 else { 1819 pstatus(pp, 1820 "waiting for queue to be enabled on %s", 1821 pp->remote_host); 1822 i = 256; 1823 } 1824 } 1825 sleep(i); 1826 } 1827 pstatus(pp, "sending to %s", pp->remote_host); 1828 } 1829 1830 /* 1831 * setup tty lines. 1832 */ 1833 static void 1834 setty(const struct printer *pp) 1835 { 1836 struct termios ttybuf; 1837 1838 if (ioctl(pfd, TIOCEXCL, (char *)0) < 0) { 1839 syslog(LOG_ERR, "%s: ioctl(TIOCEXCL): %m", pp->printer); 1840 exit(1); 1841 } 1842 if (tcgetattr(pfd, &ttybuf) < 0) { 1843 syslog(LOG_ERR, "%s: tcgetattr: %m", pp->printer); 1844 exit(1); 1845 } 1846 if (pp->baud_rate > 0) 1847 cfsetspeed(&ttybuf, pp->baud_rate); 1848 if (pp->mode_set) { 1849 char *s = strdup(pp->mode_set), *tmp; 1850 1851 while ((tmp = strsep(&s, ",")) != NULL) { 1852 (void) msearch(tmp, &ttybuf); 1853 } 1854 } 1855 if (pp->mode_set != 0 || pp->baud_rate > 0) { 1856 if (tcsetattr(pfd, TCSAFLUSH, &ttybuf) == -1) { 1857 syslog(LOG_ERR, "%s: tcsetattr: %m", pp->printer); 1858 } 1859 } 1860 } 1861 1862 #include <stdarg.h> 1863 1864 static void 1865 pstatus(const struct printer *pp, const char *msg, ...) 1866 { 1867 int fd; 1868 char *buf; 1869 va_list ap; 1870 va_start(ap, msg); 1871 1872 umask(0); 1873 fd = open(pp->status_file, O_WRONLY|O_CREAT|O_EXLOCK, STAT_FILE_MODE); 1874 if (fd < 0) { 1875 syslog(LOG_ERR, "%s: open(%s): %m", pp->printer, 1876 pp->status_file); 1877 exit(1); 1878 } 1879 ftruncate(fd, 0); 1880 vasprintf(&buf, msg, ap); 1881 va_end(ap); 1882 writel(fd, buf, "\n", (char *)0); 1883 close(fd); 1884 free(buf); 1885 } 1886 1887 void 1888 alarmhandler(int signo __unused) 1889 { 1890 /* the signal is ignored */ 1891 /* (the '__unused' is just to avoid a compile-time warning) */ 1892 } 1893