File:  [DragonFly] / src / usr.sbin / lpr / lpc / cmds.c
Revision 1.2: download - view: text, annotated - select for diffs
Tue Jun 17 04:29:56 2003 UTC (10 years, 10 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids.  Most
ids have been removed from !lint sections and moved into comment sections.

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