blob: 593fe94dc8494b44408eec7ffa912d857996f901 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/*
* 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 "ppapi/native_client/src/trusted/plugin/srpc_params.h"
#include <stdlib.h>
#include "native_client/src/shared/srpc/nacl_srpc.h"
namespace plugin {
namespace {
bool FillVec(NaClSrpcArg* vec[], const char* types) {
const size_t kLength = strlen(types);
if (kLength > NACL_SRPC_MAX_ARGS) {
return false;
}
// We use malloc/new here rather than new/delete, because the SRPC layer
// is written in C and hence will use malloc/free.
// This array will get deallocated by FreeArguments().
if (kLength > 0) {
NaClSrpcArg* args =
reinterpret_cast<NaClSrpcArg*>(malloc(kLength * sizeof(*args)));
if (NULL == args) {
return false;
}
memset(static_cast<void*>(args), 0, kLength * sizeof(*args));
for (size_t i = 0; i < kLength; ++i) {
vec[i] = &args[i];
args[i].tag = static_cast<NaClSrpcArgType>(types[i]);
}
}
vec[kLength] = NULL;
return true;
}
void FreeSrpcArg(NaClSrpcArg* arg) {
switch (arg->tag) {
case NACL_SRPC_ARG_TYPE_CHAR_ARRAY:
free(arg->arrays.carr);
break;
case NACL_SRPC_ARG_TYPE_DOUBLE_ARRAY:
free(arg->arrays.darr);
break;
case NACL_SRPC_ARG_TYPE_HANDLE:
break;
case NACL_SRPC_ARG_TYPE_INT_ARRAY:
free(arg->arrays.iarr);
break;
case NACL_SRPC_ARG_TYPE_LONG_ARRAY:
free(arg->arrays.larr);
break;
case NACL_SRPC_ARG_TYPE_STRING:
// All strings that are passed in SrpcArg must be allocated using
// malloc! We cannot use browser's allocation API
// since some of SRPC arguments is handled outside of the plugin code.
free(arg->arrays.str);
break;
case NACL_SRPC_ARG_TYPE_VARIANT_ARRAY:
if (arg->arrays.varr) {
for (uint32_t i = 0; i < arg->u.count; i++) {
FreeSrpcArg(&arg->arrays.varr[i]);
}
}
break;
case NACL_SRPC_ARG_TYPE_OBJECT:
// This is a pointer to a scriptable object and should be released
// by the browser
break;
case NACL_SRPC_ARG_TYPE_BOOL:
case NACL_SRPC_ARG_TYPE_DOUBLE:
case NACL_SRPC_ARG_TYPE_INT:
case NACL_SRPC_ARG_TYPE_LONG:
case NACL_SRPC_ARG_TYPE_INVALID:
default:
break;
}
}
void FreeArguments(NaClSrpcArg* vec[]) {
if (NULL == vec[0]) {
return;
}
for (NaClSrpcArg** argp = vec; *argp; ++argp) {
FreeSrpcArg(*argp);
}
// Free the vector containing the arguments themselves that was
// allocated with FillVec().
free(vec[0]);
}
} // namespace
bool SrpcParams::Init(const char* in_types, const char* out_types) {
if (!FillVec(ins_, in_types)) {
return false;
}
if (!FillVec(outs_, out_types)) {
FreeArguments(ins_);
return false;
}
return true;
}
void SrpcParams::FreeAll() {
FreeArguments(ins_);
FreeArguments(outs_);
memset(ins_, 0, sizeof(ins_));
memset(outs_, 0, sizeof(outs_));
}
} // namespace plugin
|
