ftrfork.c File Reference

#include <ft2build.h>
#include "basepic.h"
#include "ftbase.h"

Include dependency graph for ftrfork.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FT_COMPONENT   trace_raccess

Functions
	FT_Raccess_Get_HeaderInfo (FT_Library library, FT_Stream stream, FT_Long rfork_offset, FT_Long *map_offset, FT_Long *rdata_pos)
static int	ft_raccess_sort_ref_by_id (FT_RFork_Ref *a, FT_RFork_Ref *b)
	FT_Raccess_Get_DataOffsets (FT_Library library, FT_Stream stream, FT_Long map_offset, FT_Long rdata_pos, FT_Long tag, FT_Bool sort_by_res_id, FT_Long **offsets, FT_Long *count)
	FT_Raccess_Guess (FT_Library library, FT_Stream stream, char *base_name, char **new_names, FT_Long *offsets, FT_Error *errors)

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_raccess

Definition at line 35 of file ftrfork.c.

Function Documentation

FT_Raccess_Get_DataOffsets()

FT_Raccess_Get_DataOffsets	(	FT_Library	library,
		FT_Stream	stream,
		FT_Long	map_offset,
		FT_Long	rdata_pos,
		FT_Long	tag,
		FT_Bool	sort_by_res_id,
		FT_Long **	offsets,
		FT_Long *	count
	)

Definition at line 185 of file ftrfork.c.

  {
    FT_Error      error;
    int           i, j, cnt, subcnt;
    FT_Long       tag_internal, rpos;
    FT_Memory     memory = library->memory;
    FT_Long       temp;
    FT_Long       *offsets_internal = NULL;
    FT_RFork_Ref  *ref = NULL;
 
 
    FT_TRACE3(( "\n" ));
    error = FT_Stream_Seek( stream, (FT_ULong)map_offset );
    if ( error )
      return error;
 
    if ( FT_READ_SHORT( cnt ) )
      return error;
    cnt++;
 
    /* `rpos' is a signed 16bit integer offset to resource records; the    */
    /* size of a resource record is 12 bytes.  The map header is 28 bytes, */
    /* and a type list needs 10 bytes or more.  If we assume that the name */
    /* list is empty and we have only a single entry in the type list,     */
    /* there can be at most                                                */
    /*                                                                     */
    /*   (32768 - 28 - 10) / 12 = 2727                                     */
    /*                                                                     */
    /* resources.                                                          */
    /*                                                                     */
    /* A type list starts with a two-byte counter, followed by 10-byte     */
    /* type records.  Assuming that there are no resources, the number of  */
    /* type records can be at most                                         */
    /*                                                                     */
    /*   (32768 - 28 - 2) / 8 = 4079                                       */
    /*                                                                     */
    if ( cnt > 4079 )
      return FT_THROW( Invalid_Table );
 
    for ( i = 0; i < cnt; i++ )
    {
      if ( FT_READ_LONG( tag_internal ) ||
           FT_READ_SHORT( subcnt )      ||
           FT_READ_SHORT( rpos )        )
        return error;
 
      FT_TRACE2(( "Resource tags: %c%c%c%c\n",
                  (char)( 0xFF & ( tag_internal >> 24 ) ),
                  (char)( 0xFF & ( tag_internal >> 16 ) ),
                  (char)( 0xFF & ( tag_internal >>  8 ) ),
                  (char)( 0xFF & ( tag_internal >>  0 ) ) ));
      FT_TRACE3(( "             : subcount=%d, suboffset=0x%04x\n",
                  subcnt, rpos ));
 
      if ( tag_internal == tag )
      {
        *count = subcnt + 1;
        rpos  += map_offset;
 
        /* a zero count might be valid in the resource specification, */
        /* however, it is completely useless to us                    */
        if ( *count < 1 || *count > 2727 )
          return FT_THROW( Invalid_Table );
 
        error = FT_Stream_Seek( stream, (FT_ULong)rpos );
        if ( error )
          return error;
 
        if ( FT_NEW_ARRAY( ref, *count ) )
          return error;
 
        for ( j = 0; j < *count; j++ )
        {
          if ( FT_READ_SHORT( ref[j].res_id ) )
            goto Exit;
          if ( FT_STREAM_SKIP( 2 ) )  /* resource name offset */
            goto Exit;
          if ( FT_READ_LONG( temp ) ) /* attributes (8bit), offset (24bit) */
            goto Exit;
          if ( FT_STREAM_SKIP( 4 ) )  /* mbz */
            goto Exit;
 
          /*
           * According to Inside Macintosh: More Macintosh Toolbox,
           * "Resource IDs" (1-46), there are some reserved IDs.
           * However, FreeType2 is not a font synthesizer, no need
           * to check the acceptable resource ID.
           */
          if ( temp < 0 )
          {
            error = FT_THROW( Invalid_Table );
            goto Exit;
          }
 
          ref[j].offset = temp & 0xFFFFFFL;
 
          FT_TRACE3(( "             [%d]:"
                      " resource_id=0x%04x, offset=0x%08x\n",
                      j, (FT_UShort)ref[j].res_id, ref[j].offset ));
        }
 
        if ( sort_by_res_id )
        {
          ft_qsort( ref,
                    (size_t)*count,
                    sizeof ( FT_RFork_Ref ),
                    ( int(*)(const void*,
                             const void*) )ft_raccess_sort_ref_by_id );
 
          FT_TRACE3(( "             -- sort resources by their ids --\n" ));
 
          for ( j = 0; j < *count; j++ )
            FT_TRACE3(( "             [%d]:"
                        " resource_id=0x%04x, offset=0x%08x\n",
                        j, ref[j].res_id, ref[j].offset ));
        }
 
        if ( FT_NEW_ARRAY( offsets_internal, *count ) )
          goto Exit;
 
        /* XXX: duplicated reference ID,
         *      gap between reference IDs are acceptable?
         *      further investigation on Apple implementation is needed.
         */
        for ( j = 0; j < *count; j++ )
          offsets_internal[j] = rdata_pos + ref[j].offset;
 
        *offsets = offsets_internal;
        error    = FT_Err_Ok;
 
      Exit:
        FT_FREE( ref );
        return error;
      }
    }
 
    return FT_THROW( Cannot_Open_Resource );
  }

