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
generic(void (* specificrtn)(struct printer * _pp),int cmdopts,void (* initrtn)(int _argc,char ** _argv),int argc,char ** argv)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 *
args2line(int argc,char ** argv)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
kill_qtask(const char * lf)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
upstat(struct printer * pp,const char * msg,int notifyuser)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
abort_q(struct printer * pp)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
doselect(const struct dirent * d)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
sortq(const struct dirent ** a,const struct dirent ** b)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
clean_gi(int argc,char ** argv)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
tclean_gi(int argc,char ** argv)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
clean_q(struct printer * pp)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
wrapup_clean(int laststatus __unused)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
unlinkf(char * name)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
enable_q(struct printer * pp)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
disable_q(struct printer * pp)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
down_gi(int argc,char ** argv)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
down_q(struct printer * pp)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
quit(int argc __unused,char ** argv __unused)940 quit(int argc __unused, char **argv __unused)
941 {
942 exit(0);
943 }
944
945 /*
946 * Kill and restart the daemon.
947 */
948 void
restart_q(struct printer * pp)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
setstatus_gi(int argc __unused,char ** argv __unused)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
setstatus_q(struct printer * pp)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
start_q(struct printer * pp)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
status(struct printer * pp)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
stop_q(struct printer * pp)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
topq(int argc,char ** argv)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
touch(struct jobqueue * jq)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
doarg(char * job)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
up_q(struct printer * pp)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 }
1293