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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
/**
* Copyright (C) 2018-present MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Server Side Public License, version 1,
* as published by MongoDB, Inc.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Server Side Public License for more details.
*
* You should have received a copy of the Server Side Public License
* along with this program. If not, see
* <http://www.mongodb.com/licensing/server-side-public-license>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the Server Side Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#pragma once
#include <string>
#include <vector>
#include "mongo/base/disallow_copying.h"
#include "mongo/base/string_data.h"
#include "mongo/bson/bsonelement.h"
#include "mongo/bson/bsontypes.h"
#include "mongo/db/namespace_string.h"
namespace mongo {
/**
* IDLParserErrorContext manages the current parser context for parsing BSON documents.
*
* The class stores the path to the current document to enable it provide more useful error
* messages. The path is a dot delimited list of field names which is useful for nested struct
* parsing.
*
* This class is responsible for throwing all error messages the IDL generated parsers throw,
* and provide utility methods like checking a BSON type or set of BSON types.
*/
class IDLParserErrorContext {
MONGO_DISALLOW_COPYING(IDLParserErrorContext);
template <typename T>
friend void throwComparisonError(IDLParserErrorContext& ctxt,
StringData fieldName,
StringData op,
T actualValue,
T expectedValue);
public:
/**
* String constants for well-known IDL fields.
*/
static constexpr auto kOpMsgDollarDB = "$db"_sd;
static constexpr auto kOpMsgDollarDBDefault = "admin"_sd;
IDLParserErrorContext(StringData fieldName) : _currentField(fieldName), _predecessor(nullptr) {}
IDLParserErrorContext(StringData fieldName, const IDLParserErrorContext* predecessor)
: _currentField(fieldName), _predecessor(predecessor) {}
/**
* Check that BSON element is a given type or whether the field should be skipped.
*
* Returns true if the BSON element is the correct type.
* Return false if the BSON element is Null or Undefined and the field's value should not be
* processed.
* Throws an exception if the BSON element's type is wrong.
*/
bool checkAndAssertType(const BSONElement& element, BSONType type) const {
if (MONGO_likely(element.type() == type)) {
return true;
}
return checkAndAssertTypeSlowPath(element, type);
}
/**
* Check that BSON element is a bin data type, and has the specified bin data subtype, or
* whether the field should be skipped.
*
* Returns true if the BSON element is the correct type.
* Return false if the BSON element is Null or Undefined and the field's value should not be
* processed.
* Throws an exception if the BSON element's type is wrong.
*/
bool checkAndAssertBinDataType(const BSONElement& element, BinDataType type) const {
if (MONGO_likely(element.type() == BinData && element.binDataType() == type)) {
return true;
}
return checkAndAssertBinDataTypeSlowPath(element, type);
}
/**
* Check that BSON element is one of a given type or whether the field should be skipped.
*
* Returns true if the BSON element is one of the types.
* Return false if the BSON element is Null or Undefined and the field's value should not be
* processed.
* Throws an exception if the BSON element's type is wrong.
*/
bool checkAndAssertTypes(const BSONElement& element, const std::vector<BSONType>& types) const;
/**
* Throw an error message about the BSONElement being a duplicate field.
*/
MONGO_COMPILER_NORETURN void throwDuplicateField(const BSONElement& element) const;
/**
* Throw an error message about the BSONElement being a duplicate field.
*/
MONGO_COMPILER_NORETURN void throwDuplicateField(StringData fieldName) const;
/**
* Throw an error message about the required field missing from the document.
*/
MONGO_COMPILER_NORETURN void throwMissingField(StringData fieldName) const;
/**
* Throw an error message about an unknown field in a document.
*/
MONGO_COMPILER_NORETURN void throwUnknownField(StringData fieldName) const;
/**
* Throw an error message about an array field name not being a valid unsigned integer.
*/
MONGO_COMPILER_NORETURN void throwBadArrayFieldNumberValue(StringData value) const;
/**
* Throw an error message about the array field name not being the next number in the sequence.
*/
MONGO_COMPILER_NORETURN void throwBadArrayFieldNumberSequence(
std::uint32_t actualValue, std::uint32_t expectedValue) const;
/**
* Throw an error message about an unrecognized enum value.
*/
MONGO_COMPILER_NORETURN void throwBadEnumValue(StringData enumValue) const;
MONGO_COMPILER_NORETURN void throwBadEnumValue(int enumValue) const;
/**
* Equivalent to Command::parseNsCollectionRequired
*/
static NamespaceString parseNSCollectionRequired(StringData dbName, const BSONElement& element);
/**
* Take all the well known command generic arguments from commandPassthroughFields, but ignore
* fields that are already part of the command and append the rest to builder.
*/
static void appendGenericCommandArguments(const BSONObj& commandPassthroughFields,
const std::vector<StringData>& knownFields,
BSONObjBuilder* builder);
private:
/**
* See comment on getElementPath below.
*/
std::string getElementPath(const BSONElement& element) const;
/**
* Return a dot seperated path to the specified field. For instance, if the code is parsing a
* grandchild field that has an error, this will return "grandparent.parent.child".
*/
std::string getElementPath(StringData fieldName) const;
/**
* See comment on checkAndAssertType.
*/
bool checkAndAssertTypeSlowPath(const BSONElement& element, BSONType type) const;
/**
* See comment on checkAndAssertBinDataType.
*/
bool checkAndAssertBinDataTypeSlowPath(const BSONElement& element, BinDataType type) const;
private:
// Name of the current field that is being parsed.
const StringData _currentField;
// Pointer to a parent parser context.
// This provides a singly linked list of parent pointers, and use to produce a full path to a
// field with an error.
const IDLParserErrorContext* _predecessor;
};
/**
* Throw an error when BSON validation fails during parse.
*/
template <typename T>
void throwComparisonError(IDLParserErrorContext& ctxt,
StringData fieldName,
StringData op,
T actualValue,
T expectedValue) {
std::string path = ctxt.getElementPath(fieldName);
throwComparisonError(path, op, actualValue, expectedValue);
}
/**
* Throw an error when a user calls a setter and it fails the comparison.
*/
template <typename T>
void throwComparisonError(StringData fieldName, StringData op, T actualValue, T expectedValue) {
uasserted(51024,
str::stream() << "BSON field '" << fieldName << "' value must be " << op << " "
<< expectedValue
<< ", actual value '"
<< actualValue
<< "'");
}
/**
* Transform a vector of input type to a vector of output type.
*
* Used by the IDL generated code to transform between vectors of view, and non-view types.
*/
std::vector<StringData> transformVector(const std::vector<std::string>& input);
std::vector<std::string> transformVector(const std::vector<StringData>& input);
std::vector<ConstDataRange> transformVector(const std::vector<std::vector<std::uint8_t>>& input);
std::vector<std::vector<std::uint8_t>> transformVector(const std::vector<ConstDataRange>& input);
/**
* Get a ConstDataRange from a vector or an array of bytes.
*/
inline ConstDataRange makeCDR(const std::vector<uint8_t>& value) {
return ConstDataRange(reinterpret_cast<const char*>(value.data()), value.size());
}
inline ConstDataRange makeCDR(const std::array<uint8_t, 16>& value) {
return ConstDataRange(reinterpret_cast<const char*>(value.data()), value.size());
}
} // namespace mongo
|
