Preserve shared dictionary state on serialized parse failure.

When attaching a serialized shared dictionary (`BROTLI_SHARED_DICTIONARY_SERIALIZED`), `ParseDictionary` previously mutated `BrotliSharedDictionary` fields in-place before validating all entries and did not roll back on error. If parsing failed partway through (such as when a `context_map` entry exceeded `num_dictionaries` or when input ended before all `(words_index, transforms_index)` pairs were read), `BrotliSharedDictionaryAttach` returned `BROTLI_FALSE` while leaving the dictionary in a partially populated state. Subsequent decompression calls that proceeded after a failed attachment could then index out of bounds of `words` and `transforms` or dereference null dictionary pointers. In addition, attaching a prefix-only serialized dictionary (`num_word_lists == 0` and `num_transform_lists == 0`) onto a `BrotliSharedDictionary` that already had custom word or transform lists previously overwrote those custom tables with the built-in static dictionary.

Validate `num_word_lists`, `num_transform_lists`, `num_dictionaries`, `context_based`, and `context_map` entries using local variables before committing them to `BrotliSharedDictionary` (preserving existing custom word and transform lists when appending a prefix-only serialized dictionary), and restore the prior dictionary state (freeing any newly allocated word, transform, or prefix-suffix tables) in `DecodeSharedDictionary` whenever `ParseDictionary` fails.

PiperOrigin-RevId: 1021295358
diff --git a/c/common/shared_dictionary.c b/c/common/shared_dictionary.c
index cef4e20..1530906 100644
--- a/c/common/shared_dictionary.c
+++ b/c/common/shared_dictionary.c
@@ -274,6 +274,8 @@
   uint32_t i;
   size_t pos = 0;
   uint32_t chunk_size = 0;
+  uint8_t num_word_lists = 0;
+  uint8_t num_transform_lists = 0;
   size_t total_prefix_suffix_count = 0;
   size_t transform_list_start[SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS];
   uint16_t temporary_prefix_suffix_table[256];
@@ -293,40 +295,42 @@
   }
 
   /* NUM_WORD_LISTS */
