Extend IRT with nacl_irt_resource_open interface

tests/manifest_file/irt_manifest_file_test.cc

+/*
+ * Copyright (c) 2011 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.
+ */
+
+//
+// Post-message based test for manifest file open.
+//
+
+#include <stdio.h>
+#include <string.h>
+
+#include <string>
+
+#include "native_client/src/include/elf32.h"
+#include "native_client/src/include/elf_auxv.h"
+
+#include "native_client/src/shared/ppapi_proxy/ppruntime.h"
+#include "native_client/src/untrusted/irt/irt.h"
+
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/var.h"
+
+/*
+ * TODO(mcgrathr): This extremely stupid function should not exist.
+ * If the startup calling sequence were sane, this would be done
+ * someplace that has the initial pointer locally rather than stealing
+ * it from environ.
+ * See http://code.google.com/p/nativeclient/issues/detail?id=651
+ */
+static Elf32_auxv_t *find_auxv(void) {
+  /*
+   * This presumes environ has its startup-time value on the stack.
+   */
+  char **ep = environ;
+  while (*ep != NULL)
+    ++ep;
+  return (Elf32_auxv_t *) (ep + 1);
+}
+
+/*
+ * Scan the auxv for AT_SYSINFO, which is the pointer to the IRT query function.
+ * TODO(mcgrathr): Could get this from __nacl_irt_query, where the libnacl
+ * startup code stored it, but that would have to be also added as part of
+ * the glibc ABI.
+ */
+static TYPE_nacl_irt_query grok_auxv(const Elf32_auxv_t *auxv) {
+  const Elf32_auxv_t *av;
+  for (av = auxv; av->a_type != AT_NULL; ++av) {
+    if (av->a_type == AT_SYSINFO)
+      return (TYPE_nacl_irt_query) av->a_un.a_val;
+  }
+  return NULL;
+}
+
+std::string str;
+
+void load_manifest(TYPE_nacl_irt_query *query_func) {
+  struct nacl_irt_manifest_open nacl_irt_manifest_open;
+  printf("load_manifest\n");
+  if (sizeof(nacl_irt_manifest_open) !=
+      (*query_func)(
+          NACL_IRT_MANIFEST_OPEN_v0_0,
+          &nacl_irt_manifest_open,
+          sizeof(nacl_irt_manifest_open))) {
+    printf("irt manifest api not found\n");
+    return;
+  }
+  int desc;
+  desc = nacl_irt_manifest_open.open_file_in_manifest("files/test_file");
+  if (-1 == desc) {
+    str = "Invalid file descriptor\n";
+    printf("%s", str.c_str());
+    return;
+  }
+
+  str = "File Contents:\n";
+
+  FILE *iob = fdopen(desc, "r");
+  char buffer[4096];
+  while (fgets(buffer, sizeof buffer, iob) != NULL) {
+    // NB: fgets does not discard the newline nor any carriage return
+    // character before that.
+    //
+    // Note that CR LF is the default end-of-line style for Windows.

[pasko-google - do not use, 2011/08/15 10:35:09]

This is too complex and tied to our build-try-commit quirks on windows.  It
should be simpler to just build a special nexe for loading (but not for running)
with a magic symbol exported, the test would just verify that this magic symbol
exists by reading through the file.

or just add a comment in the manifest, put a magic there compare only the first
line, that would be enough of a test

+    // Furthermore, when the test_file (input data, which happens to
+    // be the nmf file) is initially created in a change list, the
+    // patch is sent to our try bots as text.  This means that when
+    // the file arrives, it has CR LF endings instead of the original
+    // LF line endings.  Since the expected or golden data is
+    // (manually) encoded in the HTML file's JavaScript, there will be
+    // a mismatch.  After submission, the svn property svn:eol-style
+    // will be set to LF, so a clean check out should have LF and not
+    // CR LF endings, and the tests will pass without CR removal.
+    // However -- and there's always a however in long discourses --
+    // if the nmf file is edited, say, because the test is being
+    // modified, and the modification is being done on a Windows
+    // machine, then it is likely that the editor used by the
+    // programmer will convert the file to CR LF endings.  Which,
+    // unfortunatly, implies that the test will mysteriously fail
+    // again.
+    //
+    // To defend against such nonsense, we weaken the test slighty,
+    // and just strip the CR if it is present.
+    int len = strlen(buffer);
+    if (len >= 2 && buffer[len-1] == '\n' && buffer[len-2] == '\r') {
+      buffer[len-2] = '\n';
+      buffer[len-1] = '\0';
+    }
+    str += buffer;
+  }
+  printf("file loaded: %s\n", str.c_str());
+  fclose(iob);  // closed desc
+  return;
+}
+
+class TestInstance : public pp::Instance {
+ public:
+  explicit TestInstance(PP_Instance instance) : pp::Instance(instance) {}
+  virtual ~TestInstance() {}
+  virtual void HandleMessage(const pp::Var& var_message) {
+    if (!var_message.is_string()) {
+      return;
+    }
+    if (var_message.AsString() != "hello") {
+      return;
+    }
+    pp::Var reply = pp::Var(str);
+    PostMessage(reply);
+  }
+};
+
+class TestModule : public pp::Module {
+ public:
+  TestModule() : pp::Module() {}
+  virtual ~TestModule() {}
+
+  virtual pp::Instance* CreateInstance(PP_Instance instance) {
+    return new TestInstance(instance);
+  }
+};
+
+namespace pp {
+Module* CreateModule() {
+  return new TestModule();
+}
+}
+
+int main() {
+  TYPE_nacl_irt_query query_func = grok_auxv(find_auxv());

[Roland McGrath, 2011/08/12 16:44:56]

Don't do all the auxv grovelling here.  You can just use __nacl_irt_query. 
Better yet, we should add a public interface for doing the query, that both
newlib/libnacl and glibc implement.

[halyavin, 2011/08/15 10:35:52]

Done.

+  printf("main\n");
+  if (NULL == query_func)
+    printf("PpapiPluginStart: No AT_SYSINFO item found in auxv, "
+           "so cannot start PPAPI.  Is the IRT library not present?\n");
+  load_manifest(&query_func);
+  return PpapiPluginMain();
+}
+