usr.sbin/lpr/lpd/printjob.c

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