Remove some !FreeBSD compat code, which produces warnings on DragonFly.
[dragonfly.git] / usr.sbin / lpr / common_source / ctlinfo.c
CommitLineData
984263bc
MD
1/*
2 * ------+---------+---------+---------+---------+---------+---------+---------*
3 * Copyright (c) 2001 - Garance Alistair Drosehn <gad@FreeBSD.org>.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
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.
14 *
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
25 * SUCH DAMAGE.
26 *
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.
30 *
31 * ------+---------+---------+---------+---------+---------+---------+---------*
1de703da
MD
32 *
33 * $FreeBSD: src/usr.sbin/lpr/common_source/ctlinfo.c,v 1.1.2.6 2002/07/14 23:47:09 gad Exp $
c344dd79 34 * $DragonFly: src/usr.sbin/lpr/common_source/ctlinfo.c,v 1.3 2004/11/26 14:47:04 joerg Exp $
984263bc
MD
35 */
36
984263bc
MD
37/*
38 * ctlinfo - This collection of routines will know everything there is to
39 * know about the information inside a control file ('cf*') which is used
40 * to describe a print job in lpr & friends. The eventual goal is that it
41 * will be the ONLY source file to know what's inside these control-files.
42 */
43
44/*
45 * Some define's useful for debuging.
46 * TRIGGERTEST_FNAME and DEBUGREADCF_FNAME, allow us to do testing on
47 * a per-spool-directory basis.
48 */
49/* #define TRIGGERTEST_FNAME "LpdTestRenameTF" */
50/* #define DEBUGREADCF_FNAME "LpdDebugReadCF" */
51/* #define LEAVE_TMPCF_FILES 1 */
52
53#include <sys/types.h>
54#include <sys/stat.h>
55#include <ctype.h>
56#include <errno.h>
57#include <fcntl.h>
58#include <limits.h>
59#include <netdb.h>
60#include <stdio.h>
61#include <stdlib.h>
62#include <string.h>
63#include <syslog.h>
64#include <unistd.h>
65#include "ctlinfo.h"
66
67struct cjprivate {
68 struct cjobinfo pub;
69 char *cji_buff; /* buffer for getline */
70 char *cji_eobuff; /* last byte IN the buffer */
71 FILE *cji_fstream;
72 int cji_buffsize; /* # bytes in the buffer */
73 int cji_dumpit;
74};
75
76#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
77
78/*
79 * This has to be large enough to fit the maximum length of a single line
80 * in a control-file, including the leading 'command id', a trailing '\n'
81 * and ending '\0'. The max size of an 'U'nlink line, for instance, is
82 * 1 ('U') + PATH_MAX (filename) + 2 ('\n\0'). The maximum 'H'ost line is
83 * 1 ('H') + NI_MAXHOST (remote hostname) + 2 ('\n\0'). Other lines can be
84 * even longer than those. So, pick some nice, large, arbitrary value.
85 */
86#define CTI_LINEMAX PATH_MAX+NI_MAXHOST+5
87
88extern const char *from_host; /* client's machine name */
89extern const char *from_ip; /* client machine's IP address */
90
91__BEGIN_DECLS
92void ctl_dumpcji(FILE *_dbg_stream, const char *_heading,
93 struct cjobinfo *_cjinf);
94static char *ctl_getline(struct cjobinfo *_cjinf);
95static void ctl_rewindcf(struct cjobinfo *_cjinf);
96char *ctl_rmjob(const char *_ptrname, const char *_cfname);
97__END_DECLS
98
984263bc
MD
99/*
100 * Control-files (cf*) have the following format.
101 *
102 * Each control-file describes a single job. It will list one or more
103 * "datafiles" (df*) which should be copied to some printer. Usually
104 * there is only one datafile per job. For the curious, RFC 1179 is an
105 * informal and out-of-date description of lpr/lpd circa 1990.
106 *
107 * Each line in the file gives an attribute of the job as a whole, or one
108 * of the datafiles in the job, or a "command" indicating something to do
109 * with one of the datafiles. Each line starts with an 'id' that indicates
110 * what that line is there for. The 'id' is historically a single byte,
111 * but may be multiple bytes (obviously it would be best if multi-byte ids
112 * started with some letter not already used as a single-byte id!).
113 * After the 'id', the remainder of the line will be the value of the
114 * indicated attribute, or a name of the datafile to be operated on.
115 *
116 * In the following lists of ids, the ids with a '!' in front of them are
117 * NOT explicitly supported by this version of lpd, or at least "not yet
118 * supported". They are only listed for reference purposes, so people
119 * won't be tempted to reuse the same id for a different purpose.
120 *
121 * The following are attributes of the job which should not appear more
122 * than once in a control file. Only the 'H' and 'P' lines are required
123 * by the RFC, but some implementations of lpr won't even get that right.
124 *
125 * ! A - [used by lprNG]
126 * B - As far as I know, this is never used as a single-byte id.
127 * Therefore, I intend to use it for multi-byte id codes.
128 * C - "class name" to display on banner page (this is sometimes
129 * used to hold options for print filters)
130 * ! D - [in lprNG, "timestamp" of when the job was submitted]
131 * ! E - "environment variables" to set [some versions of linux]
132 * H - "host name" of machine where the original 'lpr' was done
133 * I - "indent", the amount to indent output
134 * J - "job name" to display on banner page
135 * L - "literal" user's name as it should be displayed on the
136 * banner page (it is the existence of an 'L' line which
137 * indicates that a job should have a banner page).
138 * M - "mail", userid to mail to when done printing (with email
139 * going to 'M'@'H', so to speak).
140 * P - "person", the user's login name (e.g. for accounting)
141 * ! Q - [used by lprNG for queue-name]
142 * R - "resolution" in dpi, for some laser printer queues
143 * T - "title" for files sent thru 'pr'
144 * W - "width" to use for printing plain-text files
145 * Z - In BSD, "locale" to use for datafiles sent thru 'pr'.
146 * (this BSD usage should move to a different id...)
147 * [in lprNG - this line holds the "Z options"]
148 * 1 - "R font file" for files sent thru troff
149 * 2 - "I font file" for files sent thru troff
150 * 3 - "B font file" for files sent thru troff
151 * 4 - "S font file" for files sent thru troff
152 *
153 * The following are attributes attached to a datafile, and thus may
154 * appear multiple times in a control file (once per datafile):
155 *
156 * N - "name" of file (for display purposes, used by 'lpq')
157 * S - "stat() info" used for symbolic link ('lpr -s')
158 * security checks.
159 *
160 * The following indicate actions to take on a given datafile. The same
161 * datafile may appear on more than one "print this file" command in the
162 * control file. Note that ALL ids with lowercase letters are expected
163 * to be actions to "print this file":
164 *
165 * c - "file name", cifplot file to print. This action appears
166 * when the user has requested 'lpr -c'.
167 * d - "file name", dvi file to print, user requested 'lpr -d'
168 * f - "file name", a plain-text file to print = "standard"
169 * g - "file name", plot(1G) file to print, ie 'lpr -g'
170 * l - "file name", text file with control chars which should
171 * be printed literally, ie 'lpr -l' (note: some printers
172 * take this id as a request to print a postscript file,
173 * and because of *that* some OS's use 'l' to indicate
174 * that a datafile is a postscript file)
175 * n - "file name", ditroff(1) file to print, ie 'lpr -n'
176 * o - "file name", a postscript file to print. This id is
177 * described in the original RFC, but not much has been
178 * done with it. This 'lpr' does not generate control
179 * lines with 'o'-actions, but lpd's printjob processing
180 * will treat it the same as 'l'.
181 * p - "file name", text file to print with pr(1), ie 'lpr -p'
182 * t - "file name", troff(1) file to print, ie 'lpr -t'
183 * v - "file name", plain raster file to print
184 *
185 * U - "file name" of datafile to unlink (ie, remove file
186 * from spool directory. To be done in a 'Pass 2',
187 * AFTER having processed all datafiles in the job).
188 *
189 */
190
191void
192ctl_freeinf(struct cjobinfo *cjinf)
193{
194#define FREESTR(xStr) \
195 if (xStr != NULL) { \
196 free(xStr); \
197 xStr = NULL;\
198 }
199
200 struct cjprivate *cpriv;
201
202 if (cjinf == NULL)
203 return;
204 cpriv = cjinf->cji_priv;
205 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
206 syslog(LOG_ERR, "in ctl_freeinf(%p): invalid cjinf (cpriv %p)",
207 (void *)cjinf, (void *)cpriv);
208 return;
209 }
210
211 FREESTR(cpriv->pub.cji_accthost);
212 FREESTR(cpriv->pub.cji_acctuser);
213 FREESTR(cpriv->pub.cji_class);
214 FREESTR(cpriv->pub.cji_curqueue);
215 /* [cpriv->pub.cji_fname is part of cpriv-malloced area] */
216 FREESTR(cpriv->pub.cji_jobname);
217 FREESTR(cpriv->pub.cji_mailto);
218 FREESTR(cpriv->pub.cji_username);
219
220 if (cpriv->cji_fstream != NULL) {
221 fclose(cpriv->cji_fstream);
222 cpriv->cji_fstream = NULL;
223 }
224
225 cjinf->cji_priv = NULL;
226 free(cpriv);
227#undef FREESTR
228}
229
230#ifdef DEBUGREADCF_FNAME
231static FILE *ctl_dbgfile = NULL;
232static struct stat ctl_dbgstat;
233#endif
234static int ctl_dbgline = 0;
235
236struct cjobinfo *
237ctl_readcf(const char *ptrname, const char *cfname)
238{
239 int id;
240 char *lbuff;
241 void *cstart;
242 FILE *cfile;
243 struct cjprivate *cpriv;
244 struct cjobinfo *cjinf;
245 size_t msize, sroom, sroom2;
246
247 cfile = fopen(cfname, "r");
248 if (cfile == NULL) {
249 syslog(LOG_ERR, "%s: ctl_readcf error fopen(%s): %s",
250 ptrname, cfname, strerror(errno));
251 return NULL;
252 }
253
254 sroom = roundup(sizeof(struct cjprivate), 8);
255 sroom2 = sroom + strlen(cfname) + 1;
256 sroom2 = roundup(sroom2, 8);
257 msize = sroom2 + CTI_LINEMAX;
258 msize = roundup(msize, 8);
259 cstart = malloc(msize);
260 if (cstart == NULL)
261 return NULL;
262 memset(cstart, 0, msize);
263 cpriv = (struct cjprivate *)cstart;
264 cpriv->pub.cji_priv = cpriv;
265
266 cpriv->pub.cji_fname = (char *)cstart + sroom;
267 strcpy(cpriv->pub.cji_fname, cfname);
268 cpriv->cji_buff = (char *)cstart + sroom2;
269 cpriv->cji_buffsize = (int)(msize - sroom2);
270 cpriv->cji_eobuff = (char *)cstart + msize - 1;
271
272 cpriv->cji_fstream = cfile;
273 cpriv->pub.cji_curqueue = strdup(ptrname);
274
275 ctl_dbgline = 0;
276#ifdef DEBUGREADCF_FNAME
277 ctl_dbgfile = NULL;
278 id = stat(DEBUGREADCF_FNAME, &ctl_dbgstat);
279 if (id != -1) {
280 /* the file exists in this spool directory, write some simple
281 * debugging info to it */
282 ctl_dbgfile = fopen(DEBUGREADCF_FNAME, "a");
283 if (ctl_dbgfile != NULL) {
284 fprintf(ctl_dbgfile, "%s: s=%p r=%ld e=%p %p->%s\n",
285 ptrname, (void *)cpriv, (long)sroom,
286 cpriv->cji_eobuff, cpriv->pub.cji_fname,
287 cpriv->pub.cji_fname);
288 }
289 }
290#endif
291 /*
292 * Copy job-attribute values from control file to the struct of
293 * "public" information. In some cases, it is invalid for the
294 * value to be a null-string, so that is ignored.
295 */
296 cjinf = &(cpriv->pub);
297 lbuff = ctl_getline(cjinf);
298 while (lbuff != NULL) {
299 id = *lbuff++;
300 switch (id) {
301 case 'C':
302 cpriv->pub.cji_class = strdup(lbuff);
303 break;
304 case 'H':
305 if (*lbuff == '\0')
306 break;
307 cpriv->pub.cji_accthost = strdup(lbuff);
308 break;
309 case 'J':
310 cpriv->pub.cji_jobname = strdup(lbuff);
311 break;
312 case 'L':
313 cpriv->pub.cji_username = strdup(lbuff);
314 break;
315 case 'M':
316 /*
317 * No valid mail-to address would start with a minus.
318 * If this one does, it is probably some trickster who
319 * is trying to trigger options on sendmail. Ignore.
320 */
321 if (*lbuff == '-')
322 break;
323 if (*lbuff == '\0')
324 break;
325 cpriv->pub.cji_mailto = strdup(lbuff);
326 break;
327 case 'P':
328 /* don't allow userid's with a leading minus, either */
329 if (*lbuff == '-')
330 break;
331 if (*lbuff == '\0')
332 break;
333 cpriv->pub.cji_acctuser = strdup(lbuff);
334 break;
335 default:
336 if (islower(id)) {
337 cpriv->pub.cji_dfcount++;
338 }
339 break;
340 }
341 lbuff = ctl_getline(cjinf);
342 }
343
344 /* the 'H'ost and 'P'erson fields are *always* supposed to be there */
345 if (cpriv->pub.cji_accthost == NULL)
346 cpriv->pub.cji_accthost = strdup(".na.");
347 if (cpriv->pub.cji_acctuser == NULL)
348 cpriv->pub.cji_acctuser = strdup(".na.");
349
350#ifdef DEBUGREADCF_FNAME
351 if (ctl_dbgfile != NULL) {
352 if (cpriv->cji_dumpit)
353 ctl_dumpcji(ctl_dbgfile, "end readcf", &(cpriv->pub));
354 fclose(ctl_dbgfile);
355 ctl_dbgfile = NULL;
356 }
357#endif
358 return &(cpriv->pub);
359}
360
361/*
362 * This routine renames the temporary control file as received from some
363 * other (remote) host. That file will almost always with `tfA*', because
364 * recvjob.c creates the file by changing `c' to `t' in the original name
365 * for the control file. Now if you read the RFC, you would think that all
366 * control filenames start with `cfA*'. However, it seems there are some
367 * implementations which send control filenames which start with `cf'
368 * followed by *any* letter, so this routine can not assume what the third
369 * letter will (or will not) be. Sigh.
370 *
371 * So this will rewrite the temporary file to `rf*' (correcting any lines
372 * which need correcting), rename that `rf*' file to `cf*', and then remove
373 * the original `tf*' temporary file.
374 *
375 * The *main* purpose of this routine is to be paranoid about the contents
376 * of that control file. It is partially meant to protect against people
377 * TRYING to cause trouble (perhaps after breaking into root of some host
378 * that this host will accept print jobs from). The fact that we're willing
379 * to print jobs from some remote host does not mean that we should blindly
380 * do anything that host tells us to do.
381 *
382 * This is also meant to protect us from errors in other implementations of
383 * lpr, particularly since we may want to use some values from the control
384 * file as environment variables when it comes time to print, or as parameters
385 * to commands which will be exec'ed, or values in statistics records.
386 *
387 * This may also do some "conversions" between how different versions of
388 * lpr or lprNG define the contents of various lines in a control file.
389 *
390 * If there is an error, it returns a pointer to a descriptive error message.
391 * Error messages which are RETURNED (as opposed to syslog-ed) do not include
392 * the printer-queue name. Let the caller add that if it is wanted.
393 */
394char *
395ctl_renametf(const char *ptrname, const char *tfname)
396{
397 int chk3rd, newfd, nogood, res;
398 FILE *newcf;
399 struct cjobinfo *cjinf;
400 char *lbuff, *slash, *cp;
401 char tfname2[NAME_MAX+1], cfname2[NAME_MAX+1];
402 char errm[CTI_LINEMAX];
403
404#ifdef TRIGGERTEST_FNAME
405 struct stat tstat;
406 res = stat(TRIGGERTEST_FNAME, &tstat);
407 if (res == -1) {
408 /*
409 * if the trigger file does NOT exist in this spool directory,
410 * then do the exact same steps that the pre-ctlinfo code had
411 * been doing. Ie, very little.
412 */
413 strlcpy(cfname2, tfname, sizeof(cfname2));
414 cfname2[0] = 'c';
415 res = link(tfname, cfname2);
416 if (res < 0) {
417 snprintf(errm, sizeof(errm),
418 "ctl_renametf error link(%s,%s): %s", tfname,
419 cfname2, strerror(errno));
420 return strdup(errm);
421 }
422 unlink(tfname);
423 return NULL;
424 }
425#endif
426 cjinf = NULL; /* in case of early jump to error_ret */
427 newcf = NULL; /* in case of early jump to error_ret */
428 *errm = '\0'; /* in case of early jump to error_ret */
429
430 chk3rd = tfname[2];
431 if ((tfname[0] != 't') || (tfname[1] != 'f') || (!isalpha(chk3rd))) {
432 snprintf(errm, sizeof(errm),
433 "ctl_renametf invalid filename: %s", tfname);
434 goto error_ret;
435 }
436
437 cjinf = ctl_readcf(ptrname, tfname);
438 if (cjinf == NULL) {
439 snprintf(errm, sizeof(errm),
440 "ctl_renametf error cti_readcf(%s)", tfname);
441 goto error_ret;
442 }
443
444 /*
445 * This uses open+fdopen instead of fopen because that combination
446 * gives us greater control over file-creation issues.
447 */
448 strlcpy(tfname2, tfname, sizeof(tfname2));
449 tfname2[0] = 'r'; /* rf<letter><job><hostname> */
450 newfd = open(tfname2, O_WRONLY|O_CREAT|O_TRUNC, 0660);
451 if (newfd == -1) {
452 snprintf(errm, sizeof(errm),
453 "ctl_renametf error open(%s): %s", tfname2,
454 strerror(errno));
455 goto error_ret;
456 }
457 newcf = fdopen(newfd, "w");
458 if (newcf == NULL) {
459 close(newfd);
460 snprintf(errm, sizeof(errm),
461 "ctl_renametf error fopen(%s): %s", tfname2,
462 strerror(errno));
463 goto error_ret;
464 }
465
466 /*
467 * Do extra sanity checks on some key job-attribute fields, and
468 * write them out first (thus making sure they are written in the
469 * order we generally expect them to be in).
470 */
471 /*
472 * Some lpr implementations on PC's set a null-string for their
473 * hostname. A MacOS 10 system which has not correctly setup
474 * /etc/hostconfig will claim a hostname of 'localhost'. Anything
475 * with blanks in it would be an invalid value for hostname. For
476 * any of these invalid hostname values, replace the given value
477 * with the name of the host that this job is coming from.
478 */
479 nogood = 0;
480 if (cjinf->cji_accthost == NULL)
481 nogood = 1;
482 else if (strcmp(cjinf->cji_accthost, ".na.") == 0)
483 nogood = 1;
484 else if (strcmp(cjinf->cji_accthost, "localhost") == 0)
485 nogood = 1;
486 else {
487 for (cp = cjinf->cji_accthost; *cp != '\0'; cp++) {
488 if (*cp <= ' ') {
489 nogood = 1;
490 break;
491 }
492 }
493 }
494 if (nogood)
495 fprintf(newcf, "H%s\n", from_host);
496 else
497 fprintf(newcf, "H%s\n", cjinf->cji_accthost);
498
499 /*
500 * Now do some sanity checks on the 'P' (original userid) value. Note
501 * that the 'P'erson line is the second line which is ALWAYS supposed
502 * to be present in a control file.
503 *
504 * There is no particularly good value to use for replacements, but
505 * at least make sure the value is something reasonable to use in
506 * environment variables and statistics records. Again, some PC
507 * implementations send a null-string for a value. Various Mac
508 * implementations will set whatever string the user has set for
509 * their 'Owner Name', which usually includes blanks, etc.
510 */
511 nogood = 0;
512 if (cjinf->cji_acctuser == NULL)
513 nogood = 1;
514 else {
515 for (cp = cjinf->cji_acctuser; *cp != '\0'; cp++) {
516 if (*cp <= ' ')
517 *cp = '_';
518 }
519 }
520 if (nogood)
521 fprintf(newcf, "P%s\n", ".na.");
522 else
523 fprintf(newcf, "P%s\n", cjinf->cji_acctuser);
524
525 /* No need for sanity checks on class, jobname, "literal" user. */
526 if (cjinf->cji_class != NULL)
527 fprintf(newcf, "C%s\n", cjinf->cji_class);
528 if (cjinf->cji_jobname != NULL)
529 fprintf(newcf, "J%s\n", cjinf->cji_jobname);
530 if (cjinf->cji_username != NULL)
531 fprintf(newcf, "L%s\n", cjinf->cji_username);
532
533 /*
534 * This should probably add more sanity checks on mailto value.
535 * Note that if the mailto value is "wrong", then there's no good
536 * way to know what the "correct" value would be, and we should not
537 * semd email to some random address. At least for now, just ignore
538 * any invalid values.
539 */
540 nogood = 0;
541 if (cjinf->cji_mailto == NULL)
542 nogood = 1;
543 else {
544 for (cp = cjinf->cji_acctuser; *cp != '\0'; cp++) {
545 if (*cp <= ' ') {
546 nogood = 1;
547 break;
548 }
549 }
550 }
551 if (!nogood)
552 fprintf(newcf, "M%s\n", cjinf->cji_mailto);
553
554 /*
555 * Now go thru the old control file, copying all information which
556 * hasn't already been written into the new file.
557 */
558 ctl_rewindcf(cjinf);
559 lbuff = ctl_getline(cjinf);
560 while (lbuff != NULL) {
561 switch (lbuff[0]) {
562 case 'H':
563 case 'P':
564 case 'C':
565 case 'J':
566 case 'L':
567 case 'M':
568 /* already wrote values for these to the newcf */
569 break;
570 case 'N':
571 /* see comments under 'U'... */
572 if (cjinf->cji_dfcount == 0) {
573 /* in this case, 'N's will be done in 'U' */
574 break;
575 }
576 fprintf(newcf, "%s\n", lbuff);
577 break;
578 case 'U':
579 /*
580 * check for the very common case where the remote
581 * host had to process 'lpr -s -r', but it did not
582 * remove the Unlink line from the control file.
583 * Such Unlink lines will legitimately have a '/' in
584 * them, but it is the original lpr host which would
585 * have done the unlink of such files, and not any
586 * host receiving that job.
587 */
588 slash = strchr(lbuff, '/');
589 if (slash != NULL) {
590 break; /* skip this line */
591 }
592 /*
593 * Okay, another kind of broken lpr implementation
594 * is one which send datafiles, and Unlink's those
595 * datafiles, but never includes any PRINT request
596 * for those files. Experimentation shows that one
597 * copy of those datafiles should be printed with a
598 * format of 'f'. If this is an example of such a
599 * screwed-up control file, fix it here.
600 */
601 if (cjinf->cji_dfcount == 0) {
602 lbuff++;
603 if (strncmp(lbuff, "df", (size_t)2) == 0) {
604 fprintf(newcf, "f%s\n", lbuff);
605 fprintf(newcf, "U%s\n", lbuff);
606 fprintf(newcf, "N%s\n", lbuff);
607 }
608 break;
609 }
610 fprintf(newcf, "%s\n", lbuff);
611 break;
612 default:
613 fprintf(newcf, "%s\n", lbuff);
614 break;
615 }
616 lbuff = ctl_getline(cjinf);
617 }
618
619 ctl_freeinf(cjinf);
620 cjinf = NULL;
621
622 res = fclose(newcf);
623 newcf = NULL;
624 if (res != 0) {
625 snprintf(errm, sizeof(errm),
626 "ctl_renametf error fclose(%s): %s", tfname2,
627 strerror(errno));
628 goto error_ret;
629 }
630
631 strlcpy(cfname2, tfname, sizeof(cfname2));
632 cfname2[0] = 'c'; /* rename new file to 'cfA*' */
633 res = link(tfname2, cfname2);
634 if (res != 0) {
635 snprintf(errm, sizeof(errm),
636 "ctl_renametf error link(%s,%s): %s", tfname2, cfname2,
637 strerror(errno));
638 goto error_ret;
639 }
640
641 /* All the important work is done. Now just remove temp files */
642#ifdef LEAVE_TMPCF_FILES
643 {
644 struct stat tfstat;
645 size_t size1;
646 tfstat.st_size = 1; /* certainly invalid value */
647 res = stat(tfname, &tfstat);
648 size1 = tfstat.st_size;
649 tfstat.st_size = 2; /* certainly invalid value */
650 res = stat(tfname2, &tfstat);
651 /* if the sizes do not match, or either stat call failed,
652 * then do not remove the temp files, but return "all OK".
653 * This is just so I can see what this routine had changed.
654 */
655 if (size1 != tfstat.st_size)
656 return NULL;
657 }
658#endif
659 unlink(tfname);
660 unlink(tfname2);
661
662 return NULL;
663
664error_ret:
665 if (cjinf != NULL)
666 ctl_freeinf(cjinf);
667 if (newcf != NULL)
668 fclose(newcf);
669
670 if (*errm != '\0')
671 return strdup(errm);
672 return strdup("ctl_renametf internal (missed) error");
673}
674
675void
676ctl_rewindcf(struct cjobinfo *cjinf)
677{
678 struct cjprivate *cpriv;
679
680 if (cjinf == NULL)
681 return;
682 cpriv = cjinf->cji_priv;
683 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
684 syslog(LOG_ERR, "in ctl_rewindcf(%p): invalid cjinf (cpriv %p)",
685 (void *)cjinf, (void *)cpriv);
686 return;
687 }
688
689 rewind(cpriv->cji_fstream); /* assume no errors... :-) */
690}
691
692char *
693ctl_rmjob(const char *ptrname, const char *cfname)
694{
695 struct cjobinfo *cjinf;
696 char *lbuff;
697 char errm[CTI_LINEMAX];
698
699 cjinf = ctl_readcf(ptrname, cfname);
700 if (cjinf == NULL) {
701 snprintf(errm, sizeof(errm),
702 "ctl_renametf error cti_readcf(%s)", cfname);
703 return strdup(errm);
704 }
705
706 ctl_rewindcf(cjinf);
707 lbuff = ctl_getline(cjinf);
708 while (lbuff != NULL) {
709 /* obviously we need to fill in the following... */
710 switch (lbuff[0]) {
711 case 'S':
712 break;
713 case 'U':
714 break;
715 default:
716 break;
717 }
718 lbuff = ctl_getline(cjinf);
719 }
720
721 ctl_freeinf(cjinf);
722 cjinf = NULL;
723
724 return NULL;
725}
726
727/*
728 * The following routine was originally written to pin down a bug. It is
729 * no longer needed for that problem, but may be useful to keep around for
730 * other debugging.
731 */
732void
733ctl_dumpcji(FILE *dbg_stream, const char *heading, struct cjobinfo *cjinf)
734{
735#define PRINTSTR(xHdr,xStr) \
736 astr = xStr; \
737 ctl_dbgline++; \
738 fprintf(dbg_stream, "%4d] %12s = ", ctl_dbgline, xHdr); \
739 if (astr == NULL) \
740 fprintf(dbg_stream, "NULL\n"); \
741 else \
742 fprintf(dbg_stream, "%p -> %s\n", astr, astr)
743
744 struct cjprivate *cpriv;
745 char *astr;
746
747 if (cjinf == NULL) {
748 fprintf(dbg_stream,
749 "ctl_dumpcji: ptr to cjobinfo for '%s' is NULL\n",
750 heading);
751 return;
752 }
753 cpriv = cjinf->cji_priv;
754
755 fprintf(dbg_stream, "ctl_dumpcji: Dump '%s' of cjobinfo at %p->%p\n",
756 heading, (void *)cjinf, cpriv->cji_buff);
757
758 PRINTSTR("accthost.H", cpriv->pub.cji_accthost);
759 PRINTSTR("acctuser.P", cpriv->pub.cji_acctuser);
760 PRINTSTR("class.C", cpriv->pub.cji_class);
761 PRINTSTR("cf-qname", cpriv->pub.cji_curqueue);
762 PRINTSTR("cf-fname", cpriv->pub.cji_fname);
763 PRINTSTR("jobname.J", cpriv->pub.cji_jobname);
764 PRINTSTR("mailto.M", cpriv->pub.cji_mailto);
765 PRINTSTR("hdruser.L", cpriv->pub.cji_username);
766
767 ctl_dbgline++;
768 fprintf(dbg_stream, "%4d] %12s = ", ctl_dbgline, "*cjprivate");
769 if (cpriv->pub.cji_priv == NULL)
770 fprintf(dbg_stream, "NULL !!\n");
771 else
772 fprintf(dbg_stream, "%p\n", (void *)cpriv->pub.cji_priv);
773
774 fprintf(dbg_stream, "|- - - - --> Dump '%s' complete\n", heading);
775
776 /* flush output for the benefit of anyone doing a 'tail -f' */
777 fflush(dbg_stream);
778
779#undef PRINTSTR
780}
781
782/*
783 * This routine reads in the next line from the control-file, and removes
784 * the trailing newline character.
785 *
786 * Historical note: Earlier versions of this routine did tab-expansion for
787 * ALL lines read in, which did not make any sense for most of the lines
788 * in a control file. For the lines where tab-expansion is useful, it will
789 * now have to be done by the calling routine.
790 */
791static char *
792ctl_getline(struct cjobinfo *cjinf)
793{
794 char *strp, *nl;
795 struct cjprivate *cpriv;
796
797 if (cjinf == NULL)
798 return NULL;
799 cpriv = cjinf->cji_priv;
800 if ((cpriv == NULL) || (cpriv != cpriv->pub.cji_priv)) {
801 syslog(LOG_ERR, "in ctl_getline(%p): invalid cjinf (cpriv %p)",
802 (void *)cjinf, (void *)cpriv);
803 return NULL;
804 }
805
806 errno = 0;
807 strp = fgets(cpriv->cji_buff, cpriv->cji_buffsize, cpriv->cji_fstream);
808 if (strp == NULL) {
809 if (errno != 0)
810 syslog(LOG_ERR, "%s: ctl_getline error fgets(%s): %s",
811 cpriv->pub.cji_curqueue, cpriv->pub.cji_fname,
812 strerror(errno));
813 return NULL;
814 }
815 nl = strchr(strp, '\n');
816 if (nl != NULL)
817 *nl = '\0';
818
819#ifdef DEBUGREADCF_FNAME
820 /* I'd like to find out if the previous work to expand tabs was ever
821 * really used, and if so, on what lines and for what reason.
822 * Yes, all this work probably means I'm obsessed about this 'tab'
823 * issue, but isn't programming a matter of obsession?
824 */
825 {
826 int tabcnt;
827 char *ch;
828
829 tabcnt = 0;
830 ch = strp;
831 for (ch = strp; *ch != '\0'; ch++) {
832 if (*ch == '\t')
833 tabcnt++;
834 }
835
836 if (tabcnt && (ctl_dbgfile != NULL)) {
837 cpriv->cji_dumpit++;
838 fprintf(ctl_dbgfile, "%s: tabs=%d '%s'\n",
839 cpriv->pub.cji_fname, tabcnt, cpriv->cji_buff);
840 }
841 }
842#endif
843 return strp;
844}