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