Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	util.cc	Lines:	164	198	82.8 %
Date:	2022-08-14 04:19:53	Branches:	31	54	57.4 %


// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

#include "util.h"  // NOLINT(build/include_inline)
#include "util-inl.h"

#include "debug_utils-inl.h"
#include "env-inl.h"
#include "node_buffer.h"
#include "node_errors.h"
#include "node_internals.h"
#include "string_bytes.h"
#include "uv.h"

#ifdef _WIN32
#include <io.h>  // _S_IREAD _S_IWRITE
#include <time.h>
#ifndef S_IRUSR
#define S_IRUSR _S_IREAD
#endif  // S_IRUSR
#ifndef S_IWUSR
#define S_IWUSR _S_IWRITE
#endif  // S_IWUSR
#else
#include <sys/time.h>
#include <sys/types.h>
#endif

#include <atomic>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <sstream>

static std::atomic_int seq = {0};  // Sequence number for diagnostic filenames.

namespace node {

using v8::ArrayBufferView;
using v8::Isolate;
using v8::Local;
using v8::String;
using v8::Value;

template <typename T>
static void MakeUtf8String(Isolate* isolate,
                           Local<Value> value,
                           MaybeStackBuffer<T>* target) {
  Local<String> string;
  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  size_t storage;
  if (!StringBytes::StorageSize(isolate, string, UTF8).To(&storage)) return;
  storage += 1;
  target->AllocateSufficientStorage(storage);
  const int flags =
      String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8;
  const int length =
      string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
  target->SetLengthAndZeroTerminate(length);
}

Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {
  if (value.IsEmpty())
    return;

  MakeUtf8String(isolate, value, this);
}


TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {
  if (value.IsEmpty()) {
    return;
  }

  Local<String> string;
  if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;

  // Allocate enough space to include the null terminator
  const size_t storage = string->Length() + 1;
  AllocateSufficientStorage(storage);

  const int flags = String::NO_NULL_TERMINATION;
  const int length = string->Write(isolate, out(), 0, storage, flags);
  SetLengthAndZeroTerminate(length);
}

BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {
  // Slightly different take on Utf8Value. If value is a String,
  // it will return a Utf8 encoded string. If value is a Buffer,
  // it will copy the data out of the Buffer as is.
  if (value.IsEmpty()) {
    // Dereferencing this object will return nullptr.
    Invalidate();
    return;
  }

  if (value->IsString()) {
    MakeUtf8String(isolate, value, this);
  } else if (value->IsArrayBufferView()) {
    const size_t len = value.As<ArrayBufferView>()->ByteLength();
    // Leave place for the terminating '\0' byte.
    AllocateSufficientStorage(len + 1);
    value.As<ArrayBufferView>()->CopyContents(out(), len);
    SetLengthAndZeroTerminate(len);
  } else {
    Invalidate();
  }
}

void LowMemoryNotification() {
  if (per_process::v8_initialized) {
    auto isolate = Isolate::TryGetCurrent();
    if (isolate != nullptr) {
      isolate->LowMemoryNotification();
    }
  }
}

std::string GetProcessTitle(const char* default_title) {
  std::string buf(16, '\0');

  for (;;) {
    const int rc = uv_get_process_title(&buf[0], buf.size());

    if (rc == 0)
      break;

    // If uv_setup_args() was not called, `uv_get_process_title()` will always
    // return `UV_ENOBUFS`, no matter the input size. Guard against a possible
    // infinite loop by limiting the buffer size.
    if (rc != UV_ENOBUFS || buf.size() >= 1024 * 1024)
      return default_title;

    buf.resize(2 * buf.size());
  }

  // Strip excess trailing nul bytes. Using strlen() here is safe,
  // uv_get_process_title() always zero-terminates the result.
  buf.resize(strlen(&buf[0]));

  return buf;
}

std::string GetHumanReadableProcessName() {
  return SPrintF("%s[%d]", GetProcessTitle("Node.js"), uv_os_getpid());
}

std::vector<std::string> SplitString(const std::string& in,
                                     char delim,
                                     bool skipEmpty) {
  std::vector<std::string> out;
  if (in.empty())
    return out;
  std::istringstream in_stream(in);
  while (in_stream.good()) {
    std::string item;
    std::getline(in_stream, item, delim);
    if (item.empty() && skipEmpty) continue;
    out.emplace_back(std::move(item));
  }
  return out;
}

void ThrowErrStringTooLong(Isolate* isolate) {
  isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
}

double GetCurrentTimeInMicroseconds() {
  constexpr double kMicrosecondsPerSecond = 1e6;
  uv_timeval64_t tv;
  CHECK_EQ(0, uv_gettimeofday(&tv));
  return kMicrosecondsPerSecond * tv.tv_sec + tv.tv_usec;
}

int WriteFileSync(const char* path, uv_buf_t buf) {
  uv_fs_t req;
  int fd = uv_fs_open(nullptr,
                      &req,
                      path,
                      O_WRONLY | O_CREAT | O_TRUNC,
                      S_IWUSR | S_IRUSR,
                      nullptr);
  uv_fs_req_cleanup(&req);
  if (fd < 0) {
    return fd;
  }

  int err = uv_fs_write(nullptr, &req, fd, &buf, 1, 0, nullptr);
  uv_fs_req_cleanup(&req);
  if (err < 0) {
    return err;
  }

  err = uv_fs_close(nullptr, &req, fd, nullptr);
  uv_fs_req_cleanup(&req);
  return err;
}

int WriteFileSync(v8::Isolate* isolate,
                  const char* path,
                  v8::Local<v8::String> string) {
  node::Utf8Value utf8(isolate, string);
  uv_buf_t buf = uv_buf_init(utf8.out(), utf8.length());
  return WriteFileSync(path, buf);
}

int ReadFileSync(std::string* result, const char* path) {
  uv_fs_t req;
  auto defer_req_cleanup = OnScopeLeave([&req]() {
    uv_fs_req_cleanup(&req);
  });

  uv_file file = uv_fs_open(nullptr, &req, path, O_RDONLY, 0, nullptr);
  if (req.result < 0) {
    // req will be cleaned up by scope leave.
    return req.result;
  }
  uv_fs_req_cleanup(&req);

  auto defer_close = OnScopeLeave([file]() {
    uv_fs_t close_req;
    CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));
    uv_fs_req_cleanup(&close_req);
  });

  *result = std::string("");
  char buffer[4096];
  uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));

  while (true) {
    const int r =
        uv_fs_read(nullptr, &req, file, &buf, 1, result->length(), nullptr);
    if (req.result < 0) {
      // req will be cleaned up by scope leave.
      return req.result;
    }
    uv_fs_req_cleanup(&req);
    if (r <= 0) {
      break;
    }
    result->append(buf.base, r);
  }
  return 0;
}

