usr.sbin/lpr/common_source/common.c

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