[NaCl SDK] nacl_io: Fix real_node when dealing with a windows terminal

native_client_sdk/src/libraries/nacl_io/kernel_proxy.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 "nacl_io/kernel_proxy.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
@@ skipping 11 matching lines @@
 #include "nacl_io/filesystem.h"
 #include "nacl_io/fusefs/fuse_fs_factory.h"
 #include "nacl_io/host_resolver.h"
 #include "nacl_io/html5fs/html5_fs.h"
 #include "nacl_io/httpfs/http_fs.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/log.h"
 #include "nacl_io/memfs/mem_fs.h"
 #include "nacl_io/node.h"
+#include "nacl_io/osinttypes.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/osstat.h"
 #include "nacl_io/passthroughfs/passthrough_fs.h"
 #include "nacl_io/path.h"
 #include "nacl_io/pepper_interface.h"
 #include "nacl_io/pipe/pipe_node.h"
 #include "nacl_io/socket/tcp_node.h"
 #include "nacl_io/socket/udp_node.h"
 #include "nacl_io/stream/stream_fs.h"
@@ skipping 35 matching lines @@
 
   factories_["memfs"] = new TypedFsFactory<MemFs>;
   factories_["dev"] = new TypedFsFactory<DevFs>;
   factories_["html5fs"] = new TypedFsFactory<Html5Fs>;
   factories_["httpfs"] = new TypedFsFactory<HttpFs>;
   factories_["passthroughfs"] = new TypedFsFactory<PassthroughFs>;
 
   ScopedFilesystem root_fs;
   rtn = MountInternal("", "/", "passthroughfs", 0, NULL, false, &root_fs);
   if (rtn != 0)
-    assert(false);
+    return rtn;
 
   ScopedFilesystem fs;
   rtn = MountInternal("", "/dev", "dev", 0, NULL, false, &fs);
   if (rtn != 0)
-    assert(false);
+    return rtn;
   dev_fs_ = sdk_util::static_scoped_ref_cast<DevFs>(fs);
 
   // Create the filesystem nodes for / and /dev afterward. They can't be
   // created the normal way because the dev filesystem didn't exist yet.
   rtn = CreateFsNode(root_fs);
   if (rtn != 0)
-    assert(false);
+    return rtn;
 
   rtn = CreateFsNode(dev_fs_);
   if (rtn != 0)
-    assert(false);
+    return rtn;
 
   // Open the first three in order to get STDIN, STDOUT, STDERR
   int fd;
   fd = open("/dev/stdin", O_RDONLY, 0);
+  if (fd < 0) {
+    LOG_ERROR("failed to open /dev/stdin: %s", strerror(errno));
+    return errno;
+  }
   assert(fd == 0);
-  if (fd < 0)
-    rtn = errno;
 
   fd = open("/dev/stdout", O_WRONLY, 0);
+  if (fd < 0) {
+    LOG_ERROR("failed to open /dev/stdout: %s", strerror(errno));
+    return errno;
+  }
   assert(fd == 1);
-  if (fd < 0)
-    rtn = errno;
 
   fd = open("/dev/stderr", O_WRONLY, 0);
+  if (fd < 0) {
+    LOG_ERROR("failed to open /dev/sterr: %s", strerror(errno));
+    return errno;
+  }
   assert(fd == 2);
-  if (fd < 0)
-    rtn = errno;
 
 #ifdef PROVIDES_SOCKET_API
   host_resolver_.Init(ppapi_);
 #endif
 
   FsInitArgs args;
   args.dev = dev_++;
   args.ppapi = ppapi_;
   stream_fs_.reset(new StreamFs());
   int result = stream_fs_->Init(args);
   if (result != 0) {
-    assert(false);
-    rtn = result;
+    LOG_ERROR("initializing streamfs failed: %s", strerror(result));
+    return result;
   }
 
-  return rtn;
+  return 0;
 }
 
 bool KernelProxy::RegisterFsType(const char* fs_type,
                                  fuse_operations* fuse_ops) {
   FsFactoryMap_t::iterator iter = factories_.find(fs_type);
   if (iter != factories_.end())
     return false;
 
   factories_[fs_type] = new FuseFsFactory(fuse_ops);
   return true;
@@ skipping 982 matching lines @@
     case SIGCHLD:
     case SIGURG:
     case SIGFPE:
     case SIGILL:
     case SIGQUIT:
     case SIGSEGV:
     case SIGTRAP:
       if (action && action->sa_handler != SIG_DFL) {
         // Trying to set this action to anything other than SIG_DFL
         // is not yet supported.
-        LOG_TRACE("sigaction on signal %d != SIG_DFL not supported.", sig);
+        LOG_TRACE("sigaction on signal %d != SIG_DFL not supported.", signum);
         errno = EINVAL;
         return -1;
       }
 
       if (oaction) {
         memset(oaction, 0, sizeof(*oaction));
         oaction->sa_handler = SIG_DFL;
       }
       return 0;
 
@@ skipping 46 matching lines @@
 
   // NULL timeout signals wait forever.
   int ms_timeout = -1;
   if (timeout != NULL) {
     int64_t ms = timeout->tv_sec * 1000 + ((timeout->tv_usec + 500) / 1000);
 
     // If the timeout is invalid or too long (larger than signed 32 bit).
     if ((timeout->tv_sec < 0) || (timeout->tv_sec >= (INT_MAX / 1000)) ||
         (timeout->tv_usec < 0) || (timeout->tv_usec >= 1000000) || (ms < 0) ||
         (ms >= INT_MAX)) {
-      LOG_TRACE("Invalid timeout: tv_sec=%d tv_usec=%d.",
+      LOG_TRACE("Invalid timeout: tv_sec=%" PRIi64 " tv_usec=%ld.",
                 timeout->tv_sec,
                 timeout->tv_usec);
       errno = EINVAL;
       return -1;
     }
 
     ms_timeout = static_cast<int>(ms);
   }
 
   int result = poll(&pollfds[0], pollfds.size(), ms_timeout);
@@ skipping 568 matching lines @@
     errno = ENOTSOCK;
     return -1;
   }
 
   return 0;
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 }  // namespace_nacl_io