Make M-x shell work in emacs.

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"
@@ skipping 336 matching lines @@
     } else if (S_ISDIR(st.st_mode)) {
       // TODO(bradnelson): Land nacl_io ioctl to support this.
     } else if (S_ISCHR(st.st_mode)) {
       // Unsupported.
     } else if (S_ISBLK(st.st_mode)) {
       // Unsupported.
     } else if (S_ISFIFO(st.st_mode)) {
       char entry[100];
       snprintf(entry, sizeof entry,
           "NACL_SPAWN_FD_SETUP_%d=pipe:%d:%d:%d", count++, fd,
-          static_cast<int>(st.st_ino), st.st_rdev == O_WRONLY);
+          static_cast<int>(st.st_ino),
+          (st.st_rdev & O_WRONLY) == O_WRONLY);
       nspawn_array_appendstring(envs_var, entry);
     } else if (S_ISLNK(st.st_mode)) {
       // Unsupported.
     } else if (S_ISSOCK(st.st_mode)) {
       // Unsupported.
     }
   }
   return 0;
 }
 
@@ skipping 314 matching lines @@
     memcpy(*data, result, result_len);
     (*data)[result_len] = '\0';
   }
   nspawn_var_release(result_var);
   nspawn_var_release(result_dict_var);
 }
 
 // Create a javascript pipe. pipefd[0] will be the read end of the pipe
 // and pipefd[1] the write end of the pipe.
 int nacl_spawn_pipe(int pipefd[2]) {
+  return nacl_spawn_pipe_flags(0, pipefd);
+}
+
+// Same as above with flags.
+int nacl_spawn_pipe_flags(int flags, int pipefd[2]) {
   if (pipefd == NULL) {
     errno = EFAULT;
     return -1;
   }
 
   struct PP_Var req_var = nspawn_dict_create();
   nspawn_dict_setstring(req_var, "command", "nacl_apipe");
 
   struct PP_Var result_var = nspawn_send_request(req_var);
   int id = nspawn_dict_getint(result_var, "pipe_id");
   nspawn_var_release(result_var);
 
   int read_fd;
   int write_fd;
   char path[100];
   sprintf(path, "/apipe/%d", id);
-  read_fd = open(path, O_RDONLY);
-  write_fd = open(path, O_WRONLY);
+  // Filter out O_RDONLY + O_WRONLY

[bsy_cr, 2016/03/03 18:43:33]

sorry about the drive-by.

filtering out should be

flags &= ~(O_RDONLY | O_WRONLY);

if those are the only two access flags that might matter -- and POSIX does not
guarantee their values -- are what we care about.  however, the correct way to
do this is to use O_ACCMODE, e.g.,

flags &= ~O_ACCMODE;

to remove all access mode flags.  currently we remove O_CREAT, O_EXCL, O_TRUNC,
and O_APPEND (plus possibly others -- i forget exactly which open flags are
supported), most of which shouldn't apply to pipes (i assume these are named
pipes?).  what flags did we want to retain?

if it's really the comment that is misleading, and those are the only access
flags that we want to retain, then we'd want to do

flags &= O_ACCMODE;

and then to test if what remains is one of O_RDONLY or O_WRONLY.

[bradn, 2016/03/03 19:11:40]

Thanks, that actually caught a mistake!

Good to know about O_ACCMODE, but actually, come to think of it, the only flag
supported at the moment is O_NONBLOCK.
I've added an assert instead.

Also, added a test that O_NONBLOCK works. While emacs behaves incorrectly
without O_NONBLOCK, I have to do a package install + check manually (downside of
a real package manager...). So I had not checked things were still working when
I added the "filtering" of the flags.

Thanks Bennett!

+  flags &= O_RDONLY | O_WRONLY;
+  read_fd = open(path, O_RDONLY | flags);
+  write_fd = open(path, O_WRONLY | flags);
   if (read_fd < 0 || write_fd < 0) {
     if (read_fd >= 0) {
       close(read_fd);
     }
     if (write_fd >= 0) {
       close(write_fd);
     }
     return -1;
   }
   pipefd[0] = read_fd;
@@ skipping 105 matching lines @@
 }
 
 int execlpe(const char *path, const char *arg, ...) {  /* char* const envp[] */
   NSPAWN_LOG("execlpe: %s", path);
   VARG_TO_ARGV_ENVP;
   // TODO(bradnelson): Limit path resolution to 'p' variants.
   return spawnve_impl(P_OVERLAY, path, argv, envp);
 }
 
 };  // extern "C"