![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fontfile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / lib|
Return to fontfile.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / lib |
1.1 root 1: /******************************* MODULE HEADER ******************************
2: * fontfile.c
3: * Functions associated with generating the combined font file
4: * used with NT printer drivers. This handles the mechanics of
5: * creating/adding/deleting data in the file. No attempt is made
6: * to understand the contents of the file. That is left to
7: * individual drivers.
8: *
9: * Copyright (C) 1992 - 1993 Microsoft Corportation.
10: *
11: *****************************************************************************/
12:
13:
14: #include <stddef.h>
15: #include <windows.h>
16:
17: #include "fontfile.h" /* File layout details */
18: #include "fontgen.h" /* Globally visible components */
19: #include "libproto.h" /* bWrite() proto */
20:
21:
22:
23: /*
24: * Local functions.
25: */
26:
27:
28: BOOL bGetFileHDR( HANDLE, FF_HEADER * );
29: BOOL bGetRecHDR( HANDLE, FF_REC_HEADER *, DWORD );
30: BOOL bFixInit( HANDLE ); /* Initialise new Fixed file */
31: void vFIClean( FID * ); /* Clean up any mess */
32: BOOL bDelList( FID *, int * ); /* Delete fonts in current set */
33: BOOL bAddFList( FID *, FONTLIST * ); /* Add new fonts to existing */
34:
35:
36:
37:
38: /******************************* Function Header ****************************
39: * pFIOpen()
40: * Function to initialize the internal operations for the font installer
41: * single font file building operations. The value returned is passed
42: * to other functions here, giving them access to the data required
43: * to complete their tasks.
44: *
45: * RETURNS:
46: * Pointer to private data, cast as a (void *); 0 on error.
47: *
48: * HISTORY:
49: * 09:49 on Mon 24 Feb 1992 -by- Lindsay Harris [lindsayh]
50: * Starting work on it.
51: *
52: ****************************************************************************/
53:
54: FID *
55: pFIOpen( pwstrDataFile, hHeap )
56: PWSTR pwstrDataFile; /* Driver's data file name */
57: HANDLE hHeap; /* Heap access */
58: {
59:
60: FID *pFID; /* For our convenience */
61: PWSTR pwstr; /* For file name manipulation */
62:
63: int iPtOff; /* Location of . in file name */
64: int iSize; /* Determine the size of things */
65:
66:
67: /*
68: * Firstly allocate a FID structure from the heap. We cannot use
69: * a stack version as it needs to be persistent.
70: */
71:
72: if( !(pFID = (FID *)HeapAlloc( hHeap, 0, sizeof( FID ) )) )
73: {
74: #if DBG
75: DbgPrint( "Print!pvFIOpen: HeapAlloc( FID ) fails!\n" );
76: #endif
77:
78: return 0; /* Bad news */
79: }
80:
81: memset( pFID, 0, sizeof( FID ) ); /* Easier clean up */
82:
83: pFID->hHeap = hHeap; /* Keep it for later! */
84: pFID->dwID = FID_ID; /* Make sure we get our own back! */
85:
86: /*
87: * We want to generate some file names, so determine the
88: * length of the input name, and allocate that much storage
89: * for it. We do not know what format the name is, so allow
90: * room at the end to add ".fi_": 5 WCHARs including the null.
91: */
92:
93: iSize = (wcslen( pwstrDataFile ) + 5) * sizeof( WCHAR );
94:
95: if( !(pFID->pwstrCurName = (PWSTR)HeapAlloc( hHeap, 0, iSize )) ||
96: !(pFID->pwstrFixName = (PWSTR)HeapAlloc( hHeap, 0, iSize )) ||
97: !(pFID->pwstrVarName = (PWSTR)HeapAlloc( hHeap, 0, iSize )) )
98: {
99:
100: #if DBG
101: DbgPrint( "Print!pvFIOpen: HeapAlloc( pwstrDataFile ) fails!\n" );
102: #endif
103: vFIClean( pFID );
104:
105: return 0;
106: }
107: pwstr = pFID->pwstrCurName; /* For stuffing around */
108:
109: wcscpy( pFID->pwstrCurName, pwstrDataFile ); /* Working copies */
110: wcscpy( pFID->pwstrFixName, pwstrDataFile );
111: wcscpy( pFID->pwstrVarName, pwstrDataFile );
112:
113:
114: /* Scan from RHS looking for '.': PRESUME THERE IS ONE! */
115: iPtOff = wcslen( pwstr );
116:
117: while( --iPtOff > 0 )
118: {
119: if( *(pwstr + iPtOff) == (WCHAR)'.' )
120: break;
121: }
122:
123: if( iPtOff <= 0 )
124: {
125: iPtOff = wcslen( pwstr ); /* Presume none! */
126: *(pwstr + iPtOff) = L'.';
127: }
128: ++iPtOff; /* Skip the period */
129:
130:
131:
132: /* Generate all 3 names & open the existing file */
133: wcscpy( pFID->pwstrCurName + iPtOff, FILE_FONTS );
134: wcscpy( pFID->pwstrFixName + iPtOff, TFILE_FIX );
135: wcscpy( pFID->pwstrVarName + iPtOff, TFILE_VAR );
136:
137:
138: pFID->hCurFile = CreateFileW( pFID->pwstrCurName, GENERIC_READ,
139: FILE_SHARE_READ,
140: NULL, OPEN_EXISTING, 0, 0 );
141:
142: /*
143: * Repeat for the two new files: note that we want to create these,
144: * truncate any existing file, and allow no other access to them
145: * while we are manipulating them. They should be invisible.
146: */
147:
148:
149: pFID->hFixFile = CreateFileW( pFID->pwstrFixName,
150: GENERIC_READ | GENERIC_WRITE, 0, NULL,
151: CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
152: pFID->hCurFile );
153:
154: if( pFID->hFixFile == INVALID_HANDLE_VALUE )
155: {
156: /* Bad news */
157: #if DBG
158: DbgPrint( "Print!bFIOpen: Fixed file initialisation failure\n" );
159: #endif
160:
161:
162: vFIClean( pFID );
163:
164: return 0;
165: }
166:
167:
168: pFID->hVarFile = CreateFileW( pFID->pwstrVarName,
169: GENERIC_READ | GENERIC_WRITE, 0, NULL,
170: CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
171: pFID->hCurFile );
172:
173: if( pFID->hVarFile == INVALID_HANDLE_VALUE )
174: {
175: #if DBG
176: DbgPrint( "Print!bFIOpen: Var file creation failure\n" );
177: #endif
178:
179:
180: vFIClean( pFID );
181:
182: return 0;
183: }
184:
185: return pFID;
186: }
187:
188: /****************************** Function Header *****************************
189: * bFIClose
190: * Close up operations on the font installer file. This involves
191: * amalgamating the Fix and Var files, updating the overall header
192: * and renaming the file after deleting the old one.
193: *
194: * RETURNS:
195: * TRUE/FALSE - FALSE if any operation fails.
196: *
197: * HISTORY:
198: * 15:01 on Mon 24 Feb 1992 -by- Lindsay Harris [lindsayh]
199: * Gotta start somewhere
200: *
201: ***************************************************************************/
202:
203: BOOL
204: bFIClose( pFID, bUpdate )
205: FID *pFID; /* The file collection to close */
206: BOOL bUpdate; /* True to make new file THE file */
207: {
208:
209: long lSize; /* Bytes copied from variable file */
210:
211:
212: FF_HEADER ffh; /* The overall file header */
213:
214:
215:
216: if( pFID->dwID != FID_ID )
217: {
218: #if DBG
219: DbgPrint( "Print!bFIClose(): invalid pFID" );
220: #endif
221:
222: return FALSE;
223: }
224:
225:
226: /*
227: * If bUpdate, then reorganise the files: the existing file is
228: * removed, the Var file is appended to the Fix file, and that
229: * composite file is made the new "existing" file.
230: */
231:
232:
233: if( !bUpdate )
234: {
235: /* No updating is to be done */
236: vFIClean( pFID ); /* Does all the dirty work */
237:
238: return TRUE; /* By definition */
239: }
240:
241: /*
242: * Update is ON! First read the header from the fixed file, then
243: * fill in the missing details. This amounts to the location of
244: * the start of the variable length data in the file.
245: */
246:
247: if( !bGetFileHDR( pFID->hFixFile, &ffh ) )
248: {
249: vFIClean( pFID );
250:
251: return FALSE;
252: }
253:
254: /*
255: * Need to know the size of the fixed file to put in the header.
256: */
257:
258: lSize = (long)SetFilePointer( pFID->hFixFile, 0, NULL, FILE_END );
259:
260: lSize = (lSize + 3) & ~0x3; /* DWORD multiple */
261:
262: ffh.ulVarData = lSize;
263:
264: SetFilePointer( pFID->hFixFile, lSize, NULL, FILE_BEGIN );
265: SetFilePointer( pFID->hVarFile, 0, NULL, FILE_BEGIN );
266:
267: ffh.ulVarSize = lSize = lFICopy( pFID->hFixFile, pFID->hVarFile );
268: if( lSize < 0 )
269: {
270: /* Some sort of error */
271: vFIClean( pFID );
272:
273: return FALSE;
274: }
275:
276: if( lSize == 0 )
277: ffh.ulVarData = 0; /* NONE! */
278:
279: /*
280: * Now write the header back out.
281: */
282:
283: SetFilePointer( pFID->hFixFile, 0, NULL, FILE_BEGIN );
284: if( !bWrite( pFID->hFixFile, &ffh, sizeof( ffh ) ) )
285: {
286: /* Too bad: throw it all away. */
287: vFIClean( pFID );
288:
289: return FALSE;
290: }
291:
292: /*
293: * No longer need the file handles, so close them, and set
294: * the values to illegal so that we will not try to free them later.
295: * We can also delete the variable part of the file, since that
296: * is now appended to the end of the fixed file.
297: */
298:
299: CloseHandle( pFID->hFixFile ); /* No longer needed */
300: pFID->hFixFile = INVALID_HANDLE_VALUE; /* Won't be cleaned up */
301:
302: CloseHandle( pFID->hVarFile ); /* No longer need this file */
303: pFID->hVarFile = INVALID_HANDLE_VALUE; /* Won't be cleaned up */
304:
305:
306: DeleteFileW( pFID->pwstrVarName );
307:
308:
309: /*
310: * Now delete the existing file and rename the Fix file to the
311: * proper name!
312: */
313:
314:
315: if( pFID->hCurFile != INVALID_HANDLE_VALUE )
316: {
317: /* Have a current file, so delete it, close our handle */
318: CloseHandle( pFID->hCurFile );
319: pFID->hCurFile = INVALID_HANDLE_VALUE; /* Is now */
320:
321: if( !DeleteFileW( pFID->pwstrCurName ) )
322: {
323: vFIClean( pFID );
324:
325: return FALSE;
326: }
327: }
328:
329: /* RENAME */
330: if( !MoveFileW( pFID->pwstrFixName, pFID->pwstrCurName ) )
331: {
332: /* BAD NEWS: we have lost the lot! */
333:
334: vFIClean( pFID );
335:
336: return FALSE;
337: }
338:
339: /*
340: * Clean up whatever is left.
341: */
342:
343: vFIClean( pFID );
344:
345:
346: return TRUE;
347: }
348:
349: /******************************** Function Header ***************************
350: * bFIUpdate
351: * Called to integrate changes to the font file. Caller may delete
352: * existing fonts and/or add new ones. The deleted fonts are
353: * passed as an array of integers, each being an index into the
354: * existing fonts. The first is a count of the number of
355: * index values following; then comes the zero based index value.
356: * New fonts are passed as a linked list of type FONTLIST.
357: * NOTE: The master font file is NOT updated by this call.
358: *
359: * RETURNS:
360: * TRUE/FALSE; FALSE leaves no permanent changes.
361: *
362: * HISOTRY:
363: * 12:59 on Tue 25 Feb 1992 -by- Lindsay Harris [lindsayh]
364: * First version.
365: *
366: ****************************************************************************/
367:
368: BOOL
369: bFIUpdate( pFID, piDel, pFList )
370: FID *pFID; /* Access to our data */
371: int *piDel; /* Array of fonts to delete */
372: FONTLIST *pFList; /* Fonts to add */
373: {
374:
375: /*
376: * Not much to do! First step is to copy the fixed part of the
377: * file to our new fixed file, deleting fonts as we go. This also
378: * splits off the variable portion. Then add whatever new fonts are
379: * to be added. We do not amalgamate the file: that is done at
380: * bFIClose() time, giving the caller the chance to abort the whole
381: * operation.
382: */
383:
384: if( pFID->dwID != FID_ID )
385: {
386: #if DBG
387: DbgPrint( "Print!bFIUpdate: pFID is invalid" );
388: #endif
389:
390: return FALSE;
391: }
392:
393:
394: if( !bDelList( pFID, piDel ) )
395: return FALSE;
396:
397: if( !bAddFList( pFID, pFList ) )
398: return FALSE;
399:
400: return TRUE; /* Made it AOK */
401: }
402:
403:
404: /****************************** Function Header ******************************
405: * bDelList
406: * Delete the nominated fonts from the master font file. DOES NOT UPDATE
407: * THE MASTER FILE. The fonts are nominated by as an array of ints,
408: * the first of which is a count of the number of ints following.
409: * These values are zero based and represent the number of the font
410: * in sequence in the file.
411: *
412: * RETURNS:
413: * TRUE/FALSE
414: *
415: * HISTORY:
416: * 13:02 on Tue 25 Feb 1992 -by- Lindsay Harris [lindsayh]
417: * First version to do something.
418: *
419: *****************************************************************************/
420:
421: BOOL
422: bDelList( pFID, piDel )
423: FID *pFID; /* Access to our stuff */
424: int *piDel; /* A -1 terminated array of font indices to delete */
425: {
426:
427:
428: ULONG ulRec; /* Loop through the records */
429: DWORD dwHdrPosn; /* Position within the file */
430: DWORD dwFixPosn; /* Write position in fixed file */
431: DWORD dwVarPosn; /* Absolute position within variable part */
432: int iDelLeft; /* Number of deletion choices left */
433: int iSkip; /* Number we have dropped */
434:
435: BOOL bDelete; /* True if this font to be deleted */
436:
437:
438: FF_HEADER ffh; /* Contains sizes! */
439: FF_REC_HEADER ffrh;
440:
441: /*
442: * Do we have any to delete?
443: */
444:
445:
446: if( pFID->hCurFile == INVALID_HANDLE_VALUE )
447: {
448: /* NO existing file, so create a new empty one! */
449:
450: return bFixInit( pFID->hFixFile );
451: }
452:
453: if( !bGetFileHDR( pFID->hCurFile, &ffh ) )
454: return FALSE;
455:
456: if( piDel == NULL || *piDel <= 0 )
457: {
458: /* Just split the master file into two: fixed and variable parts */
459:
460: LONG lSize;
461:
462:
463: SetFilePointer( pFID->hCurFile, 0, NULL, FILE_BEGIN );
464:
465: lSize = sizeof( ffh ) + ffh.ulFixSize;
466:
467: if( lFInCopy( pFID->hFixFile, pFID->hCurFile, lSize ) != lSize ||
468: lFInCopy( pFID->hVarFile, pFID->hCurFile, ffh.ulVarSize ) !=
469: (long)ffh.ulVarSize )
470: {
471: #if DBG
472: DbgPrint( "Print!bDelList: file split fails\n" );
473: #endif
474:
475: return FALSE;
476: }
477:
478: return TRUE;
479: }
480:
481: /*
482: * Another speed up case is the other version: deleting all fonts!
483: */
484:
485: if( *piDel >= (int)ffh.ulRecCount )
486: {
487: /* Simply create an empty file */
488:
489: return bFixInit( pFID->hFixFile );
490: }
491:
492: /*
493: * Now determine which fonts to delete. We do this the easy (but
494: * slower) way, namely to process each record individually. We
495: * read the header, determine whether to delete, and if not, then
496: * copy the relevant portions to the output files.
497: */
498:
499: dwHdrPosn = ffh.ulFixData; /* Initial location */
500: dwFixPosn = ffh.ulFixData; /* Writing location in fixed file */
501: dwVarPosn = ffh.ulVarData; /* Starting location in variable */
502: iSkip = 0; /* Count number we drop off */
503: iDelLeft = *piDel; /* Number to delete */
504: ffh.ulFixSize = 0; /* Count it as we copy */
505:
506: for( ulRec = 0; ulRec < ffh.ulRecCount; ++ulRec )
507: {
508:
509: /* First read the header to read the record size */
510:
511: if( !bGetRecHDR( pFID->hCurFile, &ffrh, dwHdrPosn ) )
512: return FALSE; /* SHOULD NOT HAPPEN */
513:
514: if( ffrh.ulNextOff == 0 )
515: {
516: #if DBG
517: DbgPrint( "Print!bDelList: unexpected EOF record at #%ld\n",
518: ulRec );
519: #endif
520:
521: break;
522: }
523: /*
524: * Is this on the delete list??
525: */
526:
527: bDelete = FALSE; /* Assume not */
528:
529: if( iDelLeft > 0 )
530: {
531: /* Scan the list, looking for this index */
532: int iI;
533:
534: for( iI = 1; !bDelete && iI <= *piDel; ++iI )
535: {
536: if( *(piDel + iI) == (int)ulRec )
537: {
538: bDelete = TRUE;
539: --iDelLeft;
540: }
541: }
542: }
543:
544: if( bDelete )
545: {
546: /* Skip this one, so adjust offsets & counts. */
547: iSkip++; /* Reduce count at the end. */
548: }
549: else
550: {
551: /*
552: * First step is to copy the variable part. This is done
553: * first as we need to update the data position within the
554: * header record for the fixed part. So copy now to find
555: * out where it is being placed.
556: */
557:
558: dwVarPosn = ffh.ulVarData + ffrh.ulVarOff; /* Current file posn */
559:
560: if( ffrh.ulVarSize )
561: {
562: /*
563: * Data exists, so set file pointers. There are two to
564: * set. One is to position the variable data at the dword
565: * aligned end of the variable file, the other is to
566: * set the position of the current file pointer to the
567: * correct location in that file.
568: */
569:
570: /* First the new variable file */
571:
572: ffrh.ulVarOff = (GetFileSize( pFID->hVarFile, NULL ) +3) & ~0x3;
573: SetFilePointer( pFID->hVarFile, ffrh.ulVarOff, NULL,
574: FILE_BEGIN );
575:
576: /* The current file's variable data */
577:
578: SetFilePointer( pFID->hCurFile, dwVarPosn, NULL, FILE_BEGIN );
579:
580: if( lFInCopy( pFID->hVarFile, pFID->hCurFile, ffrh.ulVarSize )
581: != (long)ffrh.ulVarSize )
582: {
583: #if DBG
584: DbgPrint(
585: "Print!bDelList: Write of variable data fails, rec #%ld\n",
586: ulRec );
587: #endif
588:
589: return FALSE;
590: }
591: }
592:
593: /*
594: * Set the fixed file pointer. First time this will skip
595: * the file header we write out at the end. Second and later
596: * times, it will ensure DWORD alignment of the header.
597: */
598:
599:
600: SetFilePointer( pFID->hCurFile, dwHdrPosn + sizeof( ffrh),
601: NULL, FILE_BEGIN );
602: SetFilePointer( pFID->hFixFile, dwFixPosn, NULL, FILE_BEGIN );
603:
604: if( !bWrite( pFID->hFixFile, &ffrh, sizeof( ffrh ) ) )
605: {
606: #if DBG
607: DbgPrint( "Print!bDelList: bWrite of new header, rec %ld\n",
608: ulRec );
609: #endif
610:
611: return FALSE;
612: }
613:
614: /* And also the actual data part! */
615:
616: if( lFInCopy( pFID->hFixFile, pFID->hCurFile, ffrh.ulSize ) !=
617: (long)ffrh.ulSize )
618: {
619: #if DBG
620: DbgPrint(
621: "Print!bDelList: Can't copy FIX part of file at rec #%ld\n",
622: ulRec );
623: #endif
624:
625: return FALSE;
626: }
627: dwFixPosn += ffrh.ulNextOff; /* Next location */
628: ffh.ulFixSize += sizeof( ffrh ) + ffrh.ulSize;
629:
630: }
631: dwHdrPosn += ffrh.ulNextOff;
632: }
633:
634: /*
635: * Need to write the trailing header to our file. This contains
636: * a zero size, so that is really all that is important.
637: */
638:
639: ffrh.ulNextOff = 0;
640:
641: if( !bWrite( pFID->hFixFile, &ffrh, sizeof( ffrh ) ) )
642: return FALSE;
643:
644: ffh.ulRecCount -= iSkip; /* The number we dropped! */
645:
646: /*
647: * Rewrite the header record for the adding code.
648: */
649:
650: SetFilePointer( pFID->hFixFile, 0, NULL, FILE_BEGIN );
651:
652: return bWrite( pFID->hFixFile, &ffh, sizeof( ffh ) );
653: }
654:
655: /****************************** Function Header ******************************
656: * bAddFList
657: * Add a list of new fonts to an existing font file. This is
658: * called to add the data to our existing file. File creation or
659: * shrinking is done elsewhere.
660: *
661: * RETURNS:
662: * Number of bytes written to the file; -1 for error.
663: *
664: * HISTORY:
665: * 14:20 on Sat 22 Feb 1992 -by- Lindsay Harris [lindsayh]
666: * Started working on it.
667: *
668: *****************************************************************************/
669:
670: BOOL
671: bAddFList( pFID, pFList )
672: FID *pFID; /* Font installation data */
673: FONTLIST *pFList; /* The fonts to be added */
674: {
675:
676: DWORD dwLoc; /* File location of interest */
677: DWORD dwVarLoc; /* Location in the variable data part */
678: int iSize; /* Number of bytes written by user */
679: int iVarSize; /* Size of variable length portion */
680:
681:
682: FF_HEADER ffh; /* The overall file header */
683: FF_REC_HEADER ffrh; /* Per record header */
684:
685:
686: if( pFList == NULL )
687: return TRUE; /* No data, no processing! */
688:
689: /*
690: * First step is to step through the file, down the chain of
691: * records until we reach the end. We append the data there: the
692: * data consists of a record header plus whatever data the user
693: * writes and tells us about. We also allow the user the option
694: * of adding data to variable length part of the file.
695: */
696:
697: if( !bGetFileHDR( pFID->hFixFile, &ffh ) )
698: return FALSE;
699:
700:
701: /* Can now read the file header - it WILL exist! */
702: dwLoc = ffh.ulFixData;
703:
704: while( bGetRecHDR( pFID->hFixFile, &ffrh, dwLoc ) && ffrh.ulNextOff )
705: dwLoc += ffrh.ulNextOff; /* Next location */
706:
707: /*
708: * Can now process the user's list of stuff to write out.
709: * The writing out is done by user supplied functions - they
710: * tell us how much was written, we simply update the red tape.
711: */
712:
713: dwVarLoc = SetFilePointer( pFID->hVarFile, 0, NULL, FILE_END );
714:
715: for( ; pFList; pFList = (FONTLIST *)pFList->pFLNext )
716: {
717:
718: /* First write out the header array type data */
719:
720: SetFilePointer( pFID->hFixFile, dwLoc + sizeof( FF_REC_HEADER ),
721: NULL, FILE_BEGIN );
722:
723: iSize = iFIWriteFix( pFID->hFixFile, pFID->hHeap, pFList->pvFixData );
724:
725: if( iSize < 0 )
726: return FALSE; /* Bad news */
727:
728: ffrh.ulSize = (ULONG)iSize; /* For the record */
729: ffh.ulRecCount++; /* One more! */
730:
731: /*
732: * Position of next entry: make it DWORD aligned so that we
733: * can memory map the file.
734: */
735: ffrh.ulNextOff = sizeof( ffrh ) + (iSize + 3) & ~0x3;
736: ffh.ulFixSize += ffrh.ulNextOff;
737:
738: /*
739: * The variable length part of the data. Much the same as
740: * above, simply a different function to call.
741: */
742:
743: SetFilePointer( pFID->hVarFile, dwVarLoc, NULL, FILE_BEGIN );
744:
745: iVarSize = iFIWriteVar( pFID->hVarFile, pFID->hHeap, pFList->pvVarData );
746:
747: if( iVarSize < 0 )
748: return FALSE; /* Not good */
749:
750: ffrh.ulVarSize = (ULONG)iVarSize;
751: if( iVarSize > 0 )
752: {
753: /* A zero return means no data - quite legitimate */
754:
755: ffrh.ulVarOff = dwVarLoc;
756: dwVarLoc += (iVarSize + 3) & ~0x3;
757: }
758: else
759: ffrh.ulVarOff = 0; /* No data for this one. */
760:
761:
762: /* Finally, write out the header for the array data */
763:
764: SetFilePointer( pFID->hFixFile, dwLoc, NULL, FILE_BEGIN );
765:
766: if( !bWrite( pFID->hFixFile, &ffrh, sizeof( FF_REC_HEADER ) ) )
767: {
768: #if DBG
769: DbgPrint( "Print!bWrite of FF_REC_HEADER fails\n" );
770: #endif
771: return FALSE;
772: }
773:
774: /* Set the file pointer to the location of the next header */
775: dwLoc += ffrh.ulNextOff;
776: }
777:
778: /*
779: * Last step: write out the final header, which has ulSize set to
780: * zero to indicate that it is the terminating record.
781: */
782:
783: ffh.ulVarSize = GetFileSize( pFID->hVarFile, NULL );
784:
785: SetFilePointer( pFID->hFixFile, dwLoc, NULL, FILE_BEGIN );
786:
787: ffrh.ulNextOff = 0; /* No more in this chain! */
788:
789: if( !bWrite( pFID->hFixFile, &ffrh, sizeof( ffrh ) ) )
790: return FALSE;
791:
792: /*
793: * Finally, update the master header.
794: */
795:
796: SetFilePointer( pFID->hFixFile, 0, NULL, FILE_BEGIN );
797: if( !bWrite( pFID->hFixFile, &ffh, sizeof( ffh ) ) )
798: return FALSE;
799:
800: return TRUE;
801: }
802:
803: /******************************** Function Header **************************
804: * bGetFileHDR
805: * Read in the FF_HEADER for the font installer file. This is
806: * always located at the beginning of the file! Returns TRUE
807: * if the read was AOK, and the structure is verified.
808: *
809: * RETURNS:
810: * TRUE/FALSE
811: *
812: * HISTORY:
813: * 15:40 on Sat 22 Feb 1992 -by- Lindsay Harris [lindsayh]
814: * First incarnation.
815: *
816: ***************************************************************************/
817:
818: BOOL
819: bGetFileHDR( hFile, pffh )
820: HANDLE hFile; /* The file */
821: FF_HEADER *pffh; /* The header to fill in */
822: {
823: /*
824: * Not hard: seek to the beginning of the file, then read in the
825: * structure there, and VERIFY it!
826: */
827:
828: DWORD dwIn; /* Bytes read */
829:
830:
831: SetFilePointer( hFile, 0, NULL, FILE_BEGIN ); /* Start */
832:
833: if( !ReadFile( hFile, pffh, sizeof( FF_HEADER ), &dwIn, NULL ) ||
834: dwIn != sizeof( FF_HEADER ) )
835: {
836: return FALSE;
837: }
838:
839: return pffh->ulID == FF_ID;
840: }
841:
842:
843: /******************************* Function Header ****************************
844: * bGetRecHDR
845: * Read the FF_REC_HEADER structure at the given location with the
846: * file, and return TRUE if read successfully. This means the
847: * read was AOK, and the structure is acceptable.
848: *
849: * RETURNS:
850: * TRUE/FALSE
851: *
852: * HISTORY:
853: * 15:38 on Sat 22 Feb 1992 -by- Lindsay Harris [lindsayh]
854: * Starting out.
855: *
856: ****************************************************************************/
857:
858: BOOL
859: bGetRecHDR( hFile, pffrh, dwLoc )
860: HANDLE hFile; /* File to read from */
861: FF_REC_HEADER *pffrh; /* Structure to fill in */
862: DWORD dwLoc; /* Location of data in file: absolute */
863: {
864: /*
865: * Seek to the specified location, and read in the data there!
866: * Perform consistency checks as above in bGetFileHDR.
867: */
868:
869: DWORD dwIn; /* Bytes read */
870:
871:
872: SetFilePointer( hFile, dwLoc, NULL, FILE_BEGIN );
873:
874: if( !ReadFile( hFile, pffrh, sizeof( FF_REC_HEADER ), &dwIn, NULL ) ||
875: dwIn != sizeof( FF_REC_HEADER ) )
876: {
877: return FALSE;
878: }
879:
880: return pffrh->ulRID == FR_ID;
881: }
882:
883:
884: /**************************** Function Header ******************************
885: * bFixInit
886: * Writes a no information header into the file. This means that
887: * other functions can proceed on the basis that the file contains
888: * valid structures and links.
889: *
890: * RETURNS:
891: * TRUE/FALSE; FALSE on failure.
892: *
893: * HISTORY:
894: * 13:39 on Mon 24 Feb 1992 -by- Lindsay Harris [lindsayh]
895: * Initial
896: *
897: ***************************************************************************/
898:
899: BOOL
900: bFixInit( hFile )
901: HANDLE hFile;
902: {
903: /*
904: * As a minimum, the file needs a FF_HEADER and a FF_REC_HEADER
905: * structure. The first contains an offset to the second, and
906: * no variable length data start location. The latter contains
907: * a zero size field, indicating no more data.
908: */
909:
910: FF_HEADER ffh; /* Overall file header */
911: FF_REC_HEADER ffrh; /* Individual record header */
912:
913: /*
914: * Initialise the FF_HEADER before writing it out.
915: */
916:
917:
918: ffh.ulID = FF_ID;
919: ffh.ulVersion = FF_VERSION;
920: ffh.ulFixData = sizeof( ffh ); /* Follows us directly */
921: ffh.ulFixSize = sizeof( ffrh ); /* Bytes in fixed area */
922: ffh.ulRecCount = 0; /* No records yet! */
923: ffh.ulVarData = 0; /* None - YET! */
924: ffh.ulVarSize = 0;
925:
926:
927: ffrh.ulRID = FR_ID;
928: ffrh.ulSize = 0;
929: ffrh.ulNextOff = 0; /* EOF for fixed part of file */
930: ffrh.ulVarOff = 0;
931: ffrh.ulVarSize = 0;
932:
933: if( !bWrite( hFile, &ffh, sizeof( ffh )) ||
934: !bWrite( hFile, &ffrh, sizeof( ffrh )) )
935: {
936: #if DBG
937: DbgPrint( "Print!bFixInit fails\n" );
938: #endif
939:
940: return FALSE;
941: }
942:
943: return TRUE;
944: }
945:
946: /**************************** Function Header ******************************
947: * vFIClean
948: * The clean up the mess during bail out function. Removes the
949: * temporary files, frees heap storage and whatever else is
950: * required.
951: *
952: * RETURNS:
953: * Zilch
954: *
955: * HISOTRY:
956: * 13:25 on Mon 24 Feb 1992 -by- Lindsay Harris [lindsayh]
957: * Start on it - it probably will grow.
958: *
959: ***************************************************************************/
960:
961: void
962: vFIClean( pFID )
963: FID *pFID;
964: {
965: /*
966: * Need to be slightly careful about what we do. In particular, NO
967: * bad memory accesses.
968: */
969:
970: if( pFID->dwID != FID_ID )
971: return;
972:
973: /*
974: * Free any temporary files we may have created. Note that we
975: * must close the files before we can remove. Silly idea that is.
976: */
977:
978:
979: if( pFID->hCurFile != INVALID_HANDLE_VALUE )
980: CloseHandle( pFID->hCurFile );
981:
982: if( pFID->hFixFile != INVALID_HANDLE_VALUE )
983: CloseHandle( pFID->hFixFile );
984:
985: if( pFID->hVarFile != INVALID_HANDLE_VALUE )
986: CloseHandle( pFID->hVarFile );
987:
988: if( pFID->pwstrFixName )
989: {
990: DeleteFileW( pFID->pwstrFixName ); /* Ignore failure */
991:
992: HeapFree( pFID->hHeap, 0, (LPSTR)pFID->pwstrFixName );
993: pFID->pwstrFixName = 0;
994: }
995:
996: if( pFID->pwstrVarName )
997: {
998: DeleteFileW( pFID->pwstrVarName );
999:
1000: HeapFree( pFID->hHeap, 0, (LPSTR)pFID->pwstrVarName );
1001: pFID->pwstrFixName = 0;
1002: }
1003:
1004: if( pFID->pwstrCurName )
1005: {
1006: HeapFree( pFID->hHeap, 0, (LPSTR)pFID->pwstrCurName );
1007: pFID->pwstrCurName = 0;
1008: }
1009:
1010:
1011: pFID->dwID = (DWORD)~FID_ID; /* Invalid in case mem reused */
1012:
1013: HeapFree( pFID->hHeap, 0, (LPSTR)pFID );
1014:
1015: return;
1016: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.