GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: node_file-inl.h Lines: 149 157 94.9 %
Date: 2022-04-05 04:14:57 Branches: 24 34 70.6 %

Line Branch Exec Source
1
#ifndef SRC_NODE_FILE_INL_H_
2
#define SRC_NODE_FILE_INL_H_
3
4
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6
#include "node_file.h"
7
#include "req_wrap-inl.h"
8
9
namespace node {
10
namespace fs {
11
12
6207
FSContinuationData::FSContinuationData(uv_fs_t* req, int mode, uv_fs_cb done_cb)
13
6207
  : done_cb_(done_cb), req_(req), mode_(mode) {
14
6207
}
15
16
761
void FSContinuationData::PushPath(std::string&& path) {
17
761
  paths_.emplace_back(std::move(path));
18
761
}
19
20
5852
void FSContinuationData::PushPath(const std::string& path) {
21
5852
  paths_.push_back(path);
22
5852
}
23
24
610
void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
25
610
  if (first_path_.empty()) {
26
523
    first_path_ = path;
27
  }
28
610
}
29
30
6613
std::string FSContinuationData::PopPath() {
31
6613
  CHECK(!paths_.empty());
32
6613
  std::string path = std::move(paths_.back());
33
6613
  paths_.pop_back();
34
6613
  return path;
35
}
36
37
355
void FSContinuationData::Done(int result) {
38
355
  req_->result = result;
39
355
  done_cb_(req_);
40
355
}
41
42
55883
FSReqBase::FSReqBase(BindingData* binding_data,
43
                     v8::Local<v8::Object> req,
44
                     AsyncWrap::ProviderType type,
45
55883
                     bool use_bigint)
46
  : ReqWrap(binding_data->env(), req, type),
47
    use_bigint_(use_bigint),
48
55883
    binding_data_(binding_data) {
49
55883
}
50
51
55805
void FSReqBase::Init(const char* syscall,
52
                     const char* data,
53
                     size_t len,
54
                     enum encoding encoding) {
55
55805
  syscall_ = syscall;
56
55805
  encoding_ = encoding;
57
58
55805
  if (data != nullptr) {
59
133
    CHECK(!has_data_);
60
133
    buffer_.AllocateSufficientStorage(len + 1);
61
133
    buffer_.SetLengthAndZeroTerminate(len);
62
133
    memcpy(*buffer_, data, len);
63
133
    has_data_ = true;
64
  }
65
55805
}
66
67
FSReqBase::FSReqBuffer&
68
78
FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
69
78
  syscall_ = syscall;
70
78
  encoding_ = encoding;
71
72
78
  buffer_.AllocateSufficientStorage(len + 1);
73
78
  has_data_ = false;  // so that the data does not show up in error messages
74
78
  return buffer_;
75
}
76
77
51329
FSReqCallback::FSReqCallback(BindingData* binding_data,
78
                             v8::Local<v8::Object> req,
79
51329
                             bool use_bigint)
80
  : FSReqBase(binding_data,
81
              req,
82
              AsyncWrap::PROVIDER_FSREQCALLBACK,
83
51329
              use_bigint) {}
84
85
template <typename NativeT, typename V8T>
86
336032
void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
87
                    const uv_stat_t* s,
88
                    const size_t offset) {
89
#define SET_FIELD_WITH_STAT(stat_offset, stat)                               \
90
  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
91
                   static_cast<NativeT>(stat))
92
93
#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                          \
94
  /* NOLINTNEXTLINE(runtime/int) */                                          \
95
  SET_FIELD_WITH_STAT(stat_offset, static_cast<unsigned long>(stat))
96
97
168016
  SET_FIELD_WITH_STAT(kDev, s->st_dev);
98
168016
  SET_FIELD_WITH_STAT(kMode, s->st_mode);
99
168016
  SET_FIELD_WITH_STAT(kNlink, s->st_nlink);
100
168016
  SET_FIELD_WITH_STAT(kUid, s->st_uid);
101
168016
  SET_FIELD_WITH_STAT(kGid, s->st_gid);
102
168016
  SET_FIELD_WITH_STAT(kRdev, s->st_rdev);
103
168016
  SET_FIELD_WITH_STAT(kBlkSize, s->st_blksize);
104
168016
  SET_FIELD_WITH_STAT(kIno, s->st_ino);
105
168016
  SET_FIELD_WITH_STAT(kSize, s->st_size);
