1 /*
2  * Copyright (c) 2022 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 firstParam 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 "napi/native_api.h"
17 #include <arpa/inet.h>
18 #include <cerrno>
19 #include <clocale>
20 #include <cmath>
21 #include <csignal>
22 #include <cstdio>
23 #include <cstring>
24 #include <dlfcn.h>
25 #include <fcntl.h>
26 #include <info/application_target_sdk_version.h>
27 #include <info/fatal_message.h>
28 #include <js_native_api_types.h>
29 #include <libgen.h>
30 #include <linux/quota.h>
31 #include <mntent.h>
32 #include <netdb.h>
33 #include <netinet/ether.h>
34 #include <pthread.h>
35 #include <regex.h>
36 #include <resolv.h>
37 #include <sched.h>
38 #include <sys/epoll.h>
39 #include <sys/eventfd.h>
40 #include <sys/file.h>
41 #include <sys/socket.h>
42 #include <sys/stat.h>
43 #include <sys/xattr.h>
44 #include <syslog.h>
45 #include <threads.h>
46 #include <unistd.h>
47 #include <utmp.h>
48 #include <atomic>
49 #include <securec.h>
50 
51 #define NAMELEN 16
52 #define NSEC_PER_SEC 1000000000
53 #define NSEC_PER_100MS 100000000
54 #define NSEC_PER_MSEC 1000000
55 #define US_PER_S 1000000
56 #define MS_PER_S 1000
57 #define SLEEP_100_MS 100
58 #define DELAY_TIME_100_MS 100
59 #define SLEEP_50_MS 50
60 #define SLEEP_20_MS 20
61 #define MAXDNAME_A 1025
62 #define INIT (-1)
63 #define SUCCESS 0
64 #define NO_ERROR 0
65 #define PARAM_0 0
66 #define PARAM_1 1
67 #define PARAM_2 2
68 #define PARAM_3 3
69 #define PARAM_4 4
70 #define PARAM_5 5
71 #define PARAM_32 32
72 #define PARAM_64 64
73 #define PARAM_10 10
74 #define PARAM_100 100
75 #define PARAM_256 256
76 #define PARAM_0777 0777
77 #define PARAM_64 64
78 #define PARAM_1024 1024
79 #define PARAM_8192 8192
80 #define SPNUM 1
81 #define MINUSONE (-1)
82 #define MINUSTWO (-2)
83 #define FAILD (-1)
84 #define PARAM_UNNORMAL (-1)
85 #define SIZE_10 10
86 #define TEST_MODE 0666
87 #define BUF_SIZE (100)
88 #define PORT 2288
89 #define PORT_2 2289
90 #ifndef tls_mod_off_t
91 #define tls_mod_off_t size_t
92 #define PARAM_72 72
93 #define SLEEPTIME 1
94 #endif
95 
96 extern "C" mode_t __umask_chk(mode_t);
97 extern "C" ssize_t __sendto_chk(int, const void *, size_t, size_t, int, const struct sockaddr *, socklen_t);
98 extern "C" ssize_t __send_chk(int, const void *, size_t, size_t, int);
99 extern "C" ssize_t __recv_chk(int, void *, size_t, size_t, int);
100 extern "C" ssize_t __recvfrom_chk(int, void *, size_t, size_t, int, struct sockaddr *, socklen_t *);
101 extern "C" locale_t __duplocale(locale_t old);
102 extern "C" int *__errno_location(void);
103 extern "C" int __flt_rounds(void);
104 extern "C" int __overflow(FILE *file, int _c);
105 extern "C" int __uflow(FILE *file);
106 extern "C" void *__tls_get_addr(tls_mod_off_t *a);
107 extern "C" void _pthread_cleanup_pop(struct __ptcb *, int a);
108 extern "C" void _pthread_cleanup_push(struct __ptcb *, void (*)(void *), void *);
109 extern "C" int delete_module(const char *a, unsigned b);
110 extern "C" pid_t pthread_gettid_np(pthread_t t);
111 
DlaDdr(napi_env env, napi_callback_info info)112 static napi_value DlaDdr(napi_env env, napi_callback_info info)
113 {
114     int backParam = PARAM_0;
115     Dl_info *dlInfo = nullptr;
116     errno = SUCCESS;
117     const char *path = "/system/lib/extensionability/libstatic_subscriber_extension_module.z.so";
118     void *handle = dlopen(path, RTLD_LAZY);
119     void* ptr = dlsym(handle, "OHOS_EXTENSION_GetExtensionModule");
120     backParam = dladdr(ptr, dlInfo);
121     dlclose(handle);
122     napi_value result = nullptr;
123     napi_create_int32(env, backParam, &result);
124     return result;
125 }
126 
DlOpen(napi_env env, napi_callback_info info)127 static napi_value DlOpen(napi_env env, napi_callback_info info)
128 {
129     errno = SUCCESS;
130     const char path[] = "libotherstestndk.so";
131     int backParam = PARAM_0;
132     void *ptr = dlopen(path, RTLD_LAZY);
133     backParam = dlclose(ptr);
134     napi_value result = nullptr;
135     napi_create_int32(env, backParam, &result);
136     return result;
137 }
138 
DlClose(napi_env env, napi_callback_info info)139 static napi_value DlClose(napi_env env, napi_callback_info info)
140 {
141     const char path[] = "libotherstestndk.so";
142     int backParam = PARAM_0;
143     void *ptr = dlopen(path, RTLD_LAZY);
144     backParam = dlclose(ptr);
145     napi_value result = nullptr;
146     napi_create_int32(env, backParam, &result);
147     return result;
148 }
149 
DlError(napi_env env, napi_callback_info info)150 static napi_value DlError(napi_env env, napi_callback_info info)
151 {
152     char *errorInfo = nullptr;
153     int backParam = INIT;
154     const char path[] = "/system/lib/extensionability/libstatic_subscriber_extension_modu_le.z.so";
155     void *ptr = dlopen(path, RTLD_NOW);
156     errorInfo = dlerror();
157     if (errorInfo != nullptr) {
158         backParam = SUCCESS;
159     }
160     dlclose(ptr);
161     napi_value result = nullptr;
162     napi_create_int32(env, backParam, &result);
163     return result;
164 }
165 
CloseLog(napi_env env, napi_callback_info info)166 static napi_value CloseLog(napi_env env, napi_callback_info info)
167 {
168     int backResult = SUCCESS;
169     const char *path = "/data/storage/el2/base/files/Fzl.txt";
170     openlog(path, LOG_PID, LOG_USER);
171     syslog(LOG_DEBUG, path);
172     closelog();
173     napi_value result = nullptr;
174     napi_create_int32(env, backResult, &result);
175     return result;
176 }
177 
DirName(napi_env env, napi_callback_info info)178 static napi_value DirName(napi_env env, napi_callback_info info)
179 {
180     char *backParam = nullptr;
181     const char pathname[] = "/data/storage/el2/base/files/Fzl.txt";
182     int flags = O_CREAT;
183     mode_t mode = S_IRWXU;
184     int fd = open(pathname, flags, mode);
185     char path[] = "/data/storage/el2/base/files/Fzl.txt";
186     backParam = dirname(path);
187     close(fd);
188     napi_value result = nullptr;
189     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
190     return result;
191 }
192 
Flock(napi_env env, napi_callback_info info)193 static napi_value Flock(napi_env env, napi_callback_info info)
194 {
195     int backParam = PARAM_0;
196     int firstParam = open("/data/storage/el2/base/files/Fzl.txt", O_CREAT, PARAM_0777), secondParam = LOCK_UN;
197     backParam = flock(firstParam, secondParam);
198     close(firstParam);
199     napi_value result = nullptr;
200     napi_create_int32(env, backParam, &result);
201     return result;
202 }
203 
Dn_comp(napi_env env, napi_callback_info info)204 static napi_value Dn_comp(napi_env env, napi_callback_info info)
205 {
206     int backParam = FAILD;
207     const char domain[] = "www.baidu.com";
208     unsigned char buff[MAXDNAME_A] = {0};
209     unsigned char **firstChar = nullptr, **secondChar = nullptr;
210     backParam = dn_comp(domain, buff, MAXDNAME_A, firstChar, secondChar);
211     if (backParam > PARAM_0) {
212         backParam = SUCCESS;
213     }
214     napi_value result = nullptr;
215     napi_create_int32(env, backParam, &result);
216     return result;
217 }
218 
Dn_skipname(napi_env env, napi_callback_info info)219 static napi_value Dn_skipname(napi_env env, napi_callback_info info)
220 {
221     int backParam = PARAM_0;
222     const unsigned char str[] = {0, 2, 3, 4};
223     backParam = dn_skipname(&str[0], &str[1]);
224     napi_value result = nullptr;
225     napi_create_int32(env, backParam, &result);
226     return result;
227 }
228 
DRem(napi_env env, napi_callback_info info)229 static napi_value DRem(napi_env env, napi_callback_info info)
230 {
231     size_t argc = PARAM_2;
232     napi_value args[2] = {nullptr, nullptr};
233     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
234     double backParam, firstParam, secondParam;
235     napi_get_value_double(env, args[0], &firstParam);
236     napi_get_value_double(env, args[1], &secondParam);
237     backParam = drem(firstParam, secondParam);
238     napi_value result = nullptr;
239     napi_create_double(env, backParam, &result);
240     return result;
241 }
242 
DRemF(napi_env env, napi_callback_info info)243 static napi_value DRemF(napi_env env, napi_callback_info info)
244 {
245     size_t argc = PARAM_2;
246     napi_value args[2] = {nullptr, nullptr};
247     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
248     double backParam, firstParam, secondParam;
249     napi_get_value_double(env, args[0], &firstParam);
250     napi_get_value_double(env, args[1], &secondParam);
251     backParam = dremf(firstParam, secondParam);
252     napi_value result = nullptr;
253     napi_create_double(env, backParam, &result);
254     return result;
255 }
256 
Finite(napi_env env, napi_callback_info info)257 static napi_value Finite(napi_env env, napi_callback_info info)
258 {
259     size_t argc = PARAM_1;
260     napi_value args[1] = {nullptr};
261     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
262     int backParam = PARAM_0;
263     double firstParam;
264     napi_get_value_double(env, args[0], &firstParam);
265     backParam = finite(firstParam);
266     napi_value result = nullptr;
267     napi_create_int32(env, backParam, &result);
268     return result;
269 }
270 
FiniteF(napi_env env, napi_callback_info info)271 static napi_value FiniteF(napi_env env, napi_callback_info info)
272 {
273     size_t argc = PARAM_1;
274     napi_value args[1] = {nullptr};
275     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
276     int backParam = PARAM_0;
277     double firstParam;
278     napi_get_value_double(env, args[0], &firstParam);
279     backParam = finitef(firstParam);
280     napi_value result = nullptr;
281     napi_create_int32(env, backParam, &result);
282     return result;
283 }
284 
EndMntEnt(napi_env env, napi_callback_info info)285 static napi_value EndMntEnt(napi_env env, napi_callback_info info)
286 {
287     int backParam = PARAM_0;
288     const char *path = "/data/storage/el2/base/files/Fzl.txt";
289     const char *mode = "r";
290     FILE *stream = fopen(path, mode);
291     backParam = endmntent(stream);
292     napi_value result = nullptr;
293     napi_create_int32(env, backParam, &result);
294     return result;
295 }
296 const int STACK_SIZE = PARAM_1024 * PARAM_8192;
test(void *p)297 void *test(void *p) { return nullptr; }
Clone(napi_env env, napi_callback_info info)298 static napi_value Clone(napi_env env, napi_callback_info info)
299 {
300     void *stack = malloc(STACK_SIZE);
301     int backParam = clone((int (*)(void *))test, static_cast<char *>(stack) + STACK_SIZE,
302                           CLONE_VM | CLONE_FS | CLONE_FILES, nullptr);
303     if (backParam > PARAM_0) {
304         backParam = SUCCESS;
305     }
306     napi_value result = nullptr;
307     napi_create_int32(env, backParam, &result);
308     return result;
309 }
310 
EndUTent(napi_env env, napi_callback_info info)311 static napi_value EndUTent(napi_env env, napi_callback_info info)
312 {
313     errno = INIT;
314     endutent();
315     napi_value result = nullptr;
316     errno = SUCCESS;
317     napi_create_int32(env, errno, &result);
318     return result;
319 }
320 
Epoll_create(napi_env env, napi_callback_info info)321 static napi_value Epoll_create(napi_env env, napi_callback_info info)
322 {
323     int backParam = PARAM_1;
324     backParam = epoll_create1(EPOLL_CLOEXEC);
325     napi_value result = nullptr;
326     napi_create_int32(env, backParam, &result);
327     close(backParam);
328     return result;
329 }
330 
Epoll_create1(napi_env env, napi_callback_info info)331 static napi_value Epoll_create1(napi_env env, napi_callback_info info)
332 {
333     int backParam = PARAM_1;
334     backParam = epoll_create1(EPOLL_CLOEXEC);
335     napi_value result = nullptr;
336     napi_create_int32(env, backParam, &result);
337     close(backParam);
338     return result;
339 }
340 
Epoll_ctl(napi_env env, napi_callback_info info)341 static napi_value Epoll_ctl(napi_env env, napi_callback_info info)
342 {
343     int backParam = PARAM_1;
344     int epollFd = epoll_create1(EPOLL_CLOEXEC);
345     if (epollFd != MINUSONE) {
346         int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
347         if (sockfd != MINUSONE) {
348             struct epoll_event g_event;
349             g_event.events = EPOLLIN | EPOLLET;
350             g_event.data.fd = sockfd;
351             backParam = epoll_ctl(epollFd, EPOLL_CTL_ADD, sockfd, &g_event);
352         }
353         close(sockfd);
354     }
355     close(epollFd);
356     napi_value result = nullptr;
357     napi_create_int32(env, backParam, &result);
358     return result;
359 }
360 
Epoll_PWait(napi_env env, napi_callback_info info)361 static napi_value Epoll_PWait(napi_env env, napi_callback_info info)
362 {
363     int backParam = PARAM_1;
364     int epollFd = epoll_create1(EPOLL_CLOEXEC);
365     if (epollFd != MINUSONE) {
366         struct epoll_event g_events[PARAM_10];
367         backParam = epoll_pwait(epollFd, g_events, PARAM_10, PARAM_10, nullptr);
368     }
369     close(epollFd);
370     napi_value result = nullptr;
371     napi_create_int32(env, backParam, &result);
372     return result;
373 }
374 
Epoll_Wait(napi_env env, napi_callback_info info)375 static napi_value Epoll_Wait(napi_env env, napi_callback_info info)
376 {
377     int backParam = PARAM_1;
378     int epollFd = epoll_create1(EPOLL_CLOEXEC);
379     if (epollFd != MINUSONE) {
380         struct epoll_event g_events[PARAM_10];
381         backParam = epoll_wait(epollFd, g_events, PARAM_10, PARAM_0);
382     }
383     close(epollFd);
384     napi_value result = nullptr;
385     napi_create_int32(env, backParam, &result);
386     return result;
387 }
388 
Ether_aTon(napi_env env, napi_callback_info info)389 static napi_value Ether_aTon(napi_env env, napi_callback_info info)
390 {
391     int backParam = INIT;
392     struct ether_addr *checkParam = nullptr;
393     const char firstParam[1][18] = {"5F:4E:2C:3D:1B:0A"};
394     checkParam = ether_aton(firstParam[0]);
395     if (checkParam != nullptr) {
396         backParam = SUCCESS;
397     }
398     napi_value result = nullptr;
399     napi_create_int32(env, backParam, &result);
400     return result;
401 }
402 
Ether_nToa_r(napi_env env, napi_callback_info info)403 static napi_value Ether_nToa_r(napi_env env, napi_callback_info info)
404 {
405     int backParam = INIT;
406     struct ether_addr addr[sizeof(ether_addr)];
407     char firstParam[1][18] = {"5F:4E:2C:3D:1B:0A"};
408     ether_aton_r(firstParam[0], addr);
409     char *back = ether_ntoa_r(addr, firstParam[0]);
410     if (back != nullptr) {
411         backParam = SUCCESS;
412     }
413     napi_value result = nullptr;
414     napi_create_int32(env, backParam, &result);
415     return result;
416 }
417 
Ether_nToa(napi_env env, napi_callback_info info)418 static napi_value Ether_nToa(napi_env env, napi_callback_info info)
419 {
420     int backParam = INIT;
421     const struct ether_addr *firstParam = nullptr;
422     const char testParam[1][18] = {"5F:4E:2C:3D:1B:0A"};
423     firstParam = ether_aton(testParam[0]);
424     char *back = ether_ntoa(firstParam);
425     if (back != nullptr) {
426         backParam = SUCCESS;
427     }
428     napi_value result = nullptr;
429     napi_create_int32(env, backParam, &result);
430     return result;
431 }
432 
Ether_aTon_r(napi_env env, napi_callback_info info)433 static napi_value Ether_aTon_r(napi_env env, napi_callback_info info)
434 {
435     int backParam = INIT;
436     struct ether_addr *addr = (ether_addr *)malloc(sizeof(ether_addr));
437     struct ether_addr *checkParam = nullptr;
438     const char firstParam[1][18] = {"5F:4E:2C:3D:1B:0A"};
439     checkParam = ether_aton_r(firstParam[0], addr);
440     if (checkParam != nullptr) {
441         backParam = SUCCESS;
442     }
443     napi_value result = nullptr;
444     napi_create_int32(env, backParam, &result);
445     return result;
446 }
447 
EventFd(napi_env env, napi_callback_info info)448 static napi_value EventFd(napi_env env, napi_callback_info info)
449 {
450     int backParam = PARAM_0, secondParam = O_NONBLOCK;
451     backParam = eventfd(PARAM_2, secondParam);
452     napi_value result = nullptr;
453     napi_create_int32(env, backParam, &result);
454     close(backParam);
455     return result;
456 }
457 
EventFd_read(napi_env env, napi_callback_info info)458 static napi_value EventFd_read(napi_env env, napi_callback_info info)
459 {
460     int backParam = PARAM_0, secondParam = O_NONBLOCK;
461     int fd = eventfd(PARAM_2, secondParam);
462     eventfd_t value = PARAM_1;
463     backParam = eventfd_read(fd, &value);
464     close(fd);
465     napi_value result = nullptr;
466     napi_create_int32(env, backParam, &result);
467     return result;
468 }
469 
EventFd_write(napi_env env, napi_callback_info info)470 static napi_value EventFd_write(napi_env env, napi_callback_info info)
471 {
472     int backParam = PARAM_0, secondParam = O_NONBLOCK;
473     int fd = eventfd(PARAM_2, secondParam);
474     eventfd_t value = PARAM_1;
475     backParam = eventfd_write(fd, value);
476     close(fd);
477     napi_value result = nullptr;
478     napi_create_int32(env, backParam, &result);
479     return result;
480 }
481 
FGetXAttr(napi_env env, napi_callback_info info)482 static napi_value FGetXAttr(napi_env env, napi_callback_info info)
483 {
484     const char *path = "/data/storage/el2/base/files/Fzl.txt";
485     char buf[10];
486     int fd = open(path, O_CREAT | O_WRONLY, PARAM_0777);
487     int result = fsetxattr(fd, "user.foo", "bar", strlen("bar"), PARAM_0);
488     result = fgetxattr(fd, "user.foo", buf, sizeof(buf));
489     fremovexattr(fd, "user.foo");
490     close(fd);
491     napi_value ret = nullptr;
492     napi_create_int32(env, result, &ret);
493     return ret;
494 }
495 
UMask_chk(napi_env env, napi_callback_info info)496 static napi_value UMask_chk(napi_env env, napi_callback_info info)
497 {
498     errno = INIT;
499     mode_t checkParam;
500     mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
501     mode_t modeValue = __umask_chk(mode);
502     checkParam = __umask_chk(modeValue);
503     if (checkParam != (mode_t)MINUSONE) {
504         errno = SUCCESS;
505     }
506     napi_value result;
507     napi_create_int32(env, errno, &result);
508     return result;
509 }
510 
SendTo_chk(napi_env env, napi_callback_info info)511 static napi_value SendTo_chk(napi_env env, napi_callback_info info)
512 {
513     int sendRet = SUCCESS;
514     int pid = fork();
515     if (pid == PARAM_0) {
516         char sendBuf[] = "it is a test";
517         sendRet = __sendto_chk(PARAM_0, sendBuf, sizeof(sendBuf), sizeof(sendBuf), PARAM_0, nullptr, PARAM_0);
518         exit(PARAM_0);
519     }
520     napi_value result = nullptr;
521     napi_create_int32(env, sendRet, &result);
522     return result;
523 }
524 
Send_chk(napi_env env, napi_callback_info info)525 static napi_value Send_chk(napi_env env, napi_callback_info info)
526 {
527     int sendRet = SUCCESS;
528     int pid = fork();
529     if (pid == PARAM_0) {
530         char sendBuf[] = "x";
531         __send_chk(PARAM_0, sendBuf, sizeof(sendBuf), sizeof(sendBuf), PARAM_0);
532         exit(PARAM_0);
533     }
534     napi_value result = nullptr;
535     napi_create_int32(env, sendRet, &result);
536     return result;
537 }
RecV_chk(napi_env env, napi_callback_info info)538 static napi_value RecV_chk(napi_env env, napi_callback_info info)
539 {
540     int sendRet = SUCCESS;
541     int pid = fork();
542     if (pid == PARAM_0) {
543         size_t data_len = atoi("11");
544         char buf[SIZE_10];
545         sendRet = __recv_chk(PARAM_0, buf, data_len, data_len, PARAM_0);
546         exit(PARAM_0);
547     }
548     napi_value result = nullptr;
549     napi_create_int32(env, sendRet, &result);
550     return result;
551 }
552 
RecVFrom_chk(napi_env env, napi_callback_info info)553 static napi_value RecVFrom_chk(napi_env env, napi_callback_info info)
554 {
555     int sendRet = SUCCESS;
556     int pid = fork();
557     if (pid == PARAM_0) {
558         size_t data_len = atoi("11");
559         char buf[SIZE_10];
560         sendRet = __recvfrom_chk(PARAM_0, buf, data_len, data_len, PARAM_0, nullptr, nullptr);
561         exit(PARAM_0);
562     }
563     napi_value result = nullptr;
564     napi_create_int32(env, sendRet, &result);
565     return result;
566 }
567 
do_plain_tests(int (*fn1)(void *arg), void *arg1, int (*fn2)(void *arg), void *arg2)568 int do_plain_tests(int (*fn1)(void *arg), void *arg1, int (*fn2)(void *arg), void *arg2)
569 {
570     int ret = PARAM_0;
571     int pid = PARAM_0;
572     pid = fork();
573     if (pid == FAILD) {
574         return FAILD;
575     }
576     if (pid == PARAM_0) {
577         _exit(PARAM_0);
578     }
579     if (fn2) {
580         ret = fn2(arg2);
581     }
582     return ret;
583 }
cndwaittest(void *testarg)584 int cndwaittest(void *testarg)
585 {
586     mtx_t mutex;
587     cnd_t cond;
588     cnd_init(&cond);
589     mtx_lock(&mutex);
590     int backParam = cnd_wait(&cond, &mutex);
591     mtx_unlock(&mutex);
592     cnd_destroy(&cond);
593     mtx_destroy(&mutex);
594     return backParam;
595 }
596 
CndWait(napi_env env, napi_callback_info info)597 static napi_value CndWait(napi_env env, napi_callback_info info)
598 {
599     void *test = nullptr;
600     do_plain_tests(cndwaittest, test, nullptr, nullptr);
601     napi_value result = nullptr;
602     napi_create_int32(env, SUCCESS, &result);
603     return result;
604 }
605 
Duplocale(napi_env env, napi_callback_info info)606 static napi_value Duplocale(napi_env env, napi_callback_info info)
607 {
608     locale_t newLocale = __duplocale(LC_GLOBAL_LOCALE);
609     int backResult = PARAM_UNNORMAL;
610     if (newLocale != nullptr) {
611         backResult = SUCCESS;
612     }
613     napi_value result = nullptr;
614     napi_create_int32(env, backResult, &result);
615     return result;
616 }
617 
Errnolocation(napi_env env, napi_callback_info info)618 static napi_value Errnolocation(napi_env env, napi_callback_info info)
619 {
620     int errno_lo = *__errno_location();
621     int backResult = FAILD;
622     if (errno_lo >= PARAM_0) {
623         backResult = SUCCESS;
624     }
625     napi_value result = nullptr;
626     napi_create_int32(env, backResult, &result);
627     return result;
628 }
Fltrounds(napi_env env, napi_callback_info info)629 static napi_value Fltrounds(napi_env env, napi_callback_info info)
630 {
631     int backResult = __flt_rounds();
632     napi_value result = nullptr;
633     napi_create_int32(env, backResult, &result);
634     return result;
635 }
636 
Herrnolocation(napi_env env, napi_callback_info info)637 static napi_value Herrnolocation(napi_env env, napi_callback_info info)
638 {
639     int backInfo = FAILD;
640     int *backResult = __h_errno_location();
641     backInfo = *backResult;
642     if (backInfo >= PARAM_0) {
643         backInfo = SUCCESS;
644     }
645     napi_value result = nullptr;
646     napi_create_int32(env, backInfo, &result);
647     return result;
648 }
649 
Libccurrentsigrtmax(napi_env env, napi_callback_info info)650 static napi_value Libccurrentsigrtmax(napi_env env, napi_callback_info info)
651 {
652     int sigrtmax = __libc_current_sigrtmax();
653     int backInfo = FAILD;
654     if (sigrtmax > PARAM_0) {
655         backInfo = SUCCESS;
656     }
657     napi_value result = nullptr;
658     napi_create_int32(env, backInfo, &result);
659     return result;
660 }
661 
Libccurrentsigrtmin(napi_env env, napi_callback_info info)662 static napi_value Libccurrentsigrtmin(napi_env env, napi_callback_info info)
663 {
664     int sigrtmin = __libc_current_sigrtmin();
665     int backInfo = FAILD;
666     if (sigrtmin > PARAM_0) {
667         backInfo = SUCCESS;
668     }
669     napi_value result = nullptr;
670     napi_create_int32(env, backInfo, &result);
671     return result;
672 }
673 
Overflow(napi_env env, napi_callback_info info)674 static napi_value Overflow(napi_env env, napi_callback_info info)
675 {
676     size_t argc = PARAM_1;
677     napi_value args[1] = {nullptr};
678     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
679     size_t length = PARAM_256;
680     size_t strResult = PARAM_0;
681     char ptr[length];
682     napi_get_value_string_utf8(env, args[0], ptr, length, &strResult);
683     FILE *files = fopen(ptr, "w");
684     int backInfo = __overflow(files, PARAM_0);
685     fclose(files);
686     napi_value result = nullptr;
687     napi_create_int32(env, backInfo, &result);
688     return result;
689 }
690 
Uflow(napi_env env, napi_callback_info info)691 static napi_value Uflow(napi_env env, napi_callback_info info)
692 {
693     FILE *file = fopen("/data/storage/el2/base/files/example.txt", "w");
694     fprintf(file, "Hello, world!\nThis is a test file.\n");
695     fclose(file);
696     file = fopen("/data/storage/el2/base/files/example.txt", "r");
697     int backInfo = __uflow(file);
698     fclose(file);
699     if (backInfo == PARAM_72) {
700         backInfo = SUCCESS;
701     }
702     napi_value result = nullptr;
703     napi_create_int32(env, backInfo, &result);
704     return result;
705 }
706 
Tlsgetaddr(napi_env env, napi_callback_info infoS)707 static napi_value Tlsgetaddr(napi_env env, napi_callback_info infoS)
708 {
709     errno = NO_ERROR;
710     pid_t pid = fork();
711     if (pid == PARAM_0) {
712         __tls_get_addr((tls_mod_off_t[]){});
713         exit(PARAM_0);
714     }
715     napi_value result = nullptr;
716     napi_create_int32(env, errno, &result);
717     return result;
718 }
719 
Pthreadcleanuppop(napi_env env, napi_callback_info info)720 static napi_value Pthreadcleanuppop(napi_env env, napi_callback_info info)
721 {
722     errno = NO_ERROR;
723     struct __ptcb cb;
724     _pthread_cleanup_push(&cb, nullptr, nullptr);
725     _pthread_cleanup_pop(&cb, PARAM_0);
726     napi_value result = nullptr;
727     napi_create_int32(env, errno, &result);
728     return result;
729 }
730 
Pthreadcleanuppush(napi_env env, napi_callback_info info)731 static napi_value Pthreadcleanuppush(napi_env env, napi_callback_info info)
732 {
733     struct __ptcb cb;
734     errno = NO_ERROR;
735     _pthread_cleanup_push(&cb, nullptr, nullptr);
736     napi_value result = nullptr;
737     napi_create_int32(env, errno, &result);
738     return result;
739 }
740 
741 static pthread_barrier_t g_barrier;
742 
ClientTask(void *arg)743 void *ClientTask(void *arg)
744 {
745     int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
746     pthread_barrier_wait(&g_barrier);
747     if (sock >= PARAM_0) {
748         struct sockaddr_in server = {PARAM_0};
749         server.sin_family = AF_INET;
750         server.sin_port = htons(PORT);
751         server.sin_addr.s_addr = inet_addr("127.0.0.1");
752         connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)), sizeof(server));
753     }
754     close(sock);
755     return nullptr;
756 }
757 
ClientTask4(void *arg)758 void *ClientTask4(void *arg)
759 {
760     int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
761     pthread_barrier_wait(&g_barrier);
762     if (sock >= PARAM_0) {
763         struct sockaddr_in server = {PARAM_0};
764         server.sin_family = AF_INET;
765         server.sin_port = htons(PORT_2);
766         server.sin_addr.s_addr = inet_addr("127.0.0.1");
767         connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)), sizeof(server));
768     }
769     close(sock);
770     return nullptr;
771 }
772 
ServerTask(int sockfd, pthread_t cli)773 int ServerTask(int sockfd, pthread_t cli)
774 {
775     pthread_barrier_wait(&g_barrier);
776     struct sockaddr_in clnAddr = {PARAM_0};
777     socklen_t clnAddrLen = sizeof(clnAddr);
778     int sClient = accept(sockfd,
779         reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
780     int rets = (sClient > 0) ? PARAM_0 : PARAM_1;
781     close(sClient);
782     close(sockfd);
783     pthread_join(cli, nullptr);
784     pthread_barrier_destroy(&g_barrier);
785     return rets;
786 }
787 
Accept(napi_env env, napi_callback_info info)788 static napi_value Accept(napi_env env, napi_callback_info info)
789 {
790     napi_value result = nullptr;
791     int ret = PARAM_1;
792     int rets = pthread_barrier_init(&g_barrier, nullptr, PARAM_2);
793     if (rets != 0) {
794         napi_create_int32(env, PARAM_5, &result);
795         return result;
796     }
797     pid_t tid;
798     pthread_t cli;
799     rets = pthread_create(&cli, nullptr, ClientTask, &tid);
800     if (rets != 0) {
801         napi_create_int32(env, PARAM_5, &result);
802         return result;
803     }
804     int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
805     if (sockfd < PARAM_0) {
806         ret = PARAM_2;
807     } else {
808         struct sockaddr_in local;
809         memset_s(&local, sizeof(local), 0, sizeof(local));
810         local.sin_family = AF_INET;
811         local.sin_port = htons(PORT);
812         local.sin_addr.s_addr = inet_addr("127.0.0.1");
813         rets = bind(sockfd, reinterpret_cast<sockaddr *>(&local), sizeof(local));
814         if (rets != PARAM_0) {
815             ret = PARAM_3;
816         } else {
817             rets = listen(sockfd, PARAM_5);
818             if (rets != PARAM_0) {
819                 ret = PARAM_4;
820             } else {
821                 ret = ServerTask(sockfd, cli);
822                 napi_create_int32(env, ret, &result);
823                 return result;
824             }
825         }
826     }
827     close(sockfd);
828     pthread_barrier_wait(&g_barrier);
829     pthread_join(cli, nullptr);
830     pthread_barrier_destroy(&g_barrier);
831     napi_create_int32(env, ret, &result);
832     return result;
833 }
834 
Accept4(napi_env env, napi_callback_info info)835 static napi_value Accept4(napi_env env, napi_callback_info info)
836 {
837     napi_value result = nullptr;
838     int ret = PARAM_1;
839     int rets = pthread_barrier_init(&g_barrier, nullptr, PARAM_2);
840     if (rets != 0) {
841         napi_create_int32(env, PARAM_5, &result);
842         return result;
843     }
844     pid_t tid;
845     pthread_t cli;
846     rets = pthread_create(&cli, nullptr, ClientTask4, &tid);
847     if (rets != 0) {
848         napi_create_int32(env, PARAM_4, &result);
849         return result;
850     }
851     const char *gLocalHost = "127.0.0.1";
852     int sListen = socket(AF_INET, SOCK_STREAM, PARAM_0);
853     if (sListen != MINUSONE) {
854         int flag = PARAM_1;
855         rets = setsockopt(sListen, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(int));
856         if (rets != PARAM_0) {
857             ret = -PARAM_1;
858         } else {
859             struct sockaddr_in srvAddr = {0};
860             srvAddr.sin_family = AF_INET;
861             srvAddr.sin_addr.s_addr = inet_addr(gLocalHost);
862             srvAddr.sin_port = htons(PORT_2);
863             rets = bind(sListen,
864                 reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&srvAddr)), sizeof(srvAddr));
865             if (rets != PARAM_0) {
866                 ret = PARAM_3;
867             } else {
868                 rets = listen(sListen, PARAM_2);
869                 if (rets != PARAM_0) {
870                     ret = PARAM_2;
871                 } else {
872                     ret = ServerTask(sListen, cli);
873                     napi_create_int32(env, ret, &result);
874                     return result;
875                 }
876             }
877         }
878     }
879     close(sListen);
880     pthread_barrier_wait(&g_barrier);
881     pthread_join(cli, nullptr);
882     pthread_barrier_destroy(&g_barrier);
883     napi_create_int32(env, ret, &result);
884     return result;
885 }
886 
Deletemodule(napi_env env, napi_callback_info info)887 static napi_value Deletemodule(napi_env env, napi_callback_info info)
888 {
889     int backInfo = SUCCESS;
890     errno = NO_ERROR;
891     pid_t pid = fork();
892     if (pid == NO_ERROR) {
893         const char *put_old = "0";
894         if (access(put_old, F_OK) == 0) {
895             delete_module(put_old, PARAM_5);
896         }
897         exit(PARAM_0);
898     }
899     napi_value result = nullptr;
900     napi_create_int32(env, backInfo, &result);
901     return result;
902 }
903 
Quickexit(napi_env env, napi_callback_info info)904 static napi_value Quickexit(napi_env env, napi_callback_info info)
905 {
906     errno = NO_ERROR;
907     pid_t pid = fork();
908     if (pid == NO_ERROR) {
909         sleep(PARAM_1);
910         quick_exit(EXIT_SUCCESS);
911     } else if (pid > NO_ERROR) {
912     } else {
913         exit(EXIT_FAILURE);
914     }
915     napi_value result = nullptr;
916     napi_create_int32(env, errno, &result);
917     return result;
918 }
919 
Optresets(napi_env env, napi_callback_info info)920 static napi_value Optresets(napi_env env, napi_callback_info info)
921 {
922     napi_value result = nullptr;
923     napi_create_int32(env, optreset, &result);
924     return result;
925 }
926 
927 std::atomic<bool> isPthreadTestRun  (true);
928 
pthread_test(void *arg)929 void *pthread_test(void *arg)
930 {
931     *((pid_t *)arg) = gettid();
932     while(isPthreadTestRun)
933     {
934         sleep(SLEEPTIME);
935     }
936     return nullptr;
937 }
Pthreadgettidnp(napi_env env, napi_callback_info info)938 static napi_value Pthreadgettidnp(napi_env env, napi_callback_info info)
939 {
940     pid_t tid;
941     pthread_t t;
942     int backInfo = FAILD;
943     pthread_create(&t, nullptr, pthread_test, &tid);
944     pid_t recv_result = pthread_gettid_np(t);
945     isPthreadTestRun = false;
946     pthread_join(t,nullptr);
947     if (recv_result > NO_ERROR) {
948         backInfo = SUCCESS;
949     }
950     napi_value result = nullptr;
951     napi_create_int32(env, backInfo, &result);
952     return result;
953 }
954 
Getfatalmessage(napi_env env, napi_callback_info info)955 static napi_value Getfatalmessage(napi_env env, napi_callback_info info)
956 {
957     int backInfo = SUCCESS;
958     const char msg[1024] = {"abcdefghijklmnopqrstuvwxyz1234567890"};
959     const char msg1[1024] = {"abcdefghijklmnopqr"};
960     fatal_msg_t *fatal_message = nullptr;
961 
962     int pidChild = PARAM_0;
963 
964     pid_t fpid = fork();
965     if (fpid == pidChild) {
966         pidChild = getpid();
967         set_fatal_message(msg);
968         fatal_message = get_fatal_message();
969         if (fatal_message == nullptr) {
970             backInfo = FAILD;
971         }
972         set_fatal_message(msg1);
973         fatal_message = get_fatal_message();
974         if (fatal_message == nullptr) {
975             backInfo = FAILD;
976         }
977         exit(pidChild);
978     }
979     napi_value result = nullptr;
980     napi_create_int32(env, backInfo, &result);
981     return result;
982 }
983 
Pthreadcondclockwait(napi_env env, napi_callback_info info)984 static napi_value Pthreadcondclockwait(napi_env env, napi_callback_info info)
985 {
986     pthread_condattr_t a;
987     (pthread_condattr_init(&a), PARAM_0);
988     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
989     pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
990     struct timespec ts = {0};
991     clockid_t clock_id = CLOCK_REALTIME;
992     int clockwait = pthread_cond_clockwait(&cond, &mutex, clock_id, &ts);
993     int backInfo = FAILD;
994     if (clockwait > NO_ERROR) {
995         backInfo = SUCCESS;
996     }
997     napi_value result = nullptr;
998     napi_create_int32(env, backInfo, &result);
999     return result;
1000 }
1001 
Pthreadcondtimedwaitmonotonicnp(napi_env env, napi_callback_info info)1002 static napi_value Pthreadcondtimedwaitmonotonicnp(napi_env env, napi_callback_info info)
1003 {
1004     pthread_cond_t *cond = (pthread_cond_t *)nullptr;
1005     pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
1006     struct timespec ts = {0};
1007     int pthread = pthread_cond_timedwait_monotonic_np(cond, &mutex, &ts);
1008     int backInfo = FAILD;
1009     if (pthread > NO_ERROR) {
1010         backInfo = SUCCESS;
1011     }
1012     napi_value result = nullptr;
1013     napi_create_int32(env, backInfo, &result);
1014     return result;
1015 }
1016 
Pthreadcondtimeoutnp(napi_env env, napi_callback_info info)1017 static napi_value Pthreadcondtimeoutnp(napi_env env, napi_callback_info info)
1018 {
1019     unsigned int ms = PARAM_100;
1020     pthread_condattr_t a;
1021     pthread_condattr_init(&a);
1022     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
1023     pthread_cond_init(&cond, &a);
1024     pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
1025     int pthread = pthread_cond_timeout_np(&cond, &mutex, ms);
1026     pthread_mutex_unlock(&mutex);
1027     pthread_cond_destroy(&cond);
1028     pthread_mutex_destroy(&mutex);
1029     int backInfo = FAILD;
1030     if (pthread > PARAM_0) {
1031         backInfo = SUCCESS;
1032     }
1033     napi_value result = nullptr;
1034     napi_create_int32(env, backInfo, &result);
1035     return result;
1036 }
1037 
Pthreadgetnamenp(napi_env env, napi_callback_info info)1038 static napi_value Pthreadgetnamenp(napi_env env, napi_callback_info info)
1039 {
1040     char thread_name[NAMELEN];
1041     int pthread = pthread_getname_np(pthread_self(), thread_name, NAMELEN - PARAM_1);
1042     int backInfo = FAILD;
1043     if (pthread > PARAM_0) {
1044         backInfo = SUCCESS;
1045     }
1046     napi_value result = nullptr;
1047     napi_create_int32(env, backInfo, &result);
1048     return result;
1049 }
1050 
Msleep(int msec)1051 static inline void Msleep(int msec) { usleep(msec * MS_PER_S); }
GetDelayedTimeByClockid(struct timespec *ts, unsigned int ms, clockid_t clockid)1052 static inline void GetDelayedTimeByClockid(struct timespec *ts, unsigned int ms, clockid_t clockid)
1053 {
1054     const unsigned int nsecPerSec = NSEC_PER_SEC;
1055     unsigned int setTimeNs = ms * US_PER_S;
1056     struct timespec tsNow = {0};
1057     clock_gettime(clockid, &tsNow);
1058     ts->tv_sec = tsNow.tv_sec + (tsNow.tv_nsec + setTimeNs) / nsecPerSec;
1059     ts->tv_nsec = (tsNow.tv_nsec + setTimeNs) % nsecPerSec;
1060 }
PthreadLockTimeoutNPNoOut(void *arg)1061 static void *PthreadLockTimeoutNPNoOut(void *arg)
1062 {
1063     pthread_mutex_t *mtx = (pthread_mutex_t *)arg;
1064     unsigned ms = DELAY_TIME_100_MS;
1065     struct timespec ts = {0};
1066 
1067     Msleep(SLEEP_20_MS);
1068     GetDelayedTimeByClockid(&ts, ms, CLOCK_MONOTONIC);
1069     pthread_mutex_lock_timeout_np(mtx, ms);
1070     return arg;
1071 }
Pthreadmutexlocktimeoutnp(napi_env env, napi_callback_info info)1072 static napi_value Pthreadmutexlocktimeoutnp(napi_env env, napi_callback_info info)
1073 {
1074     errno = NO_ERROR;
1075     pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
1076     pthread_t tid;
1077     pthread_create(&tid, nullptr, PthreadLockTimeoutNPNoOut, (void *)&mtx);
1078 
1079     pthread_mutex_lock(&mtx);
1080     Msleep(SLEEP_50_MS);
1081     pthread_mutex_unlock(&mtx);
1082 
1083     pthread_join(tid, nullptr);
1084     napi_value result = nullptr;
1085     napi_create_int32(env, errno, &result);
1086     return result;
1087 }
GetTimeDiff(struct timespec ts1, struct timespec ts2)1088 static inline int GetTimeDiff(struct timespec ts1, struct timespec ts2)
1089 {
1090     const unsigned int nsecPerSec = NSEC_PER_SEC;
1091     int ms = (ts1.tv_sec - ts2.tv_sec) * nsecPerSec + (ts1.tv_nsec - ts2.tv_nsec);
1092     ms = ms / NSEC_PER_MSEC;
1093     return ms;
1094 }
PthreadTimedlockMonotonicNPOut(void *arg)1095 static void *PthreadTimedlockMonotonicNPOut(void *arg)
1096 {
1097     pthread_mutex_t *mtx = (pthread_mutex_t *)arg;
1098     struct timespec ts = {0};
1099     struct timespec tsNow = {0};
1100 
1101     Msleep(SLEEP_20_MS);
1102     GetDelayedTimeByClockid(&ts, DELAY_TIME_100_MS, CLOCK_MONOTONIC);
1103     pthread_mutex_timedlock_monotonic_np(mtx, &ts);
1104 
1105     clock_gettime(CLOCK_MONOTONIC, &tsNow);
1106     GetTimeDiff(tsNow, ts); // calculate time different
1107 
1108     return arg;
1109 }
Pthreadmutextimedlockmonotonicnp(napi_env env, napi_callback_info info)1110 static napi_value Pthreadmutextimedlockmonotonicnp(napi_env env, napi_callback_info info)
1111 {
1112     errno = NO_ERROR;
1113     pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
1114     pthread_t tid;
1115     pthread_create(&tid, nullptr, PthreadTimedlockMonotonicNPOut, (void *)&mtx);
1116 
1117     pthread_mutex_lock(&mtx);
1118     Msleep(SLEEP_50_MS);
1119     Msleep(SLEEP_100_MS);
1120     pthread_mutex_unlock(&mtx);
1121 
1122     pthread_join(tid, nullptr);
1123     napi_value result = nullptr;
1124     napi_create_int32(env, errno, &result);
1125     return result;
1126 }
PthreadClocklockNoOutRealTime(void *arg)1127 static void *PthreadClocklockNoOutRealTime(void *arg)
1128 {
1129     pthread_mutex_t *mtx = (pthread_mutex_t *)arg;
1130     struct timespec ts = {0};
1131 
1132     Msleep(SLEEP_20_MS);
1133     GetDelayedTimeByClockid(&ts, DELAY_TIME_100_MS, CLOCK_REALTIME);
1134     pthread_mutex_clocklock(mtx, CLOCK_REALTIME, &ts);
1135     return arg;
1136 }
Pthreadmutexclocklock(napi_env env, napi_callback_info info)1137 static napi_value Pthreadmutexclocklock(napi_env env, napi_callback_info info)
1138 {
1139     errno = NO_ERROR;
1140     pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
1141     pthread_t tid;
1142     pthread_create(&tid, nullptr, PthreadClocklockNoOutRealTime, (void *)&mtx);
1143 
1144     pthread_mutex_lock(&mtx);
1145     Msleep(SLEEP_50_MS);
1146     pthread_mutex_unlock(&mtx);
1147 
1148     pthread_join(tid, nullptr);
1149     napi_value result = nullptr;
1150     napi_create_int32(env, errno, &result);
1151     return result;
1152 }
1153 pthread_rwlock_t g_rwlock1;
1154 
PthreadClockRdlockNoOutRealTimeW1(void *arg)1155 static void *PthreadClockRdlockNoOutRealTimeW1(void *arg)
1156 {
1157     pthread_rwlock_wrlock(&g_rwlock1);
1158     Msleep(SLEEP_50_MS);
1159     pthread_rwlock_unlock(&g_rwlock1);
1160     return arg;
1161 }
1162 
PthreadClockRdlockNoOutRealTimeR2(void *arg)1163 static void *PthreadClockRdlockNoOutRealTimeR2(void *arg)
1164 {
1165     struct timespec ts = {0};
1166     Msleep(SLEEP_20_MS);
1167     GetDelayedTimeByClockid(&ts, DELAY_TIME_100_MS, CLOCK_REALTIME);
1168     pthread_rwlock_clockrdlock(&g_rwlock1, CLOCK_REALTIME, &ts);
1169     pthread_rwlock_unlock(&g_rwlock1);
1170     return arg;
1171 }
Pthreadrwlockclockrdlock(napi_env env, napi_callback_info info)1172 static napi_value Pthreadrwlockclockrdlock(napi_env env, napi_callback_info info)
1173 {
1174     errno = NO_ERROR;
1175     pthread_t tid[2];
1176     pthread_rwlock_init(&g_rwlock1, nullptr);
1177 
1178     pthread_create(&tid[0], nullptr, PthreadClockRdlockNoOutRealTimeW1, nullptr);
1179     pthread_create(&tid[1], nullptr, PthreadClockRdlockNoOutRealTimeR2, nullptr);
1180 
1181     pthread_join(tid[0], nullptr);
1182     pthread_join(tid[1], nullptr);
1183     pthread_rwlock_destroy(&g_rwlock1);
1184     napi_value result = nullptr;
1185     napi_create_int32(env, errno, &result);
1186     return result;
1187 }
1188 
Pthreadrwlockclockwrlock(napi_env env, napi_callback_info info)1189 static napi_value Pthreadrwlockclockwrlock(napi_env env, napi_callback_info info)
1190 {
1191     pthread_rwlock_t w;
1192     struct timespec ts = {0};
1193     clockid_t clock_id = CLOCK_REALTIME;
1194     clock_gettime(CLOCK_REALTIME, &ts);
1195     pthread_rwlock_init(&w, nullptr);
1196     pthread_rwlock_wrlock(&w);
1197     GetDelayedTimeByClockid(&ts, SLEEP_100_MS, clock_id);
1198     int pthread = pthread_rwlock_clockwrlock(&w, clock_id, &ts);
1199     pthread_rwlock_unlock(&w);
1200     pthread_rwlock_destroy(&w);
1201     int backInfo = FAILD;
1202     if (pthread > PARAM_0) {
1203         backInfo = SUCCESS;
1204     }
1205     napi_value result = nullptr;
1206     napi_create_int32(env, backInfo, &result);
1207     return result;
1208 }
1209 pthread_rwlock_t g_rwlock5;
PthreadTimedRdlockMonoNPNoOutW1(void *arg)1210 static void *PthreadTimedRdlockMonoNPNoOutW1(void *arg)
1211 {
1212     pthread_rwlock_wrlock(&g_rwlock5);
1213     Msleep(SLEEP_50_MS);
1214     pthread_rwlock_unlock(&g_rwlock5);
1215     return arg;
1216 }
1217 
PthreadTimedRdlockMonoNPNoOutR2(void *arg)1218 static void *PthreadTimedRdlockMonoNPNoOutR2(void *arg)
1219 {
1220     struct timespec ts = {0};
1221     Msleep(SLEEP_20_MS);
1222     GetDelayedTimeByClockid(&ts, DELAY_TIME_100_MS, CLOCK_MONOTONIC);
1223     pthread_rwlock_timedrdlock_monotonic_np(&g_rwlock5, &ts);
1224     pthread_rwlock_unlock(&g_rwlock5);
1225     return arg;
1226 }
Pthreadrwlocktimedrdlockmonotonicnp(napi_env env, napi_callback_info info)1227 static napi_value Pthreadrwlocktimedrdlockmonotonicnp(napi_env env, napi_callback_info info)
1228 {
1229     errno = NO_ERROR;
1230     pthread_t tid[2];
1231     pthread_rwlock_init(&g_rwlock5, nullptr);
1232 
1233     pthread_create(&tid[0], nullptr, PthreadTimedRdlockMonoNPNoOutW1, nullptr);
1234     pthread_create(&tid[1], nullptr, PthreadTimedRdlockMonoNPNoOutR2, nullptr);
1235 
1236     pthread_join(tid[0], nullptr);
1237     pthread_join(tid[1], nullptr);
1238     pthread_rwlock_destroy(&g_rwlock5);
1239     napi_value result = nullptr;
1240     napi_create_int32(env, errno, &result);
1241     return result;
1242 }
1243 
Pthreadrwlocktimedwrlockmonotonicnp(napi_env env, napi_callback_info info)1244 static napi_value Pthreadrwlocktimedwrlockmonotonicnp(napi_env env, napi_callback_info info)
1245 {
1246     struct timespec ts = {0};
1247     int pthread = pthread_rwlock_timedwrlock_monotonic_np((pthread_rwlock_t *)nullptr, &ts);
1248     int backInfo = FAILD;
1249     if (pthread > PARAM_0) {
1250         backInfo = SUCCESS;
1251     }
1252     napi_value result = nullptr;
1253     napi_create_int32(env, backInfo, &result);
1254     return result;
1255 }
1256 
Setapplicationtargetsdkversion(napi_env env, napi_callback_info info)1257 static napi_value Setapplicationtargetsdkversion(napi_env env, napi_callback_info info)
1258 {
1259     set_application_target_sdk_version(PARAM_0);
1260     int pthread = get_application_target_sdk_version();
1261     int backInfo = FAILD;
1262     if (pthread > SUCCESS) {
1263         backInfo = SUCCESS;
1264     }
1265     napi_value result = nullptr;
1266     napi_create_int32(env, backInfo, &result);
1267     return result;
1268 }
Setfatalmessage(napi_env env, napi_callback_info info)1269 static napi_value Setfatalmessage(napi_env env, napi_callback_info info)
1270 {
1271     errno = NO_ERROR;
1272     const char msg[1024] = {"abcdefghijklmnopqrstuvwxyz1234567890"};
1273     const char msg1[1024] = {"abcdefghijklmnopqr"};
1274     fatal_msg_t *fatal_message = nullptr;
1275     int pidChild = PARAM_0;
1276     pid_t fpid = fork();
1277     if (fpid < NO_ERROR) {
1278     } else if (fpid == NO_ERROR) {
1279         pidChild = getpid();
1280         set_fatal_message(msg);
1281         fatal_message = get_fatal_message();
1282         strcmp(fatal_message->msg, msg);
1283 
1284         set_fatal_message(msg1);
1285         fatal_message = get_fatal_message();
1286         strcmp(fatal_message->msg, msg);
1287 
1288         exit(pidChild);
1289     }
1290     napi_value result = nullptr;
1291     napi_create_int32(env, errno, &result);
1292     return result;
1293 }
1294 
Ctypegetmbcurmax(napi_env env, napi_callback_info info)1295 static napi_value Ctypegetmbcurmax(napi_env env, napi_callback_info info)
1296 {
1297     int rev = __ctype_get_mb_cur_max();
1298     if (rev >= PARAM_0) {
1299         rev = SUCCESS;
1300     }
1301     napi_value result = nullptr;
1302     napi_create_int32(env, rev, &result);
1303     return result;
1304 }
1305 
PSyslog(char *format, ...)1306 void PSyslog(char *format, ...)
1307 {
1308     va_list ap;
1309     va_start(ap, format);
1310     vsyslog(LOG_INFO, format, ap);
1311     va_end(ap);
1312 }
1313 
Vsyslog(napi_env env, napi_callback_info info)1314 static napi_value Vsyslog(napi_env env, napi_callback_info info)
1315 {
1316     errno = PARAM_0;
1317     openlog("main", LOG_PID, PARAM_0);
1318     int a = PARAM_10;
1319     char msg[1024] = {"test is %d\n"};
1320     PSyslog(msg, a);
1321     closelog();
1322     napi_value result = nullptr;
1323     napi_create_int32(env, errno, &result);
1324     return result;
1325 }
1326 EXTERN_C_START
Init(napi_env env, napi_value exports)1327 static napi_value Init(napi_env env, napi_value exports)
1328 {
1329     napi_property_descriptor desc[] = {
1330         {"dn_comp", nullptr, Dn_comp, nullptr, nullptr, nullptr, napi_default, nullptr},
1331         {"dn_skipname", nullptr, Dn_skipname, nullptr, nullptr, nullptr, napi_default, nullptr},
1332         {"drem", nullptr, DRem, nullptr, nullptr, nullptr, napi_default, nullptr},
1333         {"dremf", nullptr, DRemF, nullptr, nullptr, nullptr, napi_default, nullptr},
1334         {"finite", nullptr, Finite, nullptr, nullptr, nullptr, napi_default, nullptr},
1335         {"finitef", nullptr, FiniteF, nullptr, nullptr, nullptr, napi_default, nullptr},
1336         {"endmntent", nullptr, EndMntEnt, nullptr, nullptr, nullptr, napi_default, nullptr},
1337         {"clone", nullptr, Clone, nullptr, nullptr, nullptr, napi_default, nullptr},
1338         {"endutent", nullptr, EndUTent, nullptr, nullptr, nullptr, napi_default, nullptr},
1339         {"epoll_create", nullptr, Epoll_create, nullptr, nullptr, nullptr, napi_default, nullptr},
1340         {"epoll_create1", nullptr, Epoll_create1, nullptr, nullptr, nullptr, napi_default, nullptr},
1341         {"epoll_ctl", nullptr, Epoll_ctl, nullptr, nullptr, nullptr, napi_default, nullptr},
1342         {"epoll_pwait", nullptr, Epoll_PWait, nullptr, nullptr, nullptr, napi_default, nullptr},
1343         {"epoll_wait", nullptr, Epoll_Wait, nullptr, nullptr, nullptr, napi_default, nullptr},
1344         {"ether_aton", nullptr, Ether_aTon, nullptr, nullptr, nullptr, napi_default, nullptr},
1345         {"ether_aton_r", nullptr, Ether_aTon_r, nullptr, nullptr, nullptr, napi_default, nullptr},
1346         {"ether_ntoa", nullptr, Ether_nToa, nullptr, nullptr, nullptr, napi_default, nullptr},
1347         {"ether_ntoa_r", nullptr, Ether_nToa_r, nullptr, nullptr, nullptr, napi_default, nullptr},
1348         {"eventfd", nullptr, EventFd, nullptr, nullptr, nullptr, napi_default, nullptr},
1349         {"eventfd_read", nullptr, EventFd_read, nullptr, nullptr, nullptr, napi_default, nullptr},
1350         {"eventfd_write", nullptr, EventFd_write, nullptr, nullptr, nullptr, napi_default, nullptr},
1351         {"fgetxattr", nullptr, FGetXAttr, nullptr, nullptr, nullptr, napi_default, nullptr},
1352         {"dirname", nullptr, DirName, nullptr, nullptr, nullptr, napi_default, nullptr},
1353         {"closelog", nullptr, CloseLog, nullptr, nullptr, nullptr, napi_default, nullptr},
1354         {"dlopen", nullptr, DlOpen, nullptr, nullptr, nullptr, napi_default, nullptr},
1355         {"dlclose", nullptr, DlClose, nullptr, nullptr, nullptr, napi_default, nullptr},
1356         {"dlerror", nullptr, DlError, nullptr, nullptr, nullptr, napi_default, nullptr},
1357         {"dladdr", nullptr, DlaDdr, nullptr, nullptr, nullptr, napi_default, nullptr},
1358         {"flock", nullptr, Flock, nullptr, nullptr, nullptr, napi_default, nullptr},
1359         {"__umask_chk", nullptr, UMask_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1360         {"__recv_chk", nullptr, RecV_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1361         {"__recvfrom_chk", nullptr, RecVFrom_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1362         {"__send_chk", nullptr, Send_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1363         {"__sendto_chk", nullptr, SendTo_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1364         {"cndWait", nullptr, CndWait, nullptr, nullptr, nullptr, napi_default, nullptr},
1365         {"ctypegetmbcurmax", nullptr, Ctypegetmbcurmax, nullptr, nullptr, nullptr, napi_default, nullptr},
1366         {"duplocale", nullptr, Duplocale, nullptr, nullptr, nullptr, napi_default, nullptr},
1367         {"errnolocation", nullptr, Errnolocation, nullptr, nullptr, nullptr, napi_default, nullptr},
1368         {"fltrounds", nullptr, Fltrounds, nullptr, nullptr, nullptr, napi_default, nullptr},
1369         {"herrnolocation", nullptr, Herrnolocation, nullptr, nullptr, nullptr, napi_default, nullptr},
1370         {"libccurrentsigrtmax", nullptr, Libccurrentsigrtmax, nullptr, nullptr, nullptr, napi_default, nullptr},
1371         {"libccurrentsigrtmin", nullptr, Libccurrentsigrtmin, nullptr, nullptr, nullptr, napi_default, nullptr},
1372         {"overflow", nullptr, Overflow, nullptr, nullptr, nullptr, napi_default, nullptr},
1373         {"tlsgetaddr", nullptr, Tlsgetaddr, nullptr, nullptr, nullptr, napi_default, nullptr},
1374         {"uflow", nullptr, Uflow, nullptr, nullptr, nullptr, napi_default, nullptr},
1375         {"pthreadcleanuppop", nullptr, Pthreadcleanuppop, nullptr, nullptr, nullptr, napi_default, nullptr},
1376         {"pthreadcleanuppush", nullptr, Pthreadcleanuppush, nullptr, nullptr, nullptr, napi_default, nullptr},
1377         {"accept", nullptr, Accept, nullptr, nullptr, nullptr, napi_default, nullptr},
1378         {"accept4", nullptr, Accept4, nullptr, nullptr, nullptr, napi_default, nullptr},
1379         {"delete_module", nullptr, Deletemodule, nullptr, nullptr, nullptr, napi_default, nullptr},
1380         {"pthreadgettidnp", nullptr, Pthreadgettidnp, nullptr, nullptr, nullptr, napi_default, nullptr},
1381         {"quickexit", nullptr, Quickexit, nullptr, nullptr, nullptr, napi_default, nullptr},
1382         {"optreset", nullptr, Optresets, nullptr, nullptr, nullptr, napi_default, nullptr},
1383         {"getfatalmessage", nullptr, Getfatalmessage, nullptr, nullptr, nullptr, napi_default, nullptr},
1384         {"pthreadcondclockwait", nullptr, Pthreadcondclockwait, nullptr, nullptr, nullptr, napi_default, nullptr},
1385         {"pthreadcondtimedwaitmonotonicnp", nullptr, Pthreadcondtimedwaitmonotonicnp, nullptr, nullptr, nullptr,
1386          napi_default, nullptr},
1387         {"pthreadcondtimeoutnp", nullptr, Pthreadcondtimeoutnp, nullptr, nullptr, nullptr, napi_default, nullptr},
1388         {"pthreadgetnamenp", nullptr, Pthreadgetnamenp, nullptr, nullptr, nullptr, napi_default, nullptr},
1389         {"pthreadmutexlocktimeoutnp", nullptr, Pthreadmutexlocktimeoutnp, nullptr, nullptr, nullptr, napi_default,
1390          nullptr},
1391         {"pthreadmutextimedlockmonotonicnp", nullptr, Pthreadmutextimedlockmonotonicnp, nullptr, nullptr, nullptr,
1392          napi_default, nullptr},
1393         {"pthreadmutexclocklock", nullptr, Pthreadmutexclocklock, nullptr, nullptr, nullptr, napi_default, nullptr},
1394         {"pthreadrwlockclockrdlock", nullptr, Pthreadrwlockclockrdlock, nullptr, nullptr, nullptr, napi_default,
1395          nullptr},
1396         {"pthreadrwlockclockwrlock", nullptr, Pthreadrwlockclockwrlock, nullptr, nullptr, nullptr, napi_default,
1397          nullptr},
1398         {"pthreadrwlocktimedrdlockmonotonicnp", nullptr, Pthreadrwlocktimedrdlockmonotonicnp, nullptr, nullptr, nullptr,
1399          napi_default, nullptr},
1400         {"pthreadrwlocktimedwrlockmonotonicnp", nullptr, Pthreadrwlocktimedwrlockmonotonicnp, nullptr, nullptr, nullptr,
1401          napi_default, nullptr},
1402         {"setapplicationtargetsdkversion", nullptr, Setapplicationtargetsdkversion, nullptr, nullptr, nullptr,
1403          napi_default, nullptr},
1404         {"setfatalmessage", nullptr, Setfatalmessage, nullptr, nullptr, nullptr, napi_default, nullptr},
1405         {"vsyslog", nullptr, Vsyslog, nullptr, nullptr, nullptr, napi_default, nullptr},
1406 
1407     };
1408     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1409     return exports;
1410 }
1411 EXTERN_C_END
1412 
1413 static napi_module demoModule = {
1414     .nm_version = 1,
1415     .nm_flags = 0,
1416     .nm_filename = nullptr,
1417     .nm_register_func = Init,
1418     .nm_modname = "libotherstestndk",
1419     .nm_priv = ((void *)0),
1420     .reserved = {0},
1421 };
1422 
RegisterModule(void)1423 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
1424