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