1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)displayq.c 8.4 (Berkeley) 4/28/95 30 * $FreeBSD: src/usr.sbin/lpr/common_source/displayq.c,v 1.15.2.8 2001/08/30 09:27:41 kris Exp $ 31 * $DragonFly: src/usr.sbin/lpr/common_source/displayq.c,v 1.5 2005/08/08 18:58:56 joerg Exp $ 32 */ 33 34 #include <sys/param.h> 35 #include <sys/stat.h> 36 37 #include <ctype.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <limits.h> 41 #include <signal.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #define psignal foil_gcc_psignal 46 #define sys_siglist foil_gcc_siglist 47 #include <unistd.h> 48 #undef psignal 49 #undef sys_siglist 50 51 #include "lp.h" 52 #include "lp.local.h" 53 #include "pathnames.h" 54 55 /* 56 * Routines to display the state of the queue. 57 */ 58 #define JOBCOL 40 /* column for job # in -l format */ 59 #define OWNCOL 7 /* start of Owner column in normal */ 60 #define SIZCOL 62 /* start of Size column in normal */ 61 62 /* 63 * Stuff for handling job specifications 64 */ 65 extern uid_t uid, euid; 66 67 static int col; /* column on screen */ 68 static char current[NAME_MAX+1]; /* current file being printed */ 69 static char file[NAME_MAX+1]; /* print file name */ 70 static int first; /* first file in ``files'' column? */ 71 static int garbage; /* # of garbage cf files */ 72 static int lflag; /* long output option */ 73 static int rank; /* order to be printed (-1=none, 0=active) */ 74 static long totsize; /* total print job size in bytes */ 75 76 static const char *head0 = "Rank Owner Job Files"; 77 static const char *head1 = "Total Size\n"; 78 79 static void alarmhandler(int _signo); 80 static void warn(const struct printer *_pp); 81 82 /* 83 * Display the current state of the queue. Format = 1 if long format. 84 */ 85 void 86 displayq(struct printer *pp, int format) 87 { 88 struct jobqueue *q; 89 int i, nitems, fd, ret; 90 char *cp, *endp; 91 struct jobqueue **queue; 92 struct stat statb; 93 FILE *fp; 94 void (*savealrm)(int); 95 96 lflag = format; 97 totsize = 0; 98 rank = -1; 99 100 if ((cp = checkremote(pp))) { 101 printf("Warning: %s\n", cp); 102 free(cp); 103 } 104 105 /* 106 * Print out local queue 107 * Find all the control files in the spooling directory 108 */ 109 seteuid(euid); 110 if (chdir(pp->spool_dir) < 0) 111 fatal(pp, "cannot chdir to spooling directory: %s", 112 strerror(errno)); 113 seteuid(uid); 114 if ((nitems = getq(pp, &queue)) < 0) 115 fatal(pp, "cannot examine spooling area\n"); 116 seteuid(euid); 117 ret = stat(pp->lock_file, &statb); 118 seteuid(uid); 119 if (ret >= 0) { 120 if (statb.st_mode & LFM_PRINT_DIS) { 121 if (pp->remote) 122 printf("%s: ", local_host); 123 printf("Warning: %s is down: ", pp->printer); 124 seteuid(euid); 125 fd = open(pp->status_file, O_RDONLY|O_SHLOCK); 126 seteuid(uid); 127 if (fd >= 0) { 128 while ((i = read(fd, line, sizeof(line))) > 0) 129 fwrite(line, 1, i, stdout); 130 close(fd); /* unlocks as well */ 131 } else 132 putchar('\n'); 133 } 134 if (statb.st_mode & LFM_QUEUE_DIS) { 135 if (pp->remote) 136 printf("%s: ", local_host); 137 printf("Warning: %s queue is turned off\n", 138 pp->printer); 139 } 140 } 141 142 if (nitems) { 143 seteuid(euid); 144 fp = fopen(pp->lock_file, "r"); 145 seteuid(uid); 146 if (fp == NULL) 147 warn(pp); 148 else { 149 /* get daemon pid */ 150 cp = current; 151 endp = cp + sizeof(current) - 1; 152 while ((i = getc(fp)) != EOF && i != '\n') { 153 if (cp < endp) 154 *cp++ = i; 155 } 156 *cp = '\0'; 157 i = atoi(current); 158 if (i <= 0) { 159 ret = -1; 160 } else { 161 seteuid(euid); 162 ret = kill(i, 0); 163 seteuid(uid); 164 } 165 if (ret < 0) { 166 warn(pp); 167 } else { 168 /* read current file name */ 169 cp = current; 170 endp = cp + sizeof(current) - 1; 171 while ((i = getc(fp)) != EOF && i != '\n') { 172 if (cp < endp) 173 *cp++ = i; 174 } 175 *cp = '\0'; 176 /* 177 * Print the status file. 178 */ 179 if (pp->remote) 180 printf("%s: ", local_host); 181 seteuid(euid); 182 fd = open(pp->status_file, O_RDONLY|O_SHLOCK); 183 seteuid(uid); 184 if (fd >= 0) { 185 while ((i = read(fd, line, 186 sizeof(line))) > 0) 187 fwrite(line, 1, i, stdout); 188 close(fd); /* unlocks as well */ 189 } else 190 putchar('\n'); 191 } 192 fclose(fp); 193 } 194 /* 195 * Now, examine the control files and print out the jobs to 196 * be done for each user. 197 */ 198 if (!lflag) 199 header(); 200 for (i = 0; i < nitems; i++) { 201 q = queue[i]; 202 inform(pp, q->job_cfname); 203 free(q); 204 } 205 free(queue); 206 } 207 if (!pp->remote) { 208 if (nitems == 0) 209 puts("no entries"); 210 return; 211 } 212 213 /* 214 * Print foreign queue 215 * Note that a file in transit may show up in either queue. 216 */ 217 if (nitems) 218 putchar('\n'); 219 snprintf(line, sizeof(line), "%c%s", format ? '\4' : '\3', 220 pp->remote_queue); 221 cp = line; 222 for (i = 0; i < requests && cp-line+10 < sizeof(line) - 1; i++) { 223 cp += strlen(cp); 224 sprintf(cp, " %d", requ[i]); 225 } 226 for (i = 0; i < users && cp - line + 1 + strlen(user[i]) < 227 sizeof(line) - 1; i++) { 228 cp += strlen(cp); 229 *cp++ = ' '; 230 strcpy(cp, user[i]); 231 } 232 strcat(line, "\n"); 233 savealrm = signal(SIGALRM, alarmhandler); 234 alarm(pp->conn_timeout); 235 fd = getport(pp, pp->remote_host, 0); 236 alarm(0); 237 signal(SIGALRM, savealrm); 238 if (fd < 0) { 239 if (from_host != local_host) 240 printf("%s: ", local_host); 241 printf("connection to %s is down\n", pp->remote_host); 242 } 243 else { 244 i = strlen(line); 245 if (write(fd, line, i) != i) 246 fatal(pp, "Lost connection"); 247 while ((i = read(fd, line, sizeof(line))) > 0) 248 fwrite(line, 1, i, stdout); 249 close(fd); 250 } 251 } 252 253 /* 254 * Print a warning message if there is no daemon present. 255 */ 256 static void 257 warn(const struct printer *pp) 258 { 259 if (pp->remote) 260 printf("%s: ", local_host); 261 puts("Warning: no daemon present"); 262 current[0] = '\0'; 263 } 264 265 /* 266 * Print the header for the short listing format 267 */ 268 void 269 header(void) 270 { 271 printf("%s", head0); 272 col = strlen(head0)+1; 273 blankfill(SIZCOL); 274 printf("%s", head1); 275 } 276 277 void 278 inform(const struct printer *pp, char *cf) 279 { 280 int copycnt; 281 char savedname[MAXPATHLEN+1]; 282 FILE *cfp; 283 284 /* 285 * There's a chance the control file has gone away 286 * in the meantime; if this is the case just keep going 287 */ 288 seteuid(euid); 289 if ((cfp = fopen(cf, "r")) == NULL) 290 return; 291 seteuid(uid); 292 293 if (rank < 0) 294 rank = 0; 295 if (pp->remote || garbage || strcmp(cf, current)) 296 rank++; 297 298 /* 299 * The cf-file may include commands to print more than one datafile 300 * from the user. For each datafile, the cf-file contains at least 301 * one line which starts with some format-specifier ('a'-'z'), and 302 * a second line ('N'ame) which indicates the original name the user 303 * specified for that file. There can be multiple format-spec lines 304 * for a single Name-line, if the user requested multiple copies of 305 * that file. Standard lpr puts the format-spec line(s) before the 306 * Name-line, while lprNG puts the Name-line before the format-spec 307 * line(s). This section needs to handle the lines in either order. 308 */ 309 copycnt = 0; 310 file[0] = '\0'; 311 savedname[0] = '\0'; 312 while (get_line(cfp)) { 313 switch (line[0]) { 314 case 'P': /* Was this file specified in the user's list? */ 315 if (!inlist(line+1, cf)) { 316 fclose(cfp); 317 return; 318 } 319 if (lflag) { 320 printf("\n%s: ", line+1); 321 col = strlen(line+1) + 2; 322 prank(rank); 323 blankfill(JOBCOL); 324 printf(" [job %s]\n", cf+3); 325 } else { 326 col = 0; 327 prank(rank); 328 blankfill(OWNCOL); 329 printf("%-10s %-3d ", line+1, atoi(cf+3)); 330 col += 16; 331 first = 1; 332 } 333 continue; 334 default: /* some format specifer and file name? */ 335 if (line[0] < 'a' || line[0] > 'z') 336 break; 337 if (copycnt == 0 || strcmp(file, line+1) != 0) { 338 strlcpy(file, line + 1, sizeof(file)); 339 } 340 copycnt++; 341 /* 342 * deliberately 'continue' to another get_line(), so 343 * all format-spec lines for this datafile are read 344 * in and counted before calling show() 345 */ 346 continue; 347 case 'N': 348 strlcpy(savedname, line + 1, sizeof(savedname)); 349 break; 350 } 351 if ((file[0] != '\0') && (savedname[0] != '\0')) { 352 show(savedname, file, copycnt); 353 copycnt = 0; 354 file[0] = '\0'; 355 savedname[0] = '\0'; 356 } 357 } 358 fclose(cfp); 359 /* check for a file which hasn't been shown yet */ 360 if (file[0] != '\0') { 361 if (savedname[0] == '\0') { 362 /* a safeguard in case the N-ame line is missing */ 363 strlcpy(savedname, file, sizeof(savedname)); 364 } 365 show(savedname, file, copycnt); 366 } 367 if (!lflag) { 368 blankfill(SIZCOL); 369 printf("%ld bytes\n", totsize); 370 totsize = 0; 371 } 372 } 373 374 int 375 inlist(char *uname, char *cfile) 376 { 377 int *r, n; 378 char **u, *cp; 379 380 if (users == 0 && requests == 0) 381 return(1); 382 /* 383 * Check to see if it's in the user list 384 */ 385 for (u = user; u < &user[users]; u++) 386 if (!strcmp(*u, uname)) 387 return(1); 388 /* 389 * Check the request list 390 */ 391 for (n = 0, cp = cfile+3; isdigit(*cp); ) 392 n = n * 10 + (*cp++ - '0'); 393 for (r = requ; r < &requ[requests]; r++) 394 if (*r == n && !strcmp(cp, from_host)) 395 return(1); 396 return(0); 397 } 398 399 void 400 show(const char *nfile, const char *datafile, int copies) 401 { 402 if (strcmp(nfile, " ") == 0) 403 nfile = "(standard input)"; 404 if (lflag) 405 ldump(nfile, datafile, copies); 406 else 407 dump(nfile, datafile, copies); 408 } 409 410 /* 411 * Fill the line with blanks to the specified column 412 */ 413 void 414 blankfill(int tocol) 415 { 416 while (col++ < tocol) 417 putchar(' '); 418 } 419 420 /* 421 * Give the abbreviated dump of the file names 422 */ 423 void 424 dump(const char *nfile, const char *datafile, int copies) 425 { 426 struct stat lbuf; 427 const char etctmpl[] = ", ..."; 428 char etc[sizeof(etctmpl)]; 429 char *lastsep; 430 short fill, nlen; 431 short rem, remetc; 432 433 /* 434 * Print as many filenames as will fit 435 * (leaving room for the 'total size' field) 436 */ 437 fill = first ? 0 : 2; /* fill space for ``, '' */ 438 nlen = strlen(nfile); 439 rem = SIZCOL - 1 - col; 440 if (nlen + fill > rem) { 441 if (first) { 442 /* print the right-most part of the name */ 443 printf("...%s ", &nfile[3+nlen-rem]); 444 col = SIZCOL; 445 } else if (rem > 0) { 446 /* fit as much of the etc-string as we can */ 447 remetc = rem; 448 if (rem > strlen(etctmpl)) 449 remetc = strlen(etctmpl); 450 etc[0] = '\0'; 451 strncat(etc, etctmpl, remetc); 452 printf("%s", etc); 453 col += remetc; 454 rem -= remetc; 455 /* room for the last segment of this filename? */ 456 lastsep = strrchr(nfile, '/'); 457 if ((lastsep != NULL) && (rem > strlen(lastsep))) { 458 /* print the right-most part of this name */ 459 printf("%s", lastsep); 460 col += strlen(lastsep); 461 } else { 462 /* do not pack any more names in here */ 463 blankfill(SIZCOL); 464 } 465 } 466 } else { 467 if (!first) 468 printf(", "); 469 printf("%s", nfile); 470 col += nlen + fill; 471 } 472 first = 0; 473 474 seteuid(euid); 475 if (*datafile && !stat(datafile, &lbuf)) 476 totsize += copies * lbuf.st_size; 477 seteuid(uid); 478 } 479 480 /* 481 * Print the long info about the file 482 */ 483 void 484 ldump(const char *nfile, const char *datafile, int copies) 485 { 486 struct stat lbuf; 487 488 putchar('\t'); 489 if (copies > 1) 490 printf("%-2d copies of %-19s", copies, nfile); 491 else 492 printf("%-32s", nfile); 493 if (*datafile && !stat(datafile, &lbuf)) 494 printf(" %qd bytes", (long long) lbuf.st_size); 495 else 496 printf(" ??? bytes"); 497 putchar('\n'); 498 } 499 500 /* 501 * Print the job's rank in the queue, 502 * update col for screen management 503 */ 504 void 505 prank(int n) 506 { 507 char rline[100]; 508 static const char *r[] = { 509 "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th" 510 }; 511 512 if (n == 0) { 513 printf("active"); 514 col += 6; 515 return; 516 } 517 if ((n/10)%10 == 1) 518 snprintf(rline, sizeof(rline), "%dth", n); 519 else 520 snprintf(rline, sizeof(rline), "%d%s", n, r[n%10]); 521 col += strlen(rline); 522 printf("%s", rline); 523 } 524 525 void 526 alarmhandler(int signo __unused) 527 { 528 /* the signal is ignored */ 529 /* (the '__unused' is just to avoid a compile-time warning) */ 530 } 531