FT_Raccess_Get_HeaderInfo()

FT_Raccess_Get_HeaderInfo	(	FT_Library	library,
		FT_Stream	stream,
		FT_Long	rfork_offset,
		FT_Long *	map_offset,
		FT_Long *	rdata_pos
	)

Definition at line 51 of file ftrfork.c.

  {
    FT_Error       error;
    unsigned char  head[16], head2[16];
    FT_Long        map_pos, map_len, rdata_len;
    int            allzeros, allmatch, i;
    FT_Long        type_list;
 
    FT_UNUSED( library );
 
 
    error = FT_Stream_Seek( stream, (FT_ULong)rfork_offset );
    if ( error )
      return error;
 
    error = FT_Stream_Read( stream, (FT_Byte*)head, 16 );
    if ( error )
      return error;
 
    /* ensure positive values */
    if ( head[0]  >= 0x80 ||
         head[4]  >= 0x80 ||
         head[8]  >= 0x80 ||
         head[12] >= 0x80 )
      return FT_THROW( Unknown_File_Format );
 
    *rdata_pos = ( head[ 0] << 24 ) |
                 ( head[ 1] << 16 ) |
                 ( head[ 2] <<  8 ) |
                   head[ 3];
    map_pos    = ( head[ 4] << 24 ) |
                 ( head[ 5] << 16 ) |
                 ( head[ 6] <<  8 ) |
                   head[ 7];
    rdata_len  = ( head[ 8] << 24 ) |
                 ( head[ 9] << 16 ) |
                 ( head[10] <<  8 ) |
                   head[11];
    map_len    = ( head[12] << 24 ) |
                 ( head[13] << 16 ) |
                 ( head[14] <<  8 ) |
                   head[15];
 
    /* the map must not be empty */
    if ( !map_pos )
      return FT_THROW( Unknown_File_Format );
 
    /* check whether rdata and map overlap */
    if ( *rdata_pos < map_pos )
    {
      if ( *rdata_pos > map_pos - rdata_len )
        return FT_THROW( Unknown_File_Format );
    }
    else
    {
      if ( map_pos > *rdata_pos - map_len )
        return FT_THROW( Unknown_File_Format );
    }
 
    /* check whether end of rdata or map exceeds stream size */
    if ( FT_LONG_MAX - rdata_len < *rdata_pos                               ||
         FT_LONG_MAX - map_len < map_pos                                    ||
 
         FT_LONG_MAX - ( *rdata_pos + rdata_len ) < rfork_offset            ||
         FT_LONG_MAX - ( map_pos + map_len ) < rfork_offset                 ||
 
         (FT_ULong)( rfork_offset + *rdata_pos + rdata_len ) > stream->size ||
         (FT_ULong)( rfork_offset + map_pos + map_len ) > stream->size      )
      return FT_THROW( Unknown_File_Format );
 
    *rdata_pos += rfork_offset;
    map_pos    += rfork_offset;
 
    error = FT_Stream_Seek( stream, (FT_ULong)map_pos );
    if ( error )
      return error;
 
    head2[15] = (FT_Byte)( head[15] + 1 );       /* make it be different */
 
    error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
    if ( error )
      return error;
 
    allzeros = 1;
    allmatch = 1;
    for ( i = 0; i < 16; i++ )
    {
      if ( head2[i] != 0 )
        allzeros = 0;
      if ( head2[i] != head[i] )
        allmatch = 0;
    }
    if ( !allzeros && !allmatch )
      return FT_THROW( Unknown_File_Format );
 
    /* If we have reached this point then it is probably a mac resource */
    /* file.  Now, does it contain any interesting resources?           */
 
    (void)FT_STREAM_SKIP( 4        /* skip handle to next resource map */
                          + 2      /* skip file resource number */
                          + 2 );   /* skip attributes */
 
    if ( FT_READ_SHORT( type_list ) )
      return error;
    if ( type_list < 0 )
      return FT_THROW( Unknown_File_Format );
 
    error = FT_Stream_Seek( stream, (FT_ULong)( map_pos + type_list ) );
    if ( error )
      return error;
 
    *map_offset = map_pos + type_list;
    return FT_Err_Ok;
  }

FT_Raccess_Guess()

FT_Raccess_Guess	(	FT_Library	library,
		FT_Stream	stream,
		char *	base_name,
		char **	new_names,
		FT_Long *	offsets,
		FT_Error *	errors
	)

Definition at line 917 of file ftrfork.c.

  {
    FT_Int  i;
 
    FT_UNUSED( library );
    FT_UNUSED( stream );
    FT_UNUSED( base_name );
 
 
    for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
    {
      new_names[i] = NULL;
      offsets[i]   = 0;
      errors[i]    = FT_ERR( Unimplemented_Feature );
    }
  }

ft_raccess_sort_ref_by_id()

static int ft_raccess_sort_ref_by_id ( FT_RFork_Ref *  a, FT_RFork_Ref *  b  )

static

Definition at line 172 of file ftrfork.c.

  {
    if ( a->res_id < b->res_id )
      return -1;
    else if ( a->res_id > b->res_id )
      return 1;
    else
      return 0;
  }

Referenced by FT_Raccess_Get_DataOffsets().