1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <csignal>
17 #include <cstdio>
18 #include <cstdlib>
19 #include <cstring>
20 #include <fcntl.h>
21 #include <js_native_api.h>
22 #include <node_api.h>
23 #include <pthread.h>
24 #include <sys/signalfd.h>
25 #include <unistd.h>
26 #include <ctime>
27 #include <atomic>
28 #include <sys/time.h>
29
30 #define PARAM_0 0
31 #define PARAM_1 1
32 #define PARAM_2 2
33 #define PARAM_100 100
34 #define PARAM_6000 6000
35 #define PARAM_99999 99999
36 #define FAIL (-1)
37 #define NO_ERR 0
38 #define STRLENGTH 64
39 #define SUCCESS 1
40 #define ONE 1
41 #define SFD_CLOEXEC O_CLOEXEC
42 #define ONEVAL 1
43 #define MINUSONE (-1)
44 #define MINUSTWO (-2)
45 #define THRVAL 3
46 #define ERRON_0 0
47 #define SLEEP_10_MS 10
48
49 typedef void *(Func)(void *);
50 struct Sig {
51 int flag;
52 int param;
53 };
54 struct SigString {
55 int flag;
56 char param[STRLENGTH];
57 };
intInput(napi_env env, napi_callback_info info)58 static int intInput(napi_env env, napi_callback_info info)
59 {
60 size_t argc = PARAM_1;
61 napi_value args[1] = {nullptr};
62 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
63 int expect;
64 napi_get_value_int32(env, args[0], &expect);
65 return expect;
66 }
67
structInput(napi_env env, napi_callback_info info, struct Sig *siginfo)68 static void structInput(napi_env env, napi_callback_info info, struct Sig *siginfo)
69 {
70 size_t argc = PARAM_2;
71 napi_value args[2] = {nullptr};
72 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
73 napi_get_value_int32(env, args[0], &(siginfo->flag));
74 napi_get_value_int32(env, args[1], &(siginfo->param));
75 }
76
structStringInput(napi_env env, napi_callback_info info, struct SigString *siginfo)77 static void structStringInput(napi_env env, napi_callback_info info, struct SigString *siginfo)
78 {
79 size_t argc = PARAM_2;
80 napi_value args[2] = {nullptr};
81 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
82 napi_get_value_int32(env, args[0], &(siginfo->flag));
83 size_t size = STRLENGTH;
84 size_t actualVal = PARAM_0;
85 napi_get_value_string_utf8(env, args[1], siginfo->param, size, &actualVal);
86 }
87
SigMain(struct Sig siginfo, Func testfunction)88 static int SigMain(struct Sig siginfo, Func testfunction)
89 {
90 pthread_t pid;
91
92 pthread_create(&pid, nullptr, testfunction, &siginfo);
93 pthread_detach(pid);
94
95 return NO_ERR;
96 }
SigMainInt(int siginfo, Func testfunction)97 static int SigMainInt(int siginfo, Func testfunction)
98 {
99 pthread_t pid;
100
101 pthread_create(&pid, nullptr, testfunction, &siginfo);
102 pthread_detach(pid);
103
104 return NO_ERR;
105 }
SigMainNull(Func testfunction)106 static int SigMainNull(Func testfunction)
107 {
108 pthread_t pid;
109
110 pthread_create(&pid, nullptr, testfunction, nullptr);
111 pthread_detach(pid);
112
113 return NO_ERR;
114 }
SigMainString(struct SigString siginfo, Func testfunction)115 static int SigMainString(struct SigString siginfo, Func testfunction)
116 {
117 pthread_t pid;
118
119 pthread_create(&pid, nullptr, testfunction, &siginfo);
120 pthread_detach(pid);
121
122 return NO_ERR;
123 }
Sighold(void *pro)124 void *Sighold(void *pro)
125 {
126 Sig *sigInfo = (Sig *)pro;
127 if ((sigInfo->flag) == PARAM_0) {
128 int sig = SIGALRM;
129 sighold(sig);
130 } else {
131 sighold(sigInfo->param);
132 }
133 return nullptr;
134 }
135
SigMainHold(napi_env env, napi_callback_info info)136 static napi_value SigMainHold(napi_env env, napi_callback_info info)
137 {
138 napi_value result = nullptr;
139 struct Sig siginput;
140 structInput(env, info, &siginput);
141 int resSig = SigMain(siginput, Sighold);
142 napi_create_int32(env, resSig, &result);
143 return result;
144 }
145
Sigrelse(void *pro)146 void *Sigrelse(void *pro)
147 {
148 Sig *sigInfo = (Sig *)pro;
149 if ((sigInfo->flag) == PARAM_0) {
150 int sig = SIGALRM;
151 sigrelse(sig);
152 } else {
153 sigrelse(sigInfo->param);
154 }
155 return nullptr;
156 }
157
SigMainRelse(napi_env env, napi_callback_info info)158 static napi_value SigMainRelse(napi_env env, napi_callback_info info)
159 {
160 napi_value result = nullptr;
161 struct Sig siginput;
162 structInput(env, info, &siginput);
163 int resSig = SigMain(siginput, Sigrelse);
164 napi_create_int32(env, resSig, &result);
165 return result;
166 }
167
Sigdelset(void *pro)168 void *Sigdelset(void *pro)
169 {
170 sigset_t set = {PARAM_0};
171 Sig *sigInfo = (Sig *)pro;
172 sigemptyset(&set);
173 if ((sigInfo->flag) == PARAM_0) {
174 int sig = SIGALRM;
175 sigdelset(&set, sig);
176 } else {
177 sigdelset(&set, sigInfo->param);
178 }
179 return nullptr;
180 }
181
SigMainDelset(napi_env env, napi_callback_info info)182 static napi_value SigMainDelset(napi_env env, napi_callback_info info)
183 {
184 napi_value result = nullptr;
185 struct Sig siginput;
186 structInput(env, info, &siginput);
187 int resSig = SigMain(siginput, Sigdelset);
188 napi_create_int32(env, resSig, &result);
189 return result;
190 }
191
Sigaddset(void *pro)192 void *Sigaddset(void *pro)
193 {
194 sigset_t set = {PARAM_0};
195 Sig *sigInfo = (Sig *)pro;
196 sigemptyset(&set);
197 if ((sigInfo->flag) == PARAM_0) {
198 int sig = SIGALRM;
199 sigaddset(&set, sig);
200 } else {
201 sigaddset(&set, sigInfo->param);
202 }
203 return nullptr;
204 }
205
SigMainAddset(napi_env env, napi_callback_info info)206 static napi_value SigMainAddset(napi_env env, napi_callback_info info)
207 {
208 napi_value result = nullptr;
209 struct Sig siginput;
210 structInput(env, info, &siginput);
211 int resSig = SigMain(siginput, Sigaddset);
212 napi_create_int32(env, resSig, &result);
213 return result;
214 }
215
Sigemptyset(void *pro)216 void *Sigemptyset(void *pro)
217 {
218 sigset_t set = {PARAM_0};
219 sigemptyset(&set);
220 return nullptr;
221 }
222
SigMainEmptyset(napi_env env, napi_callback_info info)223 static napi_value SigMainEmptyset(napi_env env, napi_callback_info info)
224 {
225 napi_value result = nullptr;
226 int resSig = SigMainNull(Sigemptyset);
227 napi_create_int32(env, resSig, &result);
228 return result;
229 }
230
Sigfillset(void *pro)231 void *Sigfillset(void *pro)
232 {
233 sigset_t set = {PARAM_0};
234 sigfillset(&set);
235 return nullptr;
236 }
237
SigMainFillset(napi_env env, napi_callback_info info)238 static napi_value SigMainFillset(napi_env env, napi_callback_info info)
239 {
240 napi_value result = nullptr;
241 int resSig = SigMainNull(Sigfillset);
242 napi_create_int32(env, resSig, &result);
243 return result;
244 }
245
SignalHandler(int signum)246 void SignalHandler(int signum) {}
Sigaction(void *pro)247 void *Sigaction(void *pro)
248 {
249 Sig *sigInfo = (Sig *)pro;
250 struct sigaction sigabrt = {.sa_handler = SignalHandler};
251 if ((sigInfo->flag) == PARAM_0) {
252 sigaction(SIGABRT, &sigabrt, nullptr);
253 } else {
254 sigaction(sigInfo->param, &sigabrt, nullptr);
255 }
256 return nullptr;
257 }
258
SigMainAction(napi_env env, napi_callback_info info)259 static napi_value SigMainAction(napi_env env, napi_callback_info info)
260 {
261 napi_value result = nullptr;
262 struct Sig siginput;
263 structInput(env, info, &siginput);
264 int resSig = SigMain(siginput, Sigaction);
265 napi_create_int32(env, resSig, &result);
266 return result;
267 }
268
Sigaltstack(void *pro)269 void *Sigaltstack(void *pro)
270 {
271 Sig *sigInfo = (Sig *)pro;
272 stack_t ss = {PARAM_0};
273 ss.ss_size = SIGSTKSZ;
274 if ((sigInfo->flag) == PARAM_0) {
275 ss.ss_flags = PARAM_0;
276 sigaltstack(&ss, nullptr);
277 } else {
278 ss.ss_flags = MINUSONE;
279 sigaltstack(&ss, nullptr);
280 }
281 return nullptr;
282 }
283
SigMainAltstack(napi_env env, napi_callback_info info)284 static napi_value SigMainAltstack(napi_env env, napi_callback_info info)
285 {
286 napi_value result = nullptr;
287 int resSig = SigMainInt(intInput(env, info), Sigaltstack);
288 napi_create_int32(env, resSig, &result);
289 return result;
290 }
291
Sigignore(void *pro)292 void *Sigignore(void *pro)
293 {
294 Sig *sigInfo = (Sig *)pro;
295 if ((sigInfo->flag) == PARAM_0) {
296 sigignore(SIGALRM);
297 } else {
298 sigignore(sigInfo->param);
299 }
300 return nullptr;
301 }
302
SigMainIgnore(napi_env env, napi_callback_info info)303 static napi_value SigMainIgnore(napi_env env, napi_callback_info info)
304 {
305 napi_value result = nullptr;
306 struct Sig siginput;
307 structInput(env, info, &siginput);
308 int resSig = SigMain(siginput, Sigignore);
309 napi_create_int32(env, resSig, &result);
310 return result;
311 }
312
Sigpause(void *pro)313 void *Sigpause(void *pro)
314 {
315 sigpause(SIGALRM);
316 return nullptr;
317 }
318
SigMainPause(napi_env env, napi_callback_info info)319 static napi_value SigMainPause(napi_env env, napi_callback_info info)
320 {
321 napi_value result = nullptr;
322 int resSig = SigMainNull(Sigpause);
323 napi_create_int32(env, resSig, &result);
324 return result;
325 }
326
Sigpending(void *pro)327 void *Sigpending(void *pro)
328 {
329 sigset_t pending = {PARAM_0};
330 sigpending(&pending);
331 return nullptr;
332 }
333
SigMainPending(napi_env env, napi_callback_info info)334 static napi_value SigMainPending(napi_env env, napi_callback_info info)
335 {
336 napi_value result = nullptr;
337 int resSig = SigMainNull(Sigpending);
338 napi_create_int32(env, resSig, &result);
339 return result;
340 }
341
Sigprocmask(void *pro)342 void *Sigprocmask(void *pro)
343 {
344 Sig *sigInfo = (Sig *)pro;
345 sigset_t set = {PARAM_0}, set2 = {PARAM_0};
346 if ((sigInfo->flag) == PARAM_0) {
347 sigprocmask(SIG_UNBLOCK, &set, &set2);
348 } else {
349 sigprocmask(sigInfo->param, &set, &set2);
350 }
351 return nullptr;
352 }
353
SigMainProcmask(napi_env env, napi_callback_info info)354 static napi_value SigMainProcmask(napi_env env, napi_callback_info info)
355 {
356 napi_value result = nullptr;
357 struct Sig siginput;
358 structInput(env, info, &siginput);
359 int resSig = SigMain(siginput, Sigprocmask);
360 napi_create_int32(env, resSig, &result);
361 return result;
362 }
363
Kill(napi_env env, napi_callback_info info)364 static napi_value Kill(napi_env env, napi_callback_info info)
365 {
366 napi_value result = {PARAM_0};
367 napi_create_int32(env, PARAM_0, &result);
368 return result;
369 }
370
Killpg(napi_env env, napi_callback_info info)371 static napi_value Killpg(napi_env env, napi_callback_info info)
372 {
373 napi_value result = {PARAM_0};
374 napi_create_int32(env, PARAM_0, &result);
375 return result;
376 }
Psignal(void *pro)377 void *Psignal(void *pro)
378 {
379 SigString *sigInfo = (SigString *)pro;
380 psignal(sigInfo->flag, sigInfo->param);
381 return nullptr;
382 }
383
SigMainPsignal(napi_env env, napi_callback_info info)384 static napi_value SigMainPsignal(napi_env env, napi_callback_info info)
385 {
386 napi_value result = nullptr;
387 struct SigString siginput;
388 structStringInput(env, info, &siginput);
389 int resSig = SigMainString(siginput, Psignal);
390 napi_create_int32(env, resSig, &result);
391 return result;
392 }
393
PSigInfo(void *pro)394 void *PSigInfo(void *pro)
395 {
396 char paramSecond[STRLENGTH];
397 siginfo_t siginfo = {PARAM_0};
398 psiginfo(&siginfo, paramSecond);
399 return nullptr;
400 }
401
SigMainPSigInfo(napi_env env, napi_callback_info info)402 static napi_value SigMainPSigInfo(napi_env env, napi_callback_info info)
403 {
404 napi_value result = nullptr;
405 int resSig = SigMainNull(PSigInfo);
406 napi_create_int32(env, resSig, &result);
407 return result;
408 }
409
Raise(napi_env env, napi_callback_info info)410 static napi_value Raise(napi_env env, napi_callback_info info)
411 {
412 napi_value result = PARAM_0;
413 napi_create_int32(env, PARAM_0, &result);
414 return result;
415 }
416
417 std::atomic<bool> isSigSendReady (false);
418 pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
419
SigSend(void *pro)420 void *SigSend(void *pro)
421 {
422 int sig = SIGALRM;
423 union sigval sigval = {.sival_int = ONE};
424 int count = 0;
425 while (!isSigSendReady) {
426 usleep(SLEEP_10_MS);
427 count++;
428 if (count > PARAM_100) {
429 break;
430 }
431 }
432 sigqueue(getpid(), sig, sigval);
433
434 return nullptr;
435 }
436
SigMainWait(napi_env env, napi_callback_info info)437 static napi_value SigMainWait(napi_env env, napi_callback_info info)
438 {
439 pthread_mutex_lock(&g_mutex);
440 napi_value result = nullptr;
441 isSigSendReady = false;
442 pthread_t pid;
443 sigset_t set = {0};
444 int res = sigemptyset(&set);
445 int sig = SIGALRM;
446 res = sigaddset(&set, sig);
447 res = sigprocmask(SIG_BLOCK, &set, nullptr);
448 pthread_create(&pid, nullptr, SigSend, nullptr);
449 sig = PARAM_0;
450 isSigSendReady = true;
451 res = sigwait(&set, &sig);
452
453 napi_create_int32(env, res, &result);
454 pthread_mutex_unlock(&g_mutex);
455 return result;
456 }
457
SigMainWaitinfo(napi_env env, napi_callback_info info)458 static napi_value SigMainWaitinfo(napi_env env, napi_callback_info info)
459 {
460 pthread_mutex_lock(&g_mutex);
461 napi_value result = nullptr;
462 isSigSendReady = false;
463 pthread_t pid;
464 sigset_t set = {0};
465 int res = sigemptyset(&set);
466 int sig = SIGALRM;
467 res = sigaddset(&set, sig);
468 res = sigprocmask(SIG_BLOCK, &set, nullptr);
469 pthread_create(&pid, nullptr, SigSend, nullptr);
470 siginfo_t siginfo;
471 isSigSendReady = true;
472 res = sigwaitinfo(&set, &siginfo);
473 if (res == SIGALRM) {
474 res = PARAM_0;
475 }
476 if (siginfo.si_signo != sig) {
477 res = PARAM_1;
478 }
479 if (siginfo.si_value.sival_int != ONE) {
480 res = PARAM_2;
481 }
482
483 napi_create_int32(env, res, &result);
484 pthread_mutex_unlock(&g_mutex);
485 return result;
486 }
487
Sigismember(void *pro)488 void *Sigismember(void *pro)
489 {
490 Sig *sigInfo = (Sig *)pro;
491 sigset_t set = {PARAM_0};
492 if ((sigInfo->flag) == PARAM_0) {
493 int sig = SIGALRM;
494 sigismember(&set, sig);
495 } else if ((sigInfo->flag) == MINUSONE) {
496 sigismember(&set, sigInfo->param);
497 } else {
498 sigemptyset(&set);
499 sigaddset(&set, SIGINT);
500 sigismember(&set, SIGINT);
501 }
502 return nullptr;
503 }
504
SigMainIsmember(napi_env env, napi_callback_info info)505 static napi_value SigMainIsmember(napi_env env, napi_callback_info info)
506 {
507 napi_value result = nullptr;
508 struct Sig siginput;
509 structInput(env, info, &siginput);
510 int resSig = SigMain(siginput, Sigismember);
511 napi_create_int32(env, resSig, &result);
512 return result;
513 }
514
515 static int g_count = PARAM_0;
signalHandler(int signo)516 static void signalHandler(int signo) { g_count++; }
Signal(void *pro)517 void *Signal(void *pro)
518 {
519 signal(SIGHUP, signalHandler);
520 return nullptr;
521 }
522
SigMainSignal(napi_env env, napi_callback_info info)523 static napi_value SigMainSignal(napi_env env, napi_callback_info info)
524 {
525 napi_value result = nullptr;
526 int resSig = SigMainNull(Signal);
527 napi_create_int32(env, resSig, &result);
528 return result;
529 }
530
Signalfd(void *pro)531 void *Signalfd(void *pro)
532 {
533 const int sig = SIGALRM;
534 sigset_t mask = {};
535 sigaddset(&mask, sig);
536 sigprocmask(SIG_SETMASK, &mask, nullptr);
537 signalfd(MINUSONE, &mask, SFD_CLOEXEC);
538 return nullptr;
539 }
540
SigMainNalfd(napi_env env, napi_callback_info info)541 static napi_value SigMainNalfd(napi_env env, napi_callback_info info)
542 {
543 napi_value result = nullptr;
544 int resSig = SigMainNull(Signalfd);
545 napi_create_int32(env, resSig, &result);
546 return result;
547 }
548
unsupported_api(const char *Func)549 static inline void unsupported_api(const char *Func) { fprintf(stderr, "[ERR]Unsupported API %s\n", Func); }
Siginterrupt(void *pro)550 void *Siginterrupt(void *pro)
551 {
552 int sig = SIGABRT;
553 int flag = PARAM_0;
554 struct sigaction sa;
555 unsupported_api(__FUNCTION__);
556 struct sigaction sigabrt = {.sa_handler = SignalHandler};
557 sigaction(sig, &sigabrt, nullptr);
558 if (flag) {
559 sa.sa_flags &= ~SA_RESTART;
560 } else {
561 sa.sa_flags |= SA_RESTART;
562 }
563 siginterrupt(sig, ONEVAL);
564 return nullptr;
565 }
566
SigMainInterrupt(napi_env env, napi_callback_info info)567 static napi_value SigMainInterrupt(napi_env env, napi_callback_info info)
568 {
569 napi_value result = nullptr;
570 int resSig = SigMainNull(Siginterrupt);
571 napi_create_int32(env, resSig, &result);
572 return result;
573 }
574
Sigset(void *pro)575 void *Sigset(void *pro)
576 {
577 if (*(static_cast<int *>(pro)) == PARAM_0) {
578 sigset(SIGALRM, SIG_DFL);
579 } else {
580 sigset(PARAM_99999, SIG_DFL);
581 }
582 return nullptr;
583 }
584
SigMainSet(napi_env env, napi_callback_info info)585 static napi_value SigMainSet(napi_env env, napi_callback_info info)
586 {
587 napi_value result = nullptr;
588 int resSig = SigMainInt(intInput(env, info), Sigset);
589 napi_create_int32(env, resSig, &result);
590 return result;
591 }
592
Sigtimedwait(void *pro)593 void *Sigtimedwait(void *pro)
594 {
595 sigset_t set2 = {PARAM_0};
596 siginfo_t siginfo = {PARAM_0};
597 struct timespec timeout = {THRVAL, PARAM_0};
598 sigemptyset(&set2);
599 sigaddset(&set2, SIGCHLD);
600 sigtimedwait(&set2, &siginfo, &timeout);
601 return nullptr;
602 }
603
SigMainTimedwait(napi_env env, napi_callback_info info)604 static napi_value SigMainTimedwait(napi_env env, napi_callback_info info)
605 {
606 napi_value result = nullptr;
607 int resSig = SigMainNull(Sigtimedwait);
608 napi_create_int32(env, resSig, &result);
609 return result;
610 }
611
Sigqueue(void *pro)612 void *Sigqueue(void *pro)
613 {
614 Sig *sigInfo = (Sig *)pro;
615 union sigval sigval = {.sival_int = ONEVAL};
616 if (sigInfo->flag == PARAM_0) {
617 int sig = SIGALRM;
618 sigqueue(getpid(), sig, sigval);
619 } else {
620 sigqueue(getpid(), sigInfo->param, sigval);
621 }
622 return nullptr;
623 }
624
SigMainQueue(napi_env env, napi_callback_info info)625 static napi_value SigMainQueue(napi_env env, napi_callback_info info)
626 {
627 napi_value result = nullptr;
628 struct Sig siginput;
629 structInput(env, info, &siginput);
630 int resSig = SigMain(siginput, Sigqueue);
631 napi_create_int32(env, resSig, &result);
632 return result;
633 }
634
635 static int g_countNum = ERRON_0;
signaler(int signo)636 static void signaler(int signo) { g_countNum++; }
BsdSignal(void *pro)637 void *BsdSignal(void *pro)
638 {
639 bsd_signal(SIGHUP, signaler);
640 return nullptr;
641 }
642
SigMainBsdSignal(napi_env env, napi_callback_info info)643 static napi_value SigMainBsdSignal(napi_env env, napi_callback_info info)
644 {
645 napi_value result = nullptr;
646 int resSig = SigMainNull(BsdSignal);
647 napi_create_int32(env, resSig, &result);
648 return result;
649 }
650
Sigsuspend(void *pro)651 void *Sigsuspend(void *pro)
652 {
653 int sig = SIGALRM;
654 sigset_t set_without_sig;
655 sigfillset(&set_without_sig);
656 sigdelset(&set_without_sig, sig);
657 sigsuspend(&set_without_sig);
658 return nullptr;
659 }
660
SigMainSuspend(napi_env env, napi_callback_info info)661 static napi_value SigMainSuspend(napi_env env, napi_callback_info info)
662 {
663 napi_value result = nullptr;
664 int resSig = SigMainNull(Sigsuspend);
665 napi_create_int32(env, resSig, &result);
666 return result;
667 }
668
669 EXTERN_C_START
Init(napi_env env, napi_value exports)670 static napi_value Init(napi_env env, napi_value exports)
671 {
672 napi_property_descriptor desc[] = {
673 {"sighold", nullptr, SigMainHold, nullptr, nullptr, nullptr, napi_default, nullptr},
674 {"sigrelse", nullptr, SigMainRelse, nullptr, nullptr, nullptr, napi_default, nullptr},
675 {"sigdelset", nullptr, SigMainDelset, nullptr, nullptr, nullptr, napi_default, nullptr},
676 {"sigaddset", nullptr, SigMainAddset, nullptr, nullptr, nullptr, napi_default, nullptr},
677 {"sigemptyset", nullptr, SigMainEmptyset, nullptr, nullptr, nullptr, napi_default, nullptr},
678 {"sigfillset", nullptr, SigMainFillset, nullptr, nullptr, nullptr, napi_default, nullptr},
679 {"sigaction", nullptr, SigMainAction, nullptr, nullptr, nullptr, napi_default, nullptr},
680 {"sigaltstack", nullptr, SigMainAltstack, nullptr, nullptr, nullptr, napi_default, nullptr},
681 {"sigignore", nullptr, SigMainIgnore, nullptr, nullptr, nullptr, napi_default, nullptr},
682 {"sigpause", nullptr, SigMainPause, nullptr, nullptr, nullptr, napi_default, nullptr},
683 {"sigpending", nullptr, SigMainPending, nullptr, nullptr, nullptr, napi_default, nullptr},
684 {"sigprocmask", nullptr, SigMainProcmask, nullptr, nullptr, nullptr, napi_default, nullptr},
685 {"sigismember", nullptr, SigMainIsmember, nullptr, nullptr, nullptr, napi_default, nullptr},
686 {"signal", nullptr, SigMainSignal, nullptr, nullptr, nullptr, napi_default, nullptr},
687 {"signalfd", nullptr, SigMainNalfd, nullptr, nullptr, nullptr, napi_default, nullptr},
688 {"siginterrupt", nullptr, SigMainInterrupt, nullptr, nullptr, nullptr, napi_default, nullptr},
689 {"sigset", nullptr, SigMainSet, nullptr, nullptr, nullptr, napi_default, nullptr},
690 {"sigtimedwait", nullptr, SigMainTimedwait, nullptr, nullptr, nullptr, napi_default, nullptr},
691 {"sigqueue", nullptr, SigMainQueue, nullptr, nullptr, nullptr, napi_default, nullptr},
692 {"sigwait", nullptr, SigMainWait, nullptr, nullptr, nullptr, napi_default, nullptr},
693 {"sigwaitinfo", nullptr, SigMainWaitinfo, nullptr, nullptr, nullptr, napi_default, nullptr},
694 {"kill", nullptr, Kill, nullptr, nullptr, nullptr, napi_default, nullptr},
695 {"killpg", nullptr, Killpg, nullptr, nullptr, nullptr, napi_default, nullptr},
696 {"raise", nullptr, Raise, nullptr, nullptr, nullptr, napi_default, nullptr},
697 {"psignal", nullptr, SigMainPsignal, nullptr, nullptr, nullptr, napi_default, nullptr},
698 {"pSigInfo", nullptr, SigMainPSigInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
699 {"bsdSignal", nullptr, SigMainBsdSignal, nullptr, nullptr, nullptr, napi_default, nullptr},
700 {"sigsuspend", nullptr, SigMainSuspend, nullptr, nullptr, nullptr, napi_default, nullptr},
701 };
702 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
703 return exports;
704 }
705
706 EXTERN_C_END
707
708 static napi_module demoModule = {
709 .nm_version = 1,
710 .nm_flags = 0,
711 .nm_filename = nullptr,
712 .nm_register_func = Init,
713 .nm_modname = "signal",
714 .nm_priv = ((void *)0),
715 .reserved = {0},
716 };
717
RegisterEntryModule(void)718 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
719