Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	signal_wrap.cc	Lines:	73	80	91.2 %
Date:	2022-12-31 04:22:30	Branches:	14	26	53.8 %


// 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 "async_wrap-inl.h"
#include "env-inl.h"
#include "handle_wrap.h"
#include "node_external_reference.h"
#include "node_process-inl.h"
#include "util-inl.h"
#include "v8.h"

namespace node {

using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;

void DecreaseSignalHandlerCount(int signum);

namespace {

static Mutex handled_signals_mutex;
static std::map<int, int64_t> handled_signals;  // Signal -> number of handlers

class SignalWrap : public HandleWrap {
 public:
  static void Initialize(Local<Object> target,
                         Local<Value> unused,
                         Local<Context> context,
                         void* priv) {
    Environment* env = Environment::GetCurrent(context);
    Isolate* isolate = env->isolate();
    Local<FunctionTemplate> constructor = NewFunctionTemplate(isolate, New);
    constructor->InstanceTemplate()->SetInternalFieldCount(
        SignalWrap::kInternalFieldCount);
    constructor->Inherit(HandleWrap::GetConstructorTemplate(env));

    SetProtoMethod(isolate, constructor, "start", Start);
    SetProtoMethod(isolate, constructor, "stop", Stop);

    SetConstructorFunction(context, target, "Signal", constructor);
  }

  static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
    registry->Register(New);
    registry->Register(Start);
    registry->Register(Stop);
  }

  SET_NO_MEMORY_INFO()
  SET_MEMORY_INFO_NAME(SignalWrap)
  SET_SELF_SIZE(SignalWrap)

 private:
  static void New(const FunctionCallbackInfo<Value>& args) {
    // This constructor should not be exposed to public javascript.
    // Therefore we assert that we are not trying to call this as a
    // normal function.
    CHECK(args.IsConstructCall());
    Environment* env = Environment::GetCurrent(args);
    new SignalWrap(env, args.This());
  }

  SignalWrap(Environment* env, Local<Object> object)
      : HandleWrap(env,
                   object,
                   reinterpret_cast<uv_handle_t*>(&handle_),
                   AsyncWrap::PROVIDER_SIGNALWRAP) {
    int r = uv_signal_init(env->event_loop(), &handle_);
    CHECK_EQ(r, 0);
  }

  void Close(v8::Local<v8::Value> close_callback) override {
    if (active_) {
      DecreaseSignalHandlerCount(handle_.signum);
      active_ = false;
    }
    HandleWrap::Close(close_callback);
  }

  static void Start(const FunctionCallbackInfo<Value>& args) {
    SignalWrap* wrap;
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
    Environment* env = wrap->env();
    int signum;
    if (!args[0]->Int32Value(env->context()).To(&signum)) return;
#if defined(__POSIX__) && HAVE_INSPECTOR
    if (signum == SIGPROF) {
      Environment* env = Environment::GetCurrent(args);
      if (env->inspector_agent()->IsListening()) {
        ProcessEmitWarning(env,
                           "process.on(SIGPROF) is reserved while debugging");
        return;
      }
    }
#endif
    int err = uv_signal_start(
        &wrap->handle_,
        [](uv_signal_t* handle, int signum) {
          SignalWrap* wrap = ContainerOf(&SignalWrap::handle_, handle);
          Environment* env = wrap->env();
          HandleScope handle_scope(env->isolate());
          Context::Scope context_scope(env->context());
          Local<Value> arg = Integer::New(env->isolate(), signum);
          wrap->MakeCallback(env->onsignal_string(), 1, &arg);
        },
        signum);

    if (err == 0) {
      CHECK(!wrap->active_);
      wrap->active_ = true;
      Mutex::ScopedLock lock(handled_signals_mutex);
      handled_signals[signum]++;
    }

    args.GetReturnValue().Set(err);
  }

  static void Stop(const FunctionCallbackInfo<Value>& args) {
    SignalWrap* wrap;
    ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

    if (wrap->active_)  {
      wrap->active_ = false;
      DecreaseSignalHandlerCount(wrap->handle_.signum);
    }

    int err = uv_signal_stop(&wrap->handle_);
    args.GetReturnValue().Set(err);
  }

  uv_signal_t handle_;
  bool active_ = false;
};


}  // anonymous namespace

void DecreaseSignalHandlerCount(int signum) {
  Mutex::ScopedLock lock(handled_signals_mutex);
  int64_t new_handler_count = --handled_signals[signum];
  CHECK_GE(new_handler_count, 0);
  if (new_handler_count == 0)
    handled_signals.erase(signum);
}

bool HasSignalJSHandler(int signum) {
  Mutex::ScopedLock lock(handled_signals_mutex);
  return handled_signals.find(signum) != handled_signals.end();
}
}  // namespace node

