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