OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "ppapi/native_client/src/trusted/plugin/nacl_subprocess.h" | |
6 | |
7 #include <stdarg.h> | |
8 | |
9 #include <sstream> | |
10 | |
11 #include "native_client/src/shared/srpc/nacl_srpc.h" | |
12 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h" | |
13 #include "ppapi/native_client/src/trusted/plugin/srpc_params.h" | |
14 | |
15 namespace plugin { | |
16 | |
17 NaClSubprocess::NaClSubprocess(const std::string& description, | |
18 ServiceRuntime* service_runtime, | |
19 SrpcClient* srpc_client) | |
20 : description_(description), | |
21 service_runtime_(service_runtime), | |
22 srpc_client_(srpc_client) { | |
23 } | |
24 | |
25 std::string NaClSubprocess::detailed_description() const { | |
26 std::stringstream ss; | |
27 ss << description() | |
28 << "={ this=" << static_cast<const void*>(this) | |
29 << ", srpc_client=" << static_cast<void*>(srpc_client_.get()) | |
30 << ", service_runtime=" << static_cast<void*>(service_runtime_.get()) | |
31 << " }"; | |
32 return ss.str(); | |
33 } | |
34 | |
35 // Shutdown the socket connection and service runtime, in that order. | |
36 void NaClSubprocess::Shutdown() { | |
37 srpc_client_.reset(NULL); | |
38 if (service_runtime_.get() != NULL) { | |
39 service_runtime_->Shutdown(); | |
40 service_runtime_.reset(NULL); | |
41 } | |
42 } | |
43 | |
44 NaClSubprocess::~NaClSubprocess() { | |
45 Shutdown(); | |
46 } | |
47 | |
48 bool NaClSubprocess::StartSrpcServices() { | |
49 srpc_client_.reset(service_runtime_->SetupAppChannel()); | |
50 return NULL != srpc_client_.get(); | |
51 } | |
52 | |
53 bool NaClSubprocess::InvokeSrpcMethod(const std::string& method_name, | |
54 const std::string& input_signature, | |
55 SrpcParams* params, | |
56 ...) { | |
57 va_list vl; | |
58 va_start(vl, params); | |
59 bool result = VInvokeSrpcMethod(method_name, input_signature, params, vl); | |
60 va_end(vl); | |
61 return result; | |
62 } | |
63 | |
64 bool NaClSubprocess::VInvokeSrpcMethod(const std::string& method_name, | |
65 const std::string& input_signature, | |
66 SrpcParams* params, | |
67 va_list vl) { | |
68 if (NULL == srpc_client_.get()) { | |
69 PLUGIN_PRINTF(("VInvokeSrpcMethod (no srpc_client_)\n")); | |
70 return false; | |
71 } | |
72 if (!srpc_client_->HasMethod(method_name)) { | |
73 PLUGIN_PRINTF(("VInvokeSrpcMethod (no %s method found)\n", | |
74 method_name.c_str())); | |
75 return false; | |
76 } | |
77 if (!srpc_client_->InitParams(method_name, params)) { | |
78 PLUGIN_PRINTF(("VInvokeSrpcMethod (InitParams failed)\n")); | |
79 return false; | |
80 } | |
81 // Marshall inputs. | |
82 for (size_t i = 0; i < input_signature.length(); ++i) { | |
83 char c = input_signature[i]; | |
84 // Only handle the limited number of SRPC types used for PNaCl. | |
85 // Add more as needed. | |
86 switch (c) { | |
87 default: | |
88 PLUGIN_PRINTF(("PnaclSrpcLib::InvokeSrpcMethod unhandled type: %c\n", | |
89 c)); | |
90 return false; | |
91 case NACL_SRPC_ARG_TYPE_BOOL: { | |
92 int input = va_arg(vl, int); | |
93 params->ins()[i]->u.bval = input; | |
94 break; | |
95 } | |
96 case NACL_SRPC_ARG_TYPE_DOUBLE: { | |
97 double input = va_arg(vl, double); | |
98 params->ins()[i]->u.dval = input; | |
99 break; | |
100 } | |
101 case NACL_SRPC_ARG_TYPE_CHAR_ARRAY: { | |
102 // SrpcParam's destructor *should* free the allocated array | |
103 const char* orig_arr = va_arg(vl, const char*); | |
104 size_t len = va_arg(vl, size_t); | |
105 char* input = (char *)malloc(len); | |
106 if (!input) { | |
107 PLUGIN_PRINTF(("VInvokeSrpcMethod (allocation failure)\n")); | |
108 return false; | |
109 } | |
110 memcpy(input, orig_arr, len); | |
111 params->ins()[i]->arrays.carr = input; | |
112 params->ins()[i]->u.count = static_cast<nacl_abi_size_t>(len); | |
113 break; | |
114 } | |
115 case NACL_SRPC_ARG_TYPE_HANDLE: { | |
116 NaClSrpcImcDescType input = va_arg(vl, NaClSrpcImcDescType); | |
117 params->ins()[i]->u.hval = input; | |
118 break; | |
119 } | |
120 case NACL_SRPC_ARG_TYPE_INT: { | |
121 int32_t input = va_arg(vl, int32_t); | |
122 params->ins()[i]->u.ival = input; | |
123 break; | |
124 } | |
125 case NACL_SRPC_ARG_TYPE_LONG: { | |
126 int64_t input = va_arg(vl, int64_t); | |
127 params->ins()[i]->u.lval = input; | |
128 break; | |
129 } | |
130 case NACL_SRPC_ARG_TYPE_STRING: { | |
131 // SrpcParam's destructor *should* free the dup'ed string. | |
132 const char* orig_str = va_arg(vl, const char*); | |
133 char* input = strdup(orig_str); | |
134 if (!input) { | |
135 PLUGIN_PRINTF(("VInvokeSrpcMethod (allocation failure)\n")); | |
136 return false; | |
137 } | |
138 params->ins()[i]->arrays.str = input; | |
139 break; | |
140 } | |
141 } | |
142 } | |
143 return srpc_client_->Invoke(method_name, params); | |
144 } | |
145 | |
146 } // namespace plugin | |
OLD | NEW |