text: /*
   * Copyright (c) 1983, 1993
   *	The Regents of the University of California.  All rights reserved.
   *
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
   * 3. All advertising materials mentioning features or use of this software
   *    must display the following acknowledgement:
   *	This product includes software developed by the University of
   *	California, Berkeley and its contributors.
   * 4. Neither the name of the University nor the names of its contributors
   *    may be used to endorse or promote products derived from this software
   *    without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   */
  
  #ifndef lint
  static const char copyright[] =
  "@(#) Copyright (c) 1983, 1993\n\
  	The Regents of the University of California.  All rights reserved.\n";
  #endif /* not lint */
  
  #if 0
  #ifndef lint
  static char sccsid[] = "@(#)cmds.c	8.2 (Berkeley) 4/28/95";
  #endif /* not lint */
  #endif
  
  #include "lp.cdefs.h"		/* A cross-platform version of <sys/cdefs.h> */
  __FBSDID("$FreeBSD: src/usr.sbin/lpr/lpc/cmds.c,v 1.32 2003/07/14 22:24:28 gad Exp $");
  
  /*
   * lpc -- line printer control program -- commands:
   */
  
  #include <sys/param.h>
  #include <sys/time.h>
  #include <sys/stat.h>
  #include <sys/file.h>
  
  #include <signal.h>
  #include <fcntl.h>
  #include <errno.h>
  #include <dirent.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <stdio.h>
  #include <ctype.h>
  #include <string.h>
  #include "lp.h"
  #include "lp.local.h"
  #include "lpc.h"
  #include "extern.h"
  #include "pathnames.h"
  
  /*
   * Return values from kill_qtask().
   */
  #define KQT_LFERROR	-2
  #define KQT_KILLFAIL	-1
  #define KQT_NODAEMON	0
  #define KQT_KILLOK	1
  
  static char	*args2line(int argc, char **argv);
  static int	 doarg(char *_job);
  static int	 doselect(struct dirent *_d);
  static int	 kill_qtask(const char *lf);
  static int	 sortq(const void *_a, const void *_b);
  static int	 touch(struct jobqueue *_jq);
  static void	 unlinkf(char *_name);
  static void	 upstat(struct printer *_pp, const char *_msg, int _notify);
  static void	 wrapup_clean(int _laststatus);
  
  /*
   * generic framework for commands which operate on all or a specified
   * set of printers
   */
  enum	qsel_val {			/* how a given ptr was selected */
  	QSEL_UNKNOWN = -1,		/* ... not selected yet */
  	QSEL_BYNAME = 0,		/* ... user specifed it by name */
  	QSEL_ALL = 1			/* ... user wants "all" printers */
  					/*     (with more to come)    */
  };
  
  static enum qsel_val generic_qselect;	/* indicates how ptr was selected */
  static int generic_initerr;		/* result of initrtn processing */
  static char *generic_cmdname;
  static char *generic_msg;		/* if a -msg was specified */
  static char *generic_nullarg;
  static void (*generic_wrapup)(int _last_status);   /* perform rtn wrap-up */
  
  void
  generic(void (*specificrtn)(struct printer *_pp), int cmdopts,
      void (*initrtn)(int _argc, char *_argv[]), int argc, char *argv[])
  {
  	int cmdstatus, more, targc;
  	struct printer myprinter, *pp;
  	char **margv, **targv;
  
  	if (argc == 1) {
  		/*
  		 * Usage needs a special case for 'down': The user must
  		 * either include `-msg', or only the first parameter
  		 * that they give will be processed as a printer name.
  		 */
  		printf("usage: %s  {all | printer ...}", argv[0]);
  		if (strcmp(argv[0], "down") == 0) {
  			printf(" -msg [<text> ...]\n");
  			printf("   or: down  {all | printer} [<text> ...]");
  		} else if (cmdopts & LPC_MSGOPT)
  			printf(" [-msg <text> ...]");
  		printf("\n");
  		return;
  	}
  
  	/* The first argument is the command name. */
  	generic_cmdname = *argv++;
  	argc--;
  
  	/*
  	 * The initialization routine for a command might set a generic
  	 * "wrapup" routine, which should be called after processing all
  	 * the printers in the command.  This might print summary info.
  	 *
  	 * Note that the initialization routine may also parse (and
  	 * nullify) some of the parameters given on the command, leaving
  	 * only the parameters which have to do with printer names.
  	 */
  	pp = &myprinter;
  	generic_wrapup = NULL;
  	generic_qselect = QSEL_UNKNOWN;
  	cmdstatus = 0;
  	/* this just needs to be a distinct value of type 'char *' */
  	if (generic_nullarg == NULL)
  		generic_nullarg = strdup("");
  
  	/*
  	 * Some commands accept a -msg argument, which indicates that
  	 * all remaining arguments should be combined into a string.
  	 */
  	generic_msg = NULL;
  	if (cmdopts & LPC_MSGOPT) {
  		targc = argc;
  		targv = argv;
  		for (; targc > 0; targc--, targv++) {
  			if (strcmp(*targv, "-msg") == 0) {
  				argc -= targc;
  				generic_msg = args2line(targc - 1, targv + 1);
  				break;
  			}
  		}
  	}
  
  	/* call initialization routine, if there is one for this cmd */
  	if (initrtn != NULL) {
  		generic_initerr = 0;
  		(*initrtn)(argc, argv);
  		if (generic_initerr)
  			return;
  		/*
  		 * The initrtn may have null'ed out some of the parameters.
  		 * Compact the parameter list to remove those nulls, and
  		 * correct the arg-count.
  		 */
  		targc = argc;
  		targv = argv;
  		margv = argv;
  		argc = 0;
  		for (; targc > 0; targc--, targv++) {
  			if (*targv != generic_nullarg) {
  				if (targv != margv)
  					*margv = *targv;
  				margv++;
  				argc++;
  			}
  		}
  	}
  
  	if (argc == 1 && strcmp(*argv, "all") == 0) {
  		generic_qselect = QSEL_ALL;
  		more = firstprinter(pp, &cmdstatus);
  		if (cmdstatus)
  			goto looperr;
  		while (more) {
  			(*specificrtn)(pp);
  			do {
  				more = nextprinter(pp, &cmdstatus);
  looperr:
  				switch (cmdstatus) {
  				case PCAPERR_TCOPEN:
  					printf("warning: %s: unresolved "
  					       "tc= reference(s) ",
  					       pp->printer);
  				case PCAPERR_SUCCESS:
  					break;
  				default:
  					fatal(pp, "%s", pcaperr(cmdstatus));
  				}
  			} while (more && cmdstatus);
  		}
  		goto wrapup;
  	}
  
  	generic_qselect = QSEL_BYNAME;		/* specifically-named ptrs */
  	for (; argc > 0; argc--, argv++) {
  		init_printer(pp);
  		cmdstatus = getprintcap(*argv, pp);
  		switch (cmdstatus) {
  		default:
  			fatal(pp, "%s", pcaperr(cmdstatus));
  		case PCAPERR_NOTFOUND:
  			printf("unknown printer %s\n", *argv);
  			continue;
  		case PCAPERR_TCOPEN:
  			printf("warning: %s: unresolved tc= reference(s)\n",
  			       *argv);
  			break;
  		case PCAPERR_SUCCESS:
  			break;
  		}
  		(*specificrtn)(pp);
  	}
  
  wrapup:
  	if (generic_wrapup) {
  		(*generic_wrapup)(cmdstatus);
  	}
  	free_printer(pp);
  	if (generic_msg)
  		free(generic_msg);
  }
  
  /*
   * Convert an argv-array of character strings into a single string.
   */
  static char *
  args2line(int argc, char **argv)
  {
  	char *cp1, *cend;
  	const char *cp2;
  	char buf[1024];
  
  	if (argc <= 0)
  		return strdup("\n");
  
  	cp1 = buf;
  	cend = buf + sizeof(buf) - 1;		/* save room for '\0' */
  	while (--argc >= 0) {
  		cp2 = *argv++;
  		while ((cp1 < cend) && (*cp1++ = *cp2++))
  			;
  		cp1[-1] = ' ';
  	}
  	cp1[-1] = '\n';
  	*cp1 = '\0';
  	return strdup(buf);
  }
  
  /*
   * Kill the current daemon, to stop printing of the active job.
   */
  static int
  kill_qtask(const char *lf)
  {
  	FILE *fp;
  	pid_t pid;
  	int errsav, killres, lockres, res;
  
  	seteuid(euid);
  	fp = fopen(lf, "r");
  	errsav = errno;
  	seteuid(uid);
  	res = KQT_NODAEMON;
  	if (fp == NULL) {
  		/*
  		 * If there is no lock file, then there is no daemon to
  		 * kill.  Any other error return means there is some
  		 * kind of problem with the lock file.
  		 */
  		if (errsav != ENOENT)
  			res = KQT_LFERROR;
  		goto killdone;
  	}
  
  	/* If the lock file is empty, then there is no daemon to kill */
  	if (getline(fp) == 0)
  		goto killdone;
  
  	/*
  	 * If the file can be locked without blocking, then there
  	 * no daemon to kill, or we should not try to kill it.
  	 *
  	 * XXX - not sure I understand the reasoning behind this...
  	 */
  	lockres = flock(fileno(fp), LOCK_SH|LOCK_NB);
  	(void) fclose(fp);
  	if (lockres == 0)
  		goto killdone;
  
  	pid = atoi(line);
  	if (pid < 0) {
  		/*
  		 * If we got a negative pid, then the contents of the
  		 * lock file is not valid.
  		 */
  		res = KQT_LFERROR;
  		goto killdone;
  	}
  
  	seteuid(uid);
  	killres = kill(pid, SIGTERM);
  	errsav = errno;
  	seteuid(uid);
  	if (killres == 0) {
  		res = KQT_KILLOK;
  		printf("\tdaemon (pid %d) killed\n", pid);
  	} else if (errno == ESRCH) {
  		res = KQT_NODAEMON;
  	} else {
  		res = KQT_KILLFAIL;
  		printf("\tWarning: daemon (pid %d) not killed:\n", pid);
  		printf("\t    %s\n", strerror(errsav));
  	}
  
  killdone:
  	switch (res) {
  	case KQT_LFERROR:
  		printf("\tcannot open lock file: %s\n",
  		    strerror(errsav));
  		break;
  	case KQT_NODAEMON:
  		printf("\tno daemon to abort\n");
  		break;
  	case KQT_KILLFAIL:
  	case KQT_KILLOK:
  		/* These two already printed messages to the user. */
  		break;
  	default:
  		printf("\t<internal error in kill_qtask>\n");
  		break;
  	}
  
  	return (res);
  }
  
  /*
   * Write a message into the status file.
   */
  static void
  upstat(struct printer *pp, const char *msg, int notifyuser)
  {
  	int fd;
  	char statfile[MAXPATHLEN];
  
  	status_file_name(pp, statfile, sizeof statfile);
  	umask(0);
  	seteuid(euid);
  	fd = open(statfile, O_WRONLY|O_CREAT|O_EXLOCK, STAT_FILE_MODE);
  	seteuid(uid);
  	if (fd < 0) {
  		printf("\tcannot create status file: %s\n", strerror(errno));
  		return;
  	}
  	(void) ftruncate(fd, 0);
  	if (msg == (char *)NULL)
  		(void) write(fd, "\n", 1);
  	else
  		(void) write(fd, msg, strlen(msg));
  	(void) close(fd);
  	if (notifyuser) {
  		if ((msg == (char *)NULL) || (strcmp(msg, "\n") == 0))
  			printf("\tstatus message is now set to nothing.\n");
  		else
  			printf("\tstatus message is now: %s", msg);
  	}
  }
  
  /*
   * kill an existing daemon and disable printing.
   */
  void
  abort_q(struct printer *pp)
  {
  	int killres, setres;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	/*
  	 * Turn on the owner execute bit of the lock file to disable printing.
  	 */
  	setres = set_qstate(SQS_STOPP, lf);
  
  	/*
  	 * If set_qstate found that there already was a lock file, then
  	 * call a routine which will read that lock file and kill the
  	 * lpd-process which is listed in that lock file.  If the lock
  	 * file did not exist, then either there is no daemon running
  	 * for this queue, or there is one running but *it* could not
  	 * write a lock file (which means we can not determine the
  	 * process id of that lpd-process).
  	 */
  	switch (setres) {
  	case SQS_CHGOK:
  	case SQS_CHGFAIL:
  		/* Kill the process */
  		killres = kill_qtask(lf);
  		break;
  	case SQS_CREOK:
  	case SQS_CREFAIL:
  		printf("\tno daemon to abort\n");
  		break;
  	case SQS_STATFAIL:
  		printf("\tassuming no daemon to abort\n");
  		break;
  	default:
  		printf("\t<unexpected result (%d) from set_qstate>\n",
  		    setres);
  		break;
  	}
  
  	if (setres >= 0)
  		upstat(pp, "printing disabled\n", 0);
  }
  
  /*
   * "global" variables for all the routines related to 'clean' and 'tclean'
   */
  static time_t	 cln_now;		/* current time */
  static double	 cln_minage;		/* minimum age before file is removed */
  static long	 cln_sizecnt;		/* amount of space freed up */
  static int 	 cln_debug;		/* print extra debugging msgs */
  static int	 cln_filecnt;		/* number of files destroyed */
  static int	 cln_foundcore;		/* found a core file! */
  static int	 cln_queuecnt;		/* number of queues checked */
  static int 	 cln_testonly;		/* remove-files vs just-print-info */
  
  static int
  doselect(struct dirent *d)
  {
  	int c = d->d_name[0];
  
  	if ((c == 'c' || c == 'd' || c == 'r' || c == 't') &&
  	    d->d_name[1] == 'f')
  		return 1;
  	if (c == 'c') {
  		if (!strcmp(d->d_name, "core"))
  			cln_foundcore = 1;
  	}
  	if (c == 'e') {
  		if (!strncmp(d->d_name, "errs.", 5))
  			return 1;
  	}
  	return 0;
  }
  
  /*
   * Comparison routine that clean_q() uses for scandir.
   *
   * The purpose of this sort is to have all `df' files end up immediately
   * after the matching `cf' file.  For files matching `cf', `df', `rf', or
   * `tf', it sorts by job number and machine, then by `cf', `df', `rf', or
   * `tf', and then by the sequence letter (which is A-Z, or a-z).    This
   * routine may also see filenames which do not start with `cf', `df', `rf',
   * or `tf' (such as `errs.*'), and those are simply sorted by the full
   * filename.
   *
   * XXX
   *   This assumes that all control files start with `cfA*', and it turns
   *   out there are a few implementations of lpr which will create `cfB*'
   *   filenames (they will have datafile names which start with `dfB*').
   */
  static int
  sortq(const void *a, const void *b)
  {
  	const int a_lt_b = -1, a_gt_b = 1, cat_other = 10;
  	const char *fname_a, *fname_b, *jnum_a, *jnum_b;
  	int cat_a, cat_b, ch, res, seq_a, seq_b;
  
  	fname_a = (*(const struct dirent * const *)a)->d_name;
  	fname_b = (*(const struct dirent * const *)b)->d_name;
  
  	/*
  	 * First separate filenames into cagatories.  Catagories are
  	 * legitimate `cf', `df', `rf' & `tf' filenames, and "other" - in
  	 * that order.  It is critical that the mapping be exactly the
  	 * same for 'a' vs 'b', so define a macro for the job.
  	 *
  	 * [aside: the standard `cf' file has the jobnumber start in
  	 * position 4, but some implementations have that as an extra
  	 * file-sequence letter, and start the job number in position 5.]
  	 */
  #define MAP_TO_CAT(fname_X,cat_X,jnum_X,seq_X) do { \
  	cat_X = cat_other;    \
  	ch = *(fname_X + 2);  \
  	jnum_X = fname_X + 3; \
  	seq_X = 0;            \
  	if ((*(fname_X + 1) == 'f') && (isalpha(ch))) { \
  		seq_X = ch; \
  		if (*fname_X == 'c') \
  			cat_X = 1; \
  		else if (*fname_X == 'd') \
  			cat_X = 2; \
  		else if (*fname_X == 'r') \
  			cat_X = 3; \
  		else if (*fname_X == 't') \
  			cat_X = 4; \
  		if (cat_X != cat_other) { \
  			ch = *jnum_X; \
  			if (!isdigit(ch)) { \
  				if (isalpha(ch)) { \
  					jnum_X++; \
  					ch = *jnum_X; \
  					seq_X = (seq_X << 8) + ch; \
  				} \
  				if (!isdigit(ch)) \
  					cat_X = cat_other; \
  			} \
  		} \
  	} \
  } while (0)
  
  	MAP_TO_CAT(fname_a, cat_a, jnum_a, seq_a);
  	MAP_TO_CAT(fname_b, cat_b, jnum_b, seq_b);
  
  #undef MAP_TO_CAT
  
  	/* First handle all cases which have "other" files */
  	if ((cat_a >= cat_other) || (cat_b >= cat_other)) {
  		/* for two "other" files, just compare the full name */
  		if (cat_a == cat_b)
  			res = strcmp(fname_a, fname_b);
  		else if (cat_a < cat_b)
  			res = a_lt_b;
  		else
  			res = a_gt_b;
  		goto have_res;
  	}
  
  	/*
  	 * At this point, we know both files are legitimate `cf', `df', `rf',
  	 * or `tf' files.  Compare them by job-number and machine name.
  	 */
  	res = strcmp(jnum_a, jnum_b);
  	if (res != 0)
  		goto have_res;
  
  	/*
  	 * We have two files which belong to the same job.  Sort based
  	 * on the catagory of file (`c' before `d', etc).
  	 */
  	if (cat_a < cat_b) {
  		res = a_lt_b;
  		goto have_res;
  	} else if (cat_a > cat_b) {
  		res = a_gt_b;
  		goto have_res;
  	}
  
  	/*
  	 * Two files in the same catagory for a single job.  Sort based
  	 * on the sequence letter(s).  (usually `A' thru `Z', etc).
  	 */
  	if (seq_a < seq_b) {
  		res = a_lt_b;
  		goto have_res;
  	} else if (seq_a > seq_b) {
  		res = a_gt_b;
  		goto have_res;
  	}
  
  	/*
  	 * Given that the filenames in a directory are unique, this SHOULD
  	 * never happen (unless there are logic errors in this routine).
  	 * But if it does happen, we must return "is equal" or the caller
  	 * might see inconsistent results in the sorting order, and that
  	 * can trigger other problems.
  	 */
  	printf("\t*** Error in sortq: %s == %s !\n", fname_a, fname_b);
  	printf("\t***       cat %d == %d ; seq = %d %d\n", cat_a, cat_b,
  	    seq_a, seq_b);
  	res = 0;
  
  have_res:
  	return res;
  }
  
  /*
   * Remove all spool files and temporaries from the spooling area.
   * Or, perhaps:
   * Remove incomplete jobs from spooling area.
   */
  
  void
  clean_gi(int argc, char *argv[])
  {
  
  	/* init some fields before 'clean' is called for each queue */
  	cln_queuecnt = 0;
  	cln_now = time(NULL);
  	cln_minage = 3600.0;		/* only delete files >1h old */
  	cln_filecnt = 0;
  	cln_sizecnt = 0;
  	cln_debug = 0;
  	cln_testonly = 0;
  	generic_wrapup = &wrapup_clean;
  
  	/* see if there are any options specified before the ptr list */
  	for (; argc > 0; argc--, argv++) {
  		if (**argv != '-')
  			break;
  		if (strcmp(*argv, "-d") == 0) {
  			/* just an example of an option... */
  			cln_debug++;
  			*argv = generic_nullarg;	/* "erase" it */
  		} else {
  			printf("Invalid option '%s'\n", *argv);
  			generic_initerr = 1;
  		}
  	}
  
  	return;
  }
  
  void
  tclean_gi(int argc, char *argv[])
  {
  
  	/* only difference between 'clean' and 'tclean' is one value */
  	/* (...and the fact that 'clean' is priv and 'tclean' is not) */
  	clean_gi(argc, argv);
  	cln_testonly = 1;
  
  	return;
  }
  
  void
  clean_q(struct printer *pp)
  {
  	char *cp, *cp1, *lp;
  	struct dirent **queue;
  	size_t linerem;
  	int didhead, i, n, nitems, rmcp;
  
  	cln_queuecnt++;
  
  	didhead = 0;
  	if (generic_qselect == QSEL_BYNAME) {
  		printf("%s:\n", pp->printer);
  		didhead = 1;
  	}
  
  	lp = line;
  	cp = pp->spool_dir;
  	while (lp < &line[sizeof(line) - 1]) {
  		if ((*lp++ = *cp++) == 0)
  			break;
  	}
  	lp[-1] = '/';
  	linerem = sizeof(line) - (lp - line);
  
  	cln_foundcore = 0;
  	seteuid(euid);
  	nitems = scandir(pp->spool_dir, &queue, doselect, sortq);
  	seteuid(uid);
  	if (nitems < 0) {
  		if (!didhead) {
  			printf("%s:\n", pp->printer);
  			didhead = 1;
  		}
  		printf("\tcannot examine spool directory\n");
  		return;
  	}
  	if (cln_foundcore) {
  		if (!didhead) {
  			printf("%s:\n", pp->printer);
  			didhead = 1;
  		}
  		printf("\t** found a core file in %s !\n", pp->spool_dir);
  	}
  	if (nitems == 0)
  		return;
  	if (!didhead)
  		printf("%s:\n", pp->printer);
  	if (cln_debug) {
  		printf("\t** ----- Sorted list of files being checked:\n");
  		i = 0;
  		do {
  			cp = queue[i]->d_name;
  			printf("\t** [%3d] = %s\n", i, cp);
  		} while (++i < nitems);
  		printf("\t** ----- end of sorted list\n");
  	}
  	i = 0;
  	do {
  		cp = queue[i]->d_name;
  		rmcp = 0;
  		if (*cp == 'c') {
  			/*
  			 * A control file.  Look for matching data-files.
  			 */
  			/* XXX
  			 *  Note the logic here assumes that the hostname
  			 *  part of cf-filenames match the hostname part
  			 *  in df-filenames, and that is not necessarily
  			 *  true (eg: for multi-homed hosts).  This needs
  			 *  some further thought...
  			 */
  			n = 0;
  			while (i + 1 < nitems) {
  				cp1 = queue[i + 1]->d_name;
  				if (*cp1 != 'd' || strcmp(cp + 3, cp1 + 3))
  					break;
  				i++;
  				n++;
  			}
  			if (n == 0) {
  				rmcp = 1;
  			}
  		} else if (*cp == 'e') {
  			/*
  			 * Must be an errrs or email temp file.
  			 */
  			rmcp = 1;
  		} else {
  			/*
  			 * Must be a df with no cf (otherwise, it would have
  			 * been skipped above) or an rf or tf file (which can
  			 * always be removed if it is old enough).
  			 */
  			rmcp = 1;
  		}
  		if (rmcp) {
  			if (strlen(cp) >= linerem) {
  				printf("\t** internal error: 'line' overflow!\n");
  				printf("\t**   spooldir = %s\n", pp->spool_dir);
  				printf("\t**   cp = %s\n", cp);
  				return;
  			}
  			strlcpy(lp, cp, linerem);
  			unlinkf(line);
  		}
       	} while (++i < nitems);
  }
  
  static void
  wrapup_clean(int laststatus __unused)
  {
  
  	printf("Checked %d queues, and ", cln_queuecnt);
  	if (cln_filecnt < 1) {
  		printf("no cruft was found\n");
  		return;
  	}
  	if (cln_testonly) {
  		printf("would have ");
  	}
  	printf("removed %d files (%ld bytes).\n", cln_filecnt, cln_sizecnt);	
  }
   
  static void
  unlinkf(char *name)
  {
  	struct stat stbuf;
  	double agemod, agestat;
  	int res;
  	char linkbuf[BUFSIZ];
  
  	/*
  	 * We have to use lstat() instead of stat(), in case this is a df*
  	 * "file" which is really a symlink due to 'lpr -s' processing.  In
  	 * that case, we need to check the last-mod time of the symlink, and
  	 * not the file that the symlink is pointed at.
  	 */
  	seteuid(euid);
  	res = lstat(name, &stbuf);
  	seteuid(uid);
  	if (res < 0) {
  		printf("\terror return from stat(%s):\n", name);
  		printf("\t      %s\n", strerror(errno));
  		return;
  	}
  
  	agemod = difftime(cln_now, stbuf.st_mtime);
  	agestat = difftime(cln_now,  stbuf.st_ctime);
  	if (cln_debug > 1) {
  		/* this debugging-aid probably is not needed any more... */
  		printf("\t\t  modify age=%g secs, stat age=%g secs\n",
  		    agemod, agestat);
  	}
  	if ((agemod <= cln_minage) && (agestat <= cln_minage))
  		return;
  
  	/*
  	 * if this file is a symlink, then find out the target of the
  	 * symlink before unlink-ing the file itself
  	 */
  	if (S_ISLNK(stbuf.st_mode)) {
  		seteuid(euid);
  		res = readlink(name, linkbuf, sizeof(linkbuf));
  		seteuid(uid);
  		if (res < 0) {
  			printf("\terror return from readlink(%s):\n", name);
  			printf("\t      %s\n", strerror(errno));
  			return;
  		}
  		if (res == sizeof(linkbuf))
  			res--;
  		linkbuf[res] = '\0';
  	}
  
  	cln_filecnt++;
  	cln_sizecnt += stbuf.st_size;
  
  	if (cln_testonly) {
  		printf("\twould remove %s\n", name);
  		if (S_ISLNK(stbuf.st_mode)) {
  			printf("\t    (which is a symlink to %s)\n", linkbuf);
  		}
  	} else {
  		seteuid(euid);
  		res = unlink(name);
  		seteuid(uid);
  		if (res < 0)
  			printf("\tcannot remove %s (!)\n", name);
  		else
  			printf("\tremoved %s\n", name);
  		/* XXX
  		 *  Note that for a df* file, this code should also check to see
  		 *  if it is a symlink to some other file, and if the original
  		 *  lpr command included '-r' ("remove file").  Of course, this
  		 *  code would not be removing the df* file unless there was no
  		 *  matching cf* file, and without the cf* file it is currently
  		 *  impossible to determine if '-r' had been specified...
  		 *
  		 *  As a result of this quandry, we may be leaving behind a
  		 *  user's file that was supposed to have been removed after
  		 *  being printed.  This may effect services such as CAP or
  		 *  samba, if they were configured to use 'lpr -r', and if
  		 *  datafiles are not being properly removed.
  		*/
  		if (S_ISLNK(stbuf.st_mode)) {
  			printf("\t    (which was a symlink to %s)\n", linkbuf);
  		}
  	}
  }
  
  /*
   * Enable queuing to the printer (allow lpr to add new jobs to the queue).
   */
  void
  enable_q(struct printer *pp)
  {
  	int setres;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_ENABLEQ, lf);
  }
  
  /*
   * Disable queuing.
   */
  void
  disable_q(struct printer *pp)
  {
  	int setres;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_DISABLEQ, lf);
  }
  
  /*
   * Disable queuing and printing and put a message into the status file
   * (reason for being down).  If the user specified `-msg', then use
   * everything after that as the message for the status file.  If the
   * user did NOT specify `-msg', then the command should take the first
   * parameter as the printer name, and all remaining parameters as the
   * message for the status file.  (This is to be compatible with the
   * original definition of 'down', which was implemented long before
   * `-msg' was around).
   */
  void
  down_gi(int argc, char *argv[])
  {
  
  	/* If `-msg' was specified, then this routine has nothing to do. */
  	if (generic_msg != NULL)
  		return;
  
  	/*
  	 * If the user only gave one parameter, then use a default msg.
  	 * (if argc == 1 at this point, then *argv == name of printer).
  	 */ 
  	if (argc == 1) {
  		generic_msg = strdup("printing disabled\n");
  		return;
  	}
  
  	/*
  	 * The user specified multiple parameters, and did not specify
  	 * `-msg'.  Build a message from all the parameters after the
  	 * first one (and nullify those parameters so generic-processing
  	 * will not process them as printer-queue names).
  	 */
  	argc--;
  	argv++;
  	generic_msg = args2line(argc, argv);
  	for (; argc > 0; argc--, argv++)
  		*argv = generic_nullarg;	/* "erase" it */
  }
  
  void
  down_q(struct printer *pp)
  {
  	int setres;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_DISABLEQ+SQS_STOPP, lf);
  	if (setres >= 0)
  		upstat(pp, generic_msg, 1);
  }
  
  /*
   * Exit lpc
   */
  void
  quit(int argc __unused, char *argv[] __unused)
  {
  	exit(0);
  }
  
  /*
   * Kill and restart the daemon.
   */
  void
  restart_q(struct printer *pp)
  {
  	int killres, setres, startok;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	killres = kill_qtask(lf);
  
  	/*
  	 * XXX - if the kill worked, we should probably sleep for
  	 *      a second or so before trying to restart the queue.
  	 */
  
  	/* make sure the queue is set to print jobs */
  	setres = set_qstate(SQS_STARTP, lf);
  
  	seteuid(euid);
  	startok = startdaemon(pp);
  	seteuid(uid);
  	if (!startok)
  		printf("\tcouldn't restart daemon\n");
  	else
  		printf("\tdaemon restarted\n");
  }
  
  /*
   * Set the status message of each queue listed.  Requires a "-msg"
   * parameter to indicate the end of the queue list and start of msg text.
   */
  void
  setstatus_gi(int argc __unused, char *argv[] __unused)
  {
  
  	if (generic_msg == NULL) {
  		printf("You must specify '-msg' before the text of the new status message.\n");
  		generic_initerr = 1;
  	}
  }
  
  void
  setstatus_q(struct printer *pp)
  {
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	upstat(pp, generic_msg, 1);
  }
  
  /*
   * Enable printing on the specified printer and startup the daemon.
   */
  void
  start_q(struct printer *pp)
  {
  	int setres, startok;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_STARTP, lf);
  
  	seteuid(euid);
  	startok = startdaemon(pp);
  	seteuid(uid);
  	if (!startok)
  		printf("\tcouldn't start daemon\n");
  	else
  		printf("\tdaemon started\n");
  	seteuid(uid);
  }
  
  /*
   * Print the status of the printer queue.
   */
  void
  status(struct printer *pp)
  {
  	struct stat stbuf;
  	register int fd, i;
  	register struct dirent *dp;
  	DIR *dirp;
  	char file[MAXPATHLEN];
  
  	printf("%s:\n", pp->printer);
  	lock_file_name(pp, file, sizeof file);
  	if (stat(file, &stbuf) >= 0) {
  		printf("\tqueuing is %s\n",
  		       ((stbuf.st_mode & LFM_QUEUE_DIS) ? "disabled"
  			: "enabled"));
  		printf("\tprinting is %s\n",
  		       ((stbuf.st_mode & LFM_PRINT_DIS) ? "disabled"
  			: "enabled"));
  	} else {
  		printf("\tqueuing is enabled\n");
  		printf("\tprinting is enabled\n");
  	}
  	if ((dirp = opendir(pp->spool_dir)) == NULL) {
  		printf("\tcannot examine spool directory\n");
  		return;
  	}
  	i = 0;
  	while ((dp = readdir(dirp)) != NULL) {
  		if (*dp->d_name == 'c' && dp->d_name[1] == 'f')
  			i++;
  	}
  	closedir(dirp);
  	if (i == 0)
  		printf("\tno entries in spool area\n");
  	else if (i == 1)
  		printf("\t1 entry in spool area\n");
  	else
  		printf("\t%d entries in spool area\n", i);
  	fd = open(file, O_RDONLY);
  	if (fd < 0 || flock(fd, LOCK_SH|LOCK_NB) == 0) {
  		(void) close(fd);	/* unlocks as well */
  		printf("\tprinter idle\n");
  		return;
  	}
  	(void) close(fd);
  	/* print out the contents of the status file, if it exists */
  	status_file_name(pp, file, sizeof file);
  	fd = open(file, O_RDONLY|O_SHLOCK);
  	if (fd >= 0) {
  		(void) fstat(fd, &stbuf);
  		if (stbuf.st_size > 0) {
  			putchar('\t');
  			while ((i = read(fd, line, sizeof(line))) > 0)
  				(void) fwrite(line, 1, i, stdout);
  		}
  		(void) close(fd);	/* unlocks as well */
  	}
  }
  
  /*
   * Stop the specified daemon after completing the current job and disable
   * printing.
   */
  void
  stop_q(struct printer *pp)
  {
  	int setres;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_STOPP, lf);
  
  	if (setres >= 0)
  		upstat(pp, "printing disabled\n", 0);
  }
  
  struct	jobqueue **queue;
  int	nitems;
  time_t	mtime;
  
  /*
   * Put the specified jobs at the top of printer queue.
   */
  void
  topq(int argc, char *argv[])
  {
  	register int i;
  	struct stat stbuf;
  	int cmdstatus, changed;
  	struct printer myprinter, *pp = &myprinter;
  
  	if (argc < 3) {
  		printf("usage: topq printer [jobnum ...] [user ...]\n");
  		return;
  	}
  
  	--argc;
  	++argv;
  	init_printer(pp);
  	cmdstatus = getprintcap(*argv, pp);
  	switch(cmdstatus) {
  	default:
  		fatal(pp, "%s", pcaperr(cmdstatus));
  	case PCAPERR_NOTFOUND:
  		printf("unknown printer %s\n", *argv);
  		return;
  	case PCAPERR_TCOPEN:
  		printf("warning: %s: unresolved tc= reference(s)", *argv);
  		break;
  	case PCAPERR_SUCCESS:
  		break;
  	}
  	printf("%s:\n", pp->printer);
  
  	seteuid(euid);
  	if (chdir(pp->spool_dir) < 0) {
  		printf("\tcannot chdir to %s\n", pp->spool_dir);
  		goto out;
  	}
  	seteuid(uid);
  	nitems = getq(pp, &queue);
  	if (nitems == 0)
  		return;
  	changed = 0;
  	mtime = queue[0]->job_time;
  	for (i = argc; --i; ) {
  		if (doarg(argv[i]) == 0) {
  			printf("\tjob %s is not in the queue\n", argv[i]);
  			continue;
  		} else
  			changed++;
  	}
  	for (i = 0; i < nitems; i++)
  		free(queue[i]);
  	free(queue);
  	if (!changed) {
  		printf("\tqueue order unchanged\n");
  		return;
  	}
  	/*
  	 * Turn on the public execute bit of the lock file to
  	 * get lpd to rebuild the queue after the current job.
  	 */
  	seteuid(euid);
  	if (changed && stat(pp->lock_file, &stbuf) >= 0)
  		(void) chmod(pp->lock_file, stbuf.st_mode | LFM_RESET_QUE);
  
  out:
  	seteuid(uid);
  } 
  
  /*
   * Reposition the job by changing the modification time of
   * the control file.
   */
  static int
  touch(struct jobqueue *jq)
  {
  	struct timeval tvp[2];
  	int ret;
  
  	tvp[0].tv_sec = tvp[1].tv_sec = --mtime;
  	tvp[0].tv_usec = tvp[1].tv_usec = 0;
  	seteuid(euid);
  	ret = utimes(jq->job_cfname, tvp);
  	seteuid(uid);
  	return (ret);
  }
  
  /*
   * Checks if specified job name is in the printer's queue.
   * Returns:  negative (-1) if argument name is not in the queue.
   */
  static int
  doarg(char *job)
  {
  	register struct jobqueue **qq;
  	register int jobnum, n;
  	register char *cp, *machine;
  	int cnt = 0;
  	FILE *fp;
  
  	/*
  	 * Look for a job item consisting of system name, colon, number 
  	 * (example: ucbarpa:114)  
  	 */
  	if ((cp = strchr(job, ':')) != NULL) {
  		machine = job;
  		*cp++ = '\0';
  		job = cp;
  	} else
  		machine = NULL;
  
  	/*
  	 * Check for job specified by number (example: 112 or 235ucbarpa).
  	 */
  	if (isdigit(*job)) {
  		jobnum = 0;
  		do
  			jobnum = jobnum * 10 + (*job++ - '0');
  		while (isdigit(*job));
  		for (qq = queue + nitems; --qq >= queue; ) {
  			n = 0;
  			for (cp = (*qq)->job_cfname+3; isdigit(*cp); )
  				n = n * 10 + (*cp++ - '0');
  			if (jobnum != n)
  				continue;
  			if (*job && strcmp(job, cp) != 0)
  				continue;
  			if (machine != NULL && strcmp(machine, cp) != 0)
  				continue;
  			if (touch(*qq) == 0) {
  				printf("\tmoved %s\n", (*qq)->job_cfname);
  				cnt++;
  			}
  		}
  		return(cnt);
  	}
  	/*
  	 * Process item consisting of owner's name (example: henry).
  	 */
  	for (qq = queue + nitems; --qq >= queue; ) {
  		seteuid(euid);
  		fp = fopen((*qq)->job_cfname, "r");
  		seteuid(uid);
  		if (fp == NULL)
  			continue;
  		while (getline(fp) > 0)
  			if (line[0] == 'P')
  				break;
  		(void) fclose(fp);
  		if (line[0] != 'P' || strcmp(job, line+1) != 0)
  			continue;
  		if (touch(*qq) == 0) {
  			printf("\tmoved %s\n", (*qq)->job_cfname);
  			cnt++;
  		}
  	}
  	return(cnt);
  }
  
  /*
   * Enable both queuing & printing, and start printer (undo `down').
   */
  void
  up_q(struct printer *pp)
  {
  	int setres, startok;
  	char lf[MAXPATHLEN];
  
  	lock_file_name(pp, lf, sizeof lf);
  	printf("%s:\n", pp->printer);
  
  	setres = set_qstate(SQS_ENABLEQ+SQS_STARTP, lf);
  
  	seteuid(euid);
  	startok = startdaemon(pp);
  	seteuid(uid);
  	if (!startok)
  		printf("\tcouldn't start daemon\n");
  	else
  		printf("\tdaemon started\n");
  }
  