1/***************************************************************************/
2/* */
3/* ftgzip.c */
4/* */
5/* FreeType support for .gz compressed files. */
6/* */
7/* This optional component relies on zlib. It should mainly be used to */
8/* parse compressed PCF fonts, as found with many X11 server */
9/* distributions. */
10/* */
11/* Copyright 2002-2018 by */
12/* David Turner, Robert Wilhelm, and Werner Lemberg. */
13/* */
14/* This file is part of the FreeType project, and may only be used, */
15/* modified, and distributed under the terms of the FreeType project */
16/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
17/* this file you indicate that you have read the license and */
18/* understand and accept it fully. */
19/* */
20/***************************************************************************/
21
22
23#include <ft2build.h>
24#include FT_INTERNAL_MEMORY_H
25#include FT_INTERNAL_STREAM_H
26#include FT_INTERNAL_DEBUG_H
27#include FT_GZIP_H
28#include FT_CONFIG_STANDARD_LIBRARY_H
29
30
31#include FT_MODULE_ERRORS_H
32
33#undef FTERRORS_H_
34
35#undef FT_ERR_PREFIX
36#define FT_ERR_PREFIX Gzip_Err_
37#define FT_ERR_BASE FT_Mod_Err_Gzip
38
39#include FT_ERRORS_H
40
41
42#ifdef FT_CONFIG_OPTION_USE_ZLIB
43
44#ifdef FT_CONFIG_OPTION_PIC
45#error "gzip code does not support PIC yet"
46#endif
47
48#ifdef FT_CONFIG_OPTION_SYSTEM_ZLIB
49
50#include <zlib.h>
51
52#else /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
53
54 /* In this case, we include our own modified sources of the ZLib */
55 /* within the `gzip' component. The modifications were necessary */
56 /* to #include all files without conflicts, as well as preventing */
57 /* the definition of `extern' functions that may cause linking */
58 /* conflicts when a program is linked with both FreeType and the */
59 /* original ZLib. */
60
61#ifndef USE_ZLIB_ZCALLOC
62#define MY_ZCALLOC /* prevent all zcalloc() & zfree() in zutil.c */
63#endif
64
65 /* Note that our `zlib.h' includes `ftzconf.h' instead of `zconf.h'; */
66 /* the main reason is that even a global `zlib.h' includes `zconf.h' */
67 /* with */
68 /* */
69 /* #include "zconf.h" */
70 /* */
71 /* instead of the expected */
72 /* */
73 /* #include <zconf.h> */
74 /* */
75 /* so that configuration with `FT_CONFIG_OPTION_SYSTEM_ZLIB' might */
76 /* include the wrong `zconf.h' file, leading to errors. */
77#include "zlib.h"
78
79#undef SLOW
80#define SLOW 1 /* we can't use asm-optimized sources here! */
81
82#if defined( _MSC_VER ) /* Visual C++ (and Intel C++) */
83 /* We disable the warning `conversion from XXX to YYY, */
84 /* possible loss of data' in order to compile cleanly with */
85 /* the maximum level of warnings: zlib is non-FreeType */
86 /* code. */
87#pragma warning( push )
88#pragma warning( disable : 4244 )
89#endif /* _MSC_VER */
90
91 /* Urgh. `inflate_mask' must not be declared twice -- C++ doesn't like
92 this. We temporarily disable it and load all necessary header files. */
93#define NO_INFLATE_MASK
94#include "zutil.h"
95#include "inftrees.h"
96#include "infblock.h"
97#include "infcodes.h"
98#include "infutil.h"
99#undef NO_INFLATE_MASK
100
101 /* infutil.c must be included before infcodes.c */
102#include "zutil.c"
103#include "inftrees.c"
104#include "infutil.c"
105#include "infcodes.c"
106#include "infblock.c"
107#include "inflate.c"
108#include "adler32.c"
109
110#if defined( _MSC_VER )
111#pragma warning( pop )
112#endif
113
114#endif /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
115
116
117/***************************************************************************/
118/***************************************************************************/
119/***** *****/
120/***** Z L I B M E M O R Y M A N A G E M E N T *****/
121/***** *****/
122/***************************************************************************/
123/***************************************************************************/
124
125 /* it is better to use FreeType memory routines instead of raw
126 'malloc/free' */
127
128 static voidpf
129 ft_gzip_alloc( FT_Memory memory,
130 uInt items,
131 uInt size )
132 {
133 FT_ULong sz = (FT_ULong)size * items;
134 FT_Error error;
135 FT_Pointer p = NULL;
136
137
138 (void)FT_ALLOC( p, sz );
139 return p;
140 }
141
142
143 static void
144 ft_gzip_free( FT_Memory memory,
145 voidpf address )
146 {
147 FT_MEM_FREE( address );
148 }
149
150
151#if !defined( FT_CONFIG_OPTION_SYSTEM_ZLIB ) && !defined( USE_ZLIB_ZCALLOC )
152
153 local voidpf
154 zcalloc ( voidpf opaque,
155 unsigned items,
156 unsigned size )
157 {
158 return ft_gzip_alloc( (FT_Memory)opaque, items, size );
159 }
160
161 local void
162 zcfree( voidpf opaque,
163 voidpf ptr )
164 {
165 ft_gzip_free( (FT_Memory)opaque, ptr );
166 }
167
168#endif /* !SYSTEM_ZLIB && !USE_ZLIB_ZCALLOC */
169
170
171/***************************************************************************/
172/***************************************************************************/
173/***** *****/
174/***** Z L I B F I L E D E S C R I P T O R *****/
175/***** *****/
176/***************************************************************************/
177/***************************************************************************/
178
179#define FT_GZIP_BUFFER_SIZE 4096
180
181 typedef struct FT_GZipFileRec_
182 {
183 FT_Stream source; /* parent/source stream */
184 FT_Stream stream; /* embedding stream */
185 FT_Memory memory; /* memory allocator */
186 z_stream zstream; /* zlib input stream */
187
188 FT_ULong start; /* starting position, after .gz header */
189 FT_Byte input[FT_GZIP_BUFFER_SIZE]; /* input read buffer */
190
191 FT_Byte buffer[FT_GZIP_BUFFER_SIZE]; /* output buffer */
192 FT_ULong pos; /* position in output */
193 FT_Byte* cursor;
194 FT_Byte* limit;
195
196 } FT_GZipFileRec, *FT_GZipFile;
197
198
199 /* gzip flag byte */
200#define FT_GZIP_ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
201#define FT_GZIP_HEAD_CRC 0x02 /* bit 1 set: header CRC present */
202#define FT_GZIP_EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
203#define FT_GZIP_ORIG_NAME 0x08 /* bit 3 set: original file name present */
204#define FT_GZIP_COMMENT 0x10 /* bit 4 set: file comment present */
205#define FT_GZIP_RESERVED 0xE0 /* bits 5..7: reserved */
206
207
208 /* check and skip .gz header - we don't support `transparent' compression */
209 static FT_Error
210 ft_gzip_check_header( FT_Stream stream )
211 {
212 FT_Error error;
213 FT_Byte head[4];
214
215
216 if ( FT_STREAM_SEEK( 0 ) ||
217 FT_STREAM_READ( head, 4 ) )
218 goto Exit;
219
220 /* head[0] && head[1] are the magic numbers; */
221 /* head[2] is the method, and head[3] the flags */
222 if ( head[0] != 0x1F ||
223 head[1] != 0x8B ||
224 head[2] != Z_DEFLATED ||
225 (head[3] & FT_GZIP_RESERVED) )
226 {
227 error = FT_THROW( Invalid_File_Format );
228 goto Exit;
229 }
230
231 /* skip time, xflags and os code */
232 (void)FT_STREAM_SKIP( 6 );
233
234 /* skip the extra field */
235 if ( head[3] & FT_GZIP_EXTRA_FIELD )
236 {
237 FT_UInt len;
238
239
240 if ( FT_READ_USHORT_LE( len ) ||
241 FT_STREAM_SKIP( len ) )
242 goto Exit;
243 }
244
245 /* skip original file name */
246 if ( head[3] & FT_GZIP_ORIG_NAME )
247 for (;;)
248 {
249 FT_UInt c;
250
251
252 if ( FT_READ_BYTE( c ) )
253 goto Exit;
254
255 if ( c == 0 )
256 break;
257 }
258
259 /* skip .gz comment */
260 if ( head[3] & FT_GZIP_COMMENT )
261 for (;;)
262 {
263 FT_UInt c;
264
265
266 if ( FT_READ_BYTE( c ) )
267 goto Exit;
268
269 if ( c == 0 )
270 break;
271 }
272
273 /* skip CRC */
274 if ( head[3] & FT_GZIP_HEAD_CRC )
275 if ( FT_STREAM_SKIP( 2 ) )
276 goto Exit;
277
278 Exit:
279 return error;
280 }
281
282
283 static FT_Error
284 ft_gzip_file_init( FT_GZipFile zip,
285 FT_Stream stream,
286 FT_Stream source )
287 {
288 z_stream* zstream = &zip->zstream;
289 FT_Error error = FT_Err_Ok;
290
291
292 zip->stream = stream;
293 zip->source = source;
294 zip->memory = stream->memory;
295
296 zip->limit = zip->buffer + FT_GZIP_BUFFER_SIZE;
297 zip->cursor = zip->limit;
298 zip->pos = 0;
299
300 /* check and skip .gz header */
301 {
302 stream = source;
303
304 error = ft_gzip_check_header( stream );
305 if ( error )
306 goto Exit;
307
308 zip->start = FT_STREAM_POS();
309 }
310
311 /* initialize zlib -- there is no zlib header in the compressed stream */
312 zstream->zalloc = (alloc_func)ft_gzip_alloc;
313 zstream->zfree = (free_func) ft_gzip_free;
314 zstream->opaque = stream->memory;
315
316 zstream->avail_in = 0;
317 zstream->next_in = zip->buffer;
318
319 if ( inflateInit2( zstream, -MAX_WBITS ) != Z_OK ||
320 !zstream->next_in )
321 error = FT_THROW( Invalid_File_Format );
322
323 Exit:
324 return error;
325 }
326
327
328 static void
329 ft_gzip_file_done( FT_GZipFile zip )
330 {
331 z_stream* zstream = &zip->zstream;
332
333
334 inflateEnd( zstream );
335
336 /* clear the rest */
337 zstream->zalloc = NULL;
338 zstream->zfree = NULL;
339 zstream->opaque = NULL;
340 zstream->next_in = NULL;
341 zstream->next_out = NULL;
342 zstream->avail_in = 0;
343 zstream->avail_out = 0;
344
345 zip->memory = NULL;
346 zip->source = NULL;
347 zip->stream = NULL;
348 }
349
350
351 static FT_Error
352 ft_gzip_file_reset( FT_GZipFile zip )
353 {
354 FT_Stream stream = zip->source;
355 FT_Error error;
356
357
358 if ( !FT_STREAM_SEEK( zip->start ) )
359 {
360 z_stream* zstream = &zip->zstream;
361
362
363 inflateReset( zstream );
364
365 zstream->avail_in = 0;
366 zstream->next_in = zip->input;
367 zstream->avail_out = 0;
368 zstream->next_out = zip->buffer;
369
370 zip->limit = zip->buffer + FT_GZIP_BUFFER_SIZE;
371 zip->cursor = zip->limit;
372 zip->pos = 0;
373 }
374
375 return error;
376 }
377
378
379 static FT_Error
380 ft_gzip_file_fill_input( FT_GZipFile zip )
381 {
382 z_stream* zstream = &zip->zstream;
383 FT_Stream stream = zip->source;
384 FT_ULong size;
385
386
387 if ( stream->read )
388 {
389 size = stream->read( stream, stream->pos, zip->input,
390 FT_GZIP_BUFFER_SIZE );
391 if ( size == 0 )
392 {
393 zip->limit = zip->cursor;
394 return FT_THROW( Invalid_Stream_Operation );
395 }
396 }
397 else
398 {
399 size = stream->size - stream->pos;
400 if ( size > FT_GZIP_BUFFER_SIZE )
401 size = FT_GZIP_BUFFER_SIZE;
402
403 if ( size == 0 )
404 {
405 zip->limit = zip->cursor;
406 return FT_THROW( Invalid_Stream_Operation );
407 }
408
409 FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
410 }
411 stream->pos += size;
412
413 zstream->next_in = zip->input;
414 zstream->avail_in = size;
415
416 return FT_Err_Ok;
417 }
418
419
420 static FT_Error
421 ft_gzip_file_fill_output( FT_GZipFile zip )
422 {
423 z_stream* zstream = &zip->zstream;
424 FT_Error error = FT_Err_Ok;
425
426
427 zip->cursor = zip->buffer;
428 zstream->next_out = zip->cursor;
429 zstream->avail_out = FT_GZIP_BUFFER_SIZE;
430
431 while ( zstream->avail_out > 0 )
432 {
433 int err;
434
435
436 if ( zstream->avail_in == 0 )
437 {
438 error = ft_gzip_file_fill_input( zip );
439 if ( error )
440 break;
441 }
442
443 err = inflate( zstream, Z_NO_FLUSH );
444
445 if ( err == Z_STREAM_END )
446 {
447 zip->limit = zstream->next_out;
448 if ( zip->limit == zip->cursor )
449 error = FT_THROW( Invalid_Stream_Operation );
450 break;
451 }
452 else if ( err != Z_OK )
453 {
454 zip->limit = zip->cursor;
455 error = FT_THROW( Invalid_Stream_Operation );
456 break;
457 }
458 }
459
460 return error;
461 }
462
463
464 /* fill output buffer; `count' must be <= FT_GZIP_BUFFER_SIZE */
465 static FT_Error
466 ft_gzip_file_skip_output( FT_GZipFile zip,
467 FT_ULong count )
468 {
469 FT_Error error = FT_Err_Ok;
470 FT_ULong delta;
471
472
473 for (;;)
474 {
475 delta = (FT_ULong)( zip->limit - zip->cursor );
476 if ( delta >= count )
477 delta = count;
478
479 zip->cursor += delta;
480 zip->pos += delta;
481
482 count -= delta;
483 if ( count == 0 )
484 break;
485
486 error = ft_gzip_file_fill_output( zip );
487 if ( error )
488 break;
489 }
490
491 return error;
492 }
493
494
495 static FT_ULong
496 ft_gzip_file_io( FT_GZipFile zip,
497 FT_ULong pos,
498 FT_Byte* buffer,
499 FT_ULong count )
500 {
501 FT_ULong result = 0;
502 FT_Error error;
503
504
505 /* Reset inflate stream if we're seeking backwards. */
506 /* Yes, that is not too efficient, but it saves memory :-) */
507 if ( pos < zip->pos )
508 {
509 error = ft_gzip_file_reset( zip );
510 if ( error )
511 goto Exit;
512 }
513
514 /* skip unwanted bytes */
515 if ( pos > zip->pos )
516 {
517 error = ft_gzip_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
518 if ( error )
519 goto Exit;
520 }
521
522 if ( count == 0 )
523 goto Exit;
524
525 /* now read the data */
526 for (;;)
527 {
528 FT_ULong delta;
529
530
531 delta = (FT_ULong)( zip->limit - zip->cursor );
532 if ( delta >= count )
533 delta = count;
534
535 FT_MEM_COPY( buffer, zip->cursor, delta );
536 buffer += delta;
537 result += delta;
538 zip->cursor += delta;
539 zip->pos += delta;
540
541 count -= delta;
542 if ( count == 0 )
543 break;
544
545 error = ft_gzip_file_fill_output( zip );
546 if ( error )
547 break;
548 }
549
550 Exit:
551 return result;
552 }
553
554
555/***************************************************************************/
556/***************************************************************************/
557/***** *****/
558/***** G Z E M B E D D I N G S T R E A M *****/
559/***** *****/
560/***************************************************************************/
561/***************************************************************************/
562
563 static void
564 ft_gzip_stream_close( FT_Stream stream )
565 {
566 FT_GZipFile zip = (FT_GZipFile)stream->descriptor.pointer;
567 FT_Memory memory = stream->memory;
568
569
570 if ( zip )
571 {
572 /* finalize gzip file descriptor */
573 ft_gzip_file_done( zip );
574
575 FT_FREE( zip );
576
577 stream->descriptor.pointer = NULL;
578 }
579
580 if ( !stream->read )
581 FT_FREE( stream->base );
582 }
583
584
585 static unsigned long
586 ft_gzip_stream_io( FT_Stream stream,
587 unsigned long offset,
588 unsigned char* buffer,
589 unsigned long count )
590 {
591 FT_GZipFile zip = (FT_GZipFile)stream->descriptor.pointer;
592
593
594 return ft_gzip_file_io( zip, offset, buffer, count );
595 }
596
597
598 static FT_ULong
599 ft_gzip_get_uncompressed_size( FT_Stream stream )
600 {
601 FT_Error error;
602 FT_ULong old_pos;
603 FT_ULong result = 0;
604
605
606 old_pos = stream->pos;
607 if ( !FT_Stream_Seek( stream, stream->size - 4 ) )
608 {
609 result = FT_Stream_ReadULongLE( stream, &error );
610 if ( error )
611 result = 0;
612
613 (void)FT_Stream_Seek( stream, old_pos );
614 }
615
616 return result;
617 }
618
619
620 /* documentation is in ftgzip.h */
621
622 FT_EXPORT_DEF( FT_Error )
623 FT_Stream_OpenGzip( FT_Stream stream,
624 FT_Stream source )
625 {
626 FT_Error error;
627 FT_Memory memory;
628 FT_GZipFile zip = NULL;
629
630
631 if ( !stream || !source )
632 {
633 error = FT_THROW( Invalid_Stream_Handle );
634 goto Exit;
635 }
636
637 memory = source->memory;
638
639 /*
640 * check the header right now; this prevents allocating un-necessary
641 * objects when we don't need them
642 */
643 error = ft_gzip_check_header( source );
644 if ( error )
645 goto Exit;
646
647 FT_ZERO( stream );
648 stream->memory = memory;
649
650 if ( !FT_QNEW( zip ) )
651 {
652 error = ft_gzip_file_init( zip, stream, source );
653 if ( error )
654 {
655 FT_FREE( zip );
656 goto Exit;
657 }
658
659 stream->descriptor.pointer = zip;
660 }
661
662 /*
663 * We use the following trick to try to dramatically improve the
664 * performance while dealing with small files. If the original stream
665 * size is less than a certain threshold, we try to load the whole font
666 * file into memory. This saves us from using the 32KB buffer needed
667 * to inflate the file, plus the two 4KB intermediate input/output
668 * buffers used in the `FT_GZipFile' structure.
669 */
670 {
671 FT_ULong zip_size = ft_gzip_get_uncompressed_size( source );
672
673
674 if ( zip_size != 0 && zip_size < 40 * 1024 )
675 {
676 FT_Byte* zip_buff = NULL;
677
678
679 if ( !FT_ALLOC( zip_buff, zip_size ) )
680 {
681 FT_ULong count;
682
683
684 count = ft_gzip_file_io( zip, 0, zip_buff, zip_size );
685 if ( count == zip_size )
686 {
687 ft_gzip_file_done( zip );
688 FT_FREE( zip );
689
690 stream->descriptor.pointer = NULL;
691
692 stream->size = zip_size;
693 stream->pos = 0;
694 stream->base = zip_buff;
695 stream->read = NULL;
696 stream->close = ft_gzip_stream_close;
697
698 goto Exit;
699 }
700
701 ft_gzip_file_io( zip, 0, NULL, 0 );
702 FT_FREE( zip_buff );
703 }
704 error = FT_Err_Ok;
705 }
706
707 if ( zip_size )
708 stream->size = zip_size;
709 else
710 stream->size = 0x7FFFFFFFL; /* don't know the real size! */
711 }
712
713 stream->pos = 0;
714 stream->base = NULL;
715 stream->read = ft_gzip_stream_io;
716 stream->close = ft_gzip_stream_close;
717
718 Exit:
719 return error;
720 }
721
722
723 /* documentation is in ftgzip.h */
724
725 FT_EXPORT_DEF( FT_Error )
726 FT_Gzip_Uncompress( FT_Memory memory,
727 FT_Byte* output,
728 FT_ULong* output_len,
729 const FT_Byte* input,
730 FT_ULong input_len )
731 {
732 z_stream stream;
733 int err;
734
735
736 /* check for `input' delayed to `inflate' */
737
738 if ( !memory || ! output_len || !output )
739 return FT_THROW( Invalid_Argument );
740
741 /* this function is modeled after zlib's `uncompress' function */
742
743 stream.next_in = (Bytef*)input;
744 stream.avail_in = (uInt)input_len;
745
746 stream.next_out = output;
747 stream.avail_out = (uInt)*output_len;
748
749 stream.zalloc = (alloc_func)ft_gzip_alloc;
750 stream.zfree = (free_func) ft_gzip_free;
751 stream.opaque = memory;
752
753 err = inflateInit2( &stream, MAX_WBITS );
754 if ( err != Z_OK )
755 return FT_THROW( Invalid_Argument );
756
757 err = inflate( &stream, Z_FINISH );
758 if ( err != Z_STREAM_END )
759 {
760 inflateEnd( &stream );
761 if ( err == Z_OK )
762 err = Z_BUF_ERROR;
763 }
764 else
765 {
766 *output_len = stream.total_out;
767
768 err = inflateEnd( &stream );
769 }
770
771 if ( err == Z_MEM_ERROR )
772 return FT_THROW( Out_Of_Memory );
773
774 if ( err == Z_BUF_ERROR )
775 return FT_THROW( Array_Too_Large );
776
777 if ( err == Z_DATA_ERROR )
778 return FT_THROW( Invalid_Table );
779
780 return FT_Err_Ok;
781 }
782
783
784#else /* !FT_CONFIG_OPTION_USE_ZLIB */
785
786 FT_EXPORT_DEF( FT_Error )
787 FT_Stream_OpenGzip( FT_Stream stream,
788 FT_Stream source )
789 {
790 FT_UNUSED( stream );
791 FT_UNUSED( source );
792
793 return FT_THROW( Unimplemented_Feature );
794 }
795
796
797 FT_EXPORT_DEF( FT_Error )
798 FT_Gzip_Uncompress( FT_Memory memory,
799 FT_Byte* output,
800 FT_ULong* output_len,
801 const FT_Byte* input,
802 FT_ULong input_len )
803 {
804 FT_UNUSED( memory );
805 FT_UNUSED( output );
806 FT_UNUSED( output_len );
807 FT_UNUSED( input );
808 FT_UNUSED( input_len );
809
810 return FT_THROW( Unimplemented_Feature );
811 }
812
813#endif /* !FT_CONFIG_OPTION_USE_ZLIB */
814
815
816/* END */
817