1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <sstream>
#include <string>
#include <vector>
#include <google/protobuf/message.h>
#include <json/reader.h>
#include <json/value.h>
#include <jsonpb/jsonpb.h>
namespace android {
namespace jsonpb {
// Ensure that the JSON file has no unknown fields that is not defined in proto.
// Because we want forwards compatibility, the parser of JSON files must ignore
// unknown fields. This is achievable with libprotobuf version > 3.0-beta.
// - <= 3.0-beta: we have to check unknown fields manually, and parser cannot
// use libprotobuf
// to parse JSON files.
// - < 3.5: libprotobuf discards all unknown fields. We can still check unknown
// fields manually, but
// an easier way to check is `json == FormatJson(json)` (schematically)
// - >= 3.5: Unknown fields are preserved, so FormatJson() may contain these
// unknown fields. We can
// still check fields manually, or use reflection mechanism.
//
// For example, if a new field "foo" is added to cgroups.json but not to
// cgroups.proto, libprocessgroup could technically read the value of "foo" by
// using other libraries that parse JSON strings, effectively working around the
// schema.
//
// This test also ensures that the parser does not use alternative key names.
// For example, if the proto file states: message Foo { string foo_bar = 1;
// string bar_baz = 2 [json_name = "BarBaz"]; } Then the parser accepts
// "foo_bar" "fooBar", "bar_baz", "BarBaz" as valid key names. Here, we enforce
// that the JSON file must use "foo_bar" and "BarBaz".
//
// Requiring this avoids surprises like:
// message Foo { string FooBar = 1; }
// { "fooBar" : "s" }
// conforms with the schema, because libprotobuf accept "fooBar" as a valid key.
// The correct schema should be:
// message Foo { string foo_bar = 1 [json_name="fooBar"]; }
//
// Params:
// path: path to navigate inside JSON tree. For example, {"foo", "bar"} for
// the value "string" in
// {"foo": {"bar" : "string"}}
bool AllFieldsAreKnown(const google::protobuf::Message& message, const std::string& json,
std::string* error);
// Format the given JSON string according to Prototype T. This will serialize
// the JSON string to a Prototype message, then re-print the message as JSON. By
// reformatting the JSON string, we effectively enforces that the JSON source
// file uses conventions of Protobuf's JSON writer; e.g. 64-bit integers /
// special floating point numbers (inf, NaN, etc.) in strings, enum values in
// names, etc.
//
// Params:
// scratch_space: The scratch space to use to store the Protobuf message. It
// must be a pointer
// to the schema that the JSON string conforms to.
bool EqReformattedJson(const std::string& json, google::protobuf::Message* scratch_space,
std::string* error);
namespace internal {
// See EqReformattedJson().
ErrorOr<std::string> FormatJson(const std::string& json, google::protobuf::Message* scratch_space);
} // namespace internal
} // namespace jsonpb
} // namespace android
|