-  if (!ReadUint8(encoded, size, &pos, &dict->num_word_lists)) {
+  if (!ReadUint8(encoded, size, &pos, &num_word_lists)) {
     return BROTLI_FALSE;
   }
-  if (dict->num_word_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
+  if (num_word_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
     return BROTLI_FALSE;
   }
 
-  if (dict->num_word_lists != 0) {
+  if (num_word_lists != 0) {
     dict->words_instances = (BrotliDictionary*)dict->alloc_func(
         dict->memory_manager_opaque,
-        dict->num_word_lists * sizeof(*dict->words_instances));
+        num_word_lists * sizeof(*dict->words_instances));
     if (!dict->words_instances) return BROTLI_FALSE;  /* OOM */
+    dict->num_word_lists = num_word_lists;
   }
-  for (i = 0; i < dict->num_word_lists; i++) {
+  for (i = 0; i < num_word_lists; i++) {
     if (!ParseWordList(size, encoded, &pos, &dict->words_instances[i])) {
       return BROTLI_FALSE;
     }
   }
 
   /* NUM_TRANSFORM_LISTS */
-  if (!ReadUint8(encoded, size, &pos, &dict->num_transform_lists)) {
+  if (!ReadUint8(encoded, size, &pos, &num_transform_lists)) {
     return BROTLI_FALSE;
   }
-  if (dict->num_transform_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
+  if (num_transform_lists > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
     return BROTLI_FALSE;
   }
 
-  if (dict->num_transform_lists != 0) {
+  if (num_transform_lists != 0) {
     dict->transforms_instances = (BrotliTransforms*)dict->alloc_func(
         dict->memory_manager_opaque,
-        dict->num_transform_lists * sizeof(*dict->transforms_instances));
+        num_transform_lists * sizeof(*dict->transforms_instances));
     if (!dict->transforms_instances) return BROTLI_FALSE;  /* OOM */
+    dict->num_transform_lists = num_transform_lists;
   }
-  for (i = 0; i < dict->num_transform_lists; i++) {
+  for (i = 0; i < num_transform_lists; i++) {
     BROTLI_BOOL ok = BROTLI_FALSE;
     size_t prefix_suffix_count = 0;
     transform_list_start[i] = pos;
@@ -345,7 +349,7 @@
     if (!dict->prefix_suffix_maps) return BROTLI_FALSE;  /* OOM */
   }
   total_prefix_suffix_count = 0;
-  for (i = 0; i < dict->num_transform_lists; i++) {
+  for (i = 0; i < num_transform_lists; i++) {
     size_t prefix_suffix_count = 0;
     size_t position = transform_list_start[i];
     uint16_t* prefix_suffix_map =
@@ -358,47 +362,53 @@
     total_prefix_suffix_count += prefix_suffix_count;
   }
 
-  if (dict->num_word_lists != 0 || dict->num_transform_lists != 0) {
-    if (!ReadUint8(encoded, size, &pos, &dict->num_dictionaries)) {
+  if (num_word_lists != 0 || num_transform_lists != 0) {
+    uint8_t num_dictionaries;
+    BROTLI_BOOL context_based;
+    if (!ReadUint8(encoded, size, &pos, &num_dictionaries)) {
       return BROTLI_FALSE;
     }
-    if (dict->num_dictionaries == 0 ||
-        dict->num_dictionaries > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
+    if (num_dictionaries == 0 ||
+        num_dictionaries > SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS) {
       return BROTLI_FALSE;
     }
-    for (i = 0; i < dict->num_dictionaries; i++) {
+    for (i = 0; i < num_dictionaries; i++) {
       uint8_t words_index;
       uint8_t transforms_index;
       if (!ReadUint8(encoded, size, &pos, &words_index)) {
         return BROTLI_FALSE;
       }
-      if (words_index > dict->num_word_lists) return BROTLI_FALSE;
+      if (words_index > num_word_lists) return BROTLI_FALSE;
       if (!ReadUint8(encoded, size, &pos, &transforms_index)) {
         return BROTLI_FALSE;
       }
-      if (transforms_index > dict->num_transform_lists) return BROTLI_FALSE;
-      dict->words[i] = words_index == dict->num_word_lists ?
+      if (transforms_index > num_transform_lists) return BROTLI_FALSE;
+      dict->words[i] = words_index == num_word_lists ?
           BrotliGetDictionary() : &dict->words_instances[words_index];
-      dict->transforms[i] = transforms_index == dict->num_transform_lists ?
+      dict->transforms[i] = transforms_index == num_transform_lists ?
           BrotliGetTransforms(): &dict->transforms_instances[transforms_index];
     }
     /* CONTEXT_ENABLED */
-    if (!ReadBool(encoded, size, &pos, &dict->context_based)) {
+    if (!ReadBool(encoded, size, &pos, &context_based)) {
       return BROTLI_FALSE;
     }
 
     /* CONTEXT_MAP */
-    if (dict->context_based) {
+    if (context_based) {
       for (i = 0; i < SHARED_BROTLI_NUM_DICTIONARY_CONTEXTS; i++) {
-        if (!ReadUint8(encoded, size, &pos, &dict->context_map[i])) {
+        uint8_t context_map_entry;
+        if (!ReadUint8(encoded, size, &pos, &context_map_entry)) {
           return BROTLI_FALSE;
         }
-        if (dict->context_map[i] >= dict->num_dictionaries) {
+        if (context_map_entry >= num_dictionaries) {
           return BROTLI_FALSE;
         }
+        dict->context_map[i] = context_map_entry;
       }
     }
-  } else {
+    dict->num_dictionaries = num_dictionaries;
+    dict->context_based = context_based;
+  } else if (dict->num_word_lists == 0 && dict->num_transform_lists == 0) {
     dict->context_based = BROTLI_FALSE;
     dict->num_dictionaries = 1;
     dict->words[0] = BrotliGetDictionary();
@@ -421,6 +431,7 @@
   BROTLI_BOOL is_custom_static_dict = BROTLI_FALSE;
   BROTLI_BOOL has_custom_static_dict =
       dict->num_word_lists > 0 || dict->num_transform_lists > 0;
+  BrotliSharedDictionary backup;
 
   /* Check magic header bytes. */
   if (size < 2) return BROTLI_FALSE;
@@ -437,7 +448,21 @@
   /* Cannot combine different static dictionaries, only prefix dictionaries */
   if (has_custom_static_dict && is_custom_static_dict) return BROTLI_FALSE;
 
-  return ParseDictionary(encoded, size, dict);
+  backup = *dict;
+  if (!ParseDictionary(encoded, size, dict)) {
+    if (dict->words_instances != backup.words_instances) {
+      dict->free_func(dict->memory_manager_opaque, dict->words_instances);
+    }
+    if (dict->transforms_instances != backup.transforms_instances) {
+      dict->free_func(dict->memory_manager_opaque, dict->transforms_instances);
+    }
+    if (dict->prefix_suffix_maps != backup.prefix_suffix_maps) {
+      dict->free_func(dict->memory_manager_opaque, dict->prefix_suffix_maps);
+    }
+    *dict = backup;
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
 }
 
 #endif  /* BROTLI_EXPERIMENTAL */