NODE_BINDING_CONTEXT_AWARE_INTERNAL(signal_wrap, node::SignalWrap::Initialize)
NODE_BINDING_EXTERNAL_REFERENCE(signal_wrap,
                                node::SignalWrap::RegisterExternalReferences)


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 "async_wrap-inl.h"
23			#include "env-inl.h"
24			#include "handle_wrap.h"
25			#include "node_external_reference.h"
26			#include "node_process-inl.h"
27			#include "util-inl.h"
28			#include "v8.h"
29
30			namespace node {
31
32			using v8::Context;
33			using v8::FunctionCallbackInfo;
34			using v8::FunctionTemplate;
35			using v8::HandleScope;
36			using v8::Integer;
37			using v8::Isolate;
38			using v8::Local;
39			using v8::Object;
40			using v8::Value;
41
42			void DecreaseSignalHandlerCount(int signum);
43
44			namespace {
45
46			static Mutex handled_signals_mutex;
47			static std::map<int, int64_t> handled_signals; // Signal -> number of handlers
48
49			class SignalWrap : public HandleWrap {
50			public:
51		164	static void Initialize(Local<Object> target,
52			Local<Value> unused,
53			Local<Context> context,
54			void* priv) {
55		164	Environment* env = Environment::GetCurrent(context);
56		164	Isolate* isolate = env->isolate();
57		164	Local<FunctionTemplate> constructor = NewFunctionTemplate(isolate, New);
58		328	constructor->InstanceTemplate()->SetInternalFieldCount(
59			SignalWrap::kInternalFieldCount);
60		164	constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
61
62		164	SetProtoMethod(isolate, constructor, "start", Start);
63		164	SetProtoMethod(isolate, constructor, "stop", Stop);
64
65		164	SetConstructorFunction(context, target, "Signal", constructor);
66		164	}
67
68		5718	static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
69		5718	registry->Register(New);
70		5718	registry->Register(Start);
71		5718	registry->Register(Stop);
72		5718	}
73
74		3	SET_NO_MEMORY_INFO()
75		3	SET_MEMORY_INFO_NAME(SignalWrap)
76		3	SET_SELF_SIZE(SignalWrap)
77
78			private:
79		292	static void New(const FunctionCallbackInfo<Value>& args) {
80			// This constructor should not be exposed to public javascript.
81			// Therefore we assert that we are not trying to call this as a
82			// normal function.
83	✗✓	292	CHECK(args.IsConstructCall());
84		292	Environment* env = Environment::GetCurrent(args);
85		292	new SignalWrap(env, args.This());
86		292	}
87
88		292	SignalWrap(Environment* env, Local<Object> object)
89		292	: HandleWrap(env,
90			object,
91		292	reinterpret_cast<uv_handle_t*>(&handle_),
92		292	AsyncWrap::PROVIDER_SIGNALWRAP) {
93		292	int r = uv_signal_init(env->event_loop(), &handle_);
94	✗✓	292	CHECK_EQ(r, 0);
95		292	}
96
97		191	void Close(v8::Local<v8::Value> close_callback) override {
98	✓✓	191	if (active_) {
99		187	DecreaseSignalHandlerCount(handle_.signum);
100		187	active_ = false;
101			}
102		191	HandleWrap::Close(close_callback);
103		191	}
104
105		290	static void Start(const FunctionCallbackInfo<Value>& args) {
106			SignalWrap* wrap;
107	✗✓	291	ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
108		290	Environment* env = wrap->env();
109			int signum;
110	✗✓	580	if (!args[0]->Int32Value(env->context()).To(&signum)) return;
111			#if defined(__POSIX__) && HAVE_INSPECTOR
112	✓✓	290	if (signum == SIGPROF) {
113		1	Environment* env = Environment::GetCurrent(args);
114	✓✗	1	if (env->inspector_agent()->IsListening()) {
115			ProcessEmitWarning(env,
116		1	"process.on(SIGPROF) is reserved while debugging");
117		1	return;
118			}
119			}
120			#endif
121		289	int err = uv_signal_start(
122		289	&wrap->handle_,
123		37	[](uv_signal_t* handle, int signum) {
124		37	SignalWrap* wrap = ContainerOf(&SignalWrap::handle_, handle);
125		37	Environment* env = wrap->env();
126		67	HandleScope handle_scope(env->isolate());
127		37	Context::Scope context_scope(env->context());
128		37	Local<Value> arg = Integer::New(env->isolate(), signum);
129		37	wrap->MakeCallback(env->onsignal_string(), 1, &arg);
130		30	},
131			signum);
132
133	✓✗	289	if (err == 0) {
134	✗✓	289	CHECK(!wrap->active_);
135		289	wrap->active_ = true;
136		289	Mutex::ScopedLock lock(handled_signals_mutex);
137		289	handled_signals[signum]++;
138			}
139
140		578	args.GetReturnValue().Set(err);
141			}
142
143			static void Stop(const FunctionCallbackInfo<Value>& args) {
144			SignalWrap* wrap;
145			ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
146
147			if (wrap->active_) {
148			wrap->active_ = false;
149			DecreaseSignalHandlerCount(wrap->handle_.signum);
150			}
151
152			int err = uv_signal_stop(&wrap->handle_);
153			args.GetReturnValue().Set(err);
154			}
155
156			uv_signal_t handle_;
157			bool active_ = false;
158			};
159
160
161			} // anonymous namespace
162
163		187	void DecreaseSignalHandlerCount(int signum) {
164		374	Mutex::ScopedLock lock(handled_signals_mutex);
165		187	int64_t new_handler_count = --handled_signals[signum];
166	✗✓	187	CHECK_GE(new_handler_count, 0);
167	✓✓	187	if (new_handler_count == 0)
168		183	handled_signals.erase(signum);
169		187	}
170
171		28	bool HasSignalJSHandler(int signum) {
172		28	Mutex::ScopedLock lock(handled_signals_mutex);
173		28	return handled_signals.find(signum) != handled_signals.end();
174			}
175			} // namespace node
176
177		5789	NODE_BINDING_CONTEXT_AWARE_INTERNAL(signal_wrap, node::SignalWrap::Initialize)
178		5718	NODE_BINDING_EXTERNAL_REFERENCE(signal_wrap,
179			node::SignalWrap::RegisterExternalReferences)