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