Added NaCl proxy for TCP/UDP

ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc

Index: ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc
diff --git a/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7fa07fca626b88d1421d4ebb96e7787ee2196134
--- /dev/null
+++ b/ppapi/native_client/src/shared/ppapi_proxy/browser_ppb_tcp_socket_private_rpc_server.cc
@@ -0,0 +1,307 @@
+// Copyright (c) 2011 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.

[polina, 2011/11/18 09:52:10]

quick header comment?

[ygorshenin, 2011/11/21 14:13:33]

Done.

+
+#include <string.h>
+#include <limits>
+
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/shared/ppapi_proxy/browser_callback.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+#include "srpcgen/ppb_rpc.h"
+
+using ppapi_proxy::DebugPrintf;
+using ppapi_proxy::DeleteRemoteCallbackInfo;
+using ppapi_proxy::MakeRemoteCompletionCallback;
+using ppapi_proxy::PPBTCPSocketPrivateInterface;
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_Create(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Instance instance,
+    // output
+    PP_Resource* resource) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  *resource = PPBTCPSocketPrivateInterface()->Create(instance);
+
+  DebugPrintf("PPB_TCPSocket_Private::Create: resource=%"NACL_PRIu32"\n",
+              *resource);
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_IsTCPSocket(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource resource,
+    // output
+    int32_t* is_tcp_socket_private) {

[polina, 2011/11/18 09:52:10]

s/private//

[ygorshenin, 2011/11/21 14:13:33]

Done.

+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  PP_Bool pp_success =
+      PPBTCPSocketPrivateInterface()->IsTCPSocket(resource);
+
+  DebugPrintf("PPB_TCPSocket_Private::IsTCPSocket: pp_success=%d\n",
+              pp_success);
+
+  *is_tcp_socket_private = (pp_success == PP_TRUE);
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_Connect(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    nacl_abi_size_t host_bytes, char* host,

[polina, 2011/11/18 09:52:10]

can't you just use "char*" (string in .srpc)?

[ygorshenin, 2011/11/21 14:13:33]

Done.

+    int32_t port,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  UNREFERENCED_PARAMETER(host_bytes);
+
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->Connect(
+      tcp_socket,
+      host,
+      port,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Connect: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)  // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_ConnectWithNetAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    nacl_abi_size_t addr_bytes, char* addr,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+  CHECK(addr_bytes == sizeof(PP_NetAddress_Private));

[polina, 2011/11/18 09:52:10]

we usually just return in such cases, I think

[ygorshenin, 2011/11/21 14:13:33]

Done.

[polina, 2011/11/28 07:55:45]

You missed several other such CHECKs in this file.

[ygorshenin, 2011/11/28 16:44:10]

Done.

+
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->ConnectWithNetAddress(
+      tcp_socket,
+      reinterpret_cast<const struct PP_NetAddress_Private*>(addr),

[polina, 2011/11/18 09:52:10]

"const" is not necessary here, is it?

[ygorshenin, 2011/11/21 14:13:33]

Done.

+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::ConnectWithNetAddress: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING)  // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_GetLocalAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    // output
+    nacl_abi_size_t* local_addr_bytes, char* local_addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Bool pp_success =
+      PPBTCPSocketPrivateInterface()->GetLocalAddress(
+          tcp_socket,
+          reinterpret_cast<struct PP_NetAddress_Private*>(local_addr));
+
+  DebugPrintf("PPB_TCPSocket_Private::GetLocalAddress: pp_success=%d\n",
+              pp_success);
+
+  *local_addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));

[polina, 2011/11/18 09:52:10]

Shouldn't this be a check in the beginning of the function? 

[ygorshenin, 2011/11/21 14:13:33]

Done.

+  *success = (pp_success == PP_TRUE);
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_GetRemoteAddress(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    // output
+    nacl_abi_size_t* remote_addr_bytes, char* remote_addr,
+    int32_t* success) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_Bool pp_success =
+      PPBTCPSocketPrivateInterface()->GetRemoteAddress(
+          tcp_socket,
+          reinterpret_cast<struct PP_NetAddress_Private*>(remote_addr));
+
+  DebugPrintf("PPB_TCPSocket_Private::GetRemoteAddress: pp_success=%d\n",
+              pp_success);
+
+  *remote_addr_bytes =
+      static_cast<nacl_abi_size_t>(sizeof(PP_NetAddress_Private));

[polina, 2011/11/18 09:52:10]

same comment as above

[ygorshenin, 2011/11/21 14:13:33]

Done.

