1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * (c) UNIX System Laboratories, Inc. 7 * All or some portions of this file are derived from material licensed 8 * to the University of California by American Telephone and Telegraph 9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 10 * the permission of UNIX System Laboratories, Inc. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * This product includes software developed by the University of 23 * California, Berkeley and its contributors. 24 * 4. Neither the name of the University nor the names of its contributors 25 * may be used to endorse or promote products derived from this software 26 * without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 */ 40 41 #if 0 42 #ifndef lint 43 static char sccsid[] = "@(#)common.c 8.5 (Berkeley) 4/28/95"; 44 #endif /* not lint */ 45 #endif 46 47 #include "lp.cdefs.h" /* A cross-platform version of <sys/cdefs.h> */ 48 __FBSDID("$FreeBSD$"); 49 50 #include <sys/param.h> 51 #include <sys/stat.h> 52 #include <sys/time.h> 53 #include <sys/types.h> 54 55 #include <ctype.h> 56 #include <dirent.h> 57 #include <err.h> 58 #include <errno.h> 59 #include <fcntl.h> 60 #include <stdio.h> 61 #include <stdlib.h> 62 #include <string.h> 63 #include <unistd.h> 64 65 #include "lp.h" 66 #include "lp.local.h" 67 #include "pathnames.h" 68 69 /* 70 * Routines and data common to all the line printer functions. 71 */ 72 char line[BUFSIZ]; 73 const char *progname; /* program name */ 74 75 static int compar(const void *_p1, const void *_p2); 76 77 /* 78 * isdigit() takes a parameter of 'int', but expect values in the range 79 * of unsigned char. Define a wrapper which takes a value of type 'char', 80 * whether signed or unsigned, and ensure it ends up in the right range. 81 */ 82 #define isdigitch(Anychar) isdigit((u_char)(Anychar)) 83 84 /* 85 * get_line reads a line from the control file cfp, removes tabs, converts 86 * new-line to null and leaves it in line. 87 * Returns 0 at EOF or the number of characters read. 88 */ 89 int 90 get_line(FILE *cfp) 91 { 92 register int linel = 0; 93 register char *lp = line; 94 register int c; 95 96 while ((c = getc(cfp)) != '\n' && (size_t)(linel+1) < sizeof(line)) { 97 if (c == EOF) 98 return(0); 99 if (c == '\t') { 100 do { 101 *lp++ = ' '; 102 linel++; 103 } while ((linel & 07) != 0 && (size_t)(linel+1) < 104 sizeof(line)); 105 continue; 106 } 107 *lp++ = c; 108 linel++; 109 } 110 *lp++ = '\0'; 111 return(linel); 112 } 113 114 /* 115 * Scan the current directory and make a list of daemon files sorted by 116 * creation time. 117 * Return the number of entries and a pointer to the list. 118 */ 119 int 120 getq(const struct printer *pp, struct jobqueue *(*namelist[])) 121 { 122 register struct dirent *d; 123 register struct jobqueue *q, **queue; 124 size_t arraysz, entrysz, nitems; 125 struct stat stbuf; 126 DIR *dirp; 127 int statres; 128 129 PRIV_START 130 if ((dirp = opendir(pp->spool_dir)) == NULL) { 131 PRIV_END 132 return (-1); 133 } 134 if (fstat(dirfd(dirp), &stbuf) < 0) 135 goto errdone; 136 PRIV_END 137 138 /* 139 * Estimate the array size by taking the size of the directory file 140 * and dividing it by a multiple of the minimum size entry. 141 */ 142 arraysz = (stbuf.st_size / 24); 143 if (arraysz < 16) 144 arraysz = 16; 145 queue = (struct jobqueue **)malloc(arraysz * sizeof(struct jobqueue *)); 146 if (queue == NULL) 147 goto errdone; 148 149 nitems = 0; 150 while ((d = readdir(dirp)) != NULL) { 151 if (d->d_name[0] != 'c' || d->d_name[1] != 'f') 152 continue; /* daemon control files only */ 153 PRIV_START 154 statres = stat(d->d_name, &stbuf); 155 PRIV_END 156 if (statres < 0) 157 continue; /* Doesn't exist */ 158 entrysz = sizeof(struct jobqueue) - sizeof(q->job_cfname) + 159 strlen(d->d_name) + 1; 160 q = (struct jobqueue *)malloc(entrysz); 161 if (q == NULL) 162 goto errdone; 163 q->job_matched = 0; 164 q->job_processed = 0; 165 q->job_time = stbuf.st_mtime; 166 strcpy(q->job_cfname, d->d_name); 167 /* 168 * Check to make sure the array has space left and 169 * realloc the maximum size. 170 */ 171 if (++nitems > arraysz) { 172 queue = (struct jobqueue **)reallocarray((char *)queue, 173 arraysz, 2 * sizeof(struct jobqueue *)); 174 if (queue == NULL) { 175 free(q); 176 goto errdone; 177 } 178 arraysz *= 2; 179 } 180 queue[nitems-1] = q; 181 } 182 closedir(dirp); 183 if (nitems) 184 qsort(queue, nitems, sizeof(struct jobqueue *), compar); 185 *namelist = queue; 186 return(nitems); 187 188 errdone: 189 closedir(dirp); 190 PRIV_END 191 return (-1); 192 } 193 194 /* 195 * Compare modification times. 196 */ 197 static int 198 compar(const void *p1, const void *p2) 199 { 200 const struct jobqueue *qe1, *qe2; 201 202 qe1 = *(const struct jobqueue * const *)p1; 203 qe2 = *(const struct jobqueue * const *)p2; 204 205 if (qe1->job_time < qe2->job_time) 206 return (-1); 207 if (qe1->job_time > qe2->job_time) 208 return (1); 209 /* 210 * At this point, the two files have the same last-modification time. 211 * return a result based on filenames, so that 'cfA001some.host' will 212 * come before 'cfA002some.host'. Since the jobid ('001') will wrap 213 * around when it gets to '999', we also assume that '9xx' jobs are 214 * older than '0xx' jobs. 215 */ 216 if ((qe1->job_cfname[3] == '9') && (qe2->job_cfname[3] == '0')) 217 return (-1); 218 if ((qe1->job_cfname[3] == '0') && (qe2->job_cfname[3] == '9')) 219 return (1); 220 return (strcmp(qe1->job_cfname, qe2->job_cfname)); 221 } 222 223 /* 224 * A simple routine to determine the job number for a print job based on 225 * the name of its control file. The algorithm used here may look odd, but 226 * the main issue is that all parts of `lpd', `lpc', `lpq' & `lprm' must be 227 * using the same algorithm, whatever that algorithm may be. If the caller 228 * provides a non-null value for ''hostpp', then this returns a pointer to 229 * the start of the hostname (or IP address?) as found in the filename. 230 * 231 * Algorithm: The standard `cf' file has the job number start in position 4, 232 * but some implementations have that as an extra file-sequence letter, and 233 * start the job number in position 5. The job number is usually three bytes, 234 * but may be as many as five. Confusing matters still more, some Windows 235 * print servers will append an IP address to the job number, instead of 236 * the expected hostname. So, if the job number ends with a '.', then 237 * assume the correct jobnum value is the first three digits. 238 */ 239 int 240 calc_jobnum(const char *cfname, const char **hostpp) 241 { 242 int jnum; 243 const char *cp, *numstr, *hoststr; 244 245 numstr = cfname + 3; 246 if (!isdigitch(*numstr)) 247 numstr++; 248 jnum = 0; 249 for (cp = numstr; (cp < numstr + 5) && isdigitch(*cp); cp++) 250 jnum = jnum * 10 + (*cp - '0'); 251 hoststr = cp; 252 253 /* 254 * If the filename was built with an IP number instead of a hostname, 255 * then recalculate using only the first three digits found. 256 */ 257 while(isdigitch(*cp)) 258 cp++; 259 if (*cp == '.') { 260 jnum = 0; 261 for (cp = numstr; (cp < numstr + 3) && isdigitch(*cp); cp++) 262 jnum = jnum * 10 + (*cp - '0'); 263 hoststr = cp; 264 } 265 if (hostpp != NULL) 266 *hostpp = hoststr; 267 return (jnum); 268 } 269 270 /* sleep n milliseconds */ 271 void 272 delay(int millisec) 273 { 274 struct timeval tdelay; 275 276 if (millisec <= 0 || millisec > 10000) 277 fatal((struct printer *)0, /* fatal() knows how to deal */ 278 "unreasonable delay period (%d)", millisec); 279 tdelay.tv_sec = millisec / 1000; 280 tdelay.tv_usec = millisec * 1000 % 1000000; 281 (void) select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tdelay); 282 } 283 284 char * 285 lock_file_name(const struct printer *pp, char *buf, size_t len) 286 { 287 static char staticbuf[MAXPATHLEN]; 288 289 if (buf == NULL) 290 buf = staticbuf; 291 if (len == 0) 292 len = MAXPATHLEN; 293 294 if (pp->lock_file[0] == '/') 295 strlcpy(buf, pp->lock_file, len); 296 else 297 snprintf(buf, len, "%s/%s", pp->spool_dir, pp->lock_file); 298 299 return buf; 300 } 301 302 char * 303 status_file_name(const struct printer *pp, char *buf, size_t len) 304 { 305 static char staticbuf[MAXPATHLEN]; 306 307 if (buf == NULL) 308 buf = staticbuf; 309 if (len == 0) 310 len = MAXPATHLEN; 311 312 if (pp->status_file[0] == '/') 313 strlcpy(buf, pp->status_file, len); 314 else 315 snprintf(buf, len, "%s/%s", pp->spool_dir, pp->status_file); 316 317 return buf; 318 } 319 320 /* 321 * Routine to change operational state of a print queue. The operational 322 * state is indicated by the access bits on the lock file for the queue. 323 * At present, this is only called from various routines in lpc/cmds.c. 324 * 325 * XXX - Note that this works by changing access-bits on the 326 * file, and you can only do that if you are the owner of 327 * the file, or root. Thus, this won't really work for 328 * userids in the "LPR_OPER" group, unless lpc is running 329 * setuid to root (or maybe setuid to daemon). 330 * Generally lpc is installed setgid to daemon, but does 331 * not run setuid. 332 */ 333 int 334 set_qstate(int action, const char *lfname) 335 { 336 struct stat stbuf; 337 mode_t chgbits, newbits, oldmask; 338 const char *failmsg, *okmsg; 339 static const char *nomsg = "no state msg"; 340 int chres, errsav, fd, res, statres; 341 342 /* 343 * Find what the current access-bits are. 344 */ 345 memset(&stbuf, 0, sizeof(stbuf)); 346 PRIV_START 347 statres = stat(lfname, &stbuf); 348 errsav = errno; 349 PRIV_END 350 if ((statres < 0) && (errsav != ENOENT)) { 351 printf("\tcannot stat() lock file\n"); 352 return (SQS_STATFAIL); 353 /* NOTREACHED */ 354 } 355 356 /* 357 * Determine which bit(s) should change for the requested action. 358 */ 359 chgbits = stbuf.st_mode; 360 newbits = LOCK_FILE_MODE; 361 okmsg = NULL; 362 failmsg = NULL; 363 if (action & SQS_QCHANGED) { 364 chgbits |= LFM_RESET_QUE; 365 newbits |= LFM_RESET_QUE; 366 /* The okmsg is not actually printed for this case. */ 367 okmsg = nomsg; 368 failmsg = "set queue-changed"; 369 } 370 if (action & SQS_DISABLEQ) { 371 chgbits |= LFM_QUEUE_DIS; 372 newbits |= LFM_QUEUE_DIS; 373 okmsg = "queuing disabled"; 374 failmsg = "disable queuing"; 375 } 376 if (action & SQS_STOPP) { 377 chgbits |= LFM_PRINT_DIS; 378 newbits |= LFM_PRINT_DIS; 379 okmsg = "printing disabled"; 380 failmsg = "disable printing"; 381 if (action & SQS_DISABLEQ) { 382 okmsg = "printer and queuing disabled"; 383 failmsg = "disable queuing and printing"; 384 } 385 } 386 if (action & SQS_ENABLEQ) { 387 chgbits &= ~LFM_QUEUE_DIS; 388 newbits &= ~LFM_QUEUE_DIS; 389 okmsg = "queuing enabled"; 390 failmsg = "enable queuing"; 391 } 392 if (action & SQS_STARTP) { 393 chgbits &= ~LFM_PRINT_DIS; 394 newbits &= ~LFM_PRINT_DIS; 395 okmsg = "printing enabled"; 396 failmsg = "enable printing"; 397 } 398 if (okmsg == NULL) { 399 /* This routine was called with an invalid action. */ 400 printf("\t<error in set_qstate!>\n"); 401 return (SQS_PARMERR); 402 /* NOTREACHED */ 403 } 404 405 res = 0; 406 if (statres >= 0) { 407 /* The file already exists, so change the access. */ 408 PRIV_START 409 chres = chmod(lfname, chgbits); 410 errsav = errno; 411 PRIV_END 412 res = SQS_CHGOK; 413 if (chres < 0) 414 res = SQS_CHGFAIL; 415 } else if (newbits == LOCK_FILE_MODE) { 416 /* 417 * The file does not exist, but the state requested is 418 * the same as the default state when no file exists. 419 * Thus, there is no need to create the file. 420 */ 421 res = SQS_SKIPCREOK; 422 } else { 423 /* 424 * The file did not exist, so create it with the 425 * appropriate access bits for the requested action. 426 * Push a new umask around that create, to make sure 427 * all the read/write bits are set as desired. 428 */ 429 oldmask = umask(S_IWOTH); 430 PRIV_START 431 fd = open(lfname, O_WRONLY|O_CREAT, newbits); 432 errsav = errno; 433 PRIV_END 434 umask(oldmask); 435 res = SQS_CREFAIL; 436 if (fd >= 0) { 437 res = SQS_CREOK; 438 close(fd); 439 } 440 } 441 442 switch (res) { 443 case SQS_CHGOK: 444 case SQS_CREOK: 445 case SQS_SKIPCREOK: 446 if (okmsg != nomsg) 447 printf("\t%s\n", okmsg); 448 break; 449 case SQS_CREFAIL: 450 printf("\tcannot create lock file: %s\n", 451 strerror(errsav)); 452 break; 453 default: 454 printf("\tcannot %s: %s\n", failmsg, strerror(errsav)); 455 break; 456 } 457 458 return (res); 459 } 460 461 /* routine to get a current timestamp, optionally in a standard-fmt string */ 462 void 463 lpd_gettime(struct timespec *tsp, char *strp, size_t strsize) 464 { 465 struct timespec local_ts; 466 struct timeval btime; 467 char tempstr[TIMESTR_SIZE]; 468 #ifdef STRFTIME_WRONG_z 469 char *destp; 470 #endif 471 472 if (tsp == NULL) 473 tsp = &local_ts; 474 475 /* some platforms have a routine called clock_gettime, but the 476 * routine does nothing but return "not implemented". */ 477 memset(tsp, 0, sizeof(struct timespec)); 478 if (clock_gettime(CLOCK_REALTIME, tsp)) { 479 /* nanosec-aware rtn failed, fall back to microsec-aware rtn */ 480 memset(tsp, 0, sizeof(struct timespec)); 481 gettimeofday(&btime, NULL); 482 tsp->tv_sec = btime.tv_sec; 483 tsp->tv_nsec = btime.tv_usec * 1000; 484 } 485 486 /* caller may not need a character-ized version */ 487 if ((strp == NULL) || (strsize < 1)) 488 return; 489 490 strftime(tempstr, TIMESTR_SIZE, LPD_TIMESTAMP_PATTERN, 491 localtime(&tsp->tv_sec)); 492 493 /* 494 * This check is for implementations of strftime which treat %z 495 * (timezone as [+-]hhmm ) like %Z (timezone as characters), or 496 * completely ignore %z. This section is not needed on freebsd. 497 * I'm not sure this is completely right, but it should work OK 498 * for EST and EDT... 499 */ 500 #ifdef STRFTIME_WRONG_z 501 destp = strrchr(tempstr, ':'); 502 if (destp != NULL) { 503 destp += 3; 504 if ((*destp != '+') && (*destp != '-')) { 505 char savday[6]; 506 int tzmin = timezone / 60; 507 int tzhr = tzmin / 60; 508 if (daylight) 509 tzhr--; 510 strcpy(savday, destp + strlen(destp) - 4); 511 snprintf(destp, (destp - tempstr), "%+03d%02d", 512 (-1*tzhr), tzmin % 60); 513 strcat(destp, savday); 514 } 515 } 516 #endif 517 518 if (strsize > TIMESTR_SIZE) { 519 strsize = TIMESTR_SIZE; 520 strp[TIMESTR_SIZE+1] = '\0'; 521 } 522 strlcpy(strp, tempstr, strsize); 523 } 524 525 /* routines for writing transfer-statistic records */ 526 void 527 trstat_init(struct printer *pp, const char *fname, int filenum) 528 { 529 register const char *srcp; 530 register char *destp, *endp; 531 532 /* 533 * Figure out the job id of this file. The filename should be 534 * 'cf', 'df', or maybe 'tf', followed by a letter (or sometimes 535 * two), followed by the jobnum, followed by a hostname. 536 * The jobnum is usually 3 digits, but might be as many as 5. 537 * Note that some care has to be taken parsing this, as the 538 * filename could be coming from a remote-host, and thus might 539 * not look anything like what is expected... 540 */ 541 memset(pp->jobnum, 0, sizeof(pp->jobnum)); 542 pp->jobnum[0] = '0'; 543 srcp = strchr(fname, '/'); 544 if (srcp == NULL) 545 srcp = fname; 546 destp = &(pp->jobnum[0]); 547 endp = destp + 5; 548 while (*srcp != '\0' && (*srcp < '0' || *srcp > '9')) 549 srcp++; 550 while (*srcp >= '0' && *srcp <= '9' && destp < endp) 551 *(destp++) = *(srcp++); 552 553 /* get the starting time in both numeric and string formats, and 554 * save those away along with the file-number */ 555 pp->jobdfnum = filenum; 556 lpd_gettime(&pp->tr_start, pp->tr_timestr, (size_t)TIMESTR_SIZE); 557 558 return; 559 } 560 561 void 562 trstat_write(struct printer *pp, tr_sendrecv sendrecv, size_t bytecnt, 563 const char *userid, const char *otherhost, const char *orighost) 564 { 565 #define STATLINE_SIZE 1024 566 double trtime; 567 size_t remspace; 568 int statfile; 569 char thishost[MAXHOSTNAMELEN], statline[STATLINE_SIZE]; 570 char *eostat; 571 const char *lprhost, *recvdev, *recvhost, *rectype; 572 const char *sendhost, *statfname; 573 #define UPD_EOSTAT(xStr) do { \ 574 eostat = strchr(xStr, '\0'); \ 575 remspace = eostat - xStr; \ 576 } while(0) 577 578 lpd_gettime(&pp->tr_done, NULL, (size_t)0); 579 trtime = DIFFTIME_TS(pp->tr_done, pp->tr_start); 580 581 gethostname(thishost, sizeof(thishost)); 582 lprhost = sendhost = recvhost = recvdev = NULL; 583 switch (sendrecv) { 584 case TR_SENDING: 585 rectype = "send"; 586 statfname = pp->stat_send; 587 sendhost = thishost; 588 recvhost = otherhost; 589 break; 590 case TR_RECVING: 591 rectype = "recv"; 592 statfname = pp->stat_recv; 593 sendhost = otherhost; 594 recvhost = thishost; 595 break; 596 case TR_PRINTING: 597 /* 598 * This case is for copying to a device (presumably local, 599 * though filters using things like 'net/CAP' can confuse 600 * this assumption...). 601 */ 602 rectype = "prnt"; 603 statfname = pp->stat_send; 604 sendhost = thishost; 605 recvdev = _PATH_DEFDEVLP; 606 if (pp->lp) recvdev = pp->lp; 607 break; 608 default: 609 /* internal error... should we syslog/printf an error? */ 610 return; 611 } 612 if (statfname == NULL) 613 return; 614 615 /* 616 * the original-host and userid are found out by reading thru the 617 * cf (control-file) for the job. Unfortunately, on incoming jobs 618 * the df's (data-files) are sent before the matching cf, so the 619 * orighost & userid are generally not-available for incoming jobs. 620 * 621 * (it would be nice to create a work-around for that..) 622 */ 623 if (orighost && (*orighost != '\0')) 624 lprhost = orighost; 625 else 626 lprhost = ".na."; 627 if (*userid == '\0') 628 userid = NULL; 629 630 /* 631 * Format of statline. 632 * Some of the keywords listed here are not implemented here, but 633 * they are listed to reserve the meaning for a given keyword. 634 * Fields are separated by a blank. The fields in statline are: 635 * <tstamp> - time the transfer started 636 * <ptrqueue> - name of the printer queue (the short-name...) 637 * <hname> - hostname the file originally came from (the 638 * 'lpr host'), if known, or "_na_" if not known. 639 * <xxx> - id of job from that host (generally three digits) 640 * <n> - file count (# of file within job) 641 * <rectype> - 4-byte field indicating the type of transfer 642 * statistics record. "send" means it's from the 643 * host sending a datafile, "recv" means it's from 644 * a host as it receives a datafile. 645 * user=<userid> - user who sent the job (if known) 646 * secs=<n> - seconds it took to transfer the file 647 * bytes=<n> - number of bytes transferred (ie, "bytecount") 648 * bps=<n.n>e<n> - Bytes/sec (if the transfer was "big enough" 649 * for this to be useful) 650 * ! top=<str> - type of printer (if the type is defined in 651 * printcap, and if this statline is for sending 652 * a file to that ptr) 653 * ! qls=<n> - queue-length at start of send/print-ing a job 654 * ! qle=<n> - queue-length at end of send/print-ing a job 655 * sip=<addr> - IP address of sending host, only included when 656 * receiving a job. 657 * shost=<hname> - sending host (if that does != the original host) 658 * rhost=<hname> - hostname receiving the file (ie, "destination") 659 * rdev=<dev> - device receiving the file, when the file is being 660 * send to a device instead of a remote host. 661 * 662 * Note: A single print job may be transferred multiple times. The 663 * original 'lpr' occurs on one host, and that original host might 664 * send to some interim host (or print server). That interim host 665 * might turn around and send the job to yet another host (most likely 666 * the real printer). The 'shost=' parameter is only included if the 667 * sending host for this particular transfer is NOT the same as the 668 * host which did the original 'lpr'. 669 * 670 * Many values have 'something=' tags before them, because they are 671 * in some sense "optional", or their order may vary. "Optional" may 672 * mean in the sense that different SITES might choose to have other 673 * fields in the record, or that some fields are only included under 674 * some circumstances. Programs processing these records should not 675 * assume the order or existence of any of these keyword fields. 676 */ 677 snprintf(statline, STATLINE_SIZE, "%s %s %s %s %03ld %s", 678 pp->tr_timestr, pp->printer, lprhost, pp->jobnum, 679 pp->jobdfnum, rectype); 680 UPD_EOSTAT(statline); 681 682 if (userid != NULL) { 683 snprintf(eostat, remspace, " user=%s", userid); 684 UPD_EOSTAT(statline); 685 } 686 snprintf(eostat, remspace, " secs=%#.2f bytes=%lu", trtime, 687 (unsigned long)bytecnt); 688 UPD_EOSTAT(statline); 689 690 /* 691 * The bps field duplicates info from bytes and secs, so do 692 * not bother to include it for very small files. 693 */ 694 if ((bytecnt > 25000) && (trtime > 1.1)) { 695 snprintf(eostat, remspace, " bps=%#.2e", 696 ((double)bytecnt/trtime)); 697 UPD_EOSTAT(statline); 698 } 699 700 if (sendrecv == TR_RECVING) { 701 if (remspace > 5+strlen(from_ip) ) { 702 snprintf(eostat, remspace, " sip=%s", from_ip); 703 UPD_EOSTAT(statline); 704 } 705 } 706 if (0 != strcmp(lprhost, sendhost)) { 707 if (remspace > 7+strlen(sendhost) ) { 708 snprintf(eostat, remspace, " shost=%s", sendhost); 709 UPD_EOSTAT(statline); 710 } 711 } 712 if (recvhost) { 713 if (remspace > 7+strlen(recvhost) ) { 714 snprintf(eostat, remspace, " rhost=%s", recvhost); 715 UPD_EOSTAT(statline); 716 } 717 } 718 if (recvdev) { 719 if (remspace > 6+strlen(recvdev) ) { 720 snprintf(eostat, remspace, " rdev=%s", recvdev); 721 UPD_EOSTAT(statline); 722 } 723 } 724 if (remspace > 1) { 725 strcpy(eostat, "\n"); 726 } else { 727 /* probably should back up to just before the final " x=".. */ 728 strcpy(statline+STATLINE_SIZE-2, "\n"); 729 } 730 statfile = open(statfname, O_WRONLY|O_APPEND, 0664); 731 if (statfile < 0) { 732 /* statfile was given, but we can't open it. should we 733 * syslog/printf this as an error? */ 734 return; 735 } 736 write(statfile, statline, strlen(statline)); 737 close(statfile); 738 739 return; 740 #undef UPD_EOSTAT 741 } 742 743 #include <stdarg.h> 744 745 void 746 fatal(const struct printer *pp, const char *msg, ...) 747 { 748 va_list ap; 749 va_start(ap, msg); 750 /* this error message is being sent to the 'from_host' */ 751 if (from_host != local_host) 752 (void)printf("%s: ", local_host); 753 (void)printf("%s: ", progname); 754 if (pp && pp->printer) 755 (void)printf("%s: ", pp->printer); 756 (void)vprintf(msg, ap); 757 va_end(ap); 758 (void)putchar('\n'); 759 exit(1); 760 } 761 762 /* 763 * Close all file descriptors from START on up. 764 */ 765 void 766 closeallfds(int start) 767 { 768 int stop; 769 770 if (USE_CLOSEFROM) /* The faster, modern solution */ 771 closefrom(start); 772 else { 773 /* This older logic can be pretty awful on some OS's. The 774 * getdtablesize() might return ``infinity'', and then this 775 * will waste a lot of time closing file descriptors which 776 * had never been open()-ed. */ 777 stop = getdtablesize(); 778 for (; start < stop; start++) 779 close(start); 780 } 781 } 782 783