OTS: Adds more layout common table supports....

src/gdef.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gdef.h"
 
+#include <limits>
 #include <vector>
 
 #include "layout.h"
 #include "maxp.h"
 
 // GDEF - The Glyph Definition Table
 // http://www.microsoft.com/typography/otspec/gdef.htm
 
 namespace {
 
@@ skipping 16 matching lines @@
                           size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
 
   uint16_t offset_coverage = 0;
   uint16_t glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&glyph_count)) {
     return OTS_FAILURE();
   }
   const unsigned attach_points_end = static_cast<unsigned>(4) + 2*glyph_count;
+  if (attach_points_end > std::numeric_limits<uint16_t>::max()) {
+    return OTS_FAILURE();
+  }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < attach_points_end) {
     return OTS_FAILURE();
   }
   if (glyph_count > num_glyphs) {
     OTS_WARNING("bad glyph count: %u", glyph_count);
     return OTS_FAILURE();
   }
 
   std::vector<uint16_t> attach_points;
@@ skipping 45 matching lines @@
 bool ParseLigCaretListTable(ots::OpenTypeFile *file, const uint8_t *data,
                             size_t length, const uint16_t num_glyphs) {
   ots::Buffer subtable(data, length);
   uint16_t offset_coverage = 0;
   uint16_t lig_glyph_count = 0;
   if (!subtable.ReadU16(&offset_coverage) ||
       !subtable.ReadU16(&lig_glyph_count)) {
     return OTS_FAILURE();
   }
   const unsigned lig_glyphs_end = static_cast<unsigned>(4) + 2*lig_glyph_count;
+  if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) {
+    return OTS_FAILURE();
+  }
   if (offset_coverage == 0 || offset_coverage >= length ||
       offset_coverage < lig_glyphs_end) {
     return OTS_FAILURE();
   }
   if (lig_glyph_count > num_glyphs) {
     OTS_WARNING("bad ligature glyph count: %u", lig_glyph_count);
     return OTS_FAILURE();
   }
 
   std::vector<uint16_t> lig_glyphs;
@@ skipping 82 matching lines @@
   if (!subtable.ReadU16(&format) ||
       !subtable.ReadU16(&mark_set_count)) {
     return OTS_FAILURE();
   }
   if (format != 1) {
     OTS_WARNING("bad mark glyph set table format: %u", format);
     return OTS_FAILURE();
   }
 
   const unsigned mark_sets_end = static_cast<unsigned>(4) + 2*mark_set_count;
+  if (mark_sets_end > std::numeric_limits<uint16_t>::max()) {
+    return OTS_FAILURE();
+  }
   for (unsigned i = 0; i < mark_set_count; ++i) {
     uint32_t offset_coverage = 0;
     if (!subtable.ReadU32(&offset_coverage)) {
       return OTS_FAILURE();
     }
     if (offset_coverage >= length ||
         offset_coverage < mark_sets_end) {
       return OTS_FAILURE();
     }
     if (!ots::ParseCoverageTable(data + offset_coverage,
                                  length - offset_coverage, num_glyphs)) {
       return OTS_FAILURE();
     }
   }
+  file->gdef->num_mark_glyph_sets = mark_set_count;
   return true;
 }
 
 }  // namespace
 
 #define DROP_THIS_TABLE \
   do { delete file->gdef; file->gdef = 0; } while (0)
 
 namespace ots {
 
@@ skipping 36 matching lines @@
   }
   uint16_t offset_mark_glyph_sets_def = 0;
   if (gdef->version_2) {
     if (!table.ReadU16(&offset_mark_glyph_sets_def)) {
       return OTS_FAILURE();
     }
   }
 
   const unsigned gdef_header_end = static_cast<unsigned>(8) +
       gdef->version_2 ? static_cast<unsigned>(2) : static_cast<unsigned>(0);
+  if (gdef_header_end > std::numeric_limits<uint16_t>::max()) {
+    return OTS_FAILURE();
+  }
+
   // Parse subtables
   if (offset_glyph_class_def) {
     if (offset_glyph_class_def >= length ||
         offset_glyph_class_def < gdef_header_end) {
       return OTS_FAILURE();
     }
     if (!ParseGlyphClassDefTable(file, data + offset_glyph_class_def,
                                  length - offset_glyph_class_def,
                                  num_glyphs)) {
       DROP_THIS_TABLE;
@@ skipping 32 matching lines @@
         offset_mark_attach_class_def < gdef_header_end) {
       return OTS_FAILURE();
     }
     if (!ParseMarkAttachClassDefTable(file,
                                       data + offset_mark_attach_class_def,
                                       length - offset_mark_attach_class_def,
                                       num_glyphs)) {
       DROP_THIS_TABLE;
       return true;
     }
+    gdef->has_mark_attachment_class_def = true;
   }
 
   if (offset_mark_glyph_sets_def) {
     if (offset_mark_glyph_sets_def >= length ||
         offset_mark_glyph_sets_def < gdef_header_end) {
       return OTS_FAILURE();
     }
     if (!ParseMarkGlyphSetsDefTable(file,
                                     data + offset_mark_glyph_sets_def,
                                     length - offset_mark_glyph_sets_def,
                                     num_glyphs)) {
       DROP_THIS_TABLE;
       return true;
     }
+    gdef->has_mark_glyph_sets_def = true;
   }
   gdef->data = data;
   gdef->length = length;
   return true;
 }
 
 bool ots_gdef_should_serialise(OpenTypeFile *file) {
   return file->gdef != NULL;
 }
 
 bool ots_gdef_serialise(OTSStream *out, OpenTypeFile *file) {
   if (!out->Write(file->gdef->data, file->gdef->length)) {
     return OTS_FAILURE();
   }
 
   return true;
 }
 
 void ots_gdef_free(OpenTypeFile *file) {
   delete file->gdef;
 }
 
 }  // namespace ots