+  *success = (pp_success == PP_TRUE);
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_SSLHandshake(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket,
+    nacl_abi_size_t server_name_bytes, char* server_name,

[polina, 2011/11/18 09:52:10]

same comment as above about string .srpc type

[ygorshenin, 2011/11/21 14:13:33]

Done.

+    int32_t server_port,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error) {
+    UNREFERENCED_PARAMETER(server_name_bytes);
+
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback = MakeRemoteCompletionCallback(
+      rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error = PPBTCPSocketPrivateInterface()->SSLHandshake(
+      tcp_socket,
+      server_name,
+      server_port,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::SSLHandshake: "
+              "pp_error=%"NACL_PRId32"\n", *pp_error);
+
+  if (*pp_error != PP_OK_COMPLETIONPENDING) // Async error.
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_Read(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure *done,
+    // input
+    PP_Resource tcp_socket,
+    int32_t bytes_to_read,
+    int32_t callback_id,
+    // output
+    nacl_abi_size_t* buffer_bytes, char* buffer,
+    int32_t* pp_error_or_bytes) {
+  CHECK(*buffer_bytes <=
+        static_cast<nacl_abi_size_t>(std::numeric_limits<int32_t>::max()));

[polina, 2011/11/18 09:52:10]

chrome implementation should be validating the number of bytes, no?

[ygorshenin, 2011/11/21 14:13:33]

Done.

+  CHECK(*buffer_bytes == static_cast<nacl_abi_size_t>(bytes_to_read));
+
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  char* callback_buffer = NULL;
+  PP_CompletionCallback remote_callback =
+      MakeRemoteCompletionCallback(rpc->channel, callback_id, bytes_to_read,
+                                   &callback_buffer);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes = PPBTCPSocketPrivateInterface()->Read(
+      tcp_socket,
+      callback_buffer,
+      bytes_to_read,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Read: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  CHECK(*pp_error_or_bytes <= bytes_to_read);
+
+  if (*pp_error_or_bytes > 0) {  // Bytes read into |callback_buffer|.
+    // No callback scheduled.
+    CHECK(static_cast<nacl_abi_size_t>(*pp_error_or_bytes) <= *buffer_bytes);
+    *buffer_bytes = static_cast<nacl_abi_size_t>(*pp_error_or_bytes);
+    memcpy(buffer, callback_buffer, *buffer_bytes);
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING) {  // Async error.
+    // No callback scheduled.
+    *buffer_bytes = 0;
+    DeleteRemoteCallbackInfo(remote_callback);
+  } else {
+    // Callback scheduled.
+    *buffer_bytes = 0;
+  }
+
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_Write(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    PP_Resource tcp_socket,
+    // input
+    nacl_abi_size_t buffer_bytes, char* buffer,
+    int32_t bytes_to_write,
+    int32_t callback_id,
+    // output
+    int32_t* pp_error_or_bytes) {
+  CHECK(buffer_bytes <=
+        static_cast<nacl_abi_size_t>(std::numeric_limits<int32_t>::max()));
+  CHECK(static_cast<nacl_abi_size_t>(bytes_to_write) <= buffer_bytes);
+
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+
+  PP_CompletionCallback remote_callback = MakeRemoteCompletionCallback(
+      rpc->channel, callback_id);
+  if (NULL == remote_callback.func)
+    return;
+
+  *pp_error_or_bytes = PPBTCPSocketPrivateInterface()->Write(
+      tcp_socket,
+      buffer,
+      bytes_to_write,
+      remote_callback);
+
+  DebugPrintf("PPB_TCPSocket_Private::Write: "
+              "pp_error_or_bytes=%"NACL_PRId32"\n", *pp_error_or_bytes);
+
+  // Bytes must be written asynchronously.
+  if (*pp_error_or_bytes != PP_OK_COMPLETIONPENDING)
+    DeleteRemoteCallbackInfo(remote_callback);
+  rpc->result = NACL_SRPC_RESULT_OK;
+}
+
+void Ppb_TCPSocketPrivateServer::PPB_TCPSocket_Private_Disconnect(
+    NaClSrpcRpc* rpc,
+    NaClSrpcClosure* done,
+    // input
+    PP_Resource tcp_socket) {
+  NaClSrpcClosureRunner runner(done);
+  rpc->result = NACL_SRPC_RESULT_OK;
+
+  DebugPrintf("PPB_TCPSocket_Private::Disconnect: tcp_socket=%"NACL_PRIu32"\n",
+              tcp_socket);
+
+  PPBTCPSocketPrivateInterface()->Disconnect(tcp_socket);
+}