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 "napi/native_api.h"
17 #include <arpa/inet.h>
18 #include <cstdlib>
19 #include <cstring>
20 #include <js_native_api_types.h>
21 #include <netinet/in.h>
22 #include <sys/socket.h>
23 #include <sys/types.h>
24 #include <sys/un.h>
25 #include <unistd.h>
26
27 #define PARAM_5 5
28 #define ONEVAL 1
29 #define MINUSONE (-1)
30 #define MINUSTWO (-2)
31 #define TWOVAL 2
32 #define FIVEVAL 5
33 #define VALUE9898 9898
34 #define VALUE1234 1234
35 #define PARAM_6000 6000
36 #define PARAM_6001 6001
37 #define PARAM_6002 6002
38 #define PARAM_6003 6003
39 #define PARAM_6004 6004
40 #define PARAM_6005 6005
41 #define PARAM_8000 8000
42
43 #define PARAM_0 0
44 #define PARAM_1 1
45 #define PARAM_2 2
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_100 100
52 #define SIZE_1024 1024
53 #define SIZE_4096 4096
54 #define SIZE_8192 8192
55 #define PORT_E 8000
56 #define PORT_X 6000
57
58 #define MY_SOCK_PATH "/data/storage/el2/base/files"
59
Socket(napi_env env,napi_callback_info info)60 static napi_value Socket(napi_env env, napi_callback_info info)
61 {
62 int result = socket(AF_INET, SOCK_STREAM, PARAM_0);
63 napi_value results = nullptr;
64 napi_create_int32(env, result, &results);
65 return results;
66 }
67
Socketpair(napi_env env,napi_callback_info info)68 static napi_value Socketpair(napi_env env, napi_callback_info info)
69 {
70 int fb[2];
71 int result = socketpair(AF_INET, SOCK_STREAM, PARAM_0, fb);
72 napi_value results = nullptr;
73 napi_create_int32(env, result, &results);
74 return results;
75 }
Sendmsg(napi_env env,napi_callback_info info)76 static napi_value Sendmsg(napi_env env, napi_callback_info info)
77 {
78 napi_value result = nullptr;
79 int ret = PARAM_1;
80 if (fork() == PARAM_0) {
81 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
82 if (sockfd >= PARAM_0) {
83 struct sockaddr_in local = {PARAM_0};
84 local.sin_family = AF_INET;
85 local.sin_port = htons(PARAM_6000);
86 local.sin_addr.s_addr = inet_addr("127.0.0.1");
87 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
88 listen(sockfd, PARAM_5);
89 struct sockaddr_in clnAddr = {PARAM_0};
90 socklen_t clnAddrLen = sizeof(clnAddr);
91 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
92 }
93 close(sockfd);
94 _exit(PARAM_0);
95 } else {
96 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
97 if (sock >= PARAM_0) {
98 struct sockaddr_in server = {PARAM_0};
99 server.sin_family = AF_INET;
100 server.sin_port = htons(PARAM_6000);
101 server.sin_addr.s_addr = inet_addr("127.0.0.1");
102 int conn = PARAM_1;
103 while (conn) {
104 conn = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
105 sizeof(server));
106 }
107 struct msghdr msg = {PARAM_0};
108 ret = sendmsg(sock, &msg, PARAM_0);
109 }
110 close(sock);
111 }
112 napi_create_int32(env, ret, &result);
113 return result;
114 }
115
Send(napi_env env,napi_callback_info info)116 static napi_value Send(napi_env env, napi_callback_info info)
117 {
118 napi_value result = nullptr;
119 int ret = PARAM_1;
120 if (fork() == PARAM_0) {
121 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
122 if (sockfd >= PARAM_0) {
123 struct sockaddr_in local = {PARAM_0};
124 local.sin_family = AF_INET;
125 local.sin_port = htons(PARAM_6004);
126 local.sin_addr.s_addr = inet_addr("127.0.0.1");
127 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
128 listen(sockfd, PARAM_5);
129 struct sockaddr_in clnAddr = {PARAM_0};
130 socklen_t clnAddrLen = sizeof(clnAddr);
131 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
132 }
133 close(sockfd);
134 _exit(PARAM_0);
135 } else {
136 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
137 if (sock >= PARAM_0) {
138 struct sockaddr_in server = {PARAM_0};
139 server.sin_family = AF_INET;
140 server.sin_port = htons(PARAM_6004);
141 server.sin_addr.s_addr = inet_addr("127.0.0.1");
142 int conn = PARAM_1;
143 while (conn) {
144 conn = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
145 sizeof(server));
146 }
147 char sendBuf[] = "x";
148 ret = send(sock, sendBuf, sizeof(sendBuf), PARAM_0);
149 }
150 close(sock);
151 }
152 napi_create_int32(env, ret, &result);
153 return result;
154 }
155
Sendto(napi_env env,napi_callback_info info)156 static napi_value Sendto(napi_env env, napi_callback_info info)
157 {
158 napi_value result = nullptr;
159 int ret = PARAM_1;
160 if (fork() == PARAM_0) {
161 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
162 if (sockfd >= PARAM_0) {
163 struct sockaddr_in local = {PARAM_0};
164 local.sin_family = AF_INET;
165 local.sin_port = htons(PARAM_6005);
166 local.sin_addr.s_addr = inet_addr("127.0.0.1");
167 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
168 listen(sockfd, PARAM_5);
169 struct sockaddr_in clnAddr = {PARAM_0};
170 socklen_t clnAddrLen = sizeof(clnAddr);
171 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
172 }
173 close(sockfd);
174 _exit(PARAM_0);
175 } else {
176 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
177 if (sock >= PARAM_0) {
178 struct sockaddr_in server = {PARAM_0};
179 server.sin_family = AF_INET;
180 server.sin_port = htons(PARAM_6005);
181 server.sin_addr.s_addr = inet_addr("127.0.0.1");
182 int conn = PARAM_1;
183 while (conn) {
184 conn = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
185 sizeof(server));
186 }
187 char sendBuf[] = "it is a test";
188 ret = sendto(sock, sendBuf, sizeof(sendBuf), PARAM_0, nullptr, PARAM_0);
189 }
190 close(sock);
191 }
192 napi_create_int32(env, ret, &result);
193 return result;
194 }
195
Sendmmsg(napi_env env,napi_callback_info info)196 static napi_value Sendmmsg(napi_env env, napi_callback_info info)
197 {
198 napi_value result = nullptr;
199 int ret = PARAM_1;
200 if (fork() == PARAM_0) {
201 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
202 if (sockfd >= PARAM_0) {
203 struct sockaddr_in local = {PARAM_0};
204 local.sin_family = AF_INET;
205 local.sin_port = htons(PARAM_6001);
206 local.sin_addr.s_addr = inet_addr("127.0.0.1");
207 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
208 listen(sockfd, PARAM_5);
209 struct sockaddr_in clnAddr = {PARAM_0};
210 socklen_t clnAddrLen = sizeof(clnAddr);
211 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
212 }
213 close(sockfd);
214 _exit(PARAM_0);
215 } else {
216 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
217 if (sock >= PARAM_0) {
218 struct sockaddr_in server = {PARAM_0};
219 server.sin_family = AF_INET;
220 server.sin_port = htons(PARAM_6001);
221 server.sin_addr.s_addr = inet_addr("127.0.0.1");
222 int conn = PARAM_1;
223 while (conn) {
224 conn = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
225 sizeof(server));
226 }
227 struct mmsghdr msg[2];
228 ret = sendmmsg(sock, msg, TWOVAL, PARAM_0);
229 }
230 close(sock);
231 }
232 napi_create_int32(env, ret, &result);
233 return result;
234 }
235
Setsockopt(napi_env env,napi_callback_info info)236 static napi_value Setsockopt(napi_env env, napi_callback_info info)
237 {
238 int sfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
239 int reuse = ONEVAL;
240 napi_value result = nullptr;
241 int setval = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
242 napi_create_int32(env, setval, &result);
243 return result;
244 }
245
Shutdown(napi_env env,napi_callback_info info)246 static napi_value Shutdown(napi_env env, napi_callback_info info)
247 {
248 int sd = socket(AF_INET, SOCK_STREAM, PARAM_0);
249 struct sockaddr_in server_addr = {PARAM_0};
250 bzero(&server_addr, sizeof(server_addr));
251 server_addr.sin_addr.s_addr = INADDR_ANY;
252 server_addr.sin_addr.s_addr = INADDR_ANY;
253 server_addr.sin_port = htons(VALUE9898);
254 server_addr.sin_family = AF_INET;
255 bind(sd, (struct sockaddr *)(&server_addr), sizeof(server_addr));
256 listen(sd, FIVEVAL);
257 napi_value result = nullptr;
258 int shuval = shutdown(sd, PARAM_0);
259 napi_create_int32(env, shuval, &result);
260 return result;
261 }
262
Recv(napi_env env,napi_callback_info info)263 static napi_value Recv(napi_env env, napi_callback_info info)
264 {
265 size_t argc = PARAM_1;
266 napi_value args[1] = {nullptr};
267 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
268 int param = PARAM_0;
269 napi_get_value_int32(env, args[0], ¶m);
270
271 int resultValue = FAILD;
272 if (param == PARAM_UNNORMAL) {
273 size_t data_len = atoi("11");
274 char buf[SIZE_10];
275 resultValue = recv(PARAM_0, buf, data_len, PARAM_0);
276 } else {
277 char buf[SIZE_100];
278 int sockets[PARAM_2];
279 socketpair(AF_UNIX, SOCK_STREAM, PARAM_0, sockets);
280 send(sockets[PARAM_1], "x", PARAM_1, PARAM_0);
281 resultValue = recv(sockets[PARAM_0], buf, sizeof buf, PARAM_0);
282 }
283
284 napi_value result = nullptr;
285
286 napi_create_int32(env, resultValue, &result);
287 return result;
288 }
289
Recvfrom(napi_env env,napi_callback_info info)290 static napi_value Recvfrom(napi_env env, napi_callback_info info)
291 {
292 size_t argc = PARAM_1;
293 napi_value args[1] = {nullptr};
294 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
295 int param = PARAM_0;
296 napi_get_value_int32(env, args[0], ¶m);
297
298 int resultValue = FAILD;
299 if (param == PARAM_UNNORMAL) {
300 size_t data_len = atoi("11");
301 char buf[SIZE_10];
302 resultValue = recvfrom(PARAM_0, buf, data_len, PARAM_0, nullptr, nullptr);
303 }
304
305 napi_value result = nullptr;
306
307 napi_create_int32(env, resultValue, &result);
308 return result;
309 }
310
Recvmsg(napi_env env,napi_callback_info info)311 static napi_value Recvmsg(napi_env env, napi_callback_info info)
312 {
313 size_t argc = PARAM_1;
314 napi_value args[1] = {nullptr};
315 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
316 int param = PARAM_0;
317 napi_get_value_int32(env, args[0], ¶m);
318
319 int resultValue = FAILD;
320 if (param == PARAM_UNNORMAL) {
321 struct msghdr msgRev = {PARAM_0};
322 resultValue = recvmsg(PARAM_0, &msgRev, PARAM_0);
323 }
324
325 napi_value result = nullptr;
326 napi_create_int32(env, resultValue, &result);
327
328 return result;
329 }
330
Recvmmsg(napi_env env,napi_callback_info info)331 static napi_value Recvmmsg(napi_env env, napi_callback_info info)
332 {
333 size_t argc = PARAM_1;
334 napi_value args[1] = {nullptr};
335 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
336 int param = PARAM_0;
337 napi_get_value_int32(env, args[0], ¶m);
338
339 int resultValue = FAILD;
340 if (param == PARAM_UNNORMAL) {
341 struct mmsghdr msg[SIZE_10];
342 resultValue = recvmmsg(PARAM_0, msg, SIZE_10, PARAM_0, PARAM_0);
343 }
344
345 napi_value result = nullptr;
346 napi_create_int32(env, resultValue, &result);
347
348 return result;
349 }
350
Connect(napi_env env,napi_callback_info info)351 static napi_value Connect(napi_env env, napi_callback_info info)
352 {
353 napi_value result = nullptr;
354 int ret = PARAM_1;
355 if (fork() == PARAM_0) {
356 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
357 if (sockfd >= PARAM_0) {
358 struct sockaddr_in local = {PARAM_0};
359 local.sin_family = AF_INET;
360 local.sin_port = htons(PARAM_6002);
361 local.sin_addr.s_addr = inet_addr("127.0.0.1");
362 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
363 listen(sockfd, PARAM_5);
364 struct sockaddr_in clnAddr = {PARAM_0};
365 socklen_t clnAddrLen = sizeof(clnAddr);
366 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
367 }
368 close(sockfd);
369 _exit(PARAM_0);
370 } else {
371 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
372 if (sock >= PARAM_0) {
373 struct sockaddr_in server = {PARAM_0};
374 server.sin_family = AF_INET;
375 server.sin_port = htons(PARAM_6002);
376 server.sin_addr.s_addr = inet_addr("127.0.0.1");
377 while (ret) {
378 ret = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
379 sizeof(server));
380 }
381 }
382 close(sock);
383 }
384 napi_create_int32(env, ret, &result);
385 return result;
386 }
387
Bind(napi_env env,napi_callback_info info)388 static napi_value Bind(napi_env env, napi_callback_info info)
389 {
390 napi_value result = nullptr;
391 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
392 struct sockaddr_in server = {PARAM_0};
393 server.sin_family = AF_INET;
394 server.sin_port = htons(PARAM_8000);
395 server.sin_addr.s_addr = inet_addr("127.0.0.1");
396 int ret = bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)), sizeof(server));
397 close(sockfd);
398 napi_create_int32(env, ret, &result);
399 return result;
400 }
Listen(napi_env env,napi_callback_info info)401 static napi_value Listen(napi_env env, napi_callback_info info)
402 {
403 napi_value result = nullptr;
404 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
405 struct sockaddr_in local = {PARAM_0};
406 local.sin_family = AF_INET;
407 local.sin_port = htons(PARAM_6000);
408 local.sin_addr.s_addr = inet_addr("192.168.59.65");
409 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
410 int ret = listen(sockfd, PARAM_5);
411 close(sockfd);
412 napi_create_int32(env, ret, &result);
413 return result;
414 }
Getpeername(napi_env env,napi_callback_info info)415 static napi_value Getpeername(napi_env env, napi_callback_info info)
416 {
417 napi_value result = nullptr;
418 int ret = PARAM_1;
419 if (fork() == PARAM_0) {
420 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
421 if (sockfd >= PARAM_0) {
422 struct sockaddr_in local = {PARAM_0};
423 local.sin_family = AF_INET;
424 local.sin_port = htons(PARAM_6003);
425 local.sin_addr.s_addr = inet_addr("127.0.0.1");
426 bind(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&local)), sizeof(local));
427 listen(sockfd, PARAM_5);
428 struct sockaddr_in clnAddr = {PARAM_0};
429 socklen_t clnAddrLen = sizeof(clnAddr);
430 accept(sockfd, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&clnAddr)), &clnAddrLen);
431 }
432 close(sockfd);
433 _exit(PARAM_0);
434 } else {
435 int sock = socket(AF_INET, SOCK_STREAM, PARAM_0);
436 if (sock >= PARAM_0) {
437 struct sockaddr_in server = {PARAM_0};
438 server.sin_family = AF_INET;
439 server.sin_port = htons(PARAM_6003);
440 server.sin_addr.s_addr = inet_addr("127.0.0.1");
441 int conn = PARAM_1;
442 while (conn) {
443 conn = connect(sock, reinterpret_cast<sockaddr *>(static_cast<struct sockaddr_in *>(&server)),
444 sizeof(server));
445 }
446 struct sockaddr addr = {PARAM_0};
447 socklen_t addrLen = sizeof(addr);
448 ret = getpeername(sock, &addr, &addrLen);
449 }
450 close(sock);
451 }
452 napi_create_int32(env, ret, &result);
453 return result;
454 }
455
Getsockname(napi_env env,napi_callback_info info)456 static napi_value Getsockname(napi_env env, napi_callback_info info)
457 {
458 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
459 struct sockaddr_in local = {PARAM_0};
460 struct sockaddr sa = {PARAM_0};
461 int len = sizeof(struct sockaddr_in);
462 local.sin_family = AF_INET;
463 local.sin_port = htons(PARAM_8000);
464 local.sin_addr.s_addr = inet_addr("192.168.59.65");
465 bind(sockfd, (struct sockaddr *)&local, sizeof(local));
466 socklen_t *addrlen = (socklen_t *)&len;
467 int ret = getsockname(sockfd, &sa, addrlen);
468 napi_value result = nullptr;
469 napi_create_int32(env, ret, &result);
470 return result;
471 }
Getsockopt(napi_env env,napi_callback_info info)472 static napi_value Getsockopt(napi_env env, napi_callback_info info)
473 {
474 int optval = PARAM_0;
475 int optlen = PARAM_0;
476 int sockfd = socket(AF_INET, SOCK_STREAM, PARAM_0);
477 int ret = getsockopt(sockfd, SOL_SOCKET, SO_DEBUG, &optval, (socklen_t *)(&optlen));
478 napi_value result = nullptr;
479 napi_create_int32(env, ret, &result);
480 return result;
481 }
482
483 EXTERN_C_START
Init(napi_env env,napi_value exports)484 static napi_value Init(napi_env env, napi_value exports)
485 {
486 napi_property_descriptor desc[] = {
487 {"socket", nullptr, Socket, nullptr, nullptr, nullptr, napi_default, nullptr},
488 {"socketpair", nullptr, Socketpair, nullptr, nullptr, nullptr, napi_default, nullptr},
489 {"sendmsg", nullptr, Sendmsg, nullptr, nullptr, nullptr, napi_default, nullptr},
490 {"sendmmsg", nullptr, Sendmmsg, nullptr, nullptr, nullptr, napi_default, nullptr},
491 {"sendto", nullptr, Sendto, nullptr, nullptr, nullptr, napi_default, nullptr},
492 {"send", nullptr, Send, nullptr, nullptr, nullptr, napi_default, nullptr},
493 {"setsockopt", nullptr, Setsockopt, nullptr, nullptr, nullptr, napi_default, nullptr},
494 {"shutdown", nullptr, Shutdown, nullptr, nullptr, nullptr, napi_default, nullptr},
495 {"recv", nullptr, Recv, nullptr, nullptr, nullptr, napi_default, nullptr},
496 {"recvfrom", nullptr, Recvfrom, nullptr, nullptr, nullptr, napi_default, nullptr},
497 {"recvmsg", nullptr, Recvmsg, nullptr, nullptr, nullptr, napi_default, nullptr},
498 {"recvmmsg", nullptr, Recvmmsg, nullptr, nullptr, nullptr, napi_default, nullptr},
499 {"bind", nullptr, Bind, nullptr, nullptr, nullptr, napi_default, nullptr},
500 {"connect", nullptr, Connect, nullptr, nullptr, nullptr, napi_default, nullptr},
501 {"listen", nullptr, Listen, nullptr, nullptr, nullptr, napi_default, nullptr},
502 {"getpeername", nullptr, Getpeername, nullptr, nullptr, nullptr, napi_default, nullptr},
503 {"getsockname", nullptr, Getsockname, nullptr, nullptr, nullptr, napi_default, nullptr},
504 {"getsockopt", nullptr, Getsockopt, nullptr, nullptr, nullptr, napi_default, nullptr},
505 };
506 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
507 return exports;
508 }
509 EXTERN_C_END
510
511 static napi_module demoModule = {
512 .nm_version = 1,
513 .nm_flags = 0,
514 .nm_filename = nullptr,
515 .nm_register_func = Init,
516 .nm_modname = "socket",
517 .nm_priv = ((void *)0),
518 .reserved = {0},
519 };
520
RegisterModule(void)521 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
522