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