src/google/protobuf/util/json_util.cc

   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 #include <google/protobuf/util/json_util.h>
  32
  33 #include <google/protobuf/stubs/common.h>
  34 #include <google/protobuf/io/coded_stream.h>
  35 #include <google/protobuf/io/zero_copy_stream.h>
  36 #include <google/protobuf/stubs/once.h>
  37 #include <google/protobuf/util/internal/default_value_objectwriter.h>
  38 #include <google/protobuf/util/internal/error_listener.h>
  39 #include <google/protobuf/util/internal/json_objectwriter.h>
  40 #include <google/protobuf/util/internal/json_stream_parser.h>
  41 #include <google/protobuf/util/internal/protostream_objectsource.h>
  42 #include <google/protobuf/util/internal/protostream_objectwriter.h>
  43 #include <google/protobuf/util/type_resolver.h>
  44 #include <google/protobuf/util/type_resolver_util.h>
  45 #include <google/protobuf/stubs/bytestream.h>
  46
  47 #include <google/protobuf/stubs/strutil.h>
  48 #include <google/protobuf/stubs/status_macros.h>
  49
  50 #include <google/protobuf/port_def.inc>
  51
  52 namespace google {
  53 namespace protobuf {
  54 namespace util {
  55
  56 namespace internal {
  57 ZeroCopyStreamByteSink::~ZeroCopyStreamByteSink() {
  58   if (buffer_size_ > 0) {
  59     stream_->BackUp(buffer_size_);
  60   }
  61 }
  62
  63 void ZeroCopyStreamByteSink::Append(const char* bytes, size_t len) {
  64   while (true) {
  65     if (len <= buffer_size_) {
  66       memcpy(buffer_, bytes, len);
  67       buffer_ = static_cast<char*>(buffer_) + len;
  68       buffer_size_ -= len;
  69       return;
  70     }
  71     if (buffer_size_ > 0) {
  72       memcpy(buffer_, bytes, buffer_size_);
  73       bytes += buffer_size_;
  74       len -= buffer_size_;
  75     }
  76     if (!stream_->Next(&buffer_, &buffer_size_)) {
  77       // There isn't a way for ByteSink to report errors.
  78       buffer_size_ = 0;
  79       return;
  80     }
  81   }
  82 }
  83 }  // namespace internal
  84
  85 util::Status BinaryToJsonStream(TypeResolver* resolver,
  86                                   const std::string& type_url,
  87                                   io::ZeroCopyInputStream* binary_input,
  88                                   io::ZeroCopyOutputStream* json_output,
  89                                   const JsonPrintOptions& options) {
  90   io::CodedInputStream in_stream(binary_input);
  91   google::protobuf::Type type;
  92   RETURN_IF_ERROR(resolver->ResolveMessageType(type_url, &type));
  93   converter::ProtoStreamObjectSource proto_source(&in_stream, resolver, type);
  94   proto_source.set_use_ints_for_enums(options.always_print_enums_as_ints);
  95   proto_source.set_preserve_proto_field_names(
  96       options.preserve_proto_field_names);
  97   io::CodedOutputStream out_stream(json_output);
  98   converter::JsonObjectWriter json_writer(options.add_whitespace ? " " : "",
  99                                           &out_stream);
 100   if (options.always_print_primitive_fields) {
 101     converter::DefaultValueObjectWriter default_value_writer(resolver, type,
 102                                                              &json_writer);
 103     default_value_writer.set_preserve_proto_field_names(
 104         options.preserve_proto_field_names);
 105     default_value_writer.set_print_enums_as_ints(
 106         options.always_print_enums_as_ints);
 107     return proto_source.WriteTo(&default_value_writer);
 108   } else {
 109     return proto_source.WriteTo(&json_writer);
 110   }
 111 }
 112
 113 util::Status BinaryToJsonString(TypeResolver* resolver,
 114                                   const std::string& type_url,
 115                                   const std::string& binary_input,
 116                                   std::string* json_output,
 117                                   const JsonPrintOptions& options) {
 118   io::ArrayInputStream input_stream(binary_input.data(), binary_input.size());
 119   io::StringOutputStream output_stream(json_output);
 120   return BinaryToJsonStream(resolver, type_url, &input_stream, &output_stream,
 121                             options);
 122 }
 123
 124 namespace {
 125 class StatusErrorListener : public converter::ErrorListener {
 126  public:
 127   StatusErrorListener() {}
 128   ~StatusErrorListener() override {}
 129
 130   util::Status GetStatus() { return status_; }
 131
 132   void InvalidName(const converter::LocationTrackerInterface& loc,
 133                    StringPiece unknown_name,
 134                    StringPiece message) override {
 135     std::string loc_string = GetLocString(loc);
 136     if (!loc_string.empty()) {
 137       loc_string.append(" ");
 138     }
 139     status_ =
 140         util::Status(util::error::INVALID_ARGUMENT,
 141                        StrCat(loc_string, unknown_name, ": ", message));
 142   }
 143
 144   void InvalidValue(const converter::LocationTrackerInterface& loc,
 145                     StringPiece type_name,
 146                     StringPiece value) override {
 147     status_ = util::Status(
 148         util::error::INVALID_ARGUMENT,
 149         StrCat(GetLocString(loc), ": invalid value ", string(value),
 150                      " for type ", string(type_name)));
 151   }
 152
 153   void MissingField(const converter::LocationTrackerInterface& loc,
 154                     StringPiece missing_name) override {
 155     status_ = util::Status(util::error::INVALID_ARGUMENT,
 156                              StrCat(GetLocString(loc), ": missing field ",
 157                                           std::string(missing_name)));
 158   }
 159
 160  private:
 161   util::Status status_;
 162
 163   std::string GetLocString(const converter::LocationTrackerInterface& loc) {
 164     std::string loc_string = loc.ToString();
 165     StripWhitespace(&loc_string);
 166     if (!loc_string.empty()) {
 167       loc_string = StrCat("(", loc_string, ")");
 168     }
 169     return loc_string;
 170   }
 171
 172   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StatusErrorListener);
 173 };
 174 }  // namespace
 175
 176 util::Status JsonToBinaryStream(TypeResolver* resolver,
 177                                   const std::string& type_url,
 178                                   io::ZeroCopyInputStream* json_input,
 179                                   io::ZeroCopyOutputStream* binary_output,
 180                                   const JsonParseOptions& options) {
 181   google::protobuf::Type type;
 182   RETURN_IF_ERROR(resolver->ResolveMessageType(type_url, &type));
 183   internal::ZeroCopyStreamByteSink sink(binary_output);
 184   StatusErrorListener listener;
 185   converter::ProtoStreamObjectWriter::Options proto_writer_options;
 186   proto_writer_options.ignore_unknown_fields = options.ignore_unknown_fields;
 187   proto_writer_options.ignore_unknown_enum_values =
 188       options.ignore_unknown_fields;
 189   proto_writer_options.case_insensitive_enum_parsing =
 190       options.case_insensitive_enum_parsing;
 191   converter::ProtoStreamObjectWriter proto_writer(
 192       resolver, type, &sink, &listener, proto_writer_options);
 193
 194   converter::JsonStreamParser parser(&proto_writer);
 195   const void* buffer;
 196   int length;
 197   while (json_input->Next(&buffer, &length)) {
 198     if (length == 0) continue;
 199     RETURN_IF_ERROR(parser.Parse(
 200         StringPiece(static_cast<const char*>(buffer), length)));
 201   }
 202   RETURN_IF_ERROR(parser.FinishParse());
 203
 204   return listener.GetStatus();
 205 }
 206
 207 util::Status JsonToBinaryString(TypeResolver* resolver,
 208                                   const std::string& type_url,
 209                                   StringPiece json_input,
 210                                   std::string* binary_output,
 211                                   const JsonParseOptions& options) {
 212   io::ArrayInputStream input_stream(json_input.data(), json_input.size());
 213   io::StringOutputStream output_stream(binary_output);
 214   return JsonToBinaryStream(resolver, type_url, &input_stream, &output_stream,
 215                             options);
 216 }
 217
 218 namespace {
 219 const char* kTypeUrlPrefix = "type.googleapis.com";
 220 TypeResolver* generated_type_resolver_ = NULL;
 221 PROTOBUF_NAMESPACE_ID::internal::once_flag generated_type_resolver_init_;
 222
 223 std::string GetTypeUrl(const Message& message) {
 224   return std::string(kTypeUrlPrefix) + "/" +
 225          message.GetDescriptor()->full_name();
 226 }
 227
 228 void DeleteGeneratedTypeResolver() { delete generated_type_resolver_; }
 229
 230 void InitGeneratedTypeResolver() {
 231   generated_type_resolver_ = NewTypeResolverForDescriptorPool(
 232       kTypeUrlPrefix, DescriptorPool::generated_pool());
 233   ::google::protobuf::internal::OnShutdown(&DeleteGeneratedTypeResolver);
 234 }
 235
 236 TypeResolver* GetGeneratedTypeResolver() {
 237   PROTOBUF_NAMESPACE_ID::internal::call_once(generated_type_resolver_init_,
 238                                              InitGeneratedTypeResolver);
 239   return generated_type_resolver_;
 240 }
 241 }  // namespace
 242
 243 util::Status MessageToJsonString(const Message& message, std::string* output,
 244                                    const JsonOptions& options) {
 245   const DescriptorPool* pool = message.GetDescriptor()->file()->pool();
 246   TypeResolver* resolver =
 247       pool == DescriptorPool::generated_pool()
 248           ? GetGeneratedTypeResolver()
 249           : NewTypeResolverForDescriptorPool(kTypeUrlPrefix, pool);
 250   util::Status result =
 251       BinaryToJsonString(resolver, GetTypeUrl(message),
 252                          message.SerializeAsString(), output, options);
 253   if (pool != DescriptorPool::generated_pool()) {
 254     delete resolver;
 255   }
 256   return result;
 257 }
 258
 259 util::Status JsonStringToMessage(StringPiece input, Message* message,
 260                                    const JsonParseOptions& options) {
 261   const DescriptorPool* pool = message->GetDescriptor()->file()->pool();
 262   TypeResolver* resolver =
 263       pool == DescriptorPool::generated_pool()
 264           ? GetGeneratedTypeResolver()
 265           : NewTypeResolverForDescriptorPool(kTypeUrlPrefix, pool);
 266   std::string binary;
 267   util::Status result = JsonToBinaryString(resolver, GetTypeUrl(*message),
 268                                              input, &binary, options);
 269   if (result.ok() && !message->ParseFromString(binary)) {
 270     result =
 271         util::Status(util::error::INVALID_ARGUMENT,
 272                        "JSON transcoder produced invalid protobuf output.");
 273   }
 274   if (pool != DescriptorPool::generated_pool()) {
 275     delete resolver;
 276   }
 277   return result;
 278 }
 279
 280 }  // namespace util
 281 }  // namespace protobuf
 282 }  // namespace google