1 /***************************************************************************/ 2 /* */ 3 /* ftlzw.c */ 4 /* */ 5 /* FreeType support for .Z compressed files. */ 6 /* */ 7 /* This optional component relies on NetBSD's zopen(). It should mainly */ 8 /* be used to parse compressed PCF fonts, as found with many X11 server */ 9 /* distributions. */ 10 /* */ 11 /* Copyright 2004-2018 by */ 12 /* Albert Chin-A-Young. */ 13 /* */ 14 /* based on code in `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 #include <ft2build.h> 25 #include FT_INTERNAL_MEMORY_H 26 #include FT_INTERNAL_STREAM_H 27 #include FT_INTERNAL_DEBUG_H 28 #include FT_LZW_H 29 #include FT_CONFIG_STANDARD_LIBRARY_H 30 31 32 #include FT_MODULE_ERRORS_H 33 34 #undef FTERRORS_H_ 35 36 #undef FT_ERR_PREFIX 37 #define FT_ERR_PREFIX LZW_Err_ 38 #define FT_ERR_BASE FT_Mod_Err_LZW 39 40 #include FT_ERRORS_H 41 42 43 #ifdef FT_CONFIG_OPTION_USE_LZW 44 45 #ifdef FT_CONFIG_OPTION_PIC 46 #error "lzw code does not support PIC yet" 47 #endif 48 49 #include "ftzopen.h" 50 51 52 /***************************************************************************/ 53 /***************************************************************************/ 54 /***** *****/ 55 /***** M E M O R Y M A N A G E M E N T *****/ 56 /***** *****/ 57 /***************************************************************************/ 58 /***************************************************************************/ 59 60 /***************************************************************************/ 61 /***************************************************************************/ 62 /***** *****/ 63 /***** F I L E D E S C R I P T O R *****/ 64 /***** *****/ 65 /***************************************************************************/ 66 /***************************************************************************/ 67 68 #define FT_LZW_BUFFER_SIZE 4096 69 70 typedef struct FT_LZWFileRec_ 71 { 72 FT_Stream source; /* parent/source stream */ 73 FT_Stream stream; /* embedding stream */ 74 FT_Memory memory; /* memory allocator */ 75 FT_LzwStateRec lzw; /* lzw decompressor state */ 76 77 FT_Byte buffer[FT_LZW_BUFFER_SIZE]; /* output buffer */ 78 FT_ULong pos; /* position in output */ 79 FT_Byte* cursor; 80 FT_Byte* limit; 81 82 } FT_LZWFileRec, *FT_LZWFile; 83 84 85 /* check and skip .Z header */ 86 static FT_Error 87 ft_lzw_check_header( FT_Stream stream ) 88 { 89 FT_Error error; 90 FT_Byte head[2]; 91 92 93 if ( FT_STREAM_SEEK( 0 ) || 94 FT_STREAM_READ( head, 2 ) ) 95 goto Exit; 96 97 /* head[0] && head[1] are the magic numbers */ 98 if ( head[0] != 0x1F || 99 head[1] != 0x9D ) 100 error = FT_THROW( Invalid_File_Format ); 101 102 Exit: 103 return error; 104 } 105 106 107 static FT_Error 108 ft_lzw_file_init( FT_LZWFile zip, 109 FT_Stream stream, 110 FT_Stream source ) 111 { 112 FT_LzwState lzw = &zip->lzw; 113 FT_Error error; 114 115 116 zip->stream = stream; 117 zip->source = source; 118 zip->memory = stream->memory; 119 120 zip->limit = zip->buffer + FT_LZW_BUFFER_SIZE; 121 zip->cursor = zip->limit; 122 zip->pos = 0; 123 124 /* check and skip .Z header */ 125 error = ft_lzw_check_header( source ); 126 if ( error ) 127 goto Exit; 128 129 /* initialize internal lzw variable */ 130 ft_lzwstate_init( lzw, source ); 131 132 Exit: 133 return error; 134 } 135 136 137 static void 138 ft_lzw_file_done( FT_LZWFile zip ) 139 { 140 /* clear the rest */ 141 ft_lzwstate_done( &zip->lzw ); 142 143 zip->memory = NULL; 144 zip->source = NULL; 145 zip->stream = NULL; 146 } 147 148 149 static FT_Error 150 ft_lzw_file_reset( FT_LZWFile zip ) 151 { 152 FT_Stream stream = zip->source; 153 FT_Error error; 154 155 156 if ( !FT_STREAM_SEEK( 0 ) ) 157 { 158 ft_lzwstate_reset( &zip->lzw ); 159 160 zip->limit = zip->buffer + FT_LZW_BUFFER_SIZE; 161 zip->cursor = zip->limit; 162 zip->pos = 0; 163 } 164 165 return error; 166 } 167 168 169 static FT_Error 170 ft_lzw_file_fill_output( FT_LZWFile zip ) 171 { 172 FT_LzwState lzw = &zip->lzw; 173 FT_ULong count; 174 FT_Error error = FT_Err_Ok; 175 176 177 zip->cursor = zip->buffer; 178 179 count = ft_lzwstate_io( lzw, zip->buffer, FT_LZW_BUFFER_SIZE ); 180 181 zip->limit = zip->cursor + count; 182 183 if ( count == 0 ) 184 error = FT_THROW( Invalid_Stream_Operation ); 185 186 return error; 187 } 188 189 190 /* fill output buffer; `count' must be <= FT_LZW_BUFFER_SIZE */ 191 static FT_Error 192 ft_lzw_file_skip_output( FT_LZWFile zip, 193 FT_ULong count ) 194 { 195 FT_Error error = FT_Err_Ok; 196 197 198 /* first, we skip what we can from the output buffer */ 199 { 200 FT_ULong delta = (FT_ULong)( zip->limit - zip->cursor ); 201 202 203 if ( delta >= count ) 204 delta = count; 205 206 zip->cursor += delta; 207 zip->pos += delta; 208 209 count -= delta; 210 } 211 212 /* next, we skip as many bytes remaining as possible */ 213 while ( count > 0 ) 214 { 215 FT_ULong delta = FT_LZW_BUFFER_SIZE; 216 FT_ULong numread; 217 218 219 if ( delta > count ) 220 delta = count; 221 222 numread = ft_lzwstate_io( &zip->lzw, NULL, delta ); 223 if ( numread < delta ) 224 { 225 /* not enough bytes */ 226 error = FT_THROW( Invalid_Stream_Operation ); 227 break; 228 } 229 230 zip->pos += delta; 231 count -= delta; 232 } 233 234 return error; 235 } 236 237 238 static FT_ULong 239 ft_lzw_file_io( FT_LZWFile zip, 240 FT_ULong pos, 241 FT_Byte* buffer, 242 FT_ULong count ) 243 { 244 FT_ULong result = 0; 245 FT_Error error; 246 247 248 /* seeking backwards. */ 249 if ( pos < zip->pos ) 250 { 251 /* If the new position is within the output buffer, simply */ 252 /* decrement pointers, otherwise we reset the stream completely! */ 253 if ( ( zip->pos - pos ) <= (FT_ULong)( zip->cursor - zip->buffer ) ) 254 { 255 zip->cursor -= zip->pos - pos; 256 zip->pos = pos; 257 } 258 else 259 { 260 error = ft_lzw_file_reset( zip ); 261 if ( error ) 262 goto Exit; 263 } 264 } 265 266 /* skip unwanted bytes */ 267 if ( pos > zip->pos ) 268 { 269 error = ft_lzw_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) ); 270 if ( error ) 271 goto Exit; 272 } 273 274 if ( count == 0 ) 275 goto Exit; 276 277 /* now read the data */ 278 for (;;) 279 { 280 FT_ULong delta; 281 282 283 delta = (FT_ULong)( zip->limit - zip->cursor ); 284 if ( delta >= count ) 285 delta = count; 286 287 FT_MEM_COPY( buffer + result, zip->cursor, delta ); 288 result += delta; 289 zip->cursor += delta; 290 zip->pos += delta; 291 292 count -= delta; 293 if ( count == 0 ) 294 break; 295 296 error = ft_lzw_file_fill_output( zip ); 297 if ( error ) 298 break; 299 } 300 301 Exit: 302 return result; 303 } 304 305 306 /***************************************************************************/ 307 /***************************************************************************/ 308 /***** *****/ 309 /***** L Z W E M B E D D I N G S T R E A M *****/ 310 /***** *****/ 311 /***************************************************************************/ 312 /***************************************************************************/ 313 314 static void 315 ft_lzw_stream_close( FT_Stream stream ) 316 { 317 FT_LZWFile zip = (FT_LZWFile)stream->descriptor.pointer; 318 FT_Memory memory = stream->memory; 319 320 321 if ( zip ) 322 { 323 /* finalize lzw file descriptor */ 324 ft_lzw_file_done( zip ); 325 326 FT_FREE( zip ); 327 328 stream->descriptor.pointer = NULL; 329 } 330 } 331 332 333 static unsigned long 334 ft_lzw_stream_io( FT_Stream stream, 335 unsigned long offset, 336 unsigned char* buffer, 337 unsigned long count ) 338 { 339 FT_LZWFile zip = (FT_LZWFile)stream->descriptor.pointer; 340 341 342 return ft_lzw_file_io( zip, offset, buffer, count ); 343 } 344 345 346 FT_EXPORT_DEF( FT_Error ) 347 FT_Stream_OpenLZW( FT_Stream stream, 348 FT_Stream source ) 349 { 350 FT_Error error; 351 FT_Memory memory; 352 FT_LZWFile zip = NULL; 353 354 355 if ( !stream || !source ) 356 { 357 error = FT_THROW( Invalid_Stream_Handle ); 358 goto Exit; 359 } 360 361 memory = source->memory; 362 363 /* 364 * Check the header right now; this prevents allocation of a huge 365 * LZWFile object (400 KByte of heap memory) if not necessary. 366 * 367 * Did I mention that you should never use .Z compressed font 368 * files? 369 */ 370 error = ft_lzw_check_header( source ); 371 if ( error ) 372 goto Exit; 373 374 FT_ZERO( stream ); 375 stream->memory = memory; 376 377 if ( !FT_NEW( zip ) ) 378 { 379 error = ft_lzw_file_init( zip, stream, source ); 380 if ( error ) 381 { 382 FT_FREE( zip ); 383 goto Exit; 384 } 385 386 stream->descriptor.pointer = zip; 387 } 388 389 stream->size = 0x7FFFFFFFL; /* don't know the real size! */ 390 stream->pos = 0; 391 stream->base = 0; 392 stream->read = ft_lzw_stream_io; 393 stream->close = ft_lzw_stream_close; 394 395 Exit: 396 return error; 397 } 398 399 400 #include "ftzopen.c" 401 402 403 #else /* !FT_CONFIG_OPTION_USE_LZW */ 404 405 406 FT_EXPORT_DEF( FT_Error ) 407 FT_Stream_OpenLZW( FT_Stream stream, 408 FT_Stream source ) 409 { 410 FT_UNUSED( stream ); 411 FT_UNUSED( source ); 412 413 return FT_THROW( Unimplemented_Feature ); 414 } 415 416 417 #endif /* !FT_CONFIG_OPTION_USE_LZW */ 418 419 420 /* END */ 421
