Style(9) cleanup.
[dragonfly.git] / usr.sbin / lpr / lpc / cmds.c
CommitLineData
984263bc
MD
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.
1de703da
MD
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 $
be6b9a2e 37 * $DragonFly: src/usr.sbin/lpr/lpc/cmds.c,v 1.3 2004/03/22 22:32:50 cpressey Exp $
984263bc
MD
38 */
39
984263bc
MD
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
72static char *args2line(int argc, char **argv);
73static int doarg(char *_job);
74static int doselect(struct dirent *_d);
75static int kill_qtask(const char *lf);
76static int sortq(const void *_a, const void *_b);
77static int touch(struct jobqueue *_jq);
78static void unlinkf(char *_name);
79static void upstat(struct printer *_pp, const char *_msg, int _notify);
80static void wrapup_clean(int _laststatus);
81
82/*
83 * generic framework for commands which operate on all or a specified
84 * set of printers
85 */
86enum 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
93static enum qsel_val generic_qselect; /* indicates how ptr was selected */
94static int generic_initerr; /* result of initrtn processing */
95static char *generic_cmdname;
96static char *generic_msg; /* if a -msg was specified */
97static char *generic_nullarg;
98static void (*generic_wrapup)(int _last_status); /* perform rtn wrap-up */
99
100void
101generic(void (*specificrtn)(struct printer *_pp), int cmdopts,
be6b9a2e 102 void (*initrtn)(int _argc, char **_argv), int argc, char **argv)
984263bc
MD
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);
196looperr:
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
232wrapup:
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 */
244static char *
245args2line(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 */
270static int
271kill_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
333killdone:
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 */
357static void
358upstat(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 */
389void
390abort_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 */
438static time_t cln_now; /* current time */
439static double cln_minage; /* minimum age before file is removed */
440static long cln_sizecnt; /* amount of space freed up */
441static int cln_debug; /* print extra debugging msgs */
442static int cln_filecnt; /* number of files destroyed */
443static int cln_foundcore; /* found a core file! */
444static int cln_queuecnt; /* number of queues checked */
445static int cln_testonly; /* remove-files vs just-print-info */
446
447static int
448doselect(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 */
482static int
483sortq(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
593have_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
603void
be6b9a2e 604clean_gi(int argc, char **argv)
984263bc
MD
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
634void
be6b9a2e 635tclean_gi(int argc, char **argv)
984263bc
MD
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
646void
647clean_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
755static void
756wrapup_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
770static void
771unlinkf(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 */
860void
861enable_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 */
875void
876disable_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 */
897void
be6b9a2e 898down_gi(int argc, char **argv)
984263bc
MD
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
927void
928down_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 */
944void
be6b9a2e 945quit(int argc __unused, char **argv __unused)
984263bc
MD
946{
947 exit(0);
948}
949
950/*
951 * Kill and restart the daemon.
952 */
953void
954restart_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 */
985void
be6b9a2e 986setstatus_gi(int argc __unused, char **argv __unused)
984263bc
MD
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
995void
996setstatus_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 */
1009void
1010start_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 */
1033void
1034status(struct printer *pp)
1035{
1036 struct stat stbuf;
be6b9a2e
CP
1037 int fd, i;
1038 struct dirent *dp;
984263bc
MD
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 */
1096void
1097stop_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
1111struct jobqueue **queue;
1112int nitems;
1113time_t mtime;
1114
1115/*
1116 * Put the specified jobs at the top of printer queue.
1117 */
1118void
be6b9a2e 1119topq(int argc, char **argv)
984263bc 1120{
be6b9a2e 1121 int i;
984263bc
MD
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
1182out:
1183 seteuid(uid);
1184}
1185
1186/*
1187 * Reposition the job by changing the modification time of
1188 * the control file.
1189 */
1190static int
1191touch(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 */
1208static int
1209doarg(char *job)
1210{
be6b9a2e
CP
1211 struct jobqueue **qq;
1212 int jobnum, n;
1213 char *cp, *machine;
984263bc
MD
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 */
1279void
1280up_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}