| /**************************************************************************** |
| * |
| * ftstream.c |
| * |
| * I/O stream support (body). |
| * |
| * Copyright (C) 2000-2024 by |
| * David Turner, Robert Wilhelm, and Werner Lemberg. |
| * |
| * This file is part of the FreeType project, and may only be used, |
| * modified, and distributed under the terms of the FreeType project |
| * license, LICENSE.TXT. By continuing to use, modify, or distribute |
| * this file you indicate that you have read the license and |
| * understand and accept it fully. |
| * |
| */ |
| |
| |
| #include <freetype/internal/ftstream.h> |
| #include <freetype/internal/ftdebug.h> |
| |
| |
| /************************************************************************** |
| * |
| * The macro FT_COMPONENT is used in trace mode. It is an implicit |
| * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log |
| * messages during execution. |
| */ |
| #undef FT_COMPONENT |
| #define FT_COMPONENT stream |
| |
| |
| FT_BASE_DEF( void ) |
| FT_Stream_OpenMemory( FT_Stream stream, |
| const FT_Byte* base, |
| FT_ULong size ) |
| { |
| stream->base = (FT_Byte*) base; |
| stream->size = size; |
| stream->pos = 0; |
| stream->cursor = NULL; |
| stream->read = NULL; |
| stream->close = NULL; |
| } |
| |
| |
| FT_BASE_DEF( void ) |
| FT_Stream_Close( FT_Stream stream ) |
| { |
| if ( stream && stream->close ) |
| stream->close( stream ); |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_Seek( FT_Stream stream, |
| FT_ULong pos ) |
| { |
| FT_Error error = FT_Err_Ok; |
| |
| |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, pos, NULL, 0 ) ) |
| { |
| FT_ERROR(( "FT_Stream_Seek:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| pos, stream->size )); |
| |
| error = FT_THROW( Invalid_Stream_Operation ); |
| } |
| } |
| /* note that seeking to the first position after the file is valid */ |
| else if ( pos > stream->size ) |
| { |
| FT_ERROR(( "FT_Stream_Seek:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| pos, stream->size )); |
| |
| error = FT_THROW( Invalid_Stream_Operation ); |
| } |
| |
| if ( !error ) |
| stream->pos = pos; |
| |
| return error; |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_Skip( FT_Stream stream, |
| FT_Long distance ) |
| { |
| if ( distance < 0 ) |
| return FT_THROW( Invalid_Stream_Operation ); |
| |
| return FT_Stream_Seek( stream, stream->pos + (FT_ULong)distance ); |
| } |
| |
| |
| FT_BASE_DEF( FT_ULong ) |
| FT_Stream_Pos( FT_Stream stream ) |
| { |
| return stream->pos; |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_Read( FT_Stream stream, |
| FT_Byte* buffer, |
| FT_ULong count ) |
| { |
| return FT_Stream_ReadAt( stream, stream->pos, buffer, count ); |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_ReadAt( FT_Stream stream, |
| FT_ULong pos, |
| FT_Byte* buffer, |
| FT_ULong count ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_ULong read_bytes; |
| |
| |
| if ( pos >= stream->size ) |
| { |
| FT_ERROR(( "FT_Stream_ReadAt:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| pos, stream->size )); |
| |
| return FT_THROW( Invalid_Stream_Operation ); |
| } |
| |
| if ( stream->read ) |
| read_bytes = stream->read( stream, pos, buffer, count ); |
| else |
| { |
| read_bytes = stream->size - pos; |
| if ( read_bytes > count ) |
| read_bytes = count; |
| |
| /* Allow "reading" zero bytes without UB even if buffer is NULL */ |
| if ( count ) |
| FT_MEM_COPY( buffer, stream->base + pos, read_bytes ); |
| } |
| |
| stream->pos = pos + read_bytes; |
| |
| if ( read_bytes < count ) |
| { |
| FT_ERROR(( "FT_Stream_ReadAt:" |
| " invalid read; expected %lu bytes, got %lu\n", |
| count, read_bytes )); |
| |
| error = FT_THROW( Invalid_Stream_Operation ); |
| } |
| |
| return error; |
| } |
| |
| |
| FT_BASE_DEF( FT_ULong ) |
| FT_Stream_TryRead( FT_Stream stream, |
| FT_Byte* buffer, |
| FT_ULong count ) |
| { |
| FT_ULong read_bytes = 0; |
| |
| |
| if ( stream->pos >= stream->size ) |
| goto Exit; |
| |
| if ( stream->read ) |
| read_bytes = stream->read( stream, stream->pos, buffer, count ); |
| else |
| { |
| read_bytes = stream->size - stream->pos; |
| if ( read_bytes > count ) |
| read_bytes = count; |
| |
| /* Allow "reading" zero bytes without UB even if buffer is NULL */ |
| if ( count ) |
| FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes ); |
| } |
| |
| stream->pos += read_bytes; |
| |
| Exit: |
| return read_bytes; |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_ExtractFrame( FT_Stream stream, |
| FT_ULong count, |
| FT_Byte** pbytes ) |
| { |
| FT_Error error; |
| |
| |
| error = FT_Stream_EnterFrame( stream, count ); |
| if ( !error ) |
| { |
| *pbytes = (FT_Byte*)stream->cursor; |
| |
| /* equivalent to FT_Stream_ExitFrame(), with no memory block release */ |
| stream->cursor = NULL; |
| stream->limit = NULL; |
| } |
| |
| return error; |
| } |
| |
| |
| FT_BASE_DEF( void ) |
| FT_Stream_ReleaseFrame( FT_Stream stream, |
| FT_Byte** pbytes ) |
| { |
| if ( stream && stream->read ) |
| { |
| FT_Memory memory = stream->memory; |
| |
| |
| #ifdef FT_DEBUG_MEMORY |
| ft_mem_free( memory, *pbytes ); |
| #else |
| FT_FREE( *pbytes ); |
| #endif |
| } |
| |
| *pbytes = NULL; |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_EnterFrame( FT_Stream stream, |
| FT_ULong count ) |
| { |
| FT_Error error = FT_Err_Ok; |
| FT_ULong read_bytes; |
| |
| |
| FT_TRACE7(( "FT_Stream_EnterFrame: %ld bytes\n", count )); |
| |
| /* check for nested frame access */ |
| FT_ASSERT( stream && stream->cursor == 0 ); |
| |
| if ( stream->read ) |
| { |
| /* allocate the frame in memory */ |
| FT_Memory memory = stream->memory; |
| |
| |
| /* simple sanity check */ |
| if ( count > stream->size ) |
| { |
| FT_ERROR(( "FT_Stream_EnterFrame:" |
| " frame size (%lu) larger than stream size (%lu)\n", |
| count, stream->size )); |
| |
| error = FT_THROW( Invalid_Stream_Operation ); |
| goto Exit; |
| } |
| |
| #ifdef FT_DEBUG_MEMORY |
| /* assume `ft_debug_file_` and `ft_debug_lineno_` are already set */ |
| stream->base = (unsigned char*)ft_mem_qalloc( memory, |
| (FT_Long)count, |
| &error ); |
| if ( error ) |
| goto Exit; |
| #else |
| if ( FT_QALLOC( stream->base, count ) ) |
| goto Exit; |
| #endif |
| /* read it */ |
| read_bytes = stream->read( stream, stream->pos, |
| stream->base, count ); |
| if ( read_bytes < count ) |
| { |
| FT_ERROR(( "FT_Stream_EnterFrame:" |
| " invalid read; expected %lu bytes, got %lu\n", |
| count, read_bytes )); |
| |
| FT_FREE( stream->base ); |
| error = FT_THROW( Invalid_Stream_Operation ); |
| } |
| |
| stream->cursor = stream->base; |
| stream->limit = FT_OFFSET( stream->cursor, count ); |
| stream->pos += read_bytes; |
| } |
| else |
| { |
| /* check current and new position */ |
| if ( stream->pos >= stream->size || |
| stream->size - stream->pos < count ) |
| { |
| FT_ERROR(( "FT_Stream_EnterFrame:" |
| " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n", |
| stream->pos, count, stream->size )); |
| |
| error = FT_THROW( Invalid_Stream_Operation ); |
| goto Exit; |
| } |
| |
| /* set cursor */ |
| stream->cursor = stream->base + stream->pos; |
| stream->limit = stream->cursor + count; |
| stream->pos += count; |
| } |
| |
| Exit: |
| return error; |
| } |
| |
| |
| FT_BASE_DEF( void ) |
| FT_Stream_ExitFrame( FT_Stream stream ) |
| { |
| /* IMPORTANT: The assertion stream->cursor != 0 was removed, given */ |
| /* that it is possible to access a frame of length 0 in */ |
| /* some weird fonts (usually, when accessing an array of */ |
| /* 0 records, like in some strange kern tables). */ |
| /* */ |
| /* In this case, the loader code handles the 0-length table */ |
| /* gracefully; however, stream.cursor is really set to 0 by the */ |
| /* FT_Stream_EnterFrame() call, and this is not an error. */ |
| |
| FT_TRACE7(( "FT_Stream_ExitFrame\n" )); |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->read ) |
| { |
| FT_Memory memory = stream->memory; |
| |
| |
| #ifdef FT_DEBUG_MEMORY |
| ft_mem_free( memory, stream->base ); |
| stream->base = NULL; |
| #else |
| FT_FREE( stream->base ); |
| #endif |
| } |
| |
| stream->cursor = NULL; |
| stream->limit = NULL; |
| } |
| |
| |
| FT_BASE_DEF( FT_Byte ) |
| FT_Stream_GetByte( FT_Stream stream ) |
| { |
| FT_Byte result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| if ( stream->cursor < stream->limit ) |
| result = *stream->cursor++; |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt16 ) |
| FT_Stream_GetUShort( FT_Stream stream ) |
| { |
| FT_Byte* p; |
| FT_UInt16 result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| p = stream->cursor; |
| if ( p + 1 < stream->limit ) |
| result = FT_NEXT_USHORT( p ); |
| stream->cursor = p; |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt16 ) |
| FT_Stream_GetUShortLE( FT_Stream stream ) |
| { |
| FT_Byte* p; |
| FT_UInt16 result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| p = stream->cursor; |
| if ( p + 1 < stream->limit ) |
| result = FT_NEXT_USHORT_LE( p ); |
| stream->cursor = p; |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt32 ) |
| FT_Stream_GetUOffset( FT_Stream stream ) |
| { |
| FT_Byte* p; |
| FT_UInt32 result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| p = stream->cursor; |
| if ( p + 2 < stream->limit ) |
| result = FT_NEXT_UOFF3( p ); |
| stream->cursor = p; |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt32 ) |
| FT_Stream_GetULong( FT_Stream stream ) |
| { |
| FT_Byte* p; |
| FT_UInt32 result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| p = stream->cursor; |
| if ( p + 3 < stream->limit ) |
| result = FT_NEXT_ULONG( p ); |
| stream->cursor = p; |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt32 ) |
| FT_Stream_GetULongLE( FT_Stream stream ) |
| { |
| FT_Byte* p; |
| FT_UInt32 result; |
| |
| |
| FT_ASSERT( stream && stream->cursor ); |
| |
| result = 0; |
| p = stream->cursor; |
| if ( p + 3 < stream->limit ) |
| result = FT_NEXT_ULONG_LE( p ); |
| stream->cursor = p; |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_Byte ) |
| FT_Stream_ReadByte( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, stream->pos, &result, 1L ) != 1L ) |
| goto Fail; |
| } |
| else |
| result = stream->base[stream->pos]; |
| } |
| else |
| goto Fail; |
| |
| stream->pos++; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadByte:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt16 ) |
| FT_Stream_ReadUShort( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte reads[2]; |
| FT_Byte* p; |
| FT_UInt16 result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos + 1 < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) |
| goto Fail; |
| |
| p = reads; |
| } |
| else |
| p = stream->base + stream->pos; |
| |
| if ( p ) |
| result = FT_NEXT_USHORT( p ); |
| } |
| else |
| goto Fail; |
| |
| stream->pos += 2; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadUShort:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt16 ) |
| FT_Stream_ReadUShortLE( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte reads[2]; |
| FT_Byte* p; |
| FT_UInt16 result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos + 1 < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, stream->pos, reads, 2L ) != 2L ) |
| goto Fail; |
| |
| p = reads; |
| } |
| else |
| p = stream->base + stream->pos; |
| |
| if ( p ) |
| result = FT_NEXT_USHORT_LE( p ); |
| } |
| else |
| goto Fail; |
| |
| stream->pos += 2; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadUShortLE:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_ULong ) |
| FT_Stream_ReadUOffset( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte reads[3]; |
| FT_Byte* p; |
| FT_ULong result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos + 2 < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if (stream->read( stream, stream->pos, reads, 3L ) != 3L ) |
| goto Fail; |
| |
| p = reads; |
| } |
| else |
| p = stream->base + stream->pos; |
| |
| if ( p ) |
| result = FT_NEXT_UOFF3( p ); |
| } |
| else |
| goto Fail; |
| |
| stream->pos += 3; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadUOffset:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt32 ) |
| FT_Stream_ReadULong( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte reads[4]; |
| FT_Byte* p; |
| FT_UInt32 result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos + 3 < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) |
| goto Fail; |
| |
| p = reads; |
| } |
| else |
| p = stream->base + stream->pos; |
| |
| if ( p ) |
| result = FT_NEXT_ULONG( p ); |
| } |
| else |
| goto Fail; |
| |
| stream->pos += 4; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadULong:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_UInt32 ) |
| FT_Stream_ReadULongLE( FT_Stream stream, |
| FT_Error* error ) |
| { |
| FT_Byte reads[4]; |
| FT_Byte* p; |
| FT_UInt32 result = 0; |
| |
| |
| FT_ASSERT( stream ); |
| |
| if ( stream->pos + 3 < stream->size ) |
| { |
| if ( stream->read ) |
| { |
| if ( stream->read( stream, stream->pos, reads, 4L ) != 4L ) |
| goto Fail; |
| |
| p = reads; |
| } |
| else |
| p = stream->base + stream->pos; |
| |
| if ( p ) |
| result = FT_NEXT_ULONG_LE( p ); |
| } |
| else |
| goto Fail; |
| |
| stream->pos += 4; |
| |
| *error = FT_Err_Ok; |
| |
| return result; |
| |
| Fail: |
| *error = FT_THROW( Invalid_Stream_Operation ); |
| FT_ERROR(( "FT_Stream_ReadULongLE:" |
| " invalid i/o; pos = 0x%lx, size = 0x%lx\n", |
| stream->pos, stream->size )); |
| |
| return result; |
| } |
| |
| |
| FT_BASE_DEF( FT_Error ) |
| FT_Stream_ReadFields( FT_Stream stream, |
| const FT_Frame_Field* fields, |
| void* structure ) |
| { |
| FT_Error error; |
| FT_Bool frame_accessed = 0; |
| FT_Byte* cursor; |
| |
| |
| if ( !fields ) |
| return FT_THROW( Invalid_Argument ); |
| |
| if ( !stream ) |
| return FT_THROW( Invalid_Stream_Handle ); |
| |
| cursor = stream->cursor; |
| |
| error = FT_Err_Ok; |
| do |
| { |
| FT_ULong value; |
| FT_Int sign_shift; |
| FT_Byte* p; |
| |
| |
| switch ( fields->value ) |
| { |
| case ft_frame_start: /* access a new frame */ |
| error = FT_Stream_EnterFrame( stream, fields->offset ); |
| if ( error ) |
| goto Exit; |
| |
| frame_accessed = 1; |
| cursor = stream->cursor; |
| fields++; |
| continue; /* loop! */ |
| |
| case ft_frame_bytes: /* read a byte sequence */ |
| case ft_frame_skip: /* skip some bytes */ |
| { |
| FT_Offset len = fields->size; |
| |
| |
| if ( len > (FT_Offset)( stream->limit - cursor ) ) |
| { |
| error = FT_THROW( Invalid_Stream_Operation ); |
| goto Exit; |
| } |
| |
| if ( fields->value == ft_frame_bytes ) |
| { |
| p = (FT_Byte*)structure + fields->offset; |
| FT_MEM_COPY( p, cursor, len ); |
| } |
| cursor += len; |
| fields++; |
| continue; |
| } |
| |
| case ft_frame_byte: |
| case ft_frame_schar: /* read a single byte */ |
| value = FT_NEXT_BYTE( cursor ); |
| sign_shift = 24; |
| break; |
| |
| case ft_frame_short_be: |
| case ft_frame_ushort_be: /* read a 2-byte big-endian short */ |
| value = FT_NEXT_USHORT( cursor ); |
| sign_shift = 16; |
| break; |
| |
| case ft_frame_short_le: |
| case ft_frame_ushort_le: /* read a 2-byte little-endian short */ |
| value = FT_NEXT_USHORT_LE( cursor ); |
| sign_shift = 16; |
| break; |
| |
| case ft_frame_long_be: |
| case ft_frame_ulong_be: /* read a 4-byte big-endian long */ |
| value = FT_NEXT_ULONG( cursor ); |
| sign_shift = 0; |
| break; |
| |
| case ft_frame_long_le: |
| case ft_frame_ulong_le: /* read a 4-byte little-endian long */ |
| value = FT_NEXT_ULONG_LE( cursor ); |
| sign_shift = 0; |
| break; |
| |
| case ft_frame_off3_be: |
| case ft_frame_uoff3_be: /* read a 3-byte big-endian long */ |
| value = FT_NEXT_UOFF3( cursor ); |
| sign_shift = 8; |
| break; |
| |
| case ft_frame_off3_le: |
| case ft_frame_uoff3_le: /* read a 3-byte little-endian long */ |
| value = FT_NEXT_UOFF3_LE( cursor ); |
| sign_shift = 8; |
| break; |
| |
| default: |
| /* otherwise, exit the loop */ |
| stream->cursor = cursor; |
| goto Exit; |
| } |
| |
| /* now, compute the signed value if necessary */ |
| if ( fields->value & FT_FRAME_OP_SIGNED ) |
| value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift ); |
| |
| /* finally, store the value in the object */ |
| |
| p = (FT_Byte*)structure + fields->offset; |
| switch ( fields->size ) |
| { |
| case ( 8 / FT_CHAR_BIT ): |
| *(FT_Byte*)p = (FT_Byte)value; |
| break; |
| |
| case ( 16 / FT_CHAR_BIT ): |
| *(FT_UShort*)p = (FT_UShort)value; |
| break; |
| |
| case ( 32 / FT_CHAR_BIT ): |
| *(FT_UInt32*)p = (FT_UInt32)value; |
| break; |
| |
| default: /* for 64-bit systems */ |
| *(FT_ULong*)p = (FT_ULong)value; |
| } |
| |
| /* go to next field */ |
| fields++; |
| } |
| while ( 1 ); |
| |
| Exit: |
| /* close the frame if it was opened by this read */ |
| if ( frame_accessed ) |
| FT_Stream_ExitFrame( stream ); |
| |
| return error; |
| } |
| |
| |
| /* END */ |