gxvtrak.c File Reference

#include "gxvalid.h"
#include "gxvcommn.h"

Include dependency graph for gxvtrak.c:

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

Go to the source code of this file.

Classes
struct	GXV_trak_DataRec_

Macros
#define	FT_COMPONENT   trace_gxvtrak
#define	GXV_TRAK_DATA(FIELD)   GXV_TABLE_DATA( trak, FIELD )

Typedefs
typedef struct GXV_trak_DataRec_	GXV_trak_DataRec
typedef struct GXV_trak_DataRec_ *	GXV_trak_Data

Functions
static void	gxv_trak_trackTable_validate (FT_Bytes table, FT_Bytes limit, FT_UShort nTracks, GXV_Validator gxvalid)
static void	gxv_trak_trackData_validate (FT_Bytes table, FT_Bytes limit, GXV_Validator gxvalid)
	gxv_trak_validate (FT_Bytes table, FT_Face face, FT_Validator ftvalid)

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_gxvtrak

Definition at line 39 of file gxvtrak.c.

GXV_TRAK_DATA

#define GXV_TRAK_DATA

(

FIELD

)

GXV_TABLE_DATA( trak, FIELD )

Definition at line 82 of file gxvtrak.c.

Typedef Documentation

GXV_trak_Data

typedef struct GXV_trak_DataRec_ * GXV_trak_Data

GXV_trak_DataRec

typedef struct GXV_trak_DataRec_ GXV_trak_DataRec

Function Documentation

gxv_trak_trackData_validate()

static void gxv_trak_trackData_validate ( FT_Bytes  table, FT_Bytes  limit, GXV_Validator  gxvalid  )

static

Definition at line 144 of file gxvtrak.c.

  {
    FT_Bytes   p = table;
    FT_UShort  nTracks;
    FT_UShort  nSizes;
    FT_ULong   sizeTableOffset;
 
    GXV_ODTECT( 4, odtect );
 
 
    GXV_ODTECT_INIT( odtect );
    GXV_NAME_ENTER( "trackData" );
 
    /* read the header of trackData */
    GXV_LIMIT_CHECK( 2 + 2 + 4 );
    nTracks         = FT_NEXT_USHORT( p );
    nSizes          = FT_NEXT_USHORT( p );
    sizeTableOffset = FT_NEXT_ULONG( p );
 
    gxv_odtect_add_range( table, (FT_ULong)( p - table ),
                          "trackData header", odtect );
 
    /* validate trackTable */
    gxv_trak_trackTable_validate( p, limit, nTracks, gxvalid );
    gxv_odtect_add_range( p, gxvalid->subtable_length,
                          "trackTable", odtect );
 
    /* sizeTable is array of FT_Fixed, don't check contents */
    p = gxvalid->root->base + sizeTableOffset;
    GXV_LIMIT_CHECK( nSizes * 4 );
    gxv_odtect_add_range( p, nSizes * 4, "sizeTable", odtect );
 
    /* validate trackValueOffet */
    p = gxvalid->root->base + GXV_TRAK_DATA( trackValueOffset_min );
    if ( limit - p < nTracks * nSizes * 2 )
      GXV_TRACE(( "too short trackValue array\n" ));
 
    p = gxvalid->root->base + GXV_TRAK_DATA( trackValueOffset_max );
    GXV_LIMIT_CHECK( nSizes * 2 );
 
    gxv_odtect_add_range( gxvalid->root->base
                            + GXV_TRAK_DATA( trackValueOffset_min ),
                          GXV_TRAK_DATA( trackValueOffset_max )
                            - GXV_TRAK_DATA( trackValueOffset_min )
                            + nSizes * 2,
                          "trackValue array", odtect );
 
    gxv_odtect_validate( odtect, gxvalid );
 
    GXV_EXIT;
  }

Referenced by gxv_trak_validate().

gxv_trak_trackTable_validate()

static void gxv_trak_trackTable_validate ( FT_Bytes  table, FT_Bytes  limit, FT_UShort  nTracks, GXV_Validator  gxvalid  )

static

