usr.sbin/lpr/lpr/lpr.c

   1 /*
   2  * Copyright (c) 1983, 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * (c) UNIX System Laboratories, Inc.
   5  * All or some portions of this file are derived from material licensed
   6  * to the University of California by American Telephone and Telegraph
   7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   8  * the permission of UNIX System Laboratories, Inc.
   9  *
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *      This product includes software developed by the University of
  22  *      California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef lint
  41 static const char copyright[] =
  42 "@(#) Copyright (c) 1983, 1989, 1993\n\
  43         The Regents of the University of California.  All rights reserved.\n";
  44 #endif /* not lint */
  45
  46 #if 0
  47 #ifndef lint
  48 static char sccsid[] = "@(#)lpr.c       8.4 (Berkeley) 4/28/95";
  49 #endif /* not lint */
  50 #endif
  51
  52 #include "lp.cdefs.h"           /* A cross-platform version of <sys/cdefs.h> */
  53 __FBSDID("$FreeBSD$");
  54
  55 /*
  56  *      lpr -- off line print
  57  *
  58  * Allows multiple printers and printers on remote machines by
  59  * using information from a printer data base.
  60  */
  61
  62 #include <sys/param.h>
  63 #include <sys/stat.h>
  64
  65 #include <netinet/in.h>         /* N_BADMAG uses ntohl() */
  66
  67 #include <dirent.h>
  68 #include <fcntl.h>
  69 #include <a.out.h>
  70 #include <err.h>
  71 #include <locale.h>
  72 #include <signal.h>
  73 #include <syslog.h>
  74 #include <pwd.h>
  75 #include <grp.h>
  76 #include <unistd.h>
  77 #include <stdlib.h>
  78 #include <stdint.h>
  79 #include <stdio.h>
  80 #include <ctype.h>
  81 #include <string.h>
  82 #include "lp.h"
  83 #include "lp.local.h"
  84 #include "pathnames.h"
  85
  86 static char     *cfname;        /* daemon control files, linked from tf's */
  87 static char     *class = local_host;    /* class title on header page */
  88 static char     *dfname;        /* data files */
  89 static char     *fonts[4];      /* troff font names */
  90 static char      format = 'f';  /* format char for printing files */
  91 static int       hdr = 1;       /* print header or not (default is yes) */
  92 static int       iflag;         /* indentation wanted */
  93 static int       inchar;        /* location to increment char in file names */
  94 static int       indent;        /* amount to indent */
  95 static const char *jobname;     /* job name on header page */
  96 static int       mailflg;       /* send mail */
  97 static int       nact;          /* number of jobs to act on */
  98 static int       ncopies = 1;   /* # of copies to make */
  99 static char     *lpr_username;  /* person sending the print job(s) */
 100 static int       qflag;         /* q job, but don't exec daemon */
 101 static int       rflag;         /* remove files upon completion */
 102 static int       sflag;         /* symbolic link flag */
 103 static int       tfd;           /* control file descriptor */
 104 static char     *tfname;        /* tmp copy of cf before linking */
 105 static char     *title;         /* pr'ing title */
 106 static char     *locale;        /* pr'ing locale */
 107 static int       userid;        /* user id */
 108 static char     *Uflag;         /* user name specified with -U flag */
 109 static char     *width;         /* width for versatec printing */
 110 static char     *Zflag;         /* extra filter options for LPRng servers */
 111
 112 static struct stat statb;
 113
 114 static void      card(int _c, const char *_p2);
 115 static int       checkwriteperm(const char *_file, const char *_directory);
 116 static void      chkprinter(const char *_ptrname, struct printer *_pp);
 117 static void      cleanup(int _signo);
 118 static void      copy(const struct printer *_pp, int _f, const char _n[]);
 119 static char     *itoa(int _i);
 120 static const char  *linked(const char *_file);
 121 int              main(int _argc, char *_argv[]);
 122 static char     *lmktemp(const struct printer *_pp, const char *_id,
 123                     int _num, int len);
 124 static void      mktemps(const struct printer *_pp);
 125 static int       nfile(char *_n);
 126 static int       test(const char *_file);
 127 static void      usage(void);
 128
 129 uid_t   uid, euid;
 130
 131 int
 132 main(int argc, char *argv[])
 133 {
 134         struct passwd *pw;
 135         struct group *gptr;
 136         const char *arg, *cp, *printer;
 137         char *p;
 138         char buf[BUFSIZ];
 139         int c, i, f, errs;
 140         int      ret, didlink;
 141         struct stat stb;
 142         struct stat statb1, statb2;
 143         struct printer myprinter, *pp = &myprinter;
 144
 145         printer = NULL;
 146         euid = geteuid();
 147         uid = getuid();
 148         PRIV_END
 149         if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
 150                 signal(SIGHUP, cleanup);
 151         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
 152                 signal(SIGINT, cleanup);
 153         if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
 154                 signal(SIGQUIT, cleanup);
 155         if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
 156                 signal(SIGTERM, cleanup);
 157
 158         progname = argv[0];
 159         gethostname(local_host, sizeof(local_host));
 160         openlog("lpd", 0, LOG_LPR);
 161
 162         errs = 0;
 163         while ((c = getopt(argc, argv,
 164                            ":#:1:2:3:4:C:J:L:P:T:U:Z:cdfghi:lnmprstvw:"))
 165                != -1)
 166                 switch (c) {
 167                 case '#':               /* n copies */
 168                         i = strtol(optarg, &p, 10);
 169                         if (*p)
 170                                 errx(1, "Bad argument to -#, number expected");
 171                         if (i > 0)
 172                                 ncopies = i;
 173                         break;
 174
 175                 case '1':               /* troff fonts */
 176                 case '2':
 177                 case '3':
 178                 case '4':
 179                         fonts[optopt - '1'] = optarg;
 180                         break;
 181
 182                 case 'C':               /* classification spec */
 183                         hdr++;
 184                         class = optarg;
 185                         break;
 186
 187                 case 'J':               /* job name */
 188                         hdr++;
 189                         jobname = optarg;
 190                         break;
 191
 192                 case 'P':               /* specifiy printer name */
 193                         printer = optarg;
 194                         break;
 195
 196                 case 'L':               /* pr's locale */
 197                         locale = optarg;
 198                         break;
 199
 200                 case 'T':               /* pr's title line */
 201                         title = optarg;
 202                         break;
 203
 204                 case 'U':               /* user name */
 205                         hdr++;
 206                         Uflag = optarg;
 207                         break;
 208
 209                 case 'Z':
 210                         Zflag = optarg;
 211                         break;
 212
 213                 case 'c':               /* print cifplot output */
 214                 case 'd':               /* print tex output (dvi files) */
 215                 case 'g':               /* print graph(1G) output */
 216                 case 'l':               /* literal output */
 217                 case 'n':               /* print ditroff output */
 218                 case 't':               /* print troff output (cat files) */
 219                 case 'p':               /* print using ``pr'' */
 220                 case 'v':               /* print vplot output */
 221                         format = optopt;
 222                         break;
 223
 224                 case 'f':               /* print fortran output */
 225                         format = 'r';
 226                         break;
 227
 228                 case 'h':               /* nulifiy header page */
 229                         hdr = 0;
 230                         break;
 231
 232                 case 'i':               /* indent output */
 233                         iflag++;
 234                         indent = strtol(optarg, &p, 10);
 235                         if (*p)
 236                                 errx(1, "Bad argument to -i, number expected");
 237                         break;
 238
 239                 case 'm':               /* send mail when done */
 240                         mailflg++;
 241                         break;
 242
 243                 case 'q':               /* just queue job */
 244                         qflag++;
 245                         break;
 246
 247                 case 'r':               /* remove file when done */
 248                         rflag++;
 249                         break;
 250
 251                 case 's':               /* try to link files */
 252                         sflag++;
 253                         break;
 254
 255                 case 'w':               /* versatec page width */
 256                         width = optarg;
 257                         break;
 258
 259                 case ':':               /* catch "missing argument" error */
 260                         if (optopt == 'i') {
 261                                 iflag++; /* -i without args is valid */
 262                                 indent = 8;
 263                         } else
 264                                 errs++;
 265                         break;
 266
 267                 default:
 268                         errs++;
 269                 }
 270         argc -= optind;
 271         argv += optind;
 272         if (errs)
 273                 usage();
 274         if (printer == NULL && (printer = getenv("PRINTER")) == NULL)
 275                 printer = DEFLP;
 276         chkprinter(printer, pp);
 277         if (pp->no_copies && ncopies > 1)
 278                 errx(1, "multiple copies are not allowed");
 279         if (pp->max_copies > 0 && ncopies > pp->max_copies)
 280                 errx(1, "only %ld copies are allowed", pp->max_copies);
 281         /*
 282          * Get the identity of the person doing the lpr using the same
 283          * algorithm as lprm.  Actually, not quite -- lprm will override
 284          * the login name with "root" if the user is running as root;
 285          * the daemon actually checks for the string "root" in its
 286          * permission checking.  Sigh.
 287          */
 288         userid = getuid();
 289         if (Uflag) {
 290                 if (userid != 0 && userid != pp->daemon_user)
 291                         errx(1, "only privileged users may use the `-U' flag");
 292                 lpr_username = Uflag;           /* -U person doing 'lpr' */
 293         } else {
 294                 lpr_username = getlogin();      /* person doing 'lpr' */
 295                 if (userid != pp->daemon_user || lpr_username == 0) {
 296                         if ((pw = getpwuid(userid)) == NULL)
 297                                 errx(1, "Who are you?");
 298                         lpr_username = pw->pw_name;
 299                 }
 300         }
 301
 302         /*
 303          * Check for restricted group access.
 304          */
 305         if (pp->restrict_grp != NULL && userid != pp->daemon_user) {
 306                 if ((gptr = getgrnam(pp->restrict_grp)) == NULL)
 307                         errx(1, "Restricted group specified incorrectly");
 308                 if (gptr->gr_gid != getgid()) {
 309                         while (*gptr->gr_mem != NULL) {
 310                                 if ((strcmp(lpr_username, *gptr->gr_mem)) == 0)
 311                                         break;
 312                                 gptr->gr_mem++;
 313                         }
 314                         if (*gptr->gr_mem == NULL)
 315                                 errx(1, "Not a member of the restricted group");
 316                 }
 317         }
 318         /*
 319          * Check to make sure queuing is enabled if userid is not root.
 320          */
 321         lock_file_name(pp, buf, sizeof buf);
 322         if (userid && stat(buf, &stb) == 0 && (stb.st_mode & LFM_QUEUE_DIS))
 323                 errx(1, "Printer queue is disabled");
 324         /*
 325          * Initialize the control file.
 326          */
 327         mktemps(pp);
 328         tfd = nfile(tfname);
 329         PRIV_START
 330         (void) fchown(tfd, pp->daemon_user, -1);
 331         /* owned by daemon for protection */
 332         PRIV_END
 333         card('H', local_host);
 334         card('P', lpr_username);
 335         card('C', class);
 336         if (hdr && !pp->no_header) {
 337                 if (jobname == NULL) {
 338                         if (argc == 0)
 339                                 jobname = "stdin";
 340                         else
 341                                 jobname = ((arg = strrchr(argv[0], '/'))
 342                                            ? arg + 1 : argv[0]);
 343                 }
 344                 card('J', jobname);
 345                 card('L', lpr_username);
 346         }
 347         if (format != 'p' && Zflag != 0)
 348                 card('Z', Zflag);
 349         if (iflag)
 350                 card('I', itoa(indent));
 351         if (mailflg)
 352                 card('M', lpr_username);
 353         if (format == 't' || format == 'n' || format == 'd')
 354                 for (i = 0; i < 4; i++)
 355                         if (fonts[i] != NULL)
 356                                 card('1'+i, fonts[i]);
 357         if (width != NULL)
 358                 card('W', width);
 359         /*
 360          * XXX
 361          * Our use of `Z' here is incompatible with LPRng's
 362          * use.  We assume that the only use of our existing
 363          * `Z' card is as shown for `p' format (pr) files.
 364          */
 365         if (format == 'p') {
 366                 char *s;
 367
 368                 if (locale)
 369                         card('Z', locale);
 370                 else if ((s = setlocale(LC_TIME, "")) != NULL)
 371                         card('Z', s);
 372         }
 373
 374         /*
 375          * Read the files and spool them.
 376          */
 377         if (argc == 0)
 378                 copy(pp, 0, " ");
 379         else while (argc--) {
 380                 if (argv[0][0] == '-' && argv[0][1] == '\0') {
 381                         /* use stdin */
 382                         copy(pp, 0, " ");
 383                         argv++;
 384                         continue;
 385                 }
 386                 if ((f = test(arg = *argv++)) < 0)
 387                         continue;       /* file unreasonable */
 388
 389                 if (sflag && (cp = linked(arg)) != NULL) {
 390                         (void)snprintf(buf, sizeof(buf), "%u %ju",
 391                             statb.st_dev, (uintmax_t)statb.st_ino);
 392                         card('S', buf);
 393                         if (format == 'p')
 394                                 card('T', title ? title : arg);
 395                         for (i = 0; i < ncopies; i++)
 396                                 card(format, &dfname[inchar-2]);
 397                         card('U', &dfname[inchar-2]);
 398                         if (f)
 399                                 card('U', cp);
 400                         card('N', arg);
 401                         dfname[inchar]++;
 402                         nact++;
 403                         continue;
 404                 }
 405                 if (sflag)
 406                         printf("%s: %s: not linked, copying instead\n",
 407                             progname, arg);
 408
 409                 if (f) {
 410                         /*
 411                          * The user wants the file removed after it is copied
 412                          * to the spool area, so see if the file can be moved
 413                          * instead of copy/unlink'ed.  This is much faster and
 414                          * uses less spool space than copying the file.  This
 415                          * can be very significant when running services like
 416                          * samba, pcnfs, CAP, et al.
 417                          */
 418                         PRIV_START
 419                         didlink = 0;
 420                         /*
 421                          * There are several things to check to avoid any
 422                          * security issues.  Some of these are redundant
 423                          * under BSD's, but are necessary when lpr is built
 424                          * under some other OS's (which I do do...)
 425                          */
 426                         if (lstat(arg, &statb1) < 0)
 427                                 goto nohardlink;
 428                         if (S_ISLNK(statb1.st_mode))
 429                                 goto nohardlink;
 430                         if (link(arg, dfname) != 0)
 431                                 goto nohardlink;
 432                         didlink = 1;
 433                         /*
 434                          * Make sure the user hasn't tried to trick us via
 435                          * any race conditions
 436                          */
 437                         if (lstat(dfname, &statb2) < 0)
 438                                 goto nohardlink;
 439                         if (statb1.st_dev != statb2.st_dev)
 440                                 goto nohardlink;
 441                         if (statb1.st_ino != statb2.st_ino)
 442                                 goto nohardlink;
 443                         /*
 444                          * Skip if the file already had multiple hard links,
 445                          * because changing the owner and access-bits would
 446                          * change ALL versions of the file
 447                          */
 448                         if (statb2.st_nlink > 2)
 449                                 goto nohardlink;
 450                         /*
 451                          * If we can access and remove the original file
 452                          * without special setuid-ness then this method is
 453                          * safe.  Otherwise, abandon the move and fall back
 454                          * to the (usual) copy method.
 455                          */
 456                         PRIV_END
 457                         ret = access(dfname, R_OK);
 458                         if (ret == 0)
 459                                 ret = unlink(arg);
 460                         PRIV_START
 461                         if (ret != 0)
 462                                 goto nohardlink;
 463                         /*
 464                          * Unlink of user file was successful.  Change the
 465                          * owner and permissions, add entries to the control
 466                          * file, and skip the file copying step.
 467                          */
 468                         chown(dfname, pp->daemon_user, getegid());
 469                         chmod(dfname, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 470                         PRIV_END
 471                         if (format == 'p')
 472                                 card('T', title ? title : arg);
 473                         for (i = 0; i < ncopies; i++)
 474                                 card(format, &dfname[inchar-2]);
 475                         card('U', &dfname[inchar-2]);
 476                         card('N', arg);
 477                         nact++;
 478                         continue;
 479                 nohardlink:
 480                         if (didlink)
 481                                 unlink(dfname);
 482                         PRIV_END           /* restore old uid */
 483                 } /* end: if (f) */
 484
 485                 if ((i = open(arg, O_RDONLY)) < 0) {
 486                         printf("%s: cannot open %s\n", progname, arg);
 487                 } else {
 488                         copy(pp, i, arg);
 489                         (void) close(i);
 490                         if (f && unlink(arg) < 0)
 491                                 printf("%s: %s: not removed\n", progname, arg);
 492                 }
 493         }
 494
 495         if (nact) {
 496                 (void) close(tfd);
 497                 tfname[inchar]--;
 498                 /*
 499                  * Touch the control file to fix position in the queue.
 500                  */
 501                 PRIV_START
 502                 if ((tfd = open(tfname, O_RDWR)) >= 0) {
 503                         char touch_c;
 504
 505                         if (read(tfd, &touch_c, 1) == 1 &&
 506                             lseek(tfd, (off_t)0, 0) == 0 &&
 507                             write(tfd, &touch_c, 1) != 1) {
 508                                 printf("%s: cannot touch %s\n", progname,
 509                                     tfname);
 510                                 tfname[inchar]++;
 511                                 cleanup(0);
 512                         }
 513                         (void) close(tfd);
 514                 }
 515                 if (link(tfname, cfname) < 0) {
 516                         printf("%s: cannot rename %s\n", progname, cfname);
 517                         tfname[inchar]++;
 518                         cleanup(0);
 519                 }
 520                 unlink(tfname);
 521                 PRIV_END
 522                 if (qflag)              /* just q things up */
 523                         exit(0);
 524                 if (!startdaemon(pp))
 525                         printf("jobs queued, but cannot start daemon.\n");
 526                 exit(0);
 527         }
 528         cleanup(0);
 529         return (1);
 530         /* NOTREACHED */
 531 }
 532
 533 /*
 534  * Create the file n and copy from file descriptor f.
 535  */
 536 static void
 537 copy(const struct printer *pp, int f, const char n[])
 538 {
 539         register int fd, i, nr, nc;
 540         char buf[BUFSIZ];
 541
 542         if (format == 'p')
 543                 card('T', title ? title : n);
 544         for (i = 0; i < ncopies; i++)
 545                 card(format, &dfname[inchar-2]);
 546         card('U', &dfname[inchar-2]);
 547         card('N', n);
 548         fd = nfile(dfname);
 549         nr = nc = 0;
 550         while ((i = read(f, buf, BUFSIZ)) > 0) {
 551                 if (write(fd, buf, i) != i) {
 552                         printf("%s: %s: temp file write error\n", progname, n);
 553                         break;
 554                 }
 555                 nc += i;
 556                 if (nc >= BUFSIZ) {
 557                         nc -= BUFSIZ;
 558                         nr++;
 559                         if (pp->max_blocks > 0 && nr > pp->max_blocks) {
 560                                 printf("%s: %s: copy file is too large\n",
 561                                     progname, n);
 562                                 break;
 563                         }
 564                 }
 565         }
 566         (void) close(fd);
 567         if (nc==0 && nr==0)
 568                 printf("%s: %s: empty input file\n", progname,
 569                     f ? n : "stdin");
 570         else
 571                 nact++;
 572 }
 573
 574 /*
 575  * Try and link the file to dfname. Return a pointer to the full
 576  * path name if successful.
 577  */
 578 static const char *
 579 linked(const char *file)
 580 {
 581         register char *cp;
 582         static char buf[MAXPATHLEN];
 583         register int ret;
 584
 585         if (*file != '/') {
 586                 if (getcwd(buf, sizeof(buf)) == NULL)
 587                         return(NULL);
 588                 while (file[0] == '.') {
 589                         switch (file[1]) {
 590                         case '/':
 591                                 file += 2;
 592                                 continue;
 593                         case '.':
 594                                 if (file[2] == '/') {
 595                                         if ((cp = strrchr(buf, '/')) != NULL)
 596                                                 *cp = '\0';
 597                                         file += 3;
 598                                         continue;
 599                                 }
 600                         }
 601                         break;
 602                 }
 603                 strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 604                 strncat(buf, file, sizeof(buf) - strlen(buf) - 1);
 605                 file = buf;
 606         }
 607         PRIV_START
 608         ret = symlink(file, dfname);
 609         PRIV_END
 610         return(ret ? NULL : file);
 611 }
 612
 613 /*
 614  * Put a line into the control file.
 615  */
 616 static void
 617 card(int c, const char *p2)
 618 {
 619         char buf[BUFSIZ];
 620         register char *p1 = buf;
 621         size_t len = 2;
 622
 623         *p1++ = c;
 624         while ((c = *p2++) != '\0' && len < sizeof(buf)) {
 625                 *p1++ = (c == '\n') ? ' ' : c;
 626                 len++;
 627         }
 628         *p1++ = '\n';
 629         write(tfd, buf, len);
 630 }
 631
 632 /*
 633  * Create a new file in the spool directory.
 634  */
 635 static int
 636 nfile(char *n)
 637 {
 638         register int f;
 639         int oldumask = umask(0);                /* should block signals */
 640
 641         PRIV_START
 642         f = open(n, O_WRONLY | O_EXCL | O_CREAT, FILMOD);
 643         (void) umask(oldumask);
 644         if (f < 0) {
 645                 printf("%s: cannot create %s\n", progname, n);
 646                 cleanup(0);
 647         }
 648         if (fchown(f, userid, -1) < 0) {
 649                 printf("%s: cannot chown %s\n", progname, n);
 650                 cleanup(0);     /* cleanup does exit */
 651         }
 652         PRIV_END
 653         if (++n[inchar] > 'z') {
 654                 if (++n[inchar-2] == 't') {
 655                         printf("too many files - break up the job\n");
 656                         cleanup(0);
 657                 }
 658                 n[inchar] = 'A';
 659         } else if (n[inchar] == '[')
 660                 n[inchar] = 'a';
 661         return(f);
 662 }
 663
 664 /*
 665  * Cleanup after interrupts and errors.
 666  */
 667 static void
 668 cleanup(int signo __unused)
 669 {
 670         register int i;
 671
 672         signal(SIGHUP, SIG_IGN);
 673         signal(SIGINT, SIG_IGN);
 674         signal(SIGQUIT, SIG_IGN);
 675         signal(SIGTERM, SIG_IGN);
 676         i = inchar;
 677         PRIV_START
 678         if (tfname)
 679                 do
 680                         unlink(tfname);
 681                 while (tfname[i]-- != 'A');
 682         if (cfname)
 683                 do
 684                         unlink(cfname);
 685                 while (cfname[i]-- != 'A');
 686         if (dfname)
 687                 do {
 688                         do
 689                                 unlink(dfname);
 690                         while (dfname[i]-- != 'A');
 691                         dfname[i] = 'z';
 692                 } while (dfname[i-2]-- != 'd');
 693         exit(1);
 694 }
 695
 696 /*
 697  * Test to see if this is a printable file.
 698  * Return -1 if it is not, 0 if its printable, and 1 if
 699  * we should remove it after printing.
 700  */
 701 static int
 702 test(const char *file)
 703 {
 704         struct exec execb;
 705         size_t dlen;
 706         int fd;
 707         char *cp, *dirpath;
 708
 709         if (access(file, 4) < 0) {
 710                 printf("%s: cannot access %s\n", progname, file);
 711                 return(-1);
 712         }
 713         if (stat(file, &statb) < 0) {
 714                 printf("%s: cannot stat %s\n", progname, file);
 715                 return(-1);
 716         }
 717         if ((statb.st_mode & S_IFMT) == S_IFDIR) {
 718                 printf("%s: %s is a directory\n", progname, file);
 719                 return(-1);
 720         }
 721         if (statb.st_size == 0) {
 722                 printf("%s: %s is an empty file\n", progname, file);
 723                 return(-1);
 724         }
 725         if ((fd = open(file, O_RDONLY)) < 0) {
 726                 printf("%s: cannot open %s\n", progname, file);
 727                 return(-1);
 728         }
 729         /*
 730          * XXX Shall we add a similar test for ELF?
 731          */
 732         if (read(fd, &execb, sizeof(execb)) == sizeof(execb) &&
 733             !N_BADMAG(execb)) {
 734                 printf("%s: %s is an executable program", progname, file);
 735                 goto error1;
 736         }
 737         (void) close(fd);
 738         if (rflag) {
 739                 /*
 740                  * aside: note that 'cp' is technically a 'const char *'
 741                  * (because it points into 'file'), even though strrchr
 742                  * returns a value of type 'char *'.
 743                  */
 744                 if ((cp = strrchr(file, '/')) == NULL) {
 745                         if (checkwriteperm(file,".") == 0)
 746                                 return(1);
 747                 } else {
 748                         if (cp == file) {
 749                                 fd = checkwriteperm(file,"/");
 750                         } else {
 751                                 /* strlcpy will change the '/' to '\0' */
 752                                 dlen = cp - file + 1;
 753                                 dirpath = malloc(dlen);
 754                                 strlcpy(dirpath, file, dlen);
 755                                 fd = checkwriteperm(file, dirpath);
 756                                 free(dirpath);
 757                         }
 758                         if (fd == 0)
 759                                 return(1);
 760                 }
 761                 printf("%s: %s: is not removable by you\n", progname, file);
 762         }
 763         return(0);
 764
 765 error1:
 766         printf(" and is unprintable\n");
 767         (void) close(fd);
 768         return(-1);
 769 }
 770
 771 static int
 772 checkwriteperm(const char *file, const char *directory)
 773 {
 774         struct  stat    stats;
 775         if (access(directory, W_OK) == 0) {
 776                 stat(directory, &stats);
 777                 if (stats.st_mode & S_ISVTX) {
 778                         stat(file, &stats);
 779                         if(stats.st_uid == userid) {
 780                                 return(0);
 781                         }
 782                 } else return(0);
 783         }
 784         return(-1);
 785 }
 786
 787 /*
 788  * itoa - integer to string conversion
 789  */
 790 static char *
 791 itoa(int i)
 792 {
 793         static char b[10] = "########";
 794         register char *p;
 795
 796         p = &b[8];
 797         do
 798                 *p-- = i%10 + '0';
 799         while (i /= 10);
 800         return(++p);
 801 }
 802
 803 /*
 804  * Perform lookup for printer name or abbreviation --
 805  */
 806 static void
 807 chkprinter(const char *ptrname, struct printer *pp)
 808 {
 809         int status;
 810
 811         init_printer(pp);
 812         status = getprintcap(ptrname, pp);
 813         switch(status) {
 814         case PCAPERR_OSERR:
 815         case PCAPERR_TCLOOP:
 816                 errx(1, "%s: %s", ptrname, pcaperr(status));
 817         case PCAPERR_NOTFOUND:
 818                 errx(1, "%s: unknown printer", ptrname);
 819         case PCAPERR_TCOPEN:
 820                 warnx("%s: unresolved tc= reference(s)", ptrname);
 821         }
 822 }
 823
 824 /*
 825  * Tell the user what we wanna get.
 826  */
 827 static void
 828 usage(void)
 829 {
 830         fprintf(stderr, "%s\n",
 831 "usage: lpr [-Pprinter] [-#num] [-C class] [-J job] [-T title] [-U user]\n"
 832         "\t[-Z daemon-options] [-i[numcols]] [-i[numcols]] [-1234 font]\n"
 833         "\t[-L locale] [-wnum] [-cdfghlnmprstv] [name ...]");
 834         exit(1);
 835 }
 836
 837
 838 /*
 839  * Make the temp files.
 840  */
 841 static void
 842 mktemps(const struct printer *pp)
 843 {
 844         register int len, fd, n;
 845         register char *cp;
 846         char buf[BUFSIZ];
 847
 848         (void) snprintf(buf, sizeof(buf), "%s/.seq", pp->spool_dir);
 849         PRIV_START
 850         if ((fd = open(buf, O_RDWR|O_CREAT, 0664)) < 0) {
 851                 printf("%s: cannot create %s\n", progname, buf);
 852                 exit(1);
 853         }
 854         if (flock(fd, LOCK_EX)) {
 855                 printf("%s: cannot lock %s\n", progname, buf);
 856                 exit(1);
 857         }
 858         PRIV_END
 859         n = 0;
 860         if ((len = read(fd, buf, sizeof(buf))) > 0) {
 861                 for (cp = buf; len--; ) {
 862                         if (*cp < '0' || *cp > '9')
 863                                 break;
 864                         n = n * 10 + (*cp++ - '0');
 865                 }
 866         }
 867         len = strlen(pp->spool_dir) + strlen(local_host) + 8;
 868         tfname = lmktemp(pp, "tf", n, len);
 869         cfname = lmktemp(pp, "cf", n, len);
 870         dfname = lmktemp(pp, "df", n, len);
 871         inchar = strlen(pp->spool_dir) + 3;
 872         n = (n + 1) % 1000;
 873         (void) lseek(fd, (off_t)0, 0);
 874         snprintf(buf, sizeof(buf), "%03d\n", n);
 875         (void) write(fd, buf, strlen(buf));
 876         (void) close(fd);       /* unlocks as well */
 877 }
 878
 879 /*
 880  * Make a temp file name.
 881  */
 882 static char *
 883 lmktemp(const struct printer *pp, const char *id, int num, int len)
 884 {
 885         register char *s;
 886
 887         if ((s = malloc(len)) == NULL)
 888                 errx(1, "out of memory");
 889         (void) snprintf(s, len, "%s/%sA%03d%s", pp->spool_dir, id, num,
 890             local_host);
 891         return(s);
 892 }