2 * ------+---------+---------+---------+---------+---------+---------+---------*
3 * Copyright (c) 2001 - Garance Alistair Drosehn <gad@FreeBSD.org>.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * The views and conclusions contained in the software and documentation
28 * are those of the authors and should not be interpreted as representing
29 * official policies, either expressed or implied, of the FreeBSD Project.
31 * ------+---------+---------+---------+---------+---------+---------+---------*
35 static const char rcsid[] =
36 "$FreeBSD: src/usr.sbin/lpr/common_source/ctlinfo.c,v 1.1.2.6 2002/07/14 23:47:09 gad Exp $";
40 * ctlinfo - This collection of routines will know everything there is to
41 * know about the information inside a control file ('cf*') which is used
42 * to describe a print job in lpr & friends. The eventual goal is that it
43 * will be the ONLY source file to know what's inside these control-files.
47 * Some define's useful for debuging.
48 * TRIGGERTEST_FNAME and DEBUGREADCF_FNAME, allow us to do testing on
49 * a per-spool-directory basis.
51 /* #define TRIGGERTEST_FNAME "LpdTestRenameTF" */
52 /* #define DEBUGREADCF_FNAME "LpdDebugReadCF" */
53 /* #define LEAVE_TMPCF_FILES 1 */
55 #include <sys/types.h>
71 char *cji_buff; /* buffer for getline */
72 char *cji_eobuff; /* last byte IN the buffer */
74 int cji_buffsize; /* # bytes in the buffer */
78 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
81 * This has to be large enough to fit the maximum length of a single line
82 * in a control-file, including the leading 'command id', a trailing '\n'
83 * and ending '\0'. The max size of an 'U'nlink line, for instance, is
84 * 1 ('U') + PATH_MAX (filename) + 2 ('\n\0'). The maximum 'H'ost line is
85 * 1 ('H') + NI_MAXHOST (remote hostname) + 2 ('\n\0'). Other lines can be
86 * even longer than those. So, pick some nice, large, arbitrary value.
88 #define CTI_LINEMAX PATH_MAX+NI_MAXHOST+5
90 extern const char *from_host; /* client's machine name */
91 extern const char *from_ip; /* client machine's IP address */
94 void ctl_dumpcji(FILE *_dbg_stream, const char *_heading,
95 struct cjobinfo *_cjinf);
96 static char *ctl_getline(struct cjobinfo *_cjinf);
97 static void ctl_rewindcf(struct cjobinfo *_cjinf);
98 char *ctl_rmjob(const char *_ptrname, const char *_cfname);
102 * Here are some things which might be needed when compiling this under
103 * platforms other than FreeBSD.
107 # define NAME_MAX 255
110 # define NI_MAXHOST 1025
113 # define PATH_MAX 1024
116 char *strdup(const char *_src);
117 size_t strlcpy(char *_dst, const char *_src, size_t _siz);
122 * Control-files (cf*) have the following format.
124 * Each control-file describes a single job. It will list one or more
125 * "datafiles" (df*) which should be copied to some printer. Usually
126 * there is only one datafile per job. For the curious, RFC 1179 is an
127 * informal and out-of-date description of lpr/lpd circa 1990.
129 * Each line in the file gives an attribute of the job as a whole, or one
130 * of the datafiles in the job, or a "command" indicating something to do
131 * with one of the datafiles. Each line starts with an 'id' that indicates
132 * what that line is there for. The 'id' is historically a single byte,
133 * but may be multiple bytes (obviously it would be best if multi-byte ids
134 * started with some letter not already used as a single-byte id!).
135 * After the 'id', the remainder of the line will be the value of the
136 * indicated attribute, or a name of the datafile to be operated on.
138 * In the following lists of ids, the ids with a '!' in front of them are
139 * NOT explicitly supported by this version of lpd, or at least "not yet
140 * supported". They are only listed for reference purposes, so people
141 * won't be tempted to reuse the same id for a different purpose.
143 * The following are attributes of the job which should not appear more
144 * than once in a control file. Only the 'H' and 'P' lines are required
145 * by the RFC, but some implementations of lpr won't even get that right.
147 * ! A - [used by lprNG]
148 * B - As far as I know, this is never used as a single-byte id.
149 * Therefore, I intend to use it for multi-byte id codes.
150 * C - "class name" to display on banner page (this is sometimes
151 * used to hold options for print filters)
152 * ! D - [in lprNG, "timestamp" of when the job was submitted]
153 * ! E - "environment variables" to set [some versions of linux]
154 * H - "host name" of machine where the original 'lpr' was done
155 * I - "indent", the amount to indent output
156 * J - "job name" to display on banner page
157 * L - "literal" user's name as it should be displayed on the
158 * banner page (it is the existence of an 'L' line which
159 * indicates that a job should have a banner page).
160 * M - "mail", userid to mail to when done printing (with email
161 * going to 'M'@'H', so to speak).
162 * P - "person", the user's login name (e.g. for accounting)
163 * ! Q - [used by lprNG for queue-name]
164 * R - "resolution" in dpi, for some laser printer queues
165 * T - "title" for files sent thru 'pr'
166 * W - "width" to use for printing plain-text files
167 * Z - In BSD, "locale" to use for datafiles sent thru 'pr'.
168 * (this BSD usage should move to a different id...)
169 * [in lprNG - this line holds the "Z options"]
170 * 1 - "R font file" for files sent thru troff
171 * 2 - "I font file" for files sent thru troff
172 * 3 - "B font file" for files sent thru troff
173 * 4 - "S font file" for files sent thru troff
175 * The following are attributes attached to a datafile, and thus may
176 * appear multiple times in a control file (once per datafile):
178 * N - "name" of file (for display purposes, used by 'lpq')
179 * S - "stat() info" used for symbolic link ('lpr -s')
182 * The following indicate actions to take on a given datafile. The same
183 * datafile may appear on more than one "print this file" command in the
184 * control file. Note that ALL ids with lowercase letters are expected
185 * to be actions to "print this file":
187 * c - "file name", cifplot file to print. This action appears
188 * when the user has requested 'lpr -c'.
189 * d - "file name", dvi file to print, user requested 'lpr -d'
190 * f - "file name", a plain-text file to print = "standard"
191 * g - "file name", plot(1G) file to print, ie 'lpr -g'
192 * l - "file name", text file with control chars which should
193 * be printed literally, ie 'lpr -l' (note: some printers
194 * take this id as a request to print a postscript file,
195 * and because of *that* some OS's use 'l' to indicate
196 * that a datafile is a postscript file)
197 * n - "file name", ditroff(1) file to print, ie 'lpr -n'
198 * o - "file name", a postscript file to print. This id is
199 * described in the original RFC, but not much has been
200 * done with it. This 'lpr' does not generate control
201 * lines with 'o'-actions, but lpd's printjob processing
202 * will treat it the same as 'l'.
203 * p - "file name", text file to print with pr(1), ie 'lpr -p'
204 * t - "file name", troff(1) file to print, ie 'lpr -t'
205 * v - "file name", plain raster file to print
207 * U - "file name" of datafile to unlink (ie, remove file
208 * from spool directory. To be done in a 'Pass 2',
209 * AFTER having processed all datafiles in the job).
214 ctl_freeinf(struct cjobinfo *cjinf)
216 #define FREESTR(xStr) \
217 if (xStr != NULL) { \
222 struct cjprivate *cpriv;
226 cpriv = cjinf->cji_priv;
227 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
228 syslog(LOG_ERR, "in ctl_freeinf(%p): invalid cjinf (cpriv %p)",
229 (void *)cjinf, (void *)cpriv);
233 FREESTR(cpriv->pub.cji_accthost);
234 FREESTR(cpriv->pub.cji_acctuser);
235 FREESTR(cpriv->pub.cji_class);
236 FREESTR(cpriv->pub.cji_curqueue);
237 /* [cpriv->pub.cji_fname is part of cpriv-malloced area] */
238 FREESTR(cpriv->pub.cji_jobname);
239 FREESTR(cpriv->pub.cji_mailto);
240 FREESTR(cpriv->pub.cji_username);
242 if (cpriv->cji_fstream != NULL) {
243 fclose(cpriv->cji_fstream);
244 cpriv->cji_fstream = NULL;
247 cjinf->cji_priv = NULL;
252 #ifdef DEBUGREADCF_FNAME
253 static FILE *ctl_dbgfile = NULL;
254 static struct stat ctl_dbgstat;
256 static int ctl_dbgline = 0;
259 ctl_readcf(const char *ptrname, const char *cfname)
265 struct cjprivate *cpriv;
266 struct cjobinfo *cjinf;
267 size_t msize, sroom, sroom2;
269 cfile = fopen(cfname, "r");
271 syslog(LOG_ERR, "%s: ctl_readcf error fopen(%s): %s",
272 ptrname, cfname, strerror(errno));
276 sroom = roundup(sizeof(struct cjprivate), 8);
277 sroom2 = sroom + strlen(cfname) + 1;
278 sroom2 = roundup(sroom2, 8);
279 msize = sroom2 + CTI_LINEMAX;
280 msize = roundup(msize, 8);
281 cstart = malloc(msize);
284 memset(cstart, 0, msize);
285 cpriv = (struct cjprivate *)cstart;
286 cpriv->pub.cji_priv = cpriv;
288 cpriv->pub.cji_fname = (char *)cstart + sroom;
289 strcpy(cpriv->pub.cji_fname, cfname);
290 cpriv->cji_buff = (char *)cstart + sroom2;
291 cpriv->cji_buffsize = (int)(msize - sroom2);
292 cpriv->cji_eobuff = (char *)cstart + msize - 1;
294 cpriv->cji_fstream = cfile;
295 cpriv->pub.cji_curqueue = strdup(ptrname);
298 #ifdef DEBUGREADCF_FNAME
300 id = stat(DEBUGREADCF_FNAME, &ctl_dbgstat);
302 /* the file exists in this spool directory, write some simple
303 * debugging info to it */
304 ctl_dbgfile = fopen(DEBUGREADCF_FNAME, "a");
305 if (ctl_dbgfile != NULL) {
306 fprintf(ctl_dbgfile, "%s: s=%p r=%ld e=%p %p->%s\n",
307 ptrname, (void *)cpriv, (long)sroom,
308 cpriv->cji_eobuff, cpriv->pub.cji_fname,
309 cpriv->pub.cji_fname);
314 * Copy job-attribute values from control file to the struct of
315 * "public" information. In some cases, it is invalid for the
316 * value to be a null-string, so that is ignored.
318 cjinf = &(cpriv->pub);
319 lbuff = ctl_getline(cjinf);
320 while (lbuff != NULL) {
324 cpriv->pub.cji_class = strdup(lbuff);
329 cpriv->pub.cji_accthost = strdup(lbuff);
332 cpriv->pub.cji_jobname = strdup(lbuff);
335 cpriv->pub.cji_username = strdup(lbuff);
339 * No valid mail-to address would start with a minus.
340 * If this one does, it is probably some trickster who
341 * is trying to trigger options on sendmail. Ignore.
347 cpriv->pub.cji_mailto = strdup(lbuff);
350 /* don't allow userid's with a leading minus, either */
355 cpriv->pub.cji_acctuser = strdup(lbuff);
359 cpriv->pub.cji_dfcount++;
363 lbuff = ctl_getline(cjinf);
366 /* the 'H'ost and 'P'erson fields are *always* supposed to be there */
367 if (cpriv->pub.cji_accthost == NULL)
368 cpriv->pub.cji_accthost = strdup(".na.");
369 if (cpriv->pub.cji_acctuser == NULL)
370 cpriv->pub.cji_acctuser = strdup(".na.");
372 #ifdef DEBUGREADCF_FNAME
373 if (ctl_dbgfile != NULL) {
374 if (cpriv->cji_dumpit)
375 ctl_dumpcji(ctl_dbgfile, "end readcf", &(cpriv->pub));
380 return &(cpriv->pub);
384 * This routine renames the temporary control file as received from some
385 * other (remote) host. That file will almost always with `tfA*', because
386 * recvjob.c creates the file by changing `c' to `t' in the original name
387 * for the control file. Now if you read the RFC, you would think that all
388 * control filenames start with `cfA*'. However, it seems there are some
389 * implementations which send control filenames which start with `cf'
390 * followed by *any* letter, so this routine can not assume what the third
391 * letter will (or will not) be. Sigh.
393 * So this will rewrite the temporary file to `rf*' (correcting any lines
394 * which need correcting), rename that `rf*' file to `cf*', and then remove
395 * the original `tf*' temporary file.
397 * The *main* purpose of this routine is to be paranoid about the contents
398 * of that control file. It is partially meant to protect against people
399 * TRYING to cause trouble (perhaps after breaking into root of some host
400 * that this host will accept print jobs from). The fact that we're willing
401 * to print jobs from some remote host does not mean that we should blindly
402 * do anything that host tells us to do.
404 * This is also meant to protect us from errors in other implementations of
405 * lpr, particularly since we may want to use some values from the control
406 * file as environment variables when it comes time to print, or as parameters
407 * to commands which will be exec'ed, or values in statistics records.
409 * This may also do some "conversions" between how different versions of
410 * lpr or lprNG define the contents of various lines in a control file.
412 * If there is an error, it returns a pointer to a descriptive error message.
413 * Error messages which are RETURNED (as opposed to syslog-ed) do not include
414 * the printer-queue name. Let the caller add that if it is wanted.
417 ctl_renametf(const char *ptrname, const char *tfname)
419 int chk3rd, newfd, nogood, res;
421 struct cjobinfo *cjinf;
422 char *lbuff, *slash, *cp;
423 char tfname2[NAME_MAX+1], cfname2[NAME_MAX+1];
424 char errm[CTI_LINEMAX];
426 #ifdef TRIGGERTEST_FNAME
428 res = stat(TRIGGERTEST_FNAME, &tstat);
431 * if the trigger file does NOT exist in this spool directory,
432 * then do the exact same steps that the pre-ctlinfo code had
433 * been doing. Ie, very little.
435 strlcpy(cfname2, tfname, sizeof(cfname2));
437 res = link(tfname, cfname2);
439 snprintf(errm, sizeof(errm),
440 "ctl_renametf error link(%s,%s): %s", tfname,
441 cfname2, strerror(errno));
448 cjinf = NULL; /* in case of early jump to error_ret */
449 newcf = NULL; /* in case of early jump to error_ret */
450 *errm = '\0'; /* in case of early jump to error_ret */
453 if ((tfname[0] != 't') || (tfname[1] != 'f') || (!isalpha(chk3rd))) {
454 snprintf(errm, sizeof(errm),
455 "ctl_renametf invalid filename: %s", tfname);
459 cjinf = ctl_readcf(ptrname, tfname);
461 snprintf(errm, sizeof(errm),
462 "ctl_renametf error cti_readcf(%s)", tfname);
467 * This uses open+fdopen instead of fopen because that combination
468 * gives us greater control over file-creation issues.
470 strlcpy(tfname2, tfname, sizeof(tfname2));
471 tfname2[0] = 'r'; /* rf<letter><job><hostname> */
472 newfd = open(tfname2, O_WRONLY|O_CREAT|O_TRUNC, 0660);
474 snprintf(errm, sizeof(errm),
475 "ctl_renametf error open(%s): %s", tfname2,
479 newcf = fdopen(newfd, "w");
482 snprintf(errm, sizeof(errm),
483 "ctl_renametf error fopen(%s): %s", tfname2,
489 * Do extra sanity checks on some key job-attribute fields, and
490 * write them out first (thus making sure they are written in the
491 * order we generally expect them to be in).
494 * Some lpr implementations on PC's set a null-string for their
495 * hostname. A MacOS 10 system which has not correctly setup
496 * /etc/hostconfig will claim a hostname of 'localhost'. Anything
497 * with blanks in it would be an invalid value for hostname. For
498 * any of these invalid hostname values, replace the given value
499 * with the name of the host that this job is coming from.
502 if (cjinf->cji_accthost == NULL)
504 else if (strcmp(cjinf->cji_accthost, ".na.") == 0)
506 else if (strcmp(cjinf->cji_accthost, "localhost") == 0)
509 for (cp = cjinf->cji_accthost; *cp != '\0'; cp++) {
517 fprintf(newcf, "H%s\n", from_host);
519 fprintf(newcf, "H%s\n", cjinf->cji_accthost);
522 * Now do some sanity checks on the 'P' (original userid) value. Note
523 * that the 'P'erson line is the second line which is ALWAYS supposed
524 * to be present in a control file.
526 * There is no particularly good value to use for replacements, but
527 * at least make sure the value is something reasonable to use in
528 * environment variables and statistics records. Again, some PC
529 * implementations send a null-string for a value. Various Mac
530 * implementations will set whatever string the user has set for
531 * their 'Owner Name', which usually includes blanks, etc.
534 if (cjinf->cji_acctuser == NULL)
537 for (cp = cjinf->cji_acctuser; *cp != '\0'; cp++) {
543 fprintf(newcf, "P%s\n", ".na.");
545 fprintf(newcf, "P%s\n", cjinf->cji_acctuser);
547 /* No need for sanity checks on class, jobname, "literal" user. */
548 if (cjinf->cji_class != NULL)
549 fprintf(newcf, "C%s\n", cjinf->cji_class);
550 if (cjinf->cji_jobname != NULL)
551 fprintf(newcf, "J%s\n", cjinf->cji_jobname);
552 if (cjinf->cji_username != NULL)
553 fprintf(newcf, "L%s\n", cjinf->cji_username);
556 * This should probably add more sanity checks on mailto value.
557 * Note that if the mailto value is "wrong", then there's no good
558 * way to know what the "correct" value would be, and we should not
559 * semd email to some random address. At least for now, just ignore
560 * any invalid values.
563 if (cjinf->cji_mailto == NULL)
566 for (cp = cjinf->cji_acctuser; *cp != '\0'; cp++) {
574 fprintf(newcf, "M%s\n", cjinf->cji_mailto);
577 * Now go thru the old control file, copying all information which
578 * hasn't already been written into the new file.
581 lbuff = ctl_getline(cjinf);
582 while (lbuff != NULL) {
590 /* already wrote values for these to the newcf */
593 /* see comments under 'U'... */
594 if (cjinf->cji_dfcount == 0) {
595 /* in this case, 'N's will be done in 'U' */
598 fprintf(newcf, "%s\n", lbuff);
602 * check for the very common case where the remote
603 * host had to process 'lpr -s -r', but it did not
604 * remove the Unlink line from the control file.
605 * Such Unlink lines will legitimately have a '/' in
606 * them, but it is the original lpr host which would
607 * have done the unlink of such files, and not any
608 * host receiving that job.
610 slash = strchr(lbuff, '/');
612 break; /* skip this line */
615 * Okay, another kind of broken lpr implementation
616 * is one which send datafiles, and Unlink's those
617 * datafiles, but never includes any PRINT request
618 * for those files. Experimentation shows that one
619 * copy of those datafiles should be printed with a
620 * format of 'f'. If this is an example of such a
621 * screwed-up control file, fix it here.
623 if (cjinf->cji_dfcount == 0) {
625 if (strncmp(lbuff, "df", (size_t)2) == 0) {
626 fprintf(newcf, "f%s\n", lbuff);
627 fprintf(newcf, "U%s\n", lbuff);
628 fprintf(newcf, "N%s\n", lbuff);
632 fprintf(newcf, "%s\n", lbuff);
635 fprintf(newcf, "%s\n", lbuff);
638 lbuff = ctl_getline(cjinf);
647 snprintf(errm, sizeof(errm),
648 "ctl_renametf error fclose(%s): %s", tfname2,
653 strlcpy(cfname2, tfname, sizeof(cfname2));
654 cfname2[0] = 'c'; /* rename new file to 'cfA*' */
655 res = link(tfname2, cfname2);
657 snprintf(errm, sizeof(errm),
658 "ctl_renametf error link(%s,%s): %s", tfname2, cfname2,
663 /* All the important work is done. Now just remove temp files */
664 #ifdef LEAVE_TMPCF_FILES
668 tfstat.st_size = 1; /* certainly invalid value */
669 res = stat(tfname, &tfstat);
670 size1 = tfstat.st_size;
671 tfstat.st_size = 2; /* certainly invalid value */
672 res = stat(tfname2, &tfstat);
673 /* if the sizes do not match, or either stat call failed,
674 * then do not remove the temp files, but return "all OK".
675 * This is just so I can see what this routine had changed.
677 if (size1 != tfstat.st_size)
694 return strdup("ctl_renametf internal (missed) error");
698 ctl_rewindcf(struct cjobinfo *cjinf)
700 struct cjprivate *cpriv;
704 cpriv = cjinf->cji_priv;
705 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
706 syslog(LOG_ERR, "in ctl_rewindcf(%p): invalid cjinf (cpriv %p)",
707 (void *)cjinf, (void *)cpriv);
711 rewind(cpriv->cji_fstream); /* assume no errors... :-) */
715 ctl_rmjob(const char *ptrname, const char *cfname)
717 struct cjobinfo *cjinf;
719 char errm[CTI_LINEMAX];
721 cjinf = ctl_readcf(ptrname, cfname);
723 snprintf(errm, sizeof(errm),
724 "ctl_renametf error cti_readcf(%s)", cfname);
729 lbuff = ctl_getline(cjinf);
730 while (lbuff != NULL) {
731 /* obviously we need to fill in the following... */
740 lbuff = ctl_getline(cjinf);
750 * The following routine was originally written to pin down a bug. It is
751 * no longer needed for that problem, but may be useful to keep around for
755 ctl_dumpcji(FILE *dbg_stream, const char *heading, struct cjobinfo *cjinf)
757 #define PRINTSTR(xHdr,xStr) \
760 fprintf(dbg_stream, "%4d] %12s = ", ctl_dbgline, xHdr); \
762 fprintf(dbg_stream, "NULL\n"); \
764 fprintf(dbg_stream, "%p -> %s\n", astr, astr)
766 struct cjprivate *cpriv;
771 "ctl_dumpcji: ptr to cjobinfo for '%s' is NULL\n",
775 cpriv = cjinf->cji_priv;
777 fprintf(dbg_stream, "ctl_dumpcji: Dump '%s' of cjobinfo at %p->%p\n",
778 heading, (void *)cjinf, cpriv->cji_buff);
780 PRINTSTR("accthost.H", cpriv->pub.cji_accthost);
781 PRINTSTR("acctuser.P", cpriv->pub.cji_acctuser);
782 PRINTSTR("class.C", cpriv->pub.cji_class);
783 PRINTSTR("cf-qname", cpriv->pub.cji_curqueue);
784 PRINTSTR("cf-fname", cpriv->pub.cji_fname);
785 PRINTSTR("jobname.J", cpriv->pub.cji_jobname);
786 PRINTSTR("mailto.M", cpriv->pub.cji_mailto);
787 PRINTSTR("hdruser.L", cpriv->pub.cji_username);
790 fprintf(dbg_stream, "%4d] %12s = ", ctl_dbgline, "*cjprivate");
791 if (cpriv->pub.cji_priv == NULL)
792 fprintf(dbg_stream, "NULL !!\n");
794 fprintf(dbg_stream, "%p\n", (void *)cpriv->pub.cji_priv);
796 fprintf(dbg_stream, "|- - - - --> Dump '%s' complete\n", heading);
798 /* flush output for the benefit of anyone doing a 'tail -f' */
805 * This routine reads in the next line from the control-file, and removes
806 * the trailing newline character.
808 * Historical note: Earlier versions of this routine did tab-expansion for
809 * ALL lines read in, which did not make any sense for most of the lines
810 * in a control file. For the lines where tab-expansion is useful, it will
811 * now have to be done by the calling routine.
814 ctl_getline(struct cjobinfo *cjinf)
817 struct cjprivate *cpriv;
821 cpriv = cjinf->cji_priv;
822 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
823 syslog(LOG_ERR, "in ctl_getline(%p): invalid cjinf (cpriv %p)",
824 (void *)cjinf, (void *)cpriv);
829 strp = fgets(cpriv->cji_buff, cpriv->cji_buffsize, cpriv->cji_fstream);
832 syslog(LOG_ERR, "%s: ctl_getline error fgets(%s): %s",
833 cpriv->pub.cji_curqueue, cpriv->pub.cji_fname,
837 nl = strchr(strp, '\n');
841 #ifdef DEBUGREADCF_FNAME
842 /* I'd like to find out if the previous work to expand tabs was ever
843 * really used, and if so, on what lines and for what reason.
844 * Yes, all this work probably means I'm obsessed about this 'tab'
845 * issue, but isn't programming a matter of obsession?
853 for (ch = strp; *ch != '\0'; ch++) {
858 if (tabcnt && (ctl_dbgfile != NULL)) {
860 fprintf(ctl_dbgfile, "%s: tabs=%d '%s'\n",
861 cpriv->pub.cji_fname, tabcnt, cpriv->cji_buff);