Definition at line 94 of file gxvtrak.c.

  {
    FT_Bytes  p = table;
 
    FT_Fixed   track, t;
    FT_UShort  nameIndex;
    FT_UShort  offset;
    FT_UShort  i, j;
 
 
    GXV_NAME_ENTER( "trackTable" );
 
    GXV_TRAK_DATA( trackValueOffset_min ) = 0xFFFFU;
    GXV_TRAK_DATA( trackValueOffset_max ) = 0x0000;
 
    GXV_LIMIT_CHECK( nTracks * ( 4 + 2 + 2 ) );
 
    for ( i = 0; i < nTracks; i++ )
    {
      p = table + i * ( 4 + 2 + 2 );
      track     = FT_NEXT_LONG( p );
      nameIndex = FT_NEXT_USHORT( p );
      offset    = FT_NEXT_USHORT( p );
 
      if ( offset < GXV_TRAK_DATA( trackValueOffset_min ) )
        GXV_TRAK_DATA( trackValueOffset_min ) = offset;
      if ( offset > GXV_TRAK_DATA( trackValueOffset_max ) )
        GXV_TRAK_DATA( trackValueOffset_max ) = offset;
 
      gxv_sfntName_validate( nameIndex, 256, 32767, gxvalid );
 
      for ( j = i; j < nTracks; j++ )
      {
         p = table + j * ( 4 + 2 + 2 );
         t = FT_NEXT_LONG( p );
         if ( t == track )
           GXV_TRACE(( "duplicated entries found for track value 0x%x\n",
                        track ));
      }
    }
 
    gxvalid->subtable_length = (FT_ULong)( p - table );
    GXV_EXIT;
  }

Referenced by gxv_trak_trackData_validate().

gxv_trak_validate()

gxv_trak_validate	(	FT_Bytes	table,
		FT_Face	face,
		FT_Validator	ftvalid
	)

Definition at line 208 of file gxvtrak.c.

  {
    FT_Bytes          p = table;
    FT_Bytes          limit = 0;
 
    GXV_ValidatorRec  gxvalidrec;
    GXV_Validator     gxvalid = &gxvalidrec;
    GXV_trak_DataRec  trakrec;
    GXV_trak_Data     trak = &trakrec;
 
    FT_ULong   version;
    FT_UShort  format;
    FT_UShort  horizOffset;
    FT_UShort  vertOffset;
    FT_UShort  reserved;
 
 
    GXV_ODTECT( 3, odtect );
 
    GXV_ODTECT_INIT( odtect );
    gxvalid->root       = ftvalid;
    gxvalid->table_data = trak;
    gxvalid->face       = face;
 
    limit      = gxvalid->root->limit;
 
    FT_TRACE3(( "validating `trak' table\n" ));
    GXV_INIT;
 
    GXV_LIMIT_CHECK( 4 + 2 + 2 + 2 + 2 );
    version     = FT_NEXT_ULONG( p );
    format      = FT_NEXT_USHORT( p );
    horizOffset = FT_NEXT_USHORT( p );
    vertOffset  = FT_NEXT_USHORT( p );
    reserved    = FT_NEXT_USHORT( p );
 
    GXV_TRACE(( " (version = 0x%08x)\n", version ));
    GXV_TRACE(( " (format = 0x%04x)\n", format ));
    GXV_TRACE(( " (horizOffset = 0x%04x)\n", horizOffset ));
    GXV_TRACE(( " (vertOffset = 0x%04x)\n", vertOffset ));
    GXV_TRACE(( " (reserved = 0x%04x)\n", reserved ));
 
    /* Version 1.0 (always:1996) */
    if ( version != 0x00010000UL )
      FT_INVALID_FORMAT;
 
    /* format 0 (always:1996) */
    if ( format != 0x0000 )
      FT_INVALID_FORMAT;
 
    GXV_32BIT_ALIGNMENT_VALIDATE( horizOffset );
    GXV_32BIT_ALIGNMENT_VALIDATE( vertOffset );
 
    /* Reserved Fixed Value (always) */
    if ( reserved != 0x0000 )
      FT_INVALID_DATA;
 
    /* validate trackData */
    if ( 0 < horizOffset )
    {
      gxv_trak_trackData_validate( table + horizOffset, limit, gxvalid );
      gxv_odtect_add_range( table + horizOffset, gxvalid->subtable_length,
                            "horizJustData", odtect );
    }
 
    if ( 0 < vertOffset )
    {
      gxv_trak_trackData_validate( table + vertOffset, limit, gxvalid );
      gxv_odtect_add_range( table + vertOffset, gxvalid->subtable_length,
                            "vertJustData", odtect );
    }
 
    gxv_odtect_validate( odtect, gxvalid );
 
    FT_TRACE4(( "\n" ));
  }