Support non-SFI mode in NaCl manifest file.

ppapi/native_client/src/trusted/plugin/json_manifest.cc

 /*
  * Copyright (c) 2012 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <algorithm>
 
 #include "ppapi/native_client/src/trusted/plugin/json_manifest.h"
 
@@ skipping 14 matching lines @@
 namespace plugin {
 
 namespace {
 // Top-level section name keys
 const char* const kProgramKey =     "program";
 const char* const kInterpreterKey = "interpreter";
 const char* const kFilesKey =       "files";
 
 // ISA Dictionary keys
 const char* const kX8632Key =       "x86-32";
+const char* const kX8632NonSFIKey = "x86-32-nonsfi";
 const char* const kX8664Key =       "x86-64";
+const char* const kX8664NonSFIKey = "x86-64-nonsfi";
 const char* const kArmKey =         "arm";
+const char* const kArmNonSFIKey =   "arm-nonsfi";
 const char* const kPortableKey =    "portable";
 
 // Url Resolution keys
 const char* const kPnaclTranslateKey = "pnacl-translate";
 const char* const kUrlKey =            "url";
 
 // PNaCl keys
 const char* const kOptLevelKey = "optlevel";
 
 // Sample NaCl manifest file:
@@ skipping 35 matching lines @@
 //   "files": {
 //     "foo.txt": {
 //       "portable": {"url": "foo.txt"}
 //     },
 //     "bar.txt": {
 //       "portable": {"url": "bar.txt"}
 //     }
 //   }
 // }
 
+// Returns the key for the architecture in non-SFI mode.
+std::string GetNonSFIKey(const std::string& sandbox_isa) {
+  return sandbox_isa + "-nonsfi";
+}
+
 // Looks up |property_name| in the vector |valid_names| with length
 // |valid_name_count|.  Returns true if |property_name| is found.
 bool FindMatchingProperty(const nacl::string& property_name,
                           const char** valid_names,
                           size_t valid_name_count) {
   for (size_t i = 0; i < valid_name_count; ++i) {
     if (property_name == valid_names[i]) {
       return true;
     }
   }
@@ skipping 141 matching lines @@
 // is validated to have keys from within the set of recognized ISAs.  Unknown
 // ISAs are allowed, but ignored and warnings are produced. It is also validated
 // that it must have an entry to match the ISA specified in |sandbox_isa| or
 // have a fallback 'portable' entry if there is no match. Returns true if
 // |dictionary| is an ISA to URL map.  Sets |error_info| to something
 // descriptive if it fails.
 bool IsValidISADictionary(const Json::Value& dictionary,
                           const nacl::string& parent_key,
                           const nacl::string& sandbox_isa,
                           bool must_find_matching_entry,
+                          bool nonsfi_enabled,
                           ErrorInfo* error_info) {
   if (error_info == NULL) return false;
 
   // An ISA to URL dictionary has to be an object.
   if (!dictionary.isObject()) {
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE,
                           nacl::string("manifest: ") + parent_key +
                           " property is not an ISA to URL dictionary");
     return false;
   }
   // Build the set of reserved ISA dictionary keys.
   const char** isaProperties;
   size_t isaPropertiesLength;
   if (sandbox_isa == kPortableKey) {
     // The known values for PNaCl ISA dictionaries in the manifest.
     static const char* kPnaclManifestISAProperties[] = {
       kPortableKey
     };
     isaProperties = kPnaclManifestISAProperties;
     isaPropertiesLength = NACL_ARRAY_SIZE(kPnaclManifestISAProperties);
   } else {
     // The known values for NaCl ISA dictionaries in the manifest.
     static const char* kNaClManifestISAProperties[] = {
       kX8632Key,
+      kX8632NonSFIKey,
       kX8664Key,
+      kX8664NonSFIKey,
       kArmKey,
+      kArmNonSFIKey,
       // "portable" is here to allow checking that, if present, it can
       // only refer to an URL, such as for a data file, and not to
       // "pnacl-translate", which would cause the creation of a nexe.
       kPortableKey
     };
     isaProperties = kNaClManifestISAProperties;
     isaPropertiesLength = NACL_ARRAY_SIZE(kNaClManifestISAProperties);
   }
   // Check that entries in the dictionary are structurally correct.
   Json::Value::Members members = dictionary.getMemberNames();
@@ skipping 47 matching lines @@
       error_info->SetReport(
           PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH,
           nacl::string("manifest: no version of ") + parent_key +
           " given for portable.");
       return false;
     }
   } else if (must_find_matching_entry) {
     // TODO(elijahtaylor) add ISA resolver here if we expand ISAs to include
     // micro-architectures that can resolve to multiple valid sandboxes.
     bool has_isa = dictionary.isMember(sandbox_isa);
+    bool has_nonsfi_isa =
+        nonsfi_enabled && dictionary.isMember(GetNonSFIKey(sandbox_isa));
     bool has_portable = dictionary.isMember(kPortableKey);
 
-    if (!has_isa && !has_portable) {
+    if (!has_isa && !has_nonsfi_isa && !has_portable) {
       error_info->SetReport(
           PP_NACL_ERROR_MANIFEST_PROGRAM_MISSING_ARCH,
           nacl::string("manifest: no version of ") + parent_key +
           " given for current arch and no portable version found.");
       return false;
     }
   }
 
   return true;
 }
@@ skipping 62 matching lines @@
     return false;
   }
 
   // Validate the program section.
   // There must be a matching (portable or sandbox_isa_) entry for program for
   // NaCl.
   if (!IsValidISADictionary(dictionary_[kProgramKey],
                             kProgramKey,
                             sandbox_isa_,
                             true,
+                            nonsfi_enabled_,
                             error_info)) {
     return false;
   }
 
   // Validate the interpreter section (if given).
   // There must be a matching (portable or sandbox_isa_) entry for interpreter
   // for NaCl.
   if (dictionary_.isMember(kInterpreterKey)) {
     if (!IsValidISADictionary(dictionary_[kInterpreterKey],
                               kInterpreterKey,
                               sandbox_isa_,
                               true,
+                              nonsfi_enabled_,
                               error_info)) {
       return false;
     }
   }
 
   // Validate the file dictionary (if given).
   // The "files" key does not require a matching (portable or sandbox_isa_)
   // entry at schema validation time for NaCl.  This allows manifests to specify
   // resources that are only loaded for a particular sandbox_isa.
   if (dictionary_.isMember(kFilesKey)) {
     const Json::Value& files = dictionary_[kFilesKey];
     if (!files.isObject()) {
       error_info->SetReport(
           PP_NACL_ERROR_MANIFEST_SCHEMA_VALIDATE,
           nacl::string("manifest: '") + kFilesKey + "' is not a dictionary.");
     }
     Json::Value::Members members = files.getMemberNames();
     for (size_t i = 0; i < members.size(); ++i) {
       nacl::string file_name = members[i];
       if (!IsValidISADictionary(files[file_name],
                                 file_name,
                                 sandbox_isa_,
                                 false,
+                                nonsfi_enabled_,
                                 error_info)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool JsonManifest::GetURLFromISADictionary(const Json::Value& dictionary,
                                            const nacl::string& parent_key,
                                            nacl::string* url,
                                            PnaclOptions* pnacl_options,
+                                           bool* nonsfi_enabled,

[Mark Seaborn, 2014/02/27 17:10:22]

This is very close to "nonsfi_enabled_", so it would be easy to mix the two up. 
How about renaming this to "use_nonsfi_mode", to distinguish between the mode
being enabled in the browser and also being used in the NMF file?  (See other
comment.)

[hidehiko, 2014/02/28 06:41:54]

Done.

                                            ErrorInfo* error_info) const {
   DCHECK(url != NULL && pnacl_options != NULL && error_info != NULL);
 
   // When the application actually requests a resolved URL, we must have
   // a matching entry (sandbox_isa_ or portable) for NaCl.
   if (!IsValidISADictionary(dictionary, parent_key, sandbox_isa_, true,
-                            error_info)) {
+                            nonsfi_enabled_, error_info)) {
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                           "architecture " + sandbox_isa_ +
                           " is not found for file " + parent_key);
     return false;
   }
 
   *url = "";
 
   // The call to IsValidISADictionary() above guarantees that either
   // sandbox_isa_ or kPortableKey is present in the dictionary.
   bool has_portable = dictionary.isMember(kPortableKey);
   bool has_isa = dictionary.isMember(sandbox_isa_);
+  // True iff the non-SFI mode is enabled, and the nmf as the -nonsfi entry.
+  bool has_nonsfi_isa =
+      nonsfi_enabled_ && dictionary.isMember(GetNonSFIKey(sandbox_isa_));
   nacl::string chosen_isa;
-  if ((sandbox_isa_ == kPortableKey) || (has_portable && !has_isa)) {
+  if ((sandbox_isa_ == kPortableKey) ||
+      (has_portable && !has_isa && !has_nonsfi_isa)) {
     chosen_isa = kPortableKey;
   } else {
-    chosen_isa = sandbox_isa_;
+    // Choose non-SFI iff available.
+    if (has_nonsfi_isa) {
+      chosen_isa = GetNonSFIKey(sandbox_isa_);
+    } else {
+      chosen_isa = sandbox_isa_;
+    }
   }
   const Json::Value& isa_spec = dictionary[chosen_isa];
   // Check if this requires a pnacl-translate, otherwise just grab the URL.
   // We may have pnacl-translate for isa-specific bitcode for CPU tuning.
   if (isa_spec.isMember(kPnaclTranslateKey)) {
     // PNaCl
     GrabUrlAndPnaclOptions(isa_spec[kPnaclTranslateKey], url, pnacl_options);
     pnacl_options->set_translate(true);
+    if (nonsfi_enabled)

[Mark Seaborn, 2014/02/27 17:10:22]

It might be a little simpler to require the caller to pass a valid pointer than
have a NULL check.

[hidehiko, 2014/02/28 06:41:54]

Done.

+      *nonsfi_enabled = false;
   } else {
     // NaCl
     *url = isa_spec[kUrlKey].asString();
     pnacl_options->set_translate(false);
+    if (nonsfi_enabled)
+      *nonsfi_enabled = has_nonsfi_isa;
   }
 
   return true;
 }
 
 bool JsonManifest::GetKeyUrl(const Json::Value& dictionary,
                              const nacl::string& key,
                              nacl::string* full_url,
                              PnaclOptions* pnacl_options,
                              ErrorInfo* error_info) const {
   DCHECK(full_url != NULL && pnacl_options != NULL && error_info != NULL);
   if (!dictionary.isMember(key)) {
     error_info->SetReport(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                           "file key not found in manifest");
     return false;
   }
   const Json::Value& isa_dict = dictionary[key];
   nacl::string relative_url;
   if (!GetURLFromISADictionary(isa_dict, key, &relative_url,
-                               pnacl_options, error_info)) {
+                               pnacl_options, NULL, error_info)) {
     return false;
   }
   return ResolveURL(relative_url, full_url, error_info);
 }
 
 bool JsonManifest::ResolveURL(const nacl::string& relative_url,
                               nacl::string* full_url,
                               ErrorInfo* error_info) const {
   // The contents of the manifest are resolved relative to the manifest URL.
   CHECK(url_util_ != NULL);
   pp::Var resolved_url =
       url_util_->ResolveRelativeToURL(pp::Var(manifest_base_url_),
                                       relative_url);
   if (!resolved_url.is_string()) {
     error_info->SetReport(
         PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
         "could not resolve url '" + relative_url +
         "' relative to manifest base url '" + manifest_base_url_.c_str() +
         "'.");
     return false;
   }
   *full_url = resolved_url.AsString();
   return true;
 }
 
 bool JsonManifest::GetProgramURL(nacl::string* full_url,
                                  PnaclOptions* pnacl_options,
+                                 bool* nonsfi_enabled,
                                  ErrorInfo* error_info) const {
   if (full_url == NULL || pnacl_options == NULL || error_info == NULL)
     return false;
 
-  Json::Value program = dictionary_[kProgramKey];
+  const Json::Value& program = dictionary_[kProgramKey];
 
   nacl::string nexe_url;
   nacl::string error_string;
 
   if (!GetURLFromISADictionary(program,
                                kProgramKey,
                                &nexe_url,
                                pnacl_options,
+                               nonsfi_enabled,
                                error_info)) {
     return false;
   }
 
   return ResolveURL(nexe_url, full_url, error_info);
 }
 
 bool JsonManifest::GetFileKeys(std::set<nacl::string>* keys) const {
   if (!dictionary_.isMember(kFilesKey)) {
     // trivial success: no keys when there is no "files" section.
@@ skipping 50 matching lines @@
   if (!files.isMember(rest)) {
     error_info->SetReport(
         PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
         nacl::string("ResolveKey: no such \"files\" entry: ") + key);
     return false;
   }
   return GetKeyUrl(files, rest, full_url, pnacl_options, error_info);
 }
 
 }  // namespace plugin