Remove some !FreeBSD compat code, which produces warnings on DragonFly.
[dragonfly.git] / usr.sbin / lpr / common_source / ctlinfo.c
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  * ------+---------+---------+---------+---------+---------+---------+---------*
32  *
33  * $FreeBSD: src/usr.sbin/lpr/common_source/ctlinfo.c,v 1.1.2.6 2002/07/14 23:47:09 gad Exp $
34  * $DragonFly: src/usr.sbin/lpr/common_source/ctlinfo.c,v 1.3 2004/11/26 14:47:04 joerg Exp $
35  */
36
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
67 struct 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
88 extern const char       *from_host;     /* client's machine name */
89 extern const char       *from_ip;       /* client machine's IP address */
90
91 __BEGIN_DECLS
92 void             ctl_dumpcji(FILE *_dbg_stream, const char *_heading,
93                     struct cjobinfo *_cjinf);
94 static char     *ctl_getline(struct cjobinfo *_cjinf);
95 static void      ctl_rewindcf(struct cjobinfo *_cjinf);
96 char            *ctl_rmjob(const char *_ptrname, const char *_cfname);
97 __END_DECLS
98
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
191 void
192 ctl_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
231 static FILE *ctl_dbgfile = NULL;
232 static struct stat ctl_dbgstat;
233 #endif
234 static int ctl_dbgline = 0;
235
236 struct cjobinfo *
237 ctl_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  */
394 char *
395 ctl_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
664 error_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
675 void
676 ctl_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
692 char *
693 ctl_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  */
732 void
733 ctl_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  */
791 static char *
792 ctl_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 }