Added Android code
[wl-app.git] / iOS / Pods / Protobuf / objectivec / GPBCodedInputStream.m
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 #import "GPBCodedInputStream_PackagePrivate.h"
32
33 #import "GPBDictionary_PackagePrivate.h"
34 #import "GPBMessage_PackagePrivate.h"
35 #import "GPBUnknownFieldSet_PackagePrivate.h"
36 #import "GPBUtilities_PackagePrivate.h"
37 #import "GPBWireFormat.h"
38
39 NSString *const GPBCodedInputStreamException =
40     GPBNSStringifySymbol(GPBCodedInputStreamException);
41
42 NSString *const GPBCodedInputStreamUnderlyingErrorKey =
43     GPBNSStringifySymbol(GPBCodedInputStreamUnderlyingErrorKey);
44
45 NSString *const GPBCodedInputStreamErrorDomain =
46     GPBNSStringifySymbol(GPBCodedInputStreamErrorDomain);
47
48 // Matching:
49 // https://github.com/google/protobuf/blob/master/java/core/src/main/java/com/google/protobuf/CodedInputStream.java#L62
50 //  private static final int DEFAULT_RECURSION_LIMIT = 100;
51 // https://github.com/google/protobuf/blob/master/src/google/protobuf/io/coded_stream.cc#L86
52 //  int CodedInputStream::default_recursion_limit_ = 100;
53 static const NSUInteger kDefaultRecursionLimit = 100;
54
55 static void RaiseException(NSInteger code, NSString *reason) {
56   NSDictionary *errorInfo = nil;
57   if ([reason length]) {
58     errorInfo = @{ GPBErrorReasonKey: reason };
59   }
60   NSError *error = [NSError errorWithDomain:GPBCodedInputStreamErrorDomain
61                                        code:code
62                                    userInfo:errorInfo];
63
64   NSDictionary *exceptionInfo =
65       @{ GPBCodedInputStreamUnderlyingErrorKey: error };
66   [[NSException exceptionWithName:GPBCodedInputStreamException
67                            reason:reason
68                          userInfo:exceptionInfo] raise];
69 }
70
71 static void CheckRecursionLimit(GPBCodedInputStreamState *state) {
72   if (state->recursionDepth >= kDefaultRecursionLimit) {
73     RaiseException(GPBCodedInputStreamErrorRecursionDepthExceeded, nil);
74   }
75 }
76
77 static void CheckSize(GPBCodedInputStreamState *state, size_t size) {
78   size_t newSize = state->bufferPos + size;
79   if (newSize > state->bufferSize) {
80     RaiseException(GPBCodedInputStreamErrorInvalidSize, nil);
81   }
82   if (newSize > state->currentLimit) {
83     // Fast forward to end of currentLimit;
84     state->bufferPos = state->currentLimit;
85     RaiseException(GPBCodedInputStreamErrorSubsectionLimitReached, nil);
86   }
87 }
88
89 static int8_t ReadRawByte(GPBCodedInputStreamState *state) {
90   CheckSize(state, sizeof(int8_t));
91   return ((int8_t *)state->bytes)[state->bufferPos++];
92 }
93
94 static int32_t ReadRawLittleEndian32(GPBCodedInputStreamState *state) {
95   CheckSize(state, sizeof(int32_t));
96   int32_t value = OSReadLittleInt32(state->bytes, state->bufferPos);
97   state->bufferPos += sizeof(int32_t);
98   return value;
99 }
100
101 static int64_t ReadRawLittleEndian64(GPBCodedInputStreamState *state) {
102   CheckSize(state, sizeof(int64_t));
103   int64_t value = OSReadLittleInt64(state->bytes, state->bufferPos);
104   state->bufferPos += sizeof(int64_t);
105   return value;
106 }
107
108 static int64_t ReadRawVarint64(GPBCodedInputStreamState *state) {
109   int32_t shift = 0;
110   int64_t result = 0;
111   while (shift < 64) {
112     int8_t b = ReadRawByte(state);
113     result |= (int64_t)((uint64_t)(b & 0x7F) << shift);
114     if ((b & 0x80) == 0) {
115       return result;
116     }
117     shift += 7;
118   }
119   RaiseException(GPBCodedInputStreamErrorInvalidVarInt, @"Invalid VarInt64");
120   return 0;
121 }
122
123 static int32_t ReadRawVarint32(GPBCodedInputStreamState *state) {
124   return (int32_t)ReadRawVarint64(state);
125 }
126
127 static void SkipRawData(GPBCodedInputStreamState *state, size_t size) {
128   CheckSize(state, size);
129   state->bufferPos += size;
130 }
131
132 double GPBCodedInputStreamReadDouble(GPBCodedInputStreamState *state) {
133   int64_t value = ReadRawLittleEndian64(state);
134   return GPBConvertInt64ToDouble(value);
135 }
136
137 float GPBCodedInputStreamReadFloat(GPBCodedInputStreamState *state) {
138   int32_t value = ReadRawLittleEndian32(state);
139   return GPBConvertInt32ToFloat(value);
140 }
141
142 uint64_t GPBCodedInputStreamReadUInt64(GPBCodedInputStreamState *state) {
143   uint64_t value = ReadRawVarint64(state);
144   return value;
145 }
146
147 uint32_t GPBCodedInputStreamReadUInt32(GPBCodedInputStreamState *state) {
148   uint32_t value = ReadRawVarint32(state);
149   return value;
150 }
151
152 int64_t GPBCodedInputStreamReadInt64(GPBCodedInputStreamState *state) {
153   int64_t value = ReadRawVarint64(state);
154   return value;
155 }
156
157 int32_t GPBCodedInputStreamReadInt32(GPBCodedInputStreamState *state) {
158   int32_t value = ReadRawVarint32(state);
159   return value;
160 }
161
162 uint64_t GPBCodedInputStreamReadFixed64(GPBCodedInputStreamState *state) {
163   uint64_t value = ReadRawLittleEndian64(state);
164   return value;
165 }
166
167 uint32_t GPBCodedInputStreamReadFixed32(GPBCodedInputStreamState *state) {
168   uint32_t value = ReadRawLittleEndian32(state);
169   return value;
170 }
171
172 int32_t GPBCodedInputStreamReadEnum(GPBCodedInputStreamState *state) {
173   int32_t value = ReadRawVarint32(state);
174   return value;
175 }
176
177 int32_t GPBCodedInputStreamReadSFixed32(GPBCodedInputStreamState *state) {
178   int32_t value = ReadRawLittleEndian32(state);
179   return value;
180 }
181
182 int64_t GPBCodedInputStreamReadSFixed64(GPBCodedInputStreamState *state) {
183   int64_t value = ReadRawLittleEndian64(state);
184   return value;
185 }
186
187 int32_t GPBCodedInputStreamReadSInt32(GPBCodedInputStreamState *state) {
188   int32_t value = GPBDecodeZigZag32(ReadRawVarint32(state));
189   return value;
190 }
191
192 int64_t GPBCodedInputStreamReadSInt64(GPBCodedInputStreamState *state) {
193   int64_t value = GPBDecodeZigZag64(ReadRawVarint64(state));
194   return value;
195 }
196
197 BOOL GPBCodedInputStreamReadBool(GPBCodedInputStreamState *state) {
198   return ReadRawVarint32(state) != 0;
199 }
200
201 int32_t GPBCodedInputStreamReadTag(GPBCodedInputStreamState *state) {
202   if (GPBCodedInputStreamIsAtEnd(state)) {
203     state->lastTag = 0;
204     return 0;
205   }
206
207   state->lastTag = ReadRawVarint32(state);
208   // Tags have to include a valid wireformat.
209   if (!GPBWireFormatIsValidTag(state->lastTag)) {
210     RaiseException(GPBCodedInputStreamErrorInvalidTag,
211                    @"Invalid wireformat in tag.");
212   }
213   // Zero is not a valid field number.
214   if (GPBWireFormatGetTagFieldNumber(state->lastTag) == 0) {
215     RaiseException(GPBCodedInputStreamErrorInvalidTag,
216                    @"A zero field number on the wire is invalid.");
217   }
218   return state->lastTag;
219 }
220
221 NSString *GPBCodedInputStreamReadRetainedString(
222     GPBCodedInputStreamState *state) {
223   int32_t size = ReadRawVarint32(state);
224   NSString *result;
225   if (size == 0) {
226     result = @"";
227   } else {
228     CheckSize(state, size);
229     result = [[NSString alloc] initWithBytes:&state->bytes[state->bufferPos]
230                                       length:size
231                                     encoding:NSUTF8StringEncoding];
232     state->bufferPos += size;
233     if (!result) {
234 #ifdef DEBUG
235       // https://developers.google.com/protocol-buffers/docs/proto#scalar
236       NSLog(@"UTF-8 failure, is some field type 'string' when it should be "
237             @"'bytes'?");
238 #endif
239       RaiseException(GPBCodedInputStreamErrorInvalidUTF8, nil);
240     }
241   }
242   return result;
243 }
244
245 NSData *GPBCodedInputStreamReadRetainedBytes(GPBCodedInputStreamState *state) {
246   int32_t size = ReadRawVarint32(state);
247   if (size < 0) return nil;
248   CheckSize(state, size);
249   NSData *result = [[NSData alloc] initWithBytes:state->bytes + state->bufferPos
250                                           length:size];
251   state->bufferPos += size;
252   return result;
253 }
254
255 NSData *GPBCodedInputStreamReadRetainedBytesNoCopy(
256     GPBCodedInputStreamState *state) {
257   int32_t size = ReadRawVarint32(state);
258   if (size < 0) return nil;
259   CheckSize(state, size);
260   // Cast is safe because freeWhenDone is NO.
261   NSData *result = [[NSData alloc]
262       initWithBytesNoCopy:(void *)(state->bytes + state->bufferPos)
263                    length:size
264              freeWhenDone:NO];
265   state->bufferPos += size;
266   return result;
267 }
268
269 size_t GPBCodedInputStreamPushLimit(GPBCodedInputStreamState *state,
270                                     size_t byteLimit) {
271   byteLimit += state->bufferPos;
272   size_t oldLimit = state->currentLimit;
273   if (byteLimit > oldLimit) {
274     RaiseException(GPBCodedInputStreamErrorInvalidSubsectionLimit, nil);
275   }
276   state->currentLimit = byteLimit;
277   return oldLimit;
278 }
279
280 void GPBCodedInputStreamPopLimit(GPBCodedInputStreamState *state,
281                                  size_t oldLimit) {
282   state->currentLimit = oldLimit;
283 }
284
285 size_t GPBCodedInputStreamBytesUntilLimit(GPBCodedInputStreamState *state) {
286   return state->currentLimit - state->bufferPos;
287 }
288
289 BOOL GPBCodedInputStreamIsAtEnd(GPBCodedInputStreamState *state) {
290   return (state->bufferPos == state->bufferSize) ||
291          (state->bufferPos == state->currentLimit);
292 }
293
294 void GPBCodedInputStreamCheckLastTagWas(GPBCodedInputStreamState *state,
295                                         int32_t value) {
296   if (state->lastTag != value) {
297     RaiseException(GPBCodedInputStreamErrorInvalidTag, @"Unexpected tag read");
298   }
299 }
300
301 @implementation GPBCodedInputStream
302
303 + (instancetype)streamWithData:(NSData *)data {
304   return [[[self alloc] initWithData:data] autorelease];
305 }
306
307 - (instancetype)initWithData:(NSData *)data {
308   if ((self = [super init])) {
309 #ifdef DEBUG
310     NSCAssert([self class] == [GPBCodedInputStream class],
311               @"Subclassing of GPBCodedInputStream is not allowed.");
312 #endif
313     buffer_ = [data retain];
314     state_.bytes = (const uint8_t *)[data bytes];
315     state_.bufferSize = [data length];
316     state_.currentLimit = state_.bufferSize;
317   }
318   return self;
319 }
320
321 - (void)dealloc {
322   [buffer_ release];
323   [super dealloc];
324 }
325
326 // Direct access is use for speed, to avoid even internally declaring things
327 // read/write, etc. The warning is enabled in the project to ensure code calling
328 // protos can turn on -Wdirect-ivar-access without issues.
329 #pragma clang diagnostic push
330 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
331
332 - (int32_t)readTag {
333   return GPBCodedInputStreamReadTag(&state_);
334 }
335
336 - (void)checkLastTagWas:(int32_t)value {
337   GPBCodedInputStreamCheckLastTagWas(&state_, value);
338 }
339
340 - (BOOL)skipField:(int32_t)tag {
341   NSAssert(GPBWireFormatIsValidTag(tag), @"Invalid tag");
342   switch (GPBWireFormatGetTagWireType(tag)) {
343     case GPBWireFormatVarint:
344       GPBCodedInputStreamReadInt32(&state_);
345       return YES;
346     case GPBWireFormatFixed64:
347       SkipRawData(&state_, sizeof(int64_t));
348       return YES;
349     case GPBWireFormatLengthDelimited:
350       SkipRawData(&state_, ReadRawVarint32(&state_));
351       return YES;
352     case GPBWireFormatStartGroup:
353       [self skipMessage];
354       GPBCodedInputStreamCheckLastTagWas(
355           &state_, GPBWireFormatMakeTag(GPBWireFormatGetTagFieldNumber(tag),
356                                         GPBWireFormatEndGroup));
357       return YES;
358     case GPBWireFormatEndGroup:
359       return NO;
360     case GPBWireFormatFixed32:
361       SkipRawData(&state_, sizeof(int32_t));
362       return YES;
363   }
364 }
365
366 - (void)skipMessage {
367   while (YES) {
368     int32_t tag = GPBCodedInputStreamReadTag(&state_);
369     if (tag == 0 || ![self skipField:tag]) {
370       return;
371     }
372   }
373 }
374
375 - (BOOL)isAtEnd {
376   return GPBCodedInputStreamIsAtEnd(&state_);
377 }
378
379 - (size_t)position {
380   return state_.bufferPos;
381 }
382
383 - (size_t)pushLimit:(size_t)byteLimit {
384   return GPBCodedInputStreamPushLimit(&state_, byteLimit);
385 }
386
387 - (void)popLimit:(size_t)oldLimit {
388   GPBCodedInputStreamPopLimit(&state_, oldLimit);
389 }
390
391 - (double)readDouble {
392   return GPBCodedInputStreamReadDouble(&state_);
393 }
394
395 - (float)readFloat {
396   return GPBCodedInputStreamReadFloat(&state_);
397 }
398
399 - (uint64_t)readUInt64 {
400   return GPBCodedInputStreamReadUInt64(&state_);
401 }
402
403 - (int64_t)readInt64 {
404   return GPBCodedInputStreamReadInt64(&state_);
405 }
406
407 - (int32_t)readInt32 {
408   return GPBCodedInputStreamReadInt32(&state_);
409 }
410
411 - (uint64_t)readFixed64 {
412   return GPBCodedInputStreamReadFixed64(&state_);
413 }
414
415 - (uint32_t)readFixed32 {
416   return GPBCodedInputStreamReadFixed32(&state_);
417 }
418
419 - (BOOL)readBool {
420   return GPBCodedInputStreamReadBool(&state_);
421 }
422
423 - (NSString *)readString {
424   return [GPBCodedInputStreamReadRetainedString(&state_) autorelease];
425 }
426
427 - (void)readGroup:(int32_t)fieldNumber
428               message:(GPBMessage *)message
429     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
430   CheckRecursionLimit(&state_);
431   ++state_.recursionDepth;
432   [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
433   GPBCodedInputStreamCheckLastTagWas(
434       &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
435   --state_.recursionDepth;
436 }
437
438 - (void)readUnknownGroup:(int32_t)fieldNumber
439                  message:(GPBUnknownFieldSet *)message {
440   CheckRecursionLimit(&state_);
441   ++state_.recursionDepth;
442   [message mergeFromCodedInputStream:self];
443   GPBCodedInputStreamCheckLastTagWas(
444       &state_, GPBWireFormatMakeTag(fieldNumber, GPBWireFormatEndGroup));
445   --state_.recursionDepth;
446 }
447
448 - (void)readMessage:(GPBMessage *)message
449     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry {
450   CheckRecursionLimit(&state_);
451   int32_t length = ReadRawVarint32(&state_);
452   size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
453   ++state_.recursionDepth;
454   [message mergeFromCodedInputStream:self extensionRegistry:extensionRegistry];
455   GPBCodedInputStreamCheckLastTagWas(&state_, 0);
456   --state_.recursionDepth;
457   GPBCodedInputStreamPopLimit(&state_, oldLimit);
458 }
459
460 - (void)readMapEntry:(id)mapDictionary
461     extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
462                 field:(GPBFieldDescriptor *)field
463         parentMessage:(GPBMessage *)parentMessage {
464   CheckRecursionLimit(&state_);
465   int32_t length = ReadRawVarint32(&state_);
466   size_t oldLimit = GPBCodedInputStreamPushLimit(&state_, length);
467   ++state_.recursionDepth;
468   GPBDictionaryReadEntry(mapDictionary, self, extensionRegistry, field,
469                          parentMessage);
470   GPBCodedInputStreamCheckLastTagWas(&state_, 0);
471   --state_.recursionDepth;
472   GPBCodedInputStreamPopLimit(&state_, oldLimit);
473 }
474
475 - (NSData *)readBytes {
476   return [GPBCodedInputStreamReadRetainedBytes(&state_) autorelease];
477 }
478
479 - (uint32_t)readUInt32 {
480   return GPBCodedInputStreamReadUInt32(&state_);
481 }
482
483 - (int32_t)readEnum {
484   return GPBCodedInputStreamReadEnum(&state_);
485 }
486
487 - (int32_t)readSFixed32 {
488   return GPBCodedInputStreamReadSFixed32(&state_);
489 }
490
491 - (int64_t)readSFixed64 {
492   return GPBCodedInputStreamReadSFixed64(&state_);
493 }
494
495 - (int32_t)readSInt32 {
496   return GPBCodedInputStreamReadSInt32(&state_);
497 }
498
499 - (int64_t)readSInt64 {
500   return GPBCodedInputStreamReadSInt64(&state_);
501 }
502
503 #pragma clang diagnostic pop
504
505 @end