1 /****************************************************************************
2 *
3 * ftbzip2.c
4 *
5 * FreeType support for .bz2 compressed files.
6 *
7 * This optional component relies on libbz2. It should mainly be used to
8 * parse compressed PCF fonts, as found with many X11 server
9 * distributions.
10 *
11 * Copyright (C) 2010-2023 by
12 * Joel Klinghed.
13 *
14 * based on `src/gzip/ftgzip.c'
15 *
16 * This file is part of the FreeType project, and may only be used,
17 * modified, and distributed under the terms of the FreeType project
18 * license, LICENSE.TXT. By continuing to use, modify, or distribute
19 * this file you indicate that you have read the license and
20 * understand and accept it fully.
21 *
22 */
23
24
25 #include <freetype/internal/ftmemory.h>
26 #include <freetype/internal/ftstream.h>
27 #include <freetype/internal/ftdebug.h>
28 #include <freetype/ftbzip2.h>
29 #include FT_CONFIG_STANDARD_LIBRARY_H
30
31
32 #include <freetype/ftmoderr.h>
33
34 #undef FTERRORS_H_
35
36 #undef FT_ERR_PREFIX
37 #define FT_ERR_PREFIX Bzip2_Err_
38 #define FT_ERR_BASE FT_Mod_Err_Bzip2
39
40 #include <freetype/fterrors.h>
41
42
43 #ifdef FT_CONFIG_OPTION_USE_BZIP2
44
45 #define BZ_NO_STDIO /* Do not need FILE */
46 #include <bzlib.h>
47
48
49 /***************************************************************************/
50 /***************************************************************************/
51 /***** *****/
52 /***** B Z I P 2 M E M O R Y M A N A G E M E N T *****/
53 /***** *****/
54 /***************************************************************************/
55 /***************************************************************************/
56
57 /* it is better to use FreeType memory routines instead of raw
58 'malloc/free' */
59
60 typedef void* (*alloc_func)( void*, int, int );
61 typedef void (*free_func) ( void*, void* );
62
63
64 static void*
65 ft_bzip2_alloc( void* memory_, /* FT_Memory */
66 int items,
67 int size )
68 {
69 FT_Memory memory = (FT_Memory)memory_;
70
71 FT_ULong sz = (FT_ULong)size * (FT_ULong)items;
72 FT_Error error;
73 FT_Pointer p = NULL;
74
75
76 FT_MEM_QALLOC( p, sz );
77 return p;
78 }
79
80
81 static void
82 ft_bzip2_free( void* memory_, /* FT_Memory */
83 void* address )
84 {
85 FT_Memory memory = (FT_Memory)memory_;
86
87
88 FT_MEM_FREE( address );
89 }
90
91
92 /***************************************************************************/
93 /***************************************************************************/
94 /***** *****/
95 /***** B Z I P 2 F I L E D E S C R I P T O R *****/
96 /***** *****/
97 /***************************************************************************/
98 /***************************************************************************/
99
100 #define FT_BZIP2_BUFFER_SIZE 4096
101
102 typedef struct FT_BZip2FileRec_
103 {
104 FT_Stream source; /* parent/source stream */
105 FT_Stream stream; /* embedding stream */
106 FT_Memory memory; /* memory allocator */
107 bz_stream bzstream; /* bzlib input stream */
108
109 FT_Byte input[FT_BZIP2_BUFFER_SIZE]; /* input read buffer */
110
111 FT_Byte buffer[FT_BZIP2_BUFFER_SIZE]; /* output buffer */
112 FT_ULong pos; /* position in output */
113 FT_Byte* cursor;
114 FT_Byte* limit;
115 FT_Bool reset; /* reset before next read */
116
117 } FT_BZip2FileRec, *FT_BZip2File;
118
119
120 /* check and skip .bz2 header - we don't support `transparent' compression */
121 static FT_Error
122 ft_bzip2_check_header( FT_Stream stream )
123 {
124 FT_Error error = FT_Err_Ok;
125 FT_Byte head[4];
126
127
128 if ( FT_STREAM_SEEK( 0 ) ||
129 FT_STREAM_READ( head, 4 ) )
130 goto Exit;
131
132 /* head[0] && head[1] are the magic numbers; */
133 /* head[2] is the version, and head[3] the blocksize */
134 if ( head[0] != 0x42 ||
135 head[1] != 0x5A ||
136 head[2] != 0x68 ) /* only support bzip2 (huffman) */
137 {
138 error = FT_THROW( Invalid_File_Format );
139 goto Exit;
140 }
141
142 Exit:
143 return error;
144 }
145
146
147 static FT_Error
148 ft_bzip2_file_init( FT_BZip2File zip,
149 FT_Stream stream,
150 FT_Stream source )
151 {
152 bz_stream* bzstream = &zip->bzstream;
153 FT_Error error = FT_Err_Ok;
154
155
156 zip->stream = stream;
157 zip->source = source;
158 zip->memory = stream->memory;
159
160 zip->limit = zip->buffer + FT_BZIP2_BUFFER_SIZE;
161 zip->cursor = zip->limit;
162 zip->pos = 0;
163 zip->reset = 0;
164
165 /* check .bz2 header */
166 {
167 stream = source;
168
169 error = ft_bzip2_check_header( stream );
170 if ( error )
171 goto Exit;
172
173 if ( FT_STREAM_SEEK( 0 ) )
174 goto Exit;
175 }
176
177 /* initialize bzlib */
178 bzstream->bzalloc = ft_bzip2_alloc;
179 bzstream->bzfree = ft_bzip2_free;
180 bzstream->opaque = zip->memory;
181
182 bzstream->avail_in = 0;
183 bzstream->next_in = (char*)zip->buffer;
184
185 if ( BZ2_bzDecompressInit( bzstream, 0, 0 ) != BZ_OK ||
186 !bzstream->next_in )
187 error = FT_THROW( Invalid_File_Format );
188
189 Exit:
190 return error;
191 }
192
193
194 static void
195 ft_bzip2_file_done( FT_BZip2File zip )
196 {
197 bz_stream* bzstream = &zip->bzstream;
198
199
200 BZ2_bzDecompressEnd( bzstream );
201
202 /* clear the rest */
203 bzstream->bzalloc = NULL;
204 bzstream->bzfree = NULL;
205 bzstream->opaque = NULL;
206 bzstream->next_in = NULL;
207 bzstream->next_out = NULL;
208 bzstream->avail_in = 0;
209 bzstream->avail_out = 0;
210
211 zip->memory = NULL;
212 zip->source = NULL;
213 zip->stream = NULL;
214 }
215
216
217 static FT_Error
218 ft_bzip2_file_reset( FT_BZip2File zip )
219 {
220 FT_Stream stream = zip->source;
221 FT_Error error;
222
223
224 if ( !FT_STREAM_SEEK( 0 ) )
225 {
226 bz_stream* bzstream = &zip->bzstream;
227
228
229 BZ2_bzDecompressEnd( bzstream );
230
231 bzstream->avail_in = 0;
232 bzstream->next_in = (char*)zip->input;
233 bzstream->avail_out = 0;
234 bzstream->next_out = (char*)zip->buffer;
235
236 zip->limit = zip->buffer + FT_BZIP2_BUFFER_SIZE;
237 zip->cursor = zip->limit;
238 zip->pos = 0;
239 zip->reset = 0;
240
241 BZ2_bzDecompressInit( bzstream, 0, 0 );
242 }
243
244 return error;
245 }
246
247
248 static FT_Error
249 ft_bzip2_file_fill_input( FT_BZip2File zip )
250 {
251 bz_stream* bzstream = &zip->bzstream;
252 FT_Stream stream = zip->source;
253 FT_ULong size;
254
255
256 if ( stream->read )
257 {
258 size = stream->read( stream, stream->pos, zip->input,
259 FT_BZIP2_BUFFER_SIZE );
260 if ( size == 0 )
261 {
262 zip->limit = zip->cursor;
263 return FT_THROW( Invalid_Stream_Operation );
264 }
265 }
266 else
267 {
268 size = stream->size - stream->pos;
269 if ( size > FT_BZIP2_BUFFER_SIZE )
270 size = FT_BZIP2_BUFFER_SIZE;
271
272 if ( size == 0 )
273 {
274 zip->limit = zip->cursor;
275 return FT_THROW( Invalid_Stream_Operation );
276 }
277
278 FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
279 }
280 stream->pos += size;
281
282 bzstream->next_in = (char*)zip->input;
283 bzstream->avail_in = size;
284
285 return FT_Err_Ok;
286 }
287
288
289 static FT_Error
290 ft_bzip2_file_fill_output( FT_BZip2File zip )
291 {
292 bz_stream* bzstream = &zip->bzstream;
293 FT_Error error = FT_Err_Ok;
294
295
296 zip->cursor = zip->buffer;
297 bzstream->next_out = (char*)zip->cursor;
298 bzstream->avail_out = FT_BZIP2_BUFFER_SIZE;
299
300 while ( bzstream->avail_out > 0 )
301 {
302 int err;
303
304
305 if ( bzstream->avail_in == 0 )
306 {
307 error = ft_bzip2_file_fill_input( zip );
308 if ( error )
309 break;
310 }
311
312 err = BZ2_bzDecompress( bzstream );
313
314 if ( err != BZ_OK )
315 {
316 zip->reset = 1;
317
318 if ( err == BZ_STREAM_END )
319 {
320 zip->limit = (FT_Byte*)bzstream->next_out;
321 if ( zip->limit == zip->cursor )
322 error = FT_THROW( Invalid_Stream_Operation );
323 break;
324 }
325 else
326 {
327 zip->limit = zip->cursor;
328 error = FT_THROW( Invalid_Stream_Operation );
329 break;
330 }
331 }
332 }
333
334 return error;
335 }
336
337
338 /* fill output buffer; `count' must be <= FT_BZIP2_BUFFER_SIZE */
339 static FT_Error
340 ft_bzip2_file_skip_output( FT_BZip2File zip,
341 FT_ULong count )
342 {
343 FT_Error error = FT_Err_Ok;
344
345
346 for (;;)
347 {
348 FT_ULong delta = (FT_ULong)( zip->limit - zip->cursor );
349
350
351 if ( delta >= count )
352 delta = count;
353
354 zip->cursor += delta;
355 zip->pos += delta;
356
357 count -= delta;
358 if ( count == 0 )
359 break;
360
361 error = ft_bzip2_file_fill_output( zip );
362 if ( error )
363 break;
364 }
365
366 return error;
367 }
368
369
370 static FT_ULong
371 ft_bzip2_file_io( FT_BZip2File zip,
372 FT_ULong pos,
373 FT_Byte* buffer,
374 FT_ULong count )
375 {
376 FT_ULong result = 0;
377 FT_Error error;
378
379
380 /* Reset inflate stream if seeking backwards or bzip reported an error. */
381 /* Yes, that is not too efficient, but it saves memory :-) */
382 if ( pos < zip->pos || zip->reset )
383 {
384 error = ft_bzip2_file_reset( zip );
385 if ( error )
386 goto Exit;
387 }
388
389 /* skip unwanted bytes */
390 if ( pos > zip->pos )
391 {
392 error = ft_bzip2_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
393 if ( error )
394 goto Exit;
395 }
396
397 if ( count == 0 )
398 goto Exit;
399
400 /* now read the data */
401 for (;;)
402 {
403 FT_ULong delta;
404
405
406 delta = (FT_ULong)( zip->limit - zip->cursor );
407 if ( delta >= count )
408 delta = count;
409
410 FT_MEM_COPY( buffer, zip->cursor, delta );
411 buffer += delta;
412 result += delta;
413 zip->cursor += delta;
414 zip->pos += delta;
415
416 count -= delta;
417 if ( count == 0 )
418 break;
419
420 error = ft_bzip2_file_fill_output( zip );
421 if ( error )
422 break;
423 }
424
425 Exit:
426 return result;
427 }
428
429
430 /***************************************************************************/
431 /***************************************************************************/
432 /***** *****/
433 /***** B Z E M B E D D I N G S T R E A M *****/
434 /***** *****/
435 /***************************************************************************/
436 /***************************************************************************/
437
438 static void
439 ft_bzip2_stream_close( FT_Stream stream )
440 {
441 FT_BZip2File zip = (FT_BZip2File)stream->descriptor.pointer;
442 FT_Memory memory = stream->memory;
443
444
445 if ( zip )
446 {
447 /* finalize bzip file descriptor */
448 ft_bzip2_file_done( zip );
449
450 FT_FREE( zip );
451
452 stream->descriptor.pointer = NULL;
453 }
454 }
455
456
457 static unsigned long
458 ft_bzip2_stream_io( FT_Stream stream,
459 unsigned long offset,
460 unsigned char* buffer,
461 unsigned long count )
462 {
463 FT_BZip2File zip = (FT_BZip2File)stream->descriptor.pointer;
464
465
466 return ft_bzip2_file_io( zip, offset, buffer, count );
467 }
468
469
470 FT_EXPORT_DEF( FT_Error )
471 FT_Stream_OpenBzip2( FT_Stream stream,
472 FT_Stream source )
473 {
474 FT_Error error;
475 FT_Memory memory;
476 FT_BZip2File zip = NULL;
477
478
479 if ( !stream || !source )
480 {
481 error = FT_THROW( Invalid_Stream_Handle );
482 goto Exit;
483 }
484
485 memory = source->memory;
486
487 /*
488 * check the header right now; this prevents allocating unnecessary
489 * objects when we don't need them
490 */
491 error = ft_bzip2_check_header( source );
492 if ( error )
493 goto Exit;
494
495 FT_ZERO( stream );
496 stream->memory = memory;
497
498 if ( !FT_QNEW( zip ) )
499 {
500 error = ft_bzip2_file_init( zip, stream, source );
501 if ( error )
502 {
503 FT_FREE( zip );
504 goto Exit;
505 }
506
507 stream->descriptor.pointer = zip;
508 }
509
510 stream->size = 0x7FFFFFFFL; /* don't know the real size! */
511 stream->pos = 0;
512 stream->base = NULL;
513 stream->read = ft_bzip2_stream_io;
514 stream->close = ft_bzip2_stream_close;
515
516 Exit:
517 return error;
518 }
519
520 #else /* !FT_CONFIG_OPTION_USE_BZIP2 */
521
522 FT_EXPORT_DEF( FT_Error )
523 FT_Stream_OpenBzip2( FT_Stream stream,
524 FT_Stream source )
525 {
526 FT_UNUSED( stream );
527 FT_UNUSED( source );
528
529 return FT_THROW( Unimplemented_Feature );
530 }
531
532 #endif /* !FT_CONFIG_OPTION_USE_BZIP2 */
533
534
535 /* END */