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 <cerrno>
20 #include <clocale>
21 #include <csignal>
22 #include <cstdio>
23 #include <cstdlib>
24 #include <cstring>
25 #include <js_native_api.h>
26 #include <node_api.h>
27 #include <string>
28 
29 #define FAIL (-1)
30 #define NO_ERR 0
31 #define ONE 1
32 #define TWO 2
33 #define TEST_BUFFER_SIZE 128
34 #define TEST_DATA_LEN 2
35 #define SUCCESS 1
36 #define ONE 1
37 #define THREE 3
38 #define FOURVALUE 4
39 #define MAX_NUMBER 1000
40 #define MIM_NUMBER 10
41 #define TWOVALUE 2
42 #define PARAM_0 0
43 #define PARAM_1 1
44 #define PARAM_2 2
45 #define PARAM_3 3
46 #define PARAM_UNNORMAL (-1)
47 #define RETURN_0 0
48 #define FAILD (-1)
49 #define ERRON_0 0
50 #define SIZE_10 10
51 #define SIZE_15 15
52 #define SIZE_30 30
53 #define SIZE_100 100
54 #define SIZE_1024 1024
55 #define SIZE_4096 4096
56 #define SIZE_8192 8192
57 #define SIZE_5 5
58 #define SIZE_10 10
59 #define EQ_0 '0'
60 #define ONEVAL 1
61 #define MINUSONE (-1)
62 #define TEST_MODE 0666
63 #define SIZE_15 15
64 #define SIZE_100 100
65 #define STRLEN_10 "0123456789"
66 #define PARAM_5 5
67 #define PARAM_0x0 0x0
68 #define PARAM_4 4
69 #define PARAM_50 50
70 #define PARAM_CHAR 95
71 extern "C" void *__memmove_chk(void *dest, const void *src, size_t len, size_t dst_len);
72 extern "C" void *__memset_chk(void *dest, int byte, size_t count, size_t dst_len);
73 extern "C" char *__stpncpy_chk(char *dest, const char *src, size_t len, size_t dst_len);
74 extern "C" void *__mempcpy_chk(void *dest, const void *src, size_t count, size_t dst_len);
75 extern "C" size_t __strlen_chk(const char *s, size_t s_len);
76 extern "C" char *__strncpy_chk(char *dest, const char *src, size_t len, size_t dst_len);
77 extern "C" char *__strncat_chk(char *dest, const char *src, size_t len, size_t dst_buf_size);
78 extern "C" char *__strcat_chk(char *dest, const char *src, size_t dst_buf_size);
79 extern "C" void *__memcpy_chk(void *dest, const void *src, size_t count, size_t dst_len);
80 extern "C" void *__memrchr_chk(const void *, int, size_t, size_t);
81 extern "C" char *__strcpy_chk(char *dest, const char *src, size_t dst_len);
82 extern "C" char *__stpcpy_chk(char *dest, const char *src, size_t dst_len);
83 
Strerror(napi_env env, napi_callback_info info)84 static napi_value Strerror(napi_env env, napi_callback_info info)
85 {
86     size_t argc = PARAM_1;
87     napi_value args[1] = {nullptr};
88     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
89     int valueFirst;
90     napi_get_value_int32(env, args[0], &valueFirst);
91     char *errorValue;
92     if (valueFirst == PARAM_0) {
93         FILE *file = fopen("non_existent_file.txt", "r");
94         if (file == nullptr) {
95             errorValue = strerror(errno);
96         } else {
97             fclose(file);
98         }
99 
100     } else if (valueFirst == ONE) {
101         errorValue = strerror(FAIL);
102 
103     } else if (valueFirst == TWO) {
104         int valueSecond = rand();
105         errorValue = strerror(valueSecond);
106     }
107     napi_value result = nullptr;
108     napi_create_string_utf8(env, errorValue, NAPI_AUTO_LENGTH, &result);
109     return result;
110 }
Strerror_l(napi_env env, napi_callback_info info)111 static napi_value Strerror_l(napi_env env, napi_callback_info info)
112 {
113     size_t argc = PARAM_1;
114     napi_value args[1] = {nullptr};
115     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
116     int valueFirst;
117     napi_get_value_int32(env, args[0], &valueFirst);
118     char *errorValue;
119     locale_t locale = newlocale(LC_ALL_MASK, "en_US", nullptr);
120     if (valueFirst == PARAM_0) {
121         FILE *file = fopen("non_existent_file.txt", "r");
122         if (file == nullptr) {
123             errorValue = strerror_l(errno, locale);
124         } else {
125             fclose(file);
126         }
127     } else if (valueFirst == ONE) {
128         errorValue = strerror_l(FAIL, locale);
129     } else if (valueFirst == TWO) {
130         int valueSecond = rand();
131         errorValue = strerror_l(valueSecond, locale);
132     }
133     napi_value result = nullptr;
134     napi_create_string_utf8(env, errorValue, NAPI_AUTO_LENGTH, &result);
135     return result;
136 }
Strerror_r(napi_env env, napi_callback_info info)137 static napi_value Strerror_r(napi_env env, napi_callback_info info)
138 {
139     size_t argc = PARAM_1;
140     napi_value args[1] = {nullptr};
141     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
142     int valueFirst;
143     napi_get_value_int32(env, args[0], &valueFirst);
144     int errorValue = PARAM_0;
145     if (valueFirst == PARAM_0) {
146         char src[MAX_NUMBER] = "error_message";
147         errorValue = strerror_r(PARAM_UNNORMAL, src, MAX_NUMBER);
148     } else if (valueFirst == ONE) {
149         char src[MAX_NUMBER] = "";
150         errorValue = strerror_r(PARAM_UNNORMAL, src, MAX_NUMBER);
151     } else if (valueFirst == TWO) {
152         int valueSecond = rand();
153         char src[MAX_NUMBER] = "";
154         errorValue = strerror_r(valueSecond, src, MAX_NUMBER);
155     } else if (valueFirst == THREE) {
156         char src[MAX_NUMBER] = "error_message";
157         FILE *file = fopen("non_existent_file.txt", "r");
158         if (file == nullptr) {
159             errorValue = strerror_r(errno, src, MAX_NUMBER);
160         } else {
161             fclose(file);
162         }
163     } else if (valueFirst == FOURVALUE) {
164         char src[MAX_NUMBER] = "error_message";
165         FILE *file = fopen("non_existent_file.txt", "r");
166         if (file == nullptr) {
167             errorValue = strerror_r(errno, src, MIM_NUMBER);
168         } else {
169             fclose(file);
170         }
171     }
172     napi_value result = nullptr;
173     napi_create_int32(env, errorValue, &result);
174     return result;
175 }
176 
Strdup(napi_env env, napi_callback_info info)177 static napi_value Strdup(napi_env env, napi_callback_info info)
178 {
179     size_t argc = PARAM_1;
180     napi_value args[1] = {nullptr};
181     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
182     char *valueFirst = NapiHelper::GetString(env, args[0]);
183     char *char_value;
184     char_value = strdup(valueFirst);
185     napi_value result = nullptr;
186     napi_create_string_utf8(env, char_value, NAPI_AUTO_LENGTH, &result);
187     return result;
188 }
189 
Strcat(napi_env env, napi_callback_info info)190 static napi_value Strcat(napi_env env, napi_callback_info info)
191 {
192     size_t argc = PARAM_2;
193     napi_value args[2] = {nullptr};
194     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
195     char *valueFirst = NapiHelper::GetString(env, args[0]);
196     char *valueSecond = NapiHelper::GetString(env, args[1]);
197     char *char_value;
198     char_value = strcat(valueFirst, valueSecond);
199     napi_value result = nullptr;
200     napi_create_string_utf8(env, char_value, NAPI_AUTO_LENGTH, &result);
201     return result;
202 }
203 
Strchr(napi_env env, napi_callback_info info)204 static napi_value Strchr(napi_env env, napi_callback_info info)
205 {
206     size_t argc = PARAM_1;
207     napi_value args[1] = {nullptr};
208     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
209     char *valueFirst = NapiHelper::GetString(env, args[0]);
210     char valueSecond = '9';
211     char *char_value;
212     char_value = strchr(valueFirst, valueSecond);
213     napi_value result = nullptr;
214     napi_create_string_utf8(env, char_value, NAPI_AUTO_LENGTH, &result);
215     return result;
216 }
217 
Strcmp(napi_env env, napi_callback_info info)218 static napi_value Strcmp(napi_env env, napi_callback_info info)
219 {
220     size_t argc = PARAM_2;
221     napi_value args[2] = {nullptr};
222     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
223     char *valueFirst = NapiHelper::GetString(env, args[0]);
224     char *valueSecond = NapiHelper::GetString(env, args[1]);
225     int sinValue = strcmp(valueFirst, valueSecond);
226     napi_value result = nullptr;
227     napi_create_int32(env, sinValue, &result);
228     return result;
229 }
230 
Strcoll(napi_env env, napi_callback_info info)231 static napi_value Strcoll(napi_env env, napi_callback_info info)
232 {
233     size_t argc = PARAM_2;
234     napi_value args[2] = {nullptr};
235     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
236     char *valueFirst = NapiHelper::GetString(env, args[0]);
237     char *valueSecond = NapiHelper::GetString(env, args[1]);
238     int sinValue = strcoll(valueFirst, valueSecond);
239     napi_value result = nullptr;
240     napi_create_int32(env, sinValue, &result);
241     return result;
242 }
243 
Strcoll_l(napi_env env, napi_callback_info info)244 static napi_value Strcoll_l(napi_env env, napi_callback_info info)
245 {
246     size_t argc = PARAM_2;
247     napi_value args[2] = {nullptr};
248     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
249     char *valueFirst = NapiHelper::GetString(env, args[0]);
250     char *valueSecond = NapiHelper::GetString(env, args[1]);
251     locale_t locale = newlocale(LC_ALL_MASK, "en_US", nullptr);
252     int sinValue = strcoll_l(valueFirst, valueSecond, locale);
253     napi_value result = nullptr;
254     napi_create_int32(env, sinValue, &result);
255     return result;
256 }
257 
Strlen(napi_env env, napi_callback_info info)258 static napi_value Strlen(napi_env env, napi_callback_info info)
259 {
260     size_t argc = PARAM_1;
261     napi_value args[1] = {nullptr};
262     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
263     char *valueFirst = NapiHelper::GetString(env, args[0]);
264     int sinValue = strlen(valueFirst);
265     napi_value result = nullptr;
266     napi_create_int32(env, sinValue, &result);
267     return result;
268 }
269 
Strncat(napi_env env, napi_callback_info info)270 static napi_value Strncat(napi_env env, napi_callback_info info)
271 {
272     size_t argc = PARAM_3;
273     napi_value args[3] = {nullptr};
274     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
275     char *valueFirst = NapiHelper::GetString(env, args[0]);
276     char *valueSecond = NapiHelper::GetString(env, args[1]);
277     int valueThird = napi_get_value_int32(env, args[2], &valueThird);
278     char *value3 = strncat(valueFirst, valueSecond, valueThird);
279     napi_value result = nullptr;
280     napi_create_string_utf8(env, value3, NAPI_AUTO_LENGTH, &result);
281     return result;
282 }
Strncmp(napi_env env, napi_callback_info info)283 static napi_value Strncmp(napi_env env, napi_callback_info info)
284 {
285     size_t argc = PARAM_2;
286     napi_value args[2] = {nullptr};
287     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
288     char *valueFirst = NapiHelper::GetString(env, args[0]);
289     char *valueSecond = NapiHelper::GetString(env, args[1]);
290     int valueThird;
291     napi_get_value_int32(env, args[0], &valueThird);
292     int strNCmpValue = strncmp(valueFirst, valueSecond, valueThird);
293 
294     napi_value result = nullptr;
295     napi_create_int32(env, strNCmpValue, &result);
296     return result;
297 }
298 
Strncpy(napi_env env, napi_callback_info info)299 static napi_value Strncpy(napi_env env, napi_callback_info info)
300 {
301     size_t argc = PARAM_3;
302     napi_value args[3] = {nullptr};
303     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
304     char *valueFirst = NapiHelper::GetString(env, args[0]);
305     char *valueSecond = NapiHelper::GetString(env, args[1]);
306     int valueThird;
307     napi_get_value_int32(env, args[PARAM_2], &valueThird);
308     char *strNCpyValue = strncpy(valueFirst, valueSecond, valueThird);
309 
310     napi_value result = nullptr;
311     napi_create_string_utf8(env, strNCpyValue, NAPI_AUTO_LENGTH, &result);
312 
313     return result;
314 }
315 
Strndup(napi_env env, napi_callback_info info)316 static napi_value Strndup(napi_env env, napi_callback_info info)
317 {
318     size_t argc = PARAM_2;
319     napi_value args[2] = {nullptr};
320     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
321     char *valueFirst = NapiHelper::GetString(env, args[0]);
322     int valueSecond;
323     napi_get_value_int32(env, args[1], &valueSecond);
324     char *strNdUpValue = strndup(valueFirst, valueSecond);
325 
326     napi_value result = nullptr;
327     napi_create_string_utf8(env, strNdUpValue, NAPI_AUTO_LENGTH, &result);
328 
329     return result;
330 }
331 
Strnlen(napi_env env, napi_callback_info info)332 static napi_value Strnlen(napi_env env, napi_callback_info info)
333 {
334     size_t argc = PARAM_2;
335     napi_value args[2] = {nullptr};
336     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
337     char *valueFirst = NapiHelper::GetString(env, args[0]);
338     int valueSecond;
339     napi_get_value_int32(env, args[1], &valueSecond);
340     int strNLenValue = strnlen(valueFirst, valueSecond);
341 
342     napi_value result = nullptr;
343     napi_create_int32(env, strNLenValue, &result);
344 
345     return result;
346 }
347 
Strpbrk(napi_env env, napi_callback_info info)348 static napi_value Strpbrk(napi_env env, napi_callback_info info)
349 {
350     size_t argc = PARAM_2;
351     napi_value args[2] = {nullptr};
352     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
353     char *valueFirst = NapiHelper::GetString(env, args[0]);
354     char *valueSecond = NapiHelper::GetString(env, args[1]);
355     char *strPBrkValue = strpbrk(valueFirst, valueSecond);
356 
357     napi_value result = nullptr;
358     napi_create_string_utf8(env, strPBrkValue, NAPI_AUTO_LENGTH, &result);
359 
360     return result;
361 }
362 
Strrchr(napi_env env, napi_callback_info info)363 static napi_value Strrchr(napi_env env, napi_callback_info info)
364 {
365     size_t argc = PARAM_1;
366     napi_value args[1] = {nullptr};
367     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
368     char *param = NapiHelper::GetString(env, args[0]);
369 
370     char *strrchr_value = strrchr(param, 'd');
371 
372     napi_value result = nullptr;
373     napi_create_string_utf8(env, strrchr_value, NAPI_AUTO_LENGTH, &result);
374 
375     return result;
376 }
377 
Strsep(napi_env env, napi_callback_info info)378 static napi_value Strsep(napi_env env, napi_callback_info info)
379 {
380     size_t argc = PARAM_2;
381     napi_value args[2] = {nullptr};
382     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
383     char *valueFirst = NapiHelper::GetString(env, args[0]);
384     char *valueSecond = NapiHelper::GetString(env, args[1]);
385     char *strSepValue = strsep(&valueFirst, valueSecond);
386 
387     napi_value result = nullptr;
388     napi_create_string_utf8(env, strSepValue, NAPI_AUTO_LENGTH, &result);
389 
390     return result;
391 }
392 
Strspn(napi_env env, napi_callback_info info)393 static napi_value Strspn(napi_env env, napi_callback_info info)
394 {
395     size_t argc = PARAM_2;
396     napi_value args[2] = {nullptr};
397     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
398     char *valueFirst = NapiHelper::GetString(env, args[0]);
399     char *valueSecond = NapiHelper::GetString(env, args[1]);
400     int strSpnValue = strspn(valueFirst, valueSecond);
401 
402     napi_value result = nullptr;
403     napi_create_int32(env, strSpnValue, &result);
404 
405     return result;
406 }
407 
Strstr(napi_env env, napi_callback_info info)408 static napi_value Strstr(napi_env env, napi_callback_info info)
409 {
410     size_t argc = PARAM_2;
411     napi_value args[2] = {nullptr};
412     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
413     char *valueFirst = NapiHelper::GetString(env, args[0]);
414     char *valueSecond = NapiHelper::GetString(env, args[1]);
415     char *strStrValue = strstr(valueFirst, valueSecond);
416 
417     napi_value result = nullptr;
418     napi_create_string_utf8(env, strStrValue, NAPI_AUTO_LENGTH, &result);
419 
420     return result;
421 }
422 
Strtok(napi_env env, napi_callback_info info)423 static napi_value Strtok(napi_env env, napi_callback_info info)
424 {
425     size_t argc = PARAM_2;
426     napi_value args[2] = {nullptr};
427     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
428     char *valueFirst = NapiHelper::GetString(env, args[0]);
429     char *valueSecond = NapiHelper::GetString(env, args[1]);
430     char *strTokValue = strtok(valueFirst, valueSecond);
431 
432     napi_value result = nullptr;
433     napi_create_string_utf8(env, strTokValue, NAPI_AUTO_LENGTH, &result);
434 
435     return result;
436 }
437 
StrtokR(napi_env env, napi_callback_info info)438 static napi_value StrtokR(napi_env env, napi_callback_info info)
439 {
440     size_t argc = PARAM_3;
441     napi_value args[3] = {nullptr};
442     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
443     char *valueFirst = NapiHelper::GetString(env, args[0]);
444     char *valueSecond = NapiHelper::GetString(env, args[1]);
445     char *valueThird = NapiHelper::GetString(env, args[2]);
446     char *strTokValue = strtok_r(valueFirst, valueSecond, &valueThird);
447 
448     napi_value result = nullptr;
449     napi_create_string_utf8(env, strTokValue, NAPI_AUTO_LENGTH, &result);
450 
451     return result;
452 }
453 
Strxfrm(napi_env env, napi_callback_info info)454 static napi_value Strxfrm(napi_env env, napi_callback_info info)
455 {
456     size_t argc = PARAM_3;
457     napi_value args[3] = {nullptr};
458     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
459     int valueFirst;
460     napi_get_value_int32(env, args[0], &valueFirst);
461     char *valueSecond = NapiHelper::GetString(env, args[1]);
462     int valueThird;
463     napi_get_value_int32(env, args[PARAM_2], &valueThird);
464     int strTxFrmValue;
465     if (valueFirst == PARAM_0) {
466         char value[10];
467         strTxFrmValue = strxfrm(value, valueSecond, valueThird);
468     } else {
469         char value[30];
470         strTxFrmValue = strxfrm(value, valueSecond, valueThird);
471     }
472 
473     napi_value result = nullptr;
474     napi_create_int32(env, strTxFrmValue, &result);
475 
476     return result;
477 }
MemCpy(napi_env env, napi_callback_info info)478 static napi_value MemCpy(napi_env env, napi_callback_info info)
479 {
480     size_t argc = PARAM_1;
481     napi_value args[1] = {nullptr};
482     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
483     char *valueFirst = NapiHelper::GetString(env, args[0]);
484     char deSt[10] = {'A', 'B', 'C', 'D', 'E', 'F'};
485     memcpy(deSt, valueFirst, strlen(valueFirst));
486     napi_value result = nullptr;
487     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
488     return result;
489 }
MemMem(napi_env env, napi_callback_info info)490 static napi_value MemMem(napi_env env, napi_callback_info info)
491 {
492     size_t argc = PARAM_1;
493     napi_value args[1] = {nullptr};
494     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
495     char *valueFirst = NapiHelper::GetString(env, args[0]);
496     char deSt[30] = "ABCDEFGHIGKLMN";
497     void *pointer = memmem(deSt, strlen(deSt), valueFirst, strlen(valueFirst));
498 
499     napi_value result = nullptr;
500     if (pointer != nullptr) {
501         napi_create_int32(env, NO_ERR, &result);
502     } else {
503         napi_create_int32(env, FAIL, &result);
504     }
505     return result;
506 }
MemMove(napi_env env, napi_callback_info info)507 static napi_value MemMove(napi_env env, napi_callback_info info)
508 {
509     size_t argc = PARAM_1;
510     napi_value args[1] = {nullptr};
511     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
512     char *valueFirst = NapiHelper::GetString(env, args[0]);
513     char deSt[10] = {0};
514     memmove(deSt, valueFirst, strlen(valueFirst));
515     napi_value result = nullptr;
516     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
517     return result;
518 }
MemPCpy(napi_env env, napi_callback_info info)519 static napi_value MemPCpy(napi_env env, napi_callback_info info)
520 {
521     size_t argc = PARAM_1;
522     napi_value args[1] = {nullptr};
523     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
524     char *valueFirst = NapiHelper::GetString(env, args[0]);
525     char deSt[10] = {0};
526     mempcpy(deSt, valueFirst, strlen(valueFirst));
527 
528     napi_value result = nullptr;
529     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
530     return result;
531 }
MemPCpy2(napi_env env, napi_callback_info info)532 static napi_value MemPCpy2(napi_env env, napi_callback_info info)
533 {
534     size_t argc = PARAM_1;
535     napi_value args[1] = {nullptr};
536     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
537     char *valueFirst = NapiHelper::GetString(env, args[0]);
538     char deSt[10] = {'A', 'B', 'C', 'D', 'E', 'F'};
539     mempcpy(deSt, valueFirst + PARAM_2, strlen(valueFirst) - PARAM_2);
540 
541     napi_value result = nullptr;
542     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
543     return result;
544 }
MemPCpy3(napi_env env, napi_callback_info info)545 static napi_value MemPCpy3(napi_env env, napi_callback_info info)
546 {
547     size_t argc = PARAM_1;
548     napi_value args[1] = {nullptr};
549     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
550     char *valueFirst = NapiHelper::GetString(env, args[0]);
551     char deSt[10] = {'A', 'B', 'C', 'D', 'E', 'F'};
552     mempcpy(deSt, valueFirst + PARAM_2, strlen(valueFirst) - PARAM_3);
553 
554     napi_value result = nullptr;
555     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
556     return result;
557 }
MemPCpy4(napi_env env, napi_callback_info info)558 static napi_value MemPCpy4(napi_env env, napi_callback_info info)
559 {
560     size_t argc = PARAM_1;
561     napi_value args[1] = {nullptr};
562     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
563     char *valueFirst = NapiHelper::GetString(env, args[0]);
564     char deSt[10] = {'A', 'B', 'C', 'D', 'E', 'F'};
565     mempcpy(deSt, valueFirst, 0);
566 
567     napi_value result = nullptr;
568     napi_create_string_utf8(env, deSt, NAPI_AUTO_LENGTH, &result);
569     return result;
570 }
MemrChr(napi_env env, napi_callback_info info)571 static napi_value MemrChr(napi_env env, napi_callback_info info)
572 {
573     const char *src = "this is memrchr_0100 test.";
574     char *ret = static_cast<char *>(memrchr(src, 'r', strlen(src)));
575     napi_value result = nullptr;
576     napi_create_string_utf8(env, static_cast<char *>(ret), NAPI_AUTO_LENGTH, &result);
577     return result;
578 }
MemrChr2(napi_env env, napi_callback_info info)579 static napi_value MemrChr2(napi_env env, napi_callback_info info)
580 {
581     const char *src = "this is memrchr_0100 test.";
582     char *ret = nullptr;
583     ret = static_cast<char *>(memrchr(src, 'w', strlen(src)));
584     napi_value result = nullptr;
585     if (ret == nullptr) {
586         napi_create_int32(env, PARAM_0, &result);
587     } else {
588         napi_create_int32(env, ONE, &result);
589     }
590     return result;
591 }
MemSet(napi_env env, napi_callback_info info)592 static napi_value MemSet(napi_env env, napi_callback_info info)
593 {
594     char *ret = nullptr;
595     ret = static_cast<char *>(malloc(sizeof(char) * ONE));
596     ret = static_cast<char *>(memset(ret, '2', sizeof(char) * ONE));
597     napi_value result = nullptr;
598     if (ret != nullptr) {
599         napi_create_int32(env, PARAM_0, &result);
600     } else {
601         napi_create_int32(env, ONE, &result);
602     }
603     return result;
604 }
MemCcpy(napi_env env, napi_callback_info info)605 static napi_value MemCcpy(napi_env env, napi_callback_info info)
606 {
607     const char src[TEST_BUFFER_SIZE] = "musl test";
608     char dest[TEST_BUFFER_SIZE] = "";
609     void *rev = memccpy(dest, src, ' ', TEST_DATA_LEN);
610 
611     memset(dest, PARAM_0x0, sizeof(dest));
612     rev = memccpy(dest, src, ' ', sizeof(src));
613     int ret = FAIL;
614     napi_value result = nullptr;
615     if (rev != nullptr) {
616         ret = NO_ERR;
617     } else {
618         ret = FAIL;
619     }
620     napi_create_int32(env, ret, &result);
621     return result;
622 }
MemChr(napi_env env, napi_callback_info info)623 static napi_value MemChr(napi_env env, napi_callback_info info)
624 {
625     const char *srcstring = "this is a unittest";
626     char fitch = 'u';
627     char *findch = (char *)memchr(srcstring, fitch, strlen(srcstring));
628     int ret = PARAM_0;
629     if (findch[0] == fitch) {
630         ret = SUCCESS;
631     } else {
632         ret = FAIL;
633     }
634     napi_value result = nullptr;
635 
636     napi_create_int32(env, ret, &result);
637     return result;
638 }
MemCmp(napi_env env, napi_callback_info info)639 static napi_value MemCmp(napi_env env, napi_callback_info info)
640 {
641     char buffer1[] = "DWgaOtP12df0";
642     char buffer2[] = "DWgaOtP12df0";
643     int ret = memcmp(buffer1, buffer2, sizeof(buffer1));
644     if (ret != PARAM_0) {
645         ret = FAIL;
646     } else {
647         ret = SUCCESS;
648     }
649     napi_value result = nullptr;
650     napi_create_int32(env, ONE, &result);
651     return result;
652 }
653 
Strlcat(napi_env env, napi_callback_info info)654 static napi_value Strlcat(napi_env env, napi_callback_info info)
655 {
656     size_t argc = PARAM_1;
657     napi_value args[1] = {nullptr};
658     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
659     char valueFirst[4];
660     valueFirst[0] = '\0';
661     char *valueSecond = NapiHelper::GetString(env, args[0]);
662     int strlcat_value = strlcat(valueFirst, valueSecond, PARAM_4);
663     napi_value result = nullptr;
664     napi_create_int32(env, strlcat_value, &result);
665     return result;
666 }
667 
Strlcpy(napi_env env, napi_callback_info info)668 static napi_value Strlcpy(napi_env env, napi_callback_info info)
669 {
670     size_t argc = PARAM_1;
671     napi_value args[1] = {nullptr};
672     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
673     char valueFirst[4];
674     char *valueSecond = NapiHelper::GetString(env, args[0]);
675     int len = strlen(valueSecond);
676     int strlcpyValue = strlcpy(valueFirst, valueSecond, len);
677     napi_value result = nullptr;
678     napi_create_int32(env, strlcpyValue, &result);
679     return result;
680 }
681 
Strchrnul(napi_env env, napi_callback_info info)682 static napi_value Strchrnul(napi_env env, napi_callback_info info)
683 {
684     size_t argc = TWO;
685     napi_value args[2] = {nullptr};
686     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
687     char *valueFirst = NapiHelper::GetString(env, args[0]);
688     int valueSecond = napi_get_value_int32(env, args[1], &valueSecond);
689     char *strchrnulValue;
690     int int_value = PARAM_0;
691 
692     if (valueSecond == ONE) {
693         int_value = 'o';
694     } else if (valueSecond == TWO) {
695         int_value = '\0';
696     } else if (valueSecond == THREE) {
697         int_value = 'a';
698     }
699     strchrnulValue = strchrnul(valueFirst, int_value);
700     napi_value result = nullptr;
701     napi_create_string_utf8(env, strchrnulValue, NAPI_AUTO_LENGTH, &result);
702     return result;
703 }
704 
Strcasestr(napi_env env, napi_callback_info info)705 static napi_value Strcasestr(napi_env env, napi_callback_info info)
706 {
707     size_t argc = TWO;
708     napi_value args[2] = {nullptr};
709     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
710     char *valueFirst = NapiHelper::GetString(env, args[0]);
711     char *valueSecond = NapiHelper::GetString(env, args[1]);
712     char *strcasestr_value = strcasestr(valueFirst, valueSecond);
713     napi_value result = nullptr;
714     napi_create_string_utf8(env, strcasestr_value, NAPI_AUTO_LENGTH, &result);
715     return result;
716 }
717 
Strsignal(napi_env env, napi_callback_info info)718 static napi_value Strsignal(napi_env env, napi_callback_info info)
719 {
720     size_t argc = ONE;
721     napi_value args[1] = {nullptr};
722     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
723     int valueFirst;
724     napi_get_value_int32(env, args[0], &valueFirst);
725     char *sigValue;
726     if (valueFirst == PARAM_0) {
727         sigValue = strsignal(SIGHUP);
728     } else {
729         sigValue = strsignal(SIGINT);
730     }
731     napi_value result;
732     napi_create_string_utf8(env, sigValue, NAPI_AUTO_LENGTH, &result);
733     return result;
734 }
735 
StrxfrmL(napi_env env, napi_callback_info info)736 static napi_value StrxfrmL(napi_env env, napi_callback_info info)
737 {
738     size_t argc = PARAM_3;
739     napi_value args[3] = {nullptr};
740     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
741     int param;
742     napi_get_value_int32(env, args[0], &param);
743     char *param_char = NapiHelper::GetString(env, args[1]);
744     int param_int;
745     napi_get_value_int32(env, args[2], &param_int);
746     int resultValue;
747     if (param == PARAM_0) {
748         char value[SIZE_10];
749         locale_t locale = nullptr;
750         resultValue = strxfrm_l(value, param_char, param_int, locale);
751     } else {
752         char value[SIZE_30];
753         locale_t locale = nullptr;
754         resultValue = strxfrm_l(value, param_char, param_int, locale);
755     }
756 
757     napi_value result = nullptr;
758     napi_create_int32(env, resultValue, &result);
759 
760     return result;
761 }
762 
Stpcpy(napi_env env, napi_callback_info info)763 static napi_value Stpcpy(napi_env env, napi_callback_info info)
764 {
765     size_t argc = PARAM_1;
766     napi_value args[1] = {nullptr};
767     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
768     char valueFirst[4];
769     char *valueSecond = NapiHelper::GetString(env, args[0]);
770     stpcpy(valueFirst, valueSecond);
771     napi_value result = nullptr;
772     napi_create_string_utf8(env, valueFirst, NAPI_AUTO_LENGTH, &result);
773     return result;
774 }
775 
Stpncpy(napi_env env, napi_callback_info info)776 static napi_value Stpncpy(napi_env env, napi_callback_info info)
777 {
778     size_t argc = PARAM_1;
779     napi_value args[1] = {nullptr};
780     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
781     char valueFirst[SIZE_5] = "abcd";
782     valueFirst[0] = '\0';
783     char *valueSecond = NapiHelper::GetString(env, args[0]);
784     stpncpy(valueFirst, valueSecond, TWOVALUE);
785     napi_value result = nullptr;
786     napi_create_string_utf8(env, valueFirst, NAPI_AUTO_LENGTH, &result);
787     return result;
788 }
789 
Strcpy(napi_env env, napi_callback_info info)790 static napi_value Strcpy(napi_env env, napi_callback_info info)
791 {
792     size_t argc = PARAM_1;
793     napi_value args[1] = {nullptr};
794     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
795     char valueFirst[4];
796     char *valueSecond = NapiHelper::GetString(env, args[0]);
797     strcpy(valueFirst, valueSecond);
798     napi_value result = nullptr;
799     napi_create_string_utf8(env, valueFirst, NAPI_AUTO_LENGTH, &result);
800     return result;
801 }
802 
Strcspn(napi_env env, napi_callback_info info)803 static napi_value Strcspn(napi_env env, napi_callback_info info)
804 {
805     size_t argc = PARAM_2;
806     napi_value args[2] = {nullptr};
807     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
808     char *valueFirst = NapiHelper::GetString(env, args[0]);
809     char *valueSecond = NapiHelper::GetString(env, args[1]);
810     int int_value;
811     int_value = strcspn(valueFirst, valueSecond);
812     napi_value result = nullptr;
813     napi_create_int32(env, int_value, &result);
814     return result;
815 }
MemmoveChk(napi_env env, napi_callback_info info)816 static napi_value MemmoveChk(napi_env env, napi_callback_info info)
817 {
818     errno = ERRON_0;
819     napi_value result = nullptr;
820     napi_create_int32(env, errno, &result);
821     return result;
822 }
823 
MemsetChk(napi_env env, napi_callback_info info)824 static napi_value MemsetChk(napi_env env, napi_callback_info info)
825 {
826     errno = ERRON_0;
827     napi_value result = nullptr;
828     napi_create_int32(env, errno, &result);
829     return result;
830 }
StpncpyChk(napi_env env, napi_callback_info info)831 static napi_value StpncpyChk(napi_env env, napi_callback_info info)
832 {
833     char valueFirst[SIZE_5] = "abcd";
834     valueFirst[0] = '\0';
835     char valueSecond[] = "ef";
836     char *strncpyValue = __stpncpy_chk(valueFirst, valueSecond, strlen(valueSecond), strlen(valueSecond));
837     napi_value result = nullptr;
838     napi_create_string_utf8(env, strncpyValue, NAPI_AUTO_LENGTH, &result);
839     return result;
840 }
MempcpyChk(napi_env env, napi_callback_info info)841 static napi_value MempcpyChk(napi_env env, napi_callback_info info)
842 {
843     errno = ERRON_0;
844     napi_value result = nullptr;
845     napi_create_int32(env, errno, &result);
846     return result;
847 }
848 
StrlenChk(napi_env env, napi_callback_info info)849 static napi_value StrlenChk(napi_env env, napi_callback_info info)
850 {
851     char valueFirst[] = "ABCD";
852     int strlenChkValue = __strlen_chk(valueFirst, MAX_NUMBER);
853     napi_value result = nullptr;
854     napi_create_int32(env, strlenChkValue, &result);
855     return result;
856 }
StrncpyChk(napi_env env, napi_callback_info info)857 static napi_value StrncpyChk(napi_env env, napi_callback_info info)
858 {
859     char valueFirst[SIZE_5] = "abcd";
860     valueFirst[0] = '\0';
861     char valueSecond[] = "ef";
862     char *strncpyValue = __strncpy_chk(valueFirst, valueSecond, strlen(valueSecond), strlen(valueSecond));
863     napi_value result = nullptr;
864     napi_create_string_utf8(env, strncpyValue, NAPI_AUTO_LENGTH, &result);
865     return result;
866 }
867 
StrncatChk(napi_env env, napi_callback_info info)868 static napi_value StrncatChk(napi_env env, napi_callback_info info)
869 {
870     char dst[50] = "ABCD";
871     char src[] = "ABCD";
872     size_t src_len = strlen(src) + strlen(dst);
873     errno = ERRON_0;
874     char *resultValue = __strncat_chk(dst, src, src_len, PARAM_50);
875     napi_value result = nullptr;
876     napi_create_string_utf8(env, resultValue, NAPI_AUTO_LENGTH, &result);
877 
878     return result;
879 }
880 
StrcatChk(napi_env env, napi_callback_info info)881 static napi_value StrcatChk(napi_env env, napi_callback_info info)
882 {
883     size_t argc = PARAM_2;
884     napi_value args[2] = {nullptr};
885     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
886     char *valueFirst = NapiHelper::GetString(env, args[0]);
887     char *valueSecond = NapiHelper::GetString(env, args[1]);
888     char *char_value;
889     char_value = __strcat_chk(valueFirst, valueSecond, SIZE_100);
890     napi_value result = nullptr;
891     napi_create_string_utf8(env, char_value, NAPI_AUTO_LENGTH, &result);
892     return result;
893 }
894 
MemcpyChk(napi_env env, napi_callback_info info)895 static napi_value MemcpyChk(napi_env env, napi_callback_info info)
896 {
897     char dst[SIZE_15];
898     napi_value result;
899     __memcpy_chk(dst, STRLEN_10, SIZE_10, SIZE_15);
900     if (dst[0] == EQ_0) {
901         napi_create_int32(env, PARAM_0, &result);
902     } else {
903         napi_create_int32(env, MINUSONE, &result);
904     }
905     return result;
906 }
907 
MemrchrChk(napi_env env, napi_callback_info info)908 static napi_value MemrchrChk(napi_env env, napi_callback_info info)
909 {
910     size_t argc = PARAM_2;
911     napi_value args[2] = {nullptr};
912     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
913     std::string valueFirst = NapiHelper::GetString(env, args[0]);
914     std::string valueSecond = NapiHelper::GetString(env, args[1]);
915     void *voidResult =
916         __memrchr_chk(valueFirst.data(), *(valueSecond.data()), strlen(valueFirst.data()), strlen(valueFirst.data()));
917     napi_value result = nullptr;
918     char *valueResult = static_cast<char *>(voidResult);
919     napi_create_string_utf8(env, valueResult, NAPI_AUTO_LENGTH, &result);
920     return result;
921 }
922 
StrcpyChk(napi_env env, napi_callback_info info)923 static napi_value StrcpyChk(napi_env env, napi_callback_info info)
924 {
925     size_t argc = PARAM_1;
926     napi_value args[1] = {nullptr};
927     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
928     std::string valueFirst = NapiHelper::GetString(env, args[0]);
929     char copyTo[strlen(valueFirst.data()) + PARAM_1];
930     __strcpy_chk(copyTo, valueFirst.data(), strlen(valueFirst.data()) + PARAM_1);
931     napi_value result = nullptr;
932     napi_create_string_utf8(env, copyTo, NAPI_AUTO_LENGTH, &result);
933     return result;
934 }
935 
StpcpyChk(napi_env env, napi_callback_info info)936 static napi_value StpcpyChk(napi_env env, napi_callback_info info)
937 {
938     size_t argc = PARAM_1;
939     napi_value args[1] = {nullptr};
940     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
941     std::string valueFirst = NapiHelper::GetString(env, args[0]);
942     char copyTo[strlen(valueFirst.data()) + PARAM_1];
943     __stpcpy_chk(copyTo, valueFirst.data(), strlen(valueFirst.data()));
944     napi_value result = nullptr;
945     napi_create_string_utf8(env, copyTo, NAPI_AUTO_LENGTH, &result);
946     return result;
947 }
948 
StrchrChk(napi_env env, napi_callback_info info)949 static napi_value StrchrChk(napi_env env, napi_callback_info info)
950 {
951     size_t argc = PARAM_2;
952     napi_value args[2] = {nullptr};
953     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
954     std::string valueFirst = NapiHelper::GetString(env, args[0]);
955     std::string valueSecond = NapiHelper::GetString(env, args[1]);
956     char tmp = valueSecond[PARAM_0];
957     std::string resultValue = __strchr_chk(valueFirst.data(), tmp, strlen(valueFirst.data()) + PARAM_1);
958     napi_value result = nullptr;
959     napi_create_string_utf8(env, resultValue.data(), NAPI_AUTO_LENGTH, &result);
960     return result;
961 }
962 
Strrchr_Chk(napi_env env, napi_callback_info info)963 static napi_value Strrchr_Chk(napi_env env, napi_callback_info info)
964 {
965     errno = ERRON_0;
966     int character = PARAM_CHAR;
967     size_t size = PARAM_5;
968     const char *path = "/data/storage/el2/base/files/Fzl.txt";
969     char *checkParam = nullptr;
970     checkParam = __strrchr_chk(path, character, size);
971     if (checkParam != nullptr) {
972         errno = SUCCESS;
973     }
974     napi_value result = nullptr;
975     napi_create_int32(env, errno, &result);
976     return result;
977 }
978 
MemChr_chk(napi_env env, napi_callback_info info)979 static napi_value MemChr_chk(napi_env env, napi_callback_info info)
980 {
981     errno = ERRON_0;
982     const char *srcstring = "this is a unittest";
983     char fitch = 'u';
984     __memchr_chk(srcstring, fitch, strlen(srcstring), MINUSONE);
985     napi_value result = nullptr;
986     napi_create_int32(env, errno, &result);
987     return result;
988 }
Strlcpy_chk(napi_env env, napi_callback_info info)989 static napi_value Strlcpy_chk(napi_env env, napi_callback_info info)
990 {
991     char valueFirst[] = {"stringCopy"};
992     char valueSecond[] = {"string"};
993     int strlcpyValue = __strlcpy_chk(valueFirst, valueSecond, strlen(valueSecond), MINUSONE);
994     napi_value result = nullptr;
995     napi_create_int32(env, strlcpyValue, &result);
996     return result;
997 }
Strlcat_chk(napi_env env, napi_callback_info info)998 static napi_value Strlcat_chk(napi_env env, napi_callback_info info)
999 {
1000     char valueFirst[4];
1001     valueFirst[0] = '\0';
1002     char valueSecond[MAX_NUMBER] = "123456";
1003     int strlcat_chk_value = __strlcat_chk(valueFirst, valueSecond, PARAM_3, MINUSONE);
1004     napi_value result = nullptr;
1005     napi_create_int32(env, strlcat_chk_value, &result);
1006     return result;
1007 }
1008 EXTERN_C_START
Init(napi_env env, napi_value exports)1009 static napi_value Init(napi_env env, napi_value exports)
1010 {
1011     napi_property_descriptor desc[] = {
1012         {"strerror", nullptr, Strerror, nullptr, nullptr, nullptr, napi_default, nullptr},
1013         {"strerror_l", nullptr, Strerror_l, nullptr, nullptr, nullptr, napi_default, nullptr},
1014         {"strerror_r", nullptr, Strerror_r, nullptr, nullptr, nullptr, napi_default, nullptr},
1015         {"strchr", nullptr, Strchr, nullptr, nullptr, nullptr, napi_default, nullptr},
1016         {"strdup", nullptr, Strdup, nullptr, nullptr, nullptr, napi_default, nullptr},
1017         {"strcat", nullptr, Strcat, nullptr, nullptr, nullptr, napi_default, nullptr},
1018         {"strcmp", nullptr, Strcmp, nullptr, nullptr, nullptr, napi_default, nullptr},
1019         {"strcoll", nullptr, Strcoll, nullptr, nullptr, nullptr, napi_default, nullptr},
1020         {"strcoll_l", nullptr, Strcoll_l, nullptr, nullptr, nullptr, napi_default, nullptr},
1021         {"strlen", nullptr, Strlen, nullptr, nullptr, nullptr, napi_default, nullptr},
1022         {"strncat", nullptr, Strncat, nullptr, nullptr, nullptr, napi_default, nullptr},
1023         {"strncmp", nullptr, Strncmp, nullptr, nullptr, nullptr, napi_default, nullptr},
1024         {"strncpy", nullptr, Strncpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1025         {"strndup", nullptr, Strndup, nullptr, nullptr, nullptr, napi_default, nullptr},
1026         {"strnlen", nullptr, Strnlen, nullptr, nullptr, nullptr, napi_default, nullptr},
1027         {"strpbrk", nullptr, Strpbrk, nullptr, nullptr, nullptr, napi_default, nullptr},
1028         {"strrchr", nullptr, Strrchr, nullptr, nullptr, nullptr, napi_default, nullptr},
1029         {"strsep", nullptr, Strsep, nullptr, nullptr, nullptr, napi_default, nullptr},
1030         {"strspn", nullptr, Strspn, nullptr, nullptr, nullptr, napi_default, nullptr},
1031         {"strstr", nullptr, Strstr, nullptr, nullptr, nullptr, napi_default, nullptr},
1032         {"strtok", nullptr, Strtok, nullptr, nullptr, nullptr, napi_default, nullptr},
1033         {"strtokR", nullptr, StrtokR, nullptr, nullptr, nullptr, napi_default, nullptr},
1034         {"strxfrm", nullptr, Strxfrm, nullptr, nullptr, nullptr, napi_default, nullptr},
1035         {"strlcat", nullptr, Strlcat, nullptr, nullptr, nullptr, napi_default, nullptr},
1036         {"strlcpy", nullptr, Strlcpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1037         {"strchrnul", nullptr, Strchrnul, nullptr, nullptr, nullptr, napi_default, nullptr},
1038         {"strcasestr", nullptr, Strcasestr, nullptr, nullptr, nullptr, napi_default, nullptr},
1039         {"strsignal", nullptr, Strsignal, nullptr, nullptr, nullptr, napi_default, nullptr},
1040         {"strxfrmL", nullptr, StrxfrmL, nullptr, nullptr, nullptr, napi_default, nullptr},
1041         {"stpcpy", nullptr, Stpcpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1042         {"stpncpy", nullptr, Stpncpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1043         {"strcpy", nullptr, Strcpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1044         {"strcspn", nullptr, Strcspn, nullptr, nullptr, nullptr, napi_default, nullptr},
1045         {"memmoveChk", nullptr, MemmoveChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1046         {"memsetChk", nullptr, MemsetChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1047         {"stpncpyChk", nullptr, StpncpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1048         {"mempcpyChk", nullptr, MempcpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1049         {"strlenChk", nullptr, StrlenChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1050         {"strncpyChk", nullptr, StrncpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1051         {"memCpy", nullptr, MemCpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1052         {"memMem", nullptr, MemMem, nullptr, nullptr, nullptr, napi_default, nullptr},
1053         {"memMove", nullptr, MemMove, nullptr, nullptr, nullptr, napi_default, nullptr},
1054         {"memPCpy", nullptr, MemPCpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1055         {"memPCpy2", nullptr, MemPCpy2, nullptr, nullptr, nullptr, napi_default, nullptr},
1056         {"memPCpy3", nullptr, MemPCpy3, nullptr, nullptr, nullptr, napi_default, nullptr},
1057         {"memPCpy4", nullptr, MemPCpy4, nullptr, nullptr, nullptr, napi_default, nullptr},
1058         {"memrChr", nullptr, MemrChr, nullptr, nullptr, nullptr, napi_default, nullptr},
1059         {"memrChr2", nullptr, MemrChr2, nullptr, nullptr, nullptr, napi_default, nullptr},
1060         {"memSet", nullptr, MemSet, nullptr, nullptr, nullptr, napi_default, nullptr},
1061         {"memCcpy", nullptr, MemCcpy, nullptr, nullptr, nullptr, napi_default, nullptr},
1062         {"memChr", nullptr, MemChr, nullptr, nullptr, nullptr, napi_default, nullptr},
1063         {"memCmp", nullptr, MemCmp, nullptr, nullptr, nullptr, napi_default, nullptr},
1064         {"strncatChk", nullptr, StrncatChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1065         {"strcatChk", nullptr, StrcatChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1066         {"memcpyChk", nullptr, MemcpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1067         {"memrchrChk", nullptr, MemrchrChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1068         {"strcpyChk", nullptr, StrcpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1069         {"stpcpyChk", nullptr, StpcpyChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1070         {"strchrChk", nullptr, StrchrChk, nullptr, nullptr, nullptr, napi_default, nullptr},
1071         {"__strrchr_chk", nullptr, Strrchr_Chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1072         {"__memchr_chk", nullptr, MemChr_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1073         {"__strlcpy_chk", nullptr, Strlcpy_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1074         {"__strlcat_chk", nullptr, Strlcat_chk, nullptr, nullptr, nullptr, napi_default, nullptr},
1075     };
1076     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1077     return exports;
1078 }
1079 
1080 EXTERN_C_END
1081 
1082 static napi_module demoModule = {
1083     .nm_version = 1,
1084     .nm_flags = 0,
1085     .nm_filename = nullptr,
1086     .nm_register_func = Init,
1087     .nm_modname = "string",
1088     .nm_priv = ((void *)0),
1089     .reserved = {0},
1090 };
1091 
RegisterEntryModule(void)1092 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
1093