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
getline(FILE * cfp)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
getq(const struct printer * pp,struct jobqueue * (* namelist[]))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
compar(const void * p1,const void * p2)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
calc_jobnum(const char * cfname,const char ** hostpp)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
delay(int millisec)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 *
lock_file_name(const struct printer * pp,char * buf,size_t len)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 *
status_file_name(const struct printer * pp,char * buf,size_t len)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
set_qstate(int action,const char * lfname)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
lpd_gettime(struct timespec * tsp,char * strp,size_t strsize)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
trstat_init(struct printer * pp,const char * fname,int filenum)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
trstat_write(struct printer * pp,tr_sendrecv sendrecv,size_t bytecnt,const char * userid,const char * otherhost,const char * orighost)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
fatal(const struct printer * pp,const char * msg,...)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
closeallfds(int start)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
779