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