Simplify cli_main

ports/nacl-spawn/nacl_spawn.cc

 // Copyright (c) 2014 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.
 
 // Emulates spawning/waiting process by asking JavaScript to do so.
 
 // Include quoted spawn.h first so we can build in the presence of an installed
 // copy of nacl-spawn.
 #define IN_NACL_SPAWN_CC
 #include "spawn.h"
 
 #include "nacl_main.h"
 
 #include <netinet/in.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <libgen.h>
 #include <limits.h>
+#include <locale.h>
 #include <irt.h>
 #include <irt_dev.h>
 #include <netinet/in.h>
 #include <setjmp.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/mount.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "ppapi_simple/ps_instance.h"
 
 #include "library_dependencies.h"
 #include "path_util.h"
 
 
 extern char** environ;
-extern int nacl_spawn_pid;
-extern int nacl_spawn_ppid;
+
+int nacl_spawn_pid;
+int nacl_spawn_ppid;
 
 struct NaClSpawnReply {
   pthread_mutex_t mu;
   pthread_cond_t cond;
 
   pp::VarDictionary result;
 };
 
+
+// Get an environment variable as an int, or return -1 if the value cannot
+// be converted to an int.
+static int getenv_as_int(const char *env) {
+  const char* env_str = getenv(env);
+  if (!env_str) {
+    return -1;
+  }
+  errno = 0;
+  int env_int = strtol(env_str, NULL, 0);
+  if (errno) {
+    return -1;
+  }
+  return env_int;
+}
+
+static int mkdir_checked(const char* dir) {
+  int rtn =  mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO);
+  if (rtn != 0) {
+    fprintf(stderr, "mkdir '%s' failed: %s\n", dir, strerror(errno));
+  }
+  return rtn;
+}
+
+static int do_mount(const char *source, const char *target,
+                    const char *filesystemtype, unsigned long mountflags,
+                    const void *data) {
+  NACL_LOG("mount[%s] '%s' at '%s'\n", filesystemtype, source, target);
+  return mount(source, target, filesystemtype, mountflags, data);
+}
+
+void setup_env() {

[bradn, 2015/02/13 02:12:32]

How about something like setup_nacl_spawn_env, as this is in the global
namespace ?

[Sam Clegg, 2015/02/13 18:35:18]

I agree.   Perhaps prefix with _nacl?

So this function was moved to nacl-spawn so it that nacl-spawn could use the
static helper functions above?  Perhaps it would be better to leave the body of
this function in cli_main, but expose the above helpers via a header?  (with
some kind of prefix to avoid too much global namespace pollution?)

[gdeepti, 2015/02/13 21:43:55]

Apart from having access to the static helper functions above it was also moved
so that the mount functions can use SendRequest(pp::VarDictionary* req) to send
requests to Javascript. I can move the helper functions and the body back to
cli_main and just keep the mount specific functionality here. Would that be
better?   

[gdeepti, 2015/02/13 21:43:56]

Done.

+  umount("/");
+  do_mount("", "/", "memfs", 0, NULL);
+
+  // Setup common environment variables, but don't override those
+  // set already by ppapi_simple.
+  setenv("HOME", "/home/user", 0);
+  setenv("PATH", "/bin", 0);
+  setenv("USER", "user", 0);
+  setenv("LOGNAME", "user", 0);
+
+  const char* home = getenv("HOME");
+  mkdir_checked("/home");
+  mkdir_checked(home);
+  mkdir_checked("/tmp");
+  mkdir_checked("/bin");
+  mkdir_checked("/etc");
+  mkdir_checked("/mnt");
+  mkdir_checked("/mnt/http");
+  mkdir_checked("/mnt/html5");
+
+  const char* data_url = getenv("NACL_DATA_URL");
+  if (!data_url)
+    data_url = "./";
+  NACL_LOG("NACL_DATA_URL=%s\n", data_url);
+
+  const char* mount_flags = getenv("NACL_DATA_MOUNT_FLAGS");
+  if (!mount_flags)
+    mount_flags = "";
+  NACL_LOG("NACL_DATA_MOUNT_FLAGS=%s\n", mount_flags);
+
+  if (do_mount(data_url, "/mnt/http", "httpfs", 0, mount_flags) != 0) {
+    perror("mounting http filesystem at /mnt/http failed");
+  }
+
+  if (do_mount("/", "/mnt/html5", "html5fs", 0, "type=PERSISTENT") != 0) {
+    perror("Mounting HTML5 filesystem in /mnt/html5 failed");
+  } else {
+    mkdir("/mnt/html5/home", 0777);
+    struct stat st;
+    if (stat("/mnt/html5/home", &st) < 0 || !S_ISDIR(st.st_mode)) {
+      perror("Unable to create home directory in persistent storage");
+    } else {
+      if (do_mount("/home", home, "html5fs", 0, "type=PERSISTENT") != 0) {
+        fprintf(stderr, "Mounting HTML5 filesystem in %s failed.\n", home);
+      }
+    }
+  }
+
+  if (do_mount("/", "/tmp", "html5fs", 0, "type=TEMPORARY") != 0) {
+    perror("Mounting HTML5 filesystem in /tmp failed");
+  }
+
+  /* naclprocess.js sends the current working directory using this
+   * environment variable. */
+  const char* pwd = getenv("PWD");
+  if (pwd != NULL) {
+    if (chdir(pwd)) {
+      fprintf(stderr, "chdir() to %s failed: %s\n", pwd, strerror(errno));
+    }
+  }
+
+  // Tell the NaCl architecture to /etc/bashrc of mingn.
+#if defined(__x86_64__)
+  static const char kNaClArch[] = "x86_64";
+#elif defined(__i686__)
+  static const char kNaClArch[] = "i686";
+#elif defined(__arm__)
+  static const char kNaClArch[] = "arm";
+#elif defined(__pnacl__)
+  static const char kNaClArch[] = "pnacl";
+#else
+# error "Unknown architecture"
+#endif
+  // Set NACL_ARCH with a guess if not set (0 == set if not already).
+  setenv("NACL_ARCH", kNaClArch, 0);
+  // Set NACL_BOOT_ARCH if not inherited from a parent (0 == set if not already
+  // set). This will let us prefer PNaCl if we started with PNaCl (for tests
+  // mainly).
+  setenv("NACL_BOOT_ARCH", kNaClArch, 0);
+
+  setlocale(LC_CTYPE, "");
+
+  nacl_spawn_pid = getenv_as_int("NACL_PID");
+  nacl_spawn_ppid = getenv_as_int("NACL_PPID");
+}
+
 static std::string GetCwd() {
   char cwd[PATH_MAX] = ".";
   if (!getcwd(cwd, PATH_MAX)) {
     NACL_LOG("getcwd failed: %s\n", strerror(errno));
     assert(0);
   }
   return cwd;
 }
 
 static std::string GetAbsPath(const std::string& path) {
@@ skipping 788 matching lines @@
   return spawnve_impl(P_OVERLAY, path, argv, envp);
 }
 
 int execlpe(const char *path, const char *arg, ...) {  /* char* const envp[] */
   VARG_TO_ARGV_ENVP;
   // TODO(bradnelson): Limit path resolution to 'p' variants.
   return spawnve_impl(P_OVERLAY, path, argv, envp);
 }
 
 };  // extern "C"