106
168016
  SET_FIELD_WITH_STAT(kBlocks, s->st_blocks);
107
108
168016
  SET_FIELD_WITH_TIME_STAT(kATimeSec, s->st_atim.tv_sec);
109
168016
  SET_FIELD_WITH_TIME_STAT(kATimeNsec, s->st_atim.tv_nsec);
110
168016
  SET_FIELD_WITH_TIME_STAT(kMTimeSec, s->st_mtim.tv_sec);
111
168016
  SET_FIELD_WITH_TIME_STAT(kMTimeNsec, s->st_mtim.tv_nsec);
112
168016
  SET_FIELD_WITH_TIME_STAT(kCTimeSec, s->st_ctim.tv_sec);
113
168016
  SET_FIELD_WITH_TIME_STAT(kCTimeNsec, s->st_ctim.tv_nsec);
114
168016
  SET_FIELD_WITH_TIME_STAT(kBirthTimeSec, s->st_birthtim.tv_sec);
115
168016
  SET_FIELD_WITH_TIME_STAT(kBirthTimeNsec, s->st_birthtim.tv_nsec);
116
117
#undef SET_FIELD_WITH_TIME_STAT
118
#undef SET_FIELD_WITH_STAT
119
168016
}
120
121
166569
v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
122
                                          const bool use_bigint,
123
                                          const uv_stat_t* s,
124
                                          const bool second) {
125
166569
  const ptrdiff_t offset =
126
166569
      second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
127
166569
  if (use_bigint) {
128
101410
    auto* const arr = &binding_data->stats_field_bigint_array;
129
101410
    FillStatsArray(arr, s, offset);
130
202820
    return arr->GetJSArray();
131
  } else {
132
65159
    auto* const arr = &binding_data->stats_field_array;
133
65159
    FillStatsArray(arr, s, offset);
134
130318
    return arr->GetJSArray();
135
  }
136
}
137
138
template <typename AliasedBufferT>
139
FSReqPromise<AliasedBufferT>*
140
9108
FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
141
                                  bool use_bigint) {
142
9108
  Environment* env = binding_data->env();
143
  v8::Local<v8::Object> obj;
144
9108
  if (!env->fsreqpromise_constructor_template()
145
9108
           ->NewInstance(env->context())
146
9108
           .ToLocal(&obj)) {
147
    return nullptr;
148
  }
149
  v8::Local<v8::Promise::Resolver> resolver;
150
27324
  if (!v8::Promise::Resolver::New(env->context()).ToLocal(&resolver) ||
151

36432
      obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
152
    return nullptr;
153
  }
154
9108
  return new FSReqPromise(binding_data, obj, use_bigint);
155
}
156
157
template <typename AliasedBufferT>
158
18200
FSReqPromise<AliasedBufferT>::~FSReqPromise() {
159
  // Validate that the promise was explicitly resolved or rejected.
160
  CHECK(finished_);
161
18200
}
162
163
template <typename AliasedBufferT>
164
9108
FSReqPromise<AliasedBufferT>::FSReqPromise(
165
    BindingData* binding_data,
166
    v8::Local<v8::Object> obj,
167
    bool use_bigint)
168
  : FSReqBase(binding_data,
169
              obj,
170
              AsyncWrap::PROVIDER_FSREQPROMISE,
171
              use_bigint),
172
    stats_field_array_(
173
        env()->isolate(),
174
9108
        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
175
176
template <typename AliasedBufferT>
177
826
void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
178
826
  finished_ = true;
179
1652
  v8::HandleScope scope(env()->isolate());
180
826
  InternalCallbackScope callback_scope(this);
181
  v8::Local<v8::Value> value =
182
2478
      object()->Get(env()->context(),
183
1652
                    env()->promise_string()).ToLocalChecked();
184
826
  v8::Local<v8::Promise::Resolver> resolver = value.As<v8::Promise::Resolver>();
185
1652
  USE(resolver->Reject(env()->context(), reject).FromJust());
186
826
}
187
188
template <typename AliasedBufferT>
189
8274
void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {
190
8274
  finished_ = true;
191
16548
  v8::HandleScope scope(env()->isolate());
192
8274
  InternalCallbackScope callback_scope(this);
193
  v8::Local<v8::Value> val =
194
24822
      object()->Get(env()->context(),
195
8274
                    env()->promise_string()).ToLocalChecked();
196
8274
  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
197
16548
  USE(resolver->Resolve(env()->context(), value).FromJust());
198
8274
}
199
200
template <typename AliasedBufferT>
201
2894
void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
202
2894
  FillStatsArray(&stats_field_array_, stat);
