src/otvalid/otvgsub.c

   1 /****************************************************************************
   2  *
   3  * otvgsub.c
   4  *
   5  *   OpenType GSUB table validation (body).
   6  *
   7  * Copyright (C) 2004-2023 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 "otvalid.h"
  20 #include "otvcommn.h"
  21
  22
  23   /**************************************************************************
  24    *
  25    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
  26    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
  27    * messages during execution.
  28    */
  29 #undef  FT_COMPONENT
  30 #define FT_COMPONENT  otvgsub
  31
  32
  33   /*************************************************************************/
  34   /*************************************************************************/
  35   /*****                                                               *****/
  36   /*****                  GSUB LOOKUP TYPE 1                           *****/
  37   /*****                                                               *****/
  38   /*************************************************************************/
  39   /*************************************************************************/
  40
  41   /* uses otvalid->glyph_count */
  42
  43   static void
  44   otv_SingleSubst_validate( FT_Bytes       table,
  45                             OTV_Validator  otvalid )
  46   {
  47     FT_Bytes  p = table;
  48     FT_UInt   SubstFormat;
  49
  50
  51     OTV_NAME_ENTER( "SingleSubst" );
  52
  53     OTV_LIMIT_CHECK( 2 );
  54     SubstFormat = FT_NEXT_USHORT( p );
  55
  56     OTV_TRACE(( " (format %d)\n", SubstFormat ));
  57
  58     switch ( SubstFormat )
  59     {
  60     case 1:     /* SingleSubstFormat1 */
  61       {
  62         FT_Bytes  Coverage;
  63         FT_Int    DeltaGlyphID;
  64         FT_UInt   first_cov, last_cov;
  65         FT_UInt   first_idx, last_idx;
  66
  67
  68         OTV_LIMIT_CHECK( 4 );
  69         Coverage     = table + FT_NEXT_USHORT( p );
  70         DeltaGlyphID = FT_NEXT_SHORT( p );
  71
  72         otv_Coverage_validate( Coverage, otvalid, -1 );
  73
  74         first_cov = otv_Coverage_get_first( Coverage );
  75         last_cov  = otv_Coverage_get_last( Coverage );
  76
  77         /* These additions are modulo 65536. */
  78         first_idx = (FT_UInt)( (FT_Int)first_cov + DeltaGlyphID ) & 0xFFFFU;
  79         last_idx  = (FT_UInt)( (FT_Int)last_cov + DeltaGlyphID ) & 0xFFFFU;
  80
  81         /* Since the maximum number of glyphs is 2^16 - 1 = 65535, */
  82         /* the largest possible glyph index is 65534.  For this    */
  83         /* reason there can't be a wrap-around region, which would */
  84         /* imply the use of the invalid glyph index 65535.         */
  85         if ( first_idx > last_idx )
  86           FT_INVALID_DATA;
  87
  88         if ( last_idx >= otvalid->glyph_count )
  89           FT_INVALID_DATA;
  90       }
  91       break;
  92
  93     case 2:     /* SingleSubstFormat2 */
  94       {
  95         FT_UInt  Coverage, GlyphCount;
  96
  97
  98         OTV_LIMIT_CHECK( 4 );
  99         Coverage   = FT_NEXT_USHORT( p );
 100         GlyphCount = FT_NEXT_USHORT( p );
 101
 102         OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
 103
 104         otv_Coverage_validate( table + Coverage,
 105                                otvalid,
 106                                (FT_Int)GlyphCount );
 107
 108         OTV_LIMIT_CHECK( GlyphCount * 2 );
 109
 110         /* Substitute */
 111         for ( ; GlyphCount > 0; GlyphCount-- )
 112           if ( FT_NEXT_USHORT( p ) >= otvalid->glyph_count )
 113             FT_INVALID_GLYPH_ID;
 114       }
 115       break;
 116
 117     default:
 118       FT_INVALID_FORMAT;
 119     }
 120
 121     OTV_EXIT;
 122   }
 123
 124
 125   /*************************************************************************/
 126   /*************************************************************************/
 127   /*****                                                               *****/
 128   /*****                  GSUB LOOKUP TYPE 2                           *****/
 129   /*****                                                               *****/
 130   /*************************************************************************/
 131   /*************************************************************************/
 132
 133   /* sets otvalid->extra1 (glyph count) */
 134
 135   static void
 136   otv_MultipleSubst_validate( FT_Bytes       table,
 137                               OTV_Validator  otvalid )
 138   {
 139     FT_Bytes  p = table;
 140     FT_UInt   SubstFormat;
 141
 142
 143     OTV_NAME_ENTER( "MultipleSubst" );
 144
 145     OTV_LIMIT_CHECK( 2 );
 146     SubstFormat = FT_NEXT_USHORT( p );
 147
 148     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 149
 150     switch ( SubstFormat )
 151     {
 152     case 1:
 153       otvalid->extra1 = otvalid->glyph_count;
 154       OTV_NEST2( MultipleSubstFormat1, Sequence );
 155       OTV_RUN( table, otvalid );
 156       break;
 157
 158     default:
 159       FT_INVALID_FORMAT;
 160     }
 161
 162     OTV_EXIT;
 163   }
 164
 165
 166   /*************************************************************************/
 167   /*************************************************************************/
 168   /*****                                                               *****/
 169   /*****                    GSUB LOOKUP TYPE 3                         *****/
 170   /*****                                                               *****/
 171   /*************************************************************************/
 172   /*************************************************************************/
 173
 174   /* sets otvalid->extra1 (glyph count) */
 175
 176   static void
 177   otv_AlternateSubst_validate( FT_Bytes       table,
 178                                OTV_Validator  otvalid )
 179   {
 180     FT_Bytes  p = table;
 181     FT_UInt   SubstFormat;
 182
 183
 184     OTV_NAME_ENTER( "AlternateSubst" );
 185
 186     OTV_LIMIT_CHECK( 2 );
 187     SubstFormat = FT_NEXT_USHORT( p );
 188
 189     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 190
 191     switch ( SubstFormat )
 192     {
 193     case 1:
 194       otvalid->extra1 = otvalid->glyph_count;
 195       OTV_NEST2( AlternateSubstFormat1, AlternateSet );
 196       OTV_RUN( table, otvalid );
 197       break;
 198
 199     default:
 200       FT_INVALID_FORMAT;
 201     }
 202
 203     OTV_EXIT;
 204   }
 205
 206
 207   /*************************************************************************/
 208   /*************************************************************************/
 209   /*****                                                               *****/
 210   /*****                    GSUB LOOKUP TYPE 4                         *****/
 211   /*****                                                               *****/
 212   /*************************************************************************/
 213   /*************************************************************************/
 214
 215 #define LigatureFunc  otv_Ligature_validate
 216
 217   /* uses otvalid->glyph_count */
 218
 219   static void
 220   otv_Ligature_validate( FT_Bytes       table,
 221                          OTV_Validator  otvalid )
 222   {
 223     FT_Bytes  p = table;
 224     FT_UInt   LigatureGlyph, CompCount;
 225
 226
 227     OTV_ENTER;
 228
 229     OTV_LIMIT_CHECK( 4 );
 230     LigatureGlyph = FT_NEXT_USHORT( p );
 231     if ( LigatureGlyph >= otvalid->glyph_count )
 232       FT_INVALID_DATA;
 233
 234     CompCount = FT_NEXT_USHORT( p );
 235
 236     OTV_TRACE(( " (CompCount = %d)\n", CompCount ));
 237
 238     if ( CompCount == 0 )
 239       FT_INVALID_DATA;
 240
 241     CompCount--;
 242
 243     OTV_LIMIT_CHECK( CompCount * 2 );     /* Component */
 244
 245     /* no need to check the Component glyph indices */
 246
 247     OTV_EXIT;
 248   }
 249
 250
 251   static void
 252   otv_LigatureSubst_validate( FT_Bytes       table,
 253                               OTV_Validator  otvalid )
 254   {
 255     FT_Bytes  p = table;
 256     FT_UInt   SubstFormat;
 257
 258
 259     OTV_NAME_ENTER( "LigatureSubst" );
 260
 261     OTV_LIMIT_CHECK( 2 );
 262     SubstFormat = FT_NEXT_USHORT( p );
 263
 264     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 265
 266     switch ( SubstFormat )
 267     {
 268     case 1:
 269       OTV_NEST3( LigatureSubstFormat1, LigatureSet, Ligature );
 270       OTV_RUN( table, otvalid );
 271       break;
 272
 273     default:
 274       FT_INVALID_FORMAT;
 275     }
 276
 277     OTV_EXIT;
 278   }
 279
 280
 281   /*************************************************************************/
 282   /*************************************************************************/
 283   /*****                                                               *****/
 284   /*****                  GSUB LOOKUP TYPE 5                           *****/
 285   /*****                                                               *****/
 286   /*************************************************************************/
 287   /*************************************************************************/
 288
 289   /* sets otvalid->extra1 (lookup count) */
 290
 291   static void
 292   otv_ContextSubst_validate( FT_Bytes       table,
 293                              OTV_Validator  otvalid )
 294   {
 295     FT_Bytes  p = table;
 296     FT_UInt   SubstFormat;
 297
 298
 299     OTV_NAME_ENTER( "ContextSubst" );
 300
 301     OTV_LIMIT_CHECK( 2 );
 302     SubstFormat = FT_NEXT_USHORT( p );
 303
 304     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 305
 306     switch ( SubstFormat )
 307     {
 308     case 1:
 309       /* no need to check glyph indices/classes used as input for these */
 310       /* context rules since even invalid glyph indices/classes return  */
 311       /* meaningful results                                             */
 312
 313       otvalid->extra1 = otvalid->lookup_count;
 314       OTV_NEST3( ContextSubstFormat1, SubRuleSet, SubRule );
 315       OTV_RUN( table, otvalid );
 316       break;
 317
 318     case 2:
 319       /* no need to check glyph indices/classes used as input for these */
 320       /* context rules since even invalid glyph indices/classes return  */
 321       /* meaningful results                                             */
 322
 323       OTV_NEST3( ContextSubstFormat2, SubClassSet, SubClassRule );
 324       OTV_RUN( table, otvalid );
 325       break;
 326
 327     case 3:
 328       OTV_NEST1( ContextSubstFormat3 );
 329       OTV_RUN( table, otvalid );
 330       break;
 331
 332     default:
 333       FT_INVALID_FORMAT;
 334     }
 335
 336     OTV_EXIT;
 337   }
 338
 339
 340   /*************************************************************************/
 341   /*************************************************************************/
 342   /*****                                                               *****/
 343   /*****                    GSUB LOOKUP TYPE 6                         *****/
 344   /*****                                                               *****/
 345   /*************************************************************************/
 346   /*************************************************************************/
 347
 348   /* sets otvalid->extra1 (lookup count)            */
 349
 350   static void
 351   otv_ChainContextSubst_validate( FT_Bytes       table,
 352                                   OTV_Validator  otvalid )
 353   {
 354     FT_Bytes  p = table;
 355     FT_UInt   SubstFormat;
 356
 357
 358     OTV_NAME_ENTER( "ChainContextSubst" );
 359
 360     OTV_LIMIT_CHECK( 2 );
 361     SubstFormat = FT_NEXT_USHORT( p );
 362
 363     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 364
 365     switch ( SubstFormat )
 366     {
 367     case 1:
 368       /* no need to check glyph indices/classes used as input for these */
 369       /* context rules since even invalid glyph indices/classes return  */
 370       /* meaningful results                                             */
 371
 372       otvalid->extra1 = otvalid->lookup_count;
 373       OTV_NEST3( ChainContextSubstFormat1,
 374                  ChainSubRuleSet, ChainSubRule );
 375       OTV_RUN( table, otvalid );
 376       break;
 377
 378     case 2:
 379       /* no need to check glyph indices/classes used as input for these */
 380       /* context rules since even invalid glyph indices/classes return  */
 381       /* meaningful results                                             */
 382
 383       OTV_NEST3( ChainContextSubstFormat2,
 384                  ChainSubClassSet, ChainSubClassRule );
 385       OTV_RUN( table, otvalid );
 386       break;
 387
 388     case 3:
 389       OTV_NEST1( ChainContextSubstFormat3 );
 390       OTV_RUN( table, otvalid );
 391       break;
 392
 393     default:
 394       FT_INVALID_FORMAT;
 395     }
 396
 397     OTV_EXIT;
 398   }
 399
 400
 401   /*************************************************************************/
 402   /*************************************************************************/
 403   /*****                                                               *****/
 404   /*****                    GSUB LOOKUP TYPE 7                         *****/
 405   /*****                                                               *****/
 406   /*************************************************************************/
 407   /*************************************************************************/
 408
 409   /* uses otvalid->type_funcs */
 410
 411   static void
 412   otv_ExtensionSubst_validate( FT_Bytes       table,
 413                                OTV_Validator  otvalid )
 414   {
 415     FT_Bytes  p = table;
 416     FT_UInt   SubstFormat;
 417
 418
 419     OTV_NAME_ENTER( "ExtensionSubst" );
 420
 421     OTV_LIMIT_CHECK( 2 );
 422     SubstFormat = FT_NEXT_USHORT( p );
 423
 424     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 425
 426     switch ( SubstFormat )
 427     {
 428     case 1:     /* ExtensionSubstFormat1 */
 429       {
 430         FT_UInt            ExtensionLookupType;
 431         FT_ULong           ExtensionOffset;
 432         OTV_Validate_Func  validate;
 433
 434
 435         OTV_LIMIT_CHECK( 6 );
 436         ExtensionLookupType = FT_NEXT_USHORT( p );
 437         ExtensionOffset     = FT_NEXT_ULONG( p );
 438
 439         if ( ExtensionLookupType == 0 ||
 440              ExtensionLookupType == 7 ||
 441              ExtensionLookupType > 8  )
 442           FT_INVALID_DATA;
 443
 444         validate = otvalid->type_funcs[ExtensionLookupType - 1];
 445         validate( table + ExtensionOffset, otvalid );
 446       }
 447       break;
 448
 449     default:
 450       FT_INVALID_FORMAT;
 451     }
 452
 453     OTV_EXIT;
 454   }
 455
 456
 457   /*************************************************************************/
 458   /*************************************************************************/
 459   /*****                                                               *****/
 460   /*****                    GSUB LOOKUP TYPE 8                         *****/
 461   /*****                                                               *****/
 462   /*************************************************************************/
 463   /*************************************************************************/
 464
 465   /* uses otvalid->glyph_count */
 466
 467   static void
 468   otv_ReverseChainSingleSubst_validate( FT_Bytes       table,
 469                                         OTV_Validator  otvalid )
 470   {
 471     FT_Bytes  p = table, Coverage;
 472     FT_UInt   SubstFormat;
 473     FT_UInt   BacktrackGlyphCount, LookaheadGlyphCount, GlyphCount;
 474
 475
 476     OTV_NAME_ENTER( "ReverseChainSingleSubst" );
 477
 478     OTV_LIMIT_CHECK( 2 );
 479     SubstFormat = FT_NEXT_USHORT( p );
 480
 481     OTV_TRACE(( " (format %d)\n", SubstFormat ));
 482
 483     switch ( SubstFormat )
 484     {
 485     case 1:     /* ReverseChainSingleSubstFormat1 */
 486       OTV_LIMIT_CHECK( 4 );
 487       Coverage            = table + FT_NEXT_USHORT( p );
 488       BacktrackGlyphCount = FT_NEXT_USHORT( p );
 489
 490       OTV_TRACE(( " (BacktrackGlyphCount = %d)\n", BacktrackGlyphCount ));
 491
 492       otv_Coverage_validate( Coverage, otvalid, -1 );
 493
 494       OTV_LIMIT_CHECK( BacktrackGlyphCount * 2 + 2 );
 495
 496       for ( ; BacktrackGlyphCount > 0; BacktrackGlyphCount-- )
 497         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), otvalid, -1 );
 498
 499       LookaheadGlyphCount = FT_NEXT_USHORT( p );
 500
 501       OTV_TRACE(( " (LookaheadGlyphCount = %d)\n", LookaheadGlyphCount ));
 502
 503       OTV_LIMIT_CHECK( LookaheadGlyphCount * 2 + 2 );
 504
 505       for ( ; LookaheadGlyphCount > 0; LookaheadGlyphCount-- )
 506         otv_Coverage_validate( table + FT_NEXT_USHORT( p ), otvalid, -1 );
 507
 508       GlyphCount = FT_NEXT_USHORT( p );
 509
 510       OTV_TRACE(( " (GlyphCount = %d)\n", GlyphCount ));
 511
 512       if ( GlyphCount != otv_Coverage_get_count( Coverage ) )
 513         FT_INVALID_DATA;
 514
 515       OTV_LIMIT_CHECK( GlyphCount * 2 );
 516
 517       /* Substitute */
 518       for ( ; GlyphCount > 0; GlyphCount-- )
 519         if ( FT_NEXT_USHORT( p ) >= otvalid->glyph_count )
 520           FT_INVALID_DATA;
 521
 522       break;
 523
 524     default:
 525       FT_INVALID_FORMAT;
 526     }
 527
 528     OTV_EXIT;
 529   }
 530
 531
 532   static const OTV_Validate_Func  otv_gsub_validate_funcs[8] =
 533   {
 534     otv_SingleSubst_validate,
 535     otv_MultipleSubst_validate,
 536     otv_AlternateSubst_validate,
 537     otv_LigatureSubst_validate,
 538     otv_ContextSubst_validate,
 539     otv_ChainContextSubst_validate,
 540     otv_ExtensionSubst_validate,
 541     otv_ReverseChainSingleSubst_validate
 542   };
 543
 544
 545   /*************************************************************************/
 546   /*************************************************************************/
 547   /*****                                                               *****/
 548   /*****                          GSUB TABLE                           *****/
 549   /*****                                                               *****/
 550   /*************************************************************************/
 551   /*************************************************************************/
 552
 553   /* sets otvalid->type_count  */
 554   /* sets otvalid->type_funcs  */
 555   /* sets otvalid->glyph_count */
 556
 557   FT_LOCAL_DEF( void )
 558   otv_GSUB_validate( FT_Bytes      table,
 559                      FT_UInt       glyph_count,
 560                      FT_Validator  ftvalid )
 561   {
 562     OTV_ValidatorRec  otvalidrec;
 563     OTV_Validator     otvalid = &otvalidrec;
 564     FT_Bytes          p       = table;
 565     FT_UInt           table_size;
 566     FT_UShort         version;
 567     FT_UInt           ScriptList, FeatureList, LookupList;
 568
 569     OTV_OPTIONAL_TABLE32( featureVariations );
 570
 571
 572     otvalid->root = ftvalid;
 573
 574     FT_TRACE3(( "validating GSUB table\n" ));
 575     OTV_INIT;
 576
 577     OTV_LIMIT_CHECK( 4 );
 578
 579     if ( FT_NEXT_USHORT( p ) != 1 )  /* majorVersion */
 580       FT_INVALID_FORMAT;
 581
 582     version = FT_NEXT_USHORT( p );   /* minorVersion */
 583
 584     table_size = 10;
 585     switch ( version )
 586     {
 587     case 0:
 588       OTV_LIMIT_CHECK( 6 );
 589       break;
 590
 591     case 1:
 592       OTV_LIMIT_CHECK( 10 );
 593       table_size += 4;
 594       break;
 595
 596     default:
 597       FT_INVALID_FORMAT;
 598     }
 599
 600     ScriptList  = FT_NEXT_USHORT( p );
 601     FeatureList = FT_NEXT_USHORT( p );
 602     LookupList  = FT_NEXT_USHORT( p );
 603
 604     otvalid->type_count  = 8;
 605     otvalid->type_funcs  = (OTV_Validate_Func*)otv_gsub_validate_funcs;
 606     otvalid->glyph_count = glyph_count;
 607
 608     otv_LookupList_validate( table + LookupList,
 609                              otvalid );
 610     otv_FeatureList_validate( table + FeatureList, table + LookupList,
 611                               otvalid );
 612     otv_ScriptList_validate( table + ScriptList, table + FeatureList,
 613                              otvalid );
 614
 615     if ( version > 0 )
 616     {
 617       OTV_OPTIONAL_OFFSET32( featureVariations );
 618       OTV_SIZE_CHECK32( featureVariations );
 619       if ( featureVariations )
 620         OTV_TRACE(( "  [omitting featureVariations validation]\n" )); /* XXX */
 621     }
 622
 623     FT_TRACE4(( "\n" ));
 624   }
 625
 626
 627 /* END */