1/***************************************************************************/ 2/* */ 3/* ftstream.c */ 4/* */ 5/* I/O stream support (body). */ 6/* */ 7/* Copyright 2000-2002, 2004-2006, 2008-2011, 2013 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used, */ 11/* modified, and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19#include <ft2build.h> 20#include FT_INTERNAL_STREAM_H 21#include FT_INTERNAL_DEBUG_H 22 23 24 /*************************************************************************/ 25 /* */ 26 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 27 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 28 /* messages during execution. */ 29 /* */ 30#undef FT_COMPONENT 31#define FT_COMPONENT trace_stream 32 33 34 FT_BASE_DEF( void ) 35 FT_Stream_OpenMemory( FT_Stream stream, 36 const FT_Byte* base, 37 FT_ULong size ) 38 { 39 stream->base = (FT_Byte*) base; 40 stream->size = size; 41 stream->pos = 0; 42 stream->cursor = 0; 43 stream->read = 0; 44 stream->close = 0; 45 } 46 47 48 FT_BASE_DEF( void ) 49 FT_Stream_Close( FT_Stream stream ) 50 { 51 if ( stream && stream->close ) 52 stream->close( stream ); 53 } 54 55 56 FT_BASE_DEF( FT_Error ) 57 FT_Stream_Seek( FT_Stream stream, 58 FT_ULong pos ) 59 { 60 FT_Error error = FT_Err_Ok; 61 62 63 if ( stream->read ) 64 { 65 if ( stream->read( stream, pos, 0, 0 ) ) 66 { 67 FT_ERROR(( "FT_Stream_Seek:" 68 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 69 pos, stream->size )); 70 71 error = FT_THROW( Invalid_Stream_Operation ); 72 } 73 } 74 /* note that seeking to the first position after the file is valid */ 75 else if ( pos > stream->size ) 76 { 77 FT_ERROR(( "FT_Stream_Seek:" 78 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 79 pos, stream->size )); 80 81 error = FT_THROW( Invalid_Stream_Operation ); 82 } 83 84 if ( !error ) 85 stream->pos = pos; 86 87 return error; 88 } 89 90 91 FT_BASE_DEF( FT_Error ) 92 FT_Stream_Skip( FT_Stream stream, 93 FT_Long distance ) 94 { 95 if ( distance < 0 ) 96 return FT_THROW( Invalid_Stream_Operation ); 97 98 return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) ); 99 } 100 101 102 FT_BASE_DEF( FT_Long ) 103 FT_Stream_Pos( FT_Stream stream ) 104 { 105 return stream->pos; 106 } 107 108 109 FT_BASE_DEF( FT_Error ) 110 FT_Stream_Read( FT_Stream stream, 111 FT_Byte* buffer, 112 FT_ULong count ) 113 { 114 return FT_Stream_ReadAt( stream, stream->pos, buffer, count ); 115 } 116 117 118 FT_BASE_DEF( FT_Error ) 119 FT_Stream_ReadAt( FT_Stream stream, 120 FT_ULong pos, 121 FT_Byte* buffer, 122 FT_ULong count ) 123 { 124 FT_Error error = FT_Err_Ok; 125 FT_ULong read_bytes; 126 127 128 if ( pos >= stream->size ) 129 { 130 FT_ERROR(( "FT_Stream_ReadAt:" 131 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 132 pos, stream->size )); 133 134 return FT_THROW( Invalid_Stream_Operation ); 135 } 136 137 if ( stream->read ) 138 read_bytes = stream->read( stream, pos, buffer, count ); 139 else 140 { 141 read_bytes = stream->size - pos; 142 if ( read_bytes > count ) 143 read_bytes = count; 144 145 FT_MEM_COPY( buffer, stream->base + pos, read_bytes ); 146 } 147 148 stream->pos = pos + read_bytes; 149 150 if ( read_bytes < count ) 151 { 152 FT_ERROR(( "FT_Stream_ReadAt:" 153 " invalid read; expected %lu bytes, got %lu\n", 154 count, read_bytes )); 155 156 error = FT_THROW( Invalid_Stream_Operation ); 157 } 158 159 return error; 160 } 161 162 163 FT_BASE_DEF( FT_ULong ) 164 FT_Stream_TryRead( FT_Stream stream, 165 FT_Byte* buffer, 166 FT_ULong count ) 167 { 168 FT_ULong read_bytes = 0; 169 170 171 if ( stream->pos >= stream->size ) 172 goto Exit; 173 174 if ( stream->read ) 175 read_bytes = stream->read( stream, stream->pos, buffer, count ); 176 else 177 { 178 read_bytes = stream->size - stream->pos; 179 if ( read_bytes > count ) 180 read_bytes = count; 181 182 FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes ); 183 } 184 185 stream->pos += read_bytes; 186 187 Exit: 188 return read_bytes; 189 } 190 191 192 FT_BASE_DEF( FT_Error ) 193 FT_Stream_ExtractFrame( FT_Stream stream, 194 FT_ULong count, 195 FT_Byte** pbytes ) 196 { 197 FT_Error error; 198 199 200 error = FT_Stream_EnterFrame( stream, count ); 201 if ( !error ) 202 { 203 *pbytes = (FT_Byte*)stream->cursor; 204 205 /* equivalent to FT_Stream_ExitFrame(), with no memory block release */ 206 stream->cursor = 0; 207 stream->limit = 0; 208 } 209 210 return error; 211 } 212 213 214 FT_BASE_DEF( void ) 215 FT_Stream_ReleaseFrame( FT_Stream stream, 216 FT_Byte** pbytes ) 217 { 218 if ( stream && stream->read ) 219 { 220 FT_Memory memory = stream->memory; 221 222#ifdef FT_DEBUG_MEMORY 223 ft_mem_free( memory, *pbytes ); 224 *pbytes = NULL; 225#else 226 FT_FREE( *pbytes ); 227#endif 228 } 229 *pbytes = 0; 230 } 231 232 233 FT_BASE_DEF( FT_Error ) 234 FT_Stream_EnterFrame( FT_Stream stream, 235 FT_ULong count ) 236 { 237 FT_Error error = FT_Err_Ok; 238 FT_ULong read_bytes; 239 240 241 /* check for nested frame access */ 242 FT_ASSERT( stream && stream->cursor == 0 ); 243 244 if ( stream->read ) 245 { 246 /* allocate the frame in memory */ 247 FT_Memory memory = stream->memory; 248 249 250 /* simple sanity check */ 251 if ( count > stream->size ) 252 { 253 FT_ERROR(( "FT_Stream_EnterFrame:" 254 " frame size (%lu) larger than stream size (%lu)\n", 255 count, stream->size )); 256 257 error = FT_THROW( Invalid_Stream_Operation ); 258 goto Exit; 259 } 260 261#ifdef FT_DEBUG_MEMORY 262 /* assume _ft_debug_file and _ft_debug_lineno are already set */ 263 stream->base = (unsigned char*)ft_mem_qalloc( memory, count, &error ); 264 if ( error ) 265 goto Exit; 266#else 267 if ( FT_QALLOC( stream->base, count ) ) 268 goto Exit; 269#endif 270 /* read it */ 271 read_bytes = stream->read( stream, stream->pos, 272 stream->base, count ); 273 if ( read_bytes < count ) 274 { 275 FT_ERROR(( "FT_Stream_EnterFrame:" 276 " invalid read; expected %lu bytes, got %lu\n", 277 count, read_bytes )); 278 279 FT_FREE( stream->base ); 280 error = FT_THROW( Invalid_Stream_Operation ); 281 } 282 stream->cursor = stream->base; 283 stream->limit = stream->cursor + count; 284 stream->pos += read_bytes; 285 } 286 else 287 { 288 /* check current and new position */ 289 if ( stream->pos >= stream->size || 290 stream->size - stream->pos < count ) 291 { 292 FT_ERROR(( "FT_Stream_EnterFrame:" 293 " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n", 294 stream->pos, count, stream->size )); 295 296 error = FT_THROW( Invalid_Stream_Operation ); 297 goto Exit; 298 } 299 300 /* set cursor */ 301 stream->cursor = stream->base + stream->pos; 302 stream->limit = stream->cursor + count; 303 stream->pos += count; 304 } 305 306 Exit: 307 return error; 308 } 309 310 311 FT_BASE_DEF( void ) 312 FT_Stream_ExitFrame( FT_Stream stream ) 313 { 314 /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */ 315 /* that it is possible to access a frame of length 0 in */ 316 /* some weird fonts (usually, when accessing an array of */ 317 /* 0 records, like in some strange kern tables). */ 318 /* */ 319 /* In this case, the loader code handles the 0-length table */ 320 /* gracefully; however, stream.cursor is really set to 0 by the */ 321 /* FT_Stream_EnterFrame() call, and this is not an error. */ 322 /* */ 323 FT_ASSERT( stream ); 324 325 if ( stream->read ) 326 { 327 FT_Memory memory = stream->memory; 328 329#ifdef FT_DEBUG_MEMORY 330 ft_mem_free( memory, stream->base ); 331 stream->base = NULL; 332#else 333 FT_FREE( stream->base ); 334#endif 335 } 336 stream->cursor = 0; 337 stream->limit = 0; 338 } 339 340 341 FT_BASE_DEF( FT_Char ) 342 FT_Stream_GetChar( FT_Stream stream ) 343 { 344 FT_Char result; 345 346 347 FT_ASSERT( stream && stream->cursor ); 348 349 result = 0; 350 if ( stream->cursor < stream->limit ) 351 result = *stream->cursor++; 352 353 return result; 354 } 355 356 357 FT_BASE_DEF( FT_UShort ) 358 FT_Stream_GetUShort( FT_Stream stream ) 359 { 360 FT_Byte* p; 361 FT_Short result; 362 363 364 FT_ASSERT( stream && stream->cursor ); 365 366 result = 0; 367 p = stream->cursor; 368 if ( p + 1 < stream->limit ) 369 result = FT_NEXT_USHORT( p ); 370 stream->cursor = p; 371 372 return result; 373 } 374 375 376 FT_BASE_DEF( FT_UShort ) 377 FT_Stream_GetUShortLE( FT_Stream stream ) 378 { 379 FT_Byte* p; 380 FT_Short result; 381 382 383 FT_ASSERT( stream && stream->cursor ); 384 385 result = 0; 386 p = stream->cursor; 387 if ( p + 1 < stream->limit ) 388 result = FT_NEXT_USHORT_LE( p ); 389 stream->cursor = p; 390 391 return result; 392 } 393 394 395 FT_BASE_DEF( FT_ULong ) 396 FT_Stream_GetUOffset( FT_Stream stream ) 397 { 398 FT_Byte* p; 399 FT_Long result; 400 401 402 FT_ASSERT( stream && stream->cursor ); 403 404 result = 0; 405 p = stream->cursor; 406 if ( p + 2 < stream->limit ) 407 result = FT_NEXT_UOFF3( p ); 408 stream->cursor = p; 409 return result; 410 } 411 412 413 FT_BASE_DEF( FT_ULong ) 414 FT_Stream_GetULong( FT_Stream stream ) 415 { 416 FT_Byte* p; 417 FT_Long result; 418 419 420 FT_ASSERT( stream && stream->cursor ); 421 422 result = 0; 423 p = stream->cursor; 424 if ( p + 3 < stream->limit ) 425 result = FT_NEXT_ULONG( p ); 426 stream->cursor = p; 427 return result; 428 } 429 430 431 FT_BASE_DEF( FT_ULong ) 432 FT_Stream_GetULongLE( FT_Stream stream ) 433 { 434 FT_Byte* p; 435 FT_Long result; 436 437 438 FT_ASSERT( stream && stream->cursor ); 439 440 result = 0; 441 p = stream->cursor; 442 if ( p + 3 < stream->limit ) 443 result = FT_NEXT_ULONG_LE( p ); 444 stream->cursor = p; 445 return result; 446 } 447 448 449 FT_BASE_DEF( FT_Char ) 450 FT_Stream_ReadChar( FT_Stream stream, 451 FT_Error* error ) 452 { 453 FT_Byte result = 0; 454 455 456 FT_ASSERT( stream ); 457 458 *error = FT_Err_Ok; 459 460 if ( stream->read ) 461 { 462 if ( stream->read( stream, stream->pos, &result, 1L ) != 1L ) 463 goto Fail; 464 } 465 else 466 { 467 if ( stream->pos < stream->size ) 468 result = stream->base[stream->pos]; 469 else 470 goto Fail; 471 } 472 stream->pos++; 473 474 return result; 475 476 Fail: 477 *error = FT_THROW( Invalid_Stream_Operation ); 478 FT_ERROR(( "FT_Stream_ReadChar:" 479 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 480 stream->pos, stream->size )); 481 482 return 0; 483 } 484 485 486 FT_BASE_DEF( FT_UShort ) 487 FT_Stream_ReadUShort( FT_Stream stream, 488 FT_Error* error ) 489 { 490 FT_Byte reads[2]; 491 FT_Byte* p = 0; 492 FT_Short result = 0; 493 494 495 FT_ASSERT( stream ); 496 497 *error = FT_Err_Ok; 498 499 if ( stream->pos + 1 < stream->size ) 500 { 501 if ( stream->read ) 502 { 503 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) 504 goto Fail; 505 506 p = reads; 507 } 508 else 509 { 510 p = stream->base + stream->pos; 511 } 512 513 if ( p ) 514 result = FT_NEXT_USHORT( p ); 515 } 516 else 517 goto Fail; 518 519 stream->pos += 2; 520 521 return result; 522 523 Fail: 524 *error = FT_THROW( Invalid_Stream_Operation ); 525 FT_ERROR(( "FT_Stream_ReadUShort:" 526 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 527 stream->pos, stream->size )); 528 529 return 0; 530 } 531 532 533 FT_BASE_DEF( FT_UShort ) 534 FT_Stream_ReadUShortLE( FT_Stream stream, 535 FT_Error* error ) 536 { 537 FT_Byte reads[2]; 538 FT_Byte* p = 0; 539 FT_Short result = 0; 540 541 542 FT_ASSERT( stream ); 543 544 *error = FT_Err_Ok; 545 546 if ( stream->pos + 1 < stream->size ) 547 { 548 if ( stream->read ) 549 { 550 if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) 551 goto Fail; 552 553 p = reads; 554 } 555 else 556 { 557 p = stream->base + stream->pos; 558 } 559 560 if ( p ) 561 result = FT_NEXT_USHORT_LE( p ); 562 } 563 else 564 goto Fail; 565 566 stream->pos += 2; 567 568 return result; 569 570 Fail: 571 *error = FT_THROW( Invalid_Stream_Operation ); 572 FT_ERROR(( "FT_Stream_ReadUShortLE:" 573 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 574 stream->pos, stream->size )); 575 576 return 0; 577 } 578 579 580 FT_BASE_DEF( FT_ULong ) 581 FT_Stream_ReadUOffset( FT_Stream stream, 582 FT_Error* error ) 583 { 584 FT_Byte reads[3]; 585 FT_Byte* p = 0; 586 FT_Long result = 0; 587 588 589 FT_ASSERT( stream ); 590 591 *error = FT_Err_Ok; 592 593 if ( stream->pos + 2 < stream->size ) 594 { 595 if ( stream->read ) 596 { 597 if (stream->read( stream, stream->pos, reads, 3L ) != 3L ) 598 goto Fail; 599 600 p = reads; 601 } 602 else 603 { 604 p = stream->base + stream->pos; 605 } 606 607 if ( p ) 608 result = FT_NEXT_UOFF3( p ); 609 } 610 else 611 goto Fail; 612 613 stream->pos += 3; 614 615 return result; 616 617 Fail: 618 *error = FT_THROW( Invalid_Stream_Operation ); 619 FT_ERROR(( "FT_Stream_ReadUOffset:" 620 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 621 stream->pos, stream->size )); 622 623 return 0; 624 } 625 626 627 FT_BASE_DEF( FT_ULong ) 628 FT_Stream_ReadULong( FT_Stream stream, 629 FT_Error* error ) 630 { 631 FT_Byte reads[4]; 632 FT_Byte* p = 0; 633 FT_Long result = 0; 634 635 636 FT_ASSERT( stream ); 637 638 *error = FT_Err_Ok; 639 640 if ( stream->pos + 3 < stream->size ) 641 { 642 if ( stream->read ) 643 { 644 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) 645 goto Fail; 646 647 p = reads; 648 } 649 else 650 { 651 p = stream->base + stream->pos; 652 } 653 654 if ( p ) 655 result = FT_NEXT_ULONG( p ); 656 } 657 else 658 goto Fail; 659 660 stream->pos += 4; 661 662 return result; 663 664 Fail: 665 *error = FT_THROW( Invalid_Stream_Operation ); 666 FT_ERROR(( "FT_Stream_ReadULong:" 667 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 668 stream->pos, stream->size )); 669 670 return 0; 671 } 672 673 674 FT_BASE_DEF( FT_ULong ) 675 FT_Stream_ReadULongLE( FT_Stream stream, 676 FT_Error* error ) 677 { 678 FT_Byte reads[4]; 679 FT_Byte* p = 0; 680 FT_Long result = 0; 681 682 683 FT_ASSERT( stream ); 684 685 *error = FT_Err_Ok; 686 687 if ( stream->pos + 3 < stream->size ) 688 { 689 if ( stream->read ) 690 { 691 if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) 692 goto Fail; 693 694 p = reads; 695 } 696 else 697 { 698 p = stream->base + stream->pos; 699 } 700 701 if ( p ) 702 result = FT_NEXT_ULONG_LE( p ); 703 } 704 else 705 goto Fail; 706 707 stream->pos += 4; 708 709 return result; 710 711 Fail: 712 *error = FT_THROW( Invalid_Stream_Operation ); 713 FT_ERROR(( "FT_Stream_ReadULongLE:" 714 " invalid i/o; pos = 0x%lx, size = 0x%lx\n", 715 stream->pos, stream->size )); 716 717 return 0; 718 } 719 720 721 FT_BASE_DEF( FT_Error ) 722 FT_Stream_ReadFields( FT_Stream stream, 723 const FT_Frame_Field* fields, 724 void* structure ) 725 { 726 FT_Error error; 727 FT_Bool frame_accessed = 0; 728 FT_Byte* cursor; 729 730 731 if ( !fields || !stream ) 732 return FT_THROW( Invalid_Argument ); 733 734 cursor = stream->cursor; 735 736 error = FT_Err_Ok; 737 do 738 { 739 FT_ULong value; 740 FT_Int sign_shift; 741 FT_Byte* p; 742 743 744 switch ( fields->value ) 745 { 746 case ft_frame_start: /* access a new frame */ 747 error = FT_Stream_EnterFrame( stream, fields->offset ); 748 if ( error ) 749 goto Exit; 750 751 frame_accessed = 1; 752 cursor = stream->cursor; 753 fields++; 754 continue; /* loop! */ 755 756 case ft_frame_bytes: /* read a byte sequence */ 757 case ft_frame_skip: /* skip some bytes */ 758 { 759 FT_UInt len = fields->size; 760 761 762 if ( cursor + len > stream->limit ) 763 { 764 error = FT_THROW( Invalid_Stream_Operation ); 765 goto Exit; 766 } 767 768 if ( fields->value == ft_frame_bytes ) 769 { 770 p = (FT_Byte*)structure + fields->offset; 771 FT_MEM_COPY( p, cursor, len ); 772 } 773 cursor += len; 774 fields++; 775 continue; 776 } 777 778 case ft_frame_byte: 779 case ft_frame_schar: /* read a single byte */ 780 value = FT_NEXT_BYTE( cursor ); 781 sign_shift = 24; 782 break; 783 784 case ft_frame_short_be: 785 case ft_frame_ushort_be: /* read a 2-byte big-endian short */ 786 value = FT_NEXT_USHORT( cursor) ; 787 sign_shift = 16; 788 break; 789 790 case ft_frame_short_le: 791 case ft_frame_ushort_le: /* read a 2-byte little-endian short */ 792 value = FT_NEXT_USHORT_LE( cursor ); 793 sign_shift = 16; 794 break; 795 796 case ft_frame_long_be: 797 case ft_frame_ulong_be: /* read a 4-byte big-endian long */ 798 value = FT_NEXT_ULONG( cursor ); 799 sign_shift = 0; 800 break; 801 802 case ft_frame_long_le: 803 case ft_frame_ulong_le: /* read a 4-byte little-endian long */ 804 value = FT_NEXT_ULONG_LE( cursor ); 805 sign_shift = 0; 806 break; 807 808 case ft_frame_off3_be: 809 case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ 810 value = FT_NEXT_UOFF3( cursor ); 811 sign_shift = 8; 812 break; 813 814 case ft_frame_off3_le: 815 case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ 816 value = FT_NEXT_UOFF3_LE( cursor ); 817 sign_shift = 8; 818 break; 819 820 default: 821 /* otherwise, exit the loop */ 822 stream->cursor = cursor; 823 goto Exit; 824 } 825 826 /* now, compute the signed value is necessary */ 827 if ( fields->value & FT_FRAME_OP_SIGNED ) 828 value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift ); 829 830 /* finally, store the value in the object */ 831 832 p = (FT_Byte*)structure + fields->offset; 833 switch ( fields->size ) 834 { 835 case ( 8 / FT_CHAR_BIT ): 836 *(FT_Byte*)p = (FT_Byte)value; 837 break; 838 839 case ( 16 / FT_CHAR_BIT ): 840 *(FT_UShort*)p = (FT_UShort)value; 841 break; 842 843 case ( 32 / FT_CHAR_BIT ): 844 *(FT_UInt32*)p = (FT_UInt32)value; 845 break; 846 847 default: /* for 64-bit systems */ 848 *(FT_ULong*)p = (FT_ULong)value; 849 } 850 851 /* go to next field */ 852 fields++; 853 } 854 while ( 1 ); 855 856 Exit: 857 /* close the frame if it was opened by this read */ 858 if ( frame_accessed ) 859 FT_Stream_ExitFrame( stream ); 860 861 return error; 862 } 863 864 865/* END */ 866