void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {
#ifdef _WIN32
  GetLocalTime(tm_struct);
#else  // UNIX, OSX
  struct timeval time_val;
  gettimeofday(&time_val, nullptr);
  localtime_r(&time_val.tv_sec, tm_struct);
#endif
}

// Defined in node_internals.h
std::string DiagnosticFilename::MakeFilename(
    uint64_t thread_id,
    const char* prefix,
    const char* ext) {
  std::ostringstream oss;
  TIME_TYPE tm_struct;
  LocalTime(&tm_struct);
  oss << prefix;
#ifdef _WIN32
  oss << "." << std::setfill('0') << std::setw(4) << tm_struct.wYear;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wMonth;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wDay;
  oss << "." << std::setfill('0') << std::setw(2) << tm_struct.wHour;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wMinute;
  oss << std::setfill('0') << std::setw(2) << tm_struct.wSecond;
#else  // UNIX, OSX
  oss << "."
            << std::setfill('0')
            << std::setw(4)
            << tm_struct.tm_year + 1900;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_mon + 1;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_mday;
  oss << "."
            << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_hour;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_min;
  oss << std::setfill('0')
            << std::setw(2)
            << tm_struct.tm_sec;
#endif
  oss << "." << uv_os_getpid();
  oss << "." << thread_id;
  oss << "." << std::setfill('0') << std::setw(3) << ++seq;
  oss << "." << ext;
  return oss.str();
}

