![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to download.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / post.src / download|
Return to download.c CVS log | Up to [Research Unix] / researchv10no / cmd / post.src / download |
1.1 root 1: /*
2: *
3: * download - host resident font downloader
4: *
5: * Prepends host resident fonts to PostScript input files. The program assumes
6: * the input files are part of a single PostScript job and that requested fonts
7: * can be downloaded at the start of each input file. Downloaded fonts are the
8: * ones named in a %%DocumentFonts: comment and listed in a special map table.
9: * Map table pathnames (supplied using the -m option) that begin with a / are
10: * taken as is. Otherwise the final pathname is built using *hostfontdir (-H
11: * option), *mapname (-m option), and *suffix.
12: *
13: * The map table consists of fontname-filename pairs, separated by white space.
14: * Comments are introduced by % (as in PostScript) and extend to the end of the
15: * current line. The only fonts that can be downloaded are the ones listed in
16: * the active map table that point the program to a readable Unix file. A request
17: * for an unlisted font or inaccessible file is ignored. All font requests are
18: * ignored if the map table can't be read. In that case the program simply copies
19: * the input files to stdout.
20: *
21: * An example (but not one to follow) of what can be in a map table is,
22: *
23: * %
24: * % Map requests for Bookman-Light to file *hostfontdir/KR
25: * %
26: *
27: * Bookman-Light KR % Keeping everything (including the map
28: * % table) in *hostfontdir seems like the
29: * % cleanest approach.
30: *
31: * %
32: * % Map Palatino-Roman to file *hostfontdir/palatino/Roman
33: * %
34: * Palatino-Roman palatino/Roman
35: *
36: * % Map ZapfDingbats to file /usr/lib/host/dingbats
37: *
38: * ZapfDingbats /usr/lib/host/dingbats
39: *
40: * Once again, file names that begin with a / are taken as is. All others have
41: * *hostfontdir/ prepended to the file string associated with a particular font.
42: *
43: * Map table can be associated with a printer model (e.g. a LaserWriter), a
44: * printer destination, or whatever - the choice is up to an administrator.
45: * By destination may be best if your spooler is running several private
46: * printers. Host resident fonts are usually purchased under a license that
47: * restricts their use to a limited number of printers. A font licensed for
48: * a single printer should only be used on that printer.
49: *
50: * Was written quickly, so there's much room for improvement. Undoubtedly should
51: * be a more general program (e.g. scan for other comments).
52: *
53: */
54:
55: #include <stdio.h>
56: #include <signal.h>
57: #include <fcntl.h>
58: #include <sys/types.h>
59: #include <sys/stat.h>
60:
61: #include "comments.h" /* PostScript file structuring comments */
62: #include "gen.h" /* general purpose definitions */
63: #include "path.h" /* for temporary directory */
64: #include "ext.h" /* external variable declarations */
65: #include "download.h" /* a few special definitions */
66:
67: char *temp_dir = TEMPDIR; /* temp directory - for copying stdin */
68: char *hostfontdir = HOSTDIR; /* host resident directory */
69: char *mapname = "map"; /* map table - usually in *hostfontdir */
70: char *suffix = ""; /* appended to the map table pathname */
71: Map *map = NULL; /* device font map table */
72: char *stringspace = NULL; /* for storing font and file strings */
73: int next = 0; /* next free slot in map[] */
74:
75: char *residentfonts = NULL; /* list of printer resident fonts */
76: char *printer = NULL; /* printer name - only for Unix 4.0 lp */
77:
78: char buf[2048]; /* input file line buffer */
79: char *comment = DOCUMENTFONTS; /* look for this comment */
80: int atend = FALSE; /* TRUE only if a comment says so */
81:
82: FILE *fp_in = stdin; /* next input file */
83: FILE *fp_temp = NULL; /* for copying stdin */
84:
85: /*****************************************************************************/
86:
87: main(agc, agv)
88:
89: int agc;
90: char *agv[];
91:
92: {
93:
94: /*
95: *
96: * Host resident font downloader. The input files are assumed to be part of a
97: * single PostScript job.
98: *
99: */
100:
101: argc = agc; /* other routines may want them */
102: argv = agv;
103:
104: prog_name = argv[0]; /* just for error messages */
105:
106: init_signals(); /* sets up interrupt handling */
107: options(); /* first get command line options */
108: readmap(); /* read the font map table */
109: readresident(); /* and the optional resident font list */
110: arguments(); /* then process non-option arguments */
111: done(); /* and clean things up */
112:
113: exit(x_stat); /* not much could be wrong */
114:
115: } /* End of main */
116:
117: /*****************************************************************************/
118:
119: init_signals()
120:
121: {
122:
123: /*
124: *
125: * Makes sure we handle interrupts properly.
126: *
127: */
128:
129: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
130: signal(SIGINT, SIG_IGN);
131: signal(SIGQUIT, SIG_IGN);
132: signal(SIGHUP, SIG_IGN);
133: } else {
134: signal(SIGHUP, interrupt);
135: signal(SIGQUIT, interrupt);
136: } /* End else */
137:
138: signal(SIGTERM, interrupt);
139:
140: } /* End of init_signals */
141:
142: /*****************************************************************************/
143:
144: options()
145:
146: {
147:
148: int ch; /* return value from getopt() */
149: char *optnames = "c:fm:p:r:H:T:DI";
150:
151: extern char *optarg; /* used by getopt() */
152: extern int optind;
153:
154: /*
155: *
156: * Reads and processes the command line options.
157: *
158: */
159:
160: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
161: switch ( ch ) {
162: case 'c': /* look for this comment */
163: comment = optarg;
164: break;
165:
166: case 'f': /* force a complete input file scan */
167: atend = TRUE;
168: break;
169:
170: case 'm': /* printer map table name */
171: mapname = optarg;
172: break;
173:
174: case 'p': /* printer name - for Unix 4.0 lp */
175: printer = optarg;
176: break;
177:
178: case 'r': /* resident font list */
179: residentfonts = optarg;
180: break;
181:
182: case 'H': /* host resident font directory */
183: hostfontdir = optarg;
184: break;
185:
186: case 'T': /* temporary file directory */
187: temp_dir = optarg;
188: break;
189:
190: case 'D': /* debug flag */
191: debug = ON;
192: break;
193:
194: case 'I': /* ignore FATAL errors */
195: ignore = ON;
196: break;
197:
198: case '?': /* don't understand the option */
199: error(FATAL, "");
200: break;
201:
202: default: /* don't know what to do for ch */
203: error(FATAL, "missing case for option %c\n", ch);
204: break;
205: } /* End switch */
206: } /* End while */
207:
208: argc -= optind; /* get ready for non-option args */
209: argv += optind;
210:
211: } /* End of options */
212:
213: /*****************************************************************************/
214:
215: readmap()
216:
217: {
218:
219: char *path;
220: char *ptr;
221: int fd;
222: struct stat sbuf;
223:
224: /*
225: *
226: * Initializes the map table by reading an ASCII mapping file. If mapname begins
227: * with a / it's the map table. Otherwise hostfontdir, mapname, and suffix are
228: * combined to build the final pathname. If we can open the file we read it all
229: * into memory, erase comments, and separate the font and file name pairs. When
230: * we leave next points to the next free slot in the map[] array. If it's zero
231: * nothing was in the file or we couldn't open it.
232: *
233: */
234:
235: if ( hostfontdir == NULL || mapname == NULL )
236: return;
237:
238: if ( *mapname != '/' ) {
239: if ( (path = malloc(strlen(hostfontdir) + strlen(mapname) +
240: strlen(suffix) + 2)) == NULL )
241: error(FATAL, "no memory");
242: sprintf(path, "%s/%s%s", hostfontdir, mapname, suffix);
243: } else path = mapname;
244:
245: if ( (fd = open(path, 0)) != -1 ) {
246: if ( fstat(fd, &sbuf) == -1 )
247: error(FATAL, "can't fstat %s", path);
248: if ( (stringspace = malloc(sbuf.st_size + 2)) == NULL )
249: error(FATAL, "no memory");
250: if ( read(fd, stringspace, sbuf.st_size) == -1 )
251: error(FATAL, "can't read %s", path);
252: close(fd);
253:
254: stringspace[sbuf.st_size] = '\n'; /* just to be safe */
255: stringspace[sbuf.st_size+1] = '\0';
256: for ( ptr = stringspace; *ptr != '\0'; ptr++ ) /* erase comments */
257: if ( *ptr == '%' )
258: for ( ; *ptr != '\n' ; ptr++ )
259: *ptr = ' ';
260:
261: for ( ptr = stringspace; ; next++ ) {
262: if ( (next % 50) == 0 )
263: map = allocate(map, next+50);
264: map[next].downloaded = FALSE;
265: map[next].font = strtok(ptr, " \t\n");
266: map[next].file = strtok(ptr = NULL, " \t\n");
267: if ( map[next].font == NULL )
268: break;
269: if ( map[next].file == NULL )
270: error(FATAL, "map table format error - check %s", path);
271: } /* End for */
272: } /* End if */
273:
274: } /* End of readmap */
275:
276: /*****************************************************************************/
277:
278: readresident()
279:
280: {
281:
282: FILE *fp;
283: char *path;
284: int ch;
285: int n;
286:
287: /*
288: *
289: * Reads a file that lists the resident fonts for a particular printer and marks
290: * each font as already downloaded. Nothing's done if the file can't be read or
291: * there's no mapping file. Comments, as in the map file, begin with a % and
292: * extend to the end of the line. Added for Unix 4.0 lp.
293: *
294: */
295:
296: if ( next == 0 || (printer == NULL && residentfonts == NULL) )
297: return;
298:
299: if ( printer != NULL ) { /* use Unix 4.0 lp pathnames */
300: sprintf(buf, "/etc/lp/printers/%s/residentfonts", printer);
301: path = buf;
302: } else path = residentfonts;
303:
304: if ( (fp = fopen(path, "r")) != NULL ) {
305: while ( fscanf(fp, "%s", buf) != EOF )
306: if ( buf[0] == '%' )
307: while ( (ch = getc(fp)) != EOF && ch != '\n' ) ;
308: else if ( (n = lookup(buf)) < next )
309: map[n].downloaded = TRUE;
310: fclose(fp);
311: } /* End if */
312:
313: } /* End of readresident */
314:
315: /*****************************************************************************/
316:
317: arguments()
318:
319: {
320:
321: /*
322: *
323: * Makes sure all the non-option command line arguments are processed. If we get
324: * here and there aren't any arguments left, or if '-' is one of the input files
325: * we'll translate stdin. Assumes input files are part of a single PostScript
326: * job and fonts can be downloaded at the start of each file.
327: *
328: */
329:
330: if ( argc < 1 )
331: download();
332: else {
333: while ( argc > 0 ) {
334: fp_temp = NULL;
335: if ( strcmp(*argv, "-") == 0 )
336: fp_in = stdin;
337: else if ( (fp_in = fopen(*argv, "r")) == NULL )
338: error(FATAL, "can't open %s", *argv);
339: download();
340: if ( fp_in != stdin )
341: fclose(fp_in);
342: if ( fp_temp != NULL )
343: fclose(fp_temp);
344: argc--;
345: argv++;
346: } /* End while */
347: } /* End else */
348:
349: } /* End of arguments */
350:
351: /*****************************************************************************/
352:
353: done()
354:
355: {
356:
357: /*
358: *
359: * Clean things up before we quit.
360: *
361: */
362:
363: if ( temp_file != NULL )
364: unlink(temp_file);
365:
366: } /* End of done */
367:
368: /*****************************************************************************/
369:
370: download()
371:
372: {
373:
374: int infontlist = FALSE;
375:
376: /*
377: *
378: * If next is zero the map table is empty and all we do is copy the input file
379: * to stdout. Otherwise we read the input file looking for %%DocumentFonts: or
380: * continuation comments, add any accessible fonts to the output file, and then
381: * append the input file. When reading stdin we append lines to fp_temp and
382: * recover them when we're ready to copy the input file. fp_temp will often
383: * only contain part of stdin - if there's no %%DocumentFonts: (atend) comment
384: * we stop reading fp_in after the header.
385: *
386: */
387:
388: if ( next > 0 ) {
389: if ( fp_in == stdin ) {
390: if ( (temp_file = tempnam(temp_dir, "post")) == NULL )
391: error(FATAL, "can't generate temp file name");
392: if ( (fp_temp = fopen(temp_file, "w+r")) == NULL )
393: error(FATAL, "can't open %s", temp_file);
394: unlink(temp_file);
395: temp_file = NULL;
396: } /* End if */
397:
398: while ( fgets(buf, sizeof(buf), fp_in) != NULL ) {
399: if ( fp_temp != NULL )
400: fprintf(fp_temp, "%s", buf);
401: if ( buf[0] != '%' || buf[1] != '%' ) {
402: if ( (buf[0] != '%' || buf[1] != '!') && atend == FALSE )
403: break;
404: infontlist = FALSE;
405: } else if ( strncmp(buf, comment, strlen(comment)) == 0 ) {
406: copyfonts(buf);
407: infontlist = TRUE;
408: } else if ( buf[2] == '+' && infontlist == TRUE )
409: copyfonts(buf);
410: else infontlist = FALSE;
411: } /* End while */
412: } /* End if */
413:
414: copyinput();
415:
416: } /* End of download */
417:
418: /*****************************************************************************/
419:
420: copyfonts(list)
421:
422: char *list;
423:
424: {
425:
426: char *font;
427: char *path;
428: int n;
429:
430: /*
431: *
432: * list points to a %%DocumentFonts: or continuation comment. What follows the
433: * the keyword will be a list of fonts separated by white space (or (atend)).
434: * Look for each font in the map table and if it's found copy the font file to
435: * stdout (once only).
436: *
437: */
438:
439: strtok(list, " \n"); /* skip to the font list */
440:
441: while ( (font = strtok(NULL, " \t\n")) != NULL ) {
442: if ( strcmp(font, ATEND) == 0 ) {
443: atend = TRUE;
444: break;
445: } /* End if */
446: if ( (n = lookup(font)) < next ) {
447: if ( *map[n].file != '/' ) {
448: if ( (path = malloc(strlen(hostfontdir)+strlen(map[n].file)+2)) == NULL )
449: error(FATAL, "no memory");
450: sprintf(path, "%s/%s", hostfontdir, map[n].file);
451: cat(path);
452: free(path);
453: } else cat(map[n].file);
454: map[n].downloaded = TRUE;
455: } /* End if */
456: } /* End while */
457:
458: } /* End of copyfonts */
459:
460: /*****************************************************************************/
461:
462: copyinput()
463:
464: {
465:
466: /*
467: *
468: * Copies the input file to stdout. If fp_temp isn't NULL seek to the start and
469: * add it to the output file - it's a partial (or complete) copy of stdin made
470: * by download(). Then copy fp_in, but only seek to the start if it's not stdin.
471: *
472: */
473:
474: if ( fp_temp != NULL ) {
475: fseek(fp_temp, 0L, 0);
476: while ( fgets(buf, sizeof(buf), fp_temp) != NULL )
477: printf("%s", buf);
478: } /* End if */
479:
480: if ( fp_in != stdin )
481: fseek(fp_in, 0L, 0);
482:
483: while ( fgets(buf, sizeof(buf), fp_in) != NULL )
484: printf("%s", buf);
485:
486: } /* End of copyinput */
487:
488: /*****************************************************************************/
489:
490: lookup(font)
491:
492: char *font;
493:
494: {
495:
496: int i;
497:
498: /*
499: *
500: * Looks for *font in the map table. Return the map table index if found and
501: * not yet downloaded - otherwise return next.
502: *
503: */
504:
505: for ( i = 0; i < next; i++ )
506: if ( strcmp(font, map[i].font) == 0 ) {
507: if ( map[i].downloaded == TRUE )
508: i = next;
509: break;
510: } /* End if */
511:
512: return(i);
513:
514: } /* End of lookup */
515:
516: /*****************************************************************************/
517:
518: Map *allocate(ptr, num)
519:
520: Map *ptr;
521: int num;
522:
523: {
524:
525: /*
526: *
527: * Allocates space for num Map elements. Calls malloc() if ptr is NULL and
528: * realloc() otherwise.
529: *
530: */
531:
532: if ( ptr == NULL )
533: ptr = (Map *)malloc(num * sizeof(Map));
534: else ptr = (Map *)realloc(ptr, num * sizeof(Map));
535:
536: if ( ptr == NULL )
537: error(FATAL, "no map memory");
538:
539: return(ptr);
540:
541: } /* End of allocate */
542:
543: /*****************************************************************************/
544:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.