1108 lines
24 KiB
C
1108 lines
24 KiB
C
/*
|
|
* 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 char copyright[] =
|
|
"@(#) Copyright (c) 1983, 1993\n\
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)cmds.c 8.1 (Berkeley) 6/6/93";
|
|
#endif /* not lint */
|
|
|
|
/*
|
|
* lpc -- line printer control program -- commands:
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/time.h>
|
|
#include <sys/stat.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"
|
|
|
|
static void abortpr __P((int));
|
|
static void cleanpr __P((void));
|
|
static void disablepr __P((void));
|
|
static int doarg __P((char *));
|
|
static int doselect __P((struct dirent *));
|
|
static void enablepr __P((void));
|
|
static void prstat __P((void));
|
|
static void putmsg __P((int, char **));
|
|
static int sortq __P((const void *, const void *));
|
|
static void startpr __P((int));
|
|
static void stoppr __P((void));
|
|
static int touch __P((struct queue *));
|
|
static void unlinkf __P((char *));
|
|
static void upstat __P((char *));
|
|
|
|
/*
|
|
* kill an existing daemon and disable printing.
|
|
*/
|
|
void
|
|
doabort(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: abort {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
abortpr(1);
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
abortpr(1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
abortpr(dis)
|
|
int dis;
|
|
{
|
|
register FILE *fp;
|
|
struct stat stbuf;
|
|
int pid, fd;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
printf("%s:\n", printer);
|
|
|
|
/*
|
|
* Turn on the owner execute bit of the lock file to disable printing.
|
|
*/
|
|
if (dis) {
|
|
if (stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, (stbuf.st_mode & 0777) | 0100) < 0)
|
|
printf("\tcannot disable printing\n");
|
|
else {
|
|
upstat("printing disabled\n");
|
|
printf("\tprinting disabled\n");
|
|
}
|
|
} else if (errno == ENOENT) {
|
|
if ((fd = open(line, O_WRONLY|O_CREAT, 0760)) < 0)
|
|
printf("\tcannot create lock file\n");
|
|
else {
|
|
(void) close(fd);
|
|
upstat("printing disabled\n");
|
|
printf("\tprinting disabled\n");
|
|
printf("\tno daemon to abort\n");
|
|
}
|
|
return;
|
|
} else {
|
|
printf("\tcannot stat lock file\n");
|
|
return;
|
|
}
|
|
}
|
|
/*
|
|
* Kill the current daemon to stop printing now.
|
|
*/
|
|
if ((fp = fopen(line, "r")) == NULL) {
|
|
printf("\tcannot open lock file\n");
|
|
return;
|
|
}
|
|
if (!getline(fp) || flock(fileno(fp), LOCK_SH|LOCK_NB) == 0) {
|
|
(void) fclose(fp); /* unlocks as well */
|
|
printf("\tno daemon to abort\n");
|
|
return;
|
|
}
|
|
(void) fclose(fp);
|
|
if (kill(pid = atoi(line), SIGTERM) < 0)
|
|
printf("\tWarning: daemon (pid %d) not killed\n", pid);
|
|
else
|
|
printf("\tdaemon (pid %d) killed\n", pid);
|
|
}
|
|
|
|
/*
|
|
* Write a message into the status file.
|
|
*/
|
|
static void
|
|
upstat(msg)
|
|
char *msg;
|
|
{
|
|
register int fd;
|
|
char statfile[BUFSIZ];
|
|
|
|
if (cgetstr(bp, "st", &ST) == -1)
|
|
ST = DEFSTAT;
|
|
(void) sprintf(statfile, "%s/%s", SD, ST);
|
|
umask(0);
|
|
fd = open(statfile, O_WRONLY|O_CREAT, 0664);
|
|
if (fd < 0 || flock(fd, LOCK_EX) < 0) {
|
|
printf("\tcannot create status file\n");
|
|
return;
|
|
}
|
|
(void) ftruncate(fd, 0);
|
|
if (msg == (char *)NULL)
|
|
(void) write(fd, "\n", 1);
|
|
else
|
|
(void) write(fd, msg, strlen(msg));
|
|
(void) close(fd);
|
|
}
|
|
|
|
/*
|
|
* Remove all spool files and temporaries from the spooling area.
|
|
*/
|
|
void
|
|
clean(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: clean {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
cleanpr();
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
cleanpr();
|
|
}
|
|
}
|
|
|
|
static int
|
|
doselect(d)
|
|
struct dirent *d;
|
|
{
|
|
int c = d->d_name[0];
|
|
|
|
if ((c == 't' || c == 'c' || c == 'd') && d->d_name[1] == 'f')
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* Comparison routine for scandir. Sort by job number and machine, then
|
|
* by `cf', `tf', or `df', then by the sequence letter A-Z, a-z.
|
|
*/
|
|
static int
|
|
sortq(a, b)
|
|
const void *a, *b;
|
|
{
|
|
struct dirent **d1, **d2;
|
|
int c1, c2;
|
|
|
|
d1 = (struct dirent **)a;
|
|
d2 = (struct dirent **)b;
|
|
if (c1 = strcmp((*d1)->d_name + 3, (*d2)->d_name + 3))
|
|
return(c1);
|
|
c1 = (*d1)->d_name[0];
|
|
c2 = (*d2)->d_name[0];
|
|
if (c1 == c2)
|
|
return((*d1)->d_name[2] - (*d2)->d_name[2]);
|
|
if (c1 == 'c')
|
|
return(-1);
|
|
if (c1 == 'd' || c2 == 'c')
|
|
return(1);
|
|
return(-1);
|
|
}
|
|
|
|
/*
|
|
* Remove incomplete jobs from spooling area.
|
|
*/
|
|
static void
|
|
cleanpr()
|
|
{
|
|
register int i, n;
|
|
register char *cp, *cp1, *lp;
|
|
struct dirent **queue;
|
|
int nitems;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
printf("%s:\n", printer);
|
|
|
|
for (lp = line, cp = SD; *lp++ = *cp++; )
|
|
;
|
|
lp[-1] = '/';
|
|
|
|
nitems = scandir(SD, &queue, doselect, sortq);
|
|
if (nitems < 0) {
|
|
printf("\tcannot examine spool directory\n");
|
|
return;
|
|
}
|
|
if (nitems == 0)
|
|
return;
|
|
i = 0;
|
|
do {
|
|
cp = queue[i]->d_name;
|
|
if (*cp == 'c') {
|
|
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) {
|
|
strcpy(lp, cp);
|
|
unlinkf(line);
|
|
}
|
|
} else {
|
|
/*
|
|
* Must be a df with no cf (otherwise, it would have
|
|
* been skipped above) or a tf file (which can always
|
|
* be removed).
|
|
*/
|
|
strcpy(lp, cp);
|
|
unlinkf(line);
|
|
}
|
|
} while (++i < nitems);
|
|
}
|
|
|
|
static void
|
|
unlinkf(name)
|
|
char *name;
|
|
{
|
|
if (unlink(name) < 0)
|
|
printf("\tcannot remove %s\n", name);
|
|
else
|
|
printf("\tremoved %s\n", name);
|
|
}
|
|
|
|
/*
|
|
* Enable queuing to the printer (allow lpr's).
|
|
*/
|
|
void
|
|
enable(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: enable {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
enablepr();
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
enablepr();
|
|
}
|
|
}
|
|
|
|
static void
|
|
enablepr()
|
|
{
|
|
struct stat stbuf;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
printf("%s:\n", printer);
|
|
|
|
/*
|
|
* Turn off the group execute bit of the lock file to enable queuing.
|
|
*/
|
|
if (stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, stbuf.st_mode & 0767) < 0)
|
|
printf("\tcannot enable queuing\n");
|
|
else
|
|
printf("\tqueuing enabled\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Disable queuing.
|
|
*/
|
|
void
|
|
disable(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: disable {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
disablepr();
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
disablepr();
|
|
}
|
|
}
|
|
|
|
static void
|
|
disablepr()
|
|
{
|
|
register int fd;
|
|
struct stat stbuf;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
printf("%s:\n", printer);
|
|
/*
|
|
* Turn on the group execute bit of the lock file to disable queuing.
|
|
*/
|
|
if (stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, (stbuf.st_mode & 0777) | 010) < 0)
|
|
printf("\tcannot disable queuing\n");
|
|
else
|
|
printf("\tqueuing disabled\n");
|
|
} else if (errno == ENOENT) {
|
|
if ((fd = open(line, O_WRONLY|O_CREAT, 0670)) < 0)
|
|
printf("\tcannot create lock file\n");
|
|
else {
|
|
(void) close(fd);
|
|
printf("\tqueuing disabled\n");
|
|
}
|
|
return;
|
|
} else
|
|
printf("\tcannot stat lock file\n");
|
|
}
|
|
|
|
/*
|
|
* Disable queuing and printing and put a message into the status file
|
|
* (reason for being down).
|
|
*/
|
|
void
|
|
down(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: down {all | printer} [message ...]\n");
|
|
return;
|
|
}
|
|
if (!strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
putmsg(argc - 2, argv + 2);
|
|
}
|
|
return;
|
|
}
|
|
printer = argv[1];
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
return;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
return;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
putmsg(argc - 2, argv + 2);
|
|
}
|
|
|
|
static void
|
|
putmsg(argc, argv)
|
|
int argc;
|
|
char **argv;
|
|
{
|
|
register int fd;
|
|
register char *cp1, *cp2;
|
|
char buf[1024];
|
|
struct stat stbuf;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
if (cgetstr(bp, "st", &ST) == -1)
|
|
ST = DEFSTAT;
|
|
printf("%s:\n", printer);
|
|
/*
|
|
* Turn on the group execute bit of the lock file to disable queuing and
|
|
* turn on the owner execute bit of the lock file to disable printing.
|
|
*/
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
if (stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, (stbuf.st_mode & 0777) | 0110) < 0)
|
|
printf("\tcannot disable queuing\n");
|
|
else
|
|
printf("\tprinter and queuing disabled\n");
|
|
} else if (errno == ENOENT) {
|
|
if ((fd = open(line, O_WRONLY|O_CREAT, 0770)) < 0)
|
|
printf("\tcannot create lock file\n");
|
|
else {
|
|
(void) close(fd);
|
|
printf("\tprinter and queuing disabled\n");
|
|
}
|
|
return;
|
|
} else
|
|
printf("\tcannot stat lock file\n");
|
|
/*
|
|
* Write the message into the status file.
|
|
*/
|
|
(void) sprintf(line, "%s/%s", SD, ST);
|
|
fd = open(line, O_WRONLY|O_CREAT, 0664);
|
|
if (fd < 0 || flock(fd, LOCK_EX) < 0) {
|
|
printf("\tcannot create status file\n");
|
|
return;
|
|
}
|
|
(void) ftruncate(fd, 0);
|
|
if (argc <= 0) {
|
|
(void) write(fd, "\n", 1);
|
|
(void) close(fd);
|
|
return;
|
|
}
|
|
cp1 = buf;
|
|
while (--argc >= 0) {
|
|
cp2 = *argv++;
|
|
while (*cp1++ = *cp2++)
|
|
;
|
|
cp1[-1] = ' ';
|
|
}
|
|
cp1[-1] = '\n';
|
|
*cp1 = '\0';
|
|
(void) write(fd, buf, strlen(buf));
|
|
(void) close(fd);
|
|
}
|
|
|
|
/*
|
|
* Exit lpc
|
|
*/
|
|
void
|
|
quit(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
exit(0);
|
|
}
|
|
|
|
/*
|
|
* Kill and restart the daemon.
|
|
*/
|
|
void
|
|
restart(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: restart {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
abortpr(0);
|
|
startpr(0);
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
abortpr(0);
|
|
startpr(0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Enable printing on the specified printer and startup the daemon.
|
|
*/
|
|
void
|
|
startcmd(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: start {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
startpr(1);
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
startpr(1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
startpr(enable)
|
|
int enable;
|
|
{
|
|
struct stat stbuf;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
printf("%s:\n", printer);
|
|
|
|
/*
|
|
* Turn off the owner execute bit of the lock file to enable printing.
|
|
*/
|
|
if (enable && stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, stbuf.st_mode & (enable==2 ? 0666 : 0677)) < 0)
|
|
printf("\tcannot enable printing\n");
|
|
else
|
|
printf("\tprinting enabled\n");
|
|
}
|
|
if (!startdaemon(printer))
|
|
printf("\tcouldn't start daemon\n");
|
|
else
|
|
printf("\tdaemon started\n");
|
|
}
|
|
|
|
/*
|
|
* Print the status of each queue listed or all the queues.
|
|
*/
|
|
void
|
|
status(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
prstat();
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
prstat();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Print the status of the printer queue.
|
|
*/
|
|
static void
|
|
prstat()
|
|
{
|
|
struct stat stbuf;
|
|
register int fd, i;
|
|
register struct dirent *dp;
|
|
DIR *dirp;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
if (cgetstr(bp, "st", &ST) == -1)
|
|
ST = DEFSTAT;
|
|
printf("%s:\n", printer);
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
if (stat(line, &stbuf) >= 0) {
|
|
printf("\tqueuing is %s\n",
|
|
(stbuf.st_mode & 010) ? "disabled" : "enabled");
|
|
printf("\tprinting is %s\n",
|
|
(stbuf.st_mode & 0100) ? "disabled" : "enabled");
|
|
} else {
|
|
printf("\tqueuing is enabled\n");
|
|
printf("\tprinting is enabled\n");
|
|
}
|
|
if ((dirp = opendir(SD)) == 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\n");
|
|
else if (i == 1)
|
|
printf("\t1 entry in spool area\n");
|
|
else
|
|
printf("\t%d entries in spool area\n", i);
|
|
fd = open(line, O_RDONLY);
|
|
if (fd < 0 || flock(fd, LOCK_SH|LOCK_NB) == 0) {
|
|
(void) close(fd); /* unlocks as well */
|
|
printf("\tno daemon present\n");
|
|
return;
|
|
}
|
|
(void) close(fd);
|
|
putchar('\t');
|
|
(void) sprintf(line, "%s/%s", SD, ST);
|
|
fd = open(line, O_RDONLY);
|
|
if (fd >= 0) {
|
|
(void) flock(fd, LOCK_SH);
|
|
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(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: stop {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
stoppr();
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
stoppr();
|
|
}
|
|
}
|
|
|
|
static void
|
|
stoppr()
|
|
{
|
|
register int fd;
|
|
struct stat stbuf;
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
(void) sprintf(line, "%s/%s", SD, LO);
|
|
printf("%s:\n", printer);
|
|
|
|
/*
|
|
* Turn on the owner execute bit of the lock file to disable printing.
|
|
*/
|
|
if (stat(line, &stbuf) >= 0) {
|
|
if (chmod(line, (stbuf.st_mode & 0777) | 0100) < 0)
|
|
printf("\tcannot disable printing\n");
|
|
else {
|
|
upstat("printing disabled\n");
|
|
printf("\tprinting disabled\n");
|
|
}
|
|
} else if (errno == ENOENT) {
|
|
if ((fd = open(line, O_WRONLY|O_CREAT, 0760)) < 0)
|
|
printf("\tcannot create lock file\n");
|
|
else {
|
|
(void) close(fd);
|
|
upstat("printing disabled\n");
|
|
printf("\tprinting disabled\n");
|
|
}
|
|
} else
|
|
printf("\tcannot stat lock file\n");
|
|
}
|
|
|
|
struct queue **queue;
|
|
int nitems;
|
|
time_t mtime;
|
|
|
|
/*
|
|
* Put the specified jobs at the top of printer queue.
|
|
*/
|
|
void
|
|
topq(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int i;
|
|
struct stat stbuf;
|
|
int status, changed;
|
|
|
|
if (argc < 3) {
|
|
printf("Usage: topq printer [jobnum ...] [user ...]\n");
|
|
return;
|
|
}
|
|
|
|
--argc;
|
|
printer = *++argv;
|
|
status = cgetent(&bp, printcapdb, printer);
|
|
if (status == -2) {
|
|
printf("cannot open printer description file\n");
|
|
return;
|
|
} else if (status == -1) {
|
|
printf("%s: unknown printer\n", printer);
|
|
return;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
if (cgetstr(bp, "sd", &SD) == -1)
|
|
SD = _PATH_DEFSPOOL;
|
|
if (cgetstr(bp, "lo", &LO) == -1)
|
|
LO = DEFLOCK;
|
|
printf("%s:\n", printer);
|
|
|
|
if (chdir(SD) < 0) {
|
|
printf("\tcannot chdir to %s\n", SD);
|
|
return;
|
|
}
|
|
nitems = getq(&queue);
|
|
if (nitems == 0)
|
|
return;
|
|
changed = 0;
|
|
mtime = queue[0]->q_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.
|
|
*/
|
|
if (changed && stat(LO, &stbuf) >= 0)
|
|
(void) chmod(LO, (stbuf.st_mode & 0777) | 01);
|
|
}
|
|
|
|
/*
|
|
* Reposition the job by changing the modification time of
|
|
* the control file.
|
|
*/
|
|
static int
|
|
touch(q)
|
|
struct queue *q;
|
|
{
|
|
struct timeval tvp[2];
|
|
|
|
tvp[0].tv_sec = tvp[1].tv_sec = --mtime;
|
|
tvp[0].tv_usec = tvp[1].tv_usec = 0;
|
|
return(utimes(q->q_name, tvp));
|
|
}
|
|
|
|
/*
|
|
* 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(job)
|
|
char *job;
|
|
{
|
|
register struct queue **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 = index(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)->q_name+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)->q_name);
|
|
cnt++;
|
|
}
|
|
}
|
|
return(cnt);
|
|
}
|
|
/*
|
|
* Process item consisting of owner's name (example: henry).
|
|
*/
|
|
for (qq = queue + nitems; --qq >= queue; ) {
|
|
if ((fp = fopen((*qq)->q_name, "r")) == 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)->q_name);
|
|
cnt++;
|
|
}
|
|
}
|
|
return(cnt);
|
|
}
|
|
|
|
/*
|
|
* Enable everything and start printer (undo `down').
|
|
*/
|
|
void
|
|
up(argc, argv)
|
|
int argc;
|
|
char *argv[];
|
|
{
|
|
register int c, status;
|
|
register char *cp1, *cp2;
|
|
char prbuf[100];
|
|
|
|
if (argc == 1) {
|
|
printf("Usage: up {all | printer ...}\n");
|
|
return;
|
|
}
|
|
if (argc == 2 && !strcmp(argv[1], "all")) {
|
|
printer = prbuf;
|
|
while (cgetnext(&bp, printcapdb) > 0) {
|
|
cp1 = prbuf;
|
|
cp2 = bp;
|
|
while ((c = *cp2++) && c != '|' && c != ':')
|
|
*cp1++ = c;
|
|
*cp1 = '\0';
|
|
startpr(2);
|
|
}
|
|
return;
|
|
}
|
|
while (--argc) {
|
|
printer = *++argv;
|
|
if ((status = cgetent(&bp, printcapdb, printer)) == -2) {
|
|
printf("cannot open printer description file\n");
|
|
continue;
|
|
} else if (status == -1) {
|
|
printf("unknown printer %s\n", printer);
|
|
continue;
|
|
} else if (status == -3)
|
|
fatal("potential reference loop detected in printcap file");
|
|
|
|
startpr(2);
|
|
}
|
|
}
|