Local<v8::FunctionTemplate> NewFunctionTemplate(
    v8::Isolate* isolate,
    v8::FunctionCallback callback,
    Local<v8::Signature> signature,
    v8::ConstructorBehavior behavior,
    v8::SideEffectType side_effect_type,
    const v8::CFunction* c_function) {
  return v8::FunctionTemplate::New(isolate,
                                   callback,
                                   Local<v8::Value>(),
                                   signature,
                                   0,
                                   behavior,
                                   side_effect_type,
                                   c_function);
}

void SetMethod(Local<v8::Context> context,
               Local<v8::Object> that,
               const char* name,
               v8::FunctionCallback callback) {
  Isolate* isolate = context->GetIsolate();
  Local<v8::Function> function =
      NewFunctionTemplate(isolate,
                          callback,
                          Local<v8::Signature>(),
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasSideEffect)
          ->GetFunction(context)
          .ToLocalChecked();
  // kInternalized strings are created in the old space.
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->Set(context, name_string, function).Check();
  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
}

void SetFastMethod(Local<v8::Context> context,
                   Local<v8::Object> that,
                   const char* name,
                   v8::FunctionCallback slow_callback,
                   const v8::CFunction* c_function) {
  Isolate* isolate = context->GetIsolate();
  Local<v8::Function> function =
      NewFunctionTemplate(isolate,
                          slow_callback,
                          Local<v8::Signature>(),
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasNoSideEffect,
                          c_function)
          ->GetFunction(context)
          .ToLocalChecked();
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->Set(context, name_string, function).Check();
}

void SetMethodNoSideEffect(Local<v8::Context> context,
                           Local<v8::Object> that,
                           const char* name,
                           v8::FunctionCallback callback) {
  Isolate* isolate = context->GetIsolate();
  Local<v8::Function> function =
      NewFunctionTemplate(isolate,
                          callback,
                          Local<v8::Signature>(),
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasNoSideEffect)
          ->GetFunction(context)
          .ToLocalChecked();
  // kInternalized strings are created in the old space.
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->Set(context, name_string, function).Check();
  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
}

void SetProtoMethod(v8::Isolate* isolate,
                    Local<v8::FunctionTemplate> that,
                    const char* name,
                    v8::FunctionCallback callback) {
  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
  Local<v8::FunctionTemplate> t =
      NewFunctionTemplate(isolate,
                          callback,
                          signature,
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasSideEffect);
  // kInternalized strings are created in the old space.
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->PrototypeTemplate()->Set(name_string, t);
  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
}

void SetProtoMethodNoSideEffect(v8::Isolate* isolate,
                                Local<v8::FunctionTemplate> that,
                                const char* name,
                                v8::FunctionCallback callback) {
  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
  Local<v8::FunctionTemplate> t =
      NewFunctionTemplate(isolate,
                          callback,
                          signature,
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasNoSideEffect);
  // kInternalized strings are created in the old space.
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->PrototypeTemplate()->Set(name_string, t);
  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
}

void SetInstanceMethod(v8::Isolate* isolate,
                       Local<v8::FunctionTemplate> that,
                       const char* name,
                       v8::FunctionCallback callback) {
  Local<v8::Signature> signature = v8::Signature::New(isolate, that);
  Local<v8::FunctionTemplate> t =
      NewFunctionTemplate(isolate,
                          callback,
                          signature,
                          v8::ConstructorBehavior::kThrow,
                          v8::SideEffectType::kHasSideEffect);
  // kInternalized strings are created in the old space.
  const v8::NewStringType type = v8::NewStringType::kInternalized;
  Local<v8::String> name_string =
      v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
  that->InstanceTemplate()->Set(name_string, t);
  t->SetClassName(name_string);
}

