1 /** 2 * A very basic, non-complete implementation of a validator for the JSON Schema specification, 3 * for validating CPER-JSON. 4 * 5 * Author: Lawrence.Tang@arm.com 6 **/ 7 8 #include <stdio.h> 9 #include <string.h> 10 #include <unistd.h> 11 #include <libgen.h> 12 #include <limits.h> 13 #include <stdarg.h> 14 #include <json.h> 15 #include <libcper/json-schema.h> 16 #include <libcper/BaseTypes.h> 17 18 //Field definitions. 19 int json_validator_debug = 0; 20 21 //Private pre-definitions. 22 int validate_field(const char *name, json_object *schema, json_object *object, 23 char *error_message); 24 int validate_integer(const char *field_name, json_object *schema, 25 json_object *object, char *error_message); 26 int validate_string(const char *field_name, json_object *schema, 27 json_object *object, const char *error_message); 28 int validate_object(const char *field_name, json_object *schema, 29 json_object *object, char *error_message); 30 int validate_array(const char *field_name, json_object *schema, 31 json_object *object, char *error_message); 32 void log_validator_error(char *error_message, const char *format, ...); 33 void log_validator_debug(const char *format, ...); 34 void log_validator_msg(const char *format, va_list args); 35 36 //Validates a single JSON object against a provided schema file, returning 1 on success and 0 on failure to validate. 37 //Error message space must be allocated prior to call. validate_schema_from_file(const char * schema_file,json_object * object,char * error_message)38 int validate_schema_from_file(const char *schema_file, json_object *object, 39 char *error_message) 40 { 41 //Load schema IR from file. 42 json_object *schema_ir = json_object_from_file(schema_file); 43 if (schema_ir == NULL) { 44 log_validator_error(error_message, 45 "Failed to load schema from file '%s'.", 46 schema_file); 47 return 0; 48 } 49 50 //Get the directory of the file. 51 char *schema_file_copy = malloc(strlen(schema_file) + 1); 52 strcpy(schema_file_copy, schema_file); 53 char *schema_dir = dirname(schema_file_copy); 54 55 int result = 56 validate_schema(schema_ir, schema_dir, object, error_message); 57 58 //Free memory from directory call. 59 free(schema_file_copy); 60 json_object_put(schema_ir); 61 62 return result; 63 } 64 65 //Validates a single JSON object against a provided schema, returning 1 on success and 0 on failure to validate. 66 //Error message space must be allocated prior to call. 67 //If the schema does not include any other sub-schemas using "$ref", then leaving schema_directory as NULL is valid. validate_schema(json_object * schema,char * schema_directory,json_object * object,char * error_message)68 int validate_schema(json_object *schema, char *schema_directory, 69 json_object *object, char *error_message) 70 { 71 //Check that the schema version is the same as this validator. 72 json_object *schema_ver = json_object_object_get(schema, "$schema"); 73 if (schema_ver == NULL || strcmp(json_object_get_string(schema_ver), 74 JSON_SCHEMA_VERSION) != 0) { 75 log_validator_error( 76 error_message, 77 "Provided schema is not of the same version that is referenced by this validator, or is not a schema."); 78 return 0; 79 } 80 81 //Change current directory into the schema directory. 82 char *original_cwd = malloc(PATH_MAX); 83 if (getcwd(original_cwd, PATH_MAX) == NULL) { 84 log_validator_error(error_message, 85 "Failed fetching the current directory."); 86 if (original_cwd) { 87 free(original_cwd); 88 } 89 return 0; 90 } 91 if (chdir(schema_directory)) { 92 log_validator_error(error_message, 93 "Failed to chdir into schema directory."); 94 if (original_cwd) { 95 free(original_cwd); 96 } 97 return 0; 98 } 99 100 //Parse the top level structure appropriately. 101 int result = validate_field("parent", schema, object, error_message); 102 if (result < 0) { 103 log_validator_error(error_message, 104 "Failed validating schema for parent."); 105 result = 0; 106 } 107 108 //Change back to original CWD. 109 if (chdir(original_cwd)) { 110 log_validator_error(error_message, 111 "Failed to chdir into original directory."); 112 } 113 114 free(original_cwd); 115 116 if (result) { 117 log_validator_debug( 118 "Successfully validated the provided object against schema."); 119 } 120 return result; 121 } 122 123 //Validates a single JSON field given a schema/object. 124 //Returns -1 on fatal/error failure, 0 on validation failure, and 1 on validation. validate_field(const char * field_name,json_object * schema,json_object * object,char * error_message)125 int validate_field(const char *field_name, json_object *schema, 126 json_object *object, char *error_message) 127 { 128 int ret = -1; 129 130 log_validator_debug("Validating field '%s'...", field_name); 131 132 //If there is a "$ref" field, attempt to load the referenced schema. 133 json_object *ref_field = json_object_object_get(schema, "$ref"); 134 if (ref_field != NULL && 135 json_object_get_type(ref_field) == json_type_string) { 136 log_validator_debug("$ref schema detected for field '%s'.", 137 field_name); 138 139 //Attempt to load. If loading fails, report error. 140 const char *ref_path = json_object_get_string(ref_field); 141 json_object *ref_schema = json_object_from_file(ref_path); 142 if (ref_schema == NULL) { 143 log_validator_error( 144 error_message, 145 "Failed to open referenced schema file '%s'.", 146 ref_path); 147 return -1; 148 } 149 150 log_validator_debug("loaded schema path '%s' for field '%s'.", 151 ref_path, field_name); 152 153 //Validate field with schema. 154 ret = validate_field(field_name, ref_schema, object, 155 error_message); 156 json_object_put(ref_schema); 157 158 return ret; 159 } 160 161 //Get the schema field type. 162 json_object *desired_field_type = 163 json_object_object_get(schema, "type"); 164 if (desired_field_type == NULL || 165 !json_object_is_type(desired_field_type, json_type_string)) { 166 log_validator_error( 167 error_message, 168 "Desired field type not provided within schema/is not a string for field '%s' (schema violation).", 169 field_name); 170 return 0; 171 } 172 173 //Check the field types are actually equal. 174 const char *desired_field_type_str = 175 json_object_get_string(desired_field_type); 176 if (!((!strcmp(desired_field_type_str, "object") && 177 json_object_is_type(object, json_type_object)) || 178 (!strcmp(desired_field_type_str, "array") && 179 json_object_is_type(object, json_type_array)) || 180 (!strcmp(desired_field_type_str, "integer") && 181 json_object_is_type(object, json_type_int)) || 182 (!strcmp(desired_field_type_str, "string") && 183 json_object_is_type(object, json_type_string)) || 184 (!strcmp(desired_field_type_str, "boolean") && 185 json_object_is_type(object, json_type_boolean)) || 186 (!strcmp(desired_field_type_str, "double") && 187 json_object_is_type(object, json_type_double)))) { 188 log_validator_error(error_message, 189 "Field type match failed for field '%s'.", 190 field_name); 191 return 0; 192 } 193 194 //If the schema contains a "oneOf" array, we need to validate the field against each of the 195 //possible options in turn. 196 json_object *one_of = json_object_object_get(schema, "oneOf"); 197 if (one_of != NULL && json_object_get_type(one_of) == json_type_array) { 198 log_validator_debug("oneOf options detected for field '%s'.", 199 field_name); 200 201 int len = json_object_array_length(one_of); 202 int validated = 0; 203 for (int i = 0; i < len; i++) { 204 //If the "oneOf" member isn't an object, warn on schema violation. 205 json_object *one_of_option = 206 json_object_array_get_idx(one_of, i); 207 if (one_of_option == NULL || 208 json_object_get_type(one_of_option) != 209 json_type_object) { 210 log_validator_debug( 211 "Schema Warning: 'oneOf' member for field '%s' is not an object, schema violation.", 212 field_name); 213 continue; 214 } 215 216 //Validate field with schema. 217 validated = validate_field(field_name, one_of_option, 218 object, error_message); 219 if (validated == -1) { 220 return -1; 221 } 222 if (validated) { 223 break; 224 } 225 } 226 227 //Return if failed all checks. 228 if (!validated) { 229 log_validator_error( 230 error_message, 231 "No schema object structures matched provided object for field '%s'.", 232 field_name); 233 return 0; 234 } 235 } 236 237 //Switch and validate each type in turn. 238 switch (json_object_get_type(object)) { 239 case json_type_int: 240 return validate_integer(field_name, schema, object, 241 error_message); 242 case json_type_string: 243 return validate_string(field_name, schema, object, 244 error_message); 245 case json_type_object: 246 return validate_object(field_name, schema, object, 247 error_message); 248 case json_type_array: 249 return validate_array(field_name, schema, object, 250 error_message); 251 252 //We don't perform extra validation on this type. 253 default: 254 log_validator_debug( 255 "validation passed for '%s' (no extra validation).", 256 field_name); 257 return 1; 258 } 259 } 260 261 //Validates a single integer value according to the given specification. validate_integer(const char * field_name,json_object * schema,json_object * object,char * error_message)262 int validate_integer(const char *field_name, json_object *schema, 263 json_object *object, char *error_message) 264 { 265 //Is there a minimum/maximum specified? If so, check those. 266 //Validate minimum. 267 json_object *min_value = json_object_object_get(schema, "minimum"); 268 if (min_value != NULL && 269 json_object_is_type(min_value, json_type_int)) { 270 int min_value_int = json_object_get_int(min_value); 271 if (json_object_get_uint64(object) < (uint64_t)min_value_int) { 272 log_validator_error( 273 error_message, 274 "Failed to validate integer field '%s'. Value was below minimum of %d.", 275 field_name, min_value_int); 276 return 0; 277 } 278 } 279 280 //Validate maximum. 281 json_object *max_value = json_object_object_get(schema, "maximum"); 282 if (max_value != NULL && 283 json_object_is_type(max_value, json_type_int)) { 284 int max_value_int = json_object_get_int(max_value); 285 if (json_object_get_uint64(object) > (uint64_t)max_value_int) { 286 log_validator_error( 287 error_message, 288 "Failed to validate integer field '%s'. Value was above maximum of %d.", 289 field_name, max_value_int); 290 return 0; 291 } 292 } 293 294 return 1; 295 } 296 297 //Validates a single string value according to the given specification. validate_string(const char * field_name,json_object * schema,json_object * object,const char * error_message)298 int validate_string(const char *field_name, json_object *schema, 299 json_object *object, const char *error_message) 300 { 301 //todo: if there is a "pattern" field, verify the string with RegEx. 302 (void)field_name; 303 (void)schema; 304 (void)object; 305 (void)error_message; 306 307 return 1; 308 } 309 310 //Validates a single object value according to the given specification. validate_object(const char * field_name,json_object * schema,json_object * object,char * error_message)311 int validate_object(const char *field_name, json_object *schema, 312 json_object *object, char *error_message) 313 { 314 //Are there a set of "required" fields? If so, check they all exist. 315 json_object *required_fields = 316 json_object_object_get(schema, "required"); 317 if (required_fields != NULL && 318 json_object_get_type(required_fields) == json_type_array) { 319 log_validator_debug( 320 "Required fields found for '%s', matching...", 321 field_name); 322 323 int len = json_object_array_length(required_fields); 324 for (int i = 0; i < len; i++) { 325 //Get the required field from schema. 326 json_object *required_field = 327 json_object_array_get_idx(required_fields, i); 328 if (json_object_get_type(required_field) != 329 json_type_string) { 330 log_validator_error( 331 error_message, 332 "Required field for object '%s' is not a string (schema violation).", 333 field_name); 334 return 0; 335 } 336 337 //Does it exist in the object? 338 const char *required_field_str = 339 json_object_get_string(required_field); 340 if (json_object_object_get( 341 object, required_field_str) == NULL) { 342 log_validator_error( 343 error_message, 344 "Required field '%s' was not present in object '%s'.", 345 required_field_str, field_name); 346 return 0; 347 } 348 } 349 } 350 351 //Get additional properties value in advance. 352 json_object *additional_properties = 353 json_object_object_get(schema, "additionalProperties"); 354 int additional_properties_allowed = 0; 355 if (additional_properties != NULL && 356 json_object_get_type(additional_properties) == json_type_boolean) { 357 additional_properties_allowed = 358 json_object_get_boolean(additional_properties); 359 } 360 361 //Run through the "properties" object and validate each of those in turn. 362 json_object *properties = json_object_object_get(schema, "properties"); 363 if (properties != NULL && 364 json_object_get_type(properties) == json_type_object) { 365 json_object_object_foreach(properties, key, value) 366 { 367 //If the given property name does not exist on the target object, ignore and continue next. 368 json_object *object_prop = 369 json_object_object_get(object, key); 370 if (object_prop == NULL) { 371 continue; 372 } 373 374 //Validate against the schema. 375 if (!validate_field(key, value, object_prop, 376 error_message)) { 377 return 0; 378 } 379 } 380 381 //If additional properties are banned, validate that no additional properties exist. 382 if (!additional_properties_allowed) { 383 json_object_object_foreach(object, key, value) 384 { 385 //Avoid compiler warning 386 (void)value; 387 388 //If the given property name does not exist on the schema object, fail validation. 389 const json_object *schema_prop = 390 json_object_object_get(properties, key); 391 if (schema_prop == NULL) { 392 log_validator_error( 393 error_message, 394 "Invalid additional property '%s' detected on field '%s'.", 395 key, field_name); 396 return 0; 397 } 398 } 399 } 400 } 401 402 return 1; 403 } 404 405 //Validates a single array value according to the given specification. validate_array(const char * field_name,json_object * schema,json_object * object,char * error_message)406 int validate_array(const char *field_name, json_object *schema, 407 json_object *object, char *error_message) 408 { 409 //Iterate all items in the array, and validate according to the "items" schema. 410 json_object *items_schema = json_object_object_get(schema, "items"); 411 if (items_schema != NULL && 412 json_object_get_type(items_schema) == json_type_object) { 413 int array_len = json_object_array_length(object); 414 for (int i = 0; i < array_len; i++) { 415 if (!validate_field(field_name, items_schema, 416 json_object_array_get_idx(object, 417 i), 418 error_message)) { 419 return 0; 420 } 421 } 422 } 423 424 return 1; 425 } 426 427 //Enables/disables debugging globally for the JSON validator. validate_schema_debug_enable()428 void validate_schema_debug_enable() 429 { 430 json_validator_debug = 1; 431 } validate_schema_debug_disable()432 void validate_schema_debug_disable() 433 { 434 json_validator_debug = 0; 435 } 436 437 //Logs an error message to the given error message location and (optionally) provides debug output. log_validator_error(char * error_message,const char * format,...)438 void log_validator_error(char *error_message, const char *format, ...) 439 { 440 va_list args; 441 442 //Log error to error out. 443 va_start(args, format); 444 vsnprintf(error_message, JSON_ERROR_MSG_MAX_LEN, format, args); 445 va_end(args); 446 447 //Debug message if necessary. 448 va_start(args, format); 449 log_validator_msg(format, args); 450 va_end(args); 451 } 452 453 //Logs a debug message to stdout, if validator debug is enabled. log_validator_debug(const char * format,...)454 void log_validator_debug(const char *format, ...) 455 { 456 va_list args; 457 va_start(args, format); 458 log_validator_msg(format, args); 459 va_end(args); 460 } 461 462 //Logs a single validator debug/error message. log_validator_msg(const char * format,va_list args)463 void log_validator_msg(const char *format, va_list args) 464 { 465 //Print debug output if debug is on. 466 if (json_validator_debug) { 467 //Make new format string for error. 468 const char *header = "json_validator: "; 469 char *new_format = malloc(strlen(header) + strlen(format) + 2); 470 strcpy(new_format, header); 471 strcat(new_format, format); 472 strcat(new_format, "\n"); 473 474 //Print & free format. 475 vfprintf(stdout, new_format, args); 476 free(new_format); 477 } 478 } 479