1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "common/napi_helper.cpp"
17 #include "common/native_common.h"
18 #include "napi/native_api.h"
19 #include <cstdarg>
20 #include <cstdio>
21 #include <cstdlib>
22 #include <cstring>
23 #include <fcntl.h>
24 #include <sys/inotify.h>
25 #include <unistd.h>
26 #include <utmp.h>
27 #include <uv.h>
28
29 #define SBUF_SIZE 128
30 #define ONEVAL 1
31 #define MINUSONE (-1)
32 #define SUCCESS 1
33 #define ERRON_0 0
34 #define SIZE_20 20
35 #define PARAM_1 1
36 #define PARAM_2 2
37 #define ZEROVAL 0
38 #define PATH "/data/storage/el2/base/files"
39 #define TEST_MODE 0666
40 #define PARAM_0777 0777
41 #define SBUF_SIZE 128
42 #define ZEROVAL 0
43 #define ONEVAL 1
44 #define MINUSONE (-1)
45 #define SIXFOUR 64
46 #define ONEEIGHT 18
47 #define MAX_NAMBER 1024
48 #define HUNDRED 100
49 #define MAX_NUMBER 128
50 #define NO_ERR 0
51 #define SUCCESS 1
52 #define FAIL (-1)
53 #define ZERO 0
54 #define PARAM_0 0
55 #define PARAM_1 1
56 #define PARAM_5 5
57 #define PARAM_13 13
58 #define SIZE_64 64
59 #define PARAM_123 123
60 #define PARAM_321 321
61 #define HUNDRED 100
62 #define PATH "/data/storage/el2/base/files"
63 #define STRLENGTH 64
64 #define ONE 1
65 #define PARAM_2 2
66 #define PARAM_UNNORMAL (-1)
67 #define RETURN_0 0
68 #define SIZE_10 10
69 #define SIZE_20 20
70 #define SIZE_100 100
71 #define SIZE_1024 1024
72 #define SIZE_4096 4096
73 #define SIZE_8192 8192
74 #define ONESIX 16
75 #define DEF_VALUE (-2)
76 #define PARAM_10 10
77 #define LENGTH 256
78 #define RUTVAL 112
79 #define STR_VFSCANF_TXT "/data/storage/el2/base/files/Fzl.txt"
80
81 extern "C" int __vsprintf_chk(char *dest, int flags, size_t dst_len_from_compiler, const char *format, va_list va);
82
83 extern "C" size_t __fread_chk(void *, size_t, size_t, FILE *, size_t);
84 extern "C" char *__fgets_chk(char *, int, FILE *, size_t);
85 extern "C" ssize_t __pwrite_chk(int fd, const void *buf, size_t count, off_t offset, size_t buf_size);
86 extern "C" ssize_t __write_chk(int fd, const void *buf, size_t count, size_t buf_size);
87 extern "C" int __sprintf_chk(char *dest, int flags, size_t dst_len_from_compiler, const char *format, ...);
88 extern "C" int __snprintf_chk(char *dest, size_t supplied_size, int flags, size_t dst_len_from_compiler,
89 const char *format, ...);
90 extern "C" int __vsnprintf_chk(char *dest, size_t supplied_size, int flags, size_t dst_len_from_compiler,
91 const char *format, va_list va);
92
Setbuf(napi_env env, napi_callback_info info)93 static napi_value Setbuf(napi_env env, napi_callback_info info)
94 {
95 errno = ERRON_0;
96 FILE *f = fopen(STR_VFSCANF_TXT, "w+");
97 NAPI_ASSERT(env, f != nullptr, "Setbuf fopen Error");
98 setbuf(f, nullptr);
99 fclose(f);
100 napi_value result = nullptr;
101 napi_create_int32(env, errno, &result);
102 return result;
103 }
104
Setbuffer(napi_env env, napi_callback_info info)105 static napi_value Setbuffer(napi_env env, napi_callback_info info)
106 {
107 errno = ERRON_0;
108 FILE *f = fopen(STR_VFSCANF_TXT, "w+");
109 NAPI_ASSERT(env, f != nullptr, "Setbuffer fopen Error");
110 setbuffer(f, nullptr, BUFSIZ);
111 fclose(f);
112 napi_value result = nullptr;
113 napi_create_int32(env, errno, &result);
114 return result;
115 }
116
Setlinebuf(napi_env env, napi_callback_info info)117 static napi_value Setlinebuf(napi_env env, napi_callback_info info)
118 {
119 errno = ERRON_0;
120 FILE *f = fopen(STR_VFSCANF_TXT, "w+");
121 NAPI_ASSERT(env, f != nullptr, "Setlinebuf fopen Error");
122 setlinebuf(f);
123 fclose(f);
124 napi_value result = nullptr;
125 napi_create_int32(env, errno, &result);
126 return result;
127 }
128
VsprintfTest(char *format, ...)129 int VsprintfTest(char *format, ...)
130 {
131 char buffer[SIZE_20] = {0};
132 va_list aptr;
133 va_start(aptr, format);
134 int vspval = vsprintf(buffer, format, aptr);
135 va_end(aptr);
136 return vspval;
137 }
Vsprintf(napi_env env, napi_callback_info info)138 static napi_value Vsprintf(napi_env env, napi_callback_info info)
139 {
140 int i = ONEVAL;
141 napi_value result = nullptr;
142 char format[SBUF_SIZE] = "%d";
143 int vspval = VsprintfTest(format, i);
144 if (vspval > ZEROVAL) {
145 napi_create_int32(env, ZEROVAL, &result);
146 } else {
147 napi_create_int32(env, MINUSONE, &result);
148 }
149 return result;
150 }
151
vsprintfChkTest(char *format, ...)152 int vsprintfChkTest(char *format, ...)
153 {
154 char buffer[SIZE_20] = {0};
155 va_list aptr;
156 va_start(aptr, format);
157 int vspval = __vsprintf_chk(buffer, PARAM_1, PARAM_2, format, aptr);
158 va_end(aptr);
159 return vspval;
160 }
VsprintfChk(napi_env env, napi_callback_info info)161 static napi_value VsprintfChk(napi_env env, napi_callback_info info)
162 {
163 int i = ONEVAL;
164 napi_value result = nullptr;
165 char format[SBUF_SIZE] = "%d";
166 int vspval = vsprintfChkTest(format, i);
167 if (vspval > ZEROVAL) {
168 napi_create_int32(env, ZEROVAL, &result);
169 } else {
170 napi_create_int32(env, MINUSONE, &result);
171 }
172 return result;
173 }
Feof(napi_env env, napi_callback_info info)174 static napi_value Feof(napi_env env, napi_callback_info info)
175 {
176 char path[SBUF_SIZE] = "/data/storage/el2/base/files/Fzl.txt";
177 int fileDescribe = SUCCESS;
178 FILE *stream = fopen(path, "r");
179 NAPI_ASSERT(env, stream != nullptr, "Feof fopen Error");
180 napi_value result = nullptr;
181 fileDescribe = feof(stream);
182 fclose(stream);
183 napi_create_int32(env, fileDescribe, &result);
184 return result;
185 }
186
Tmpnam(napi_env env, napi_callback_info info)187 static napi_value Tmpnam(napi_env env, napi_callback_info info)
188 {
189 char buffer[L_tmpnam];
190 char *p = tmpnam(buffer);
191 napi_value result = nullptr;
192 napi_create_string_utf8(env, p, NAPI_AUTO_LENGTH, &result);
193 return result;
194 }
195
Tmpfile(napi_env env, napi_callback_info info)196 static napi_value Tmpfile(napi_env env, napi_callback_info info)
197 {
198 FILE *f = tmpfile();
199 int file_value = ZERO;
200 if (f == nullptr) {
201 file_value = FAIL;
202 }
203 napi_value result = nullptr;
204 napi_create_int32(env, file_value, &result);
205 return result;
206 }
207
Tmpfile64(napi_env env, napi_callback_info info)208 static napi_value Tmpfile64(napi_env env, napi_callback_info info)
209 {
210 FILE *f = tmpfile64();
211 int file_value = ZERO;
212 if (f == nullptr) {
213 file_value = FAIL;
214 }
215 napi_value result = nullptr;
216 napi_create_int32(env, file_value, &result);
217 return result;
218 }
219
vsnprintfChk_test(char *str, size_t n, char *fmt, const char *funcName, ...)220 int vsnprintfChk_test(char *str, size_t n, char *fmt, const char *funcName, ...)
221 {
222 char s[n];
223 va_list ap;
224 va_start(ap, funcName);
225 size_t bos = __DIAGNOSE_BOS(fmt);
226 int vsnval = __vsnprintf_chk(s, n, ZEROVAL, bos, fmt, ap);
227 va_end(ap);
228 return vsnval;
229 }
230
VsnprintfChk(napi_env env, napi_callback_info info)231 static napi_value VsnprintfChk(napi_env env, napi_callback_info info)
232 {
233 char value[MAX_NUMBER] = "value is use";
234 char value1[MAX_NUMBER] = "value is %s";
235 int vsnval = vsnprintfChk_test(value, PARAM_13, value1, "vsnprintfChk_test", "use");
236 napi_value result = nullptr;
237 if (vsnval < ZEROVAL) {
238 napi_create_int32(env, MINUSONE, &result);
239 } else {
240 napi_create_int32(env, ZEROVAL, &result);
241 }
242 return result;
243 }
244
SnprintfChk(napi_env env, napi_callback_info info)245 static napi_value SnprintfChk(napi_env env, napi_callback_info info)
246 {
247 size_t argc = PARAM_1;
248 napi_value args[1] = {nullptr};
249 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
250 int isSuccessCase;
251 napi_get_value_int32(env, args[0], &isSuccessCase);
252 char buffer[SIZE_20];
253 int snprintf_value = DEF_VALUE;
254 int toJs = DEF_VALUE;
255 if (isSuccessCase == PARAM_1) {
256 snprintf_value = __snprintf_chk(buffer, SIZE_20, PARAM_0, SIZE_20, "hello : %s", "world!");
257 if (snprintf_value > PARAM_0) {
258 toJs = PARAM_1;
259 }
260 }
261 napi_value result = nullptr;
262 napi_create_int32(env, toJs, &result);
263 return result;
264 }
265
SprintfChk(napi_env env, napi_callback_info info)266 static napi_value SprintfChk(napi_env env, napi_callback_info info)
267 {
268 size_t argc = PARAM_1;
269 napi_value args[1] = {nullptr};
270 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
271 int isSuccessCase;
272 napi_get_value_int32(env, args[0], &isSuccessCase);
273 char buffer[SIZE_20];
274 int sprintfValue = DEF_VALUE;
275 int toJs = DEF_VALUE;
276 if (isSuccessCase == PARAM_1) {
277 sprintfValue = __sprintf_chk(buffer, PARAM_0, SIZE_20, "hello : %s", "world!");
278 if (sprintfValue > PARAM_0) {
279 toJs = SUCCESS;
280 }
281 }
282 napi_value result = nullptr;
283 napi_create_int32(env, toJs, &result);
284 return result;
285 }
286
WriteChk(napi_env env, napi_callback_info info)287 static napi_value WriteChk(napi_env env, napi_callback_info info)
288 {
289 size_t argc = PARAM_2;
290 napi_value args[2] = {nullptr};
291 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
292
293 size_t length = SIZE_64, stresult = PARAM_0;
294 char *strTemp = static_cast<char *>(malloc(sizeof(char) * length));
295 napi_get_value_string_utf8(env, args[0], strTemp, length, &stresult);
296 char *valueSecond = NapiHelper::GetString(env, args[1]);
297
298 int fp = open(strTemp, O_WRONLY | O_CREAT, PARAM_0777);
299 ssize_t valueResult = __write_chk(fp, valueSecond, strlen(valueSecond), strlen(valueSecond) + PARAM_1);
300 int toJs = DEF_VALUE;
301 if (valueResult != FAIL) {
302 toJs = SUCCESS;
303 }
304 close(fp);
305 napi_value result = nullptr;
306 napi_create_int32(env, toJs, &result);
307 return result;
308 }
309
PwriteChk(napi_env env, napi_callback_info info)310 static napi_value PwriteChk(napi_env env, napi_callback_info info)
311 {
312 size_t argc = PARAM_2;
313 napi_value args[2] = {nullptr};
314 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
315
316 size_t length = SIZE_64, stresult = PARAM_0;
317 char *strTemp = static_cast<char *>(malloc(sizeof(char) * length));
318 napi_get_value_string_utf8(env, args[0], strTemp, length, &stresult);
319 char *valueSecond = NapiHelper::GetString(env, args[1]);
320
321 int fp = open(strTemp, O_WRONLY | O_CREAT, PARAM_0777);
322 ssize_t valueResult = __pwrite_chk(fp, valueSecond, strlen(valueSecond), PARAM_5, strlen(valueSecond) + PARAM_1);
323 int toJs = DEF_VALUE;
324 if (valueResult != FAIL) {
325 toJs = SUCCESS;
326 }
327 close(fp);
328 napi_value result = nullptr;
329 napi_create_int32(env, toJs, &result);
330 return result;
331 }
332
FgetsChk(napi_env env, napi_callback_info info)333 static napi_value FgetsChk(napi_env env, napi_callback_info info)
334 {
335 char helloWorld[] = "hello world!";
336 FILE *fp = fmemopen(helloWorld, sizeof(helloWorld), "r");
337 const int bufferSize = ONESIX;
338 char buf[bufferSize];
339 char *char_value;
340 char_value = __fgets_chk(buf, sizeof(buf), fp, ONESIX);
341 fclose(fp);
342 napi_value result = nullptr;
343 napi_create_string_utf8(env, char_value, NAPI_AUTO_LENGTH, &result);
344 return result;
345 }
346
Fread_chk(napi_env env, napi_callback_info info)347 static napi_value Fread_chk(napi_env env, napi_callback_info info)
348 {
349 size_t bos = ZERO;
350 FILE *file;
351 char buffer[20];
352 file = fopen(PATH, "r");
353 int ret = __fread_chk(buffer, bos, bos, file, bos);
354 fclose(file);
355 napi_value result = nullptr;
356 napi_create_int32(env, ret, &result);
357 return result;
358 }
359
vasprintf_0100(char *v, ...)360 int vasprintf_0100(char *v, ...)
361 {
362 va_list ap;
363 va_start(ap, v);
364 char ta[] = " ";
365 char *temp = ta;
366 int result = vasprintf(&temp, v, ap);
367 if (result < PARAM_0 || strcmp(temp, "value is 123 and 321.") != PARAM_0) {
368 result = FAIL;
369 }
370 va_end(ap);
371 return result;
372 }
373
Vasprintf(napi_env env, napi_callback_info info)374 static napi_value Vasprintf(napi_env env, napi_callback_info info)
375 {
376 size_t argc = PARAM_1;
377 napi_value args[1] = {nullptr};
378 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
379
380 int caseNumber;
381 int toJs = FAIL;
382 napi_get_value_int32(env, args[0], &caseNumber);
383 if (caseNumber == PARAM_1) {
384 char cb[] = "value is %d and %d.";
385 int value = vasprintf_0100(cb, PARAM_123, PARAM_321);
386 if (value != FAIL) {
387 toJs = SUCCESS;
388 }
389 }
390 napi_value result = nullptr;
391 napi_create_int32(env, toJs, &result);
392 return result;
393 }
394
Ungetc(napi_env env, napi_callback_info info)395 static napi_value Ungetc(napi_env env, napi_callback_info info)
396 {
397 size_t argc = PARAM_1;
398 napi_value args[1] = {nullptr};
399 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
400
401 int valueFirst = getchar();
402 napi_get_value_int32(env, args[0], &valueFirst);
403 FILE *fp = fopen("/data/storage/el2/base/files/FZL.txt", "r");
404 valueFirst = getc(fp);
405 int ungetcValue = ungetc(valueFirst, fp);
406 fclose(fp);
407 napi_value result = nullptr;
408 napi_create_int32(env, ungetcValue, &result);
409 return result;
410 }
411
Putw(napi_env env, napi_callback_info info)412 static napi_value Putw(napi_env env, napi_callback_info info)
413 {
414 size_t argc = PARAM_1;
415 napi_value args[1] = {nullptr};
416 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
417 int valueFirst;
418 napi_get_value_int32(env, args[0], &valueFirst);
419 FILE *fp;
420 napi_value result = nullptr;
421 char file[LENGTH] = "/data/storage/el2/base/files/testPutw.txt";
422 fp = fopen(file, "w+");
423 if (valueFirst == ZEROVAL) {
424 int putval = putw(PARAM_10, fp);
425 napi_create_int32(env, putval, &result);
426 } else {
427 int putval = putw(PARAM_10, stdin);
428 napi_create_int32(env, putval, &result);
429 }
430 fclose(fp);
431 return result;
432 }
433
Rename(napi_env env, napi_callback_info info)434 static napi_value Rename(napi_env env, napi_callback_info info)
435 {
436 char oldName[] = "/data/storage/el2/base/files/testRenameOld.txt";
437 char newName[] = "/data/storage/el2/base/files/testRenameNew.txt";
438 int resultValue = rename(oldName, newName);
439 napi_value result = nullptr;
440
441 napi_create_int32(env, resultValue, &result);
442 return result;
443 }
vfsf(FILE *file, char *fmt, ...)444 int vfsf(FILE *file, char *fmt, ...)
445 {
446 va_list argp;
447 int value;
448 va_start(argp, fmt);
449 value = vfscanf(file, fmt, argp);
450 va_end(argp);
451 return value;
452 }
453 #define TFVAL 24
454 #define FFVAL 40.0
Vfscanf(napi_env env, napi_callback_info info)455 static napi_value Vfscanf(napi_env env, napi_callback_info info)
456 {
457 errno = ZEROVAL;
458 FILE *file;
459 int i = TFVAL;
460 float fl = FFVAL;
461 char str[4] = "boy";
462 file = fopen("/data/storage/el2/base/files/Fzl.txt", "w+");
463 char value[MAX_NUMBER] = "%d%f%s";
464 int ret = vfsf(file, value, i, fl, str);
465 rewind(file);
466 fscanf(file, "%d%f%s", &i, &fl, str);
467 fclose(file);
468 if (errno == NO_ERR) {
469 ret = SUCCESS;
470 }
471 napi_value result;
472 napi_create_int32(env, ret, &result);
473 return result;
474 }
Remove(napi_env env, napi_callback_info info)475 static napi_value Remove(napi_env env, napi_callback_info info)
476 {
477 char path[] = "/data/storage/el2/base/files/testRemove.txt";
478 int resultValue = remove(path);
479 napi_value result = nullptr;
480
481 napi_create_int32(env, resultValue, &result);
482 return result;
483 }
484
vfprintftest(char *file_name, char *format, char *funcName, char *want_reuslt, ...)485 int vfprintftest(char *file_name, char *format, char *funcName, char *want_reuslt, ...)
486 {
487 FILE *file = fopen(file_name, "w");
488 va_list ap;
489 va_start(ap, want_reuslt);
490 int vfpval = vfprintf(file, format, ap);
491 va_end(ap);
492 fclose(file);
493 return vfpval;
494 }
495
Vfprintf(napi_env env, napi_callback_info info)496 static napi_value Vfprintf(napi_env env, napi_callback_info info)
497 {
498 char value1[MAX_NUMBER] = "/data/storage/el2/base/files/test.txt";
499 char value2[MAX_NUMBER] = "value is %s and %d";
500 char value3[MAX_NUMBER] = "vfprintf_0100";
501 char value4[MAX_NUMBER] = "value is qwe and 1";
502
503 int vfpval = vfprintftest(value1, value2, value3, value4, "qwe", "1");
504 napi_value result;
505 if (vfpval < ZEROVAL) {
506 napi_create_int32(env, MINUSONE, &result);
507 } else {
508 napi_create_int32(env, ZEROVAL, &result);
509 }
510 return result;
511 }
512
vprintf()513 int vprintf()
514 {
515 va_list ap;
516 return vfprintf(stdout, "/data/storage/el2/base/files/test.txt", ap);
517 }
518
VprintfTestt(char *format, ...)519 int VprintfTestt(char *format, ...)
520 {
521 va_list args;
522 va_start(args, format);
523 int vprval = vprintf(format, args);
524 va_end(args);
525 return vprval;
526 }
527
Vprintf(napi_env env, napi_callback_info info)528 static napi_value Vprintf(napi_env env, napi_callback_info info)
529 {
530 char value[MAX_NUMBER] = "value is %s and %d";
531 int vprval = VprintfTestt(value);
532 napi_value result;
533 if (vprval < ZEROVAL) {
534 napi_create_int32(env, MINUSONE, &result);
535 } else {
536 napi_create_int32(env, ZEROVAL, &result);
537 }
538 return result;
539 }
540
vsnprintf_test(char *str, size_t n, char *fmt, const char *funcName, ...)541 int vsnprintf_test(char *str, size_t n, char *fmt, const char *funcName, ...)
542 {
543 char s[n];
544 va_list ap;
545 va_start(ap, funcName);
546 int vsnval = vsnprintf(s, n, fmt, ap);
547 va_end(ap);
548 return vsnval;
549 }
550
Vsnprintf(napi_env env, napi_callback_info info)551 static napi_value Vsnprintf(napi_env env, napi_callback_info info)
552 {
553 char value1[MAX_NUMBER] = "value is use";
554 char value2[MAX_NUMBER] = "value is %s";
555
556 int vsnval = vsnprintf_test(value1, 13, value2, "vsnprintf_test", "use");
557 napi_value result = nullptr;
558 if (vsnval < ZEROVAL) {
559 napi_create_int32(env, MINUSONE, &result);
560 } else {
561 napi_create_int32(env, ZEROVAL, &result);
562 }
563 return result;
564 }
565
GetMatches(const char *str, const char *format, ...)566 int GetMatches(const char *str, const char *format, ...)
567 {
568 va_list args;
569 va_start(args, format);
570 int vssval = vsscanf(str, format, args);
571 va_end(args);
572 return vssval;
573 }
574
Vsscanf(napi_env env, napi_callback_info info)575 static napi_value Vsscanf(napi_env env, napi_callback_info info)
576 {
577 int val = ZEROVAL;
578 char buf[HUNDRED];
579 int vssval = GetMatches("99 bottles of beer on the wall", " %d %s ", &val, buf);
580 napi_value result;
581 if (vssval < ZEROVAL) {
582 napi_create_int32(env, MINUSONE, &result);
583 } else {
584 napi_create_int32(env, ZEROVAL, &result);
585 }
586 return result;
587 }
588
Tempnam(napi_env env, napi_callback_info info)589 static napi_value Tempnam(napi_env env, napi_callback_info info)
590 {
591 char dir[] = PATH;
592 char pte[] = "temp";
593 char *temp = tempnam(dir, pte);
594 napi_value result = nullptr;
595 napi_create_string_utf8(env, temp, NAPI_AUTO_LENGTH, &result);
596 return result;
597 }
598
Sscanf(napi_env env, napi_callback_info info)599 static napi_value Sscanf(napi_env env, napi_callback_info info)
600 {
601 const char *fmt = "temp";
602 char s[] = "temp";
603 int snprintf_value = sscanf(s, fmt, fmt);
604 napi_value result = nullptr;
605 napi_create_int32(env, snprintf_value, &result);
606 return result;
607 }
608
Snprintf(napi_env env, napi_callback_info info)609 static napi_value Snprintf(napi_env env, napi_callback_info info)
610 {
611 char buffer[20];
612 const char *format = "AB";
613 int snprintf_value = snprintf(buffer, ZERO, format, format);
614 napi_value result = nullptr;
615 napi_create_int32(env, snprintf_value, &result);
616 return result;
617 }
618
Setvbuf(napi_env env, napi_callback_info info)619 static napi_value Setvbuf(napi_env env, napi_callback_info info)
620 {
621 char buf[MAX_NAMBER] = {0};
622 char path[PATH_MAX] = {0};
623 FILE *fptr = fopen("/data/storage/el2/base/files/FZL.txt", "w+");
624 int setval = setvbuf(fptr, buf, _IOFBF, MAX_NAMBER);
625 napi_value result = nullptr;
626 napi_create_int32(env, setval, &result);
627 fclose(fptr);
628 remove(path);
629 return result;
630 }
631
PutCUnlocked(napi_env env, napi_callback_info info)632 static napi_value PutCUnlocked(napi_env env, napi_callback_info info)
633 {
634 const int32_t PUTC_RET = RUTVAL;
635 int ret = FAIL;
636 FILE *file = fopen("/data/storage/el2/base/files/fzl.txt", "w");
637 if (putc_unlocked('p', file) != PUTC_RET) {
638 ret = FAIL;
639 } else {
640 ret = SUCCESS;
641 }
642 fclose(file);
643 napi_value result = nullptr;
644 napi_create_int32(env, ret, &result);
645 return result;
646 }
647
Putc(napi_env env, napi_callback_info info)648 static napi_value Putc(napi_env env, napi_callback_info info)
649 {
650 const int32_t PUTC_RET = RUTVAL;
651 int ret = FAIL;
652 FILE *file = fopen("/data/storage/el2/base/files/fzl.txt", "w");
653 if (putc('p', file) != PUTC_RET) {
654 ret = FAIL;
655 } else {
656 ret = SUCCESS;
657 }
658 fclose(file);
659 napi_value result = nullptr;
660 napi_create_int32(env, ret, &result);
661 return result;
662 }
663
664 EXTERN_C_START
Init(napi_env env, napi_value exports)665 static napi_value Init(napi_env env, napi_value exports)
666 {
667 napi_property_descriptor desc[] = {
668 {"setbuf", nullptr, Setbuf, nullptr, nullptr, nullptr, napi_default, nullptr},
669 {"setbuffer", nullptr, Setbuffer, nullptr, nullptr, nullptr, napi_default, nullptr},
670 {"setlinebuf", nullptr, Setlinebuf, nullptr, nullptr, nullptr, napi_default, nullptr},
671 {"vsprintf", nullptr, Vsprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
672 {"vsprintfChk", nullptr, VsprintfChk, nullptr, nullptr, nullptr, napi_default, nullptr},
673 {"feof", nullptr, Feof, nullptr, nullptr, nullptr, napi_default, nullptr},
674 {"putc", nullptr, Putc, nullptr, nullptr, nullptr, napi_default, nullptr},
675 {"putCUnlocked", nullptr, PutCUnlocked, nullptr, nullptr, nullptr, napi_default, nullptr},
676 {"setvbuf", nullptr, Setvbuf, nullptr, nullptr, nullptr, napi_default, nullptr},
677 {"snprintf", nullptr, Snprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
678 {"sscanf", nullptr, Sscanf, nullptr, nullptr, nullptr, napi_default, nullptr},
679 {"tempnam", nullptr, Tempnam, nullptr, nullptr, nullptr, napi_default, nullptr},
680 {"vsscanf", nullptr, Vsscanf, nullptr, nullptr, nullptr, napi_default, nullptr},
681 {"vsnprintf", nullptr, Vsnprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
682 {"vprintf", nullptr, Vprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
683 {"vfprintf", nullptr, Vfprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
684 {"vfscanf", nullptr, Vfscanf, nullptr, nullptr, nullptr, napi_default, nullptr},
685 {"remove", nullptr, Remove, nullptr, nullptr, nullptr, napi_default, nullptr},
686 {"rename", nullptr, Rename, nullptr, nullptr, nullptr, napi_default, nullptr},
687 {"putw", nullptr, Putw, nullptr, nullptr, nullptr, napi_default, nullptr},
688 {"ungetc", nullptr, Ungetc, nullptr, nullptr, nullptr, napi_default, nullptr},
689 {"vasprintf", nullptr, Vasprintf, nullptr, nullptr, nullptr, napi_default, nullptr},
690 {"freadChk", nullptr, Fread_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
691 {"fgetsChk", nullptr, FgetsChk, nullptr, nullptr, nullptr, napi_default, nullptr},
692 {"pwriteChk", nullptr, PwriteChk, nullptr, nullptr, nullptr, napi_default, nullptr},
693 {"writeChk", nullptr, WriteChk, nullptr, nullptr, nullptr, napi_default, nullptr},
694 {"sprintfChk", nullptr, SprintfChk, nullptr, nullptr, nullptr, napi_default, nullptr},
695 {"snprintfChk", nullptr, SnprintfChk, nullptr, nullptr, nullptr, napi_default, nullptr},
696 {"vsnprintfChk", nullptr, VsnprintfChk, nullptr, nullptr, nullptr, napi_default, nullptr},
697 {"tmpfile", nullptr, Tmpfile, nullptr, nullptr, nullptr, napi_default, nullptr},
698 {"tmpfile64", nullptr, Tmpfile64, nullptr, nullptr, nullptr, napi_default, nullptr},
699 {"tmpnam", nullptr, Tmpnam, nullptr, nullptr, nullptr, napi_default, nullptr},
700 };
701 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
702 return exports;
703 }
704
705 EXTERN_C_END
706
707 static napi_module demoModule = {
708 .nm_version = 1,
709 .nm_flags = 0,
710 .nm_filename = nullptr,
711 .nm_register_func = Init,
712 .nm_modname = "stdio",
713 .nm_priv = ((void *)0),
714 .reserved = {0},
715 };
716
RegisterEntryModule(void)717 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
718