Issue 1092005

src/trusted/plugin/srpc/plugin.cc

 /*
  * Copyright 2008 The Native Client 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 "native_client/src/trusted/plugin/srpc/plugin.h"
 
 #include <assert.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include <list>
 #include <string>
 
 #include "native_client/src/include/portability_string.h"
 
 #include "native_client/src/trusted/desc/nacl_desc_conn_cap.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 
 #include "native_client/src/trusted/plugin/srpc/browser_interface.h"
 #include "native_client/src/trusted/plugin/srpc/srpc.h"
 #include "native_client/src/trusted/plugin/srpc/scriptable_handle.h"
@@ skipping 22 matching lines @@
       "__defaultSocketAddress", METHOD_CALL, "", "h");
   AddMethodToMap(NullPluginMethod, "__nullPluginMethod", METHOD_CALL, "s", "i");
   AddMethodToMap(GetHeightProperty, "height", PROPERTY_GET, "", "i");
   AddMethodToMap(SetHeightProperty, "height", PROPERTY_SET, "i", "");
   AddMethodToMap(GetWidthProperty, "width", PROPERTY_GET, "", "i");
   AddMethodToMap(SetWidthProperty, "width", PROPERTY_SET, "i", "");
   AddMethodToMap(GetModuleReadyProperty,
       "__moduleReady", PROPERTY_GET, "", "i");
   AddMethodToMap(SetModuleReadyProperty,
       "__moduleReady", PROPERTY_SET, "i", "");
-  AddMethodToMap(GetSrcProperty,
-      "src", PROPERTY_GET, "", "s");
-  AddMethodToMap(SetSrcProperty,
-      "src", PROPERTY_SET, "s", "");
+  AddMethodToMap(GetNexeProperty,
+      "nexe", PROPERTY_GET, "", "s");
+  AddMethodToMap(SetNexeProperty,
+      "nexe", PROPERTY_SET, "s", "");
   AddMethodToMap(GetVideoUpdateModeProperty,
       "videoUpdateMode", PROPERTY_GET, "", "i");
   AddMethodToMap(SetVideoUpdateModeProperty,
       "videoUpdateMode", PROPERTY_SET, "i", "");
 }
 
 bool Plugin::HasMethodEx(uintptr_t method_id, CallType call_type) {
   // The requested method is not implemented by the Plugin,
   // maybe it is implemented by the NaCl module
   if (socket_) {
@@ skipping 152 matching lines @@
     }
   return true;
 }
 
 bool Plugin::SetModuleReadyProperty(void *obj, SrpcParams *params) {
   UNREFERENCED_PARAMETER(obj);
   params->SetExceptionInfo("__moduleReady is a read-only property");
   return false;
 }
 
-bool Plugin::GetSrcProperty(void *obj, SrpcParams *params) {
+bool Plugin::GetNexeProperty(void *obj, SrpcParams *params) {
   Plugin *plugin = reinterpret_cast<Plugin*>(obj);
   params->outs[0]->u.sval =
     PortablePluginInterface::MemAllocStrdup(plugin->local_url_);
   return true;
 }
 
-bool Plugin::SetSrcProperty(void *obj, SrpcParams *params) {
+// TODO(adonovan): Expose this as a user configuration option.
+static const enum { BEFORE_ARCH, AFTER_ARCH, NEVER } kTryPNaCl = BEFORE_ARCH;

[bsy, 2010/03/23 21:20:37]

might want ALWAYS/ONLY, for those people who prefer to ensure that the web stay
platform neutral. :-)

+// TODO(adonovan): Compatibility hack.  Allows x86 bigots to avoid
+// renaming their executables.  Not for release.
+static const bool kTryWithoutArchitecture = true;
+
+// Given a base nexe URL (architecture unspecified), computes the list
+// of URLs to try, e.g.:
+//
+//   <base>-armv7.nexe
+//   <base>.pnacl
+//   <base>.nexe
+//
+// The order and elements of the returned list depend on the options
+// above.
+static void GetNexeURLs(const std::string& base_url,
+                        std::list<std::string> *urls) {
+  // Issue a helpful warning, since we're making an incompatible change.
+  unsigned int idx = base_url.find(".nexe");
+  if (idx != std::string::npos && idx + 5 == base_url.size()) {
+    dprintf(("embed.nexe = %s; \".nexe\" suffix should be omitted",
+             base_url.c_str()));
+  }
+
+  if (kTryPNaCl == BEFORE_ARCH) urls->push_back(base_url + ".pnacl");
+
+  // TODO(adonovan): is there a better macro for us to use?
+  urls->push_back(base_url +
+#if NACL_TARGET_ARCH == x86 && NACL_TARGET_SUBARCH == 64
+      "-x86-64.nexe"

[bsy, 2010/03/23 21:20:37]

not sure i like '-' as separator, esp since tools that parse filenames will have
to understand that in this case, it's the 2nd '-' that is the actual separator.

i actually prefer the subdirectory approach, since in the limit, data files may
also be architecture dependent, and this turns into a general PATH-like search
mechanism.  ditto for dynamic library loading -- the app may want to load a
dynamic library, but should the user be able to specify whether the pnacl
version is tried first?  last?  etc.

+#elif NACL_TARGET_ARCH == x86 && NACL_TARGET_SUBARCH == 32
+      "-x86-32.nexe"
+#elif NACL_TARGET_ARCH == arm
+      "-arm.nexe"
+  // FIXME(adonovan): Shouldn't we be more specific than just "ARM",
+  // We should probably be as specific as uname -m, e.g. "armv7l"?
+#else
+#error "Unknown NACL_TARGET_ARCH/SUBARCH."
+#endif
+                  );
+  if (kTryPNaCl == AFTER_ARCH) urls->push_back(base_url + ".pnacl");
+  if (kTryWithoutArchitecture) urls->push_back(base_url);
+}
+
+bool Plugin::SetNexeProperty(void *obj, SrpcParams *params) {
   Plugin *plugin = reinterpret_cast<Plugin*>(obj);
   if (NULL != plugin->service_runtime_interface_) {
     dprintf(("Plugin::SetProperty: unloading previous\n"));
     // Plugin owns socket_address_ and socket_, so when we change to a new
     // socket we need to give up ownership of the old one.
     plugin->socket_address_->Unref();
     plugin->socket_address_ = NULL;
     plugin->socket_->Unref();
     plugin->socket_ = NULL;
     plugin->service_runtime_interface_ = NULL;
   }
   // Load the new module if the origin of the page is valid.
   const char* url = params->ins[0]->u.sval;
-  dprintf(("Plugin::SetProperty src = '%s'\n", url));
-  LoadNaClAppNotify* callback = new(std::nothrow) LoadNaClAppNotify(plugin,
-                                                                    url);
+  dprintf(("Plugin::SetProperty nexe = '%s'\n", url));
+  std::list<std::string> urls;
+  GetNexeURLs(url, &urls);
+  LoadNaClAppNotify* callback =
+      new(std::nothrow) LoadNaClAppNotify(plugin, urls);
   if ((NULL == callback) || (!callback->StartDownload())) {
     dprintf(("Failed to load URL to local file.\n"));
     // callback is always deleted in URLNotify
+    // FIXME(adonovan): it is?  even when StartDownload failed?
+    // FIXME(adonovan): shouldn't this result in the onfail handler
+    // getting called?

[bsy, 2010/03/23 21:20:37]

i think StartDownload always fails a download by calling URLNotify, since
originally this was single threaded and all that's done is to put something on a
work queue -- possibly having initiated the DNS lookup for the URL via the dns
helper process.  not sure what the actual reasons why StartDownload would fail
here are.

though perhaps the oom case probably should result in the on fail handlers being
called.

[adonovan, 2010/03/25 00:44:05]

You're right, the notification always occurs, even on failure.
Perhaps, but it doesn't seem particularly bad.  

     return false;
   }
   return true;
 }
 
 bool Plugin::GetVideoUpdateModeProperty(void *obj, SrpcParams *params) {
   Plugin *plugin = reinterpret_cast<Plugin*>(obj);
   params->outs[0]->u.ival = plugin->video_update_mode_;
   return true;
 }
@@ skipping 207 matching lines @@
 
 Plugin* Plugin::GetPlugin() {
   return this;
 }
 
 
 PLUGIN_JMPBUF Plugin::loader_env;
 
 
 }  // namespace nacl_srpc