source: asp3_tinet_ecnl_rx/trunk/ntshell/src/socket_stub.c@ 374

Last change on this file since 374 was 374, checked in by coas-nagasima, 5 years ago

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 49.4 KB
Line 
1/*
2 * TOPPERS ECHONET Lite Communication Middleware
3 *
4 * Copyright (C) 2017 Cores Co., Ltd. Japan
5 *
6 * 上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
7 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
8 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
9 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
10 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
11 * スコード中に含まれていること．
12 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
13 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
14 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
15 * の無保証規定を掲載すること．
16 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
17 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
18 * と．
19 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
20 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
21 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
22 * 報告すること．
23 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
24 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
25 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
26 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
27 * 免責すること．
28 *
29 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
30 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
31 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
32 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
33 * の責任を負わない．
34 *
35 * @(#) $Id$
36 */
37#include "shellif.h"
38#include <kernel.h>
39#include <t_syslog.h>
40#include <t_stdlib.h>
41#include <string.h>
42#include <sil.h>
43#include "syssvc/syslog.h"
44#include <tinet_defs.h>
45#include <tinet_config.h>
46#include <net/net.h>
47#include <net/net_endian.h>
48#include <netinet/in.h>
49#include <netinet/in_itron.h>
50#include <tinet_nic_defs.h>
51#include <tinet_cfg.h>
52#include <netinet/in_var.h>
53#include <net/ethernet.h>
54#include <net/if6_var.h>
55#include <net/net.h>
56#include <net/if_var.h>
57#include <netinet/udp_var.h>
58#include <net/net_buf.h>
59#include <netinet/udp.h>
60#include <netinet/udp_var.h>
61#include <netinet/tcp.h>
62#include <netinet/tcp_var.h>
63#include <netapp/resolver.h>
64extern const ID tmax_tcp_cepid;
65#include "ff.h"
66#include "socket_stub.h"
67#include "kernel_cfg.h"
68
69#define SOCKET_TIMEOUT 2000000
70
71#define tcp6_cre_cep tcp_cre_cep
72#define tcp6_del_cep tcp_del_cep
73#define tcp6_del_rep tcp_del_rep
74#define tcp6_sht_cep tcp_sht_cep
75#define tcp6_cls_cep tcp_cls_cep
76#define tcp6_snd_oob tcp_snd_oob
77#define tcp6_snd_dat tcp_snd_dat
78#define tcp6_rcv_oob tcp_rcv_oob
79#define tcp6_rcv_buf tcp_rcv_buf
80#define tcp6_rel_buf tcp_rel_buf
81#define tcp6_get_opt tcp_get_opt
82#define tcp6_set_opt tcp_set_opt
83
84#define udp6_del_cep udp_del_cep
85#define udp6_get_opt udp_get_opt
86#define udp6_set_opt udp_set_opt
87
88#ifndef SUPPORT_INET6
89
90ER tcp6_cre_rep (ID repid, T_TCP6_CREP *pk_crep) { return E_SYS; }
91ER tcp6_acp_cep (ID cepid, ID repid, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
92ER tcp6_con_cep (ID cepid, T_IPV6EP *p_myaddr, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
93
94ER udp6_cre_cep (ID cepid, T_UDP6_CCEP *pk_ccep) { return E_SYS; }
95ER_UINT udp6_snd_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
96ER_UINT udp6_rcv_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
97
98const T_IN6_ADDR *in6_get_ifaddr (int_t index) { return NULL; }
99
100#endif
101
102ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk);
103ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk);
104ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk);
105ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk);
106
107static int tcp_fd_close(struct SHELL_FILE *fp);
108static size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
109static size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
110static off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
111static int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
112static bool_t tcp_fd_readable(struct SHELL_FILE *fp);
113static void tcp_fd_delete(struct SHELL_FILE *fp);
114
115static int udp_fd_close(struct SHELL_FILE *fp);
116static size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
117static size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
118static off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
119static int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
120static bool_t udp_fd_readable(struct SHELL_FILE *fp);
121static void udp_fd_delete(struct SHELL_FILE *fp);
122
123IO_TYPE IO_TYPE_TCP = { tcp_fd_close, tcp_fd_read, tcp_fd_write, tcp_fd_seek, tcp_fd_ioctl, tcp_fd_readable, tcp_fd_delete };
124IO_TYPE IO_TYPE_UDP = { udp_fd_close, udp_fd_read, udp_fd_write, udp_fd_seek, udp_fd_ioctl, udp_fd_readable, udp_fd_delete };
125
126typedef struct id_table_t {
127 int used;
128 ID id;
129} id_table_t;
130
131id_table_t tcp_repid_table[] = {
132 {0, USR_TCP_REP1}, {0, USR_TCP_REP2}, {0, USR_TCP_REP3}, {0, USR_TCP_REP4}
133};
134#define tcp_repid_table_count (sizeof(tcp_repid_table) / sizeof(tcp_repid_table[0]))
135
136id_table_t tcp_cepid_table[] = {
137 {0, USR_TCP_CEP1}, {0, USR_TCP_CEP2}, {0, USR_TCP_CEP3}, {0, USR_TCP_CEP4},
138#ifndef TOPPERS_GRSAKURA
139 {0, USR_TCP_CEP5}, {0, USR_TCP_CEP6}, {0, USR_TCP_CEP7}, {0, USR_TCP_CEP8}
140#endif
141};
142#define tcp_cepid_table_count (sizeof(tcp_cepid_table) / sizeof(tcp_cepid_table[0]))
143
144#ifdef SUPPORT_INET6
145
146id_table_t tcp6_repid_table[] = {
147 {0, USR_TCP6_REP1}, {0, USR_TCP6_REP2}, {0, USR_TCP6_REP3}, {0, USR_TCP6_REP4}
148};
149#define tcp6_repid_table_count (sizeof(tcp6_repid_table) / sizeof(tcp6_repid_table[0]))
150
151id_table_t tcp6_cepid_table[] = {
152 {0, USR_TCP6_CEP1}, {0, USR_TCP6_CEP2}, {0, USR_TCP6_CEP3}, {0, USR_TCP6_CEP4},
153#ifndef TOPPERS_GRSAKURA
154 {0, USR_TCP6_CEP5}, {0, USR_TCP6_CEP6}, {0, USR_TCP6_CEP7}, {0, USR_TCP6_CEP8}
155#endif
156};
157#define tcp6_cepid_table_count (sizeof(tcp6_cepid_table) / sizeof(tcp6_cepid_table[0]))
158
159#else
160
161#define tcp6_repid_table NULL
162#define tcp6_repid_table_count 0
163
164#define tcp6_cepid_table NULL
165#define tcp6_cepid_table_count 0
166
167#endif
168
169id_table_t udp_cepid_table[] = {
170 {0, USR_UDP_CEP1}, {0, USR_UDP_CEP2}, {0, USR_UDP_CEP3}, {0, USR_UDP_CEP4}
171};
172#define udp_cepid_table_count (sizeof(udp_cepid_table) / sizeof(udp_cepid_table[0]))
173
174#ifdef SUPPORT_INET6
175
176id_table_t udp6_cepid_table[] = {
177 {0, USR_UDP6_CEP1}, {0, USR_UDP6_CEP2}, {0, USR_UDP6_CEP3}, {0, USR_UDP6_CEP4}
178};
179#define udp6_cepid_table_count (sizeof(udp6_cepid_table) / sizeof(udp6_cepid_table[0]))
180
181#else
182
183#define udp6_cepid_table NULL
184#define udp6_cepid_table_count 0
185
186#endif
187
188ID new_id(id_table_t *table, int count)
189{
190 for (int i = 0; i < count; i++) {
191 id_table_t *item = &table[i];
192 if (item->used != 0)
193 continue;
194
195 item->used = 1;
196 return item->id;
197}
198
199 return -ENOMEM;
200}
201
202int delete_id(id_table_t *table, int count, ID id)
203{
204 for (int i = 0; i < count; i++) {
205 id_table_t *item = &table[i];
206 if ((item->used == 0) || (item->id != id))
207 continue;
208
209 item->used = 0;
210 return 0;
211 }
212 return -EINVAL;
213}
214
215typedef struct SHELL_FILE SOCKET;
216
217int shell_socket(int family, int type, int protocol)
218{
219 SOCKET *fp;
220 unsigned int flags;
221
222 switch (family) {
223 case AF_INET:
224 case AF_INET6:
225 break;
226 default:
227 return -EAFNOSUPPORT;
228 }
229
230 flags = type & (SOCK_CLOEXEC|SOCK_NONBLOCK);
231 type &= ~flags;
232
233 switch (type) {
234 case SOCK_STREAM:
235 fp = new_fp(&IO_TYPE_TCP, 0, 0);
236 if (fp == NULL)
237 return -ENOMEM;
238
239 fp->exinf = malloc(sizeof(socket_t));
240 memset(fp->exinf, 0, sizeof(socket_t));
241 break;
242 case SOCK_DGRAM:
243 fp = new_fp(&IO_TYPE_UDP, 0, 1);
244 if (fp == NULL)
245 return -ENOMEM;
246
247 fp->exinf = malloc(sizeof(socket_t));
248 memset(fp->exinf, 0, sizeof(socket_t));
249 break;
250 default:
251 return -ENOPROTOOPT;
252 }
253
254 socket_t *socket = (socket_t *)fp->exinf;
255 socket->family = family;
256 socket->type = type;
257 socket->protocol = protocol;
258 socket->flags = flags;
259
260 return fp->fd;
261}
262
263int shell_bind(int fd, const struct sockaddr *addr, socklen_t len)
264{
265 SOCKET *fp = fd_to_fp(fd);
266 if (fp == NULL)
267 return -EBADF;
268 socket_t *socket = (socket_t *)fp->exinf;
269 if (socket->family != addr->sa_family)
270 return -EINVAL;
271
272 ER ret;
273 switch (addr->sa_family) {
274 case AF_INET: {
275 if (len < 8) {
276 return -EINVAL;
277 }
278 struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
279 memcpy(&socket->laddr4, addr, len);
280 switch (socket->type) {
281 case SOCK_STREAM: {
282 ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
283 if (cepid < 0)
284 return -ENOMEM;
285
286 socket->buf_size = 512 + 512;
287 socket->buf = malloc(socket->buf_size);
288#ifdef _DEBUG
289 memset(socket->buf, 0, socket->buf_size);
290#endif
291 T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
292 ret = tcp_cre_cep(cepid, &ccep);
293 if (ret != E_OK) {
294 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
295 return -ENOMEM;
296 }
297 fp->handle = cepid;
298 socket->cepid = cepid;
299 break;
300 }
301 case SOCK_DGRAM: {
302 ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
303 if (cepid < 0)
304 return -ENOMEM;
305
306 T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, (FP)socket_udp_callback };
307 ret = udp_cre_cep(cepid, &ccep);
308 if (ret != E_OK) {
309 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
310 return -ENOMEM;
311 }
312 fp->handle = cepid;
313 socket->cepid = cepid;
314 break;
315 }
316 default:
317 return -ENOPROTOOPT;
318 }
319 break;
320 }
321 case AF_INET6: {
322 if (len < 20) {
323 return -EINVAL;
324 }
325 struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
326 memcpy(&socket->laddr6, addr, len);
327 switch (socket->type) {
328 case SOCK_STREAM: {
329 ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
330 if (cepid < 0)
331 return -ENOMEM;
332
333 socket->buf_size = 512 + 512;
334 socket->buf = malloc(socket->buf_size);
335#ifdef _DEBUG
336 memset(socket->buf, 0, socket->buf_size);
337#endif
338 T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
339 ret = tcp6_cre_cep(cepid, &ccep);
340 if (ret != E_OK) {
341 delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
342 return -ENOMEM;
343 }
344 fp->handle = cepid;
345 socket->cepid = cepid;
346 break;
347 }
348 case SOCK_DGRAM: {
349 ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
350 if (cepid < 0)
351 return -ENOMEM;
352
353 T_UDP6_CCEP ccep = { 0, {ntohl(addr_in6->sin6_addr.__in6_union.__s6_addr), ntohs(addr_in6->sin6_port)}, (FP)socket_udp6_callback };
354 ret = udp6_cre_cep(cepid, &ccep);
355 if (ret != E_OK) {
356 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
357 return -ENOMEM;
358 }
359 fp->handle = cepid;
360 socket->cepid = cepid;
361 break;
362 }
363 default:
364 return -ENOPROTOOPT;
365 }
366 break;
367 }
368 default:
369 return -ENOPROTOOPT;
370 }
371
372 return 0;
373}
374
375int shell_listen(int fd, int backlog)
376{
377 SOCKET *fp = fd_to_fp(fd);
378 if (fp == NULL)
379 return -EBADF;
380 socket_t *socket = (socket_t *)fp->exinf;
381 if (socket->type != SOCK_STREAM)
382 return -EINVAL;
383
384 socket->backlog = backlog;
385
386 ER ret;
387 switch (socket->family) {
388 case AF_INET: {
389 ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
390 if (repid < 0)
391 return -ENOMEM;
392
393 struct sockaddr_in *laddr = &socket->laddr4;
394 T_TCP_CREP crep = { 0, {ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port)} };
395 ret = tcp_cre_rep(repid, &crep);
396 if (ret != E_OK) {
397 delete_id(tcp_repid_table, tcp_repid_table_count, repid);
398 return -ENOMEM;
399 }
400 socket->repid = repid;
401 break;
402 }
403 case AF_INET6: {
404 ID repid = new_id(tcp6_repid_table, tcp6_repid_table_count);
405 if (repid < 0)
406 return -ENOMEM;
407
408 struct sockaddr_in6 *laddr = &socket->laddr6;
409 T_TCP6_CREP crep = { 0, {ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port)} };
410 ret = tcp6_cre_rep(repid, &crep);
411 if (ret != E_OK) {
412 delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
413 return -ENOMEM;
414 }
415 socket->repid = repid;
416 break;
417 }
418 default:
419 return -ENOPROTOOPT;
420 }
421
422 return 0;
423}
424
425int shell_connect(int fd, const struct sockaddr *addr, socklen_t len)
426{
427 SOCKET *fp = fd_to_fp(fd);
428 if (fp == NULL)
429 return -EBADF;
430 socket_t *socket = (socket_t *)fp->exinf;
431 if (socket->type != SOCK_STREAM)
432 return -EINVAL;
433
434 ER ret;
435 switch (socket->family) {
436 case AF_INET: {
437 if (len < 8) {
438 return -EINVAL;
439 }
440 if (socket->cepid == 0) {
441 ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
442 if (cepid < 0)
443 return -ENOMEM;
444
445 socket->buf_size = 512 + 512;
446 socket->buf = malloc(socket->buf_size);
447#ifdef _DEBUG
448 memset(socket->buf, 0, socket->buf_size);
449#endif
450 T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
451 ret = tcp_cre_cep(cepid, &ccep);
452 if (ret != E_OK) {
453 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
454 return -ENOMEM;
455 }
456 fp->handle = cepid;
457 socket->cepid = cepid;
458 }
459 struct sockaddr_in *laddr = &socket->laddr4;
460 struct sockaddr_in *raddr = &socket->raddr4;
461 memset(raddr, 0, sizeof(*raddr));
462 memcpy(raddr, addr, len);
463 T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
464 T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
465 ret = tcp_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
466 if (ret < 0) {
467 return -EHOSTUNREACH;
468 }
469 break;
470 }
471 case AF_INET6: {
472 if (len < 20) {
473 return -EINVAL;
474 }
475 if (socket->cepid == 0) {
476 ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
477 if (cepid < 0)
478 return -ENOMEM;
479
480 socket->buf_size = 512 + 512;
481 socket->buf = malloc(socket->buf_size);
482#ifdef _DEBUG
483 memset(socket->buf, 0, socket->buf_size);
484#endif
485 T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
486 ret = tcp6_cre_cep(cepid, &ccep);
487 if (ret != E_OK) {
488 delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
489 return -ENOMEM;
490 }
491 fp->handle = cepid;
492 socket->cepid = cepid;
493 }
494 struct sockaddr_in6 *laddr = &socket->laddr6;
495 struct sockaddr_in6 *raddr = &socket->raddr6;
496 memset(raddr, 0, sizeof(*raddr));
497 memcpy(raddr, addr, len);
498 T_IPV6EP lep = { ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port) };
499 T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
500 ret = tcp6_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
501 if (ret < 0) {
502 return -EHOSTUNREACH;
503 }
504 break;
505 }
506 default:
507 return -ENOPROTOOPT;
508 }
509
510 return 0;
511}
512
513int shell_accept(int fd, struct sockaddr *__restrict addr, socklen_t *__restrict len)
514{
515 SOCKET *lfp = fd_to_fp(fd);
516 if (lfp == NULL)
517 return -EBADF;
518 if (((socket_t *)lfp->exinf)->type != SOCK_STREAM)
519 return -EINVAL;
520
521 SOCKET *fp = new_fp(&IO_TYPE_TCP, 0, 0);
522 if (fp == NULL)
523 return -ENOMEM;
524
525 fp->exinf = malloc(sizeof(socket_t));
526 memset(fp->exinf, 0, sizeof(socket_t));
527
528 memcpy(fp->exinf, lfp->exinf, offsetof(socket_t, buf_size));
529
530 ER ret;
531 socket_t *socket = (socket_t *)fp->exinf;
532 switch (socket->family) {
533 case AF_INET: {
534 ID cepid;
535 if (socket->cepid == 0) {
536 cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
537 if (cepid < 0)
538 return -ENOMEM;
539
540 socket->buf_size = 512 + 512;
541 socket->buf = malloc(socket->buf_size);
542#ifdef _DEBUG
543 memset(socket->buf, 0, socket->buf_size);
544#endif
545 T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
546 ret = tcp_cre_cep(cepid, &ccep);
547 if (ret != E_OK) {
548 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
549 return -ENOMEM;
550 }
551 fp->handle = cepid;
552 socket->cepid = cepid;
553 }
554 else {
555 cepid = ((socket_t *)lfp->exinf)->cepid;
556 fp->handle = cepid;
557 lfp->handle = tmax_tcp_cepid + ((socket_t *)lfp->exinf)->repid;
558 ((socket_t *)lfp->exinf)->cepid = 0;
559 ((socket_t *)lfp->exinf)->buf_size = 0;
560 ((socket_t *)lfp->exinf)->buf = 0;
561 }
562 T_IPV4EP rep = { 0, 0 };
563 ret = tcp_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
564 if (ret < 0) {
565 return -ENOMEM;
566 }
567 struct sockaddr_in *raddr = &socket->raddr4;
568 memset(raddr, 0, sizeof(*raddr));
569 raddr->sin_family = AF_INET;
570 raddr->sin_port = htons(rep.portno);
571 raddr->sin_addr.s_addr = htonl(rep.ipaddr);
572
573 if (addr != NULL && len != NULL) {
574 int sz = *len;
575 if (sz < 8) {
576 return -EINVAL;
577 }
578 struct sockaddr_in *raddr = &socket->raddr4;
579 if (sz > sizeof(*raddr))
580 sz = sizeof(*raddr);
581 memcpy(addr, raddr, sz);
582 *len = sizeof(*raddr);
583 }
584 break;
585 }
586 case AF_INET6: {
587 ID cepid;
588 if (socket->cepid == 0) {
589 cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
590 if (cepid < 0)
591 return -ENOMEM;
592
593 socket->buf_size = 512 + 512;
594 socket->buf = malloc(socket->buf_size);
595#ifdef _DEBUG
596 memset(socket->buf, 0, socket->buf_size);
597#endif
598 T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
599 ret = tcp6_cre_cep(cepid, &ccep);
600 if (ret != E_OK) {
601 delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
602 return -ENOMEM;
603 }
604 fp->handle = cepid;
605 socket->cepid = cepid;
606 }
607 else {
608 cepid = ((socket_t *)lfp->exinf)->cepid;
609 fp->handle = cepid;
610 lfp->handle = tmax_tcp6_cepid + ((socket_t *)lfp->exinf)->repid;
611 ((socket_t *)lfp->exinf)->cepid = 0;
612 ((socket_t *)lfp->exinf)->buf_size = 0;
613 ((socket_t *)lfp->exinf)->buf = 0;
614 }
615 T_IPV6EP rep = { 0, 0 };
616 ret = tcp6_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
617 if (ret < 0) {
618 return -ENOMEM;
619 }
620 struct sockaddr_in6 *raddr = &socket->raddr6;
621 memset(raddr, 0, sizeof(*raddr));
622 raddr->sin6_family = AF_INET;
623 raddr->sin6_port = htons(rep.portno);
624#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
625 memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
626#else
627 for (int i = 0; i < 16; i++)
628 raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
629#endif
630
631 if (addr != NULL && len != NULL) {
632 int sz = *len;
633 if (sz < 8) {
634 return -EINVAL;
635 }
636 struct sockaddr_in6 *raddr = &socket->raddr6;
637 if (sz > sizeof(*raddr))
638 sz = sizeof(*raddr);
639 memcpy(addr, raddr, sz);
640 *len = sizeof(*raddr);
641 }
642 break;
643 }
644 default:
645 return -ENOPROTOOPT;
646 }
647
648 return fp->fd;
649}
650
651ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
652{
653 SOCKET *fp = fd_to_fp(fd);
654 if (fp == NULL) {
655 return -EBADF;
656 }
657
658 int ret = 0;
659 socket_t *socket = (socket_t *)fp->exinf;
660 switch (socket->family) {
661 case AF_INET: {
662 switch (socket->type) {
663 case SOCK_STREAM: {
664 if ((addr != NULL) || (alen != 0)) {
665 return -EISCONN;
666 }
667
668 if (flags & MSG_OOB) {
669 ret = tcp_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
670 if (ret < 0) {
671 return -ECOMM;
672 }
673 }
674 else {
675 for (;;) {
676 ret = tcp_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
677 if (ret < 0) {
678 if (ret == E_TMOUT)
679 return -ETIME;
680 return -ECOMM;
681 }
682 len -= ret;
683 if (len <= 0)
684 break;
685 buf = (const void *)&((uint8_t *)buf)[ret];
686 }
687 }
688 break;
689 }
690 case SOCK_DGRAM: {
691 int sz = alen;
692 if ((addr == NULL) || (sz < 8)) {
693 return -EINVAL;
694 }
695 struct sockaddr_in *raddr = &socket->raddr4;
696 memset(raddr, 0, sizeof(*raddr));
697 memcpy(raddr, addr, sz);
698 T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
699 ret = udp_snd_dat(socket->cepid, &rep, (void *)buf, len,
700 (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
701 if (ret < 0) {
702 return (ret == E_TMOUT) ? -ETIME : -ECOMM;
703 }
704 break;
705 }
706 }
707 break;
708 }
709 case AF_INET6: {
710 switch (socket->type) {
711 case SOCK_STREAM: {
712 if ((addr != NULL) || (alen != 0)) {
713 return -EISCONN;
714 }
715
716 if (flags & MSG_OOB) {
717 ret = tcp6_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
718 if (ret < 0) {
719 return -ECOMM;
720 }
721 }
722 else {
723 for (;;) {
724 ret = tcp6_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
725 if (ret < 0) {
726 if (ret == E_TMOUT)
727 return -ETIME;
728 return -ECOMM;
729 }
730 len -= ret;
731 if (len <= 0)
732 break;
733 buf = (const void *)&((uint8_t *)buf)[ret];
734 }
735 }
736 break;
737 }
738 case SOCK_DGRAM: {
739 int sz = alen;
740 if ((addr == NULL) || (sz < 8)) {
741 return -EINVAL;
742 }
743 struct sockaddr_in6 *raddr = &socket->raddr6;
744 memset(raddr, 0, sizeof(*raddr));
745 memcpy(raddr, addr, sz);
746 T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
747 ret = udp6_snd_dat(socket->cepid, &rep, (void *)buf, len,
748 (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
749 if (ret < 0) {
750 return (ret == E_TMOUT) ? -ETIME : -ECOMM;
751 }
752 break;
753 }
754 }
755 break;
756 }
757 default:
758 return -ENOPROTOOPT;
759 }
760
761 return ret;
762}
763
764ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
765{
766 no_implement("sendmsg\n");
767 return -ENOSYS;
768}
769
770ssize_t shell_recvfrom(int fd, void *__restrict buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
771{
772 SOCKET *fp = fd_to_fp(fd);
773 if (fp == NULL) {
774 return -EBADF;
775 }
776
777 int ret = 0;
778 socket_t *socket = (socket_t *)fp->exinf;
779 switch (socket->family) {
780 case AF_INET: {
781 switch (socket->type) {
782 case SOCK_STREAM: {
783 if (flags & MSG_OOB) {
784 ret = tcp_rcv_oob(socket->cepid, buf, len);
785 if (ret < 0) {
786 syslog(LOG_ERROR, "tcp_rcv_oob => %d", ret);
787 return -ECOMM;
788 }
789 }
790 else {
791 int rsz, tmp;
792 if (socket->input == NULL) {
793 ret = wai_sem(SEM_FILEDESC);
794 if (ret < 0) {
795 syslog(LOG_ERROR, "wai_sem => %d", ret);
796 }
797 socket->len = 0;
798 ret = sig_sem(SEM_FILEDESC);
799 if (ret < 0) {
800 syslog(LOG_ERROR, "sig_sem => %d", ret);
801 }
802 ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
803 if (ret < 0) {
804 syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
805 return -ECOMM;
806 }
807 rsz = ret;
808 }
809 else
810 rsz = socket->len;
811 tmp = rsz;
812 if (rsz > len)
813 rsz = len;
814 if (rsz >= 0) {
815 memcpy(buf, socket->input, rsz);
816 ret = wai_sem(SEM_FILEDESC);
817 if (ret < 0) {
818 syslog(LOG_ERROR, "wai_sem => %d", ret);
819 }
820 socket->len = tmp - rsz;
821 ret = sig_sem(SEM_FILEDESC);
822 if (ret < 0) {
823 syslog(LOG_ERROR, "sig_sem => %d", ret);
824 }
825 if (tmp - rsz == 0) {
826 socket->input = NULL;
827 }
828 else
829 socket->input = (void *)&((uint8_t *)socket->input)[rsz];
830 ret = tcp_rel_buf(socket->cepid, rsz);
831 if ((ret != E_OBJ) && (ret < 0)) {
832 syslog(LOG_ERROR, "tcp_rel_buf => %d", ret);
833 //return -ECOMM;
834 }
835 }
836 ret = rsz;
837 }
838 break;
839 }
840 case SOCK_DGRAM: {
841 struct sockaddr_in *raddr = &socket->raddr4;
842 int rsz;
843 ret = wai_sem(SEM_FILEDESC);
844 if (ret < 0) {
845 syslog(LOG_ERROR, "wai_sem => %d", ret);
846 }
847 T_NET_BUF *input = socket->input;
848 if (input == NULL) {
849 ret = sig_sem(SEM_FILEDESC);
850 if (ret < 0) {
851 syslog(LOG_ERROR, "sig_sem => %d", ret);
852 }
853
854 T_IPV4EP rep = { 0, 0 };
855 ret = udp_rcv_dat(socket->cepid, &rep, buf, len,
856 (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
857 if (ret < 0) {
858 if ((socket->flags & O_NONBLOCK) == 0)
859 syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
860 return (ret == E_TMOUT) ? -ETIME : -ECOMM;
861 }
862 rsz = ret;
863 if ((addr != NULL) && (alen != NULL)) {
864 ret = wai_sem(SEM_FILEDESC);
865 if (ret < 0) {
866 syslog(LOG_ERROR, "wai_sem => %d", ret);
867 }
868 int sz = *alen;
869 memset(raddr, 0, sizeof(socket->raddr4));
870 raddr->sin_family = AF_INET;
871 raddr->sin_port = htons(rep.portno);
872 raddr->sin_addr.s_addr = htonl(rep.ipaddr);
873 if (sz > sizeof(socket->raddr4))
874 sz = sizeof(socket->raddr4);
875 memcpy(addr, raddr, sz);
876 *alen = sz;
877 ret = sig_sem(SEM_FILEDESC);
878 if (ret < 0) {
879 syslog(LOG_ERROR, "sig_sem => %d", ret);
880 }
881 }
882 }
883 else {
884 rsz = socket->len;
885 void *pbuf = socket->buf;
886 socket->input = NULL;
887 socket->len = 0;
888 socket->buf = NULL;
889 if ((addr != NULL) && (alen != NULL)) {
890 int sz = *alen;
891 if (sz > sizeof(socket->raddr4))
892 sz = sizeof(socket->raddr4);
893 memcpy(addr, raddr, sz);
894 *alen = sz;
895 }
896 ret = sig_sem(SEM_FILEDESC);
897 if (ret < 0) {
898 syslog(LOG_ERROR, "sig_sem => %d", ret);
899 }
900 if (rsz > len)
901 rsz = len;
902 memcpy(buf, pbuf, rsz);
903 ret = rel_net_buf(input);
904 if (ret < 0) {
905 syslog(LOG_ERROR, "rel_net_buf => %d", ret);
906 //return -ECOMM;
907 }
908 }
909 ret = rsz;
910 }
911 }
912 break;
913 }
914 case AF_INET6: {
915 switch (socket->type) {
916 case SOCK_STREAM: {
917 if (flags & MSG_OOB) {
918 ret = tcp6_rcv_oob(socket->cepid, buf, len);
919 if (ret < 0) {
920 syslog(LOG_ERROR, "tcp6_rcv_oob => %d", ret);
921 return -ECOMM;
922 }
923 }
924 else {
925 int rsz, tmp;
926 if (socket->input == NULL) {
927 ret = wai_sem(SEM_FILEDESC);
928 if (ret < 0) {
929 syslog(LOG_ERROR, "wai_sem => %d", ret);
930 }
931 socket->len = 0;
932 ret = sig_sem(SEM_FILEDESC);
933 if (ret < 0) {
934 syslog(LOG_ERROR, "sig_sem => %d", ret);
935 }
936 ret = tcp6_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
937 if (ret < 0) {
938 syslog(LOG_ERROR, "tcp6_rcv_buf => %d", ret);
939 return -ECOMM;
940 }
941 rsz = ret;
942 }
943 else
944 rsz = socket->len;
945 tmp = rsz;
946 if (rsz > len)
947 rsz = len;
948 if (rsz >= 0) {
949 memcpy(buf, socket->input, rsz);
950 ret = wai_sem(SEM_FILEDESC);
951 if (ret < 0) {
952 syslog(LOG_ERROR, "wai_sem => %d", ret);
953 }
954 socket->len = tmp - rsz;
955 ret = sig_sem(SEM_FILEDESC);
956 if (ret < 0) {
957 syslog(LOG_ERROR, "sig_sem => %d", ret);
958 }
959 if (tmp - rsz == 0) {
960 socket->input = NULL;
961 }
962 else
963 socket->input = (void *)&((uint8_t *)socket->input)[rsz];
964 ret = tcp6_rel_buf(socket->cepid, rsz);
965 if ((ret != E_OBJ) && (ret < 0)) {
966 syslog(LOG_ERROR, "tcp6_rel_buf => %d", ret);
967 //return -ECOMM;
968 }
969 }
970 ret = rsz;
971 }
972 break;
973 }
974 case SOCK_DGRAM: {
975 struct sockaddr_in6 *raddr = &socket->raddr6;
976 int rsz;
977 ret = wai_sem(SEM_FILEDESC);
978 if (ret < 0) {
979 syslog(LOG_ERROR, "wai_sem => %d", ret);
980 }
981 T_NET_BUF *input = socket->input;
982 if (input == NULL) {
983 ret = sig_sem(SEM_FILEDESC);
984 if (ret < 0) {
985 syslog(LOG_ERROR, "sig_sem => %d", ret);
986 }
987
988 T_IPV6EP rep = { 0, 0 };
989 ret = udp6_rcv_dat(socket->cepid, &rep, buf, len,
990 (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
991 if (ret < 0) {
992 if ((socket->flags & O_NONBLOCK) == 0)
993 syslog(LOG_ERROR, "udp6_rcv_buf => %d", ret);
994 return (ret == E_TMOUT) ? -ETIME : -ECOMM;
995 }
996 rsz = ret;
997 if ((addr != NULL) && (alen != NULL)) {
998 ret = wai_sem(SEM_FILEDESC);
999 if (ret < 0) {
1000 syslog(LOG_ERROR, "wai_sem => %d", ret);
1001 }
1002 int sz = *alen;
1003 memset(raddr, 0, sizeof(socket->raddr6));
1004 raddr->sin6_family = AF_INET;
1005 raddr->sin6_port = htons(rep.portno);
1006#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
1007 memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
1008#else
1009 for (int i = 0; i < 16; i++)
1010 raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
1011#endif
1012 if (sz > sizeof(socket->raddr6))
1013 sz = sizeof(socket->raddr6);
1014 memcpy(addr, raddr, sz);
1015 *alen = sz;
1016 ret = sig_sem(SEM_FILEDESC);
1017 if (ret < 0) {
1018 syslog(LOG_ERROR, "sig_sem => %d", ret);
1019 }
1020 }
1021 }
1022 else {
1023 rsz = socket->len;
1024 void *pbuf = socket->buf;
1025 socket->input = NULL;
1026 socket->len = 0;
1027 socket->buf = NULL;
1028 if ((addr != NULL) && (alen != NULL)) {
1029 int sz = *alen;
1030 if (sz > sizeof(socket->raddr6))
1031 sz = sizeof(socket->raddr6);
1032 memcpy(addr, raddr, sz);
1033 *alen = sz;
1034 }
1035 ret = sig_sem(SEM_FILEDESC);
1036 if (ret < 0) {
1037 syslog(LOG_ERROR, "sig_sem => %d", ret);
1038 }
1039 if (rsz > len)
1040 rsz = len;
1041 memcpy(buf, pbuf, rsz);
1042 ret = rel_net_buf(input);
1043 if (ret < 0) {
1044 syslog(LOG_ERROR, "rel_net_buf => %d", ret);
1045 //return -ECOMM;
1046 }
1047 }
1048 ret = rsz;
1049 }
1050 }
1051 break;
1052 }
1053 default:
1054 return -ENOPROTOOPT;
1055 }
1056
1057 return ret;
1058}
1059
1060ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
1061{
1062 no_implement("recvmsg\n");
1063 return -ENOSYS;
1064}
1065
1066int shell_shutdown(int fd, int how)
1067{
1068 SOCKET *fp = fd_to_fp(fd);
1069 if (fp == NULL) {
1070 return -EBADF;
1071 }
1072
1073 ER ret;
1074 socket_t *socket = (socket_t *)fp->exinf;
1075 switch (socket->family) {
1076 case AF_INET: {
1077 switch (socket->type) {
1078 case SOCK_STREAM: {
1079 ret = tcp_sht_cep(socket->cepid);
1080 if (ret < 0) {
1081 return -ECOMM;
1082 }
1083 break;
1084 }
1085 }
1086 break;
1087 }
1088 case AF_INET6: {
1089 switch (socket->type) {
1090 case SOCK_STREAM: {
1091 ret = tcp6_sht_cep(socket->cepid);
1092 if (ret < 0) {
1093 return -ECOMM;
1094 }
1095 break;
1096 }
1097 }
1098 break;
1099 }
1100 default:
1101 return -ENOPROTOOPT;
1102 }
1103
1104 return 0;
1105}
1106
1107int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *__restrict optlen)
1108{
1109 SOCKET *fp = fd_to_fp(fd);
1110 if (fp == NULL) {
1111 return -EBADF;
1112 }
1113
1114 ER ret;
1115 socket_t *socket = (socket_t *)fp->exinf;
1116 switch (socket->family) {
1117 case AF_INET: {
1118 switch (socket->type) {
1119 case SOCK_STREAM: {
1120 switch (level) {
1121 case SOL_SOCKET:
1122 switch (optname) {
1123 case SO_REUSEADDR:
1124 if (socket->flags & SO_REUSEADDR) {
1125 *(bool *)optval = true;
1126 }
1127 else {
1128 *(bool *)optval = false;
1129 }
1130 break;
1131 case SO_KEEPALIVE:
1132 if (socket->flags & SO_KEEPALIVE) {
1133 *(bool *)optval = true;
1134 }
1135 else {
1136 *(bool *)optval = false;
1137 }
1138 break;
1139 case SO_ERROR:
1140 *(int *)optval = 0;
1141 break;
1142 default:
1143 return -EINVAL;
1144 }
1145 break;
1146 case IPPROTO_TCP:
1147 ret = tcp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
1148 if (ret < 0) {
1149 return -EINVAL;
1150 }
1151 *optlen = ret;
1152 break;
1153 default:
1154 return -EINVAL;
1155 }
1156 break;
1157 }
1158 case SOCK_DGRAM: {
1159 switch (level) {
1160 case IPPROTO_UDP:
1161 ret = udp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
1162 if (ret < 0) {
1163 return -EINVAL;
1164 }
1165 *optlen = ret;
1166 break;
1167 default:
1168 return -EINVAL;
1169 }
1170 break;
1171 }
1172 }
1173 break;
1174 }
1175 case AF_INET6: {
1176 switch (socket->type) {
1177 case SOCK_STREAM: {
1178 switch (level) {
1179 case SOL_SOCKET:
1180 switch (optname) {
1181 case SO_REUSEADDR:
1182 if (socket->flags & SO_REUSEADDR) {
1183 *(bool *)optval = true;
1184 }
1185 else {
1186 *(bool *)optval = false;
1187 }
1188 break;
1189 case SO_KEEPALIVE:
1190 if (socket->flags & SO_KEEPALIVE) {
1191 *(bool *)optval = true;
1192 }
1193 else {
1194 *(bool *)optval = false;
1195 }
1196 break;
1197 case SO_ERROR:
1198 *(int *)optval = 0;
1199 break;
1200 default:
1201 return -EINVAL;
1202 }
1203 break;
1204 case IPPROTO_TCP:
1205 ret = tcp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
1206 if (ret < 0) {
1207 return -EINVAL;
1208 }
1209 *optlen = ret;
1210 break;
1211 default:
1212 return -EINVAL;
1213 }
1214 break;
1215 }
1216 case SOCK_DGRAM: {
1217 switch (level) {
1218 case IPPROTO_UDP:
1219 ret = udp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
1220 if (ret < 0) {
1221 return -EINVAL;
1222 }
1223 *optlen = ret;
1224 break;
1225 default:
1226 return -EINVAL;
1227 }
1228 break;
1229 }
1230 }
1231 break;
1232 }
1233 default:
1234 return -ENOPROTOOPT;
1235 }
1236
1237 return 0;
1238}
1239
1240int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
1241{
1242 SOCKET *fp = fd_to_fp(fd);
1243 if (fp == NULL) {
1244 return -EBADF;
1245 }
1246
1247 ER ret;
1248 socket_t *socket = (socket_t *)fp->exinf;
1249 switch (socket->family) {
1250 case AF_INET: {
1251 switch (socket->type) {
1252 case SOCK_STREAM: {
1253 switch (level){
1254 case SOL_SOCKET:
1255 switch (optname) {
1256 case SO_REUSEADDR:
1257 if (*(bool *)optval) {
1258 socket->flags |= SO_REUSEADDR;
1259 }
1260 else {
1261 socket->flags &= ~SO_REUSEADDR;
1262 }
1263 break;
1264 case SO_KEEPALIVE:
1265 if (*(bool *)optval) {
1266 socket->flags |= SO_KEEPALIVE;
1267 }
1268 else {
1269 socket->flags &= ~SO_KEEPALIVE;
1270 }
1271 break;
1272 default:
1273 return -EINVAL;
1274 }
1275 break;
1276 case IPPROTO_TCP:
1277 ret = tcp_set_opt(socket->cepid, optname, (void *)optval, optlen);
1278 if (ret < 0) {
1279 return -EINVAL;
1280 }
1281 break;
1282 default:
1283 return -EINVAL;
1284 }
1285 break;
1286 }
1287 case SOCK_DGRAM: {
1288 switch (level){
1289 case IPPROTO_UDP:
1290 ret = udp_set_opt(socket->cepid, optname, (void *)optval, optlen);
1291 if (ret < 0) {
1292 return -EINVAL;
1293 }
1294 break;
1295 default:
1296 return -EINVAL;
1297 }
1298 break;
1299 }
1300 }
1301 break;
1302 }
1303 case AF_INET6: {
1304 switch (socket->type) {
1305 case SOCK_STREAM: {
1306 switch (level){
1307 case SOL_SOCKET:
1308 switch (optname) {
1309 case SO_REUSEADDR:
1310 if (*(bool *)optval) {
1311 socket->flags |= SO_REUSEADDR;
1312 }
1313 else {
1314 socket->flags &= ~SO_REUSEADDR;
1315 }
1316 break;
1317 case SO_KEEPALIVE:
1318 if (*(bool *)optval) {
1319 socket->flags |= SO_KEEPALIVE;
1320 }
1321 else {
1322 socket->flags &= ~SO_KEEPALIVE;
1323 }
1324 break;
1325 default:
1326 return -EINVAL;
1327 }
1328 break;
1329 case IPPROTO_TCP:
1330 ret = tcp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
1331 if (ret < 0) {
1332 return -EINVAL;
1333 }
1334 break;
1335 default:
1336 return -EINVAL;
1337 }
1338 break;
1339 }
1340 case SOCK_DGRAM: {
1341 switch (level){
1342 case IPPROTO_UDP:
1343 ret = udp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
1344 if (ret < 0) {
1345 return -EINVAL;
1346 }
1347 break;
1348 default:
1349 return -EINVAL;
1350 }
1351 break;
1352 }
1353 }
1354 break;
1355 }
1356 default:
1357 return -ENOPROTOOPT;
1358 }
1359
1360 return 0;
1361}
1362
1363int shell_getpeername(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
1364{
1365 SOCKET *fp = fd_to_fp(fd);
1366 if (fp == NULL) {
1367 return -EBADF;
1368 }
1369 if (len == NULL) {
1370 return -EINVAL;
1371 }
1372
1373 socklen_t size = *len;
1374 socket_t *socket = (socket_t *)fp->exinf;
1375 switch (socket->family) {
1376 case AF_INET: {
1377 struct sockaddr_in *raddr = &socket->raddr4;
1378 *len = sizeof(struct sockaddr_in);
1379 if (size > sizeof(struct sockaddr_in))
1380 size = sizeof(struct sockaddr_in);
1381 memcpy(addr, raddr, size);
1382 break;
1383 }
1384 case AF_INET6: {
1385 struct sockaddr_in6 *raddr = &socket->raddr6;
1386 *len = sizeof(struct sockaddr_in6);
1387 if (size > sizeof(struct sockaddr_in6))
1388 size = sizeof(struct sockaddr_in6);
1389 memcpy(addr, raddr, size);
1390 break;
1391 }
1392 default:
1393 return -ENOPROTOOPT;
1394 }
1395
1396 return 0;
1397}
1398
1399int shell_getsockname(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
1400{
1401 SOCKET *fp = fd_to_fp(fd);
1402 if (fp == NULL) {
1403 return -EBADF;
1404 }
1405 if (len == NULL) {
1406 return -EINVAL;
1407 }
1408
1409 socklen_t size = *len;
1410 socket_t *socket = (socket_t *)fp->exinf;
1411 switch (socket->family) {
1412 case AF_INET: {
1413 const T_IN4_ADDR *laddr4 = in4_get_ifaddr(0);
1414 struct sockaddr_in laddr;
1415 laddr.sin_family = AF_INET;
1416 laddr.sin_addr.s_addr = htonl(*laddr4);
1417 laddr.sin_port = socket->laddr4.sin_port;
1418 memset(&laddr.sin_zero, 0, sizeof(laddr.sin_zero));
1419 *len = sizeof(struct sockaddr_in);
1420 if (size > sizeof(struct sockaddr_in))
1421 size = sizeof(struct sockaddr_in);
1422 memcpy(addr, &laddr, size);
1423 break;
1424 }
1425 case AF_INET6: {
1426 const T_IN6_ADDR *laddr6 = in6_get_ifaddr(0);
1427 struct sockaddr_in6 laddr;
1428 laddr.sin6_family = AF_INET;
1429#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
1430 memcpy(laddr.sin6_addr.__in6_union.__s6_addr, laddr6->__u6_addr.__u6_addr8, 16);
1431#else
1432 for (int i = 0; i < 16; i++)
1433 laddr.sin6_addr.__in6_union.__s6_addr[i] = laddr6->__u6_addr.__u6_addr8[i];
1434#endif
1435 laddr.sin6_port = socket->laddr6.sin6_port;
1436 *len = sizeof(struct sockaddr_in6);
1437 if (size > sizeof(struct sockaddr_in6))
1438 size = sizeof(struct sockaddr_in6);
1439 memcpy(addr, &laddr, size);
1440 break;
1441 }
1442 default:
1443 return -ENOPROTOOPT;
1444 }
1445
1446 return 0;
1447}
1448
1449int tcp_fd_close(struct SHELL_FILE *fp)
1450{
1451 ER ret, ret2;
1452
1453 socket_t *socket = (socket_t *)fp->exinf;
1454 switch (socket->family) {
1455 case AF_INET: {
1456 if (socket->cepid != 0) {
1457 ID cepid = socket->cepid;
1458 ret = tcp_sht_cep(cepid);
1459 if (ret < 0) {
1460 //return -1;
1461 }
1462 ret = tcp_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
1463 ret2 = tcp_del_cep(cepid);
1464 //delete_fd_by_id(&IO_TYPE_TCP, cepid);
1465 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
1466 if ((ret < 0) || (ret2 < 0)) {
1467 return (ret == E_TMOUT) ? -ETIME : -EINVAL;
1468 }
1469 }
1470 else if (socket->repid != 0) {
1471 ID repid = socket->repid;
1472 ret = tcp_del_rep(repid);
1473 //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + repid);
1474 delete_id(tcp_repid_table, tcp_repid_table_count, repid);
1475 if (ret < 0) {
1476 return -EINVAL;
1477 }
1478 }
1479 else {
1480 return -EINVAL;
1481 }
1482 break;
1483 }
1484 case AF_INET6: {
1485 if (socket->cepid != 0) {
1486 ID cepid = socket->cepid;
1487 ret = tcp6_sht_cep(cepid);
1488 if (ret < 0) {
1489 //return -1;
1490 }
1491 ret = tcp6_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
1492 ret2 = tcp6_del_cep(cepid);
1493 //delete_fd_by_id(&IO_TYPE_TCP, cepid);
1494 delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
1495 if ((ret < 0) || (ret2 < 0)) {
1496 return (ret == E_TMOUT) ? -ETIME : -EINVAL;
1497 }
1498 }
1499 else if (socket->repid != 0) {
1500 ID repid = socket->repid;
1501 ret = tcp6_del_rep(repid);
1502 //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp6_cepid + repid);
1503 delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
1504 if (ret < 0) {
1505 return -EINVAL;
1506 }
1507 }
1508 else {
1509 return -EINVAL;
1510 }
1511 break;
1512 }
1513 default:
1514 return -ENOPROTOOPT;
1515 }
1516
1517 return 0;
1518}
1519
1520size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
1521{
1522 return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
1523}
1524
1525size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
1526{
1527 return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
1528}
1529
1530off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
1531{
1532 return -EPERM;
1533}
1534
1535int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
1536{
1537 return -EINVAL;
1538}
1539
1540bool_t tcp_fd_readable(struct SHELL_FILE *fp)
1541{
1542 ER ret;
1543
1544 socket_t *socket = (socket_t *)fp->exinf;
1545 if (socket->cepid != 0) {
1546 if (socket->len == 0) {
1547 ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_NBLK);
1548 if ((ret != E_WBLK) && (ret != E_OBJ) && (ret < 0)) {
1549 syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
1550 //return ret;
1551 }
1552 if (ret > 0) {
1553 ret = wai_sem(SEM_FILEDESC);
1554 if (ret < 0) {
1555 syslog(LOG_ERROR, "wai_sem => %d", ret);
1556 }
1557 socket->len += ret;
1558 ret = sig_sem(SEM_FILEDESC);
1559 if (ret < 0) {
1560 syslog(LOG_ERROR, "sig_sem => %d", ret);
1561 }
1562 }
1563 }
1564 else ret = 1;
1565 if (ret > 0) {
1566 return true;
1567 }
1568 }
1569
1570 return false;
1571}
1572
1573void tcp_fd_delete(struct SHELL_FILE *fp)
1574{
1575 socket_t *socket = (socket_t *)fp->exinf;
1576 free(socket->buf);
1577 socket->buf = NULL;
1578 free(fp->exinf);
1579 fp->exinf = NULL;
1580}
1581
1582ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
1583{
1584 struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
1585 FLGPTN flgptn = 0;
1586 ER ret;
1587 int len;
1588
1589 if (fp == NULL)
1590 return E_PAR;
1591
1592 int fd = fp->fd;
1593 FD_SET(fd, (fd_set *)&flgptn);
1594
1595 switch (fncd) {
1596 case TFN_TCP_RCV_BUF:
1597 len = *(int *)p_parblk;
1598 if ((len <= 0) || (fp->exinf == NULL))
1599 return E_OK;
1600
1601 ret = wai_sem(SEM_FILEDESC);
1602 if (ret < 0) {
1603 syslog(LOG_ERROR, "wai_sem => %d", ret);
1604 }
1605 socket_t *socket = (socket_t *)fp->exinf;
1606 socket->len += len;
1607 ret = sig_sem(SEM_FILEDESC);
1608 if (ret < 0) {
1609 syslog(LOG_ERROR, "sig_sem => %d", ret);
1610 }
1611
1612 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1613
1614 set_flg(FLG_SELECT_WAIT, flgptn);
1615 return E_OK;
1616
1617 case TFN_TCP_RCV_DAT:
1618 len = *(int *)p_parblk;
1619 if ((len <= 0) || (fp->exinf == NULL))
1620 return E_OK;
1621
1622 ret = wai_sem(SEM_FILEDESC);
1623 if (ret < 0) {
1624 syslog(LOG_ERROR, "wai_sem => %d", ret);
1625 }
1626 socket->len += len;
1627 ret = sig_sem(SEM_FILEDESC);
1628 if (ret < 0) {
1629 syslog(LOG_ERROR, "sig_sem => %d", ret);
1630 }
1631
1632 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1633
1634 set_flg(FLG_SELECT_WAIT, flgptn);
1635 return E_OK;
1636
1637 case TFN_TCP_SND_DAT:
1638 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
1639
1640 set_flg(FLG_SELECT_WAIT, flgptn);
1641 return E_OK;
1642
1643 case TFN_TCP_CAN_CEP:
1644 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
1645
1646 set_flg(FLG_SELECT_WAIT, flgptn);
1647 return E_OK;
1648
1649 case TFN_TCP_DEL_REP:
1650 delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
1651 return E_OK;
1652
1653 case TFN_TCP_DEL_CEP:
1654 delete_fd_by_id(&IO_TYPE_TCP, cepid);
1655 return E_OK;
1656
1657 default:
1658 return E_OK;
1659 }
1660}
1661
1662ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk)
1663{
1664 struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
1665 FLGPTN flgptn = 0;
1666 ER ret;
1667 int len;
1668
1669 if (fp == NULL)
1670 return E_PAR;
1671
1672 int fd = fp->fd;
1673 FD_SET(fd, (fd_set *)&flgptn);
1674
1675 switch (fncd) {
1676 case TFN_TCP_RCV_BUF:
1677 len = *(int *)p_parblk;
1678 if ((len <= 0) || (fp->exinf == NULL))
1679 return E_OK;
1680
1681 ret = wai_sem(SEM_FILEDESC);
1682 if (ret < 0) {
1683 syslog(LOG_ERROR, "wai_sem => %d", ret);
1684 }
1685 socket_t *socket = (socket_t *)fp->exinf;
1686 socket->len += len;
1687 ret = sig_sem(SEM_FILEDESC);
1688 if (ret < 0) {
1689 syslog(LOG_ERROR, "sig_sem => %d", ret);
1690 }
1691
1692 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1693
1694 set_flg(FLG_SELECT_WAIT, flgptn);
1695 return E_OK;
1696
1697 case TFN_TCP_RCV_DAT:
1698 len = *(int *)p_parblk;
1699 if ((len <= 0) || (fp->exinf == NULL))
1700 return E_OK;
1701
1702 ret = wai_sem(SEM_FILEDESC);
1703 if (ret < 0) {
1704 syslog(LOG_ERROR, "wai_sem => %d", ret);
1705 }
1706 socket->len += len;
1707 ret = sig_sem(SEM_FILEDESC);
1708 if (ret < 0) {
1709 syslog(LOG_ERROR, "sig_sem => %d", ret);
1710 }
1711
1712 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1713
1714 set_flg(FLG_SELECT_WAIT, flgptn);
1715 return E_OK;
1716
1717 case TFN_TCP_SND_DAT:
1718 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
1719
1720 set_flg(FLG_SELECT_WAIT, flgptn);
1721 return E_OK;
1722
1723 case TFN_TCP_CAN_CEP:
1724 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
1725
1726 set_flg(FLG_SELECT_WAIT, flgptn);
1727 return E_OK;
1728
1729 case TFN_TCP_DEL_REP:
1730 delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
1731 return E_OK;
1732
1733 case TFN_TCP_DEL_CEP:
1734 delete_fd_by_id(&IO_TYPE_TCP, cepid);
1735 return E_OK;
1736
1737 default:
1738 return E_OK;
1739 }
1740}
1741
1742int udp_fd_close(struct SHELL_FILE *fp)
1743{
1744 ER ret;
1745 ID cepid;
1746
1747 socket_t *socket = (socket_t *)fp->exinf;
1748 switch (socket->family) {
1749 case AF_INET: {
1750 cepid = socket->cepid;
1751 ret = udp_del_cep(cepid);
1752 //delete_fd_by_id(&IO_TYPE_UDP, cepid);
1753 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
1754 if (ret < 0) {
1755 return -EINVAL;
1756 }
1757 break;
1758 }
1759 case AF_INET6: {
1760 cepid = socket->cepid;
1761 ret = udp6_del_cep(cepid);
1762 //delete_fd_by_id(&IO_TYPE_UDP, cepid);
1763 delete_id(udp6_cepid_table, udp6_cepid_table_count, cepid);
1764 if (ret < 0) {
1765 return -EINVAL;
1766 }
1767 break;
1768 }
1769 default:
1770 return -ENOPROTOOPT;
1771 }
1772
1773 return 0;
1774}
1775
1776size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
1777{
1778 return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
1779}
1780
1781size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
1782{
1783 return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
1784}
1785
1786off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
1787{
1788 return -EPERM;
1789}
1790
1791int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
1792{
1793 return -EINVAL;
1794}
1795
1796bool_t udp_fd_readable(struct SHELL_FILE *fp)
1797{
1798 socket_t *socket = (socket_t *)fp->exinf;
1799 if (socket->cepid != 0) {
1800 if (socket->input != NULL) {
1801 return true;
1802 }
1803 }
1804
1805 return false;
1806}
1807
1808void udp_fd_delete(struct SHELL_FILE *fp)
1809{
1810 //socket_t *socket = (socket_t *)fp->exinf;
1811 //free(socket->buf);
1812 //socket->buf = NULL;
1813 free(fp->exinf);
1814 fp->exinf = NULL;
1815}
1816
1817ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk)
1818{
1819 struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
1820 FLGPTN flgptn = 0;
1821 int len;
1822
1823 if (fp == NULL)
1824 return E_PAR;
1825
1826 int fd = fp->fd;
1827 FD_SET(fd, (fd_set *)&flgptn);
1828
1829 switch (fncd) {
1830 case TEV_UDP_RCV_DAT:
1831 {
1832 T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
1833 len = udppara->len;
1834 if ((len <= 0) || (fp->exinf == NULL))
1835 return E_OK;
1836
1837 ER ret = wai_sem(SEM_FILEDESC);
1838 if (ret < 0) {
1839 syslog(LOG_ERROR, "wai_sem => %d", ret);
1840 }
1841 socket_t *socket = (socket_t *)fp->exinf;
1842 socket->len = len;
1843 if (socket->input != NULL) {
1844 ret = rel_net_buf(socket->input);
1845 if (ret < 0) {
1846 syslog(LOG_ERROR, "rel_net_buf => %d", ret);
1847 }
1848 }
1849 socket->input = udppara->input;
1850 socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
1851 memset(&socket->raddr4, 0, sizeof(socket->raddr4));
1852 socket->raddr4.sin_family = AF_INET;
1853 socket->raddr4.sin_port = htons(udppara->rep4.portno);
1854 socket->raddr4.sin_addr.s_addr = htonl(udppara->rep4.ipaddr);
1855 udppara->input->flags |= NB_FLG_NOREL_IFOUT;
1856 ret = sig_sem(SEM_FILEDESC);
1857 if (ret < 0) {
1858 syslog(LOG_ERROR, "sig_sem => %d", ret);
1859 }
1860
1861 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1862
1863 set_flg(FLG_SELECT_WAIT, flgptn);
1864 return E_OK;
1865 }
1866 case TFN_UDP_CRE_CEP:
1867 return E_OK;
1868
1869 case TFN_UDP_RCV_DAT:
1870 len = *(int *)p_parblk;
1871 if ((len <= 0) || (fp->exinf == NULL))
1872 return E_OK;
1873
1874 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1875
1876 set_flg(FLG_SELECT_WAIT, flgptn);
1877 return E_OK;
1878
1879 case TFN_UDP_SND_DAT:
1880 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
1881
1882 set_flg(FLG_SELECT_WAIT, flgptn);
1883 return E_OK;
1884
1885 case TFN_UDP_CAN_CEP:
1886 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
1887
1888 set_flg(FLG_SELECT_WAIT, flgptn);
1889 return E_OK;
1890
1891 case TFN_UDP_DEL_CEP:
1892 delete_fd_by_id(&IO_TYPE_UDP, cepid);
1893 return E_OK;
1894
1895 default:
1896 return E_OK;
1897 }
1898}
1899
1900ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk)
1901{
1902 struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
1903 FLGPTN flgptn = 0;
1904 int len;
1905
1906 if (fp == NULL)
1907 return E_PAR;
1908
1909 int fd = fp->fd;
1910 FD_SET(fd, (fd_set *)&flgptn);
1911
1912 switch (fncd) {
1913 case TEV_UDP_RCV_DAT:
1914 {
1915 T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
1916 len = udppara->len;
1917 if ((len <= 0) || (fp->exinf == NULL))
1918 return E_OK;
1919
1920 ER ret = wai_sem(SEM_FILEDESC);
1921 if (ret < 0) {
1922 syslog(LOG_ERROR, "wai_sem => %d", ret);
1923 }
1924 socket_t *socket = (socket_t *)fp->exinf;
1925 socket->len = len;
1926 if (socket->input != NULL) {
1927 ret = rel_net_buf(socket->input);
1928 if (ret < 0) {
1929 syslog(LOG_ERROR, "rel_net_buf => %d", ret);
1930 }
1931 }
1932 socket->input = udppara->input;
1933 socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
1934 memset(&socket->raddr6, 0, sizeof(socket->raddr6));
1935 socket->raddr6.sin6_family = AF_INET;
1936 socket->raddr6.sin6_port = htons(udppara->rep6.portno);
1937#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
1938 memcpy(socket->raddr6.sin6_addr.__in6_union.__s6_addr, udppara->rep6.ipaddr.__u6_addr.__u6_addr8, 16);
1939#else
1940 for (int i = 0; i < 16; i++)
1941 socket->raddr6.sin6_addr.__in6_union.__s6_addr[i] = udppara->rep6.ipaddr.__u6_addr.__u6_addr8[i];
1942#endif
1943 udppara->input->flags |= NB_FLG_NOREL_IFOUT;
1944 ret = sig_sem(SEM_FILEDESC);
1945 if (ret < 0) {
1946 syslog(LOG_ERROR, "sig_sem => %d", ret);
1947 }
1948
1949 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1950
1951 set_flg(FLG_SELECT_WAIT, flgptn);
1952 return E_OK;
1953 }
1954 case TFN_UDP_CRE_CEP:
1955 return E_OK;
1956
1957 case TFN_UDP_RCV_DAT:
1958 len = *(int *)p_parblk;
1959 if ((len <= 0) || (fp->exinf == NULL))
1960 return E_OK;
1961
1962 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
1963
1964 set_flg(FLG_SELECT_WAIT, flgptn);
1965 return E_OK;
1966
1967 case TFN_UDP_SND_DAT:
1968 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
1969
1970 set_flg(FLG_SELECT_WAIT, flgptn);
1971 return E_OK;
1972
1973 case TFN_UDP_CAN_CEP:
1974 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
1975
1976 set_flg(FLG_SELECT_WAIT, flgptn);
1977 return E_OK;
1978
1979 case TFN_UDP_DEL_CEP:
1980 delete_fd_by_id(&IO_TYPE_UDP, cepid);
1981 return E_OK;
1982
1983 default:
1984 return E_OK;
1985 }
1986}
1987
1988#ifndef TCP_CFG_EXTENTIONS
1989ER tcp_cre_rep(ID repid, T_TCP_CREP *pk_crep)
1990{
1991 syslog(LOG_ERROR, "tcp_cre_rep not implement");
1992 shell_abort();
1993 return E_SYS;
1994}
1995
1996ER tcp_cre_cep(ID cepid, T_TCP_CCEP *pk_ccep)
1997{
1998 syslog(LOG_ERROR, "tcp_cre_cep not implement");
1999 shell_abort();
2000 return E_SYS;
2001}
2002#endif
2003
2004#ifndef UDP_CFG_EXTENTIONS
2005ER udp_cre_cep(ID cepid, T_UDP_CCEP *pk_ccep)
2006{
2007 syslog(LOG_ERROR, "udp_cre_cep not implement");
2008 shell_abort();
2009 return E_SYS;
2010}
2011#endif
2012
2013#ifndef TCP_CFG_EXTENTIONS
2014ER_UINT tcp_snd_oob(ID cepid, void *data, int_t len, TMO tmout)
2015{
2016 syslog(LOG_ERROR, "tcp_snd_oob not implement");
2017 shell_abort();
2018 return E_SYS;
2019}
2020
2021ER_UINT tcp_rcv_oob(ID cepid, void *data, int_t len)
2022{
2023 syslog(LOG_ERROR, "tcp_rcv_oob not implement");
2024 shell_abort();
2025 return E_SYS;
2026}
2027
2028ER tcp_set_opt(ID cepid, int_t optname, void *optval, int_t optlen)
2029{
2030 syslog(LOG_ERROR, "tcp_set_opt not implement");
2031 shell_abort();
2032 return E_SYS;
2033}
2034
2035ER tcp_get_opt(ID cepid, int_t optname, void *optval, int_t optlen)
2036{
2037 syslog(LOG_ERROR, "tcp_get_opt not implement");
2038 shell_abort();
2039 return E_SYS;
2040}
2041#endif
2042
2043#ifndef UDP_CFG_EXTENTIONS
2044ER udp_get_opt(ID cepid, int_t optname, void *optval, int_t optlen)
2045{
2046 syslog(LOG_ERROR, "udp_get_opt not implement");
2047 shell_abort();
2048 return E_SYS;
2049}
2050
2051ER udp_set_opt(ID cepid, int_t optname, void *optval, int_t optlen)
2052{
2053 syslog(LOG_ERROR, "udp_set_opt not implement");
2054 shell_abort();
2055 return E_SYS;
2056}
2057#endif
2058
2059// musl-1.1.18/network/lookup.h
2060struct address {
2061 int family;
2062 unsigned scopeid;
2063 uint8_t addr[16];
2064 int sortkey;
2065};
2066
2067#define MAXNS 3
2068
2069struct resolvconf {
2070 struct address ns[MAXNS];
2071 unsigned nns, attempts, ndots;
2072 unsigned timeout;
2073};
2074
2075// musl-1.1.18/network/resolvconf.c
2076int __get_resolv_conf(struct resolvconf *conf, char *search, size_t search_sz)
2077{
2078 int nns = 0;
2079
2080 conf->ndots = 1;
2081 conf->timeout = 5;
2082 conf->attempts = 2;
2083 if (search) *search = 0;
2084
2085#if defined(SUPPORT_INET4)
2086 T_IN4_ADDR in4_addr;
2087 conf->ns[nns].family = AF_INET;
2088 conf->ns[nns].scopeid = 0;
2089 dns_in4_get_addr(&in4_addr);
2090 *(uint32_t *)conf->ns[nns].addr = ntohl(in4_addr);
2091 nns++;
2092#endif
2093
2094#if defined(SUPPORT_INET6)
2095 conf->ns[nns].family = AF_INET6;
2096 conf->ns[nns].scopeid = 0;
2097 dns_in6_get_addr((T_IN6_ADDR *)conf->ns[nns].addr);
2098 nns++;
2099#endif
2100 conf->nns = nns;
2101
2102 return 0;
2103}
Note: See TracBrowser for help on using the repository browser.