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