1 /*
2  * Copyright (c) 2009-2021, Google LLC
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *     * Redistributions of source code must retain the above copyright
8  *       notice, this list of conditions and the following disclaimer.
9  *     * Redistributions in binary form must reproduce the above copyright
10  *       notice, this list of conditions and the following disclaimer in the
11  *       documentation and/or other materials provided with the distribution.
12  *     * Neither the name of Google LLC nor the
13  *       names of its contributors may be used to endorse or promote products
14  *       derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
20  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #include "upb/message/promote.h"
29 
30 #include "upb/collections/array.h"
31 #include "upb/collections/array_internal.h"
32 #include "upb/collections/map.h"
33 #include "upb/message/accessors.h"
34 #include "upb/message/message.h"
35 #include "upb/mini_table/field_internal.h"
36 #include "upb/wire/common.h"
37 #include "upb/wire/decode.h"
38 #include "upb/wire/encode.h"
39 #include "upb/wire/eps_copy_input_stream.h"
40 #include "upb/wire/reader.h"
41 
42 // Must be last.
43 #include "upb/port/def.inc"
44 
45 // Parses unknown data by merging into existing base_message or creating a
46 // new message usingg mini_table.
upb_MiniTable_ParseUnknownMessage(const char * unknown_data,size_t unknown_size,const upb_MiniTable * mini_table,upb_Message * base_message,int decode_options,upb_Arena * arena)47 static upb_UnknownToMessageRet upb_MiniTable_ParseUnknownMessage(
48     const char* unknown_data, size_t unknown_size,
49     const upb_MiniTable* mini_table, upb_Message* base_message,
50     int decode_options, upb_Arena* arena) {
51   upb_UnknownToMessageRet ret;
52   ret.message =
53       base_message ? base_message : _upb_Message_New(mini_table, arena);
54   if (!ret.message) {
55     ret.status = kUpb_UnknownToMessage_OutOfMemory;
56     return ret;
57   }
58   // Decode sub message using unknown field contents.
59   const char* data = unknown_data;
60   uint32_t tag;
61   uint64_t message_len = 0;
62   data = upb_WireReader_ReadTag(data, &tag);
63   data = upb_WireReader_ReadVarint(data, &message_len);
64   upb_DecodeStatus status = upb_Decode(data, message_len, ret.message,
65                                        mini_table, NULL, decode_options, arena);
66   if (status == kUpb_DecodeStatus_OutOfMemory) {
67     ret.status = kUpb_UnknownToMessage_OutOfMemory;
68   } else if (status == kUpb_DecodeStatus_Ok) {
69     ret.status = kUpb_UnknownToMessage_Ok;
70   } else {
71     ret.status = kUpb_UnknownToMessage_ParseError;
72   }
73   return ret;
74 }
75 
upb_MiniTable_GetOrPromoteExtension(upb_Message * msg,const upb_MiniTableExtension * ext_table,int decode_options,upb_Arena * arena,const upb_Message_Extension ** extension)76 upb_GetExtension_Status upb_MiniTable_GetOrPromoteExtension(
77     upb_Message* msg, const upb_MiniTableExtension* ext_table,
78     int decode_options, upb_Arena* arena,
79     const upb_Message_Extension** extension) {
80   UPB_ASSERT(upb_MiniTableField_CType(&ext_table->field) == kUpb_CType_Message);
81   *extension = _upb_Message_Getext(msg, ext_table);
82   if (*extension) {
83     return kUpb_GetExtension_Ok;
84   }
85 
86   // Check unknown fields, if available promote.
87   int field_number = ext_table->field.number;
88   upb_FindUnknownRet result = upb_MiniTable_FindUnknown(
89       msg, field_number, kUpb_WireFormat_DefaultDepthLimit);
90   if (result.status != kUpb_FindUnknown_Ok) {
91     return kUpb_GetExtension_NotPresent;
92   }
93   size_t len;
94   size_t ofs = result.ptr - upb_Message_GetUnknown(msg, &len);
95   // Decode and promote from unknown.
96   const upb_MiniTable* extension_table = ext_table->sub.submsg;
97   upb_UnknownToMessageRet parse_result = upb_MiniTable_ParseUnknownMessage(
98       result.ptr, result.len, extension_table,
99       /* base_message= */ NULL, decode_options, arena);
100   switch (parse_result.status) {
101     case kUpb_UnknownToMessage_OutOfMemory:
102       return kUpb_GetExtension_OutOfMemory;
103     case kUpb_UnknownToMessage_ParseError:
104       return kUpb_GetExtension_ParseError;
105     case kUpb_UnknownToMessage_NotFound:
106       return kUpb_GetExtension_NotPresent;
107     case kUpb_UnknownToMessage_Ok:
108       break;
109   }
110   upb_Message* extension_msg = parse_result.message;
111   // Add to extensions.
112   upb_Message_Extension* ext =
113       _upb_Message_GetOrCreateExtension(msg, ext_table, arena);
114   if (!ext) {
115     return kUpb_GetExtension_OutOfMemory;
116   }
117   memcpy(&ext->data, &extension_msg, sizeof(extension_msg));
118   *extension = ext;
119   const char* delete_ptr = upb_Message_GetUnknown(msg, &len) + ofs;
120   upb_Message_DeleteUnknown(msg, delete_ptr, result.len);
121   return kUpb_GetExtension_Ok;
122 }
123 
upb_MiniTable_GetExtensionAsBytes(const upb_Message * msg,const upb_MiniTableExtension * ext_table,int encode_options,upb_Arena * arena,const char ** extension_data,size_t * len)124 upb_GetExtensionAsBytes_Status upb_MiniTable_GetExtensionAsBytes(
125     const upb_Message* msg, const upb_MiniTableExtension* ext_table,
126     int encode_options, upb_Arena* arena, const char** extension_data,
127     size_t* len) {
128   const upb_Message_Extension* msg_ext = _upb_Message_Getext(msg, ext_table);
129   UPB_ASSERT(upb_MiniTableField_CType(&ext_table->field) == kUpb_CType_Message);
130   if (msg_ext) {
131     upb_EncodeStatus status =
132         upb_Encode(msg_ext->data.ptr, msg_ext->ext->sub.submsg, encode_options,
133                    arena, (char**)extension_data, len);
134     if (status != kUpb_EncodeStatus_Ok) {
135       return kUpb_GetExtensionAsBytes_EncodeError;
136     }
137     return kUpb_GetExtensionAsBytes_Ok;
138   }
139   int field_number = ext_table->field.number;
140   upb_FindUnknownRet result = upb_MiniTable_FindUnknown(
141       msg, field_number, upb_DecodeOptions_GetMaxDepth(encode_options));
142   if (result.status != kUpb_FindUnknown_Ok) {
143     return kUpb_GetExtensionAsBytes_NotPresent;
144   }
145   const char* data = result.ptr;
146   uint32_t tag;
147   uint64_t message_len = 0;
148   data = upb_WireReader_ReadTag(data, &tag);
149   data = upb_WireReader_ReadVarint(data, &message_len);
150   *extension_data = data;
151   *len = message_len;
152   return kUpb_GetExtensionAsBytes_Ok;
153 }
154 
upb_FindUnknownRet_ParseError(void)155 static upb_FindUnknownRet upb_FindUnknownRet_ParseError(void) {
156   return (upb_FindUnknownRet){.status = kUpb_FindUnknown_ParseError};
157 }
158 
upb_MiniTable_FindUnknown(const upb_Message * msg,uint32_t field_number,int depth_limit)159 upb_FindUnknownRet upb_MiniTable_FindUnknown(const upb_Message* msg,
160                                              uint32_t field_number,
161                                              int depth_limit) {
162   size_t size;
163   upb_FindUnknownRet ret;
164 
165   const char* ptr = upb_Message_GetUnknown(msg, &size);
166   upb_EpsCopyInputStream stream;
167   upb_EpsCopyInputStream_Init(&stream, &ptr, size, true);
168 
169   while (!upb_EpsCopyInputStream_IsDone(&stream, &ptr)) {
170     uint32_t tag;
171     const char* unknown_begin = ptr;
172     ptr = upb_WireReader_ReadTag(ptr, &tag);
173     if (!ptr) return upb_FindUnknownRet_ParseError();
174     if (field_number == upb_WireReader_GetFieldNumber(tag)) {
175       ret.status = kUpb_FindUnknown_Ok;
176       ret.ptr = upb_EpsCopyInputStream_GetAliasedPtr(&stream, unknown_begin);
177       ptr = _upb_WireReader_SkipValue(ptr, tag, depth_limit, &stream);
178       // Because we know that the input is a flat buffer, it is safe to perform
179       // pointer arithmetic on aliased pointers.
180       ret.len = upb_EpsCopyInputStream_GetAliasedPtr(&stream, ptr) - ret.ptr;
181       return ret;
182     }
183 
184     ptr = _upb_WireReader_SkipValue(ptr, tag, depth_limit, &stream);
185     if (!ptr) return upb_FindUnknownRet_ParseError();
186   }
187   ret.status = kUpb_FindUnknown_NotPresent;
188   ret.ptr = NULL;
189   ret.len = 0;
190   return ret;
191 }
192 
193 // Warning: See TODO(b/267655898)
upb_MiniTable_PromoteUnknownToMessage(upb_Message * msg,const upb_MiniTable * mini_table,const upb_MiniTableField * field,const upb_MiniTable * sub_mini_table,int decode_options,upb_Arena * arena)194 upb_UnknownToMessageRet upb_MiniTable_PromoteUnknownToMessage(
195     upb_Message* msg, const upb_MiniTable* mini_table,
196     const upb_MiniTableField* field, const upb_MiniTable* sub_mini_table,
197     int decode_options, upb_Arena* arena) {
198   upb_FindUnknownRet unknown;
199   // We need to loop and merge unknowns that have matching tag field->number.
200   upb_Message* message = NULL;
201   // Callers should check that message is not set first before calling
202   // PromotoUnknownToMessage.
203   UPB_ASSERT(upb_MiniTable_GetSubMessageTable(mini_table, field) ==
204              sub_mini_table);
205   bool is_oneof = _upb_MiniTableField_InOneOf(field);
206   if (!is_oneof || _upb_getoneofcase_field(msg, field) == field->number) {
207     UPB_ASSERT(upb_Message_GetMessage(msg, field, NULL) == NULL);
208   }
209   upb_UnknownToMessageRet ret;
210   ret.status = kUpb_UnknownToMessage_Ok;
211   do {
212     unknown = upb_MiniTable_FindUnknown(
213         msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
214     switch (unknown.status) {
215       case kUpb_FindUnknown_Ok: {
216         const char* unknown_data = unknown.ptr;
217         size_t unknown_size = unknown.len;
218         ret = upb_MiniTable_ParseUnknownMessage(unknown_data, unknown_size,
219                                                 sub_mini_table, message,
220                                                 decode_options, arena);
221         if (ret.status == kUpb_UnknownToMessage_Ok) {
222           message = ret.message;
223           upb_Message_DeleteUnknown(msg, unknown_data, unknown_size);
224         }
225       } break;
226       case kUpb_FindUnknown_ParseError:
227         ret.status = kUpb_UnknownToMessage_ParseError;
228         break;
229       case kUpb_FindUnknown_NotPresent:
230         // If we parsed at least one unknown, we are done.
231         ret.status =
232             message ? kUpb_UnknownToMessage_Ok : kUpb_UnknownToMessage_NotFound;
233         break;
234     }
235   } while (unknown.status == kUpb_FindUnknown_Ok);
236   if (message) {
237     if (is_oneof) {
238       *_upb_oneofcase_field(msg, field) = field->number;
239     }
240     upb_Message_SetMessage(msg, mini_table, field, message);
241     ret.message = message;
242   }
243   return ret;
244 }
245 
246 // Moves repeated messages in unknowns to a upb_Array.
247 //
248 // Since the repeated field is not a scalar type we don't check for
249 // kUpb_LabelFlags_IsPacked.
250 // TODO(b/251007554): Optimize. Instead of converting messages one at a time,
251 // scan all unknown data once and compact.
upb_MiniTable_PromoteUnknownToMessageArray(upb_Message * msg,const upb_MiniTableField * field,const upb_MiniTable * mini_table,int decode_options,upb_Arena * arena)252 upb_UnknownToMessage_Status upb_MiniTable_PromoteUnknownToMessageArray(
253     upb_Message* msg, const upb_MiniTableField* field,
254     const upb_MiniTable* mini_table, int decode_options, upb_Arena* arena) {
255   upb_Array* repeated_messages = upb_Message_GetMutableArray(msg, field);
256   // Find all unknowns with given field number and parse.
257   upb_FindUnknownRet unknown;
258   do {
259     unknown = upb_MiniTable_FindUnknown(
260         msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
261     if (unknown.status == kUpb_FindUnknown_Ok) {
262       upb_UnknownToMessageRet ret = upb_MiniTable_ParseUnknownMessage(
263           unknown.ptr, unknown.len, mini_table,
264           /* base_message= */ NULL, decode_options, arena);
265       if (ret.status == kUpb_UnknownToMessage_Ok) {
266         upb_MessageValue value;
267         value.msg_val = ret.message;
268         // Allocate array on demand before append.
269         if (!repeated_messages) {
270           upb_Message_ResizeArray(msg, field, 0, arena);
271           repeated_messages = upb_Message_GetMutableArray(msg, field);
272         }
273         if (!upb_Array_Append(repeated_messages, value, arena)) {
274           return kUpb_UnknownToMessage_OutOfMemory;
275         }
276         upb_Message_DeleteUnknown(msg, unknown.ptr, unknown.len);
277       } else {
278         return ret.status;
279       }
280     }
281   } while (unknown.status == kUpb_FindUnknown_Ok);
282   return kUpb_UnknownToMessage_Ok;
283 }
284 
285 // Moves repeated messages in unknowns to a upb_Map.
upb_MiniTable_PromoteUnknownToMap(upb_Message * msg,const upb_MiniTable * mini_table,const upb_MiniTableField * field,int decode_options,upb_Arena * arena)286 upb_UnknownToMessage_Status upb_MiniTable_PromoteUnknownToMap(
287     upb_Message* msg, const upb_MiniTable* mini_table,
288     const upb_MiniTableField* field, int decode_options, upb_Arena* arena) {
289   const upb_MiniTable* map_entry_mini_table =
290       mini_table->subs[field->UPB_PRIVATE(submsg_index)].submsg;
291   UPB_ASSERT(map_entry_mini_table);
292   UPB_ASSERT(map_entry_mini_table);
293   UPB_ASSERT(map_entry_mini_table->field_count == 2);
294   UPB_ASSERT(upb_FieldMode_Get(field) == kUpb_FieldMode_Map);
295   // Find all unknowns with given field number and parse.
296   upb_FindUnknownRet unknown;
297   while (1) {
298     unknown = upb_MiniTable_FindUnknown(
299         msg, field->number, upb_DecodeOptions_GetMaxDepth(decode_options));
300     if (unknown.status != kUpb_FindUnknown_Ok) break;
301     upb_UnknownToMessageRet ret = upb_MiniTable_ParseUnknownMessage(
302         unknown.ptr, unknown.len, map_entry_mini_table,
303         /* base_message= */ NULL, decode_options, arena);
304     if (ret.status != kUpb_UnknownToMessage_Ok) return ret.status;
305     // Allocate map on demand before append.
306     upb_Map* map = upb_Message_GetOrCreateMutableMap(msg, map_entry_mini_table,
307                                                      field, arena);
308     upb_Message* map_entry_message = ret.message;
309     upb_MapInsertStatus insert_status = upb_Message_InsertMapEntry(
310         map, mini_table, field, map_entry_message, arena);
311     if (insert_status == kUpb_MapInsertStatus_OutOfMemory) {
312       return kUpb_UnknownToMessage_OutOfMemory;
313     }
314     UPB_ASSUME(insert_status == kUpb_MapInsertStatus_Inserted ||
315                insert_status == kUpb_MapInsertStatus_Replaced);
316     upb_Message_DeleteUnknown(msg, unknown.ptr, unknown.len);
317   }
318   return kUpb_UnknownToMessage_Ok;
319 }
320