Commit | Line | Data |
---|---|---|
d0d4e0ed SM |
1 | /* |
2 | * Copyright 2019 EfficiOS Inc. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
5 | * of this software and associated documentation files (the "Software"), to deal | |
6 | * in the Software without restriction, including without limitation the rights | |
7 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
8 | * copies of the Software, and to permit persons to whom the Software is | |
9 | * furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice shall be included in | |
12 | * all copies or substantial portions of the Software. | |
13 | * | |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
17 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
18 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
19 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
20 | * SOFTWARE. | |
21 | */ | |
22 | ||
23 | #include "param-validation.h" | |
24 | ||
25 | #include <babeltrace2/babeltrace.h> | |
26 | #include <glib.h> | |
27 | #include <inttypes.h> | |
28 | ||
29 | #include "common/common.h" | |
30 | ||
31 | struct bt_param_validation_context { | |
32 | gchar *error; | |
33 | GArray *scope_stack; | |
34 | }; | |
35 | ||
36 | struct validate_ctx_stack_element { | |
37 | enum { | |
38 | VALIDATE_CTX_STACK_ELEMENT_MAP, | |
39 | VALIDATE_CTX_STACK_ELEMENT_ARRAY, | |
40 | } type; | |
41 | ||
42 | union { | |
43 | const char *map_key_name; | |
44 | uint64_t array_index; | |
45 | }; | |
46 | }; | |
47 | ||
48 | static | |
49 | void validate_ctx_push_map_scope( | |
50 | struct bt_param_validation_context *ctx, | |
51 | const char *key) | |
52 | { | |
53 | struct validate_ctx_stack_element stack_element = { | |
54 | .type = VALIDATE_CTX_STACK_ELEMENT_MAP, | |
55 | .map_key_name = key, | |
56 | }; | |
57 | ||
58 | g_array_append_val(ctx->scope_stack, stack_element); | |
59 | } | |
60 | ||
61 | static | |
62 | void validate_ctx_push_array_scope( | |
63 | struct bt_param_validation_context *ctx, uint64_t index) | |
64 | { | |
65 | struct validate_ctx_stack_element stack_element = { | |
66 | .type = VALIDATE_CTX_STACK_ELEMENT_ARRAY, | |
67 | .array_index = index, | |
68 | }; | |
69 | ||
70 | g_array_append_val(ctx->scope_stack, stack_element); | |
71 | } | |
72 | ||
73 | static | |
74 | void validate_ctx_pop_scope(struct bt_param_validation_context *ctx) | |
75 | { | |
76 | BT_ASSERT(ctx->scope_stack->len > 0); | |
77 | ||
78 | g_array_remove_index_fast(ctx->scope_stack, ctx->scope_stack->len - 1); | |
79 | } | |
80 | ||
81 | static | |
82 | void append_scope_to_string(GString *str, | |
83 | const struct validate_ctx_stack_element *elem, | |
84 | bool first) | |
85 | { | |
86 | switch (elem->type) { | |
87 | case VALIDATE_CTX_STACK_ELEMENT_MAP: | |
88 | if (!first) { | |
89 | g_string_append_c(str, '.'); | |
90 | } | |
91 | ||
92 | g_string_append(str, elem->map_key_name); | |
93 | break; | |
94 | case VALIDATE_CTX_STACK_ELEMENT_ARRAY: | |
95 | g_string_append_printf(str, "[%" PRIu64 "]", elem->array_index); | |
96 | break; | |
97 | default: | |
98 | abort(); | |
99 | } | |
100 | } | |
101 | ||
102 | enum bt_param_validation_status bt_param_validation_error( | |
103 | struct bt_param_validation_context *ctx, | |
104 | const char *format, ...) { | |
105 | va_list ap; | |
106 | enum bt_param_validation_status status; | |
107 | ||
108 | GString *str = g_string_new(NULL); | |
109 | if (!str) { | |
110 | status = BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR; | |
111 | goto end; | |
112 | } | |
113 | ||
114 | if (ctx->scope_stack->len > 0) { | |
115 | guint i; | |
116 | ||
117 | g_string_assign(str, "Error validating parameter `"); | |
118 | ||
119 | append_scope_to_string(str, &g_array_index(ctx->scope_stack, | |
120 | struct validate_ctx_stack_element, 0), true); | |
121 | ||
122 | for (i = 1; i < ctx->scope_stack->len; i++) { | |
123 | append_scope_to_string(str, | |
124 | &g_array_index(ctx->scope_stack, | |
125 | struct validate_ctx_stack_element, i), false); | |
126 | } | |
127 | ||
128 | g_string_append(str, "`: "); | |
129 | } else { | |
130 | g_string_assign(str, "Error validating parameters: "); | |
131 | } | |
132 | ||
133 | va_start(ap, format); | |
134 | g_string_append_vprintf(str, format, ap); | |
135 | va_end(ap); | |
136 | ||
137 | ctx->error = g_string_free(str, FALSE); | |
138 | status = BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR; | |
139 | ||
140 | end: | |
141 | return status; | |
142 | } | |
143 | ||
144 | struct validate_map_value_data | |
145 | { | |
146 | GPtrArray *available_keys; | |
147 | enum bt_param_validation_status status; | |
148 | struct bt_param_validation_context *ctx; | |
149 | }; | |
150 | ||
151 | static | |
152 | enum bt_param_validation_status validate_value( | |
153 | const bt_value *value, | |
154 | const struct bt_param_validation_value_descr *descr, | |
155 | struct bt_param_validation_context *ctx); | |
156 | ||
157 | static | |
158 | bt_bool validate_map_value_entry(const char *key, | |
159 | const bt_value *value, void *v_data) | |
160 | { | |
161 | struct validate_map_value_data *data = v_data; | |
5a039e2a | 162 | const struct bt_param_validation_map_value_entry_descr *entry = NULL; |
d0d4e0ed SM |
163 | guint i; |
164 | ||
165 | /* Check if this key is in the available keys. */ | |
166 | for (i = 0; i < data->available_keys->len; i++) { | |
5a039e2a SM |
167 | const struct bt_param_validation_map_value_entry_descr *candidate = |
168 | g_ptr_array_index(data->available_keys, i); | |
d0d4e0ed SM |
169 | |
170 | if (g_str_equal(key, candidate->key)) { | |
5a039e2a | 171 | entry = candidate; |
d0d4e0ed SM |
172 | break; |
173 | } | |
174 | } | |
175 | ||
5a039e2a | 176 | if (entry) { |
d0d4e0ed SM |
177 | /* Key was found in available keys. */ |
178 | g_ptr_array_remove_index_fast(data->available_keys, i); | |
179 | ||
180 | /* Push key name as the scope. */ | |
181 | validate_ctx_push_map_scope(data->ctx, key); | |
182 | ||
183 | /* Validate the value of the entry. */ | |
5a039e2a | 184 | data->status = validate_value(value, &entry->value_descr, |
d0d4e0ed SM |
185 | data->ctx); |
186 | ||
187 | validate_ctx_pop_scope(data->ctx); | |
188 | } else { | |
189 | data->status = bt_param_validation_error(data->ctx, | |
190 | "unexpected key `%s`.", key); | |
191 | } | |
192 | ||
193 | /* Continue iterating if everything is good so far. */ | |
194 | return data->status == BT_PARAM_VALIDATION_STATUS_OK; | |
195 | } | |
196 | ||
197 | static | |
198 | enum bt_param_validation_status validate_map_value( | |
199 | const struct bt_param_validation_map_value_descr *descr, | |
200 | const bt_value *map, | |
201 | struct bt_param_validation_context *ctx) { | |
202 | enum bt_param_validation_status status; | |
203 | struct validate_map_value_data data; | |
204 | bt_value_map_foreach_entry_const_status foreach_entry_status; | |
205 | GPtrArray *available_keys = NULL; | |
206 | const struct bt_param_validation_map_value_entry_descr *descr_iter; | |
207 | guint i; | |
208 | ||
209 | BT_ASSERT(bt_value_get_type(map) == BT_VALUE_TYPE_MAP); | |
210 | ||
211 | available_keys = g_ptr_array_new(); | |
212 | if (!available_keys) { | |
213 | status = BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR; | |
214 | goto end; | |
215 | } | |
216 | ||
217 | for (descr_iter = descr->entries; descr_iter->key; descr_iter++) { | |
218 | g_ptr_array_add(available_keys, (gpointer) descr_iter); | |
219 | } | |
220 | ||
221 | /* Initialize `status` to OK, in case the map is empty. */ | |
222 | data.status = BT_PARAM_VALIDATION_STATUS_OK; | |
223 | data.available_keys = available_keys; | |
224 | data.ctx = ctx; | |
225 | ||
226 | foreach_entry_status = bt_value_map_foreach_entry_const(map, | |
227 | validate_map_value_entry, &data); | |
605adc18 SM |
228 | if (foreach_entry_status == BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_INTERRUPTED) { |
229 | BT_ASSERT(data.status != BT_PARAM_VALIDATION_STATUS_OK); | |
d0d4e0ed SM |
230 | status = data.status; |
231 | goto end; | |
232 | } | |
233 | ||
605adc18 SM |
234 | BT_ASSERT(data.status == BT_PARAM_VALIDATION_STATUS_OK); |
235 | ||
d0d4e0ed SM |
236 | for (i = 0; i < data.available_keys->len; i++) { |
237 | const struct bt_param_validation_map_value_entry_descr *entry = | |
238 | g_ptr_array_index(data.available_keys, i); | |
239 | ||
240 | if (!entry->is_optional) { | |
241 | status = bt_param_validation_error(ctx, | |
242 | "missing mandatory entry `%s`", | |
243 | entry->key); | |
244 | goto end; | |
245 | } | |
246 | } | |
247 | ||
248 | status = BT_PARAM_VALIDATION_STATUS_OK; | |
249 | ||
250 | end: | |
251 | g_ptr_array_free(available_keys, TRUE); | |
252 | return status; | |
253 | } | |
254 | ||
255 | static | |
256 | enum bt_param_validation_status validate_array_value( | |
257 | const struct bt_param_validation_array_value_descr *descr, | |
258 | const bt_value *array, | |
259 | struct bt_param_validation_context *ctx) { | |
260 | enum bt_param_validation_status status; | |
261 | uint64_t i; | |
262 | ||
263 | BT_ASSERT(bt_value_get_type(array) == BT_VALUE_TYPE_ARRAY); | |
264 | ||
265 | if (bt_value_array_get_length(array) < descr->min_length) { | |
266 | status = bt_param_validation_error(ctx, | |
267 | "array is smaller than the minimum length: " | |
268 | "array-length=%" PRIu64 ", min-length=%" PRIu64, | |
269 | bt_value_array_get_length(array), | |
270 | descr->min_length); | |
271 | goto end; | |
272 | } | |
273 | ||
274 | if (bt_value_array_get_length(array) > descr->max_length) { | |
275 | status = bt_param_validation_error(ctx, | |
276 | "array is larger than the maximum length: " | |
277 | "array-length=%" PRIu64 ", max-length=%" PRIu64, | |
278 | bt_value_array_get_length(array), | |
279 | descr->max_length); | |
280 | goto end; | |
281 | } | |
282 | ||
283 | for (i = 0; i < bt_value_array_get_length(array); i++) { | |
284 | const bt_value *element = | |
285 | bt_value_array_borrow_element_by_index_const(array, i); | |
286 | ||
287 | validate_ctx_push_array_scope(ctx, i); | |
288 | ||
289 | status = validate_value(element, descr->element_type, ctx); | |
290 | ||
291 | validate_ctx_pop_scope(ctx); | |
292 | ||
293 | if (status != BT_PARAM_VALIDATION_STATUS_OK) { | |
294 | goto end; | |
295 | } | |
296 | } | |
297 | ||
298 | status = BT_PARAM_VALIDATION_STATUS_OK; | |
299 | ||
300 | end: | |
301 | return status; | |
302 | } | |
303 | ||
304 | static | |
305 | enum bt_param_validation_status validate_string_value( | |
306 | const struct bt_param_validation_string_value_descr *descr, | |
307 | const bt_value *string, | |
308 | struct bt_param_validation_context *ctx) { | |
309 | enum bt_param_validation_status status; | |
310 | const char *s = bt_value_string_get(string); | |
311 | gchar *joined_choices = NULL; | |
312 | ||
313 | BT_ASSERT(bt_value_get_type(string) == BT_VALUE_TYPE_STRING); | |
314 | ||
315 | if (descr->choices) { | |
316 | const char **choice; | |
317 | ||
318 | for (choice = descr->choices; *choice; choice++) { | |
319 | if (strcmp(s, *choice) == 0) { | |
320 | break; | |
321 | } | |
322 | } | |
323 | ||
324 | if (!*choice) { | |
325 | /* | |
326 | * g_strjoinv takes a gchar **, but it doesn't modify | |
327 | * the array of the strings (yet). | |
328 | */ | |
329 | joined_choices = g_strjoinv(", ", (gchar **) descr->choices); | |
330 | if (!joined_choices) { | |
331 | status = BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR; | |
332 | goto end; | |
333 | } | |
334 | ||
335 | status = bt_param_validation_error(ctx, | |
336 | "string is not amongst the available choices: " | |
337 | "string=%s, choices=[%s]", s, joined_choices); | |
338 | goto end; | |
339 | } | |
340 | } | |
341 | ||
342 | status = BT_PARAM_VALIDATION_STATUS_OK; | |
343 | end: | |
344 | g_free(joined_choices); | |
345 | ||
346 | return status; | |
347 | } | |
348 | ||
349 | static | |
350 | enum bt_param_validation_status validate_value( | |
351 | const bt_value *value, | |
352 | const struct bt_param_validation_value_descr *descr, | |
353 | struct bt_param_validation_context *ctx) { | |
354 | enum bt_param_validation_status status; | |
355 | ||
356 | /* If there is a custom validation func, we call it and ignore the rest. */ | |
357 | if (descr->validation_func) { | |
358 | status = descr->validation_func(value, ctx); | |
359 | ||
360 | if (status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) { | |
361 | BT_ASSERT(ctx->error); | |
362 | } | |
363 | ||
364 | goto end; | |
365 | } | |
366 | ||
367 | if (bt_value_get_type(value) != descr->type) { | |
368 | bt_param_validation_error(ctx, | |
369 | "unexpected type: expected-type=%s, actual-type=%s", | |
370 | bt_common_value_type_string(descr->type), | |
371 | bt_common_value_type_string(bt_value_get_type(value))); | |
372 | status = BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR; | |
373 | goto end; | |
374 | } | |
375 | ||
376 | switch (bt_value_get_type(value)) { | |
377 | case BT_VALUE_TYPE_MAP: | |
378 | status = validate_map_value(&descr->map, value, ctx); | |
379 | break; | |
380 | case BT_VALUE_TYPE_ARRAY: | |
381 | status = validate_array_value(&descr->array, value, ctx); | |
382 | break; | |
383 | case BT_VALUE_TYPE_STRING: | |
384 | status = validate_string_value(&descr->string, value, ctx); | |
385 | break; | |
386 | default: | |
387 | status = BT_PARAM_VALIDATION_STATUS_OK; | |
388 | break; | |
389 | } | |
390 | ||
391 | end: | |
392 | return status; | |
393 | } | |
394 | ||
395 | enum bt_param_validation_status bt_param_validation_validate( | |
396 | const bt_value *params, | |
397 | const struct bt_param_validation_map_value_entry_descr *entries, | |
398 | gchar **error) { | |
399 | struct bt_param_validation_context ctx; | |
400 | struct bt_param_validation_map_value_descr map_value_descr; | |
401 | enum bt_param_validation_status status; | |
402 | ||
403 | ctx.error = NULL; | |
404 | ctx.scope_stack = g_array_new(FALSE, FALSE, | |
405 | sizeof(struct validate_ctx_stack_element)); | |
406 | g_ptr_array_new_with_free_func(g_free); | |
407 | if (!ctx.scope_stack) { | |
408 | status = BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR; | |
409 | goto end; | |
410 | } | |
411 | ||
412 | map_value_descr.entries = entries; | |
413 | ||
414 | status = validate_map_value(&map_value_descr, params, &ctx); | |
415 | ||
416 | end: | |
417 | *error = ctx.error; | |
418 | ctx.error = NULL; | |
419 | ||
420 | return status; | |
421 | } |