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

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

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