static inline int verify_string_vector(const void *buf, uoffset_t end, uoffset_t base, uoffset_t offset) { uoffset_t i, n; check_result(verify_vector(buf, end, base, offset, offset_size, offset_size, FLATBUFFERS_COUNT_MAX(offset_size))); base += offset; n = read_uoffset(buf, base); base += offset_size; for (i = 0; i < n; ++i, base += offset_size) { check_result(verify_string(buf, end, base, read_uoffset(buf, base))); } return flatcc_verify_ok; }
static inline int verify_table_vector(const void *buf, uoffset_t end, uoffset_t base, uoffset_t offset, int ttl, flatcc_table_verifier_f tvf) { uoffset_t i, n; verify(ttl-- > 0, flatcc_verify_error_max_nesting_level_reached); check_result(verify_vector(buf, end, base, offset, offset_size, offset_size, FLATBUFFERS_COUNT_MAX(offset_size))); base += offset; n = read_uoffset(buf, base); base += offset_size; for (i = 0; i < n; ++i, base += offset_size) { check_result(verify_table(buf, end, base, read_uoffset(buf, base), ttl, tvf)); } return flatcc_verify_ok; }
int flatcc_verify_struct_as_nested_root(flatcc_table_verifier_descriptor_t *td, voffset_t id, int required, const char *fid, uint16_t align, size_t size) { const uoffset_t *buf; uoffset_t bufsiz; check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1))); if (0 == (buf = get_field_ptr(td, id))) { return flatcc_verify_ok; } buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0)); bufsiz = read_uoffset(buf, 0); ++buf; return flatcc_verify_struct_as_root(buf, bufsiz, fid, align, size); }
int flatcc_verify_table_as_nested_root(flatcc_table_verifier_descriptor_t *td, voffset_t id, int required, const char *fid, uint16_t align, flatcc_table_verifier_f tvf) { const uoffset_t *buf; uoffset_t bufsiz; check_result(flatcc_verify_vector_field(td, id, required, align, 1, FLATBUFFERS_COUNT_MAX(1))); if (0 == (buf = get_field_ptr(td, id))) { return flatcc_verify_ok; } buf = (const uoffset_t *)((size_t)buf + read_uoffset(buf, 0)); bufsiz = read_uoffset(buf, 0); ++buf; /* * Don't verify nested buffers identifier - information is difficult to get and * might not be what is desired anyway. User can do it later. */ check_result(flatcc_verify_buffer_header(buf, bufsiz, fid)); return verify_table(buf, bufsiz, 0, read_uoffset(buf, 0), td->ttl, tvf); }
static int gen_table_verifier(output_t *out, fb_compound_type_t *ct) { fb_symbol_t *sym; fb_member_t *member; fb_scoped_name_t snt, snref; int required, first = 1; fb_clear(snt); fb_clear(snref); fb_compound_name(ct, &snt); fprintf(out->fp, "static int __%s_table_verifier(flatcc_table_verifier_descriptor_t *td)\n{\n", snt.text); for (sym = ct->members; sym; sym = sym->link) { member = (fb_member_t *)sym; if (member->metadata_flags & fb_f_deprecated) { continue; } if (first) { fprintf(out->fp, " int ret;\n if ((ret = "); } else { fprintf(out->fp, ")) return ret;\n if ((ret = "); } first = 0; required = (member->metadata_flags & fb_f_required) != 0; switch (member->type.type) { case vt_scalar_type: fprintf( out->fp, "flatcc_verify_field(td, %"PRIu64", %"PRIu16", %"PRIu64")", member->id, member->align, member->size); break; case vt_vector_type: if (member->nest) { fb_compound_name((fb_compound_type_t *)&member->nest->symbol, &snref); if (member->nest->symbol.kind == fb_is_table) { fprintf(out->fp, "flatcc_verify_table_as_nested_root(td, %"PRIu64", " "%u, 0, %"PRIu16", __%s_table_verifier)", member->id, required, member->align, snref.text); } else { fprintf(out->fp, "flatcc_verify_struct_as_nested_root(td, %"PRIu64", " "%u, 0, %"PRIu16", %"PRIu64")", member->id, required, member->align, member->size); } } else { fprintf(out->fp, "flatcc_verify_vector_field(td, %"PRIu64", %d, %"PRId16", %"PRIu64", %"PRIu64")", member->id, required, member->align, member->size, (uint64_t)FLATBUFFERS_COUNT_MAX(member->size)); }; break; case vt_string_type: fprintf(out->fp, "flatcc_verify_string_field(td, %"PRIu64", %d)", member->id, required); break; case vt_vector_string_type: fprintf(out->fp, "flatcc_verify_string_vector_field(td, %"PRIu64", %d)", member->id, required); break; case vt_compound_type_ref: fb_compound_name(member->type.ct, &snref); switch (member->type.ct->symbol.kind) { case fb_is_enum: case fb_is_struct: fprintf(out->fp, "flatcc_verify_field(td, %"PRIu64", %"PRIu16", %"PRIu64")", member->id, member->align, member->size); break; case fb_is_table: fprintf(out->fp, "flatcc_verify_table_field(td, %"PRIu64", %d, &__%s_table_verifier)", member->id, required, snref.text); break; case fb_is_union: fprintf(out->fp, "flatcc_verify_union_field(td, %"PRIu64", %d, &__%s_union_verifier)", member->id, required, snref.text); break; default: gen_panic(out, "internal error: unexpected compound type for table verifier"); return -1; } break; case vt_vector_compound_type_ref: fb_compound_name(member->type.ct, &snref); switch (member->type.ct->symbol.kind) { case fb_is_table: fprintf(out->fp, "flatcc_verify_table_vector_field(td, %"PRIu64", %d, &__%s_table_verifier)", member->id, required, snref.text); break; case fb_is_enum: case fb_is_struct: fprintf(out->fp, "flatcc_verify_vector_field(td, %"PRIu64", %d, %"PRId16", %"PRIu64", %"PRIu64")", member->id, required, member->align, member->size, (uint64_t)FLATBUFFERS_COUNT_MAX(member->size)); break; default: gen_panic(out, "internal error: unexpected vector compound type for table verifier"); return -1; } break; } fprintf(out->fp, " /* %.*s */", (int)sym->ident->len, sym->ident->text); } if (!first) { fprintf(out->fp, ")) return ret;\n"); } fprintf(out->fp, " return flatcc_verify_ok;\n"); fprintf(out->fp, "}\n\n"); fprintf(out->fp, "static inline int %s_verify_as_root(const void *buf, size_t bufsiz, const char *fid)\n" "{\n return flatcc_verify_table_as_root(buf, bufsiz, fid, &__%s_table_verifier);\n}\n\n", snt.text, snt.text); return 0; }