[NaCl SDK] Remove use of TIOCNACLINPUT from nacl_io/ppapi_simple.

native_client_sdk/src/libraries/nacl_io/devfs/tty_node.cc

 // Copyright 2013 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/devfs/tty_node.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 
 #include <algorithm>
 
 #include "nacl_io/filesystem.h"
 #include "nacl_io/ioctl.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_intercept.h"
+#include "nacl_io/log.h"
 #include "nacl_io/pepper_interface.h"
 #include "sdk_util/auto_lock.h"
 
 #define CHECK_LFLAG(TERMIOS, FLAG) (TERMIOS.c_lflag& FLAG)
 
 #define IS_ECHO CHECK_LFLAG(termios_, ECHO)
 #define IS_ECHOE CHECK_LFLAG(termios_, ECHOE)
 #define IS_ECHONL CHECK_LFLAG(termios_, ECHONL)
 #define IS_ECHOCTL CHECK_LFLAG(termios_, ECHOCTL)
 #define IS_ICANON CHECK_LFLAG(termios_, ICANON)
@@ skipping 129 matching lines @@
   Error error = Write(data, string, count, &wrote);
   if (error != 0 || wrote != count) {
     // TOOD(sbc): Do something more useful in response to a
     // failure to echo.
     return error;
   }
 
   return 0;
 }
 
-Error TtyNode::ProcessInput(struct tioc_nacl_input_string* message) {
+Error TtyNode::ProcessInput(PP_Var message) {
+  if (message.type != PP_VARTYPE_ARRAY_BUFFER) {
+    LOG_ERROR("ProcessInput: expected ArrayBuffer but got %d.", message.type);
+    return EINVAL;
+  }
+
+  PepperInterface* ppapi = filesystem_->ppapi();
+  if (!ppapi) {
+    LOG_ERROR("ProcessInput: ppapi is NULL.");
+    return EINVAL;
+  }
+
+  VarArrayBufferInterface* buffer_iface = ppapi->GetVarArrayBufferInterface();
+  if (!buffer_iface) {
+    LOG_ERROR("ProcessInput: ArrayBuffer interface pointer is NULL.");
+    return EINVAL;
+  }

[Sam Clegg, 2014/06/17 22:29:28]

I hate to do this to you now, but I think the actual payload sould probably just
continue to be a string.  I spoke to rginda about this and it looks like hterm
should be sending utf8 strings.

Also, keeping it as a string will keep the JS side a little more simple, right?

[binji, 2014/06/17 22:55:22]

Done.

+
+  uint32_t num_bytes;
+  if (buffer_iface->ByteLength(message, &num_bytes) != PP_TRUE) {
+    LOG_ERROR("ProcessInput: unable to get ArrayBuffer length.");
+    return EINVAL;
+  }
+
+  const char* buffer = static_cast<const char*>(buffer_iface->Map(message));
+  Error error = ProcessInput(buffer, num_bytes);
+  buffer_iface->Unmap(message);
+  return error;
+}
+
+Error TtyNode::ProcessInput(const char* buffer, size_t num_bytes) {
   AUTO_LOCK(emitter_->GetLock())
 
-  const char* buffer = message->buffer;
-  size_t num_bytes = message->length;
-
   for (size_t i = 0; i < num_bytes; i++) {
     char c = buffer[i];
     // Transform characters according to input flags.
     if (c == '\r') {
       if (termios_.c_iflag & IGNCR)
         continue;
       if (termios_.c_iflag & ICRNL)
         c = '\n';
     } else if (c == '\n') {
       if (termios_.c_iflag & INLCR)
@@ skipping 55 matching lines @@
       AUTO_LOCK(output_lock_);
       if (arg == NULL) {
         output_handler_.handler = NULL;
         return 0;
       }
       if (output_handler_.handler != NULL)
         return EALREADY;
       output_handler_ = *arg;
       return 0;
     }
-    case TIOCNACLINPUT: {
-      // This ioctl is used to deliver data from the user to this tty node's
-      // input buffer.
-      struct tioc_nacl_input_string* message =
-          va_arg(args, struct tioc_nacl_input_string*);
-      return ProcessInput(message);
+    case NACL_IOC_HANDLEMESSAGE: {
+      struct PP_Var* message = va_arg(args, struct PP_Var*);
+      return ProcessInput(*message);
     }
     case TIOCSWINSZ: {
       struct winsize* size = va_arg(args, struct winsize*);
       {
         AUTO_LOCK(node_lock_);
         if (rows_ == size->ws_row && cols_ == size->ws_col)
           return 0;
         rows_ = size->ws_row;
         cols_ = size->ws_col;
       }
       ki_kill(getpid(), SIGWINCH);
       {
         // Wake up any thread waiting on Read with POLLERR then immediate
         // clear it to signal EINTR.
         AUTO_LOCK(emitter_->GetLock())
         emitter_->RaiseEvents_Locked(POLLERR);
         emitter_->ClearEvents_Locked(POLLERR);
       }
       return 0;
     }
     case TIOCGWINSZ: {
       struct winsize* size = va_arg(args, struct winsize*);
       size->ws_row = rows_;
       size->ws_col = cols_;
       return 0;
     }
+    default: {
+      LOG_ERROR("TtyNode:VIoctl: Unknown request: %#x", request);
+    }
   }
 
   return EINVAL;
 }
 
 Error TtyNode::Tcgetattr(struct termios* termios_p) {
   AUTO_LOCK(node_lock_);
   *termios_p = termios_;
   return 0;
 }
 
 Error TtyNode::Tcsetattr(int optional_actions,
                          const struct termios* termios_p) {
   AUTO_LOCK(node_lock_);
   termios_ = *termios_p;
   return 0;
 }
 
 }  // namespace nacl_io