• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "uv.h"
23 #include "env-inl.h"
24 #include "node.h"
25 #include "node_external_reference.h"
26 #include "node_process-inl.h"
27 
28 namespace node {
29 
30 namespace per_process {
31 struct UVError {
32   int value;
33   const char* name;
34   const char* message;
35 };
36 
37 // We only expand the macro once here to reduce the amount of code
38 // generated.
39 static const struct UVError uv_errors_map[] = {
40 #define V(name, message) {UV_##name, #name, message},
41     UV_ERRNO_MAP(V)
42 #undef V
43 };
44 }  // namespace per_process
45 
46 namespace uv {
47 
48 using v8::Array;
49 using v8::Context;
50 using v8::DontDelete;
51 using v8::FunctionCallbackInfo;
52 using v8::Integer;
53 using v8::Isolate;
54 using v8::Local;
55 using v8::Map;
56 using v8::Object;
57 using v8::PropertyAttribute;
58 using v8::ReadOnly;
59 using v8::String;
60 using v8::Value;
61 
ErrName(const FunctionCallbackInfo<Value> & args)62 void ErrName(const FunctionCallbackInfo<Value>& args) {
63   Environment* env = Environment::GetCurrent(args);
64   if (env->options()->pending_deprecation && env->EmitErrNameWarning()) {
65     if (ProcessEmitDeprecationWarning(
66         env,
67         "Directly calling process.binding('uv').errname(<val>) is being"
68         " deprecated. "
69         "Please make sure to use util.getSystemErrorName() instead.",
70         "DEP0119").IsNothing())
71     return;
72   }
73   int err;
74   if (!args[0]->Int32Value(env->context()).To(&err)) return;
75   CHECK_LT(err, 0);
76   char name[50];
77   uv_err_name_r(err, name, sizeof(name));
78   args.GetReturnValue().Set(OneByteString(env->isolate(), name));
79 }
80 
GetErrMap(const FunctionCallbackInfo<Value> & args)81 void GetErrMap(const FunctionCallbackInfo<Value>& args) {
82   Environment* env = Environment::GetCurrent(args);
83   Isolate* isolate = env->isolate();
84   Local<Context> context = env->context();
85 
86   // This can't return a SafeMap, because the uv binding can be referenced
87   // by user code by using `process.binding('uv').getErrorMap()`:
88   Local<Map> err_map = Map::New(isolate);
89 
90   size_t errors_len = arraysize(per_process::uv_errors_map);
91   for (size_t i = 0; i < errors_len; ++i) {
92     const auto& error = per_process::uv_errors_map[i];
93     Local<Value> arr[] = {OneByteString(isolate, error.name),
94                           OneByteString(isolate, error.message)};
95     if (err_map
96             ->Set(context,
97                   Integer::New(isolate, error.value),
98                   Array::New(isolate, arr, arraysize(arr)))
99             .IsEmpty()) {
100       return;
101     }
102   }
103 
104   args.GetReturnValue().Set(err_map);
105 }
106 
Initialize(Local<Object> target,Local<Value> unused,Local<Context> context,void * priv)107 void Initialize(Local<Object> target,
108                 Local<Value> unused,
109                 Local<Context> context,
110                 void* priv) {
111   Environment* env = Environment::GetCurrent(context);
112   Isolate* isolate = env->isolate();
113   SetConstructorFunction(
114       context, target, "errname", NewFunctionTemplate(isolate, ErrName));
115 
116   // TODO(joyeecheung): This should be deprecated in user land in favor of
117   // `util.getSystemErrorName(err)`.
118   PropertyAttribute attributes =
119       static_cast<PropertyAttribute>(ReadOnly | DontDelete);
120   size_t errors_len = arraysize(per_process::uv_errors_map);
121   const std::string prefix = "UV_";
122   for (size_t i = 0; i < errors_len; ++i) {
123     const auto& error = per_process::uv_errors_map[i];
124     const std::string prefixed_name = prefix + error.name;
125     Local<String> name = OneByteString(isolate, prefixed_name.c_str());
126     Local<Integer> value = Integer::New(isolate, error.value);
127     target->DefineOwnProperty(context, name, value, attributes).Check();
128   }
129 
130   SetMethod(context, target, "getErrorMap", GetErrMap);
131 }
132 
RegisterExternalReferences(ExternalReferenceRegistry * registry)133 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
134   registry->Register(ErrName);
135   registry->Register(GetErrMap);
136 }
137 }  // namespace uv
138 }  // namespace node
139 
140 NODE_BINDING_CONTEXT_AWARE_INTERNAL(uv, node::uv::Initialize)
141 NODE_BINDING_EXTERNAL_REFERENCE(uv, node::uv::RegisterExternalReferences)
142