source: EcnlProtoTool/trunk/ntshell/src/socket_stub.c@ 321

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

文字コードを設定
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 18.6 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 <sys/types.h>
38#include <stdint.h>
39#if 0
40#include <sys/socket.h>
41#include <sys/un.h>
42#include <netinet/in.h>
43#include <netinet/tcp.h>
44#include <arpa/inet.h>
45#include <netdb.h>
46#endif
47#include <fcntl.h>
48#include "sys/unistd.h"
49#include <stddef.h>
50#include <string.h>
51#include <stdlib.h>
52#include <kernel.h>
53#include <t_syslog.h>
54#include <t_stdlib.h>
55#include <sil.h>
56#include <stdlib.h>
57#include <string.h>
58#include <stdio.h>
59#include <setjmp.h>
60#include "syssvc/syslog.h"
61#include <tinet_config.h>
62#include <netinet/in.h>
63#include <netinet/in_itron.h>
64#include <tinet_nic_defs.h>
65#include <tinet_cfg.h>
66#include <netinet/in_var.h>
67#include <net/ethernet.h>
68#include <net/if6_var.h>
69#include <net/net.h>
70#include <net/if_var.h>
71#include <netinet/udp_var.h>
72//#include <netinet/tcp_var.h>
73extern const ID tmax_tcp_cepid;
74#include "ff.h"
75#include "socket_stub.h"
76#define SO_REUSEADDR 2
77
78typedef struct id_table_t {
79 int used;
80 ID id;
81} id_table_t;
82
83id_table_t tcp_repid_table[] = {
84 {0, USR_TCP_REP1}, {0, USR_TCP_REP2}, {0, USR_TCP_REP3}, {0, USR_TCP_REP4}
85};
86#define tcp_repid_table_count (sizeof(tcp_repid_table) / sizeof(tcp_repid_table[0]))
87
88id_table_t tcp_cepid_table[] = {
89 {0, USR_TCP_CEP1}, {0, USR_TCP_CEP2}, {0, USR_TCP_CEP3}, {0, USR_TCP_CEP4}, {0, USR_TCP_CEP5}, {0, USR_TCP_CEP6}, {0, USR_TCP_CEP7}, {0, USR_TCP_CEP8}
90};
91#define tcp_cepid_table_count (sizeof(tcp_cepid_table) / sizeof(tcp_cepid_table[0]))
92
93id_table_t udp_cepid_table[] = {
94 {0, USR_UDP_CEP1}, {0, USR_UDP_CEP2}, {0, USR_UDP_CEP3}, {0, USR_UDP_CEP4}
95};
96#define udp_cepid_table_count (sizeof(udp_cepid_table) / sizeof(udp_cepid_table[0]))
97
98ID new_id(id_table_t *table, int count)
99{
100 for (int i = 0; i < count; i++) {
101 id_table_t *item = &table[i];
102 if (item->used != 0)
103 continue;
104
105 item->used = 1;
106 return item->id;
107}
108
109 return -1;
110}
111
112int delete_id(id_table_t *table, int count, ID id)
113{
114 for (int i = 0; i < count; i++) {
115 id_table_t *item = &table[i];
116 if ((item->used == 0) || (item->id != id))
117 continue;
118
119 item->used = 0;
120 return 0;
121 }
122 return -1;
123}
124
125int delete_tcp_rep(int repid)
126{
127 delete_tcp_fd(tmax_tcp_cepid + repid);
128}
129
130unsigned char tcp_buf[tcp_cepid_table_count][2 * 512];
131
132unsigned char *id_to_buff(ID id)
133{
134 for (int i = 0; i < tcp_cepid_table_count; i++) {
135 id_table_t *item = &tcp_cepid_table[i];
136 if ((item->used == 0) || (item->id != id))
137 continue;
138
139 return tcp_buf[i];
140 }
141
142 return NULL;
143}
144
145typedef struct _IO_FILE SOCKET;
146
147int socket(int family, int type, int protocol)
148{
149 SOCKET *fp;
150
151 switch (family) {
152 case AF_INET:
153 case AF_INET6:
154 break;
155 default:
156 return -1;
157 }
158
159 switch (type) {
160 case SOCK_STREAM:
161 fp = new_tcp_fd(0);
162 break;
163 case SOCK_DGRAM:
164 fp = new_udp_fd(0);
165 break;
166 default:
167 return -1;
168 }
169
170 if (fp == NULL) {
171 return -1;
172 }
173
174 fp->socket.family = family;
175 fp->socket.type = type;
176 fp->socket.protocol = protocol;
177
178 return fp->fd;
179}
180
181int bind(int fd, const struct sockaddr *addr, socklen_t len)
182{
183 SOCKET *fp = fd_to_fp(fd);
184 if (fp == NULL) {
185 return -1;
186 }
187
188 if (fp->socket.family != addr->sa_family) {
189 return -1;
190 }
191
192 ER ret;
193 switch (addr->sa_family) {
194 case AF_INET: {
195 if (len < 8) {
196 return -1;
197 }
198 struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
199 memcpy(&fp->socket.laddr4, addr, len);
200 switch (fp->socket.type) {
201 case SOCK_STREAM: {
202 ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
203 if (cepid < 0)
204 return -1;
205
206 fp->socket.buf_size = 512 + 512;
207 fp->socket.buf = id_to_buff(cepid);
208 T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
209 ret = tcp_cre_cep(cepid, &ccep);
210 if (ret != E_OK) {
211 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
212 return -1;
213 }
214 fp->handle = cepid;
215 fp->socket.cepid = cepid;
216 break;
217 }
218 case SOCK_DGRAM: {
219 ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
220 if (cepid < 0)
221 return -1;
222
223 T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, socket_udp_callback };
224 ret = udp_cre_cep(cepid, &ccep);
225 if (ret != E_OK) {
226 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
227 return -1;
228 }
229 fp->handle = cepid;
230 fp->socket.cepid = cepid;
231 break;
232 }
233 default:
234 return -1;
235 }
236 break;
237 }
238 case AF_INET6: {
239 if (len < 20) {
240 return -1;
241 }
242 memcpy(&fp->socket.laddr4, addr, len);
243 break;
244 }
245 }
246
247 return 0;
248}
249
250int listen(int fd, int backlog)
251{
252 SOCKET *fp = fd_to_fp(fd);
253 if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
254 return -1;
255 }
256
257 fp->socket.backlog = backlog;
258
259 ER ret;
260 switch (fp->socket.family) {
261 case AF_INET: {
262 ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
263 if (repid < 0)
264 return -1;
265
266 struct sockaddr_in *laddr = &fp->socket.laddr4;
267 T_TCP_CREP crep = { 0, {ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port)} };
268 ret = tcp_cre_rep(repid, &crep);
269 if (ret != E_OK) {
270 delete_id(tcp_repid_table, tcp_repid_table_count, repid);
271 return -1;
272 }
273 fp->socket.repid = repid;
274 break;
275 }
276 case AF_INET6: {
277 break;
278 }
279 }
280
281 return 0;
282}
283
284int connect(int fd, const struct sockaddr *addr, socklen_t len)
285{
286 SOCKET *fp = fd_to_fp(fd);
287 if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
288 return -1;
289 }
290
291 ER ret;
292 switch (fp->socket.family) {
293 case AF_INET: {
294 if (len < 8) {
295 return -1;
296 }
297 if (fp->socket.cepid == 0) {
298 ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
299 if (cepid < 0)
300 return -1;
301
302 fp->socket.buf_size = 512 + 512;
303 fp->socket.buf = id_to_buff(cepid);
304 T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
305 ret = tcp_cre_cep(cepid, &ccep);
306 if (ret != E_OK) {
307 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
308 return -1;
309 }
310 fp->handle = cepid;
311 fp->socket.cepid = cepid;
312 }
313 struct sockaddr_in *laddr = &fp->socket.laddr4;
314 struct sockaddr_in *raddr = &fp->socket.raddr4;
315 memset(raddr, 0, sizeof(*raddr));
316 memcpy(raddr, addr, len);
317 T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
318 T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
319 ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, TMO_FEVR);
320 if (ret < 0) {
321 return -1;
322 }
323 break;
324 }
325 case AF_INET6: {
326 break;
327 }
328 }
329
330 return 0;
331}
332
333int accept(int fd, struct sockaddr *addr, socklen_t *len)
334{
335 SOCKET *lfp = fd_to_fp(fd);
336 if ((lfp == NULL) || (lfp->socket.type != SOCK_STREAM)) {
337 return -1;
338 }
339
340 SOCKET *fp = new_tcp_fd(0);
341 if (fp == NULL) {
342 return -1;
343 }
344
345 memcpy(&fp->socket, &lfp->socket, sizeof(fp->socket));
346
347 ER ret;
348 switch (fp->socket.family) {
349 case AF_INET: {
350 ID cepid;
351 if (fp->socket.cepid == 0) {
352 cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
353 if (cepid < 0)
354 return -1;
355
356 fp->socket.buf_size = 512 + 512;
357 fp->socket.buf = id_to_buff(cepid);
358 T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
359 ret = tcp_cre_cep(cepid, &ccep);
360 if (ret != E_OK) {
361 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
362 return -1;
363 }
364 fp->handle = cepid;
365 fp->socket.cepid = cepid;
366 }
367 else {
368 cepid = lfp->socket.cepid;
369 lfp->handle = tmax_tcp_cepid + lfp->socket.repid;
370 lfp->socket.cepid = 0;
371 lfp->socket.buf_size = 0;
372 lfp->socket.buf = 0;
373 }
374 T_IPV4EP rep = { 0, 0 };
375 ret = tcp_acp_cep(fp->socket.cepid, fp->socket.repid, &rep, TMO_FEVR);
376 if (ret < 0) {
377 return -1;
378 }
379 struct sockaddr_in *raddr = &fp->socket.raddr4;
380 memset(raddr, 0, sizeof(*raddr));
381 raddr->sin_family = AF_INET;
382 raddr->sin_port = htons(rep.portno);
383 raddr->sin_addr.s_addr = htonl(rep.ipaddr);
384 break;
385 }
386 case AF_INET6: {
387 break;
388 }
389 }
390
391 if (addr != NULL && len != NULL) {
392 int sz = *len;
393 if (sz < 8) {
394 return -1;
395 }
396 struct sockaddr_in *raddr = &fp->socket.raddr4;
397 if (sz > sizeof(*raddr))
398 sz = sizeof(*raddr);
399 memcpy(addr, raddr, sz);
400 *len = sizeof(*raddr);
401 }
402
403 return fp->fd;
404}
405
406ssize_t send(int fd, const void *buf, size_t len, int flags)
407{
408 SOCKET *fp = fd_to_fp(fd);
409 if (fp == NULL) {
410 return -1;
411 }
412
413 int ret = 0;
414 switch (fp->socket.family) {
415 case AF_INET: {
416 switch (fp->socket.type) {
417 case SOCK_STREAM: {
418 if (flags & MSG_OOB) {
419 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
420 if (ret < 0) {
421 return -1;
422 }
423 }
424 else {
425 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
426 if (ret < 0) {
427 return -1;
428 }
429 }
430 break;
431 }
432 case SOCK_DGRAM: {
433 return -1;
434 }
435 }
436 break;
437 }
438 case AF_INET6: {
439 break;
440 }
441 }
442
443 return ret;
444}
445
446ssize_t sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
447{
448 SOCKET *fp = fd_to_fp(fd);
449 if (fp == NULL) {
450 return -1;
451 }
452
453 int ret = 0;
454 switch (fp->socket.family) {
455 case AF_INET: {
456 switch (fp->socket.type) {
457 case SOCK_STREAM: {
458 if ((addr != NULL) && (alen != 0)) {
459 return -1;
460 }
461
462 if (flags & MSG_OOB) {
463 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
464 if (ret < 0) {
465 return -1;
466 }
467 }
468 else {
469 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
470 if (ret < 0) {
471 return -1;
472 }
473 }
474 break;
475 }
476 case SOCK_DGRAM: {
477 int sz = alen;
478 if (sz < 8) {
479 return -1;
480 }
481 struct sockaddr_in *raddr = &fp->socket.raddr4;
482 memset(raddr, 0, sizeof(*raddr));
483 memcpy(raddr, addr, sz);
484 T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
485 ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len, TMO_FEVR);
486 if (ret < 0) {
487 return -1;
488 }
489 break;
490 }
491 }
492 break;
493 }
494 case AF_INET6: {
495 break;
496 }
497 }
498
499 return ret;
500}
501
502ssize_t recv(int fd, void *buf, size_t len, int flags)
503{
504 SOCKET *fp = fd_to_fp(fd);
505 if (fp == NULL) {
506 return -1;
507 }
508
509 int ret = 0;
510 switch (fp->socket.family) {
511 case AF_INET: {
512 switch (fp->socket.type) {
513 case SOCK_STREAM: {
514 if (flags & MSG_OOB) {
515 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
516 if (ret < 0) {
517 return -1;
518 }
519 }
520 else {
521 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
522 if (ret < 0) {
523 return -1;
524 }
525 }
526 break;
527 }
528 case SOCK_DGRAM: {
529 T_IPV4EP rep = { 0, 0 };
530 ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
531 if (ret < 0) {
532 return -1;
533 }
534 }
535 }
536 break;
537 }
538 case AF_INET6: {
539 break;
540 }
541 }
542
543 return ret;
544}
545
546ssize_t recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen)
547{
548 SOCKET *fp = fd_to_fp(fd);
549 if (fp == NULL) {
550 return -1;
551 }
552
553 int ret = 0;
554 switch (fp->socket.family) {
555 case AF_INET: {
556 switch (fp->socket.type) {
557 case SOCK_STREAM: {
558 if (flags & MSG_OOB) {
559 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
560 if (ret < 0) {
561 return -1;
562 }
563 }
564 else {
565 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
566 if (ret < 0) {
567 return -1;
568 }
569 }
570 break;
571 }
572 case SOCK_DGRAM: {
573 T_IPV4EP rep = { 0, 0 };
574 ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
575 if (ret < 0) {
576 return -1;
577 }
578 int sz = *alen;
579 struct sockaddr_in raddr;
580 memset(&raddr, 0, sizeof(raddr));
581 raddr.sin_family = AF_INET;
582 raddr.sin_port = htons(rep.portno);
583 raddr.sin_addr.s_addr = htonl(rep.ipaddr);
584 if (sz > sizeof(raddr))
585 sz = sizeof(raddr);
586 memcpy(addr, &raddr, sz);
587 }
588 }
589 break;
590 }
591 case AF_INET6: {
592 break;
593 }
594 }
595
596 return ret;
597}
598
599int shutdown(int fd, int how)
600{
601 SOCKET *fp = fd_to_fp(fd);
602 if (fp == NULL) {
603 return -1;
604 }
605
606 ER ret;
607 switch (fp->socket.family) {
608 case AF_INET: {
609 switch (fp->socket.type) {
610 case SOCK_STREAM: {
611 ret = tcp_sht_cep(fp->socket.cepid);
612 if (ret < 0) {
613 return -1;
614 }
615 break;
616 }
617 }
618 break;
619 }
620 case AF_INET6: {
621 break;
622 }
623 }
624
625 return 0;
626}
627
628int getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
629{
630 SOCKET *fp = fd_to_fp(fd);
631 if (fp == NULL) {
632 return -1;
633 }
634
635 ER ret;
636 switch (fp->socket.family) {
637 case AF_INET: {
638 switch (fp->socket.type) {
639 case SOCK_STREAM: {
640 switch (optname) {
641 case SO_REUSEADDR:
642 if (fp->socket.flags & SO_REUSEADDR) {
643 *(bool *)optval = true;
644 }
645 else {
646 *(bool *)optval = false;
647 }
648 break;
649 default:
650 ret = tcp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
651 if (ret < 0) {
652 return -1;
653 }
654 *optlen = ret;
655 break;
656 }
657 break;
658 }
659 case SOCK_DGRAM: {
660 ret = udp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
661 if (ret < 0) {
662 return -1;
663 }
664 *optlen = ret;
665 break;
666 }
667 }
668 break;
669 }
670 case AF_INET6: {
671 break;
672 }
673 }
674
675 return 0;
676}
677
678int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
679{
680 SOCKET *fp = fd_to_fp(fd);
681 if (fp == NULL) {
682 return -1;
683 }
684
685 ER ret;
686 switch (fp->socket.family) {
687 case AF_INET: {
688 switch (fp->socket.type) {
689 case SOCK_STREAM: {
690 switch (optname) {
691 case SO_REUSEADDR:
692 if (*(bool *)optval) {
693 fp->socket.flags |= SO_REUSEADDR;
694 }
695 else {
696 fp->socket.flags &= ~SO_REUSEADDR;
697 }
698 break;
699 default:
700 ret = tcp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
701 if (ret < 0) {
702 return -1;
703 }
704 break;
705 }
706 break;
707 }
708 case SOCK_DGRAM: {
709 ret = udp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
710 if (ret < 0) {
711 return -1;
712 }
713 break;
714 }
715 }
716 break;
717 }
718 case AF_INET6: {
719 break;
720 }
721 }
722
723 return 0;
724}
725
726int tcp_fd_close(struct _IO_FILE *fp)
727{
728 ER ret;
729 switch (fp->socket.family) {
730 case AF_INET: {
731 if (fp->socket.cepid != 0) {
732 ID cepid = fp->socket.cepid;
733 ret = tcp_sht_cep(cepid);
734 if (ret < 0) {
735 //return -1;
736 }
737 ret = tcp_cls_cep(cepid, TMO_FEVR);
738 if (ret < 0) {
739 //return -1;
740 }
741 ret = tcp_del_cep(cepid);
742 delete_tcp_fd(cepid);
743 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
744 if (ret < 0) {
745 return -1;
746 }
747 }
748 else if (fp->socket.repid != 0) {
749 ID repid = fp->socket.repid;
750 ret = tcp_del_rep(repid);
751 delete_tcp_fd(tmax_tcp_cepid + repid);
752 delete_id(tcp_repid_table, tcp_repid_table_count, repid);
753 if (ret < 0) {
754 return -1;
755 }
756 }
757 else {
758 return -1;
759 }
760 break;
761 }
762 case AF_INET6: {
763 break;
764 }
765 }
766
767 return 0;
768}
769
770size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
771{
772 return recv(fp->fd, dst, dstsz, 0);
773}
774
775size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
776{
777 return send(fp->fd, src, srcsz, 0);
778}
779
780off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
781{
782 return -1;
783}
784
785int udp_fd_close(struct _IO_FILE *fp)
786{
787 ER ret;
788 ID cepid;
789 switch (fp->socket.family) {
790 case AF_INET: {
791 cepid = fp->socket.cepid;
792 ret = udp_del_cep(cepid);
793 delete_udp_fd(cepid);
794 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
795 if (ret < 0) {
796 return -1;
797 }
798 break;
799 }
800 case AF_INET6: {
801 break;
802 }
803 }
804
805 return 0;
806}
807
808size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
809{
810 return recv(fp->fd, dst, dstsz, 0);
811}
812
813size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
814{
815 return send(fp->fd, src, srcsz, 0);
816}
817
818off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
819{
820 return -1;
821}
822
823#ifndef TCP_CFG_EXTENTIONS
824ER tcp_cre_rep(ID repid, T_TCP_CREP *pk_crep)
825{
826 syslog(LOG_ERROR, "tcp_cre_rep not implement");
827 shell_abort();
828 return E_SYS;
829}
830
831ER tcp_cre_cep(ID cepid, T_TCP_CCEP *pk_ccep)
832{
833 syslog(LOG_ERROR, "tcp_cre_cep not implement");
834 shell_abort();
835 return E_SYS;
836}
837#endif
838
839#ifndef UDP_CFG_EXTENTIONS
840ER udp_cre_cep(ID cepid, T_UDP_CCEP *pk_ccep)
841{
842 syslog(LOG_ERROR, "udp_cre_cep not implement");
843 shell_abort();
844 return E_SYS;
845}
846#endif
847
848#ifndef TCP_CFG_EXTENTIONS
849ER_UINT tcp_snd_oob(ID cepid, void *data, int_t len, TMO tmout)
850{
851 syslog(LOG_ERROR, "tcp_snd_oob not implement");
852 shell_abort();
853 return E_SYS;
854}
855
856ER_UINT tcp_rcv_oob(ID cepid, void *data, int_t len)
857{
858 syslog(LOG_ERROR, "tcp_rcv_oob not implement");
859 shell_abort();
860 return E_SYS;
861}
862
863ER tcp_set_opt(ID cepid, int_t optname, void *optval, int_t optlen)
864{
865 syslog(LOG_ERROR, "tcp_set_opt not implement");
866 shell_abort();
867 return E_SYS;
868}
869
870ER tcp_get_opt(ID cepid, int_t optname, void *optval, int_t optlen)
871{
872 syslog(LOG_ERROR, "tcp_get_opt not implement");
873 shell_abort();
874 return E_SYS;
875}
876#endif
877
878#ifndef UDP_CFG_EXTENTIONS
879ER udp_get_opt(ID cepid, int_t optname, void *optval, int_t optlen)
880{
881 syslog(LOG_ERROR, "udp_get_opt not implement");
882 shell_abort();
883 return E_SYS;
884}
885
886ER udp_set_opt(ID cepid, int_t optname, void *optval, int_t optlen)
887{
888 syslog(LOG_ERROR, "udp_set_opt not implement");
889 shell_abort();
890 return E_SYS;
891}
892#endif
Note: See TracBrowser for help on using the repository browser.