203
5788
  Resolve(stats_field_array_.GetJSArray());
204
2894
}
205
206
template <typename AliasedBufferT>
207
9108
void FSReqPromise<AliasedBufferT>::SetReturnValue(
208
    const v8::FunctionCallbackInfo<v8::Value>& args) {
209
  v8::Local<v8::Value> val =
210
27324
      object()->Get(env()->context(),
211
9108
                    env()->promise_string()).ToLocalChecked();
212
9108
  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
213
9108
  args.GetReturnValue().Set(resolver->GetPromise());
214
9108
}
215
216
template <typename AliasedBufferT>
217
2
void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
218
2
  FSReqBase::MemoryInfo(tracker);
219
2
  tracker->TrackField("stats_field_array", stats_field_array_);
220
}
221
222
569363
FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
223
                      int index,
224
                      bool use_bigint) {
225
569363
  v8::Local<v8::Value> value = args[index];
226
569363
  if (value->IsObject()) {
227
51329
    return Unwrap<FSReqBase>(value.As<v8::Object>());
228
  }
229
230
518034
  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
231
518034
  Environment* env = binding_data->env();
232
1036068
  if (value->StrictEquals(env->fs_use_promises_symbol())) {
233
4554
    if (use_bigint) {
234
420
      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
235
    } else {
236
4134
      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
237
    }
238
  }
239
513480
  return nullptr;
240
}
241
242
// Returns nullptr if the operation fails from the start.
243
template <typename Func, typename... Args>
244
111610
FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,
245
                         const v8::FunctionCallbackInfo<v8::Value>& args,
246
                         const char* syscall, const char* dest,
247
                         size_t len, enum encoding enc, uv_fs_cb after,
248
                         Func fn, Args... fn_args) {
249
111610
  CHECK_NOT_NULL(req_wrap);
250
111610
  req_wrap->Init(syscall, dest, len, enc);
251
111610
  int err = req_wrap->Dispatch(fn, fn_args..., after);
252
111610
  if (err < 0) {
253
    uv_fs_t* uv_req = req_wrap->req();
254
    uv_req->result = err;
255
    uv_req->path = nullptr;
256
    after(uv_req);  // after may delete req_wrap if there is an error
257
    req_wrap = nullptr;
258
  } else {
259
111610
    req_wrap->SetReturnValue(args);
260
  }
261
262
111610
  return req_wrap;
263
}
264
265
// Returns nullptr if the operation fails from the start.
266
template <typename Func, typename... Args>
267
111344
FSReqBase* AsyncCall(Environment* env,
268
                     FSReqBase* req_wrap,
269
                     const v8::FunctionCallbackInfo<v8::Value>& args,
270
                     const char* syscall, enum encoding enc,
271
                     uv_fs_cb after, Func fn, Args... fn_args) {
272
111344
  return AsyncDestCall(env, req_wrap, args,
273
                       syscall, nullptr, 0, enc,
274
111344
                       after, fn, fn_args...);
275
}
276
277
// Template counterpart of SYNC_CALL, except that it only puts
278
// the error number and the syscall in the context instead of
279
// creating an error in the C++ land.
280
// ctx must be checked using value->IsObject() before being passed.
281
template <typename Func, typename... Args>
282
513196
int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
283
             FSReqWrapSync* req_wrap, const char* syscall,
284
             Func fn, Args... args) {
285
513196
  env->PrintSyncTrace();
286
513196
  int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);
287
513196
  if (err < 0) {
288
2653
    v8::Local<v8::Context> context = env->context();
289
2653
    v8::Local<v8::Object> ctx_obj = ctx.As<v8::Object>();
290
2653
    v8::Isolate* isolate = env->isolate();
291
10612
    ctx_obj->Set(context,
292
                 env->errno_string(),
293
                 v8::Integer::New(isolate, err)).Check();
294
10612
    ctx_obj->Set(context,
295
                 env->syscall_string(),
296
                 OneByteString(isolate, syscall)).Check();
297
  }
298
513196
  return err;
299
}
300
301
}  // namespace fs
302
}  // namespace node
303
304
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
305
306
#endif  // SRC_NODE_FILE_INL_H_