2 * SPDX-License-Identifier: BSD-3-Clause
4 * Copyright (c) 1983, 1993
5 * The Regents of the University of California. All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 static const char copyright[] =
35 "@(#) Copyright (c) 1983, 1993\n\
36 The Regents of the University of California. All rights reserved.\n";
41 static char sccsid[] = "@(#)cmds.c 8.2 (Berkeley) 4/28/95";
45 #include "lp.cdefs.h" /* A cross-platform version of <sys/cdefs.h> */
46 __FBSDID("$FreeBSD$");
49 * lpc -- line printer control program -- commands:
52 #include <sys/param.h>
71 #include "pathnames.h"
74 * Return values from kill_qtask().
76 #define KQT_LFERROR -2
77 #define KQT_KILLFAIL -1
78 #define KQT_NODAEMON 0
81 static char *args2line(int argc, char **argv);
82 static int doarg(char *_job);
83 static int doselect(const struct dirent *_d);
84 static int kill_qtask(const char *lf);
85 static int sortq(const struct dirent **a, const struct dirent **b);
86 static int touch(struct jobqueue *_jq);
87 static void unlinkf(char *_name);
88 static void upstat(struct printer *_pp, const char *_msg, int _notify);
89 static void wrapup_clean(int _laststatus);
92 * generic framework for commands which operate on all or a specified
95 enum qsel_val { /* how a given ptr was selected */
96 QSEL_UNKNOWN = -1, /* ... not selected yet */
97 QSEL_BYNAME = 0, /* ... user specifed it by name */
98 QSEL_ALL = 1 /* ... user wants "all" printers */
99 /* (with more to come) */
102 static enum qsel_val generic_qselect; /* indicates how ptr was selected */
103 static int generic_initerr; /* result of initrtn processing */
104 static char *generic_cmdname;
105 static char *generic_msg; /* if a -msg was specified */
106 static char *generic_nullarg;
107 static void (*generic_wrapup)(int _last_status); /* perform rtn wrap-up */
110 generic(void (*specificrtn)(struct printer *_pp), int cmdopts,
111 void (*initrtn)(int _argc, char *_argv[]), int argc, char *argv[])
113 int cmdstatus, more, targc;
114 struct printer myprinter, *pp;
115 char **margv, **targv;
119 * Usage needs a special case for 'down': The user must
120 * either include `-msg', or only the first parameter
121 * that they give will be processed as a printer name.
123 printf("usage: %s {all | printer ...}", argv[0]);
124 if (strcmp(argv[0], "down") == 0) {
125 printf(" -msg [<text> ...]\n");
126 printf(" or: down {all | printer} [<text> ...]");
127 } else if (cmdopts & LPC_MSGOPT)
128 printf(" [-msg <text> ...]");
133 /* The first argument is the command name. */
134 generic_cmdname = *argv++;
138 * The initialization routine for a command might set a generic
139 * "wrapup" routine, which should be called after processing all
140 * the printers in the command. This might print summary info.
142 * Note that the initialization routine may also parse (and
143 * nullify) some of the parameters given on the command, leaving
144 * only the parameters which have to do with printer names.
147 generic_wrapup = NULL;
148 generic_qselect = QSEL_UNKNOWN;
150 /* this just needs to be a distinct value of type 'char *' */
151 if (generic_nullarg == NULL)
152 generic_nullarg = strdup("");
155 * Some commands accept a -msg argument, which indicates that
156 * all remaining arguments should be combined into a string.
159 if (cmdopts & LPC_MSGOPT) {
162 for (; targc > 0; targc--, targv++) {
163 if (strcmp(*targv, "-msg") == 0) {
165 generic_msg = args2line(targc - 1, targv + 1);
170 printf("error: No printer name(s) specified before"
172 printf("usage: %s {all | printer ...}",
174 printf(" [-msg <text> ...]\n");
179 /* call initialization routine, if there is one for this cmd */
180 if (initrtn != NULL) {
182 (*initrtn)(argc, argv);
186 * The initrtn may have null'ed out some of the parameters.
187 * Compact the parameter list to remove those nulls, and
188 * correct the arg-count.
194 for (; targc > 0; targc--, targv++) {
195 if (*targv != generic_nullarg) {
204 if (argc == 1 && strcmp(*argv, "all") == 0) {
205 generic_qselect = QSEL_ALL;
206 more = firstprinter(pp, &cmdstatus);
212 more = nextprinter(pp, &cmdstatus);
216 printf("warning: %s: unresolved "
219 case PCAPERR_SUCCESS:
222 fatal(pp, "%s", pcaperr(cmdstatus));
224 } while (more && cmdstatus);
229 generic_qselect = QSEL_BYNAME; /* specifically-named ptrs */
230 for (; argc > 0; argc--, argv++) {
232 cmdstatus = getprintcap(*argv, pp);
235 fatal(pp, "%s", pcaperr(cmdstatus));
236 case PCAPERR_NOTFOUND:
237 printf("unknown printer %s\n", *argv);
240 printf("warning: %s: unresolved tc= reference(s)\n",
243 case PCAPERR_SUCCESS:
250 if (generic_wrapup) {
251 (*generic_wrapup)(cmdstatus);
259 * Convert an argv-array of character strings into a single string.
262 args2line(int argc, char **argv)
272 cend = buf + sizeof(buf) - 1; /* save room for '\0' */
273 while (--argc >= 0) {
275 while ((cp1 < cend) && (*cp1++ = *cp2++))
285 * Kill the current daemon, to stop printing of the active job.
288 kill_qtask(const char *lf)
292 int errsav, killres, lockres, res;
301 * If there is no lock file, then there is no daemon to
302 * kill. Any other error return means there is some
303 * kind of problem with the lock file.
305 if (errsav != ENOENT)
310 /* If the lock file is empty, then there is no daemon to kill */
311 if (get_line(fp) == 0)
315 * If the file can be locked without blocking, then there
316 * no daemon to kill, or we should not try to kill it.
318 * XXX - not sure I understand the reasoning behind this...
320 lockres = flock(fileno(fp), LOCK_SH|LOCK_NB);
328 * If we got a negative pid, then the contents of the
329 * lock file is not valid.
336 killres = kill(pid, SIGTERM);
341 printf("\tdaemon (pid %d) killed\n", pid);
342 } else if (errno == ESRCH) {
346 printf("\tWarning: daemon (pid %d) not killed:\n", pid);
347 printf("\t %s\n", strerror(errsav));
353 printf("\tcannot open lock file: %s\n",
357 printf("\tno daemon to abort\n");
361 /* These two already printed messages to the user. */
364 printf("\t<internal error in kill_qtask>\n");
372 * Write a message into the status file.
375 upstat(struct printer *pp, const char *msg, int notifyuser)
378 char statfile[MAXPATHLEN];
380 status_file_name(pp, statfile, sizeof statfile);
383 fd = open(statfile, O_WRONLY|O_CREAT|O_EXLOCK, STAT_FILE_MODE);
386 printf("\tcannot create status file: %s\n", strerror(errno));
389 (void) ftruncate(fd, 0);
391 (void) write(fd, "\n", 1);
393 (void) write(fd, msg, strlen(msg));
396 if ((msg == (char *)NULL) || (strcmp(msg, "\n") == 0))
397 printf("\tstatus message is now set to nothing.\n");
399 printf("\tstatus message is now: %s", msg);
404 * kill an existing daemon and disable printing.
407 abort_q(struct printer *pp)
412 lock_file_name(pp, lf, sizeof lf);
413 printf("%s:\n", pp->printer);
416 * Turn on the owner execute bit of the lock file to disable printing.
418 setres = set_qstate(SQS_STOPP, lf);
421 * If set_qstate found that there already was a lock file, then
422 * call a routine which will read that lock file and kill the
423 * lpd-process which is listed in that lock file. If the lock
424 * file did not exist, then either there is no daemon running
425 * for this queue, or there is one running but *it* could not
426 * write a lock file (which means we can not determine the
427 * process id of that lpd-process).
432 /* Kill the process */
433 killres = kill_qtask(lf);
437 printf("\tno daemon to abort\n");
440 printf("\tassuming no daemon to abort\n");
443 printf("\t<unexpected result (%d) from set_qstate>\n",
449 upstat(pp, "printing disabled\n", 0);
453 * "global" variables for all the routines related to 'clean' and 'tclean'
455 static time_t cln_now; /* current time */
456 static double cln_minage; /* minimum age before file is removed */
457 static long cln_sizecnt; /* amount of space freed up */
458 static int cln_debug; /* print extra debugging msgs */
459 static int cln_filecnt; /* number of files destroyed */
460 static int cln_foundcore; /* found a core file! */
461 static int cln_queuecnt; /* number of queues checked */
462 static int cln_testonly; /* remove-files vs just-print-info */
465 doselect(const struct dirent *d)
467 int c = d->d_name[0];
469 if ((c == 'c' || c == 'd' || c == 'r' || c == 't') &&
473 if (!strcmp(d->d_name, "core"))
477 if (!strncmp(d->d_name, "errs.", 5))
484 * Comparison routine that clean_q() uses for scandir.
486 * The purpose of this sort is to have all `df' files end up immediately
487 * after the matching `cf' file. For files matching `cf', `df', `rf', or
488 * `tf', it sorts by job number and machine, then by `cf', `df', `rf', or
489 * `tf', and then by the sequence letter (which is A-Z, or a-z). This
490 * routine may also see filenames which do not start with `cf', `df', `rf',
491 * or `tf' (such as `errs.*'), and those are simply sorted by the full
495 * This assumes that all control files start with `cfA*', and it turns
496 * out there are a few implementations of lpr which will create `cfB*'
497 * filenames (they will have datafile names which start with `dfB*').
500 sortq(const struct dirent **a, const struct dirent **b)
502 const int a_lt_b = -1, a_gt_b = 1, cat_other = 10;
503 const char *fname_a, *fname_b, *jnum_a, *jnum_b;
504 int cat_a, cat_b, ch, res, seq_a, seq_b;
506 fname_a = (*a)->d_name;
507 fname_b = (*b)->d_name;
510 * First separate filenames into categories. Categories are
511 * legitimate `cf', `df', `rf' & `tf' filenames, and "other" - in
512 * that order. It is critical that the mapping be exactly the
513 * same for 'a' vs 'b', so define a macro for the job.
515 * [aside: the standard `cf' file has the jobnumber start in
516 * position 4, but some implementations have that as an extra
517 * file-sequence letter, and start the job number in position 5.]
519 #define MAP_TO_CAT(fname_X,cat_X,jnum_X,seq_X) do { \
521 ch = *(fname_X + 2); \
522 jnum_X = fname_X + 3; \
524 if ((*(fname_X + 1) == 'f') && (isalpha(ch))) { \
526 if (*fname_X == 'c') \
528 else if (*fname_X == 'd') \
530 else if (*fname_X == 'r') \
532 else if (*fname_X == 't') \
534 if (cat_X != cat_other) { \
536 if (!isdigit(ch)) { \
540 seq_X = (seq_X << 8) + ch; \
549 MAP_TO_CAT(fname_a, cat_a, jnum_a, seq_a);
550 MAP_TO_CAT(fname_b, cat_b, jnum_b, seq_b);
554 /* First handle all cases which have "other" files */
555 if ((cat_a >= cat_other) || (cat_b >= cat_other)) {
556 /* for two "other" files, just compare the full name */
558 res = strcmp(fname_a, fname_b);
559 else if (cat_a < cat_b)
567 * At this point, we know both files are legitimate `cf', `df', `rf',
568 * or `tf' files. Compare them by job-number and machine name.
570 res = strcmp(jnum_a, jnum_b);
575 * We have two files which belong to the same job. Sort based
576 * on the category of file (`c' before `d', etc).
581 } else if (cat_a > cat_b) {
587 * Two files in the same category for a single job. Sort based
588 * on the sequence letter(s). (usually `A' through `Z', etc).
593 } else if (seq_a > seq_b) {
599 * Given that the filenames in a directory are unique, this SHOULD
600 * never happen (unless there are logic errors in this routine).
601 * But if it does happen, we must return "is equal" or the caller
602 * might see inconsistent results in the sorting order, and that
603 * can trigger other problems.
605 printf("\t*** Error in sortq: %s == %s !\n", fname_a, fname_b);
606 printf("\t*** cat %d == %d ; seq = %d %d\n", cat_a, cat_b,
615 * Remove all spool files and temporaries from the spooling area.
617 * Remove incomplete jobs from spooling area.
621 clean_gi(int argc, char *argv[])
624 /* init some fields before 'clean' is called for each queue */
626 cln_now = time(NULL);
627 cln_minage = 3600.0; /* only delete files >1h old */
632 generic_wrapup = &wrapup_clean;
634 /* see if there are any options specified before the ptr list */
635 for (; argc > 0; argc--, argv++) {
638 if (strcmp(*argv, "-d") == 0) {
639 /* just an example of an option... */
641 *argv = generic_nullarg; /* "erase" it */
643 printf("Invalid option '%s'\n", *argv);
652 tclean_gi(int argc, char *argv[])
655 /* only difference between 'clean' and 'tclean' is one value */
656 /* (...and the fact that 'clean' is priv and 'tclean' is not) */
657 clean_gi(argc, argv);
664 clean_q(struct printer *pp)
667 struct dirent **queue;
669 int didhead, i, n, nitems, rmcp;
674 if (generic_qselect == QSEL_BYNAME) {
675 printf("%s:\n", pp->printer);
681 while (lp < &line[sizeof(line) - 1]) {
682 if ((*lp++ = *cp++) == 0)
686 linerem = sizeof(line) - (lp - line);
690 nitems = scandir(pp->spool_dir, &queue, doselect, sortq);
694 printf("%s:\n", pp->printer);
697 printf("\tcannot examine spool directory\n");
702 printf("%s:\n", pp->printer);
705 printf("\t** found a core file in %s !\n", pp->spool_dir);
710 printf("%s:\n", pp->printer);
712 printf("\t** ----- Sorted list of files being checked:\n");
715 cp = queue[i]->d_name;
716 printf("\t** [%3d] = %s\n", i, cp);
717 } while (++i < nitems);
718 printf("\t** ----- end of sorted list\n");
722 cp = queue[i]->d_name;
726 * A control file. Look for matching data-files.
729 * Note the logic here assumes that the hostname
730 * part of cf-filenames match the hostname part
731 * in df-filenames, and that is not necessarily
732 * true (eg: for multi-homed hosts). This needs
733 * some further thought...
736 while (i + 1 < nitems) {
737 cp1 = queue[i + 1]->d_name;
738 if (*cp1 != 'd' || strcmp(cp + 3, cp1 + 3))
746 } else if (*cp == 'e') {
748 * Must be an errrs or email temp file.
753 * Must be a df with no cf (otherwise, it would have
754 * been skipped above) or an rf or tf file (which can
755 * always be removed if it is old enough).
760 if (strlen(cp) >= linerem) {
761 printf("\t** internal error: 'line' overflow!\n");
762 printf("\t** spooldir = %s\n", pp->spool_dir);
763 printf("\t** cp = %s\n", cp);
766 strlcpy(lp, cp, linerem);
769 } while (++i < nitems);
773 wrapup_clean(int laststatus __unused)
776 printf("Checked %d queues, and ", cln_queuecnt);
777 if (cln_filecnt < 1) {
778 printf("no cruft was found\n");
782 printf("would have ");
784 printf("removed %d files (%ld bytes).\n", cln_filecnt, cln_sizecnt);
791 double agemod, agestat;
793 char linkbuf[BUFSIZ];
796 * We have to use lstat() instead of stat(), in case this is a df*
797 * "file" which is really a symlink due to 'lpr -s' processing. In
798 * that case, we need to check the last-mod time of the symlink, and
799 * not the file that the symlink is pointed at.
802 res = lstat(name, &stbuf);
805 printf("\terror return from stat(%s):\n", name);
806 printf("\t %s\n", strerror(errno));
810 agemod = difftime(cln_now, stbuf.st_mtime);
811 agestat = difftime(cln_now, stbuf.st_ctime);
813 /* this debugging-aid probably is not needed any more... */
814 printf("\t\t modify age=%g secs, stat age=%g secs\n",
817 if ((agemod <= cln_minage) && (agestat <= cln_minage))
821 * if this file is a symlink, then find out the target of the
822 * symlink before unlink-ing the file itself
824 if (S_ISLNK(stbuf.st_mode)) {
826 res = readlink(name, linkbuf, sizeof(linkbuf));
829 printf("\terror return from readlink(%s):\n", name);
830 printf("\t %s\n", strerror(errno));
833 if (res == sizeof(linkbuf))
839 cln_sizecnt += stbuf.st_size;
842 printf("\twould remove %s\n", name);
843 if (S_ISLNK(stbuf.st_mode)) {
844 printf("\t (which is a symlink to %s)\n", linkbuf);
851 printf("\tcannot remove %s (!)\n", name);
853 printf("\tremoved %s\n", name);
855 * Note that for a df* file, this code should also check to see
856 * if it is a symlink to some other file, and if the original
857 * lpr command included '-r' ("remove file"). Of course, this
858 * code would not be removing the df* file unless there was no
859 * matching cf* file, and without the cf* file it is currently
860 * impossible to determine if '-r' had been specified...
862 * As a result of this quandry, we may be leaving behind a
863 * user's file that was supposed to have been removed after
864 * being printed. This may effect services such as CAP or
865 * samba, if they were configured to use 'lpr -r', and if
866 * datafiles are not being properly removed.
868 if (S_ISLNK(stbuf.st_mode)) {
869 printf("\t (which was a symlink to %s)\n", linkbuf);
875 * Enable queuing to the printer (allow lpr to add new jobs to the queue).
878 enable_q(struct printer *pp)
883 lock_file_name(pp, lf, sizeof lf);
884 printf("%s:\n", pp->printer);
886 setres = set_qstate(SQS_ENABLEQ, lf);
893 disable_q(struct printer *pp)
898 lock_file_name(pp, lf, sizeof lf);
899 printf("%s:\n", pp->printer);
901 setres = set_qstate(SQS_DISABLEQ, lf);
905 * Disable queuing and printing and put a message into the status file
906 * (reason for being down). If the user specified `-msg', then use
907 * everything after that as the message for the status file. If the
908 * user did NOT specify `-msg', then the command should take the first
909 * parameter as the printer name, and all remaining parameters as the
910 * message for the status file. (This is to be compatible with the
911 * original definition of 'down', which was implemented long before
912 * `-msg' was around).
915 down_gi(int argc, char *argv[])
918 /* If `-msg' was specified, then this routine has nothing to do. */
919 if (generic_msg != NULL)
923 * If the user only gave one parameter, then use a default msg.
924 * (if argc == 1 at this point, then *argv == name of printer).
927 generic_msg = strdup("printing disabled\n");
932 * The user specified multiple parameters, and did not specify
933 * `-msg'. Build a message from all the parameters after the
934 * first one (and nullify those parameters so generic-processing
935 * will not process them as printer-queue names).
939 generic_msg = args2line(argc, argv);
940 for (; argc > 0; argc--, argv++)
941 *argv = generic_nullarg; /* "erase" it */
945 down_q(struct printer *pp)
950 lock_file_name(pp, lf, sizeof lf);
951 printf("%s:\n", pp->printer);
953 setres = set_qstate(SQS_DISABLEQ+SQS_STOPP, lf);
955 upstat(pp, generic_msg, 1);
962 quit(int argc __unused, char *argv[] __unused)
968 * Kill and restart the daemon.
971 restart_q(struct printer *pp)
973 int killres, setres, startok;
976 lock_file_name(pp, lf, sizeof lf);
977 printf("%s:\n", pp->printer);
979 killres = kill_qtask(lf);
982 * XXX - if the kill worked, we should probably sleep for
983 * a second or so before trying to restart the queue.
986 /* make sure the queue is set to print jobs */
987 setres = set_qstate(SQS_STARTP, lf);
990 startok = startdaemon(pp);
993 printf("\tcouldn't restart daemon\n");
995 printf("\tdaemon restarted\n");
999 * Set the status message of each queue listed. Requires a "-msg"
1000 * parameter to indicate the end of the queue list and start of msg text.
1003 setstatus_gi(int argc __unused, char *argv[] __unused)
1006 if (generic_msg == NULL) {
1007 printf("You must specify '-msg' before the text of the new status message.\n");
1008 generic_initerr = 1;
1013 setstatus_q(struct printer *pp)
1017 char lf[MAXPATHLEN];
1019 lock_file_name(pp, lf, sizeof lf);
1020 printf("%s:\n", pp->printer);
1022 upstat(pp, generic_msg, 1);
1025 * Warn the user if 'lpq' will not display this new status-message.
1026 * Note that if lock file does not exist, then the queue is enabled
1027 * for both queuing and printing.
1030 if (stat(lf, &stbuf) >= 0) {
1031 if (stbuf.st_mode & LFM_PRINT_DIS)
1035 printf("\tnote: This queue currently has printing enabled,\n");
1036 printf("\t so this -msg will only be shown by 'lpq' if\n");
1037 printf("\t a job is actively printing on it.\n");
1042 * Enable printing on the specified printer and startup the daemon.
1045 start_q(struct printer *pp)
1047 int setres, startok;
1048 char lf[MAXPATHLEN];
1050 lock_file_name(pp, lf, sizeof lf);
1051 printf("%s:\n", pp->printer);
1053 setres = set_qstate(SQS_STARTP, lf);
1056 startok = startdaemon(pp);
1059 printf("\tcouldn't start daemon\n");
1061 printf("\tdaemon started\n");
1066 * Print the status of the printer queue.
1069 status(struct printer *pp)
1073 register struct dirent *dp;
1075 char file[MAXPATHLEN];
1077 printf("%s:\n", pp->printer);
1078 lock_file_name(pp, file, sizeof file);
1079 if (stat(file, &stbuf) >= 0) {
1080 printf("\tqueuing is %s\n",
1081 ((stbuf.st_mode & LFM_QUEUE_DIS) ? "disabled"
1083 printf("\tprinting is %s\n",
1084 ((stbuf.st_mode & LFM_PRINT_DIS) ? "disabled"
1087 printf("\tqueuing is enabled\n");
1088 printf("\tprinting is enabled\n");
1090 if ((dirp = opendir(pp->spool_dir)) == NULL) {
1091 printf("\tcannot examine spool directory\n");
1095 while ((dp = readdir(dirp)) != NULL) {
1096 if (*dp->d_name == 'c' && dp->d_name[1] == 'f')
1101 printf("\tno entries in spool area\n");
1103 printf("\t1 entry in spool area\n");
1105 printf("\t%d entries in spool area\n", i);
1106 fd = open(file, O_RDONLY);
1107 if (fd < 0 || flock(fd, LOCK_SH|LOCK_NB) == 0) {
1108 (void) close(fd); /* unlocks as well */
1109 printf("\tprinter idle\n");
1113 /* print out the contents of the status file, if it exists */
1114 status_file_name(pp, file, sizeof file);
1115 fd = open(file, O_RDONLY|O_SHLOCK);
1117 (void) fstat(fd, &stbuf);
1118 if (stbuf.st_size > 0) {
1120 while ((i = read(fd, line, sizeof(line))) > 0)
1121 (void) fwrite(line, 1, i, stdout);
1123 (void) close(fd); /* unlocks as well */
1128 * Stop the specified daemon after completing the current job and disable
1132 stop_q(struct printer *pp)
1135 char lf[MAXPATHLEN];
1137 lock_file_name(pp, lf, sizeof lf);
1138 printf("%s:\n", pp->printer);
1140 setres = set_qstate(SQS_STOPP, lf);
1143 upstat(pp, "printing disabled\n", 0);
1146 struct jobqueue **queue;
1151 * Put the specified jobs at the top of printer queue.
1154 topq(int argc, char *argv[])
1158 int cmdstatus, changed;
1159 struct printer myprinter, *pp = &myprinter;
1162 printf("usage: topq printer [jobnum ...] [user ...]\n");
1169 cmdstatus = getprintcap(*argv, pp);
1172 fatal(pp, "%s", pcaperr(cmdstatus));
1173 case PCAPERR_NOTFOUND:
1174 printf("unknown printer %s\n", *argv);
1176 case PCAPERR_TCOPEN:
1177 printf("warning: %s: unresolved tc= reference(s)", *argv);
1179 case PCAPERR_SUCCESS:
1182 printf("%s:\n", pp->printer);
1185 if (chdir(pp->spool_dir) < 0) {
1186 printf("\tcannot chdir to %s\n", pp->spool_dir);
1190 nitems = getq(pp, &queue);
1194 mtime = queue[0]->job_time;
1195 for (i = argc; --i; ) {
1196 if (doarg(argv[i]) == 0) {
1197 printf("\tjob %s is not in the queue\n", argv[i]);
1202 for (i = 0; i < nitems; i++)
1206 printf("\tqueue order unchanged\n");
1210 * Turn on the public execute bit of the lock file to
1211 * get lpd to rebuild the queue after the current job.
1214 if (changed && stat(pp->lock_file, &stbuf) >= 0)
1215 (void) chmod(pp->lock_file, stbuf.st_mode | LFM_RESET_QUE);
1222 * Reposition the job by changing the modification time of
1226 touch(struct jobqueue *jq)
1228 struct timeval tvp[2];
1231 tvp[0].tv_sec = tvp[1].tv_sec = --mtime;
1232 tvp[0].tv_usec = tvp[1].tv_usec = 0;
1234 ret = utimes(jq->job_cfname, tvp);
1240 * Checks if specified job name is in the printer's queue.
1241 * Returns: negative (-1) if argument name is not in the queue.
1246 register struct jobqueue **qq;
1247 register int jobnum, n;
1248 register char *cp, *machine;
1253 * Look for a job item consisting of system name, colon, number
1254 * (example: ucbarpa:114)
1256 if ((cp = strchr(job, ':')) != NULL) {
1264 * Check for job specified by number (example: 112 or 235ucbarpa).
1266 if (isdigit(*job)) {
1269 jobnum = jobnum * 10 + (*job++ - '0');
1270 while (isdigit(*job));
1271 for (qq = queue + nitems; --qq >= queue; ) {
1273 for (cp = (*qq)->job_cfname+3; isdigit(*cp); )
1274 n = n * 10 + (*cp++ - '0');
1277 if (*job && strcmp(job, cp) != 0)
1279 if (machine != NULL && strcmp(machine, cp) != 0)
1281 if (touch(*qq) == 0) {
1282 printf("\tmoved %s\n", (*qq)->job_cfname);
1289 * Process item consisting of owner's name (example: henry).
1291 for (qq = queue + nitems; --qq >= queue; ) {
1293 fp = fopen((*qq)->job_cfname, "r");
1297 while (get_line(fp) > 0)
1301 if (line[0] != 'P' || strcmp(job, line+1) != 0)
1303 if (touch(*qq) == 0) {
1304 printf("\tmoved %s\n", (*qq)->job_cfname);
1312 * Enable both queuing & printing, and start printer (undo `down').
1315 up_q(struct printer *pp)
1317 int setres, startok;
1318 char lf[MAXPATHLEN];
1320 lock_file_name(pp, lf, sizeof lf);
1321 printf("%s:\n", pp->printer);
1323 setres = set_qstate(SQS_ENABLEQ+SQS_STARTP, lf);
1326 startok = startdaemon(pp);
1329 printf("\tcouldn't start daemon\n");
1331 printf("\tdaemon started\n");