Home | History | Annotate | Download | only in protobuf
      1 // Protocol Buffers - Google's data interchange format
      2 // Copyright 2008 Google Inc.  All rights reserved.
      3 // http://code.google.com/p/protobuf/
      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 // Authors: wink (at) google.com (Wink Saville),
     32 //          kenton (at) google.com (Kenton Varda)
     33 //  Based on original Protocol Buffers design by
     34 //  Sanjay Ghemawat, Jeff Dean, and others.
     35 
     36 #include <google/protobuf/message_lite.h>
     37 #include <string>
     38 #include <google/protobuf/stubs/common.h>
     39 #include <google/protobuf/io/coded_stream.h>
     40 #include <google/protobuf/io/zero_copy_stream_impl.h>
     41 #include <google/protobuf/stubs/stl_util-inl.h>
     42 
     43 namespace google {
     44 namespace protobuf {
     45 
     46 MessageLite::~MessageLite() {}
     47 
     48 string MessageLite::InitializationErrorString() const {
     49   return "(cannot determine missing fields for lite message)";
     50 }
     51 
     52 namespace {
     53 
     54 // When serializing, we first compute the byte size, then serialize the message.
     55 // If serialization produces a different number of bytes than expected, we
     56 // call this function, which crashes.  The problem could be due to a bug in the
     57 // protobuf implementation but is more likely caused by concurrent modification
     58 // of the message.  This function attempts to distinguish between the two and
     59 // provide a useful error message.
     60 void ByteSizeConsistencyError(int byte_size_before_serialization,
     61                               int byte_size_after_serialization,
     62                               int bytes_produced_by_serialization) {
     63   GOOGLE_CHECK_EQ(byte_size_before_serialization, byte_size_after_serialization)
     64       << "Protocol message was modified concurrently during serialization.";
     65   GOOGLE_CHECK_EQ(bytes_produced_by_serialization, byte_size_before_serialization)
     66       << "Byte size calculation and serialization were inconsistent.  This "
     67          "may indicate a bug in protocol buffers or it may be caused by "
     68          "concurrent modification of the message.";
     69   GOOGLE_LOG(FATAL) << "This shouldn't be called if all the sizes are equal.";
     70 }
     71 
     72 string InitializationErrorMessage(const char* action,
     73                                   const MessageLite& message) {
     74   // Note:  We want to avoid depending on strutil in the lite library, otherwise
     75   //   we'd use:
     76   //
     77   // return strings::Substitute(
     78   //   "Can't $0 message of type \"$1\" because it is missing required "
     79   //   "fields: $2",
     80   //   action, message.GetTypeName(),
     81   //   message.InitializationErrorString());
     82 
     83   string result;
     84   result += "Can't ";
     85   result += action;
     86   result += " message of type \"";
     87   result += message.GetTypeName();
     88   result += "\" because it is missing required fields: ";
     89   result += message.InitializationErrorString();
     90   return result;
     91 }
     92 
     93 // Several of the Parse methods below just do one thing and then call another
     94 // method.  In a naive implementation, we might have ParseFromString() call
     95 // ParseFromArray() which would call ParseFromZeroCopyStream() which would call
     96 // ParseFromCodedStream() which would call MergeFromCodedStream() which would
     97 // call MergePartialFromCodedStream().  However, when parsing very small
     98 // messages, every function call introduces significant overhead.  To avoid
     99 // this without reproducing code, we use these forced-inline helpers.
    100 //
    101 // Note:  GCC only allows GOOGLE_ATTRIBUTE_ALWAYS_INLINE on declarations, not
    102 //   definitions.
    103 inline bool InlineMergeFromCodedStream(io::CodedInputStream* input,
    104                                        MessageLite* message)
    105                                        GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
    106 inline bool InlineParseFromCodedStream(io::CodedInputStream* input,
    107                                        MessageLite* message)
    108                                        GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
    109 inline bool InlineParsePartialFromCodedStream(io::CodedInputStream* input,
    110                                               MessageLite* message)
    111                                               GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
    112 inline bool InlineParseFromArray(const void* data, int size,
    113                                  MessageLite* message)
    114                                  GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
    115 inline bool InlineParsePartialFromArray(const void* data, int size,
    116                                         MessageLite* message)
    117                                         GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
    118 
    119 bool InlineMergeFromCodedStream(io::CodedInputStream* input,
    120                                 MessageLite* message) {
    121   if (!message->MergePartialFromCodedStream(input)) return false;
    122   if (!message->IsInitialized()) {
    123     GOOGLE_LOG(ERROR) << InitializationErrorMessage("parse", *message);
    124     return false;
    125   }
    126   return true;
    127 }
    128 
    129 bool InlineParseFromCodedStream(io::CodedInputStream* input,
    130                                 MessageLite* message) {
    131   message->Clear();
    132   return InlineMergeFromCodedStream(input, message);
    133 }
    134 
    135 bool InlineParsePartialFromCodedStream(io::CodedInputStream* input,
    136                                        MessageLite* message) {
    137   message->Clear();
    138   return message->MergePartialFromCodedStream(input);
    139 }
    140 
    141 bool InlineParseFromArray(const void* data, int size, MessageLite* message) {
    142   io::CodedInputStream input(reinterpret_cast<const uint8*>(data), size);
    143   return InlineParseFromCodedStream(&input, message) &&
    144          input.ConsumedEntireMessage();
    145 }
    146 
    147 bool InlineParsePartialFromArray(const void* data, int size,
    148                                  MessageLite* message) {
    149   io::CodedInputStream input(reinterpret_cast<const uint8*>(data), size);
    150   return InlineParsePartialFromCodedStream(&input, message) &&
    151          input.ConsumedEntireMessage();
    152 }
    153 
    154 }  // namespace
    155 
    156 bool MessageLite::MergeFromCodedStream(io::CodedInputStream* input) {
    157   return InlineMergeFromCodedStream(input, this);
    158 }
    159 
    160 bool MessageLite::ParseFromCodedStream(io::CodedInputStream* input) {
    161   return InlineParseFromCodedStream(input, this);
    162 }
    163 
    164 bool MessageLite::ParsePartialFromCodedStream(io::CodedInputStream* input) {
    165   return InlineParsePartialFromCodedStream(input, this);
    166 }
    167 
    168 bool MessageLite::ParseFromZeroCopyStream(io::ZeroCopyInputStream* input) {
    169   io::CodedInputStream decoder(input);
    170   return ParseFromCodedStream(&decoder) && decoder.ConsumedEntireMessage();
    171 }
    172 
    173 bool MessageLite::ParsePartialFromZeroCopyStream(
    174     io::ZeroCopyInputStream* input) {
    175   io::CodedInputStream decoder(input);
    176   return ParsePartialFromCodedStream(&decoder) &&
    177          decoder.ConsumedEntireMessage();
    178 }
    179 
    180 bool MessageLite::ParseFromBoundedZeroCopyStream(
    181     io::ZeroCopyInputStream* input, int size) {
    182   io::CodedInputStream decoder(input);
    183   decoder.PushLimit(size);
    184   return ParseFromCodedStream(&decoder) &&
    185          decoder.ConsumedEntireMessage() &&
    186          decoder.BytesUntilLimit() == 0;
    187 }
    188 
    189 bool MessageLite::ParsePartialFromBoundedZeroCopyStream(
    190     io::ZeroCopyInputStream* input, int size) {
    191   io::CodedInputStream decoder(input);
    192   decoder.PushLimit(size);
    193   return ParsePartialFromCodedStream(&decoder) &&
    194          decoder.ConsumedEntireMessage() &&
    195          decoder.BytesUntilLimit() == 0;
    196 }
    197 
    198 bool MessageLite::ParseFromString(const string& data) {
    199   return InlineParseFromArray(data.data(), data.size(), this);
    200 }
    201 
    202 bool MessageLite::ParsePartialFromString(const string& data) {
    203   return InlineParsePartialFromArray(data.data(), data.size(), this);
    204 }
    205 
    206 bool MessageLite::ParseFromArray(const void* data, int size) {
    207   return InlineParseFromArray(data, size, this);
    208 }
    209 
    210 bool MessageLite::ParsePartialFromArray(const void* data, int size) {
    211   return InlineParsePartialFromArray(data, size, this);
    212 }
    213 
    214 
    215 // ===================================================================
    216 
    217 uint8* MessageLite::SerializeWithCachedSizesToArray(uint8* target) const {
    218   // We only optimize this when using optimize_for = SPEED.  In other cases
    219   // we just use the CodedOutputStream path.
    220   int size = GetCachedSize();
    221   io::ArrayOutputStream out(target, size);
    222   io::CodedOutputStream coded_out(&out);
    223   SerializeWithCachedSizes(&coded_out);
    224   GOOGLE_CHECK(!coded_out.HadError());
    225   return target + size;
    226 }
    227 
    228 bool MessageLite::SerializeToCodedStream(io::CodedOutputStream* output) const {
    229   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
    230   return SerializePartialToCodedStream(output);
    231 }
    232 
    233 bool MessageLite::SerializePartialToCodedStream(
    234     io::CodedOutputStream* output) const {
    235   const int size = ByteSize();  // Force size to be cached.
    236   uint8* buffer = output->GetDirectBufferForNBytesAndAdvance(size);
    237   if (buffer != NULL) {
    238     uint8* end = SerializeWithCachedSizesToArray(buffer);
    239     if (end - buffer != size) {
    240       ByteSizeConsistencyError(size, ByteSize(), end - buffer);
    241     }
    242     return true;
    243   } else {
    244     int original_byte_count = output->ByteCount();
    245     SerializeWithCachedSizes(output);
    246     if (output->HadError()) {
    247       return false;
    248     }
    249     int final_byte_count = output->ByteCount();
    250 
    251     if (final_byte_count - original_byte_count != size) {
    252       ByteSizeConsistencyError(size, ByteSize(),
    253                                final_byte_count - original_byte_count);
    254     }
    255 
    256     return true;
    257   }
    258 }
    259 
    260 bool MessageLite::SerializeToZeroCopyStream(
    261     io::ZeroCopyOutputStream* output) const {
    262   io::CodedOutputStream encoder(output);
    263   return SerializeToCodedStream(&encoder);
    264 }
    265 
    266 bool MessageLite::SerializePartialToZeroCopyStream(
    267     io::ZeroCopyOutputStream* output) const {
    268   io::CodedOutputStream encoder(output);
    269   return SerializePartialToCodedStream(&encoder);
    270 }
    271 
    272 bool MessageLite::AppendToString(string* output) const {
    273   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
    274   return AppendPartialToString(output);
    275 }
    276 
    277 bool MessageLite::AppendPartialToString(string* output) const {
    278   int old_size = output->size();
    279   int byte_size = ByteSize();
    280   STLStringResizeUninitialized(output, old_size + byte_size);
    281   uint8* start = reinterpret_cast<uint8*>(string_as_array(output) + old_size);
    282   uint8* end = SerializeWithCachedSizesToArray(start);
    283   if (end - start != byte_size) {
    284     ByteSizeConsistencyError(byte_size, ByteSize(), end - start);
    285   }
    286   return true;
    287 }
    288 
    289 bool MessageLite::SerializeToString(string* output) const {
    290   output->clear();
    291   return AppendToString(output);
    292 }
    293 
    294 bool MessageLite::SerializePartialToString(string* output) const {
    295   output->clear();
    296   return AppendPartialToString(output);
    297 }
    298 
    299 bool MessageLite::SerializeToArray(void* data, int size) const {
    300   GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
    301   return SerializePartialToArray(data, size);
    302 }
    303 
    304 bool MessageLite::SerializePartialToArray(void* data, int size) const {
    305   int byte_size = ByteSize();
    306   if (size < byte_size) return false;
    307   uint8* start = reinterpret_cast<uint8*>(data);
    308   uint8* end = SerializeWithCachedSizesToArray(start);
    309   if (end - start != byte_size) {
    310     ByteSizeConsistencyError(byte_size, ByteSize(), end - start);
    311   }
    312   return true;
    313 }
    314 
    315 string MessageLite::SerializeAsString() const {
    316   // If the compiler implements the (Named) Return Value Optimization,
    317   // the local variable 'result' will not actually reside on the stack
    318   // of this function, but will be overlaid with the object that the
    319   // caller supplied for the return value to be constructed in.
    320   string output;
    321   if (!AppendToString(&output))
    322     output.clear();
    323   return output;
    324 }
    325 
    326 string MessageLite::SerializePartialAsString() const {
    327   string output;
    328   if (!AppendPartialToString(&output))
    329     output.clear();
    330   return output;
    331 }
    332 
    333 }  // namespace protobuf
    334 }  // namespace google
    335