usr.sbin/lpr/lpr/lpr.c

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