ftbzip2.c (12870B)
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-2025 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 */