1 /****************************************************************************
2  *
3  * otvmath.c
4  *
5  *   OpenType MATH table validation (body).
6  *
7  * Copyright (C) 2007-2020 by
8  * David Turner, Robert Wilhelm, and Werner Lemberg.
9  *
10  * Written by George Williams.
11  *
12  * This file is part of the FreeType project, and may only be used,
13  * modified, and distributed under the terms of the FreeType project
14  * license, LICENSE.TXT.  By continuing to use, modify, or distribute
15  * this file you indicate that you have read the license and
16  * understand and accept it fully.
17  *
18  */
19 
20 
21 #include "otvalid.h"
22 #include "otvcommn.h"
23 #include "otvgpos.h"
24 
25 
26   /**************************************************************************
27    *
28    * The macro FT_COMPONENT is used in trace mode.  It is an implicit
29    * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
30    * messages during execution.
31    */
32 #undef  FT_COMPONENT
33 #define FT_COMPONENT  otvmath
34 
35 
36 
37   /*************************************************************************/
38   /*************************************************************************/
39   /*****                                                               *****/
40   /*****                  MATH TYPOGRAPHIC CONSTANTS                   *****/
41   /*****                                                               *****/
42   /*************************************************************************/
43   /*************************************************************************/
44 
45   static void
otv_MathConstants_validate(FT_Bytes table,OTV_Validator otvalid)46   otv_MathConstants_validate( FT_Bytes       table,
47                               OTV_Validator  otvalid )
48   {
49     FT_Bytes  p = table;
50     FT_UInt   i;
51     FT_UInt   table_size;
52 
53     OTV_OPTIONAL_TABLE( DeviceTableOffset );
54 
55 
56     OTV_NAME_ENTER( "MathConstants" );
57 
58     /* 56 constants, 51 have device tables */
59     OTV_LIMIT_CHECK( 2 * ( 56 + 51 ) );
60     table_size = 2 * ( 56 + 51 );
61 
62     p += 4 * 2;                 /* First 4 constants have no device tables */
63     for ( i = 0; i < 51; i++ )
64     {
65       p += 2;                                            /* skip the value */
66       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
67       OTV_SIZE_CHECK( DeviceTableOffset );
68       if ( DeviceTableOffset )
69         otv_Device_validate( table + DeviceTableOffset, otvalid );
70     }
71 
72     OTV_EXIT;
73   }
74 
75 
76   /*************************************************************************/
77   /*************************************************************************/
78   /*****                                                               *****/
79   /*****                   MATH ITALICS CORRECTION                     *****/
80   /*****                 MATH TOP ACCENT ATTACHMENT                    *****/
81   /*****                                                               *****/
82   /*************************************************************************/
83   /*************************************************************************/
84 
85   static void
otv_MathItalicsCorrectionInfo_validate(FT_Bytes table,OTV_Validator otvalid,FT_Int isItalic)86   otv_MathItalicsCorrectionInfo_validate( FT_Bytes       table,
87                                           OTV_Validator  otvalid,
88                                           FT_Int         isItalic )
89   {
90     FT_Bytes  p = table;
91     FT_UInt   i, cnt, table_size;
92 
93     OTV_OPTIONAL_TABLE( Coverage );
94     OTV_OPTIONAL_TABLE( DeviceTableOffset );
95 
96     FT_UNUSED( isItalic );  /* only used if tracing is active */
97 
98 
99     OTV_NAME_ENTER( isItalic ? "MathItalicsCorrectionInfo"
100                              : "MathTopAccentAttachment" );
101 
102     OTV_LIMIT_CHECK( 4 );
103 
104     OTV_OPTIONAL_OFFSET( Coverage );
105     cnt = FT_NEXT_USHORT( p );
106 
107     OTV_LIMIT_CHECK( 4 * cnt );
108     table_size = 4 + 4 * cnt;
109 
110     OTV_SIZE_CHECK( Coverage );
111     otv_Coverage_validate( table + Coverage, otvalid, (FT_Int)cnt );
112 
113     for ( i = 0; i < cnt; i++ )
114     {
115       p += 2;                                            /* Skip the value */
116       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
117       OTV_SIZE_CHECK( DeviceTableOffset );
118       if ( DeviceTableOffset )
119         otv_Device_validate( table + DeviceTableOffset, otvalid );
120     }
121 
122     OTV_EXIT;
123   }
124 
125 
126   /*************************************************************************/
127   /*************************************************************************/
128   /*****                                                               *****/
129   /*****                           MATH KERNING                        *****/
130   /*****                                                               *****/
131   /*************************************************************************/
132   /*************************************************************************/
133 
134   static void
otv_MathKern_validate(FT_Bytes table,OTV_Validator otvalid)135   otv_MathKern_validate( FT_Bytes       table,
136                          OTV_Validator  otvalid )
137   {
138     FT_Bytes  p = table;
139     FT_UInt   i, cnt, table_size;
140 
141     OTV_OPTIONAL_TABLE( DeviceTableOffset );
142 
143 
144     /* OTV_NAME_ENTER( "MathKern" );*/
145 
146     OTV_LIMIT_CHECK( 2 );
147 
148     cnt = FT_NEXT_USHORT( p );
149 
150     OTV_LIMIT_CHECK( 4 * cnt + 2 );
151     table_size = 4 + 4 * cnt;
152 
153     /* Heights */
154     for ( i = 0; i < cnt; i++ )
155     {
156       p += 2;                                            /* Skip the value */
157       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
158       OTV_SIZE_CHECK( DeviceTableOffset );
159       if ( DeviceTableOffset )
160         otv_Device_validate( table + DeviceTableOffset, otvalid );
161     }
162 
163     /* One more Kerning value */
164     for ( i = 0; i < cnt + 1; i++ )
165     {
166       p += 2;                                            /* Skip the value */
167       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
168       OTV_SIZE_CHECK( DeviceTableOffset );
169       if ( DeviceTableOffset )
170         otv_Device_validate( table + DeviceTableOffset, otvalid );
171     }
172 
173     OTV_EXIT;
174   }
175 
176 
177   static void
otv_MathKernInfo_validate(FT_Bytes table,OTV_Validator otvalid)178   otv_MathKernInfo_validate( FT_Bytes       table,
179                              OTV_Validator  otvalid )
180   {
181     FT_Bytes  p = table;
182     FT_UInt   i, j, cnt, table_size;
183 
184     OTV_OPTIONAL_TABLE( Coverage );
185     OTV_OPTIONAL_TABLE( MKRecordOffset );
186 
187 
188     OTV_NAME_ENTER( "MathKernInfo" );
189 
190     OTV_LIMIT_CHECK( 4 );
191 
192     OTV_OPTIONAL_OFFSET( Coverage );
193     cnt = FT_NEXT_USHORT( p );
194 
195     OTV_LIMIT_CHECK( 8 * cnt );
196     table_size = 4 + 8 * cnt;
197 
198     OTV_SIZE_CHECK( Coverage );
199     otv_Coverage_validate( table + Coverage, otvalid, (FT_Int)cnt );
200 
201     for ( i = 0; i < cnt; i++ )
202     {
203       for ( j = 0; j < 4; j++ )
204       {
205         OTV_OPTIONAL_OFFSET( MKRecordOffset );
206         OTV_SIZE_CHECK( MKRecordOffset );
207         if ( MKRecordOffset )
208           otv_MathKern_validate( table + MKRecordOffset, otvalid );
209       }
210     }
211 
212     OTV_EXIT;
213   }
214 
215 
216   /*************************************************************************/
217   /*************************************************************************/
218   /*****                                                               *****/
219   /*****                         MATH GLYPH INFO                       *****/
220   /*****                                                               *****/
221   /*************************************************************************/
222   /*************************************************************************/
223 
224   static void
otv_MathGlyphInfo_validate(FT_Bytes table,OTV_Validator otvalid)225   otv_MathGlyphInfo_validate( FT_Bytes       table,
226                               OTV_Validator  otvalid )
227   {
228     FT_Bytes  p = table;
229     FT_UInt   MathItalicsCorrectionInfo, MathTopAccentAttachment;
230     FT_UInt   ExtendedShapeCoverage, MathKernInfo;
231 
232 
233     OTV_NAME_ENTER( "MathGlyphInfo" );
234 
235     OTV_LIMIT_CHECK( 8 );
236 
237     MathItalicsCorrectionInfo = FT_NEXT_USHORT( p );
238     MathTopAccentAttachment   = FT_NEXT_USHORT( p );
239     ExtendedShapeCoverage     = FT_NEXT_USHORT( p );
240     MathKernInfo              = FT_NEXT_USHORT( p );
241 
242     if ( MathItalicsCorrectionInfo )
243       otv_MathItalicsCorrectionInfo_validate(
244         table + MathItalicsCorrectionInfo, otvalid, TRUE );
245 
246     /* Italic correction and Top Accent Attachment have the same format */
247     if ( MathTopAccentAttachment )
248       otv_MathItalicsCorrectionInfo_validate(
249         table + MathTopAccentAttachment, otvalid, FALSE );
250 
251     if ( ExtendedShapeCoverage )
252     {
253       OTV_NAME_ENTER( "ExtendedShapeCoverage" );
254       otv_Coverage_validate( table + ExtendedShapeCoverage, otvalid, -1 );
255       OTV_EXIT;
256     }
257 
258     if ( MathKernInfo )
259       otv_MathKernInfo_validate( table + MathKernInfo, otvalid );
260 
261     OTV_EXIT;
262   }
263 
264 
265   /*************************************************************************/
266   /*************************************************************************/
267   /*****                                                               *****/
268   /*****                    MATH GLYPH CONSTRUCTION                    *****/
269   /*****                                                               *****/
270   /*************************************************************************/
271   /*************************************************************************/
272 
273   static void
otv_GlyphAssembly_validate(FT_Bytes table,OTV_Validator otvalid)274   otv_GlyphAssembly_validate( FT_Bytes       table,
275                               OTV_Validator  otvalid )
276   {
277     FT_Bytes  p = table;
278     FT_UInt   pcnt, table_size;
279     FT_UInt   i;
280 
281     OTV_OPTIONAL_TABLE( DeviceTableOffset );
282 
283 
284     /* OTV_NAME_ENTER( "GlyphAssembly" ); */
285 
286     OTV_LIMIT_CHECK( 6 );
287 
288     p += 2;                           /* Skip the Italics Correction value */
289     OTV_OPTIONAL_OFFSET( DeviceTableOffset );
290     pcnt = FT_NEXT_USHORT( p );
291 
292     OTV_LIMIT_CHECK( 8 * pcnt );
293     table_size = 6 + 8 * pcnt;
294 
295     OTV_SIZE_CHECK( DeviceTableOffset );
296     if ( DeviceTableOffset )
297       otv_Device_validate( table + DeviceTableOffset, otvalid );
298 
299     for ( i = 0; i < pcnt; i++ )
300     {
301       FT_UInt  gid;
302 
303 
304       gid = FT_NEXT_USHORT( p );
305       if ( gid >= otvalid->glyph_count )
306         FT_INVALID_GLYPH_ID;
307       p += 2*4;             /* skip the Start, End, Full, and Flags fields */
308     }
309 
310     /* OTV_EXIT; */
311   }
312 
313 
314   static void
otv_MathGlyphConstruction_validate(FT_Bytes table,OTV_Validator otvalid)315   otv_MathGlyphConstruction_validate( FT_Bytes       table,
316                                       OTV_Validator  otvalid )
317   {
318     FT_Bytes  p = table;
319     FT_UInt   vcnt, table_size;
320     FT_UInt   i;
321 
322     OTV_OPTIONAL_TABLE( GlyphAssembly );
323 
324 
325     /* OTV_NAME_ENTER( "MathGlyphConstruction" ); */
326 
327     OTV_LIMIT_CHECK( 4 );
328 
329     OTV_OPTIONAL_OFFSET( GlyphAssembly );
330     vcnt = FT_NEXT_USHORT( p );
331 
332     OTV_LIMIT_CHECK( 4 * vcnt );
333     table_size = 4 + 4 * vcnt;
334 
335     for ( i = 0; i < vcnt; i++ )
336     {
337       FT_UInt  gid;
338 
339 
340       gid = FT_NEXT_USHORT( p );
341       if ( gid >= otvalid->glyph_count )
342         FT_INVALID_GLYPH_ID;
343       p += 2;                          /* skip the size */
344     }
345 
346     OTV_SIZE_CHECK( GlyphAssembly );
347     if ( GlyphAssembly )
348       otv_GlyphAssembly_validate( table+GlyphAssembly, otvalid );
349 
350     /* OTV_EXIT; */
351   }
352 
353 
354   static void
otv_MathVariants_validate(FT_Bytes table,OTV_Validator otvalid)355   otv_MathVariants_validate( FT_Bytes       table,
356                              OTV_Validator  otvalid )
357   {
358     FT_Bytes  p = table;
359     FT_UInt   vcnt, hcnt, i, table_size;
360 
361     OTV_OPTIONAL_TABLE( VCoverage );
362     OTV_OPTIONAL_TABLE( HCoverage );
363     OTV_OPTIONAL_TABLE( Offset );
364 
365 
366     OTV_NAME_ENTER( "MathVariants" );
367 
368     OTV_LIMIT_CHECK( 10 );
369 
370     p += 2;                       /* Skip the MinConnectorOverlap constant */
371     OTV_OPTIONAL_OFFSET( VCoverage );
372     OTV_OPTIONAL_OFFSET( HCoverage );
373     vcnt = FT_NEXT_USHORT( p );
374     hcnt = FT_NEXT_USHORT( p );
375 
376     OTV_LIMIT_CHECK( 2 * vcnt + 2 * hcnt );
377     table_size = 10 + 2 * vcnt + 2 * hcnt;
378 
379     OTV_SIZE_CHECK( VCoverage );
380     if ( VCoverage )
381       otv_Coverage_validate( table + VCoverage, otvalid, (FT_Int)vcnt );
382 
383     OTV_SIZE_CHECK( HCoverage );
384     if ( HCoverage )
385       otv_Coverage_validate( table + HCoverage, otvalid, (FT_Int)hcnt );
386 
387     for ( i = 0; i < vcnt; i++ )
388     {
389       OTV_OPTIONAL_OFFSET( Offset );
390       OTV_SIZE_CHECK( Offset );
391       otv_MathGlyphConstruction_validate( table + Offset, otvalid );
392     }
393 
394     for ( i = 0; i < hcnt; i++ )
395     {
396       OTV_OPTIONAL_OFFSET( Offset );
397       OTV_SIZE_CHECK( Offset );
398       otv_MathGlyphConstruction_validate( table + Offset, otvalid );
399     }
400 
401     OTV_EXIT;
402   }
403 
404 
405   /*************************************************************************/
406   /*************************************************************************/
407   /*****                                                               *****/
408   /*****                          MATH TABLE                           *****/
409   /*****                                                               *****/
410   /*************************************************************************/
411   /*************************************************************************/
412 
413   /* sets otvalid->glyph_count */
414 
415   FT_LOCAL_DEF( void )
otv_MATH_validate(FT_Bytes table,FT_UInt glyph_count,FT_Validator ftvalid)416   otv_MATH_validate( FT_Bytes      table,
417                      FT_UInt       glyph_count,
418                      FT_Validator  ftvalid )
419   {
420     OTV_ValidatorRec  otvalidrec;
421     OTV_Validator     otvalid = &otvalidrec;
422     FT_Bytes          p       = table;
423     FT_UInt           MathConstants, MathGlyphInfo, MathVariants;
424 
425 
426     otvalid->root = ftvalid;
427 
428     FT_TRACE3(( "validating MATH table\n" ));
429     OTV_INIT;
430 
431     OTV_LIMIT_CHECK( 10 );
432 
433     if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
434       FT_INVALID_FORMAT;
435 
436     MathConstants = FT_NEXT_USHORT( p );
437     MathGlyphInfo = FT_NEXT_USHORT( p );
438     MathVariants  = FT_NEXT_USHORT( p );
439 
440     otvalid->glyph_count = glyph_count;
441 
442     otv_MathConstants_validate( table + MathConstants,
443                                 otvalid );
444     otv_MathGlyphInfo_validate( table + MathGlyphInfo,
445                                 otvalid );
446     otv_MathVariants_validate ( table + MathVariants,
447                                 otvalid );
448 
449     FT_TRACE4(( "\n" ));
450   }
451 
452 
453 /* END */
454