Skip to content

Commit d0ee8c0

Browse files
jasnelltargos
jasnell
authored and
targos
committed
src: improve error handling in process_wrap
Replace ToLocalChecked uses. PR-URL: #56977 Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com> Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
1 parent 0a82d27 commit d0ee8c0

File tree

1 file changed

+112
-46
lines changed

1 file changed

+112
-46
lines changed

‎src/process_wrap.cc

+112-46
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
// USE OR OTHER DEALINGS IN THE SOFTWARE.
2121

2222
#include "env-inl.h"
23+
#include "node_errors.h"
2324
#include "node_external_reference.h"
2425
#include "permission/permission.h"
2526
#include "stream_base-inl.h"
@@ -40,7 +41,11 @@ using v8::HandleScope;
4041
using v8::Int32;
4142
using v8::Integer;
4243
using v8::Isolate;
44+
using v8::Just;
45+
using v8::JustVoid;
4346
using v8::Local;
47+
using v8::Maybe;
48+
using v8::Nothing;
4449
using v8::Number;
4550
using v8::Object;
4651
using v8::String;
@@ -96,58 +101,84 @@ class ProcessWrap : public HandleWrap {
96101
MarkAsUninitialized();
97102
}
98103

99-
static uv_stream_t* StreamForWrap(Environment* env, Local<Object> stdio) {
104+
static Maybe<uv_stream_t*> StreamForWrap(Environment* env,
105+
Local<Object> stdio) {
100106
Local<String> handle_key = env->handle_string();
101107
// This property has always been set by JS land if we are in this code path.
102-
Local<Object> handle =
103-
stdio->Get(env->context(), handle_key).ToLocalChecked().As<Object>();
108+
Local<Value> val;
109+
if (!stdio->Get(env->context(), handle_key).ToLocal(&val)) {
110+
return Nothing<uv_stream_t*>();
111+
}
112+
Local<Object> handle = val.As<Object>();
104113

105114
uv_stream_t* stream = LibuvStreamWrap::From(env, handle)->stream();
106115
CHECK_NOT_NULL(stream);
107-
return stream;
116+
return Just(stream);
108117
}
109118

110-
static void ParseStdioOptions(Environment* env,
111-
Local<Object> js_options,
112-
uv_process_options_t* options) {
119+
static Maybe<void> ParseStdioOptions(Environment* env,
120+
Local<Object> js_options,
121+
uv_process_options_t* options) {
113122
Local<Context> context = env->context();
114123
Local<String> stdio_key = env->stdio_string();
115-
Local<Array> stdios =
116-
js_options->Get(context, stdio_key).ToLocalChecked().As<Array>();
124+
Local<Value> stdios_val;
125+
if (!js_options->Get(context, stdio_key).ToLocal(&stdios_val)) {
126+
return Nothing<void>();
127+
}
128+
if (!stdios_val->IsArray()) {
129+
THROW_ERR_INVALID_ARG_TYPE(env, "options.stdio must be an array");
130+
return Nothing<void>();
131+
}
132+
Local<Array> stdios = stdios_val.As<Array>();
117133

118134
uint32_t len = stdios->Length();
119135
options->stdio = new uv_stdio_container_t[len];
120136
options->stdio_count = len;
121137

122138
for (uint32_t i = 0; i < len; i++) {
123-
Local<Object> stdio =
124-
stdios->Get(context, i).ToLocalChecked().As<Object>();
125-
Local<Value> type =
126-
stdio->Get(context, env->type_string()).ToLocalChecked();
139+
Local<Value> val;
140+
if (!stdios->Get(context, i).ToLocal(&val)) {
141+
return Nothing<void>();
142+
}
143+
Local<Object> stdio = val.As<Object>();
144+
Local<Value> type;
145+
if (!stdio->Get(context, env->type_string()).ToLocal(&type)) {
146+
return Nothing<void>();
147+
}
127148

128149
if (type->StrictEquals(env->ignore_string())) {
129150
options->stdio[i].flags = UV_IGNORE;
130151
} else if (type->StrictEquals(env->pipe_string())) {
131152
options->stdio[i].flags = static_cast<uv_stdio_flags>(
132153
UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE);
133-
options->stdio[i].data.stream = StreamForWrap(env, stdio);
154+
if (!StreamForWrap(env, stdio).To(&options->stdio[i].data.stream)) {
155+
return Nothing<void>();
156+
}
134157
} else if (type->StrictEquals(env->overlapped_string())) {
135158
options->stdio[i].flags = static_cast<uv_stdio_flags>(
136159
UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE |
137160
UV_OVERLAPPED_PIPE);
138-
options->stdio[i].data.stream = StreamForWrap(env, stdio);
161+
if (!StreamForWrap(env, stdio).To(&options->stdio[i].data.stream)) {
162+
return Nothing<void>();
163+
}
139164
} else if (type->StrictEquals(env->wrap_string())) {
140165
options->stdio[i].flags = UV_INHERIT_STREAM;
141-
options->stdio[i].data.stream = StreamForWrap(env, stdio);
166+
if (!StreamForWrap(env, stdio).To(&options->stdio[i].data.stream)) {
167+
return Nothing<void>();
168+
}
142169
} else {
143170
Local<String> fd_key = env->fd_string();
144-
Local<Value> fd_value = stdio->Get(context, fd_key).ToLocalChecked();
171+
Local<Value> fd_value;
172+
if (!stdio->Get(context, fd_key).ToLocal(&fd_value)) {
173+
return Nothing<void>();
174+
}
145175
CHECK(fd_value->IsNumber());
146176
int fd = static_cast<int>(fd_value.As<Integer>()->Value());
147177
options->stdio[i].flags = UV_INHERIT_FD;
148178
options->stdio[i].data.fd = fd;
149179
}
150180
}
181+
return JustVoid();
151182
}
152183

153184
static void Spawn(const FunctionCallbackInfo<Value>& args) {
@@ -159,17 +190,22 @@ class ProcessWrap : public HandleWrap {
159190
env, permission::PermissionScope::kChildProcess, "");
160191
int err = 0;
161192

162-
Local<Object> js_options =
163-
args[0]->ToObject(env->context()).ToLocalChecked();
193+
if (!args[0]->IsObject()) {
194+
return THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object");
195+
}
196+
197+
Local<Object> js_options = args[0].As<Object>();
164198

165199
uv_process_options_t options;
166200
memset(&options, 0, sizeof(uv_process_options_t));
167201

168202
options.exit_cb = OnExit;
169203

170204
// options.uid
171-
Local<Value> uid_v =
172-
js_options->Get(context, env->uid_string()).ToLocalChecked();
205+
Local<Value> uid_v;
206+
if (!js_options->Get(context, env->uid_string()).ToLocal(&uid_v)) {
207+
return;
208+
}
173209
if (!uid_v->IsUndefined() && !uid_v->IsNull()) {
174210
CHECK(uid_v->IsInt32());
175211
const int32_t uid = uid_v.As<Int32>()->Value();
@@ -178,8 +214,10 @@ class ProcessWrap : public HandleWrap {
178214
}
179215

180216
// options.gid
181-
Local<Value> gid_v =
182-
js_options->Get(context, env->gid_string()).ToLocalChecked();
217+
Local<Value> gid_v;
218+
if (!js_options->Get(context, env->gid_string()).ToLocal(&gid_v)) {
219+
return;
220+
}
183221
if (!gid_v->IsUndefined() && !gid_v->IsNull()) {
184222
CHECK(gid_v->IsInt32());
185223
const int32_t gid = gid_v.As<Int32>()->Value();
@@ -190,8 +228,10 @@ class ProcessWrap : public HandleWrap {
190228
// TODO(bnoordhuis) is this possible to do without mallocing ?
191229

192230
// options.file
193-
Local<Value> file_v =
194-
js_options->Get(context, env->file_string()).ToLocalChecked();
231+
Local<Value> file_v;
232+
if (!js_options->Get(context, env->file_string()).ToLocal(&file_v)) {
233+
return;
234+
}
195235
CHECK(file_v->IsString());
196236
node::Utf8Value file(env->isolate(), file_v);
197237
options.file = *file;
@@ -206,8 +246,10 @@ class ProcessWrap : public HandleWrap {
206246
#endif
207247

208248
// options.args
209-
Local<Value> argv_v =
210-
js_options->Get(context, env->args_string()).ToLocalChecked();
249+
Local<Value> argv_v;
250+
if (!js_options->Get(context, env->args_string()).ToLocal(&argv_v)) {
251+
return;
252+
}
211253
if (!argv_v.IsEmpty() && argv_v->IsArray()) {
212254
Local<Array> js_argv = argv_v.As<Array>();
213255
int argc = js_argv->Length();
@@ -216,46 +258,61 @@ class ProcessWrap : public HandleWrap {
216258
// Heap allocate to detect errors. +1 is for nullptr.
217259
options.args = new char*[argc + 1];
218260
for (int i = 0; i < argc; i++) {
219-
node::Utf8Value arg(env->isolate(),
220-
js_argv->Get(context, i).ToLocalChecked());
261+
Local<Value> val;
262+
if (!js_argv->Get(context, i).ToLocal(&val)) {
263+
return;
264+
}
265+
node::Utf8Value arg(env->isolate(), val);
221266
options.args[i] = strdup(*arg);
222267
CHECK_NOT_NULL(options.args[i]);
223268
}
224269
options.args[argc] = nullptr;
225270
}
226271

227272
// options.cwd
228-
Local<Value> cwd_v =
229-
js_options->Get(context, env->cwd_string()).ToLocalChecked();
273+
Local<Value> cwd_v;
274+
if (!js_options->Get(context, env->cwd_string()).ToLocal(&cwd_v)) {
275+
return;
276+
}
230277
node::Utf8Value cwd(env->isolate(),
231278
cwd_v->IsString() ? cwd_v : Local<Value>());
232279
if (cwd.length() > 0) {
233280
options.cwd = *cwd;
234281
}
235282

236283
// options.env
237-
Local<Value> env_v =
238-
js_options->Get(context, env->env_pairs_string()).ToLocalChecked();
284+
Local<Value> env_v;
285+
if (!js_options->Get(context, env->env_pairs_string()).ToLocal(&env_v)) {
286+
return;
287+
}
239288
if (!env_v.IsEmpty() && env_v->IsArray()) {
240289
Local<Array> env_opt = env_v.As<Array>();
241290
int envc = env_opt->Length();
242291
CHECK_LT(envc, INT_MAX); // Check for overflow.
243292
options.env = new char*[envc + 1]; // Heap allocated to detect errors.
244293
for (int i = 0; i < envc; i++) {
245-
node::Utf8Value pair(env->isolate(),
246-
env_opt->Get(context, i).ToLocalChecked());
294+
Local<Value> val;
295+
if (!env_opt->Get(context, i).ToLocal(&val)) {
296+
return;
297+
}
298+
node::Utf8Value pair(env->isolate(), val);
247299
options.env[i] = strdup(*pair);
248300
CHECK_NOT_NULL(options.env[i]);
249301
}
250302
options.env[envc] = nullptr;
251303
}
252304

253305
// options.stdio
254-
ParseStdioOptions(env, js_options, &options);
306+
if (ParseStdioOptions(env, js_options, &options).IsNothing()) {
307+
return;
308+
}
255309

256310
// options.windowsHide
257-
Local<Value> hide_v =
258-
js_options->Get(context, env->windows_hide_string()).ToLocalChecked();
311+
Local<Value> hide_v;
312+
if (!js_options->Get(context, env->windows_hide_string())
313+
.ToLocal(&hide_v)) {
314+
return;
315+
}
259316

260317
if (hide_v->IsTrue()) {
261318
options.flags |= UV_PROCESS_WINDOWS_HIDE;
@@ -266,17 +323,22 @@ class ProcessWrap : public HandleWrap {
266323
}
267324

268325
// options.windows_verbatim_arguments
269-
Local<Value> wva_v =
270-
js_options->Get(context, env->windows_verbatim_arguments_string())
271-
.ToLocalChecked();
326+
Local<Value> wva_v;
327+
if (!js_options->Get(context, env->windows_verbatim_arguments_string())
328+
.ToLocal(&wva_v)) {
329+
return;
330+
}
272331

273332
if (wva_v->IsTrue()) {
274333
options.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
275334
}
276335

277336
// options.detached
278-
Local<Value> detached_v =
279-
js_options->Get(context, env->detached_string()).ToLocalChecked();
337+
Local<Value> detached_v;
338+
if (!js_options->Get(context, env->detached_string())
339+
.ToLocal(&detached_v)) {
340+
return;
341+
}
280342

281343
if (detached_v->IsTrue()) {
282344
options.flags |= UV_PROCESS_DETACHED;
@@ -289,9 +351,13 @@ class ProcessWrap : public HandleWrap {
289351

290352
if (err == 0) {
291353
CHECK_EQ(wrap->process_.data, wrap);
292-
wrap->object()->Set(context, env->pid_string(),
293-
Integer::New(env->isolate(),
294-
wrap->process_.pid)).Check();
354+
if (wrap->object()
355+
->Set(context,
356+
env->pid_string(),
357+
Integer::New(env->isolate(), wrap->process_.pid))
358+
.IsNothing()) {
359+
return;
360+
}
295361
}
296362

297363
if (options.args) {

0 commit comments

Comments
 (0)