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