| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/nacl/renderer/json_manifest.h" | |
| 6 | |
| 7 #include <set> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/macros.h" | |
| 11 #include "components/nacl/renderer/nexe_load_manager.h" | |
| 12 #include "third_party/jsoncpp/source/include/json/reader.h" | |
| 13 #include "third_party/jsoncpp/source/include/json/value.h" | |
| 14 #include "url/gurl.h" | |
| 15 | |
| 16 namespace nacl { | |
| 17 | |
| 18 namespace { | |
| 19 // Top-level section name keys | |
| 20 const char* const kProgramKey = "program"; | |
| 21 const char* const kInterpreterKey = "interpreter"; | |
| 22 const char* const kFilesKey = "files"; | |
| 23 | |
| 24 // ISA Dictionary keys | |
| 25 const char* const kX8632Key = "x86-32"; | |
| 26 const char* const kX8632NonSFIKey = "x86-32-nonsfi"; | |
| 27 const char* const kX8664Key = "x86-64"; | |
| 28 const char* const kX8664NonSFIKey = "x86-64-nonsfi"; | |
| 29 const char* const kArmKey = "arm"; | |
| 30 const char* const kArmNonSFIKey = "arm-nonsfi"; | |
| 31 const char* const kPortableKey = "portable"; | |
| 32 | |
| 33 // Url Resolution keys | |
| 34 const char* const kPnaclDebugKey = "pnacl-debug"; | |
| 35 const char* const kPnaclTranslateKey = "pnacl-translate"; | |
| 36 const char* const kUrlKey = "url"; | |
| 37 | |
| 38 // PNaCl keys | |
| 39 const char* const kOptLevelKey = "optlevel"; | |
| 40 | |
| 41 // Sample NaCl manifest file: | |
| 42 // { | |
| 43 // "program": { | |
| 44 // "x86-32": {"url": "myprogram_x86-32.nexe"}, | |
| 45 // "x86-64": {"url": "myprogram_x86-64.nexe"}, | |
| 46 // "arm": {"url": "myprogram_arm.nexe"} | |
| 47 // }, | |
| 48 // "interpreter": { | |
| 49 // "x86-32": {"url": "interpreter_x86-32.nexe"}, | |
| 50 // "x86-64": {"url": "interpreter_x86-64.nexe"}, | |
| 51 // "arm": {"url": "interpreter_arm.nexe"} | |
| 52 // }, | |
| 53 // "files": { | |
| 54 // "foo.txt": { | |
| 55 // "portable": {"url": "foo.txt"} | |
| 56 // }, | |
| 57 // "bar.txt": { | |
| 58 // "x86-32": {"url": "x86-32/bar.txt"}, | |
| 59 // "portable": {"url": "bar.txt"} | |
| 60 // }, | |
| 61 // "libfoo.so": { | |
| 62 // "x86-64" : { "url": "..." } | |
| 63 // } | |
| 64 // } | |
| 65 // } | |
| 66 | |
| 67 // Sample PNaCl manifest file: | |
| 68 // { | |
| 69 // "program": { | |
| 70 // "portable": { | |
| 71 // "pnacl-translate": { | |
| 72 // "url": "myprogram.pexe" | |
| 73 // }, | |
| 74 // "pnacl-debug": { | |
| 75 // "url": "myprogram.debug.pexe", | |
| 76 // "opt_level": 0 | |
| 77 // } | |
| 78 // } | |
| 79 // }, | |
| 80 // "files": { | |
| 81 // "foo.txt": { | |
| 82 // "portable": {"url": "foo.txt"} | |
| 83 // }, | |
| 84 // "bar.txt": { | |
| 85 // "portable": {"url": "bar.txt"} | |
| 86 // } | |
| 87 // } | |
| 88 // } | |
| 89 | |
| 90 // Returns the key for the architecture in non-SFI mode. | |
| 91 std::string GetNonSFIKey(const std::string& sandbox_isa) { | |
| 92 return sandbox_isa + "-nonsfi"; | |
| 93 } | |
| 94 | |
| 95 // Looks up |property_name| in the vector |valid_names| with length | |
| 96 // |valid_name_count|. Returns true if |property_name| is found. | |
| 97 bool FindMatchingProperty(const std::string& property_name, | |
| 98 const char** valid_names, | |
| 99 size_t valid_name_count) { | |
| 100 for (size_t i = 0; i < valid_name_count; ++i) { | |
| 101 if (property_name == valid_names[i]) { | |
| 102 return true; | |
| 103 } | |
| 104 } | |
| 105 return false; | |
| 106 } | |
| 107 | |
| 108 // Return true if this is a valid dictionary. Having only keys present in | |
| 109 // |valid_keys| and having at least the keys in |required_keys|. | |
| 110 // Error messages will be placed in |error_string|, given that the dictionary | |
| 111 // was the property value of |container_key|. | |
| 112 // E.g., "container_key" : dictionary | |
| 113 bool IsValidDictionary(const Json::Value& dictionary, | |
| 114 const std::string& container_key, | |
| 115 const std::string& parent_key, | |
| 116 const char** valid_keys, | |
| 117 size_t valid_key_count, | |
| 118 const char** required_keys, | |
| 119 size_t required_key_count, | |
| 120 std::string* error_string) { | |
| 121 if (!dictionary.isObject()) { | |
| 122 std::stringstream error_stream; | |
| 123 error_stream << parent_key << " property '" << container_key | |
| 124 << "' is non-dictionary value '" | |
| 125 << dictionary.toStyledString() << "'."; | |
| 126 *error_string = error_stream.str(); | |
| 127 return false; | |
| 128 } | |
| 129 // Check for unknown dictionary members. | |
| 130 Json::Value::Members members = dictionary.getMemberNames(); | |
| 131 for (size_t i = 0; i < members.size(); ++i) { | |
| 132 std::string property_name = members[i]; | |
| 133 if (!FindMatchingProperty(property_name, | |
| 134 valid_keys, | |
| 135 valid_key_count)) { | |
| 136 // For forward compatibility, we do not prohibit other keys being in | |
| 137 // the dictionary. | |
| 138 VLOG(1) << "WARNING: '" << parent_key << "' property '" | |
| 139 << container_key << "' has unknown key '" | |
| 140 << property_name << "'."; | |
| 141 } | |
| 142 } | |
| 143 // Check for required members. | |
| 144 for (size_t i = 0; i < required_key_count; ++i) { | |
| 145 if (!dictionary.isMember(required_keys[i])) { | |
| 146 std::stringstream error_stream; | |
| 147 error_stream << parent_key << " property '" << container_key | |
| 148 << "' does not have required key: '" | |
| 149 << required_keys[i] << "'."; | |
| 150 *error_string = error_stream.str(); | |
| 151 return false; | |
| 152 } | |
| 153 } | |
| 154 return true; | |
| 155 } | |
| 156 | |
| 157 // Validate a "url" dictionary assuming it was resolved from container_key. | |
| 158 // E.g., "container_key" : { "url": "foo.txt" } | |
| 159 bool IsValidUrlSpec(const Json::Value& url_spec, | |
| 160 const std::string& container_key, | |
| 161 const std::string& parent_key, | |
| 162 const std::string& sandbox_isa, | |
| 163 std::string* error_string) { | |
| 164 static const char* kManifestUrlSpecRequired[] = { | |
| 165 kUrlKey | |
| 166 }; | |
| 167 const char** urlSpecPlusOptional; | |
| 168 size_t urlSpecPlusOptionalLength; | |
| 169 if (sandbox_isa == kPortableKey) { | |
| 170 static const char* kPnaclUrlSpecPlusOptional[] = { | |
| 171 kUrlKey, | |
| 172 kOptLevelKey, | |
| 173 }; | |
| 174 urlSpecPlusOptional = kPnaclUrlSpecPlusOptional; | |
| 175 urlSpecPlusOptionalLength = arraysize(kPnaclUrlSpecPlusOptional); | |
| 176 } else { | |
| 177 // URL specifications must not contain "pnacl-translate" keys. | |
| 178 // This prohibits NaCl clients from invoking PNaCl. | |
| 179 if (url_spec.isMember(kPnaclTranslateKey)) { | |
| 180 std::stringstream error_stream; | |
| 181 error_stream << "PNaCl-like NMF with application/x-nacl mimetype instead " | |
| 182 << "of x-pnacl mimetype (has " << kPnaclTranslateKey << ")."; | |
| 183 *error_string = error_stream.str(); | |
| 184 return false; | |
| 185 } | |
| 186 urlSpecPlusOptional = kManifestUrlSpecRequired; | |
| 187 urlSpecPlusOptionalLength = arraysize(kManifestUrlSpecRequired); | |
| 188 } | |
| 189 if (!IsValidDictionary(url_spec, container_key, parent_key, | |
| 190 urlSpecPlusOptional, | |
| 191 urlSpecPlusOptionalLength, | |
| 192 kManifestUrlSpecRequired, | |
| 193 arraysize(kManifestUrlSpecRequired), | |
| 194 error_string)) { | |
| 195 return false; | |
| 196 } | |
| 197 // Verify the correct types of the fields if they exist. | |
| 198 Json::Value url = url_spec[kUrlKey]; | |
| 199 if (!url.isString()) { | |
| 200 std::stringstream error_stream; | |
| 201 error_stream << parent_key << " property '" << container_key << | |
| 202 "' has non-string value '" << url.toStyledString() << | |
| 203 "' for key '" << kUrlKey << "'."; | |
| 204 *error_string = error_stream.str(); | |
| 205 return false; | |
| 206 } | |
| 207 Json::Value opt_level = url_spec[kOptLevelKey]; | |
| 208 if (!opt_level.empty() && !opt_level.isNumeric()) { | |
| 209 std::stringstream error_stream; | |
| 210 error_stream << parent_key << " property '" << container_key << | |
| 211 "' has non-numeric value '" << opt_level.toStyledString() << | |
| 212 "' for key '" << kOptLevelKey << "'."; | |
| 213 *error_string = error_stream.str(); | |
| 214 return false; | |
| 215 } | |
| 216 return true; | |
| 217 } | |
| 218 | |
| 219 // Validate a "pnacl-translate" or "pnacl-debug" dictionary, assuming | |
| 220 // it was resolved from container_key. | |
| 221 // E.g., "container_key" : { "pnacl-translate" : URLSpec } | |
| 222 bool IsValidPnaclTranslateSpec(const Json::Value& pnacl_spec, | |
| 223 const std::string& container_key, | |
| 224 const std::string& parent_key, | |
| 225 const std::string& sandbox_isa, | |
| 226 std::string* error_string) { | |
| 227 static const char* kManifestPnaclSpecValid[] = { | |
| 228 kPnaclDebugKey, | |
| 229 kPnaclTranslateKey | |
| 230 }; | |
| 231 static const char* kManifestPnaclSpecRequired[] = { kPnaclTranslateKey }; | |
| 232 if (!IsValidDictionary(pnacl_spec, container_key, parent_key, | |
| 233 kManifestPnaclSpecValid, | |
| 234 arraysize(kManifestPnaclSpecValid), | |
| 235 kManifestPnaclSpecRequired, | |
| 236 arraysize(kManifestPnaclSpecRequired), | |
| 237 error_string)) { | |
| 238 return false; | |
| 239 } | |
| 240 Json::Value url_spec = pnacl_spec[kPnaclTranslateKey]; | |
| 241 return IsValidUrlSpec(url_spec, kPnaclTranslateKey, | |
| 242 container_key, sandbox_isa, error_string); | |
| 243 } | |
| 244 | |
| 245 // Validates that |dictionary| is a valid ISA dictionary. An ISA dictionary | |
| 246 // is validated to have keys from within the set of recognized ISAs. Unknown | |
| 247 // ISAs are allowed, but ignored and warnings are produced. It is also | |
| 248 // validated | |
| 249 // that it must have an entry to match the ISA specified in |sandbox_isa| or | |
| 250 // have a fallback 'portable' entry if there is no match. Returns true if | |
| 251 // |dictionary| is an ISA to URL map. Sets |error_info| to something | |
| 252 // descriptive if it fails. | |
| 253 bool IsValidISADictionary(const Json::Value& dictionary, | |
| 254 const std::string& parent_key, | |
| 255 const std::string& sandbox_isa, | |
| 256 bool must_find_matching_entry, | |
| 257 bool nonsfi_enabled, | |
| 258 JsonManifest::ErrorInfo* error_info) { | |
| 259 // An ISA to URL dictionary has to be an object. | |
| 260 if (!dictionary.isObject()) { | |
| 261 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 262 error_info->string = std::string("manifest: ") + parent_key + | |
| 263 " property is not an ISA to URL dictionary"; | |
| 264 return false; | |
| 265 } | |
| 266 // Build the set of reserved ISA dictionary keys. | |
| 267 const char** isaProperties; | |
| 268 size_t isaPropertiesLength; | |
| 269 if (sandbox_isa == kPortableKey) { | |
| 270 // The known values for PNaCl ISA dictionaries in the manifest. | |
| 271 static const char* kPnaclManifestISAProperties[] = { | |
| 272 kPortableKey | |
| 273 }; | |
| 274 isaProperties = kPnaclManifestISAProperties; | |
| 275 isaPropertiesLength = arraysize(kPnaclManifestISAProperties); | |
| 276 } else { | |
| 277 // The known values for NaCl ISA dictionaries in the manifest. | |
| 278 static const char* kNaClManifestISAProperties[] = { | |
| 279 kX8632Key, | |
| 280 kX8632NonSFIKey, | |
| 281 kX8664Key, | |
| 282 kX8664NonSFIKey, | |
| 283 kArmKey, | |
| 284 kArmNonSFIKey, | |
| 285 // "portable" is here to allow checking that, if present, it can | |
| 286 // only refer to an URL, such as for a data file, and not to | |
| 287 // "pnacl-translate", which would cause the creation of a nexe. | |
| 288 kPortableKey | |
| 289 }; | |
| 290 isaProperties = kNaClManifestISAProperties; | |
| 291 isaPropertiesLength = arraysize(kNaClManifestISAProperties); | |
| 292 } | |
| 293 // Check that entries in the dictionary are structurally correct. | |
| 294 Json::Value::Members members = dictionary.getMemberNames(); | |
| 295 for (size_t i = 0; i < members.size(); ++i) { | |
| 296 std::string property_name = members[i]; | |
| 297 Json::Value property_value = dictionary[property_name]; | |
| 298 std::string error_string; | |
| 299 if (FindMatchingProperty(property_name, | |
| 300 isaProperties, | |
| 301 isaPropertiesLength)) { | |
| 302 // For NaCl, arch entries can only be | |
| 303 // "arch/portable" : URLSpec | |
| 304 // For PNaCl arch in "program" dictionary entries can be | |
| 305 // "portable" : { "pnacl-translate": URLSpec } | |
| 306 // or "portable" : { "pnacl-debug": URLSpec } | |
| 307 // For PNaCl arch elsewhere, dictionary entries can only be | |
| 308 // "portable" : URLSpec | |
| 309 if ((sandbox_isa != kPortableKey && | |
| 310 !IsValidUrlSpec(property_value, property_name, parent_key, | |
| 311 sandbox_isa, &error_string)) || | |
| 312 (sandbox_isa == kPortableKey && | |
| 313 parent_key == kProgramKey && | |
| 314 !IsValidPnaclTranslateSpec(property_value, property_name, parent_key, | |
| 315 sandbox_isa, &error_string)) || | |
| 316 (sandbox_isa == kPortableKey && | |
| 317 parent_key != kProgramKey && | |
| 318 !IsValidUrlSpec(property_value, property_name, parent_key, | |
| 319 sandbox_isa, &error_string))) { | |
| 320 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 321 error_info->string = "manifest: " + error_string; | |
| 322 return false; | |
| 323 } | |
| 324 } else { | |
| 325 // For forward compatibility, we do not prohibit other keys being in | |
| 326 // the dictionary, as they may be architectures supported in later | |
| 327 // versions. However, the value of these entries must be an URLSpec. | |
| 328 VLOG(1) << "IsValidISADictionary: unrecognized key '" | |
| 329 << property_name << "'."; | |
| 330 if (!IsValidUrlSpec(property_value, property_name, parent_key, | |
| 331 sandbox_isa, &error_string)) { | |
| 332 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 333 error_info->string = "manifest: " + error_string; | |
| 334 return false; | |
| 335 } | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 if (sandbox_isa == kPortableKey) { | |
| 340 if (!dictionary.isMember(kPortableKey)) { | |
| 341 error_info->error = PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH; | |
| 342 error_info->string = "manifest: no version of " + parent_key + | |
| 343 " given for portable."; | |
| 344 return false; | |
| 345 } | |
| 346 } else if (must_find_matching_entry) { | |
| 347 // TODO(elijahtaylor) add ISA resolver here if we expand ISAs to include | |
| 348 // micro-architectures that can resolve to multiple valid sandboxes. | |
| 349 bool has_isa = dictionary.isMember(sandbox_isa); | |
| 350 bool has_nonsfi_isa = | |
| 351 nonsfi_enabled && dictionary.isMember(GetNonSFIKey(sandbox_isa)); | |
| 352 bool has_portable = dictionary.isMember(kPortableKey); | |
| 353 | |
| 354 if (!has_isa && !has_nonsfi_isa && !has_portable) { | |
| 355 error_info->error = PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH; | |
| 356 error_info->string = "manifest: no version of " + parent_key + | |
| 357 " given for current arch and no portable version found."; | |
| 358 return false; | |
| 359 } | |
| 360 } | |
| 361 return true; | |
| 362 } | |
| 363 | |
| 364 void GrabUrlAndPnaclOptions(const Json::Value& url_spec, | |
| 365 std::string* url, | |
| 366 PP_PNaClOptions* pnacl_options) { | |
| 367 *url = url_spec[kUrlKey].asString(); | |
| 368 pnacl_options->translate = PP_TRUE; | |
| 369 if (url_spec.isMember(kOptLevelKey)) { | |
| 370 int32_t opt_raw = url_spec[kOptLevelKey].asInt(); | |
| 371 // Currently only allow 0 or 2, since that is what we test. | |
| 372 if (opt_raw <= 0) | |
| 373 pnacl_options->opt_level = 0; | |
| 374 else | |
| 375 pnacl_options->opt_level = 2; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 } // namespace | |
| 380 | |
| 381 JsonManifest::JsonManifest(const std::string& manifest_base_url, | |
| 382 const std::string& sandbox_isa, | |
| 383 bool nonsfi_enabled, | |
| 384 bool pnacl_debug) | |
| 385 : manifest_base_url_(manifest_base_url), | |
| 386 sandbox_isa_(sandbox_isa), | |
| 387 nonsfi_enabled_(nonsfi_enabled), | |
| 388 pnacl_debug_(pnacl_debug) { } | |
| 389 | |
| 390 bool JsonManifest::Init(const std::string& manifest_json, | |
| 391 ErrorInfo* error_info) { | |
| 392 CHECK(error_info); | |
| 393 | |
| 394 Json::Reader reader; | |
| 395 if (!reader.parse(manifest_json, dictionary_)) { | |
| 396 std::string json_error = reader.getFormattedErrorMessages(); | |
| 397 error_info->error = PP_NACL_ERROR_MANIFEST_PARSING; | |
| 398 error_info->string = "manifest JSON parsing failed: " + json_error; | |
| 399 return false; | |
| 400 } | |
| 401 // Parse has ensured the string was valid JSON. Check that it matches the | |
| 402 // manifest schema. | |
| 403 return MatchesSchema(error_info); | |
| 404 } | |
| 405 | |
| 406 bool JsonManifest::GetProgramURL(std::string* full_url, | |
| 407 PP_PNaClOptions* pnacl_options, | |
| 408 bool* uses_nonsfi_mode, | |
| 409 ErrorInfo* error_info) const { | |
| 410 if (!full_url) | |
| 411 return false; | |
| 412 CHECK(pnacl_options); | |
| 413 CHECK(uses_nonsfi_mode); | |
| 414 CHECK(error_info); | |
| 415 | |
| 416 const Json::Value& program = dictionary_[kProgramKey]; | |
| 417 std::string nexe_url; | |
| 418 if (!GetURLFromISADictionary(program, | |
| 419 kProgramKey, | |
| 420 &nexe_url, | |
| 421 pnacl_options, | |
| 422 uses_nonsfi_mode, | |
| 423 error_info)) { | |
| 424 return false; | |
| 425 } | |
| 426 | |
| 427 // The contents of the manifest are resolved relative to the manifest URL. | |
| 428 GURL base_gurl(manifest_base_url_); | |
| 429 if (!base_gurl.is_valid()) | |
| 430 return false; | |
| 431 | |
| 432 GURL resolved_gurl = base_gurl.Resolve(nexe_url); | |
| 433 if (!resolved_gurl.is_valid()) { | |
| 434 error_info->error = PP_NACL_ERROR_MANIFEST_RESOLVE_URL; | |
| 435 error_info->string = | |
| 436 "could not resolve url '" + nexe_url + | |
| 437 "' relative to manifest base url '" + manifest_base_url_.c_str() + | |
| 438 "'."; | |
| 439 return false; | |
| 440 } | |
| 441 *full_url = resolved_gurl.possibly_invalid_spec(); | |
| 442 return true; | |
| 443 } | |
| 444 | |
| 445 bool JsonManifest::ResolveKey(const std::string& key, | |
| 446 std::string* full_url, | |
| 447 PP_PNaClOptions* pnacl_options) const { | |
| 448 // key must be one of kProgramKey or kFileKey '/' file-section-key | |
| 449 if (full_url == NULL || pnacl_options == NULL) | |
| 450 return false; | |
| 451 | |
| 452 if (key == kProgramKey) | |
| 453 return GetKeyUrl(dictionary_, key, full_url, pnacl_options); | |
| 454 | |
| 455 std::string::const_iterator p = find(key.begin(), key.end(), '/'); | |
| 456 if (p == key.end()) { | |
| 457 VLOG(1) << "ResolveKey failed: invalid key, no slash: " << key; | |
| 458 return false; | |
| 459 } | |
| 460 | |
| 461 // generalize to permit other sections? | |
| 462 std::string prefix(key.begin(), p); | |
| 463 if (prefix != kFilesKey) { | |
| 464 VLOG(1) << "ResolveKey failed: invalid key, no \"files\" prefix: " << key; | |
| 465 return false; | |
| 466 } | |
| 467 | |
| 468 const Json::Value& files = dictionary_[kFilesKey]; | |
| 469 if (!files.isObject()) { | |
| 470 VLOG(1) << "ResolveKey failed: no \"files\" dictionary"; | |
| 471 return false; | |
| 472 } | |
| 473 | |
| 474 std::string rest(p + 1, key.end()); | |
| 475 if (!files.isMember(rest)) { | |
| 476 VLOG(1) << "ResolveKey failed: no such \"files\" entry: " << key; | |
| 477 return false; | |
| 478 } | |
| 479 return GetKeyUrl(files, rest, full_url, pnacl_options); | |
| 480 } | |
| 481 | |
| 482 bool JsonManifest::MatchesSchema(ErrorInfo* error_info) { | |
| 483 if (!dictionary_.isObject()) { | |
| 484 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 485 error_info->string = "manifest: is not a json dictionary."; | |
| 486 return false; | |
| 487 } | |
| 488 Json::Value::Members members = dictionary_.getMemberNames(); | |
| 489 for (size_t i = 0; i < members.size(); ++i) { | |
| 490 // The top level dictionary entries valid in the manifest file. | |
| 491 static const char* kManifestTopLevelProperties[] = { kProgramKey, | |
| 492 kInterpreterKey, | |
| 493 kFilesKey }; | |
| 494 std::string property_name = members[i]; | |
| 495 if (!FindMatchingProperty(property_name, | |
| 496 kManifestTopLevelProperties, | |
| 497 arraysize(kManifestTopLevelProperties))) { | |
| 498 VLOG(1) << "JsonManifest::MatchesSchema: WARNING: unknown top-level " | |
| 499 << "section '" << property_name << "' in manifest."; | |
| 500 } | |
| 501 } | |
| 502 | |
| 503 // A manifest file must have a program section. | |
| 504 if (!dictionary_.isMember(kProgramKey)) { | |
| 505 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 506 error_info->string = std::string("manifest: missing '") + kProgramKey + | |
| 507 "' section."; | |
| 508 return false; | |
| 509 } | |
| 510 | |
| 511 // Validate the program section. | |
| 512 // There must be a matching (portable or sandbox_isa_) entry for program for | |
| 513 // NaCl. | |
| 514 if (!IsValidISADictionary(dictionary_[kProgramKey], | |
| 515 kProgramKey, | |
| 516 sandbox_isa_, | |
| 517 true, | |
| 518 nonsfi_enabled_, | |
| 519 error_info)) { | |
| 520 return false; | |
| 521 } | |
| 522 | |
| 523 // Validate the interpreter section (if given). | |
| 524 // There must be a matching (portable or sandbox_isa_) entry for interpreter | |
| 525 // for NaCl. | |
| 526 if (dictionary_.isMember(kInterpreterKey)) { | |
| 527 if (!IsValidISADictionary(dictionary_[kInterpreterKey], | |
| 528 kInterpreterKey, | |
| 529 sandbox_isa_, | |
| 530 true, | |
| 531 nonsfi_enabled_, | |
| 532 error_info)) { | |
| 533 return false; | |
| 534 } | |
| 535 } | |
| 536 | |
| 537 // Validate the file dictionary (if given). | |
| 538 // The "files" key does not require a matching (portable or sandbox_isa_) | |
| 539 // entry at schema validation time for NaCl. This allows manifests to | |
| 540 // specify resources that are only loaded for a particular sandbox_isa. | |
| 541 if (dictionary_.isMember(kFilesKey)) { | |
| 542 const Json::Value& files = dictionary_[kFilesKey]; | |
| 543 if (!files.isObject()) { | |
| 544 error_info->error = PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE; | |
| 545 error_info->string = std::string("manifest: '") + kFilesKey + | |
| 546 "' is not a dictionary."; | |
| 547 } | |
| 548 Json::Value::Members members = files.getMemberNames(); | |
| 549 for (size_t i = 0; i < members.size(); ++i) { | |
| 550 std::string file_name = members[i]; | |
| 551 if (!IsValidISADictionary(files[file_name], | |
| 552 file_name, | |
| 553 sandbox_isa_, | |
| 554 false, | |
| 555 nonsfi_enabled_, | |
| 556 error_info)) { | |
| 557 return false; | |
| 558 } | |
| 559 } | |
| 560 } | |
| 561 return true; | |
| 562 } | |
| 563 | |
| 564 bool JsonManifest::GetKeyUrl(const Json::Value& dictionary, | |
| 565 const std::string& key, | |
| 566 std::string* full_url, | |
| 567 PP_PNaClOptions* pnacl_options) const { | |
| 568 DCHECK(full_url && pnacl_options); | |
| 569 if (!dictionary.isMember(key)) { | |
| 570 VLOG(1) << "GetKeyUrl failed: file " << key << " not found in manifest."; | |
| 571 return false; | |
| 572 } | |
| 573 const Json::Value& isa_dict = dictionary[key]; | |
| 574 std::string relative_url; | |
| 575 bool uses_nonsfi_mode; | |
| 576 ErrorInfo ignored_error_info; | |
| 577 if (!GetURLFromISADictionary(isa_dict, key, &relative_url, | |
| 578 pnacl_options, &uses_nonsfi_mode, | |
| 579 &ignored_error_info)) | |
| 580 return false; | |
| 581 | |
| 582 // The contents of the manifest are resolved relative to the manifest URL. | |
| 583 GURL base_gurl(manifest_base_url_); | |
| 584 if (!base_gurl.is_valid()) | |
| 585 return false; | |
| 586 GURL resolved_gurl = base_gurl.Resolve(relative_url); | |
| 587 if (!resolved_gurl.is_valid()) | |
| 588 return false; | |
| 589 *full_url = resolved_gurl.possibly_invalid_spec(); | |
| 590 return true; | |
| 591 } | |
| 592 | |
| 593 bool JsonManifest::GetURLFromISADictionary(const Json::Value& dictionary, | |
| 594 const std::string& parent_key, | |
| 595 std::string* url, | |
| 596 PP_PNaClOptions* pnacl_options, | |
| 597 bool* uses_nonsfi_mode, | |
| 598 ErrorInfo* error_info) const { | |
| 599 DCHECK(url && pnacl_options && error_info); | |
| 600 | |
| 601 // When the application actually requests a resolved URL, we must have | |
| 602 // a matching entry (sandbox_isa_ or portable) for NaCl. | |
| 603 ErrorInfo ignored_error_info; | |
| 604 if (!IsValidISADictionary(dictionary, parent_key, sandbox_isa_, true, | |
| 605 nonsfi_enabled_, &ignored_error_info)) { | |
| 606 error_info->error = PP_NACL_ERROR_MANIFEST_RESOLVE_URL; | |
| 607 error_info->string = "architecture " + sandbox_isa_ + | |
| 608 " is not found for file " + parent_key; | |
| 609 return false; | |
| 610 } | |
| 611 | |
| 612 // The call to IsValidISADictionary() above guarantees that either | |
| 613 // sandbox_isa_, its nonsfi mode, or kPortableKey is present in the | |
| 614 // dictionary. | |
| 615 *uses_nonsfi_mode = false; | |
| 616 std::string chosen_isa; | |
| 617 if (sandbox_isa_ == kPortableKey) { | |
| 618 chosen_isa = kPortableKey; | |
| 619 } else { | |
| 620 std::string nonsfi_isa = GetNonSFIKey(sandbox_isa_); | |
| 621 if (nonsfi_enabled_ && dictionary.isMember(nonsfi_isa)) { | |
| 622 chosen_isa = nonsfi_isa; | |
| 623 *uses_nonsfi_mode = true; | |
| 624 } else if (dictionary.isMember(sandbox_isa_)) { | |
| 625 chosen_isa = sandbox_isa_; | |
| 626 } else if (dictionary.isMember(kPortableKey)) { | |
| 627 chosen_isa = kPortableKey; | |
| 628 } else { | |
| 629 // Should not reach here, because the earlier IsValidISADictionary() | |
| 630 // call checked that the manifest covers the current architecture. | |
| 631 DCHECK(false); | |
| 632 return false; | |
| 633 } | |
| 634 } | |
| 635 | |
| 636 const Json::Value& isa_spec = dictionary[chosen_isa]; | |
| 637 // If the PNaCl debug flag is turned on, look for pnacl-debug entries first. | |
| 638 // If found, mark that it is a debug URL. Otherwise, fall back to | |
| 639 // checking for pnacl-translate URLs, etc. and don't mark it as a debug URL. | |
| 640 if (pnacl_debug_ && isa_spec.isMember(kPnaclDebugKey)) { | |
| 641 GrabUrlAndPnaclOptions(isa_spec[kPnaclDebugKey], url, pnacl_options); | |
| 642 pnacl_options->is_debug = PP_TRUE; | |
| 643 } else if (isa_spec.isMember(kPnaclTranslateKey)) { | |
| 644 GrabUrlAndPnaclOptions(isa_spec[kPnaclTranslateKey], url, pnacl_options); | |
| 645 } else { | |
| 646 // NaCl | |
| 647 *url = isa_spec[kUrlKey].asString(); | |
| 648 pnacl_options->translate = PP_FALSE; | |
| 649 } | |
| 650 | |
| 651 return true; | |
| 652 } | |
| 653 | |
| 654 } // namespace nacl | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 264143002:
Revert 268250 "Pepper: Move manifest logic to components/nacl." (Closed)
Base URL: svn://svn.chromium.org/chrome/