1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 // Author: kenton@google.com (Kenton Varda)
32 // Based on original Protocol Buffers design by
33 // Sanjay Ghemawat, Jeff Dean, and others.
34
35 #include <google/protobuf/unknown_field_set.h>
36
37 #include <google/protobuf/stubs/logging.h>
38 #include <google/protobuf/stubs/common.h>
39 #include <google/protobuf/parse_context.h>
40 #include <google/protobuf/io/coded_stream.h>
41 #include <google/protobuf/io/zero_copy_stream.h>
42 #include <google/protobuf/io/zero_copy_stream_impl.h>
43 #include <google/protobuf/extension_set.h>
44 #include <google/protobuf/generated_message_tctable_decl.h>
45 #include <google/protobuf/generated_message_tctable_impl.h>
46 #include <google/protobuf/wire_format.h>
47 #include <google/protobuf/wire_format_lite.h>
48 #include <google/protobuf/stubs/stl_util.h>
49
50 #include <google/protobuf/port_def.inc>
51
52 namespace google {
53 namespace protobuf {
54
default_instance()55 const UnknownFieldSet& UnknownFieldSet::default_instance() {
56 static auto instance = internal::OnShutdownDelete(new UnknownFieldSet());
57 return *instance;
58 }
59
ClearFallback()60 void UnknownFieldSet::ClearFallback() {
61 GOOGLE_DCHECK(!fields_.empty());
62 int n = fields_.size();
63 do {
64 (fields_)[--n].Delete();
65 } while (n > 0);
66 fields_.clear();
67 }
68
InternalMergeFrom(const UnknownFieldSet & other)69 void UnknownFieldSet::InternalMergeFrom(const UnknownFieldSet& other) {
70 int other_field_count = other.field_count();
71 if (other_field_count > 0) {
72 fields_.reserve(fields_.size() + other_field_count);
73 for (int i = 0; i < other_field_count; i++) {
74 fields_.push_back((other.fields_)[i]);
75 fields_.back().DeepCopy((other.fields_)[i]);
76 }
77 }
78 }
79
MergeFrom(const UnknownFieldSet & other)80 void UnknownFieldSet::MergeFrom(const UnknownFieldSet& other) {
81 int other_field_count = other.field_count();
82 if (other_field_count > 0) {
83 fields_.reserve(fields_.size() + other_field_count);
84 for (int i = 0; i < other_field_count; i++) {
85 fields_.push_back((other.fields_)[i]);
86 fields_.back().DeepCopy((other.fields_)[i]);
87 }
88 }
89 }
90
91 // A specialized MergeFrom for performance when we are merging from an UFS that
92 // is temporary and can be destroyed in the process.
MergeFromAndDestroy(UnknownFieldSet * other)93 void UnknownFieldSet::MergeFromAndDestroy(UnknownFieldSet* other) {
94 if (fields_.empty()) {
95 fields_ = std::move(other->fields_);
96 } else {
97 fields_.insert(fields_.end(),
98 std::make_move_iterator(other->fields_.begin()),
99 std::make_move_iterator(other->fields_.end()));
100 }
101 other->fields_.clear();
102 }
103
MergeToInternalMetadata(const UnknownFieldSet & other,internal::InternalMetadata * metadata)104 void UnknownFieldSet::MergeToInternalMetadata(
105 const UnknownFieldSet& other, internal::InternalMetadata* metadata) {
106 metadata->mutable_unknown_fields<UnknownFieldSet>()->MergeFrom(other);
107 }
108
SpaceUsedExcludingSelfLong() const109 size_t UnknownFieldSet::SpaceUsedExcludingSelfLong() const {
110 if (fields_.empty()) return 0;
111
112 size_t total_size = sizeof(fields_) + sizeof(UnknownField) * fields_.size();
113
114 for (const UnknownField& field : fields_) {
115 switch (field.type()) {
116 case UnknownField::TYPE_LENGTH_DELIMITED:
117 total_size += sizeof(*field.data_.length_delimited_.string_value) +
118 internal::StringSpaceUsedExcludingSelfLong(
119 *field.data_.length_delimited_.string_value);
120 break;
121 case UnknownField::TYPE_GROUP:
122 total_size += field.data_.group_->SpaceUsedLong();
123 break;
124 default:
125 break;
126 }
127 }
128 return total_size;
129 }
130
SpaceUsedLong() const131 size_t UnknownFieldSet::SpaceUsedLong() const {
132 return sizeof(*this) + SpaceUsedExcludingSelf();
133 }
134
AddVarint(int number,uint64 value)135 void UnknownFieldSet::AddVarint(int number, uint64 value) {
136 UnknownField field;
137 field.number_ = number;
138 field.SetType(UnknownField::TYPE_VARINT);
139 field.data_.varint_ = value;
140 fields_.push_back(field);
141 }
142
AddFixed32(int number,uint32 value)143 void UnknownFieldSet::AddFixed32(int number, uint32 value) {
144 UnknownField field;
145 field.number_ = number;
146 field.SetType(UnknownField::TYPE_FIXED32);
147 field.data_.fixed32_ = value;
148 fields_.push_back(field);
149 }
150
AddFixed64(int number,uint64 value)151 void UnknownFieldSet::AddFixed64(int number, uint64 value) {
152 UnknownField field;
153 field.number_ = number;
154 field.SetType(UnknownField::TYPE_FIXED64);
155 field.data_.fixed64_ = value;
156 fields_.push_back(field);
157 }
158
AddLengthDelimited(int number)159 std::string* UnknownFieldSet::AddLengthDelimited(int number) {
160 UnknownField field;
161 field.number_ = number;
162 field.SetType(UnknownField::TYPE_LENGTH_DELIMITED);
163 field.data_.length_delimited_.string_value = new std::string;
164 fields_.push_back(field);
165 return field.data_.length_delimited_.string_value;
166 }
167
168
AddGroup(int number)169 UnknownFieldSet* UnknownFieldSet::AddGroup(int number) {
170 UnknownField field;
171 field.number_ = number;
172 field.SetType(UnknownField::TYPE_GROUP);
173 field.data_.group_ = new UnknownFieldSet;
174 fields_.push_back(field);
175 return field.data_.group_;
176 }
177
AddField(const UnknownField & field)178 void UnknownFieldSet::AddField(const UnknownField& field) {
179 fields_.push_back(field);
180 fields_.back().DeepCopy(field);
181 }
182
DeleteSubrange(int start,int num)183 void UnknownFieldSet::DeleteSubrange(int start, int num) {
184 // Delete the specified fields.
185 for (int i = 0; i < num; ++i) {
186 (fields_)[i + start].Delete();
187 }
188 // Slide down the remaining fields.
189 for (size_t i = start + num; i < fields_.size(); ++i) {
190 (fields_)[i - num] = (fields_)[i];
191 }
192 // Pop off the # of deleted fields.
193 for (int i = 0; i < num; ++i) {
194 fields_.pop_back();
195 }
196 }
197
DeleteByNumber(int number)198 void UnknownFieldSet::DeleteByNumber(int number) {
199 size_t left = 0; // The number of fields left after deletion.
200 for (size_t i = 0; i < fields_.size(); ++i) {
201 UnknownField* field = &(fields_)[i];
202 if (field->number() == number) {
203 field->Delete();
204 } else {
205 if (i != left) {
206 (fields_)[left] = (fields_)[i];
207 }
208 ++left;
209 }
210 }
211 fields_.resize(left);
212 }
213
MergeFromCodedStream(io::CodedInputStream * input)214 bool UnknownFieldSet::MergeFromCodedStream(io::CodedInputStream* input) {
215 UnknownFieldSet other;
216 if (internal::WireFormat::SkipMessage(input, &other) &&
217 input->ConsumedEntireMessage()) {
218 MergeFromAndDestroy(&other);
219 return true;
220 } else {
221 return false;
222 }
223 }
224
ParseFromCodedStream(io::CodedInputStream * input)225 bool UnknownFieldSet::ParseFromCodedStream(io::CodedInputStream* input) {
226 Clear();
227 return MergeFromCodedStream(input);
228 }
229
ParseFromZeroCopyStream(io::ZeroCopyInputStream * input)230 bool UnknownFieldSet::ParseFromZeroCopyStream(io::ZeroCopyInputStream* input) {
231 io::CodedInputStream coded_input(input);
232 return (ParseFromCodedStream(&coded_input) &&
233 coded_input.ConsumedEntireMessage());
234 }
235
ParseFromArray(const void * data,int size)236 bool UnknownFieldSet::ParseFromArray(const void* data, int size) {
237 io::ArrayInputStream input(data, size);
238 return ParseFromZeroCopyStream(&input);
239 }
240
Delete()241 void UnknownField::Delete() {
242 switch (type()) {
243 case UnknownField::TYPE_LENGTH_DELIMITED:
244 delete data_.length_delimited_.string_value;
245 break;
246 case UnknownField::TYPE_GROUP:
247 delete data_.group_;
248 break;
249 default:
250 break;
251 }
252 }
253
DeepCopy(const UnknownField & other)254 void UnknownField::DeepCopy(const UnknownField& other) {
255 switch (type()) {
256 case UnknownField::TYPE_LENGTH_DELIMITED:
257 data_.length_delimited_.string_value =
258 new std::string(*data_.length_delimited_.string_value);
259 break;
260 case UnknownField::TYPE_GROUP: {
261 UnknownFieldSet* group = new UnknownFieldSet();
262 group->InternalMergeFrom(*data_.group_);
263 data_.group_ = group;
264 break;
265 }
266 default:
267 break;
268 }
269 }
270
271
InternalSerializeLengthDelimitedNoTag(uint8 * target,io::EpsCopyOutputStream * stream) const272 uint8* UnknownField::InternalSerializeLengthDelimitedNoTag(
273 uint8* target, io::EpsCopyOutputStream* stream) const {
274 GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
275 const std::string& data = *data_.length_delimited_.string_value;
276 target = io::CodedOutputStream::WriteVarint32ToArray(data.size(), target);
277 target = stream->WriteRaw(data.data(), data.size(), target);
278 return target;
279 }
280
281 namespace internal {
282
283 class UnknownFieldParserHelper {
284 public:
UnknownFieldParserHelper(UnknownFieldSet * unknown)285 explicit UnknownFieldParserHelper(UnknownFieldSet* unknown)
286 : unknown_(unknown) {}
287
AddVarint(uint32 num,uint64 value)288 void AddVarint(uint32 num, uint64 value) { unknown_->AddVarint(num, value); }
AddFixed64(uint32 num,uint64 value)289 void AddFixed64(uint32 num, uint64 value) {
290 unknown_->AddFixed64(num, value);
291 }
ParseLengthDelimited(uint32 num,const char * ptr,ParseContext * ctx)292 const char* ParseLengthDelimited(uint32 num, const char* ptr,
293 ParseContext* ctx) {
294 std::string* s = unknown_->AddLengthDelimited(num);
295 int size = ReadSize(&ptr);
296 GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
297 return ctx->ReadString(ptr, size, s);
298 }
ParseGroup(uint32 num,const char * ptr,ParseContext * ctx)299 const char* ParseGroup(uint32 num, const char* ptr, ParseContext* ctx) {
300 UnknownFieldParserHelper child(unknown_->AddGroup(num));
301 return ctx->ParseGroup(&child, ptr, num * 8 + 3);
302 }
AddFixed32(uint32 num,uint32 value)303 void AddFixed32(uint32 num, uint32 value) {
304 unknown_->AddFixed32(num, value);
305 }
306
_InternalParse(const char * ptr,ParseContext * ctx)307 const char* _InternalParse(const char* ptr, ParseContext* ctx) {
308 return WireFormatParser(*this, ptr, ctx);
309 }
310
311 private:
312 UnknownFieldSet* unknown_;
313 };
314
UnknownGroupParse(UnknownFieldSet * unknown,const char * ptr,ParseContext * ctx)315 const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr,
316 ParseContext* ctx) {
317 UnknownFieldParserHelper field_parser(unknown);
318 return WireFormatParser(field_parser, ptr, ctx);
319 }
320
UnknownFieldParse(uint64 tag,UnknownFieldSet * unknown,const char * ptr,ParseContext * ctx)321 const char* UnknownFieldParse(uint64 tag, UnknownFieldSet* unknown,
322 const char* ptr, ParseContext* ctx) {
323 UnknownFieldParserHelper field_parser(unknown);
324 return FieldParser(tag, field_parser, ptr, ctx);
325 }
326
327 } // namespace internal
328 } // namespace protobuf
329 } // namespace google
330
331 #include <google/protobuf/port_undef.inc>
332