void SetConstructorFunction(Local<v8::Context> context,
                            Local<v8::Object> that,
                            const char* name,
                            Local<v8::FunctionTemplate> tmpl,
                            SetConstructorFunctionFlag flag) {
  Isolate* isolate = context->GetIsolate();
  SetConstructorFunction(
      context, that, OneByteString(isolate, name), tmpl, flag);
}

void SetConstructorFunction(Local<v8::Context> context,
                            Local<v8::Object> that,
                            Local<v8::String> name,
                            Local<v8::FunctionTemplate> tmpl,
                            SetConstructorFunctionFlag flag) {
  if (LIKELY(flag == SetConstructorFunctionFlag::SET_CLASS_NAME))
    tmpl->SetClassName(name);
  that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();
}

}  // namespace node


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			// Copyright Joyent, Inc. and other Node contributors.
2			//
3			// Permission is hereby granted, free of charge, to any person obtaining a
4			// copy of this software and associated documentation files (the
5			// "Software"), to deal in the Software without restriction, including
6			// without limitation the rights to use, copy, modify, merge, publish,
7			// distribute, sublicense, and/or sell copies of the Software, and to permit
8			// persons to whom the Software is furnished to do so, subject to the
9			// following conditions:
10			//
11			// The above copyright notice and this permission notice shall be included
12			// in all copies or substantial portions of the Software.
13			//
14			// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15			// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16			// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17			// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18			// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19			// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20			// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22			#include "util.h" // NOLINT(build/include_inline)
23			#include "util-inl.h"
24
25			#include "debug_utils-inl.h"
26			#include "env-inl.h"
27			#include "node_buffer.h"
28			#include "node_errors.h"
29			#include "node_internals.h"
30			#include "string_bytes.h"
31			#include "uv.h"
32
33			#ifdef _WIN32
34			#include <io.h> // _S_IREAD _S_IWRITE
35			#include <time.h>
36			#ifndef S_IRUSR
37			#define S_IRUSR _S_IREAD
38			#endif // S_IRUSR
39			#ifndef S_IWUSR
40			#define S_IWUSR _S_IWRITE
41			#endif // S_IWUSR
42			#else
43			#include <sys/time.h>
44			#include <sys/types.h>
45			#endif
46
47			#include <atomic>
48			#include <cstdio>
49			#include <cstring>
50			#include <iomanip>
51			#include <sstream>
52
53			static std::atomic_int seq = {0}; // Sequence number for diagnostic filenames.
54
55			namespace node {
56
57			using v8::ArrayBufferView;
58			using v8::Isolate;
59			using v8::Local;
60			using v8::String;
61			using v8::Value;
62
63			template <typename T>
64		2901051	static void MakeUtf8String(Isolate* isolate,
65			Local<Value> value,
66			MaybeStackBuffer<T>* target) {
67			Local<String> string;
68	✗✓	5802102	if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;
69
70			size_t storage;
71	✗✓	5802102	if (!StringBytes::StorageSize(isolate, string, UTF8).To(&storage)) return;
72		2901051	storage += 1;
73		2901051	target->AllocateSufficientStorage(storage);
74		2901051	const int flags =
75			String::NO_NULL_TERMINATION \| String::REPLACE_INVALID_UTF8;
76		2901051	const int length =
77			string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
78		2901051	target->SetLengthAndZeroTerminate(length);
79			}
80
81		2689733	Utf8Value::Utf8Value(Isolate* isolate, Local<Value> value) {
82	✓✓	2689733	if (value.IsEmpty())
83		1816	return;
84
85		2687917	MakeUtf8String(isolate, value, this);
86			}
87
88
89		1197371	TwoByteValue::TwoByteValue(Isolate* isolate, Local<Value> value) {
90	✗✓	1197371	if (value.IsEmpty()) {
91			return;
92			}
93
94			Local<String> string;
95	✗✓	2394742	if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&string)) return;
96
97			// Allocate enough space to include the null terminator
98		1197371	const size_t storage = string->Length() + 1;
99		1197371	AllocateSufficientStorage(storage);
100
101		1197371	const int flags = String::NO_NULL_TERMINATION;
102		1197371	const int length = string->Write(isolate, out(), 0, storage, flags);
103		1197371	SetLengthAndZeroTerminate(length);
104			}
105
106		220591	BufferValue::BufferValue(Isolate* isolate, Local<Value> value) {
107			// Slightly different take on Utf8Value. If value is a String,
108			// it will return a Utf8 encoded string. If value is a Buffer,
109			// it will copy the data out of the Buffer as is.
110	✗✓	220591	if (value.IsEmpty()) {
111			// Dereferencing this object will return nullptr.
112			Invalidate();
113			return;
114			}
115
116	✓✓	441182	if (value->IsString()) {
117		213134	MakeUtf8String(isolate, value, this);
118	✓✗	7457	} else if (value->IsArrayBufferView()) {
119		7457	const size_t len = value.As<ArrayBufferView>()->ByteLength();
120			// Leave place for the terminating '\0' byte.
121		7457	AllocateSufficientStorage(len + 1);
122		7457	value.As<ArrayBufferView>()->CopyContents(out(), len);
123		7457	SetLengthAndZeroTerminate(len);
124			} else {
125			Invalidate();
126			}
127			}
128
129			void LowMemoryNotification() {
130			if (per_process::v8_initialized) {
131			auto isolate = Isolate::TryGetCurrent();
132			if (isolate != nullptr) {
133			isolate->LowMemoryNotification();
134			}
135			}
136			}
137
138		5471	std::string GetProcessTitle(const char* default_title) {
139		16413	std::string buf(16, '\0');
140
141			for (;;) {
142		14743	const int rc = uv_get_process_title(&buf[0], buf.size());
143
144	✓✓	14743	if (rc == 0)
145		5431	break;
146
147			// If uv_setup_args() was not called, `uv_get_process_title()` will always
148			// return `UV_ENOBUFS`, no matter the input size. Guard against a possible
149			// infinite loop by limiting the buffer size.
150	✓✗✓✓ ✓✓	9312	if (rc != UV_ENOBUFS \|\| buf.size() >= 1024 * 1024)
151		40	return default_title;
152
153		9272	buf.resize(2 * buf.size());
154		9272	}
155
156			// Strip excess trailing nul bytes. Using strlen() here is safe,
157			// uv_get_process_title() always zero-terminates the result.
158		5431	buf.resize(strlen(&buf[0]));
159
160		5431	return buf;
161			}
162
163		5313	std::string GetHumanReadableProcessName() {
164		5313	return SPrintF("%s[%d]", GetProcessTitle("Node.js"), uv_os_getpid());
165			}
166
167		14908	std::vector<std::string> SplitString(const std::string& in,
168			char delim,
169			bool skipEmpty) {
170		14908	std::vector<std::string> out;
171	✓✓	14908	if (in.empty())
172		2	return out;
173		29812	std::istringstream in_stream(in);
174	✓✓	45217	while (in_stream.good()) {
175		30311	std::string item;
176		30311	std::getline(in_stream, item, delim);
177	✓✓✗✓ ✗✓	30311	if (item.empty() && skipEmpty) continue;
178		30311	out.emplace_back(std::move(item));
179			}
180		14906	return out;
181			}
182
183			void ThrowErrStringTooLong(Isolate* isolate) {
184			isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
185			}
186
187		11976	double GetCurrentTimeInMicroseconds() {
188		11976	constexpr double kMicrosecondsPerSecond = 1e6;
189			uv_timeval64_t tv;
190	✗✓	11976	CHECK_EQ(0, uv_gettimeofday(&tv));
191		11976	return kMicrosecondsPerSecond * tv.tv_sec + tv.tv_usec;
192			}
193
194		5980	int WriteFileSync(const char* path, uv_buf_t buf) {
195			uv_fs_t req;
196		5980	int fd = uv_fs_open(nullptr,
197			&req,
198			path,
199			O_WRONLY \| O_CREAT \| O_TRUNC,
200			S_IWUSR \| S_IRUSR,
201			nullptr);
202		5980	uv_fs_req_cleanup(&req);
203	✓✓	5980	if (fd < 0) {
204		7	return fd;
205			}
206
207		5973	int err = uv_fs_write(nullptr, &req, fd, &buf, 1, 0, nullptr);
208		5973	uv_fs_req_cleanup(&req);
209	✗✓	5973	if (err < 0) {
210			return err;
211			}
212
213		5973	err = uv_fs_close(nullptr, &req, fd, nullptr);
214		5973	uv_fs_req_cleanup(&req);
215		5973	return err;
216			}
217
218		5980	int WriteFileSync(v8::Isolate* isolate,
219			const char* path,
220			v8::Local<v8::String> string) {
221		11960	node::Utf8Value utf8(isolate, string);
222		5980	uv_buf_t buf = uv_buf_init(utf8.out(), utf8.length());
223		5980	return WriteFileSync(path, buf);
224			}
225
226			int ReadFileSync(std::string* result, const char* path) {
227			uv_fs_t req;
228			auto defer_req_cleanup = OnScopeLeave([&req]() {
229			uv_fs_req_cleanup(&req);
230			});
231
232			uv_file file = uv_fs_open(nullptr, &req, path, O_RDONLY, 0, nullptr);
233			if (req.result < 0) {
234			// req will be cleaned up by scope leave.
235			return req.result;
236			}
237			uv_fs_req_cleanup(&req);
238
239			auto defer_close = OnScopeLeave([file]() {
240			uv_fs_t close_req;
241			CHECK_EQ(0, uv_fs_close(nullptr, &close_req, file, nullptr));
242			uv_fs_req_cleanup(&close_req);
243			});
244
245			*result = std::string("");
246			char buffer[4096];
247			uv_buf_t buf = uv_buf_init(buffer, sizeof(buffer));
248
249			while (true) {
250			const int r =
251			uv_fs_read(nullptr, &req, file, &buf, 1, result->length(), nullptr);
252			if (req.result < 0) {
253			// req will be cleaned up by scope leave.
254			return req.result;
255			}
256			uv_fs_req_cleanup(&req);
257			if (r <= 0) {
258			break;
259			}
260			result->append(buf.base, r);
261			}
262			return 0;
263			}
264
265		55	void DiagnosticFilename::LocalTime(TIME_TYPE* tm_struct) {
266			#ifdef _WIN32
267			GetLocalTime(tm_struct);
268			#else // UNIX, OSX
269			struct timeval time_val;
270		55	gettimeofday(&time_val, nullptr);
271		55	localtime_r(&time_val.tv_sec, tm_struct);
272			#endif
273		55	}
274
275			// Defined in node_internals.h
276		30	std::string DiagnosticFilename::MakeFilename(
277			uint64_t thread_id,
278			const char* prefix,
279			const char* ext) {
280		60	std::ostringstream oss;
281			TIME_TYPE tm_struct;
282		30	LocalTime(&tm_struct);
283		30	oss << prefix;
284			#ifdef _WIN32
285			oss << "." << std::setfill('0') << std::setw(4) << tm_struct.wYear;
286			oss << std::setfill('0') << std::setw(2) << tm_struct.wMonth;
287			oss << std::setfill('0') << std::setw(2) << tm_struct.wDay;
288			oss << "." << std::setfill('0') << std::setw(2) << tm_struct.wHour;
289			oss << std::setfill('0') << std::setw(2) << tm_struct.wMinute;
290			oss << std::setfill('0') << std::setw(2) << tm_struct.wSecond;
291			#else // UNIX, OSX
292			oss << "."
293			<< std::setfill('0')
294		30	<< std::setw(4)
295		30	<< tm_struct.tm_year + 1900;
296			oss << std::setfill('0')
297		30	<< std::setw(2)
298		30	<< tm_struct.tm_mon + 1;
299			oss << std::setfill('0')
300		30	<< std::setw(2)
301		30	<< tm_struct.tm_mday;
302			oss << "."
303			<< std::setfill('0')
304		30	<< std::setw(2)
305		30	<< tm_struct.tm_hour;
306			oss << std::setfill('0')
307		30	<< std::setw(2)
308		30	<< tm_struct.tm_min;
309			oss << std::setfill('0')
310		30	<< std::setw(2)
311		30	<< tm_struct.tm_sec;
312			#endif
313		30	oss << "." << uv_os_getpid();
314		30	oss << "." << thread_id;
315		30	oss << "." << std::setfill('0') << std::setw(3) << ++seq;
316		30	oss << "." << ext;
317		30	return oss.str();
318			}
319
320		1107655	Local<v8::FunctionTemplate> NewFunctionTemplate(
321			v8::Isolate* isolate,
322			v8::FunctionCallback callback,
323			Local<v8::Signature> signature,
324			v8::ConstructorBehavior behavior,
325			v8::SideEffectType side_effect_type,
326			const v8::CFunction* c_function) {
327			return v8::FunctionTemplate::New(isolate,
328			callback,
329			Local<v8::Value>(),
330			signature,
331			0,
332			behavior,
333			side_effect_type,
334		1107655	c_function);
335			}
336
337		267893	void SetMethod(Local<v8::Context> context,
338			Local<v8::Object> that,
339			const char* name,
340			v8::FunctionCallback callback) {
341		267893	Isolate* isolate = context->GetIsolate();
342			Local<v8::Function> function =
343		267893	NewFunctionTemplate(isolate,
344			callback,
345			Local<v8::Signature>(),
346			v8::ConstructorBehavior::kThrow,
347		267893	v8::SideEffectType::kHasSideEffect)
348		267893	->GetFunction(context)
349		267893	.ToLocalChecked();
350			// kInternalized strings are created in the old space.
351		267893	const v8::NewStringType type = v8::NewStringType::kInternalized;
352			Local<v8::String> name_string =
353		535786	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
354		535786	that->Set(context, name_string, function).Check();
355		267893	function->SetName(name_string); // NODE_SET_METHOD() compatibility.
356		267893	}
357
358		1524	void SetFastMethod(Local<v8::Context> context,
359			Local<v8::Object> that,
360			const char* name,
361			v8::FunctionCallback slow_callback,
362			const v8::CFunction* c_function) {
363		1524	Isolate* isolate = context->GetIsolate();
364			Local<v8::Function> function =
365		1524	NewFunctionTemplate(isolate,
366			slow_callback,
367			Local<v8::Signature>(),
368			v8::ConstructorBehavior::kThrow,
369			v8::SideEffectType::kHasNoSideEffect,
370		1524	c_function)
371		1524	->GetFunction(context)
372		1524	.ToLocalChecked();
373		1524	const v8::NewStringType type = v8::NewStringType::kInternalized;
374			Local<v8::String> name_string =
375		3048	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
376		1524	that->Set(context, name_string, function).Check();
377		1524	}
378
379		68473	void SetMethodNoSideEffect(Local<v8::Context> context,
380			Local<v8::Object> that,
381			const char* name,
382			v8::FunctionCallback callback) {
383		68473	Isolate* isolate = context->GetIsolate();
384			Local<v8::Function> function =
385		68473	NewFunctionTemplate(isolate,
386			callback,
387			Local<v8::Signature>(),
388			v8::ConstructorBehavior::kThrow,
389		68473	v8::SideEffectType::kHasNoSideEffect)
390		68473	->GetFunction(context)
391		68473	.ToLocalChecked();
392			// kInternalized strings are created in the old space.
393		68473	const v8::NewStringType type = v8::NewStringType::kInternalized;
394			Local<v8::String> name_string =
395		136946	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
396		136946	that->Set(context, name_string, function).Check();
397		68473	function->SetName(name_string); // NODE_SET_METHOD() compatibility.
398		68473	}
399
400		537603	void SetProtoMethod(v8::Isolate* isolate,
401			Local<v8::FunctionTemplate> that,
402			const char* name,
403			v8::FunctionCallback callback) {
404		537603	Local<v8::Signature> signature = v8::Signature::New(isolate, that);
405			Local<v8::FunctionTemplate> t =
406			NewFunctionTemplate(isolate,
407			callback,
408			signature,
409			v8::ConstructorBehavior::kThrow,
410		537603	v8::SideEffectType::kHasSideEffect);
411			// kInternalized strings are created in the old space.
412		537603	const v8::NewStringType type = v8::NewStringType::kInternalized;
413			Local<v8::String> name_string =
414		1075206	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
415		1075206	that->PrototypeTemplate()->Set(name_string, t);
416		537603	t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
417		537603	}
418
419		74803	void SetProtoMethodNoSideEffect(v8::Isolate* isolate,
420			Local<v8::FunctionTemplate> that,
421			const char* name,
422			v8::FunctionCallback callback) {
423		74803	Local<v8::Signature> signature = v8::Signature::New(isolate, that);
424			Local<v8::FunctionTemplate> t =
425			NewFunctionTemplate(isolate,
426			callback,
427			signature,
428			v8::ConstructorBehavior::kThrow,
429		74803	v8::SideEffectType::kHasNoSideEffect);
430			// kInternalized strings are created in the old space.
431		74803	const v8::NewStringType type = v8::NewStringType::kInternalized;
432			Local<v8::String> name_string =
433		149606	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
434		149606	that->PrototypeTemplate()->Set(name_string, t);
435		74803	t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
436		74803	}
437
438		33	void SetInstanceMethod(v8::Isolate* isolate,
439			Local<v8::FunctionTemplate> that,
440			const char* name,
441			v8::FunctionCallback callback) {
442		33	Local<v8::Signature> signature = v8::Signature::New(isolate, that);
443			Local<v8::FunctionTemplate> t =
444			NewFunctionTemplate(isolate,
445			callback,
446			signature,
447			v8::ConstructorBehavior::kThrow,
448		33	v8::SideEffectType::kHasSideEffect);
449			// kInternalized strings are created in the old space.
450		33	const v8::NewStringType type = v8::NewStringType::kInternalized;
451			Local<v8::String> name_string =
452		66	v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
453		66	that->InstanceTemplate()->Set(name_string, t);
454		33	t->SetClassName(name_string);
455		33	}
456
457		101257	void SetConstructorFunction(Local<v8::Context> context,
458			Local<v8::Object> that,
459			const char* name,
460			Local<v8::FunctionTemplate> tmpl,
461			SetConstructorFunctionFlag flag) {
462		101257	Isolate* isolate = context->GetIsolate();
463		101257	SetConstructorFunction(
464			context, that, OneByteString(isolate, name), tmpl, flag);
465		101257	}
466
467		105067	void SetConstructorFunction(Local<v8::Context> context,
468			Local<v8::Object> that,
469			Local<v8::String> name,
470			Local<v8::FunctionTemplate> tmpl,
471			SetConstructorFunctionFlag flag) {
472	✓✓	105067	if (LIKELY(flag == SetConstructorFunctionFlag::SET_CLASS_NAME))
473		92349	tmpl->SetClassName(name);
474		210134	that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();
475		105067	}
476
477			} // namespace node