usr.sbin/lpr/lpc/cmds.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  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by the University of
  17  *      California, Berkeley and its contributors.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * @(#) Copyright (c) 1983, 1993 The Regents of the University of California.  All rights reserved.
  35  * @(#)cmds.c   8.2 (Berkeley) 4/28/95
  36  * $FreeBSD: src/usr.sbin/lpr/lpc/cmds.c,v 1.14.2.16 2002/07/25 23:29:39 gad Exp $
  37  * $DragonFly: src/usr.sbin/lpr/lpc/cmds.c,v 1.2 2003/06/17 04:29:56 dillon Exp $
  38  */
  39
  40 /*
  41  * lpc -- line printer control program -- commands:
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/time.h>
  46 #include <sys/stat.h>
  47 #include <sys/file.h>
  48
  49 #include <signal.h>
  50 #include <fcntl.h>
  51 #include <errno.h>
  52 #include <dirent.h>
  53 #include <unistd.h>
  54 #include <stdlib.h>
  55 #include <stdio.h>
  56 #include <ctype.h>
  57 #include <string.h>
  58 #include "lp.h"
  59 #include "lp.local.h"
  60 #include "lpc.h"
  61 #include "extern.h"
  62 #include "pathnames.h"
  63
  64 /*
  65  * Return values from kill_qtask().
  66  */
  67 #define KQT_LFERROR     -2
  68 #define KQT_KILLFAIL    -1
  69 #define KQT_NODAEMON    0
  70 #define KQT_KILLOK      1
  71
  72 static char     *args2line(int argc, char **argv);
  73 static int       doarg(char *_job);
  74 static int       doselect(struct dirent *_d);
  75 static int       kill_qtask(const char *lf);
  76 static int       sortq(const void *_a, const void *_b);
  77 static int       touch(struct jobqueue *_jq);
  78 static void      unlinkf(char *_name);
  79 static void      upstat(struct printer *_pp, const char *_msg, int _notify);
  80 static void      wrapup_clean(int _laststatus);
  81
  82 /*
  83  * generic framework for commands which operate on all or a specified
  84  * set of printers
  85  */
  86 enum    qsel_val {                      /* how a given ptr was selected */
  87         QSEL_UNKNOWN = -1,              /* ... not selected yet */
  88         QSEL_BYNAME = 0,                /* ... user specifed it by name */
  89         QSEL_ALL = 1                    /* ... user wants "all" printers */
  90                                         /*     (with more to come)    */
  91 };
  92
  93 static enum qsel_val generic_qselect;   /* indicates how ptr was selected */
  94 static int generic_initerr;             /* result of initrtn processing */
  95 static char *generic_cmdname;
  96 static char *generic_msg;               /* if a -msg was specified */
  97 static char *generic_nullarg;
  98 static void (*generic_wrapup)(int _last_status);   /* perform rtn wrap-up */
  99
 100 void
 101 generic(void (*specificrtn)(struct printer *_pp), int cmdopts,
 102     void (*initrtn)(int _argc, char *_argv[]), int argc, char *argv[])
 103 {
 104         int cmdstatus, more, targc;
 105         struct printer myprinter, *pp;
 106         char **margv, **targv;
 107
 108         if (argc == 1) {
 109                 /*
 110                  * Usage needs a special case for 'down': The user must
 111                  * either include `-msg', or only the first parameter
 112                  * that they give will be processed as a printer name.
 113                  */
 114                 printf("usage: %s  {all | printer ...}", argv[0]);
 115                 if (strcmp(argv[0], "down") == 0) {
 116                         printf(" -msg [<text> ...]\n");
 117                         printf("   or: down  {all | printer} [<text> ...]");
 118                 } else if (cmdopts & LPC_MSGOPT)
 119                         printf(" [-msg <text> ...]");
 120                 printf("\n");
 121                 return;
 122         }
 123
 124         /* The first argument is the command name. */
 125         generic_cmdname = *argv++;
 126         argc--;
 127
 128         /*
 129          * The initialization routine for a command might set a generic
 130          * "wrapup" routine, which should be called after processing all
 131          * the printers in the command.  This might print summary info.
 132          *
 133          * Note that the initialization routine may also parse (and
 134          * nullify) some of the parameters given on the command, leaving
 135          * only the parameters which have to do with printer names.
 136          */
 137         pp = &myprinter;
 138         generic_wrapup = NULL;
 139         generic_qselect = QSEL_UNKNOWN;
 140         cmdstatus = 0;
 141         /* this just needs to be a distinct value of type 'char *' */
 142         if (generic_nullarg == NULL)
 143                 generic_nullarg = strdup("");
 144
 145         /*
 146          * Some commands accept a -msg argument, which indicates that
 147          * all remaining arguments should be combined into a string.
 148          */
 149         generic_msg = NULL;
 150         if (cmdopts & LPC_MSGOPT) {
 151                 targc = argc;
 152                 targv = argv;
 153                 for (; targc > 0; targc--, targv++) {
 154                         if (strcmp(*targv, "-msg") == 0) {
 155                                 argc -= targc;
 156                                 generic_msg = args2line(targc - 1, targv + 1);
 157                                 break;
 158                         }
 159                 }
 160         }
 161
 162         /* call initialization routine, if there is one for this cmd */
 163         if (initrtn != NULL) {
 164                 generic_initerr = 0;
 165                 (*initrtn)(argc, argv);
 166                 if (generic_initerr)
 167                         return;
 168                 /*
 169                  * The initrtn may have null'ed out some of the parameters.
 170                  * Compact the parameter list to remove those nulls, and
 171                  * correct the arg-count.
 172                  */
 173                 targc = argc;
 174                 targv = argv;
 175                 margv = argv;
 176                 argc = 0;
 177                 for (; targc > 0; targc--, targv++) {
 178                         if (*targv != generic_nullarg) {
 179                                 if (targv != margv)
 180                                         *margv = *targv;
 181                                 margv++;
 182                                 argc++;
 183                         }
 184                 }
 185         }
 186
 187         if (argc == 1 && strcmp(*argv, "all") == 0) {
 188                 generic_qselect = QSEL_ALL;
 189                 more = firstprinter(pp, &cmdstatus);
 190                 if (cmdstatus)
 191                         goto looperr;
 192                 while (more) {
 193                         (*specificrtn)(pp);
 194                         do {
 195                                 more = nextprinter(pp, &cmdstatus);
 196 looperr:
 197                                 switch (cmdstatus) {
 198                                 case PCAPERR_TCOPEN:
 199                                         printf("warning: %s: unresolved "
 200                                                "tc= reference(s) ",
 201                                                pp->printer);
 202                                 case PCAPERR_SUCCESS:
 203                                         break;
 204                                 default:
 205                                         fatal(pp, "%s", pcaperr(cmdstatus));
 206                                 }
 207                         } while (more && cmdstatus);
 208                 }
 209                 goto wrapup;
 210         }
 211
 212         generic_qselect = QSEL_BYNAME;          /* specifically-named ptrs */
 213         for (; argc > 0; argc--, argv++) {
 214                 init_printer(pp);
 215                 cmdstatus = getprintcap(*argv, pp);
 216                 switch (cmdstatus) {
 217                 default:
 218                         fatal(pp, "%s", pcaperr(cmdstatus));
 219                 case PCAPERR_NOTFOUND:
 220                         printf("unknown printer %s\n", *argv);
 221                         continue;
 222                 case PCAPERR_TCOPEN:
 223                         printf("warning: %s: unresolved tc= reference(s)\n",
 224                                *argv);
 225                         break;
 226                 case PCAPERR_SUCCESS:
 227                         break;
 228                 }
 229                 (*specificrtn)(pp);
 230         }
 231
 232 wrapup:
 233         if (generic_wrapup) {
 234                 (*generic_wrapup)(cmdstatus);
 235         }
 236         free_printer(pp);
 237         if (generic_msg)
 238                 free(generic_msg);
 239 }
 240
 241 /*
 242  * Convert an argv-array of character strings into a single string.
 243  */
 244 static char *
 245 args2line(int argc, char **argv)
 246 {
 247         char *cp1, *cend;
 248         const char *cp2;
 249         char buf[1024];
 250
 251         if (argc <= 0)
 252                 return strdup("\n");
 253
 254         cp1 = buf;
 255         cend = buf + sizeof(buf) - 1;           /* save room for '\0' */
 256         while (--argc >= 0) {
 257                 cp2 = *argv++;
 258                 while ((cp1 < cend) && (*cp1++ = *cp2++))
 259                         ;
 260                 cp1[-1] = ' ';
 261         }
 262         cp1[-1] = '\n';
 263         *cp1 = '\0';
 264         return strdup(buf);
 265 }
 266
 267 /*
 268  * Kill the current daemon, to stop printing of the active job.
 269  */
 270 static int
 271 kill_qtask(const char *lf)
 272 {
 273         FILE *fp;
 274         pid_t pid;
 275         int errsav, killres, lockres, res;
 276
 277         seteuid(euid);
 278         fp = fopen(lf, "r");
 279         errsav = errno;
 280         seteuid(uid);
 281         res = KQT_NODAEMON;
 282         if (fp == NULL) {
 283                 /*
 284                  * If there is no lock file, then there is no daemon to
 285                  * kill.  Any other error return means there is some
 286                  * kind of problem with the lock file.
 287                  */
 288                 if (errsav != ENOENT)
 289                         res = KQT_LFERROR;
 290                 goto killdone;
 291         }
 292
 293         /* If the lock file is empty, then there is no daemon to kill */
 294         if (getline(fp) == 0)
 295                 goto killdone;
 296
 297         /*
 298          * If the file can be locked without blocking, then there
 299          * no daemon to kill, or we should not try to kill it.
 300          *
 301          * XXX - not sure I understand the reasoning behind this...
 302          */
 303         lockres = flock(fileno(fp), LOCK_SH|LOCK_NB);
 304         (void) fclose(fp);
 305         if (lockres == 0)
 306                 goto killdone;
 307
 308         pid = atoi(line);
 309         if (pid < 0) {
 310                 /*
 311                  * If we got a negative pid, then the contents of the
 312                  * lock file is not valid.
 313                  */
 314                 res = KQT_LFERROR;
 315                 goto killdone;
 316         }
 317
 318         seteuid(uid);
 319         killres = kill(pid, SIGTERM);
 320         errsav = errno;
 321         seteuid(uid);
 322         if (killres == 0) {
 323                 res = KQT_KILLOK;
 324                 printf("\tdaemon (pid %d) killed\n", pid);
 325         } else if (errno == ESRCH) {
 326                 res = KQT_NODAEMON;
 327         } else {
 328                 res = KQT_KILLFAIL;
 329                 printf("\tWarning: daemon (pid %d) not killed:\n", pid);
 330                 printf("\t    %s\n", strerror(errsav));
 331         }
 332
 333 killdone:
 334         switch (res) {
 335         case KQT_LFERROR:
 336                 printf("\tcannot open lock file: %s\n",
 337                     strerror(errsav));
 338                 break;
 339         case KQT_NODAEMON:
 340                 printf("\tno daemon to abort\n");
 341                 break;
 342         case KQT_KILLFAIL:
 343         case KQT_KILLOK:
 344                 /* These two already printed messages to the user. */
 345                 break;
 346         default:
 347                 printf("\t<internal error in kill_qtask>\n");
 348                 break;
 349         }
 350
 351         return (res);
 352 }
 353
 354 /*
 355  * Write a message into the status file.
 356  */
 357 static void
 358 upstat(struct printer *pp, const char *msg, int notifyuser)
 359 {
 360         int fd;
 361         char statfile[MAXPATHLEN];
 362
 363         status_file_name(pp, statfile, sizeof statfile);
 364         umask(0);
 365         seteuid(euid);
 366         fd = open(statfile, O_WRONLY|O_CREAT|O_EXLOCK, STAT_FILE_MODE);
 367         seteuid(uid);
 368         if (fd < 0) {
 369                 printf("\tcannot create status file: %s\n", strerror(errno));
 370                 return;
 371         }
 372         (void) ftruncate(fd, 0);
 373         if (msg == (char *)NULL)
 374                 (void) write(fd, "\n", 1);
 375         else
 376                 (void) write(fd, msg, strlen(msg));
 377         (void) close(fd);
 378         if (notifyuser) {
 379                 if ((msg == (char *)NULL) || (strcmp(msg, "\n") == 0))
 380                         printf("\tstatus message is now set to nothing.\n");
 381                 else
 382                         printf("\tstatus message is now: %s", msg);
 383         }
 384 }
 385
 386 /*
 387  * kill an existing daemon and disable printing.
 388  */
 389 void
 390 abort_q(struct printer *pp)
 391 {
 392         int killres, setres;
 393         char lf[MAXPATHLEN];
 394
 395         lock_file_name(pp, lf, sizeof lf);
 396         printf("%s:\n", pp->printer);
 397
 398         /*
 399          * Turn on the owner execute bit of the lock file to disable printing.
 400          */
 401         setres = set_qstate(SQS_STOPP, lf);
 402
 403         /*
 404          * If set_qstate found that there already was a lock file, then
 405          * call a routine which will read that lock file and kill the
 406          * lpd-process which is listed in that lock file.  If the lock
 407          * file did not exist, then either there is no daemon running
 408          * for this queue, or there is one running but *it* could not
 409          * write a lock file (which means we can not determine the
 410          * process id of that lpd-process).
 411          */
 412         switch (setres) {
 413         case SQS_CHGOK:
 414         case SQS_CHGFAIL:
 415                 /* Kill the process */
 416                 killres = kill_qtask(lf);
 417                 break;
 418         case SQS_CREOK:
 419         case SQS_CREFAIL:
 420                 printf("\tno daemon to abort\n");
 421                 break;
 422         case SQS_STATFAIL:
 423                 printf("\tassuming no daemon to abort\n");
 424                 break;
 425         default:
 426                 printf("\t<unexpected result (%d) from set_qstate>\n",
 427                     setres);
 428                 break;
 429         }
 430
 431         if (setres >= 0)
 432                 upstat(pp, "printing disabled\n", 0);
 433 }
 434
 435 /*
 436  * "global" variables for all the routines related to 'clean' and 'tclean'
 437  */
 438 static time_t    cln_now;               /* current time */
 439 static double    cln_minage;            /* minimum age before file is removed */
 440 static long      cln_sizecnt;           /* amount of space freed up */
 441 static int       cln_debug;             /* print extra debugging msgs */
 442 static int       cln_filecnt;           /* number of files destroyed */
 443 static int       cln_foundcore;         /* found a core file! */
 444 static int       cln_queuecnt;          /* number of queues checked */
 445 static int       cln_testonly;          /* remove-files vs just-print-info */
 446
 447 static int
 448 doselect(struct dirent *d)
 449 {
 450         int c = d->d_name[0];
 451
 452         if ((c == 'c' || c == 'd' || c == 'r' || c == 't') &&
 453             d->d_name[1] == 'f')
 454                 return 1;
 455         if (c == 'c') {
 456                 if (!strcmp(d->d_name, "core"))
 457                         cln_foundcore = 1;
 458         }
 459         if (c == 'e') {
 460                 if (!strncmp(d->d_name, "errs.", 5))
 461                         return 1;
 462         }
 463         return 0;
 464 }
 465
 466 /*
 467  * Comparison routine that clean_q() uses for scandir.
 468  *
 469  * The purpose of this sort is to have all `df' files end up immediately
 470  * after the matching `cf' file.  For files matching `cf', `df', `rf', or
 471  * `tf', it sorts by job number and machine, then by `cf', `df', `rf', or
 472  * `tf', and then by the sequence letter (which is A-Z, or a-z).    This
 473  * routine may also see filenames which do not start with `cf', `df', `rf',
 474  * or `tf' (such as `errs.*'), and those are simply sorted by the full
 475  * filename.
 476  *
 477  * XXX
 478  *   This assumes that all control files start with `cfA*', and it turns
 479  *   out there are a few implementations of lpr which will create `cfB*'
 480  *   filenames (they will have datafile names which start with `dfB*').
 481  */
 482 static int
 483 sortq(const void *a, const void *b)
 484 {
 485         const int a_lt_b = -1, a_gt_b = 1, cat_other = 10;
 486         const char *fname_a, *fname_b, *jnum_a, *jnum_b;
 487         int cat_a, cat_b, ch, res, seq_a, seq_b;
 488
 489         fname_a = (*(const struct dirent * const *)a)->d_name;
 490         fname_b = (*(const struct dirent * const *)b)->d_name;
 491
 492         /*
 493          * First separate filenames into cagatories.  Catagories are
 494          * legitimate `cf', `df', `rf' & `tf' filenames, and "other" - in
 495          * that order.  It is critical that the mapping be exactly the
 496          * same for 'a' vs 'b', so define a macro for the job.
 497          *
 498          * [aside: the standard `cf' file has the jobnumber start in
 499          * position 4, but some implementations have that as an extra
 500          * file-sequence letter, and start the job number in position 5.]
 501          */
 502 #define MAP_TO_CAT(fname_X,cat_X,jnum_X,seq_X) do { \
 503         cat_X = cat_other;    \
 504         ch = *(fname_X + 2);  \
 505         jnum_X = fname_X + 3; \
 506         seq_X = 0;            \
 507         if ((*(fname_X + 1) == 'f') && (isalpha(ch))) { \
 508                 seq_X = ch; \
 509                 if (*fname_X == 'c') \
 510                         cat_X = 1; \
 511                 else if (*fname_X == 'd') \
 512                         cat_X = 2; \
 513                 else if (*fname_X == 'r') \
 514                         cat_X = 3; \
 515                 else if (*fname_X == 't') \
 516                         cat_X = 4; \
 517                 if (cat_X != cat_other) { \
 518                         ch = *jnum_X; \
 519                         if (!isdigit(ch)) { \
 520                                 if (isalpha(ch)) { \
 521                                         jnum_X++; \
 522                                         ch = *jnum_X; \
 523                                         seq_X = (seq_X << 8) + ch; \
 524                                 } \
 525                                 if (!isdigit(ch)) \
 526                                         cat_X = cat_other; \
 527                         } \
 528                 } \
 529         } \
 530 } while (0)
 531
 532         MAP_TO_CAT(fname_a, cat_a, jnum_a, seq_a);
 533         MAP_TO_CAT(fname_b, cat_b, jnum_b, seq_b);
 534
 535 #undef MAP_TO_CAT
 536
 537         /* First handle all cases which have "other" files */
 538         if ((cat_a >= cat_other) || (cat_b >= cat_other)) {
 539                 /* for two "other" files, just compare the full name */
 540                 if (cat_a == cat_b)
 541                         res = strcmp(fname_a, fname_b);
 542                 else if (cat_a < cat_b)
 543                         res = a_lt_b;
 544                 else
 545                         res = a_gt_b;
 546                 goto have_res;
 547         }
 548
 549         /*
 550          * At this point, we know both files are legitimate `cf', `df', `rf',
 551          * or `tf' files.  Compare them by job-number and machine name.
 552          */
 553         res = strcmp(jnum_a, jnum_b);
 554         if (res != 0)
 555                 goto have_res;
 556
 557         /*
 558          * We have two files which belong to the same job.  Sort based
 559          * on the catagory of file (`c' before `d', etc).
 560          */
 561         if (cat_a < cat_b) {
 562                 res = a_lt_b;
 563                 goto have_res;
 564         } else if (cat_a > cat_b) {
 565                 res = a_gt_b;
 566                 goto have_res;
 567         }
 568
 569         /*
 570          * Two files in the same catagory for a single job.  Sort based
 571          * on the sequence letter(s).  (usually `A' thru `Z', etc).
 572          */
 573         if (seq_a < seq_b) {
 574                 res = a_lt_b;
 575                 goto have_res;
 576         } else if (seq_a > seq_b) {
 577                 res = a_gt_b;
 578                 goto have_res;
 579         }
 580
 581         /*
 582          * Given that the filenames in a directory are unique, this SHOULD
 583          * never happen (unless there are logic errors in this routine).
 584          * But if it does happen, we must return "is equal" or the caller
 585          * might see inconsistent results in the sorting order, and that
 586          * can trigger other problems.
 587          */
 588         printf("\t*** Error in sortq: %s == %s !\n", fname_a, fname_b);
 589         printf("\t***       cat %d == %d ; seq = %d %d\n", cat_a, cat_b,
 590             seq_a, seq_b);
 591         res = 0;
 592
 593 have_res:
 594         return res;
 595 }
 596
 597 /*
 598  * Remove all spool files and temporaries from the spooling area.
 599  * Or, perhaps:
 600  * Remove incomplete jobs from spooling area.
 601  */
 602
 603 void
 604 clean_gi(int argc, char *argv[])
 605 {
 606
 607         /* init some fields before 'clean' is called for each queue */
 608         cln_queuecnt = 0;
 609         cln_now = time(NULL);
 610         cln_minage = 3600.0;            /* only delete files >1h old */
 611         cln_filecnt = 0;
 612         cln_sizecnt = 0;
 613         cln_debug = 0;
 614         cln_testonly = 0;
 615         generic_wrapup = &wrapup_clean;
 616
 617         /* see if there are any options specified before the ptr list */
 618         for (; argc > 0; argc--, argv++) {
 619                 if (**argv != '-')
 620                         break;
 621                 if (strcmp(*argv, "-d") == 0) {
 622                         /* just an example of an option... */
 623                         cln_debug++;
 624                         *argv = generic_nullarg;        /* "erase" it */
 625                 } else {
 626                         printf("Invalid option '%s'\n", *argv);
 627                         generic_initerr = 1;
 628                 }
 629         }
 630
 631         return;
 632 }
 633
 634 void
 635 tclean_gi(int argc, char *argv[])
 636 {
 637
 638         /* only difference between 'clean' and 'tclean' is one value */
 639         /* (...and the fact that 'clean' is priv and 'tclean' is not) */
 640         clean_gi(argc, argv);
 641         cln_testonly = 1;
 642
 643         return;
 644 }
 645
 646 void
 647 clean_q(struct printer *pp)
 648 {
 649         char *cp, *cp1, *lp;
 650         struct dirent **queue;
 651         size_t linerem;
 652         int didhead, i, n, nitems, rmcp;
 653
 654         cln_queuecnt++;
 655
 656         didhead = 0;
 657         if (generic_qselect == QSEL_BYNAME) {
 658                 printf("%s:\n", pp->printer);
 659                 didhead = 1;
 660         }
 661
 662         lp = line;
 663         cp = pp->spool_dir;
 664         while (lp < &line[sizeof(line) - 1]) {
 665                 if ((*lp++ = *cp++) == 0)
 666                         break;
 667         }
 668         lp[-1] = '/';
 669         linerem = sizeof(line) - (lp - line);
 670
 671         cln_foundcore = 0;
 672         seteuid(euid);
 673         nitems = scandir(pp->spool_dir, &queue, doselect, sortq);
 674         seteuid(uid);
 675         if (nitems < 0) {
 676                 if (!didhead) {
 677                         printf("%s:\n", pp->printer);
 678                         didhead = 1;
 679                 }
 680                 printf("\tcannot examine spool directory\n");
 681                 return;
 682         }
 683         if (cln_foundcore) {
 684                 if (!didhead) {
 685                         printf("%s:\n", pp->printer);
 686                         didhead = 1;
 687                 }
 688                 printf("\t** found a core file in %s !\n", pp->spool_dir);
 689         }
 690         if (nitems == 0)
 691                 return;
 692         if (!didhead)
 693                 printf("%s:\n", pp->printer);
 694         if (cln_debug) {
 695                 printf("\t** ----- Sorted list of files being checked:\n");
 696                 i = 0;
 697                 do {
 698                         cp = queue[i]->d_name;
 699                         printf("\t** [%3d] = %s\n", i, cp);
 700                 } while (++i < nitems);
 701                 printf("\t** ----- end of sorted list\n");
 702         }
 703         i = 0;
 704         do {
 705                 cp = queue[i]->d_name;
 706                 rmcp = 0;
 707                 if (*cp == 'c') {
 708                         /*
 709                          * A control file.  Look for matching data-files.
 710                          */
 711                         /* XXX
 712                          *  Note the logic here assumes that the hostname
 713                          *  part of cf-filenames match the hostname part
 714                          *  in df-filenames, and that is not necessarily
 715                          *  true (eg: for multi-homed hosts).  This needs
 716                          *  some further thought...
 717                          */
 718                         n = 0;
 719                         while (i + 1 < nitems) {
 720                                 cp1 = queue[i + 1]->d_name;
 721                                 if (*cp1 != 'd' || strcmp(cp + 3, cp1 + 3))
 722                                         break;
 723                                 i++;
 724                                 n++;
 725                         }
 726                         if (n == 0) {
 727                                 rmcp = 1;
 728                         }
 729                 } else if (*cp == 'e') {
 730                         /*
 731                          * Must be an errrs or email temp file.
 732                          */
 733                         rmcp = 1;
 734                 } else {
 735                         /*
 736                          * Must be a df with no cf (otherwise, it would have
 737                          * been skipped above) or an rf or tf file (which can
 738                          * always be removed if it is old enough).
 739                          */
 740                         rmcp = 1;
 741                 }
 742                 if (rmcp) {
 743                         if (strlen(cp) >= linerem) {
 744                                 printf("\t** internal error: 'line' overflow!\n");
 745                                 printf("\t**   spooldir = %s\n", pp->spool_dir);
 746                                 printf("\t**   cp = %s\n", cp);
 747                                 return;
 748                         }
 749                         strlcpy(lp, cp, linerem);
 750                         unlinkf(line);
 751                 }
 752         } while (++i < nitems);
 753 }
 754
 755 static void
 756 wrapup_clean(int laststatus __unused)
 757 {
 758
 759         printf("Checked %d queues, and ", cln_queuecnt);
 760         if (cln_filecnt < 1) {
 761                 printf("no cruft was found\n");
 762                 return;
 763         }
 764         if (cln_testonly) {
 765                 printf("would have ");
 766         }
 767         printf("removed %d files (%ld bytes).\n", cln_filecnt, cln_sizecnt);
 768 }
 769
 770 static void
 771 unlinkf(char *name)
 772 {
 773         struct stat stbuf;
 774         double agemod, agestat;
 775         int res;
 776         char linkbuf[BUFSIZ];
 777
 778         /*
 779          * We have to use lstat() instead of stat(), in case this is a df*
 780          * "file" which is really a symlink due to 'lpr -s' processing.  In
 781          * that case, we need to check the last-mod time of the symlink, and
 782          * not the file that the symlink is pointed at.
 783          */
 784         seteuid(euid);
 785         res = lstat(name, &stbuf);
 786         seteuid(uid);
 787         if (res < 0) {
 788                 printf("\terror return from stat(%s):\n", name);
 789                 printf("\t      %s\n", strerror(errno));
 790                 return;
 791         }
 792
 793         agemod = difftime(cln_now, stbuf.st_mtime);
 794         agestat = difftime(cln_now,  stbuf.st_ctime);
 795         if (cln_debug > 1) {
 796                 /* this debugging-aid probably is not needed any more... */
 797                 printf("\t\t  modify age=%g secs, stat age=%g secs\n",
 798                     agemod, agestat);
 799         }
 800         if ((agemod <= cln_minage) && (agestat <= cln_minage))
 801                 return;
 802
 803         /*
 804          * if this file is a symlink, then find out the target of the
 805          * symlink before unlink-ing the file itself
 806          */
 807         if (S_ISLNK(stbuf.st_mode)) {
 808                 seteuid(euid);
 809                 res = readlink(name, linkbuf, sizeof(linkbuf));
 810                 seteuid(uid);
 811                 if (res < 0) {
 812                         printf("\terror return from readlink(%s):\n", name);
 813                         printf("\t      %s\n", strerror(errno));
 814                         return;
 815                 }
 816                 if (res == sizeof(linkbuf))
 817                         res--;
 818                 linkbuf[res] = '\0';
 819         }
 820
 821         cln_filecnt++;
 822         cln_sizecnt += stbuf.st_size;
 823
 824         if (cln_testonly) {
 825                 printf("\twould remove %s\n", name);
 826                 if (S_ISLNK(stbuf.st_mode)) {
 827                         printf("\t    (which is a symlink to %s)\n", linkbuf);
 828                 }
 829         } else {
 830                 seteuid(euid);
 831                 res = unlink(name);
 832                 seteuid(uid);
 833                 if (res < 0)
 834                         printf("\tcannot remove %s (!)\n", name);
 835                 else
 836                         printf("\tremoved %s\n", name);
 837                 /* XXX
 838                  *  Note that for a df* file, this code should also check to see
 839                  *  if it is a symlink to some other file, and if the original
 840                  *  lpr command included '-r' ("remove file").  Of course, this
 841                  *  code would not be removing the df* file unless there was no
 842                  *  matching cf* file, and without the cf* file it is currently
 843                  *  impossible to determine if '-r' had been specified...
 844                  *
 845                  *  As a result of this quandry, we may be leaving behind a
 846                  *  user's file that was supposed to have been removed after
 847                  *  being printed.  This may effect services such as CAP or
 848                  *  samba, if they were configured to use 'lpr -r', and if
 849                  *  datafiles are not being properly removed.
 850                 */
 851                 if (S_ISLNK(stbuf.st_mode)) {
 852                         printf("\t    (which was a symlink to %s)\n", linkbuf);
 853                 }
 854         }
 855 }
 856
 857 /*
 858  * Enable queuing to the printer (allow lpr to add new jobs to the queue).
 859  */
 860 void
 861 enable_q(struct printer *pp)
 862 {
 863         int setres;
 864         char lf[MAXPATHLEN];
 865
 866         lock_file_name(pp, lf, sizeof lf);
 867         printf("%s:\n", pp->printer);
 868
 869         setres = set_qstate(SQS_ENABLEQ, lf);
 870 }
 871
 872 /*
 873  * Disable queuing.
 874  */
 875 void
 876 disable_q(struct printer *pp)
 877 {
 878         int setres;
 879         char lf[MAXPATHLEN];
 880
 881         lock_file_name(pp, lf, sizeof lf);
 882         printf("%s:\n", pp->printer);
 883
 884         setres = set_qstate(SQS_DISABLEQ, lf);
 885 }
 886
 887 /*
 888  * Disable queuing and printing and put a message into the status file
 889  * (reason for being down).  If the user specified `-msg', then use
 890  * everything after that as the message for the status file.  If the
 891  * user did NOT specify `-msg', then the command should take the first
 892  * parameter as the printer name, and all remaining parameters as the
 893  * message for the status file.  (This is to be compatible with the
 894  * original definition of 'down', which was implemented long before
 895  * `-msg' was around).
 896  */
 897 void
 898 down_gi(int argc, char *argv[])
 899 {
 900
 901         /* If `-msg' was specified, then this routine has nothing to do. */
 902         if (generic_msg != NULL)
 903                 return;
 904
 905         /*
 906          * If the user only gave one parameter, then use a default msg.
 907          * (if argc == 1 at this point, then *argv == name of printer).
 908          */
 909         if (argc == 1) {
 910                 generic_msg = strdup("printing disabled\n");
 911                 return;
 912         }
 913
 914         /*
 915          * The user specified multiple parameters, and did not specify
 916          * `-msg'.  Build a message from all the parameters after the
 917          * first one (and nullify those parameters so generic-processing
 918          * will not process them as printer-queue names).
 919          */
 920         argc--;
 921         argv++;
 922         generic_msg = args2line(argc, argv);
 923         for (; argc > 0; argc--, argv++)
 924                 *argv = generic_nullarg;        /* "erase" it */
 925 }
 926
 927 void
 928 down_q(struct printer *pp)
 929 {
 930         int setres;
 931         char lf[MAXPATHLEN];
 932
 933         lock_file_name(pp, lf, sizeof lf);
 934         printf("%s:\n", pp->printer);
 935
 936         setres = set_qstate(SQS_DISABLEQ+SQS_STOPP, lf);
 937         if (setres >= 0)
 938                 upstat(pp, generic_msg, 1);
 939 }
 940
 941 /*
 942  * Exit lpc
 943  */
 944 void
 945 quit(int argc __unused, char *argv[] __unused)
 946 {
 947         exit(0);
 948 }
 949
 950 /*
 951  * Kill and restart the daemon.
 952  */
 953 void
 954 restart_q(struct printer *pp)
 955 {
 956         int killres, setres, startok;
 957         char lf[MAXPATHLEN];
 958
 959         lock_file_name(pp, lf, sizeof lf);
 960         printf("%s:\n", pp->printer);
 961
 962         killres = kill_qtask(lf);
 963
 964         /*
 965          * XXX - if the kill worked, we should probably sleep for
 966          *      a second or so before trying to restart the queue.
 967          */
 968
 969         /* make sure the queue is set to print jobs */
 970         setres = set_qstate(SQS_STARTP, lf);
 971
 972         seteuid(euid);
 973         startok = startdaemon(pp);
 974         seteuid(uid);
 975         if (!startok)
 976                 printf("\tcouldn't restart daemon\n");
 977         else
 978                 printf("\tdaemon restarted\n");
 979 }
 980
 981 /*
 982  * Set the status message of each queue listed.  Requires a "-msg"
 983  * parameter to indicate the end of the queue list and start of msg text.
 984  */
 985 void
 986 setstatus_gi(int argc __unused, char *argv[] __unused)
 987 {
 988
 989         if (generic_msg == NULL) {
 990                 printf("You must specify '-msg' before the text of the new status message.\n");
 991                 generic_initerr = 1;
 992         }
 993 }
 994
 995 void
 996 setstatus_q(struct printer *pp)
 997 {
 998         char lf[MAXPATHLEN];
 999
1000         lock_file_name(pp, lf, sizeof lf);
1001         printf("%s:\n", pp->printer);
1002
1003         upstat(pp, generic_msg, 1);
1004 }
1005
1006 /*
1007  * Enable printing on the specified printer and startup the daemon.
1008  */
1009 void
1010 start_q(struct printer *pp)
1011 {
1012         int setres, startok;
1013         char lf[MAXPATHLEN];
1014
1015         lock_file_name(pp, lf, sizeof lf);
1016         printf("%s:\n", pp->printer);
1017
1018         setres = set_qstate(SQS_STARTP, lf);
1019
1020         seteuid(euid);
1021         startok = startdaemon(pp);
1022         seteuid(uid);
1023         if (!startok)
1024                 printf("\tcouldn't start daemon\n");
1025         else
1026                 printf("\tdaemon started\n");
1027         seteuid(uid);
1028 }
1029
1030 /*
1031  * Print the status of the printer queue.
1032  */
1033 void
1034 status(struct printer *pp)
1035 {
1036         struct stat stbuf;
1037         register int fd, i;
1038         register struct dirent *dp;
1039         DIR *dirp;
1040         char file[MAXPATHLEN];
1041
1042         printf("%s:\n", pp->printer);
1043         lock_file_name(pp, file, sizeof file);
1044         if (stat(file, &stbuf) >= 0) {
1045                 printf("\tqueuing is %s\n",
1046                        ((stbuf.st_mode & LFM_QUEUE_DIS) ? "disabled"
1047                         : "enabled"));
1048                 printf("\tprinting is %s\n",
1049                        ((stbuf.st_mode & LFM_PRINT_DIS) ? "disabled"
1050                         : "enabled"));
1051         } else {
1052                 printf("\tqueuing is enabled\n");
1053                 printf("\tprinting is enabled\n");
1054         }
1055         if ((dirp = opendir(pp->spool_dir)) == NULL) {
1056                 printf("\tcannot examine spool directory\n");
1057                 return;
1058         }
1059         i = 0;
1060         while ((dp = readdir(dirp)) != NULL) {
1061                 if (*dp->d_name == 'c' && dp->d_name[1] == 'f')
1062                         i++;
1063         }
1064         closedir(dirp);
1065         if (i == 0)
1066                 printf("\tno entries in spool area\n");
1067         else if (i == 1)
1068                 printf("\t1 entry in spool area\n");
1069         else
1070                 printf("\t%d entries in spool area\n", i);
1071         fd = open(file, O_RDONLY);
1072         if (fd < 0 || flock(fd, LOCK_SH|LOCK_NB) == 0) {
1073                 (void) close(fd);       /* unlocks as well */
1074                 printf("\tprinter idle\n");
1075                 return;
1076         }
1077         (void) close(fd);
1078         /* print out the contents of the status file, if it exists */
1079         status_file_name(pp, file, sizeof file);
1080         fd = open(file, O_RDONLY|O_SHLOCK);
1081         if (fd >= 0) {
1082                 (void) fstat(fd, &stbuf);
1083                 if (stbuf.st_size > 0) {
1084                         putchar('\t');
1085                         while ((i = read(fd, line, sizeof(line))) > 0)
1086                                 (void) fwrite(line, 1, i, stdout);
1087                 }
1088                 (void) close(fd);       /* unlocks as well */
1089         }
1090 }
1091
1092 /*
1093  * Stop the specified daemon after completing the current job and disable
1094  * printing.
1095  */
1096 void
1097 stop_q(struct printer *pp)
1098 {
1099         int setres;
1100         char lf[MAXPATHLEN];
1101
1102         lock_file_name(pp, lf, sizeof lf);
1103         printf("%s:\n", pp->printer);
1104
1105         setres = set_qstate(SQS_STOPP, lf);
1106
1107         if (setres >= 0)
1108                 upstat(pp, "printing disabled\n", 0);
1109 }
1110
1111 struct  jobqueue **queue;
1112 int     nitems;
1113 time_t  mtime;
1114
1115 /*
1116  * Put the specified jobs at the top of printer queue.
1117  */
1118 void
1119 topq(int argc, char *argv[])
1120 {
1121         register int i;
1122         struct stat stbuf;
1123         int cmdstatus, changed;
1124         struct printer myprinter, *pp = &myprinter;
1125
1126         if (argc < 3) {
1127                 printf("usage: topq printer [jobnum ...] [user ...]\n");
1128                 return;
1129         }
1130
1131         --argc;
1132         ++argv;
1133         init_printer(pp);
1134         cmdstatus = getprintcap(*argv, pp);
1135         switch(cmdstatus) {
1136         default:
1137                 fatal(pp, "%s", pcaperr(cmdstatus));
1138         case PCAPERR_NOTFOUND:
1139                 printf("unknown printer %s\n", *argv);
1140                 return;
1141         case PCAPERR_TCOPEN:
1142                 printf("warning: %s: unresolved tc= reference(s)", *argv);
1143                 break;
1144         case PCAPERR_SUCCESS:
1145                 break;
1146         }
1147         printf("%s:\n", pp->printer);
1148
1149         seteuid(euid);
1150         if (chdir(pp->spool_dir) < 0) {
1151                 printf("\tcannot chdir to %s\n", pp->spool_dir);
1152                 goto out;
1153         }
1154         seteuid(uid);
1155         nitems = getq(pp, &queue);
1156         if (nitems == 0)
1157                 return;
1158         changed = 0;
1159         mtime = queue[0]->job_time;
1160         for (i = argc; --i; ) {
1161                 if (doarg(argv[i]) == 0) {
1162                         printf("\tjob %s is not in the queue\n", argv[i]);
1163                         continue;
1164                 } else
1165                         changed++;
1166         }
1167         for (i = 0; i < nitems; i++)
1168                 free(queue[i]);
1169         free(queue);
1170         if (!changed) {
1171                 printf("\tqueue order unchanged\n");
1172                 return;
1173         }
1174         /*
1175          * Turn on the public execute bit of the lock file to
1176          * get lpd to rebuild the queue after the current job.
1177          */
1178         seteuid(euid);
1179         if (changed && stat(pp->lock_file, &stbuf) >= 0)
1180                 (void) chmod(pp->lock_file, stbuf.st_mode | LFM_RESET_QUE);
1181
1182 out:
1183         seteuid(uid);
1184 }
1185
1186 /*
1187  * Reposition the job by changing the modification time of
1188  * the control file.
1189  */
1190 static int
1191 touch(struct jobqueue *jq)
1192 {
1193         struct timeval tvp[2];
1194         int ret;
1195
1196         tvp[0].tv_sec = tvp[1].tv_sec = --mtime;
1197         tvp[0].tv_usec = tvp[1].tv_usec = 0;
1198         seteuid(euid);
1199         ret = utimes(jq->job_cfname, tvp);
1200         seteuid(uid);
1201         return (ret);
1202 }
1203
1204 /*
1205  * Checks if specified job name is in the printer's queue.
1206  * Returns:  negative (-1) if argument name is not in the queue.
1207  */
1208 static int
1209 doarg(char *job)
1210 {
1211         register struct jobqueue **qq;
1212         register int jobnum, n;
1213         register char *cp, *machine;
1214         int cnt = 0;
1215         FILE *fp;
1216
1217         /*
1218          * Look for a job item consisting of system name, colon, number
1219          * (example: ucbarpa:114)
1220          */
1221         if ((cp = strchr(job, ':')) != NULL) {
1222                 machine = job;
1223                 *cp++ = '\0';
1224                 job = cp;
1225         } else
1226                 machine = NULL;
1227
1228         /*
1229          * Check for job specified by number (example: 112 or 235ucbarpa).
1230          */
1231         if (isdigit(*job)) {
1232                 jobnum = 0;
1233                 do
1234                         jobnum = jobnum * 10 + (*job++ - '0');
1235                 while (isdigit(*job));
1236                 for (qq = queue + nitems; --qq >= queue; ) {
1237                         n = 0;
1238                         for (cp = (*qq)->job_cfname+3; isdigit(*cp); )
1239                                 n = n * 10 + (*cp++ - '0');
1240                         if (jobnum != n)
1241                                 continue;
1242                         if (*job && strcmp(job, cp) != 0)
1243                                 continue;
1244                         if (machine != NULL && strcmp(machine, cp) != 0)
1245                                 continue;
1246                         if (touch(*qq) == 0) {
1247                                 printf("\tmoved %s\n", (*qq)->job_cfname);
1248                                 cnt++;
1249                         }
1250                 }
1251                 return(cnt);
1252         }
1253         /*
1254          * Process item consisting of owner's name (example: henry).
1255          */
1256         for (qq = queue + nitems; --qq >= queue; ) {
1257                 seteuid(euid);
1258                 fp = fopen((*qq)->job_cfname, "r");
1259                 seteuid(uid);
1260                 if (fp == NULL)
1261                         continue;
1262                 while (getline(fp) > 0)
1263                         if (line[0] == 'P')
1264                                 break;
1265                 (void) fclose(fp);
1266                 if (line[0] != 'P' || strcmp(job, line+1) != 0)
1267                         continue;
1268                 if (touch(*qq) == 0) {
1269                         printf("\tmoved %s\n", (*qq)->job_cfname);
1270                         cnt++;
1271                 }
1272         }
1273         return(cnt);
1274 }
1275
1276 /*
1277  * Enable both queuing & printing, and start printer (undo `down').
1278  */
1279 void
1280 up_q(struct printer *pp)
1281 {
1282         int setres, startok;
1283         char lf[MAXPATHLEN];
1284
1285         lock_file_name(pp, lf, sizeof lf);
1286         printf("%s:\n", pp->printer);
1287
1288         setres = set_qstate(SQS_ENABLEQ+SQS_STARTP, lf);
1289
1290         seteuid(euid);
1291         startok = startdaemon(pp);
1292         seteuid(uid);
1293         if (!startok)
1294                 printf("\tcouldn't start daemon\n");
1295         else
1296                 printf("\tdaemon started\n");
1297 }