source: trunk/athena/bin/lpr/lpr.c @ 12350

Revision 12350, 19.3 KB checked in by ghudson, 26 years ago (diff)
Some RCS ID cleanup: delete $Log$ and replace other RCS keywords with $Id$.
Line 
1#ifndef SERVER
2
3#define TMPDIR "/tmp"
4#include "lp.h"
5
6/*
7 * Error tokens
8 */
9#define REPRINT         -2
10#define ERROR           -1
11#define OK              0
12#define FATALERR        1
13#define NOACCT          2
14#define FILTERERR       3
15#define ACCESS          4
16#endif
17
18/*
19 *      $Id: lpr.c,v 1.20 1999-01-22 23:10:39 ghudson Exp $
20 */
21
22#ifndef lint
23static char *rcsid_lpr_c = "$Id: lpr.c,v 1.20 1999-01-22 23:10:39 ghudson Exp $";
24#endif lint
25
26/*
27 * Copyright (c) 1983 Regents of the University of California.
28 * All rights reserved.  The Berkeley software License Agreement
29 * specifies the terms and conditions for redistribution.
30 */
31
32#ifndef lint
33char copyright[] =
34"@(#) Copyright (c) 1983 Regents of the University of California.\n\
35 All rights reserved.\n";
36#endif not lint
37
38#ifndef lint
39static char sccsid[] = "@(#)lpr.c       5.2 (Berkeley) 11/17/85";
40#endif not lint
41
42/*
43 *      lpr -- off line print
44 *
45 * Allows multiple printers and printers on remote machines by
46 * using information from a printer data base.
47 */
48
49#include <stdio.h>
50#include <grp.h>
51#include <syslog.h>
52#include <sys/types.h>
53#ifdef SERVER
54#include <sys/file.h>
55#include <sys/stat.h>
56#include <pwd.h>
57#include <signal.h>
58#include <ctype.h>
59#include <netdb.h>
60#include <string.h>
61#include <stdlib.h>
62#include "lp.local.h"
63#endif SERVER
64#if defined(POSIX) && !defined(ultrix)
65#include "posix.h"
66#endif
67#include "nonposix.h"   
68#include <unistd.h>
69#define UNLINK unlink
70
71#ifndef SERVER
72char  *RG;                      /* Restricted group */
73       
74#else SERVER
75char    *tfname;                /* tmp copy of cf before linking */
76#endif SERVER
77char    *cfname;                /* daemon control files, linked from tf's */
78char    *dfname;                /* data files */
79
80int     nact;                   /* number of jobs to act on */
81#ifndef SERVER
82int     pfd;                    /* Printer file descriptor */
83#endif SERVER
84int     tfd;                    /* control file descriptor */
85int     mailflg;                /* send mail */
86int     qflag;                  /* q job, but don't exec daemon */
87char    format = 'f';           /* format char for printing files */
88int     rflag;                  /* remove files upon completion */     
89#ifdef SERVER
90int     sflag;                  /* symbolic link flag */
91#endif SERVER
92int     inchar;                 /* location to increment char in file names */
93int     ncopies = 1;            /* # of copies to make */
94int     iflag;                  /* indentation wanted */
95int     indent;                 /* amount to indent */
96int     noendpage;              /* file contains own form feeds */
97int     hdr = 1;                /* print header or not (default is yes) */
98int     userid;                 /* user id */
99char    *person;                /* user name */
100char    *title;                 /* pr'ing title */
101char    *fonts[4];              /* troff font names */
102char    *width;                 /* width for versatec printing */
103char    host[MAXHOSTNAMELEN + 1];               /* host name */
104char    *class = host;          /* class title on header page */
105char    *jobname;               /* job name on header page */
106char    *name;                  /* program name */
107char    *printer;               /* printer name */
108char    *forms;                 /* printer forms (for Multics) */
109char    *lpropt;                /* for lpropt env. variable */
110struct  stat statb;
111#ifdef HESIOD
112char    alibuf[BUFSIZ/2];       /* buffer for printer alias */
113#endif
114
115#ifdef KERBEROS
116int use_kerberos;
117int kerberos_override = -1;
118int account = 0;
119#endif KERBEROS
120
121#ifdef ZEPHYR
122int zephyrflag = 0;
123#endif ZEPHYR
124
125#ifdef SERVER
126int     MX;                     /* maximum number of blocks to copy */
127int     MC;                     /* maximum number of copies allowed */
128int     DU;                     /* daemon user-id */
129char    *SD;                    /* spool directory */
130char    *LO;                    /* lock file name */
131char    *RG;                    /* restrict group */
132short   SC;                     /* suppress multiple copies */
133
134#endif SERVER
135char    *getenv();
136char    *linked();
137void    cleanup();
138
139/*ARGSUSED*/
140main(argc, argv)
141        int argc;
142        char *argv[];
143{
144        extern struct passwd *getpwuid();
145        struct passwd *pw;
146        struct group *gptr;
147        extern char *itoa();
148        register char *arg, *cp;
149        char buf[BUFSIZ];
150
151#ifndef SERVER
152        int i, f, retry;
153#else SERVER
154        int i, f;
155        struct stat stb;
156#endif SERVER
157        struct hostent *hp;
158
159#ifndef SERVER
160        pfd = -1;               /* Printer isn't open yet */
161
162#endif SERVER
163        if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
164                signal(SIGHUP, cleanup);
165        if (signal(SIGINT, SIG_IGN) != SIG_IGN)
166                signal(SIGINT, cleanup);
167        if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
168                signal(SIGQUIT, cleanup);
169        if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
170                signal(SIGTERM, cleanup);
171
172        name = argv[0];
173        gethostname(host, sizeof (host));
174#ifndef SERVER
175        if (hp = gethostbyname(host))
176                (void) strcpy(host, hp -> h_name);
177#else SERVER
178        if (hp = gethostbyname(host)) strcpy(host, hp -> h_name);
179#endif SERVER
180#ifdef LOG_LPR
181        openlog("lpr", 0, LOG_LPR);
182#else
183        openlog("lpr", 0);
184#endif
185
186        /* Process LPROPT environment variable if it exists */
187        if((lpropt = getenv("LPROPT")) != NULL) {
188            char *lpropt1, **nargv;
189
190            /* Copy lpropt to permanent storage */
191            if(!(lpropt1 = malloc(strlen(lpropt)+1))) {
192                printf("%s: out of memory\n", name);
193                exit(1);
194            }
195            strcpy(lpropt1, lpropt);
196           
197            /* Count up spaces in lpropt1 - number of arguments */
198
199            for(i=1, cp = lpropt1; *cp != NULL; cp++) if(*cp == ' ') i++;
200
201            if(!(nargv = (char **) malloc(sizeof(char *) *(i + argc +1 )))) {
202                printf("%s: out of memory\n", name);
203                exit(1);
204            }
205
206            nargv[0] = argv[0];
207            for(f = 1, cp = lpropt1; f <= i; f++) {
208                nargv[f] = cp;
209                while((*cp != NULL) && (*cp != ' ')) cp++;
210                if(*cp == ' ') *cp = NULL, cp++;
211            }
212            for(f = i+1; f<= argc+i; f++)
213                nargv[f] = argv[f-i];
214            argv = nargv;
215            argc += i;
216        }
217
218/*      for(i = 0; i < argc; i++) printf("%d :%s:\n", i, argv[i]); */
219
220        while (argc > 1 && argv[1][0] == '-') {
221                argc--;
222                arg = *++argv;
223                switch (arg[1]) {
224
225                case 'P':               /* specify printer name */
226                        if (arg[2])
227                                printer = &arg[2];
228                        else if (argc > 1) {
229                                argc--;
230                                printer = *++argv;
231                        }
232                        break;
233
234                case 'C':               /* classification spec */
235                        hdr = 1;
236                        if (arg[2])
237                                class = &arg[2];
238                        else if (argc > 1) {
239                                argc--;
240                                class = *++argv;
241                        }
242                        break;
243
244                case 'J':               /* job name */
245                        hdr = 1;
246                        if (arg[2])
247                                jobname = &arg[2];
248                        else if (argc > 1) {
249                                argc--;
250                                jobname = *++argv;
251                        }
252                        break;
253
254                case 'T':               /* pr's title line */
255                        if (arg[2])
256                                title = &arg[2];
257                        else if (argc > 1) {
258                                argc--;
259                                title = *++argv;
260                        }
261                        break;
262
263                case 'p':               /* print using ``pr'' */
264                        if (arg[2]) {
265                                printf ("The -p option does not take an "
266                                        "argument, perhaps you meant -P.\n");
267                                exit(1);
268                        }
269                        /* Intentionally fall through to actually process -p. */
270                case 'l':               /* literal output */
271                case 't':               /* print troff output (cat files) */
272                case 'n':               /* print ditroff output */
273                case 'd':               /* print tex output (dvi files) */
274                case 'g':               /* print graph(1G) output */
275                case 'c':               /* print cifplot output */
276                case 'v':               /* print vplot output */
277                        format = arg[1];
278                        break;
279
280                case 'f':               /* print fortran output */
281                        format = 'r';
282                        break;
283
284                case '4':               /* troff fonts */
285                case '3':
286                case '2':
287                case '1':
288                        if (argc > 1) {
289                                argc--;
290                                fonts[arg[1] - '1'] = *++argv;
291                        }
292                        break;
293
294                case 'w':               /* versatec page width */
295                        width = arg+2;
296                        break;
297
298                case 'r':               /* remove file when done */
299                        rflag++;
300                        break;
301
302                case 'm':               /* send mail when done */
303                        mailflg++;
304                        break;
305
306#ifdef ZEPHYR
307                case 'z':
308                        zephyrflag++;
309                        break;
310#endif ZEPHYR
311
312                case 'h':               /* toggle want of header page */
313                        hdr = 0;
314                        break;
315
316#ifdef SERVER
317                case 's':               /* try to link files */
318                        sflag++;
319                        break;
320
321#endif SERVER
322                case 'q':               /* just q job */
323                        qflag++;
324                        break;
325
326                case 'i':               /* indent output */
327                        iflag++;
328                        indent = arg[2] ? atoi(&arg[2]) : 8;
329                        break;
330
331                case '#':               /* n copies */
332                        if (isdigit(arg[2])) {
333                                i = atoi(&arg[2]);
334                                if (i > 0)
335                                        ncopies = i;
336                        }
337                case 'E':
338                        noendpage++;    /* form feeds there already */
339                        break;  /* for multics */
340
341                case 'F':               /* printer forms */
342                        if (arg[2]) /* for multics */
343                                forms = &arg[2];
344                        else if (argc > 1) {
345                                argc--;
346                                forms = *++argv;
347                        }
348                        break;
349#ifdef KERBEROS
350                case 'u':
351                        kerberos_override = 0;
352                        break;
353                case 'k':
354                        kerberos_override = 1;
355                        break;
356                case 'a':
357                        if (isdigit(arg[2])) {
358                                i = atoi(&arg[2]);
359                                if (i > 0)
360                                        account = i;
361                        }
362                        break;
363#endif KERBEROS
364                }
365        }
366        if (printer == NULL && (printer = getenv("PRINTER")) == NULL)
367                printer = DEFLP;
368        chkprinter();
369        if (SC && ncopies > 1)
370                fatal("multiple copies are not allowed");
371        if (MC > 0 && ncopies > MC)
372                fatal("only %d copies are allowed", MC);
373        /*
374         * Get the identity of the person doing the lpr using the same
375         * algorithm as lprm.
376         */
377        userid = getuid();
378        if ((pw = getpwuid(userid)) == NULL)
379                fatal("Who are you?");
380        person = pw->pw_name;
381        /*
382         * Check for restricted group access.
383         */
384        if (RG != NULL) {
385                if ((gptr = getgrnam(RG)) == NULL)
386                        fatal("Restricted group specified incorrectly");
387                if (gptr->gr_gid != getgid()) {
388                        while (*gptr->gr_mem != NULL) {
389                                if ((strcmp(person, *gptr->gr_mem)) == 0)
390                                        break;
391                                gptr->gr_mem++;
392                        }
393                        if (*gptr->gr_mem == NULL)
394                                fatal("Not a member of the restricted group");
395                }
396        }
397#ifndef SERVER
398        openpr();
399        mktemps();
400        (void) setuid(userid);          /* Drop root privs */
401#else
402        /*
403         * Check to make sure queuing is enabled if userid is not root.
404         */
405        (void) sprintf(buf, "%s/%s", SD, LO);
406        if (userid && stat(buf, &stb) == 0 && (stb.st_mode & 010))
407                fatal("Printer queue is disabled");
408#endif SERVER
409        /*
410         * Initialize the control file.
411         */
412#ifndef SERVER
413        tfd = creat(cfname, FILMOD);
414#else SERVER
415        mktemps();
416        tfd = nfile(tfname);
417        (void) fchown(tfd, DU, -1);     /* owned by daemon for protection */
418#endif SERVER
419        card('H', host);
420        card('P', person);
421#ifdef KERBEROS
422        if (account)
423                card('Q', itoa(account));
424#endif KERBEROS
425        if (forms != NULL)
426                card('F', forms);
427        if (hdr) {
428                if (jobname == NULL) {
429                        if (argc == 1)
430                                jobname = "stdin";
431                        else
432                                jobname = (arg = strrchr(argv[1], '/')) ? arg+1 : argv[1];
433                }
434                card('J', jobname);
435                card('C', class);
436                card('L', person);
437        }
438        if (noendpage)
439                card('E', "");
440        if (iflag)
441                card('I', itoa(indent));
442        if (mailflg)
443                card('M', person);
444
445#ifdef ZEPHYR
446        if (zephyrflag)
447                card('Z', person);
448#endif ZEPHYR
449
450        if (format == 't' || format == 'n' || format == 'd')
451                for (i = 0; i < 4; i++)
452                        if (fonts[i] != NULL)
453                                card('1'+i, fonts[i]);
454        if (width != NULL)
455                card('W', width);       
456
457        /*
458         * Read the files and spool them.
459         */
460        if (argc == 1)
461                copy(0, " ");
462        else while (--argc) {
463                if ((f = test(arg = *++argv)) < 0)
464                        continue;       /* file unreasonable */
465
466#ifndef SERVER
467                if ((cp = linked(arg)) != NULL) {
468#else SERVER
469                if (sflag && (cp = linked(arg)) != NULL) {
470#endif SERVER
471                        (void) sprintf(buf, "%d %d", statb.st_dev, statb.st_ino);
472                        card('S', buf);
473                        if (format == 'p')
474                                card('T', title ? title : arg);
475                        for (i = 0; i < ncopies; i++)
476                                card(format, &dfname[inchar-2]);
477                        card('U', &dfname[inchar-2]);
478                        if (f)
479                                card('U', cp);
480                        card('N', arg);
481                        dfname[inchar]++;
482                        nact++;
483                        continue;
484                }
485#ifndef SERVER
486                printf("%s: %s: not linked, copying instead\n", name, arg);
487#else SERVER
488                if (sflag)
489                        printf("%s: %s: not linked, copying instead\n", name, arg);
490#endif SERVER
491                if ((i = open(arg, O_RDONLY)) < 0) {
492                        printf("%s: cannot open %s\n", name, arg);
493                        continue;
494                }
495                copy(i, arg);
496                (void) close(i);
497                if (f && UNLINK(arg) < 0)
498                        printf("%s: %s: not removed\n", name, arg);
499        }
500
501        if (nact) {
502                (void) close(tfd);
503#ifdef SERVER
504                tfname[inchar]--;
505                /*
506                 * Touch the control file to fix position in the queue.
507                 */
508                if ((tfd = open(tfname, O_RDWR)) >= 0) {
509                        char c;
510
511                        if (read(tfd, &c, 1) == 1 && lseek(tfd, 0L, 0) == 0 &&
512                            write(tfd, &c, 1) != 1) {
513                                printf("%s: cannot touch %s\n", name, tfname);
514                                tfname[inchar]++;
515                                cleanup();
516                        }
517                        (void) close(tfd);
518                }
519                if (link(tfname, cfname) < 0) {
520                        printf("%s: cannot rename %s\n", name, cfname);
521                        tfname[inchar]++;
522                        cleanup();
523                }
524                UNLINK(tfname);
525#endif SERVER
526                if (qflag)              /* just q things up */
527                        exit(0);
528#ifndef SERVER
529                retry=0;                /* Retry counter */
530                while (((i = sendit(&cfname[inchar-2])) == REPRINT) &&
531                       (retry<3))
532                        retry++;
533                if (i != OK) {
534                        fprintf(stderr,"I can't seem to be able to send ");
535                        fprintf(stderr,"your request to the printer.\n");
536                        fprintf(stderr,"Please try again later or try ");
537                        fprintf(stderr,"using another printer.\n");
538                        exit(1);
539                }
540#else SERVER
541                if (!startdaemon(printer))
542                        printf("jobs queued, but cannot start daemon.\n");
543#endif SERVER
544                exit(0);
545        }
546        cleanup();
547        /* NOTREACHED */
548}
549
550/*
551 * Create the file n and copy from file descriptor f.
552 */
553copy(f, n)
554        int f;
555        char n[];
556{
557        register int fd, i, nr, nc;
558        char buf[BUFSIZ];
559
560        if (format == 'p')
561                card('T', title ? title : n);
562        for (i = 0; i < ncopies; i++)
563                card(format, &dfname[inchar-2]);
564        card('U', &dfname[inchar-2]);
565        card('N', n);
566        fd = nfile(dfname);
567        nr = nc = 0;
568        while ((i = read(f, buf, BUFSIZ)) > 0) {
569                if (write(fd, buf, i) != i) {
570                        printf("%s: %s: temp file write error\n", name, n);
571                        break;
572                }
573                nc += i;
574                if (nc >= BUFSIZ) {
575                        nc -= BUFSIZ;
576                        nr++;
577                        if (MX > 0 && nr > MX) {
578                                printf("%s: %s: copy file is too large\n", name, n);
579                                break;
580                        }
581                }
582        }
583        (void) close(fd);
584        if (nc==0 && nr==0)
585                printf("%s: %s: empty input file\n", name, f ? n : "stdin");
586        else
587                nact++;
588}
589
590/*
591 * Try and link the file to dfname. Return a pointer to the full
592 * path name if successful.
593 */
594char *
595linked(file)
596        register char *file;
597{
598        register char *cp;
599        static char buf[BUFSIZ];
600
601        if (*file != '/') {
602                if (getcwd(buf, sizeof(buf)) == NULL)
603                        return(NULL);
604                while (file[0] == '.') {
605                        switch (file[1]) {
606                        case '/':
607                                file += 2;
608                                continue;
609                        case '.':
610                                if (file[2] == '/') {
611                                        if ((cp = strrchr(buf, '/')) != NULL)
612                                                *cp = '\0';
613                                        file += 3;
614                                        continue;
615                                }
616                        }
617                        break;
618                }
619                (void) strcat(buf, "/");
620                (void) strcat(buf, file);
621                file = buf;
622        }
623        return(symlink(file, dfname) ? NULL : file);
624}
625
626/*
627 * Put a line into the control file.
628 */
629card(c, p2)
630        register char c, *p2;
631{
632        char buf[BUFSIZ];
633        register char *p1 = buf;
634        register int len = 2;
635
636        *p1++ = c;
637        while ((c = *p2++) != '\0') {
638                *p1++ = c;
639                len++;
640        }
641        *p1++ = '\n';
642        write(tfd, buf, len);
643}
644
645/*
646 * Create a new file in the spool directory.
647 */
648nfile(n)
649        char *n;
650{
651        register int f;
652        int oldumask = umask(0);                /* should block signals */
653
654        f = creat(n, FILMOD);
655        (void) umask(oldumask);
656        if (f < 0) {
657                printf("%s: cannot create %s\n", name, n);
658                cleanup();
659        }
660#ifdef SERVER
661        if (fchown(f, userid, -1) < 0) {
662                printf("%s: cannot chown %s\n", name, n);
663                cleanup();
664        }
665#endif SERVER
666        if (++n[inchar] > 'z') {
667                if (++n[inchar-2] == 't') {
668                        printf("too many files - break up the job\n");
669                        cleanup();
670                }
671                n[inchar] = 'A';
672        } else if (n[inchar] == '[')
673                n[inchar] = 'a';
674        return(f);
675}
676
677/*
678 * Cleanup after interrupts and errors.
679 */
680void
681cleanup()
682{
683        register int i;
684
685        signal(SIGHUP, SIG_IGN);
686        signal(SIGINT, SIG_IGN);
687        signal(SIGQUIT, SIG_IGN);
688        signal(SIGTERM, SIG_IGN);
689        i = inchar;
690#ifdef SERVER
691        if (tfname)
692                do
693                        UNLINK(tfname);
694                while (tfname[i]-- != 'A');
695#endif SERVER
696        if (cfname)
697#ifdef SERVER
698                do {
699                        UNLINK(cfname);
700                } while (cfname[i]-- != 'A');
701#else
702                UNLINK(cfname);
703#endif SERVER
704        if (dfname)
705                do {
706                        do
707                                UNLINK(dfname);
708                        while (dfname[i]-- != 'A');
709                        dfname[i] = 'z';
710                } while (dfname[i-2]-- != 'd');
711#ifndef SERVER
712        if (pfd > 0)
713                (void) close(pfd);      /* Shutdown printer connection */
714#endif SERVER
715        exit(1);
716}
717
718/*
719 * Test to see if this is a printable file.
720 * Return -1 if it is not, 0 if its printable, and 1 if
721 * we should remove it after printing.
722 */
723test(file)
724        char *file;
725{
726        register int fd;
727        register char *cp;
728
729#ifdef SERVER
730        if (access(file, 4) < 0) {
731                printf("%s: cannot access %s\n", name, file);
732                return(-1);
733        }
734#endif SERVER
735        if (stat(file, &statb) < 0) {
736                printf("%s: cannot stat %s\n", name, file);
737                return(-1);
738        }
739#ifdef POSIX
740        if (S_ISDIR(statb.st_mode)) {
741#else
742        if ((statb.st_mode & S_IFMT) == S_IFDIR) {
743#endif
744                printf("%s: %s is a directory\n", name, file);
745                return(-1);
746        }
747        if (statb.st_size == 0) {
748                printf("%s: %s is an empty file\n", name, file);
749                return(-1);
750        }
751        if ((fd = open(file, O_RDONLY)) < 0) {
752                printf("%s: cannot open %s\n", name, file);
753                return(-1);
754        }
755
756        if (isexec (fd)) {
757          printf("%s: %s is an executable program\n", name, file);
758          goto error1;
759        }
760        (void) close(fd);
761        if (rflag) {
762                if ((cp = strrchr(file, '/')) == NULL) {
763                        if (access(".", 2) == 0)
764                                return(1);
765                } else {
766                        *cp = '\0';
767                        fd = access(file, 2);
768                        *cp = '/';
769                        if (fd == 0)
770                                return(1);
771                }
772                printf("%s: %s: is not removable by you\n", name, file);
773        }
774        return(0);
775
776error1:
777        printf(" and is unprintable\n");
778        (void) close(fd);
779        return(-1);
780}
781
782/*
783 * itoa - integer to string conversion
784 */
785char *
786itoa(i)
787        register int i;
788{
789        static char b[10] = "########";
790        register char *p;
791
792        p = &b[8];
793        do
794                *p-- = i%10 + '0';
795        while (i /= 10);
796        return(++p);
797}
798
799/*
800 * Get printcap entry for printer.
801 */
802chkprinter()
803{
804        int status;
805        char buf[BUFSIZ];
806        static char pbuf[BUFSIZ/2];
807        char *bp = pbuf;
808        extern char *pgetstr();
809
810#if defined(KERBEROS) && !defined(SERVER)
811        short KA;
812#endif /* KERBEROS */
813
814#ifdef HESIOD
815        if ((status = pgetent(buf, printer)) <= 0) {
816                if (pralias(alibuf, printer))
817                        printer = alibuf;
818                if ((status = hpgetent(buf, printer)) < 1)
819                        fatal("%s: unknown printer", printer);
820        }
821#else
822        if ((status = pgetent(buf, printer)) < 0)
823                fatal("cannot open printer description file");
824        else if (status == 0)
825                fatal("%s: unknown printer", printer);
826#endif HESIOD
827#ifdef SERVER
828        if ((SD = pgetstr("sd", &bp)) == NULL)
829                SD = DEFSPOOL;
830        if ((LO = pgetstr("lo", &bp)) == NULL)
831                LO = DEFLOCK;
832#endif SERVER
833        RG = pgetstr("rg", &bp);
834        if ((MX = pgetnum("mx")) < 0)
835                MX = DEFMX;
836        if ((MC = pgetnum("mc")) < 0)
837                MC = DEFMAXCOPIES;
838#ifdef SERVER
839        if ((DU = pgetnum("du")) < 0)
840                DU = DEFUID;
841#endif SERVER
842        SC = pgetflag("sc");
843#ifndef SERVER
844        if ((RM = pgetstr("rm",&bp)) == NULL)
845                RM = host;      /* If no remote machine name, assume */
846                                /* its local */
847        if ((RP = pgetstr("rp",&bp)) == NULL)
848                RP = printer;   /* Use same name if no remote printer */
849                                /* name */
850#ifdef KERBEROS
851        KA = pgetnum("ka");
852        if (KA > 0)
853            use_kerberos = 1;
854        else
855            use_kerberos = 0;
856        if (kerberos_override > -1)
857            use_kerberos = kerberos_override;
858#endif KERBEROS
859#endif SERVER
860}
861
862/*
863 * Make the temp files.
864 */
865mktemps()
866{
867#ifndef SERVER
868        register int len, fd, n;
869        register char *cp;
870#else SERVER
871        register int len, fd, n;
872        register char *cp;
873#endif SERVER
874        char buf[BUFSIZ];
875#ifndef SERVER
876        char *maketemp();
877#else SERVER
878        char *mktemp();
879#endif SERVER
880
881#ifndef SERVER
882        (void) sprintf(buf, "%s/.seq", TMPDIR);
883#else SERVER
884        (void) sprintf(buf, "%s/.seq", SD);
885#endif SERVER
886        if ((fd = open(buf, O_RDWR|O_CREAT, 0661)) < 0) {
887                printf("%s: cannot create %s\n", name, buf);
888#ifndef SERVER
889                cleanup();
890#else SERVER
891                exit(1);
892#endif SERVER
893        }
894        if (flock(fd, LOCK_EX)) {
895                printf("%s: cannot lock %s\n", name, buf);
896#ifndef SERVER
897                cleanup();
898#else SERVER
899                exit(1);
900#endif SERVER
901        }
902        n = 0;
903        if ((len = read(fd, buf, sizeof(buf))) > 0) {
904                for (cp = buf; len--; ) {
905                        if (*cp < '0' || *cp > '9')
906                                break;
907                        n = n * 10 + (*cp++ - '0');
908                }
909        }
910#ifndef SERVER
911        len = strlen(TMPDIR) + strlen(host) + 8;
912        cfname = maketemp("cf", n, len);
913        dfname = maketemp("df", n, len);
914        inchar = strlen(TMPDIR) + 3;
915#else SERVER
916        len = strlen(SD) + strlen(host) + 8;
917        tfname = mktemp("tf", n, len);
918        cfname = mktemp("cf", n, len);
919        dfname = mktemp("df", n, len);
920        inchar = strlen(SD) + 3;
921#endif SERVER
922        n = (n + 1) % 1000;
923        (void) lseek(fd, 0L, 0);
924        sprintf(buf, "%03d\n", n);
925        (void) write(fd, buf, strlen(buf));
926        (void) close(fd);       /* unlocks as well */
927}
928
929/*
930 * Make a temp file name.
931 */
932char *
933#ifndef SERVER
934maketemp(id, num, len)
935#else SERVER
936mktemp(id, num, len)
937#endif SERVER
938        char    *id;
939        int     num, len;
940{
941        register char *s;
942
943        if ((s = malloc(len)) == NULL)
944                fatal("out of memory");
945#ifndef SERVER
946        (void) sprintf(s, "%s/%sA%03d%s", TMPDIR, id, num, host);
947#else SERVER
948        (void) sprintf(s, "%s/%sA%03d%s", SD, id, num, host);
949#endif SERVER
950        return(s);
951}
Note: See TracBrowser for help on using the repository browser.