Ignore:
Timestamp:
Jul 10, 2020, 9:09:25 PM (4 years ago)
Author:
coas-nagasima
Message:

NTShellタスクを更新

File:
1 edited

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/ntshell/src/socket_stub.c

    r439 r441  
    3939#include <t_syslog.h>
    4040#include <t_stdlib.h>
    41 //#include <string.h>
     41#include <string.h>
    4242#include <sil.h>
    43 #include <setjmp.h>
    4443#include "syssvc/syslog.h"
     44#include <tinet_defs.h>
    4545#include <tinet_config.h>
     46#include <net/net.h>
     47#include <net/net_endian.h>
    4648#include <netinet/in.h>
    4749#include <netinet/in_itron.h>
    … …  
    5456#include <net/if_var.h>
    5557#include <netinet/udp_var.h>
    56 //#include <netinet/tcp_var.h>
    57 extern const ID tmax_tcp_cepid;
    58 #include "ff.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>
    5964#include "fdtable.h"
     65#include "kernel_cfg.h"
     66
     67#ifdef _DEBUG
     68static const char THIS_FILE[] = __FILE__;
     69#endif
    6070
    6171#define SOCKET_TIMEOUT 2000000
     72#define TCP_SOCKET_BUF_SIZE 512
     73
     74struct addrinfo {
     75        int ai_flags;
     76        int ai_family;
     77        int ai_socktype;
     78        int ai_protocol;
     79        socklen_t ai_addrlen;
     80        struct sockaddr *ai_addr;
     81        char *ai_canonname;
     82        struct addrinfo *ai_next;
     83};
     84
     85typedef uint16_t in_port_t;
     86typedef uint32_t in_addr_t;
     87struct in_addr { in_addr_t s_addr; };
     88
     89struct sockaddr_in {
     90        sa_family_t sin_family;
     91        in_port_t sin_port;
     92        struct in_addr sin_addr;
     93        uint8_t sin_zero[8];
     94};
     95
     96struct in6_addr
     97{
     98        union {
     99                uint8_t __s6_addr[16];
     100                uint16_t __s6_addr16[8];
     101                uint32_t __s6_addr32[4];
     102        } __in6_union;
     103};
     104//#define s6_addr __in6_union.__s6_addr
     105//#define s6_addr16 __in6_union.__s6_addr16
     106//#define s6_addr32 __in6_union.__s6_addr32
     107
     108struct sockaddr_in6
     109{
     110        sa_family_t     sin6_family;
     111        in_port_t       sin6_port;
     112        uint32_t        sin6_flowinfo;
     113        struct in6_addr sin6_addr;
     114        uint32_t        sin6_scope_id;
     115};
     116
     117typedef struct socket_t {
     118        int family;
     119        int type;
     120        int protocol;
     121        int cepid;
     122        int repid;
     123        int backlog;
     124        unsigned int flags;
     125        union {
     126                struct sockaddr_in laddr4;
     127                struct sockaddr_in6 laddr6;
     128        };
     129        union {
     130                struct sockaddr_in raddr4;
     131                struct sockaddr_in6 raddr6;
     132        };
     133        int buf_size;
     134        unsigned char *buf;
     135        void *input;
     136        int len;
     137} socket_t;
     138
     139#define tcp6_cre_cep tcp_cre_cep
     140#define tcp6_del_cep tcp_del_cep
     141#define tcp6_del_rep tcp_del_rep
     142#define tcp6_can_cep tcp_can_cep
     143#define tcp6_sht_cep tcp_sht_cep
     144#define tcp6_cls_cep tcp_cls_cep
     145#define tcp6_snd_oob tcp_snd_oob
     146#define tcp6_snd_dat tcp_snd_dat
     147#define tcp6_rcv_oob tcp_rcv_oob
     148#define tcp6_rcv_buf tcp_rcv_buf
     149#define tcp6_rel_buf tcp_rel_buf
     150#define tcp6_get_opt tcp_get_opt
     151#define tcp6_set_opt tcp_set_opt
     152
     153#define udp6_can_cep udp_can_cep
     154
     155#ifndef SUPPORT_INET6
     156
     157ER      tcp6_cre_rep (ID repid, T_TCP6_CREP *pk_crep) { return E_SYS; }
     158ER      tcp6_acp_cep (ID cepid, ID repid, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     159ER      tcp6_con_cep (ID cepid, T_IPV6EP *p_myaddr, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     160
     161ER      udp6_cre_cep (ID cepid, T_UDP6_CCEP *pk_ccep) { return E_SYS; }
     162ER      udp6_del_cep (ID cepid) { return E_SYS; }
     163ER_UINT udp6_snd_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     164ER_UINT udp6_rcv_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     165ER      udp6_set_opt (ID cepid, int_t optname, void *optval, int_t optlen) { return E_SYS; }
     166ER      udp6_get_opt (ID cepid, int_t optname, void *optval, int_t optlen) { return E_SYS; }
     167
     168const T_IN6_ADDR *in6_get_ifaddr (int_t index) { return NULL; }
     169
     170#endif
     171
     172ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk);
     173ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk);
     174ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk);
     175ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk);
     176
     177static int tcp_fd_close(struct SHELL_FILE *fp);
     178static size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     179static size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     180static off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     181static int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     182static bool_t tcp_fd_readable(struct SHELL_FILE *fp);
     183static bool_t tcp_fd_writable(struct SHELL_FILE *fp);
     184static void tcp_fd_delete(struct SHELL_FILE *fp);
     185
     186static int udp_fd_close(struct SHELL_FILE *fp);
     187static size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     188static size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     189static off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     190static int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     191static bool_t udp_fd_readable(struct SHELL_FILE *fp);
     192static bool_t udp_fd_writable(struct SHELL_FILE *fp);
     193static void udp_fd_delete(struct SHELL_FILE *fp);
     194
     195IO_TYPE IO_TYPE_TCP = { tcp_fd_close, tcp_fd_read, tcp_fd_write, tcp_fd_seek, tcp_fd_ioctl, tcp_fd_readable, tcp_fd_writable, tcp_fd_delete };
     196IO_TYPE IO_TYPE_UDP = { udp_fd_close, udp_fd_read, udp_fd_write, udp_fd_seek, udp_fd_ioctl, udp_fd_readable, udp_fd_writable, udp_fd_delete };
    62197
    63198typedef struct id_table_t {
    … …  
    72207
    73208id_table_t tcp_cepid_table[] = {
    74         {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}
     209        {0, USR_TCP_CEP1}, {0, USR_TCP_CEP2}, {0, USR_TCP_CEP3}, {0, USR_TCP_CEP4},
     210#ifndef TOPPERS_GRSAKURA
     211        {0, USR_TCP_CEP5}, {0, USR_TCP_CEP6}, {0, USR_TCP_CEP7}, {0, USR_TCP_CEP8}
     212#endif
    75213};
    76214#define tcp_cepid_table_count (sizeof(tcp_cepid_table) / sizeof(tcp_cepid_table[0]))
     215
     216#ifdef SUPPORT_INET6
     217
     218id_table_t tcp6_repid_table[] = {
     219        {0, USR_TCP6_REP1}, {0, USR_TCP6_REP2}, {0, USR_TCP6_REP3}, {0, USR_TCP6_REP4}
     220};
     221#define tcp6_repid_table_count (sizeof(tcp6_repid_table) / sizeof(tcp6_repid_table[0]))
     222
     223id_table_t tcp6_cepid_table[] = {
     224        {0, USR_TCP6_CEP1}, {0, USR_TCP6_CEP2}, {0, USR_TCP6_CEP3}, {0, USR_TCP6_CEP4},
     225#ifndef TOPPERS_GRSAKURA
     226        {0, USR_TCP6_CEP5}, {0, USR_TCP6_CEP6}, {0, USR_TCP6_CEP7}, {0, USR_TCP6_CEP8}
     227#endif
     228};
     229#define tcp6_cepid_table_count (sizeof(tcp6_cepid_table) / sizeof(tcp6_cepid_table[0]))
     230
     231#else
     232
     233#define tcp6_repid_table NULL
     234#define tcp6_repid_table_count 0
     235
     236#define tcp6_cepid_table NULL
     237#define tcp6_cepid_table_count 0
     238
     239#endif
    77240
    78241id_table_t udp_cepid_table[] = {
    … …  
    81244#define udp_cepid_table_count (sizeof(udp_cepid_table) / sizeof(udp_cepid_table[0]))
    82245
     246#ifdef SUPPORT_INET6
     247
     248id_table_t udp6_cepid_table[] = {
     249        {0, USR_UDP6_CEP1}, {0, USR_UDP6_CEP2}, {0, USR_UDP6_CEP3}, {0, USR_UDP6_CEP4}
     250};
     251#define udp6_cepid_table_count (sizeof(udp6_cepid_table) / sizeof(udp6_cepid_table[0]))
     252
     253#else
     254
     255#define udp6_cepid_table NULL
     256#define udp6_cepid_table_count 0
     257
     258#endif
     259
     260void addrcpy(void *_dst, const void *_src, int len)
     261{
     262#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     263        memcpy(_dst, _src, len);
     264#else
     265        uint8_t *dst = (uint8_t *)_dst, *src = &((uint8_t *)_src)[len];
     266        while (src != _src)
     267                *dst++ = *--src;
     268#endif
     269}
     270
    83271ID new_id(id_table_t *table, int count)
    84272{
    … …  
    108296}
    109297
    110 int delete_tcp_rep(int repid)
    111 {
    112         return delete_tcp_fd(tmax_tcp_cepid + repid);
    113 }
    114 
    115 unsigned char tcp_buf[tcp_cepid_table_count][2 * 512];
    116 
    117 unsigned char *id_to_buff(ID id)
    118 {
    119         for (int i = 0; i < tcp_cepid_table_count; i++) {
    120                 id_table_t *item = &tcp_cepid_table[i];
    121                 if ((item->used == 0) || (item->id != id))
    122                         continue;
    123 
    124                 return tcp_buf[i];
    125         }
    126 
    127         return NULL;
    128 }
    129 
    130 typedef struct _IO_FILE SOCKET;
     298typedef struct SHELL_FILE SOCKET;
    131299
    132300int shell_socket(int family, int type, int protocol)
    … …  
    148316        switch (type) {
    149317        case SOCK_STREAM:
    150                 fp = new_tcp_fd(0);
     318                fp = new_fp(&IO_TYPE_TCP, 0, 0);
     319                if (fp == NULL)
     320                        return -ENOMEM;
     321
     322                fp->exinf = malloc(sizeof(socket_t));
     323                memset(fp->exinf, 0, sizeof(socket_t));
    151324                break;
    152325        case SOCK_DGRAM:
    153                 fp = new_udp_fd(0);
     326                fp = new_fp(&IO_TYPE_UDP, 0, 1);
     327                if (fp == NULL)
     328                        return -ENOMEM;
     329
     330                fp->exinf = malloc(sizeof(socket_t));
     331                memset(fp->exinf, 0, sizeof(socket_t));
    154332                break;
    155333        default:
    … …  
    157335        }
    158336
    159         if (fp == NULL) {
    160                 return -ENOMEM;
    161         }
    162 
    163         fp->socket.family = family;
    164         fp->socket.type = type;
    165         fp->socket.protocol = protocol;
    166         fp->socket.flags = flags;
     337        socket_t *socket = (socket_t *)fp->exinf;
     338        socket->family = family;
     339        socket->type = type;
     340        socket->protocol = protocol;
     341        socket->flags = flags;
    167342
    168343        return fp->fd;
    … …  
    174349        if (fp == NULL)
    175350                return -EBADF;
    176         if (fp->socket.family != addr->sa_family)
     351        socket_t *socket = (socket_t *)fp->exinf;
     352        if (socket->family != addr->sa_family)
    177353                return -EINVAL;
    178354
    … …  
    184360                }
    185361                struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
    186                 memcpy(&fp->socket.laddr4, addr, len);
    187                 switch (fp->socket.type) {
     362                memcpy(&socket->laddr4, addr, len);
     363                switch (socket->type) {
    188364                case SOCK_STREAM: {
    189365                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    … …  
    191367                                return -ENOMEM;
    192368
    193                         fp->socket.buf_size = 512 + 512;
    194                         fp->socket.buf = id_to_buff(cepid);
    195                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
     369                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     370                        socket->buf = malloc(socket->buf_size);
     371#ifdef _DEBUG
     372                        memset(socket->buf, 0, socket->buf_size);
     373#endif
     374                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    196375                        ret = tcp_cre_cep(cepid, &ccep);
    197376                        if (ret != E_OK) {
     377                                free(socket->buf);
     378                                socket->buf = NULL;
     379                                socket->buf_size = 0;
    198380                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    199381                                return -ENOMEM;
    200382                        }
    201383                        fp->handle = cepid;
    202                         fp->socket.cepid = cepid;
     384                        socket->cepid = cepid;
    203385                        break;
    204386                }
    … …  
    215397                        }
    216398                        fp->handle = cepid;
    217                         fp->socket.cepid = cepid;
     399                        socket->cepid = cepid;
    218400                        break;
    219401                }
    … …  
    227409                        return -EINVAL;
    228410                }
    229                 memcpy(&fp->socket.laddr4, addr, len);
    230                 break;
    231         }
     411                struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
     412                memcpy(&socket->laddr6, addr, len);
     413                switch (socket->type) {
     414                case SOCK_STREAM: {
     415                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     416                        if (cepid < 0)
     417                                return -ENOMEM;
     418
     419                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     420                        socket->buf = malloc(socket->buf_size);
     421#ifdef _DEBUG
     422                        memset(socket->buf, 0, socket->buf_size);
     423#endif
     424                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
     425                        ret = tcp6_cre_cep(cepid, &ccep);
     426                        if (ret != E_OK) {
     427                                free(socket->buf);
     428                                socket->buf = NULL;
     429                                socket->buf_size = 0;
     430                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     431                                return -ENOMEM;
     432                        }
     433                        fp->handle = cepid;
     434                        socket->cepid = cepid;
     435                        break;
     436                }
     437                case SOCK_DGRAM: {
     438                        ID cepid = new_id(udp6_cepid_table, udp6_cepid_table_count);
     439                        if (cepid < 0)
     440                                return -ENOMEM;
     441
     442                        T_UDP6_CCEP ccep = { 0, { { ntohl(addr_in6->sin6_addr.__in6_union.__s6_addr) }, ntohs(addr_in6->sin6_port)}, (FP)socket_udp6_callback };
     443                        ret = udp6_cre_cep(cepid, &ccep);
     444                        if (ret != E_OK) {
     445                                delete_id(udp6_cepid_table, udp6_cepid_table_count, cepid);
     446                                return -ENOMEM;
     447                        }
     448                        fp->handle = cepid;
     449                        socket->cepid = cepid;
     450                        break;
     451                }
     452                default:
     453                        return -ENOPROTOOPT;
     454                }
     455                break;
     456        }
     457        default:
     458                return -ENOPROTOOPT;
    232459        }
    233460
    … …  
    240467        if (fp == NULL)
    241468                return -EBADF;
    242         if (fp->socket.type != SOCK_STREAM)
     469        socket_t *socket = (socket_t *)fp->exinf;
     470        if (socket->type != SOCK_STREAM)
    243471                return -EINVAL;
    244472
    245         fp->socket.backlog = backlog;
     473        socket->backlog = backlog;
    246474
    247475        ER ret;
    248         switch (fp->socket.family) {
     476        switch (socket->family) {
    249477        case AF_INET: {
    250478                ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
    … …  
    252480                        return -ENOMEM;
    253481
    254                 struct sockaddr_in *laddr = &fp->socket.laddr4;
     482                struct sockaddr_in *laddr = &socket->laddr4;
    255483                T_TCP_CREP crep = { 0, {ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port)} };
    256484                ret = tcp_cre_rep(repid, &crep);
    … …  
    259487                        return -ENOMEM;
    260488                }
    261                 fp->socket.repid = repid;
     489                socket->repid = repid;
    262490                break;
    263491        }
    264492        case AF_INET6: {
    265                 break;
    266         }
     493                ID repid = new_id(tcp6_repid_table, tcp6_repid_table_count);
     494                if (repid < 0)
     495                        return -ENOMEM;
     496
     497                struct sockaddr_in6 *laddr = &socket->laddr6;
     498                T_TCP6_CREP crep = { 0, { { ntohl(laddr->sin6_addr.__in6_union.__s6_addr) }, ntohs(laddr->sin6_port)} };
     499                ret = tcp6_cre_rep(repid, &crep);
     500                if (ret != E_OK) {
     501                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     502                        return -ENOMEM;
     503                }
     504                socket->repid = repid;
     505                break;
     506        }
     507        default:
     508                return -ENOPROTOOPT;
    267509        }
    268510
    … …  
    270512}
    271513
    272 int shell_connect(int fd, const struct sockaddr *addr, socklen_t len)
     514int shell_connect(int fd, const struct sockaddr *addr, socklen_t alen)
    273515{
    274516        SOCKET *fp = fd_to_fp(fd);
    275517        if (fp == NULL)
    276518                return -EBADF;
    277         if (fp->socket.type != SOCK_STREAM)
     519        socket_t *socket = (socket_t *)fp->exinf;
     520        if (socket->type != SOCK_STREAM)
    278521                return -EINVAL;
    279522
    280523        ER ret;
    281         switch (fp->socket.family) {
     524        switch (socket->family) {
    282525        case AF_INET: {
    283                 if (len < 8) {
     526                if (alen < sizeof(struct sockaddr_in)) {
    284527                        return -EINVAL;
    285528                }
    286                 if (fp->socket.cepid == 0) {
     529                if (socket->cepid == 0) {
    287530                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    288531                        if (cepid < 0)
    289532                                return -ENOMEM;
    290533
    291                         fp->socket.buf_size = 512 + 512;
    292                         fp->socket.buf = id_to_buff(cepid);
    293                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
     534                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     535                        socket->buf = malloc(socket->buf_size);
     536#ifdef _DEBUG
     537                        memset(socket->buf, 0, socket->buf_size);
     538#endif
     539                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    294540                        ret = tcp_cre_cep(cepid, &ccep);
    295541                        if (ret != E_OK) {
     542                                free(socket->buf);
     543                                socket->buf = NULL;
     544                                socket->buf_size = 0;
    296545                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    297546                                return -ENOMEM;
    298547                        }
    299548                        fp->handle = cepid;
    300                         fp->socket.cepid = cepid;
    301                 }
    302                 struct sockaddr_in *laddr = &fp->socket.laddr4;
    303                 struct sockaddr_in *raddr = &fp->socket.raddr4;
    304                 memset(raddr, 0, sizeof(*raddr));
    305                 memcpy(raddr, addr, len);
     549                        fp->writable = 1;
     550                        socket->cepid = cepid;
     551                }
     552                struct sockaddr_in *laddr = &socket->laddr4;
     553                struct sockaddr_in *raddr = &socket->raddr4;
     554                memcpy(raddr, addr, sizeof(struct sockaddr_in));
    306555                T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
    307556                T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    308                 ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, SOCKET_TIMEOUT);
    309                 if (ret < 0) {
     557                ret = tcp_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
     558                if (ret == E_TMOUT) {
     559                        return -ETIMEDOUT;
     560                }
     561                else if (ret < 0) {
    310562                        return -EHOSTUNREACH;
    311563                }
    … …  
    313565        }
    314566        case AF_INET6: {
    315                 break;
    316         }
    317         }
     567                if (alen < sizeof(struct sockaddr_in6)) {
     568                        return -EINVAL;
     569                }
     570                if (socket->cepid == 0) {
     571                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     572                        if (cepid < 0)
     573                                return -ENOMEM;
     574
     575                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     576                        socket->buf = malloc(socket->buf_size);
     577#ifdef _DEBUG
     578                        memset(socket->buf, 0, socket->buf_size);
     579#endif
     580                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
     581                        ret = tcp6_cre_cep(cepid, &ccep);
     582                        if (ret != E_OK) {
     583                                free(socket->buf);
     584                                socket->buf = NULL;
     585                                socket->buf_size = 0;
     586                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     587                                return -ENOMEM;
     588                        }
     589                        fp->handle = cepid;
     590                        fp->writable = 1;
     591                        socket->cepid = cepid;
     592                }
     593                struct sockaddr_in6 *laddr = &socket->laddr6;
     594                struct sockaddr_in6 *raddr = &socket->raddr6;
     595                memcpy(raddr, addr, sizeof(struct sockaddr_in6));
     596                T_IPV6EP lep;
     597                addrcpy(&lep.ipaddr, &laddr->sin6_addr, 16);
     598                lep.portno = ntohs(laddr->sin6_port);
     599                T_IPV6EP rep;
     600                addrcpy(&rep.ipaddr, &raddr->sin6_addr, 16);
     601                rep.portno = ntohs(raddr->sin6_port);
     602                ret = tcp6_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
     603                if (ret == E_TMOUT) {
     604                        return -ETIMEDOUT;
     605                }
     606                else if (ret < 0) {
     607                        return -EHOSTUNREACH;
     608                }
     609                break;
     610        }
     611        default:
     612                return -ENOPROTOOPT;
     613        }
     614
     615        if (fp->writeevt_w != fp->writeevt_r) fp->writeevt_r++;
    318616
    319617        return 0;
    320618}
    321619
    322 int shell_accept(int fd, struct sockaddr *__restrict addr, socklen_t *__restrict len)
     620int shell_accept(int fd, struct sockaddr *restrict addr, socklen_t *restrict alen)
    323621{
    324622        SOCKET *lfp = fd_to_fp(fd);
    325623        if (lfp == NULL)
    326624                return -EBADF;
    327         if (lfp->socket.type != SOCK_STREAM)
     625        if (((socket_t *)lfp->exinf)->type != SOCK_STREAM)
    328626                return -EINVAL;
    329627
    330         SOCKET *fp = new_tcp_fd(0);
    331         if (fp == NULL) {
     628        SOCKET *fp = new_fp(&IO_TYPE_TCP, 0, 0);
     629        if (fp == NULL)
    332630                return -ENOMEM;
    333         }
    334 
    335         memcpy(&fp->socket, &lfp->socket, sizeof(fp->socket));
     631
     632        fp->exinf = malloc(sizeof(socket_t));
     633        memset(fp->exinf, 0, sizeof(socket_t));
     634
     635        memcpy(fp->exinf, lfp->exinf, offsetof(socket_t, buf_size));
    336636
    337637        ER ret;
    338         switch (fp->socket.family) {
     638        socket_t *socket = (socket_t *)fp->exinf;
     639        switch (socket->family) {
    339640        case AF_INET: {
    340641                ID cepid;
    341                 if (fp->socket.cepid == 0) {
     642                if (socket->cepid == 0) {
    342643                        cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    343644                        if (cepid < 0)
    344645                                return -ENOMEM;
    345646
    346                         fp->socket.buf_size = 512 + 512;
    347                         fp->socket.buf = id_to_buff(cepid);
    348                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
     647                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     648                        socket->buf = malloc(socket->buf_size);
     649#ifdef _DEBUG
     650                        memset(socket->buf, 0, socket->buf_size);
     651#endif
     652                        T_TCP_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp_callback };
    349653                        ret = tcp_cre_cep(cepid, &ccep);
    350654                        if (ret != E_OK) {
     655                                free(socket->buf);
     656                                socket->buf = NULL;
     657                                socket->buf_size = 0;
    351658                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    352659                                return -ENOMEM;
    353660                        }
    354661                        fp->handle = cepid;
    355                         fp->socket.cepid = cepid;
     662                        fp->writable = 1;
     663                        socket->cepid = cepid;
    356664                }
    357665                else {
    358                         cepid = lfp->socket.cepid;
    359                         lfp->handle = tmax_tcp_cepid + lfp->socket.repid;
    360                         lfp->socket.cepid = 0;
    361                         lfp->socket.buf_size = 0;
    362                         lfp->socket.buf = 0;
     666                        cepid = ((socket_t *)lfp->exinf)->cepid;
     667                        fp->handle = cepid;
     668                        fp->writable = 1;
     669                        lfp->handle = tmax_tcp_cepid + ((socket_t *)lfp->exinf)->repid;
     670                        ((socket_t *)lfp->exinf)->cepid = 0;
     671                        ((socket_t *)lfp->exinf)->buf_size = 0;
     672                        ((socket_t *)lfp->exinf)->buf = 0;
    363673                }
    364674                T_IPV4EP rep = { 0, 0 };
    365                 ret = tcp_acp_cep(fp->socket.cepid, fp->socket.repid, &rep, TMO_FEVR);
     675                ret = tcp_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
    366676                if (ret < 0) {
    367677                        return -ENOMEM;
    368678                }
    369                 struct sockaddr_in *raddr = &fp->socket.raddr4;
    370                 memset(raddr, 0, sizeof(*raddr));
     679                struct sockaddr_in *raddr = &socket->raddr4;
     680                memset(raddr, 0, sizeof(struct sockaddr_in));
    371681                raddr->sin_family = AF_INET;
    372682                raddr->sin_port = htons(rep.portno);
    373683                raddr->sin_addr.s_addr = htonl(rep.ipaddr);
     684
     685                if (addr != NULL && alen != NULL) {
     686                        int sz = *alen;
     687                        if (sz < sizeof(struct sockaddr_in)) {
     688                                return -EINVAL;
     689                        }
     690                        if (sz > sizeof(struct sockaddr_in))
     691                                sz = sizeof(struct sockaddr_in);
     692                        memcpy(addr, raddr, sz);
     693                        *alen = sz;
     694                }
    374695                break;
    375696        }
    376697        case AF_INET6: {
    377                 return -EAFNOSUPPORT;
    378         }
    379         }
    380 
    381         if (addr != NULL && len != NULL) {
    382                 int sz = *len;
    383                 if (sz < 8) {
    384                         return -EINVAL;
    385                 }
    386                 struct sockaddr_in *raddr = &fp->socket.raddr4;
    387                 if (sz > sizeof(*raddr))
    388                         sz = sizeof(*raddr);
    389                 memcpy(addr, raddr, sz);
    390                 *len = sizeof(*raddr);
    391         }
     698                ID cepid;
     699                if (socket->cepid == 0) {
     700                        cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     701                        if (cepid < 0)
     702                                return -ENOMEM;
     703
     704                        socket->buf_size = TCP_SOCKET_BUF_SIZE + TCP_SOCKET_BUF_SIZE;
     705                        socket->buf = malloc(socket->buf_size);
     706#ifdef _DEBUG
     707                        memset(socket->buf, 0, socket->buf_size);
     708#endif
     709                        T_TCP6_CCEP ccep = { 0, socket->buf, TCP_SOCKET_BUF_SIZE, &socket->buf[TCP_SOCKET_BUF_SIZE], TCP_SOCKET_BUF_SIZE, (FP)socket_tcp6_callback };
     710                        ret = tcp6_cre_cep(cepid, &ccep);
     711                        if (ret != E_OK) {
     712                                free(socket->buf);
     713                                socket->buf = NULL;
     714                                socket->buf_size = 0;
     715                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     716                                return -ENOMEM;
     717                        }
     718                        fp->handle = cepid;
     719                        fp->writable = 1;
     720                        socket->cepid = cepid;
     721                }
     722                else {
     723                        cepid = ((socket_t *)lfp->exinf)->cepid;
     724                        fp->handle = cepid;
     725                        fp->writable = 1;
     726                        lfp->handle = tmax_tcp6_cepid + ((socket_t *)lfp->exinf)->repid;
     727                        ((socket_t *)lfp->exinf)->cepid = 0;
     728                        ((socket_t *)lfp->exinf)->buf_size = 0;
     729                        ((socket_t *)lfp->exinf)->buf = 0;
     730                }
     731                T_IPV6EP rep = { { 0 }, 0 };
     732                ret = tcp6_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
     733                if (ret < 0) {
     734                        return -ENOMEM;
     735                }
     736                struct sockaddr_in6 *raddr = &socket->raddr6;
     737                memset(raddr, 0, sizeof(struct sockaddr_in6));
     738                raddr->sin6_family = AF_INET;
     739                raddr->sin6_port = htons(rep.portno);
     740                addrcpy(&raddr->sin6_addr, &rep.ipaddr, 16);
     741
     742                if (addr != NULL && alen != NULL) {
     743                        int sz = *alen;
     744                        if (sz < sizeof(struct sockaddr_in6)) {
     745                                return -EINVAL;
     746                        }
     747                        if (sz > sizeof(struct sockaddr_in6))
     748                                sz = sizeof(struct sockaddr_in6);
     749                        memcpy(addr, raddr, sz);
     750                        *alen = sz;
     751                }
     752                break;
     753        }
     754        default:
     755                return -ENOPROTOOPT;
     756        }
     757
     758        if (fp->writeevt_w != fp->writeevt_r) fp->writeevt_r++;
    392759
    393760        return fp->fd;
    394761}
    395762
    396 ssize_t shell_send(int fd, const void *buf, size_t len, int flags)
     763ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
    397764{
    398765        SOCKET *fp = fd_to_fp(fd);
    … …  
    402769
    403770        int ret = 0;
    404         switch (fp->socket.family) {
     771        socket_t *socket = (socket_t *)fp->exinf;
     772        switch (socket->family) {
    405773        case AF_INET: {
    406                 switch (fp->socket.type) {
     774                switch (socket->type) {
    407775                case SOCK_STREAM: {
     776                        if ((addr != NULL) || (alen != 0)) {
     777                                return -EISCONN;
     778                        }
     779
    408780                        if (flags & MSG_OOB) {
    409                                 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
     781                                ret = tcp_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    410782                                if (ret < 0) {
    411783                                        return -ECOMM;
    … …  
    413785                        }
    414786                        else {
    415                                 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
     787                                int temp = len;
     788                                for (;;) {
     789                                        ret = tcp_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     790                                        if (ret < 0) {
     791                                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     792                                        }
     793                                        len -= ret;
     794                                        if (len <= 0)
     795                                                break;
     796                                        buf = (const void *)&((uint8_t *)buf)[ret];
     797                                }
     798                                ret = temp;
     799                        }
     800                        break;
     801                }
     802                case SOCK_DGRAM: {
     803                        if ((addr == NULL) || (alen < sizeof(struct sockaddr_in))) {
     804                                return -EINVAL;
     805                        }
     806                        struct sockaddr_in *raddr = &socket->raddr4;
     807                        memcpy(raddr, addr, sizeof(struct sockaddr_in));
     808                        T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
     809                        ret = udp_snd_dat(socket->cepid, &rep, (void *)buf, len,
     810                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     811                        if (ret < 0) {
     812                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     813                        }
     814                        break;
     815                }
     816                }
     817                break;
     818        }
     819        case AF_INET6: {
     820                switch (socket->type) {
     821                case SOCK_STREAM: {
     822                        if ((addr != NULL) || (alen != 0)) {
     823                                return -EISCONN;
     824                        }
     825
     826                        if (flags & MSG_OOB) {
     827                                ret = tcp6_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    416828                                if (ret < 0) {
    417829                                        return -ECOMM;
    418830                                }
    419831                        }
     832                        else {
     833                                int temp = len;
     834                                for (;;) {
     835                                        ret = tcp6_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     836                                        if (ret < 0) {
     837                                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     838                                        }
     839                                        len -= ret;
     840                                        if (len <= 0)
     841                                                break;
     842                                        buf = (const void *)&((uint8_t *)buf)[ret];
     843                                }
     844                                ret = temp;
     845                        }
    420846                        break;
    421847                }
    422848                case SOCK_DGRAM: {
    423                         return -EINVAL;
    424                 }
    425                 }
    426                 break;
    427         }
    428         case AF_INET6: {
    429                 return -EAFNOSUPPORT;
    430         }
    431         }
     849                        if ((addr == NULL) || (alen < sizeof(struct sockaddr_in6))) {
     850                                return -EINVAL;
     851                        }
     852                        struct sockaddr_in6 *raddr = &socket->raddr6;
     853                        memcpy(raddr, addr, sizeof(struct sockaddr_in6));
     854                        T_IPV6EP rep;
     855                        addrcpy(&rep.ipaddr, &raddr->sin6_addr, 16);
     856                        rep.portno = ntohs(raddr->sin6_port);
     857                        ret = udp6_snd_dat(socket->cepid, &rep, (void *)buf, len,
     858                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     859                        if (ret < 0) {
     860                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     861                        }
     862                        break;
     863                }
     864                }
     865                break;
     866        }
     867        default:
     868                return -ENOPROTOOPT;
     869        }
     870
     871        if (fp->writeevt_w != fp->writeevt_r) fp->writeevt_r++;
    432872
    433873        return ret;
    434874}
    435875
    436 ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
     876ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
     877{
     878        no_implement("sendmsg\n");
     879        return -ENOSYS;
     880}
     881
     882ssize_t shell_recvfrom(int fd, void *restrict buf, size_t len, int flags, struct sockaddr *restrict addr, socklen_t *restrict alen)
    437883{
    438884        SOCKET *fp = fd_to_fp(fd);
    … …  
    442888
    443889        int ret = 0;
    444         switch (fp->socket.family) {
     890        socket_t *socket = (socket_t *)fp->exinf;
     891        switch (socket->family) {
    445892        case AF_INET: {
    446                 switch (fp->socket.type) {
     893                switch (socket->type) {
    447894                case SOCK_STREAM: {
    448                         if ((addr != NULL) && (alen != 0)) {
    449                                 return -EINVAL;
    450                         }
    451 
    452895                        if (flags & MSG_OOB) {
    453                                 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
     896                                ret = tcp_rcv_oob(socket->cepid, buf, len);
    454897                                if (ret < 0) {
     898                                        syslog(LOG_ERROR, "tcp_rcv_oob => %d", ret);
    455899                                        return -ECOMM;
    456900                                }
    457901                        }
    458902                        else {
    459                                 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
     903                                int rsz, tmp;
     904                                if (socket->input == NULL) {
     905                                        ret = wai_sem(SEM_FILEDESC);
     906                                        if (ret < 0) {
     907                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     908                                        }
     909                                        socket->len = 0;
     910                                        ret = sig_sem(SEM_FILEDESC);
     911                                        if (ret < 0) {
     912                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     913                                        }
     914                                        ret = tcp_rcv_buf(socket->cepid, &socket->input,
     915                                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     916                                        if (ret < 0) {
     917                                                if ((socket->flags & O_NONBLOCK) == 0)
     918                                                        syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     919                                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     920                                        }
     921                                        rsz = ret;
     922                                }
     923                                else
     924                                        rsz = socket->len;
     925                                tmp = rsz;
     926                                if (rsz > len)
     927                                        rsz = len;
     928                                if (rsz > 0) {
     929                                        memcpy(buf, socket->input, rsz);
     930                                        ret = wai_sem(SEM_FILEDESC);
     931                                        if (ret < 0) {
     932                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     933                                        }
     934                                        socket->len = tmp - rsz;
     935                                        ret = sig_sem(SEM_FILEDESC);
     936                                        if (ret < 0) {
     937                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     938                                        }
     939                                        if (tmp - rsz == 0) {
     940                                                socket->input = NULL;
     941                                        }
     942                                        else
     943                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     944                                        ret = tcp_rel_buf(socket->cepid, rsz);
     945                                        if ((ret != E_OBJ) && (ret < 0)) {
     946                                                syslog(LOG_ERROR, "tcp_rel_buf => %d", ret);
     947                                                //return -ECOMM;
     948                                        }
     949                                }
     950                                else {
     951                                        syslog(LOG_ERROR, "shell_recvfrom => %d", rsz);
     952                                }
     953                                ret = rsz;
     954                        }
     955                        break;
     956                }
     957                case SOCK_DGRAM: {
     958                        struct sockaddr_in *raddr = &socket->raddr4;
     959                        int rsz;
     960                        ret = wai_sem(SEM_FILEDESC);
     961                        if (ret < 0) {
     962                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     963                        }
     964                        T_NET_BUF *input = socket->input;
     965                        if (input == NULL) {
     966                                ret = sig_sem(SEM_FILEDESC);
    460967                                if (ret < 0) {
     968                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     969                                }
     970
     971                                T_IPV4EP rep = { 0, 0 };
     972                                ret = udp_rcv_dat(socket->cepid, &rep, buf, len,
     973                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     974                                if (ret < 0) {
     975                                        if ((socket->flags & O_NONBLOCK) == 0)
     976                                                syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
     977                                        return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     978                                }
     979                                rsz = ret;
     980                                if ((addr != NULL) && (alen != NULL)) {
     981                                        ret = wai_sem(SEM_FILEDESC);
     982                                        if (ret < 0) {
     983                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     984                                        }
     985                                        int sz = *alen;
     986                                        memset(raddr, 0, sizeof(struct sockaddr_in));
     987                                        raddr->sin_family = AF_INET;
     988                                        raddr->sin_port = htons(rep.portno);
     989                                        raddr->sin_addr.s_addr = htonl(rep.ipaddr);
     990                                        if (sz > sizeof(struct sockaddr_in))
     991                                                sz = sizeof(struct sockaddr_in);
     992                                        memcpy(addr, raddr, sz);
     993                                        *alen = sz;
     994                                        ret = sig_sem(SEM_FILEDESC);
     995                                        if (ret < 0) {
     996                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     997                                        }
     998                                }
     999                        }
     1000                        else {
     1001                                rsz = socket->len;
     1002                                void *pbuf = socket->buf;
     1003                                socket->input = NULL;
     1004                                socket->len = 0;
     1005                                socket->buf = NULL;
     1006                                if ((addr != NULL) && (alen != NULL)) {
     1007                                        int sz = *alen;
     1008                                        if (sz > sizeof(struct sockaddr_in))
     1009                                                sz = sizeof(struct sockaddr_in);
     1010                                        memcpy(addr, raddr, sz);
     1011                                        *alen = sz;
     1012                                }
     1013                                ret = sig_sem(SEM_FILEDESC);
     1014                                if (ret < 0) {
     1015                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1016                                }
     1017                                if (rsz > len)
     1018                                        rsz = len;
     1019                                memcpy(buf, pbuf, rsz);
     1020                                ret = rel_net_buf(input);
     1021                                if (ret < 0) {
     1022                                        syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1023                                        //return -ECOMM;
     1024                                }
     1025                        }
     1026                        ret = rsz;
     1027                }
     1028                }
     1029                break;
     1030        }
     1031        case AF_INET6: {
     1032                switch (socket->type) {
     1033                case SOCK_STREAM: {
     1034                        if (flags & MSG_OOB) {
     1035                                ret = tcp6_rcv_oob(socket->cepid, buf, len);
     1036                                if (ret < 0) {
     1037                                        syslog(LOG_ERROR, "tcp6_rcv_oob => %d", ret);
    4611038                                        return -ECOMM;
    4621039                                }
    4631040                        }
     1041                        else {
     1042                                int rsz, tmp;
     1043                                if (socket->input == NULL) {
     1044                                        ret = wai_sem(SEM_FILEDESC);
     1045                                        if (ret < 0) {
     1046                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1047                                        }
     1048                                        socket->len = 0;
     1049                                        ret = sig_sem(SEM_FILEDESC);
     1050                                        if (ret < 0) {
     1051                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     1052                                        }
     1053                                        ret = tcp6_rcv_buf(socket->cepid, &socket->input,
     1054                                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     1055                                        if (ret < 0) {
     1056                                                if ((socket->flags & O_NONBLOCK) == 0)
     1057                                                        syslog(LOG_ERROR, "tcp6_rcv_buf => %d", ret);
     1058                                                return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     1059                                        }
     1060                                        rsz = ret;
     1061                                }
     1062                                else
     1063                                        rsz = socket->len;
     1064                                tmp = rsz;
     1065                                if (rsz > len)
     1066                                        rsz = len;
     1067                                if (rsz >= 0) {
     1068                                        memcpy(buf, socket->input, rsz);
     1069                                        ret = wai_sem(SEM_FILEDESC);
     1070                                        if (ret < 0) {
     1071                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1072                                        }
     1073                                        socket->len = tmp - rsz;
     1074                                        ret = sig_sem(SEM_FILEDESC);
     1075                                        if (ret < 0) {
     1076                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     1077                                        }
     1078                                        if (tmp - rsz == 0) {
     1079                                                socket->input = NULL;
     1080                                        }
     1081                                        else
     1082                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     1083                                        ret = tcp6_rel_buf(socket->cepid, rsz);
     1084                                        if ((ret != E_OBJ) && (ret < 0)) {
     1085                                                syslog(LOG_ERROR, "tcp6_rel_buf => %d", ret);
     1086                                                //return -ECOMM;
     1087                                        }
     1088                                }
     1089                                ret = rsz;
     1090                        }
    4641091                        break;
    4651092                }
    4661093                case SOCK_DGRAM: {
    467                         int sz = alen;
    468                         if (sz < 8) {
    469                                 return -EINVAL;
    470                         }
    471                         struct sockaddr_in *raddr = &fp->socket.raddr4;
    472                         memset(raddr, 0, sizeof(*raddr));
    473                         memcpy(raddr, addr, sz);
    474                         T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    475                         ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len,
    476                                 (fp->socket.flags & O_NONBLOCK) ? 0 : SOCKET_TIMEOUT);
     1094                        struct sockaddr_in6 *raddr = &socket->raddr6;
     1095                        int rsz;
     1096                        ret = wai_sem(SEM_FILEDESC);
    4771097                        if (ret < 0) {
    478                                 return -ECOMM;
    479                         }
    480                         break;
    481                 }
    482                 }
    483                 break;
    484         }
    485         case AF_INET6: {
    486                 return -EAFNOSUPPORT;
    487         }
    488         }
     1098                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1099                        }
     1100                        T_NET_BUF *input = socket->input;
     1101                        if (input == NULL) {
     1102                                ret = sig_sem(SEM_FILEDESC);
     1103                                if (ret < 0) {
     1104                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1105                                }
     1106
     1107                                T_IPV6EP rep = { { 0 }, 0 };
     1108                                ret = udp6_rcv_dat(socket->cepid, &rep, buf, len,
     1109                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     1110                                if (ret < 0) {
     1111                                        if ((socket->flags & O_NONBLOCK) == 0)
     1112                                                syslog(LOG_ERROR, "udp6_rcv_buf => %d", ret);
     1113                                        return (ret == E_TMOUT) ? -EAGAIN : -ECOMM;
     1114                                }
     1115                                rsz = ret;
     1116                                if ((addr != NULL) && (alen != NULL)) {
     1117                                        ret = wai_sem(SEM_FILEDESC);
     1118                                        if (ret < 0) {
     1119                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1120                                        }
     1121                                        int sz = *alen;
     1122                                        memset(raddr, 0, sizeof(struct sockaddr_in6));
     1123                                        raddr->sin6_family = AF_INET;
     1124                                        raddr->sin6_port = htons(rep.portno);
     1125                                        addrcpy(&raddr->sin6_addr, &rep.ipaddr, 16);
     1126                                        if (sz > sizeof(struct sockaddr_in6))
     1127                                                sz = sizeof(struct sockaddr_in6);
     1128                                        memcpy(addr, raddr, sz);
     1129                                        *alen = sz;
     1130                                        ret = sig_sem(SEM_FILEDESC);
     1131                                        if (ret < 0) {
     1132                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     1133                                        }
     1134                                }
     1135                        }
     1136                        else {
     1137                                rsz = socket->len;
     1138                                void *pbuf = socket->buf;
     1139                                socket->input = NULL;
     1140                                socket->len = 0;
     1141                                socket->buf = NULL;
     1142                                if ((addr != NULL) && (alen != NULL)) {
     1143                                        int sz = *alen;
     1144                                        if (sz > sizeof(struct sockaddr_in6))
     1145                                                sz = sizeof(struct sockaddr_in6);
     1146                                        memcpy(addr, raddr, sz);
     1147                                        *alen = sz;
     1148                                }
     1149                                ret = sig_sem(SEM_FILEDESC);
     1150                                if (ret < 0) {
     1151                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1152                                }
     1153                                if (rsz > len)
     1154                                        rsz = len;
     1155                                memcpy(buf, pbuf, rsz);
     1156                                ret = rel_net_buf(input);
     1157                                if (ret < 0) {
     1158                                        syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1159                                        //return -ECOMM;
     1160                                }
     1161                        }
     1162                        ret = rsz;
     1163                }
     1164                }
     1165                break;
     1166        }
     1167        default:
     1168                return -ENOPROTOOPT;
     1169        }
     1170
     1171        if (fp->readevt_w != fp->readevt_r) fp->readevt_r++;
    4891172
    4901173        return ret;
    4911174}
    4921175
    493 ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
    494 {
    495         no_implement("sendmsg\n");
     1176ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
     1177{
     1178        no_implement("recvmsg\n");
    4961179        return -ENOSYS;
    4971180}
    4981181
    499 ssize_t shell_recv(int fd, void *buf, size_t len, int flags)
     1182int shell_shutdown(int fd, int how)
    5001183{
    5011184        SOCKET *fp = fd_to_fp(fd);
    … …  
    5041187        }
    5051188
    506         int ret = 0;
    507         switch (fp->socket.family) {
     1189        ER ret;
     1190        socket_t *socket = (socket_t *)fp->exinf;
     1191        switch (socket->family) {
    5081192        case AF_INET: {
    509                 switch (fp->socket.type) {
     1193                switch (socket->type) {
    5101194                case SOCK_STREAM: {
    511                         if (flags & MSG_OOB) {
    512                                 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
    513                                 if (ret < 0) {
    514                                         return -ECOMM;
    515                                 }
    516                         }
    517                         else {
    518                                 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
    519                                 if (ret < 0) {
    520                                         return -ECOMM;
    521                                 }
    522                         }
    523                         break;
    524                 }
    525                 case SOCK_DGRAM: {
    526                         T_IPV4EP rep = { 0, 0 };
    527                         ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, (fp->socket.flags & O_NONBLOCK) ? 0 : TMO_FEVR);
     1195                        ret = tcp_sht_cep(socket->cepid);
    5281196                        if (ret < 0) {
    5291197                                return -ECOMM;
    5301198                        }
     1199                        break;
    5311200                }
    5321201                }
    … …  
    5341203        }
    5351204        case AF_INET6: {
    536                 return -EAFNOSUPPORT;
    537         }
    538         }
    539 
    540         return ret;
    541 }
    542 
    543 ssize_t shell_recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
     1205                switch (socket->type) {
     1206                case SOCK_STREAM: {
     1207                        ret = tcp6_sht_cep(socket->cepid);
     1208                        if (ret < 0) {
     1209                                return -ECOMM;
     1210                        }
     1211                        break;
     1212                }
     1213                }
     1214                break;
     1215        }
     1216        default:
     1217                return -ENOPROTOOPT;
     1218        }
     1219
     1220        return 0;
     1221}
     1222
     1223int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *restrict optlen)
    5441224{
    5451225        SOCKET *fp = fd_to_fp(fd);
    … …  
    5481228        }
    5491229
    550         int ret = 0;
    551         switch (fp->socket.family) {
     1230        ER ret;
     1231        socket_t *socket = (socket_t *)fp->exinf;
     1232        switch (socket->family) {
    5521233        case AF_INET: {
    553                 switch (fp->socket.type) {
     1234                switch (socket->type) {
    5541235                case SOCK_STREAM: {
    555                         if (flags & MSG_OOB) {
    556                                 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
     1236                        switch (level) {
     1237                        case SOL_SOCKET:
     1238                                switch (optname) {
     1239                                case SO_REUSEADDR:
     1240                                        if (socket->flags & SO_REUSEADDR) {
     1241                                                *(bool *)optval = true;
     1242                                        }
     1243                                        else {
     1244                                                *(bool *)optval = false;
     1245                                        }
     1246                                        break;
     1247                                case SO_KEEPALIVE:
     1248                                        if (socket->flags & SO_KEEPALIVE) {
     1249                                                *(bool *)optval = true;
     1250                                        }
     1251                                        else {
     1252                                                *(bool *)optval = false;
     1253                                        }
     1254                                        break;
     1255                                case SO_ERROR:
     1256                                        *(int *)optval = 0;
     1257                                        break;
     1258                                default:
     1259                                        return -EINVAL;
     1260                                }
     1261                                break;
     1262                        case IPPROTO_TCP:
     1263                                ret = tcp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    5571264                                if (ret < 0) {
    558                                         return -ECOMM;
    559                                 }
    560                         }
    561                         else {
    562                                 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
     1265                                        return -EINVAL;
     1266                                }
     1267                                *optlen = ret;
     1268                                break;
     1269                        default:
     1270                                return -EINVAL;
     1271                        }
     1272                        break;
     1273                }
     1274                case SOCK_DGRAM: {
     1275                        switch (level) {
     1276                        case IPPROTO_UDP:
     1277                                ret = udp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    5631278                                if (ret < 0) {
    564                                         return -ECOMM;
    565                                 }
     1279                                        return -EINVAL;
     1280                                }
     1281                                *optlen = ret;
     1282                                break;
     1283                        default:
     1284                                return -EINVAL;
    5661285                        }
    5671286                        break;
    5681287                }
     1288                }
     1289                break;
     1290        }
     1291        case AF_INET6: {
     1292                switch (socket->type) {
     1293                case SOCK_STREAM: {
     1294                        switch (level) {
     1295                        case SOL_SOCKET:
     1296                                switch (optname) {
     1297                                case SO_REUSEADDR:
     1298                                        if (socket->flags & SO_REUSEADDR) {
     1299                                                *(bool *)optval = true;
     1300                                        }
     1301                                        else {
     1302                                                *(bool *)optval = false;
     1303                                        }
     1304                                        break;
     1305                                case SO_KEEPALIVE:
     1306                                        if (socket->flags & SO_KEEPALIVE) {
     1307                                                *(bool *)optval = true;
     1308                                        }
     1309                                        else {
     1310                                                *(bool *)optval = false;
     1311                                        }
     1312                                        break;
     1313                                case SO_ERROR:
     1314                                        *(int *)optval = 0;
     1315                                        break;
     1316                                default:
     1317                                        return -EINVAL;
     1318                                }
     1319                                break;
     1320                        case IPPROTO_TCP:
     1321                                ret = tcp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1322                                if (ret < 0) {
     1323                                        return -EINVAL;
     1324                                }
     1325                                *optlen = ret;
     1326                                break;
     1327                        default:
     1328                                return -EINVAL;
     1329                        }
     1330                        break;
     1331                }
    5691332                case SOCK_DGRAM: {
    570                         T_IPV4EP rep = { 0, 0 };
    571                         ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
    572                         if (ret < 0) {
    573                                 return -ECOMM;
    574                         }
    575                         int sz = *alen;
    576                         struct sockaddr_in raddr;
    577                         memset(&raddr, 0, sizeof(raddr));
    578                         raddr.sin_family = AF_INET;
    579                         raddr.sin_port = htons(rep.portno);
    580                         raddr.sin_addr.s_addr = htonl(rep.ipaddr);
    581                         if (sz > sizeof(raddr))
    582                                 sz = sizeof(raddr);
    583                         memcpy(addr, &raddr, sz);
    584                 }
    585                 }
    586                 break;
    587         }
    588         case AF_INET6: {
    589                 return -EAFNOSUPPORT;
    590         }
    591         }
    592 
    593         return ret;
    594 }
    595 
    596 ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
    597 {
    598         no_implement("recvmsg\n");
    599         return -ENOSYS;
    600 }
    601 
    602 int shell_shutdown(int fd, int how)
     1333                        switch (level) {
     1334                        case IPPROTO_UDP:
     1335                                ret = udp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1336                                if (ret < 0) {
     1337                                        return -EINVAL;
     1338                                }
     1339                                *optlen = ret;
     1340                                break;
     1341                        default:
     1342                                return -EINVAL;
     1343                        }
     1344                        break;
     1345                }
     1346                }
     1347                break;
     1348        }
     1349        default:
     1350                return -ENOPROTOOPT;
     1351        }
     1352
     1353        return 0;
     1354}
     1355
     1356int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
    6031357{
    6041358        SOCKET *fp = fd_to_fp(fd);
    … …  
    6081362
    6091363        ER ret;
    610         switch (fp->socket.family) {
     1364        socket_t *socket = (socket_t *)fp->exinf;
     1365        switch (socket->family) {
    6111366        case AF_INET: {
    612                 switch (fp->socket.type) {
     1367                switch (socket->type) {
    6131368                case SOCK_STREAM: {
    614                         ret = tcp_sht_cep(fp->socket.cepid);
    615                         if (ret < 0) {
    616                                 return -ECOMM;
     1369                        switch (level){
     1370                        case SOL_SOCKET:
     1371                                switch (optname) {
     1372                                case SO_REUSEADDR:
     1373                                        if (*(bool *)optval) {
     1374                                                socket->flags |= SO_REUSEADDR;
     1375                                        }
     1376                                        else {
     1377                                                socket->flags &= ~SO_REUSEADDR;
     1378                                        }
     1379                                        break;
     1380                                case SO_KEEPALIVE:
     1381                                        if (*(bool *)optval) {
     1382                                                socket->flags |= SO_KEEPALIVE;
     1383                                        }
     1384                                        else {
     1385                                                socket->flags &= ~SO_KEEPALIVE;
     1386                                        }
     1387                                        break;
     1388                                default:
     1389                                        return -EINVAL;
     1390                                }
     1391                                break;
     1392                        case IPPROTO_TCP:
     1393                                ret = tcp_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1394                                if (ret < 0) {
     1395                                        return -EINVAL;
     1396                                }
     1397                                break;
     1398                        default:
     1399                                return -EINVAL;
    6171400                        }
    6181401                        break;
    6191402                }
     1403                case SOCK_DGRAM: {
     1404                        switch (level){
     1405                        case IPPROTO_UDP:
     1406                                ret = udp_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1407                                if (ret < 0) {
     1408                                        return -EINVAL;
     1409                                }
     1410                                break;
     1411                        default:
     1412                                return -EINVAL;
     1413                        }
     1414                        break;
     1415                }
    6201416                }
    6211417                break;
    6221418        }
    6231419        case AF_INET6: {
    624                 return -EAFNOSUPPORT;
    625         }
     1420                switch (socket->type) {
     1421                case SOCK_STREAM: {
     1422                        switch (level){
     1423                        case SOL_SOCKET:
     1424                                switch (optname) {
     1425                                case SO_REUSEADDR:
     1426                                        if (*(bool *)optval) {
     1427                                                socket->flags |= SO_REUSEADDR;
     1428                                        }
     1429                                        else {
     1430                                                socket->flags &= ~SO_REUSEADDR;
     1431                                        }
     1432                                        break;
     1433                                case SO_KEEPALIVE:
     1434                                        if (*(bool *)optval) {
     1435                                                socket->flags |= SO_KEEPALIVE;
     1436                                        }
     1437                                        else {
     1438                                                socket->flags &= ~SO_KEEPALIVE;
     1439                                        }
     1440                                        break;
     1441                                default:
     1442                                        return -EINVAL;
     1443                                }
     1444                                break;
     1445                        case IPPROTO_TCP:
     1446                                ret = tcp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1447                                if (ret < 0) {
     1448                                        return -EINVAL;
     1449                                }
     1450                                break;
     1451                        default:
     1452                                return -EINVAL;
     1453                        }
     1454                        break;
     1455                }
     1456                case SOCK_DGRAM: {
     1457                        switch (level){
     1458                        case IPPROTO_UDP:
     1459                                ret = udp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1460                                if (ret < 0) {
     1461                                        return -EINVAL;
     1462                                }
     1463                                break;
     1464                        default:
     1465                                return -EINVAL;
     1466                        }
     1467                        break;
     1468                }
     1469                }
     1470                break;
     1471        }
     1472        default:
     1473                return -ENOPROTOOPT;
    6261474        }
    6271475
    … …  
    6291477}
    6301478
    631 int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *__restrict optlen)
     1479int shell_getpeername(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
    6321480{
    6331481        SOCKET *fp = fd_to_fp(fd);
    … …  
    6351483                return -EBADF;
    6361484        }
    637 
    638         ER ret;
    639         switch (fp->socket.family) {
     1485        if (len == NULL) {
     1486                return -EINVAL;
     1487        }
     1488
     1489        socklen_t size = *len;
     1490        socket_t *socket = (socket_t *)fp->exinf;
     1491        switch (socket->family) {
    6401492        case AF_INET: {
    641                 switch (fp->socket.type) {
    642                 case SOCK_STREAM: {
    643                         switch (optname) {
    644                         case SO_REUSEADDR:
    645                                 if (fp->socket.flags & SO_REUSEADDR) {
    646                                         *(bool *)optval = true;
    647                                 }
    648                                 else {
    649                                         *(bool *)optval = false;
    650                                 }
    651                                 break;
    652                         default:
    653                                 ret = tcp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
    654                                 if (ret < 0) {
    655                                         return -EINVAL;
    656                                 }
    657                                 *optlen = ret;
    658                                 break;
    659                         }
    660                         break;
    661                 }
    662                 case SOCK_DGRAM: {
    663                         ret = udp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
    664                         if (ret < 0) {
    665                                 return -EINVAL;
    666                         }
    667                         *optlen = ret;
    668                         break;
    669                 }
    670                 }
     1493                struct sockaddr_in *raddr = &socket->raddr4;
     1494                *len = sizeof(struct sockaddr_in);
     1495                if (size > sizeof(struct sockaddr_in))
     1496                        size = sizeof(struct sockaddr_in);
     1497                memcpy(addr, raddr, size);
    6711498                break;
    6721499        }
    6731500        case AF_INET6: {
    674                 return -EAFNOSUPPORT;
    675         }
     1501                struct sockaddr_in6 *raddr = &socket->raddr6;
     1502                *len = sizeof(struct sockaddr_in6);
     1503                if (size > sizeof(struct sockaddr_in6))
     1504                        size = sizeof(struct sockaddr_in6);
     1505                memcpy(addr, raddr, size);
     1506                break;
     1507        }
     1508        default:
     1509                return -ENOPROTOOPT;
    6761510        }
    6771511
    … …  
    6791513}
    6801514
    681 int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
     1515int shell_getsockname(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
    6821516{
    6831517        SOCKET *fp = fd_to_fp(fd);
    … …  
    6851519                return -EBADF;
    6861520        }
    687 
    688         ER ret;
    689         switch (fp->socket.family) {
     1521        if (len == NULL) {
     1522                return -EINVAL;
     1523        }
     1524
     1525        socklen_t size = *len;
     1526        socket_t *socket = (socket_t *)fp->exinf;
     1527        switch (socket->family) {
    6901528        case AF_INET: {
    691                 switch (fp->socket.type) {
    692                 case SOCK_STREAM: {
    693                         switch (optname) {
    694                         case SO_REUSEADDR:
    695                                 if (*(bool *)optval) {
    696                                         fp->socket.flags |= SO_REUSEADDR;
    697                                 }
    698                                 else {
    699                                         fp->socket.flags &= ~SO_REUSEADDR;
    700                                 }
    701                                 break;
    702                         default:
    703                                 ret = tcp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
    704                                 if (ret < 0) {
    705                                         return -EINVAL;
    706                                 }
    707                                 break;
    708                         }
    709                         break;
    710                 }
    711                 case SOCK_DGRAM: {
    712                         ret = udp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
    713                         if (ret < 0) {
    714                                 return -EINVAL;
    715                         }
    716                         break;
    717                 }
    718                 }
     1529                const T_IN4_ADDR *laddr4 = in4_get_ifaddr(0);
     1530                struct sockaddr_in laddr;
     1531                laddr.sin_family = AF_INET;
     1532                laddr.sin_addr.s_addr = htonl(*laddr4);
     1533                laddr.sin_port = socket->laddr4.sin_port;
     1534                memset(&laddr.sin_zero, 0, sizeof(laddr.sin_zero));
     1535                *len = sizeof(struct sockaddr_in);
     1536                if (size > sizeof(struct sockaddr_in))
     1537                        size = sizeof(struct sockaddr_in);
     1538                memcpy(addr, &laddr, size);
    7191539                break;
    7201540        }
    7211541        case AF_INET6: {
    722                 return -EAFNOSUPPORT;
    723         }
     1542                const T_IN6_ADDR *laddr6 = in6_get_ifaddr(0);
     1543                struct sockaddr_in6 laddr;
     1544                laddr.sin6_family = AF_INET;
     1545                addrcpy(&laddr.sin6_addr, laddr6, 16);
     1546                laddr.sin6_port = socket->laddr6.sin6_port;
     1547                *len = sizeof(struct sockaddr_in6);
     1548                if (size > sizeof(struct sockaddr_in6))
     1549                        size = sizeof(struct sockaddr_in6);
     1550                memcpy(addr, &laddr, size);
     1551                break;
     1552        }
     1553        default:
     1554                return -ENOPROTOOPT;
    7241555        }
    7251556
    … …  
    7271558}
    7281559
    729 int tcp_fd_close(struct _IO_FILE *fp)
    730 {
    731         ER ret;
    732         switch (fp->socket.family) {
     1560int tcp_fd_close(struct SHELL_FILE *fp)
     1561{
     1562        ER ret, ret2;
     1563
     1564        socket_t *socket = (socket_t *)fp->exinf;
     1565        switch (socket->family) {
    7331566        case AF_INET: {
    734                 if (fp->socket.cepid != 0) {
    735                         ID cepid = fp->socket.cepid;
     1567                if (socket->cepid != 0) {
     1568                        ID cepid = socket->cepid;
     1569                        ret = tcp_can_cep(cepid, TFN_TCP_ALL);
     1570                        if ((ret < 0) && (ret != E_OBJ)) {
     1571                                syslog(LOG_ERROR, "tcp_can_cep => %d", ret);
     1572                        }
    7361573                        ret = tcp_sht_cep(cepid);
    737                         if (ret < 0) {
    738                                 //return -1;
    739                         }
    740                         ret = tcp_cls_cep(cepid, (fp->socket.repid != 0) ? 0 : SOCKET_TIMEOUT);
    741                         if (ret < 0) {
    742                                 //return -1;
    743                         }
    744                         ret = tcp_del_cep(cepid);
    745                         delete_tcp_fd(cepid);
     1574                        if ((ret < 0) && (ret != E_OBJ)) {
     1575                                syslog(LOG_ERROR, "tcp_sht_cep => %d", ret);
     1576                        }
     1577                        ret = tcp_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
     1578                        ret2 = tcp_del_cep(cepid);
     1579                        if (ret2 < 0) {
     1580                                syslog(LOG_ERROR, "tcp_del_cep => %d", ret2);
     1581                        }
     1582                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
    7461583                        delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    747                         if (ret < 0) {
    748                                 return -EINVAL;
    749                         }
    750                 }
    751                 else if (fp->socket.repid != 0) {
    752                         ID repid = fp->socket.repid;
     1584                        if ((ret < 0) || (ret2 < 0)) {
     1585                                return (ret == E_TMOUT) ? -ETIMEDOUT : -EIO;
     1586                        }
     1587                }
     1588                else if (socket->repid != 0) {
     1589                        ID repid = socket->repid;
    7531590                        ret = tcp_del_rep(repid);
    754                         delete_tcp_fd(tmax_tcp_cepid + repid);
     1591                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + repid);
    7551592                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    7561593                        if (ret < 0) {
    … …  
    7641601        }
    7651602        case AF_INET6: {
    766                 return -EAFNOSUPPORT;
    767         }
     1603                if (socket->cepid != 0) {
     1604                        ID cepid = socket->cepid;
     1605                        ret = tcp6_can_cep(cepid, TFN_TCP_ALL);
     1606                        if ((ret < 0) && (ret != E_OBJ)) {
     1607                                syslog(LOG_ERROR, "tcp_can_cep => %d", ret);
     1608                        }
     1609                        ret = tcp6_sht_cep(cepid);
     1610                        if ((ret < 0) && (ret != E_OBJ)) {
     1611                                syslog(LOG_ERROR, "tcp6_sht_cep => %d", ret);
     1612                        }
     1613                        ret = tcp6_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
     1614                        ret2 = tcp6_del_cep(cepid);
     1615                        if (ret2 < 0) {
     1616                                syslog(LOG_ERROR, "tcp6_del_cep => %d", ret2);
     1617                        }
     1618                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1619                        delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     1620                        if ((ret < 0) || (ret2 < 0)) {
     1621                                return (ret == E_TMOUT) ? -ETIMEDOUT : -EIO;
     1622                        }
     1623                }
     1624                else if (socket->repid != 0) {
     1625                        ID repid = socket->repid;
     1626                        ret = tcp6_del_rep(repid);
     1627                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp6_cepid + repid);
     1628                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     1629                        if (ret < 0) {
     1630                                return -EINVAL;
     1631                        }
     1632                }
     1633                else {
     1634                        return -EINVAL;
     1635                }
     1636                break;
     1637        }
     1638        default:
     1639                return -ENOPROTOOPT;
    7681640        }
    7691641
    … …  
    7711643}
    7721644
    773 size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    774 {
    775         return shell_recv(fp->fd, dst, dstsz, 0);
    776 }
    777 
    778 size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    779 {
    780         return shell_send(fp->fd, src, srcsz, 0);
    781 }
    782 
    783 off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     1645size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
     1646{
     1647        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
     1648}
     1649
     1650size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
     1651{
     1652        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
     1653}
     1654
     1655off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    7841656{
    7851657        return -EPERM;
    7861658}
    7871659
    788 int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
    789 {
     1660int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
     1661{
     1662        socket_t *socket = (socket_t *)fp->exinf;
     1663
     1664        switch (req) {
     1665        case F_GETFL:
     1666                return socket->flags;
     1667        case F_SETFL:
     1668                socket->flags = (unsigned int)arg;
     1669                return 0;
     1670        }
     1671
    7901672        return -EINVAL;
    7911673}
    7921674
    793 int udp_fd_close(struct _IO_FILE *fp)
     1675bool_t tcp_fd_readable(struct SHELL_FILE *fp)
     1676{
     1677        ER ret;
     1678
     1679        socket_t *socket = (socket_t *)fp->exinf;
     1680        if (socket->cepid != 0) {
     1681                if (socket->len == 0) {
     1682                        ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_NBLK);
     1683                        if ((ret != E_WBLK) && (ret != E_OBJ) && (ret < 0)) {
     1684                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     1685                                //return ret;
     1686                        }
     1687                        if (ret > 0) {
     1688                                ret = wai_sem(SEM_FILEDESC);
     1689                                if (ret < 0) {
     1690                                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1691                                }
     1692                                socket->len += ret;
     1693                                ret = sig_sem(SEM_FILEDESC);
     1694                                if (ret < 0) {
     1695                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1696                                }
     1697                        }
     1698                }
     1699                else ret = 1;
     1700                if (ret > 0) {
     1701                        return true;
     1702                }
     1703        }
     1704
     1705        return false;
     1706}
     1707
     1708bool_t tcp_fd_writable(struct SHELL_FILE *fp)
     1709{
     1710        //socket_t *socket = (socket_t *)fp->exinf;
     1711
     1712        return /*fp->writable &&*/ (fp->writeevt_w == fp->writeevt_r);
     1713}
     1714
     1715void tcp_fd_delete(struct SHELL_FILE *fp)
     1716{
     1717        socket_t *socket = (socket_t *)fp->exinf;
     1718        free(socket->buf);
     1719        socket->buf = NULL;
     1720        free(fp->exinf);
     1721        fp->exinf = NULL;
     1722}
     1723
     1724ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
     1725{
     1726        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1727        FLGPTN flgptn = 0;
     1728        ER ret;
     1729        int len;
     1730
     1731        if (fp == NULL)
     1732                return E_PAR;
     1733
     1734        socket_t *socket = (socket_t *)fp->exinf;
     1735        int fd = fp->fd;
     1736        FD_SET(fd, (fd_set *)&flgptn);
     1737
     1738        switch (fncd) {
     1739        case TFN_TCP_RCV_BUF:
     1740                len = *(int *)p_parblk;
     1741                if ((len <= 0) || (fp->exinf == NULL))
     1742                        return E_OK;
     1743
     1744                ret = wai_sem(SEM_FILEDESC);
     1745                if (ret < 0) {
     1746                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1747                }
     1748                socket->len += len;
     1749                ret = sig_sem(SEM_FILEDESC);
     1750                if (ret < 0) {
     1751                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1752                }
     1753
     1754                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1755
     1756                set_flg(FLG_SELECT_WAIT, flgptn);
     1757                return E_OK;
     1758
     1759        case TFN_TCP_RCV_DAT:
     1760                len = *(int *)p_parblk;
     1761                if ((len <= 0) || (fp->exinf == NULL))
     1762                        return E_OK;
     1763
     1764                ret = wai_sem(SEM_FILEDESC);
     1765                if (ret < 0) {
     1766                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1767                }
     1768                socket->len += len;
     1769                ret = sig_sem(SEM_FILEDESC);
     1770                if (ret < 0) {
     1771                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1772                }
     1773
     1774                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1775
     1776                set_flg(FLG_SELECT_WAIT, flgptn);
     1777                return E_OK;
     1778
     1779        case TFN_TCP_SND_DAT:
     1780                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1781
     1782                set_flg(FLG_SELECT_WAIT, flgptn);
     1783                return E_OK;
     1784
     1785        case TFN_TCP_CAN_CEP:
     1786                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1787
     1788                set_flg(FLG_SELECT_WAIT, flgptn);
     1789                return E_OK;
     1790
     1791        case TFN_TCP_DEL_REP:
     1792                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1793                return E_OK;
     1794
     1795        case TFN_TCP_DEL_CEP:
     1796                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1797                return E_OK;
     1798
     1799        default:
     1800                return E_OK;
     1801        }
     1802}
     1803
     1804ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk)
     1805{
     1806        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1807        FLGPTN flgptn = 0;
     1808        ER ret;
     1809        int len;
     1810
     1811        if (fp == NULL)
     1812                return E_PAR;
     1813
     1814        socket_t *socket = (socket_t *)fp->exinf;
     1815        int fd = fp->fd;
     1816        FD_SET(fd, (fd_set *)&flgptn);
     1817
     1818        switch (fncd) {
     1819        case TFN_TCP_RCV_BUF:
     1820                len = *(int *)p_parblk;
     1821                if ((len <= 0) || (fp->exinf == NULL))
     1822                        return E_OK;
     1823
     1824                ret = wai_sem(SEM_FILEDESC);
     1825                if (ret < 0) {
     1826                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1827                }
     1828                socket->len += len;
     1829                ret = sig_sem(SEM_FILEDESC);
     1830                if (ret < 0) {
     1831                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1832                }
     1833
     1834                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1835
     1836                set_flg(FLG_SELECT_WAIT, flgptn);
     1837                return E_OK;
     1838
     1839        case TFN_TCP_RCV_DAT:
     1840                len = *(int *)p_parblk;
     1841                if ((len <= 0) || (fp->exinf == NULL))
     1842                        return E_OK;
     1843
     1844                ret = wai_sem(SEM_FILEDESC);
     1845                if (ret < 0) {
     1846                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1847                }
     1848                socket->len += len;
     1849                ret = sig_sem(SEM_FILEDESC);
     1850                if (ret < 0) {
     1851                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1852                }
     1853
     1854                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1855
     1856                set_flg(FLG_SELECT_WAIT, flgptn);
     1857                return E_OK;
     1858
     1859        case TFN_TCP_SND_DAT:
     1860                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1861
     1862                set_flg(FLG_SELECT_WAIT, flgptn);
     1863                return E_OK;
     1864
     1865        case TFN_TCP_CAN_CEP:
     1866                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1867
     1868                set_flg(FLG_SELECT_WAIT, flgptn);
     1869                return E_OK;
     1870
     1871        case TFN_TCP_DEL_REP:
     1872                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1873                return E_OK;
     1874
     1875        case TFN_TCP_DEL_CEP:
     1876                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1877                return E_OK;
     1878
     1879        default:
     1880                return E_OK;
     1881        }
     1882}
     1883
     1884int udp_fd_close(struct SHELL_FILE *fp)
    7941885{
    7951886        ER ret;
    7961887        ID cepid;
    797         switch (fp->socket.family) {
     1888
     1889        socket_t *socket = (socket_t *)fp->exinf;
     1890        switch (socket->family) {
    7981891        case AF_INET: {
    799                 cepid = fp->socket.cepid;
     1892                cepid = socket->cepid;
     1893                ret = udp_can_cep(cepid, TFN_UDP_ALL);
     1894                if ((ret < 0) && (ret != E_OBJ)) {
     1895                        syslog(LOG_ERROR, "udp_can_cep => %d", ret);
     1896                }
    8001897                ret = udp_del_cep(cepid);
    801                 delete_udp_fd(cepid);
     1898                if (ret < 0) {
     1899                        syslog(LOG_ERROR, "udp_del_cep => %d", ret);
     1900                }
     1901                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
    8021902                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    8031903                if (ret < 0) {
    … …  
    8071907        }
    8081908        case AF_INET6: {
    809                 return -EAFNOSUPPORT;
    810         }
     1909                cepid = socket->cepid;
     1910                ret = udp6_can_cep(cepid, TFN_UDP_ALL);
     1911                if ((ret < 0) && (ret != E_OBJ)) {
     1912                        syslog(LOG_ERROR, "udp6_can_cep => %d", ret);
     1913                }
     1914                ret = udp6_del_cep(cepid);
     1915                if (ret < 0) {
     1916                        syslog(LOG_ERROR, "udp6_del_cep => %d", ret);
     1917                }
     1918                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1919                delete_id(udp6_cepid_table, udp6_cepid_table_count, cepid);
     1920                if (ret < 0) {
     1921                        return -EINVAL;
     1922                }
     1923                break;
     1924        }
     1925        default:
     1926                return -ENOPROTOOPT;
    8111927        }
    8121928
    … …  
    8141930}
    8151931
    816 size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    817 {
    818         return shell_recv(fp->fd, dst, dstsz, 0);
    819 }
    820 
    821 size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    822 {
    823         return shell_send(fp->fd, src, srcsz, 0);
    824 }
    825 
    826 off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     1932size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
     1933{
     1934        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
     1935}
     1936
     1937size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
     1938{
     1939        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
     1940}
     1941
     1942off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    8271943{
    8281944        return -EPERM;
    8291945}
    8301946
    831 int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     1947int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
    8321948{
    8331949        return -EINVAL;
     1950}
     1951
     1952bool_t udp_fd_readable(struct SHELL_FILE *fp)
     1953{
     1954        socket_t *socket = (socket_t *)fp->exinf;
     1955        if (socket->cepid != 0) {
     1956                if (socket->input != NULL) {
     1957                        return true;
     1958                }
     1959        }
     1960
     1961        return false;
     1962}
     1963
     1964bool_t udp_fd_writable(struct SHELL_FILE *fp)
     1965{
     1966        //socket_t *socket = (socket_t *)fp->exinf;
     1967
     1968        return fp->writable && (fp->writeevt_w == fp->writeevt_r);
     1969}
     1970
     1971void udp_fd_delete(struct SHELL_FILE *fp)
     1972{
     1973        //socket_t *socket = (socket_t *)fp->exinf;
     1974        //free(socket->buf);
     1975        //socket->buf = NULL;
     1976        free(fp->exinf);
     1977        fp->exinf = NULL;
     1978}
     1979
     1980ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk)
     1981{
     1982        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     1983        FLGPTN flgptn = 0;
     1984        int len;
     1985
     1986        if (fp == NULL)
     1987                return E_PAR;
     1988
     1989        int fd = fp->fd;
     1990        FD_SET(fd, (fd_set *)&flgptn);
     1991
     1992        switch (fncd) {
     1993        case TEV_UDP_RCV_DAT:
     1994        {
     1995                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     1996                len = udppara->len;
     1997                if ((len <= 0) || (fp->exinf == NULL))
     1998                        return E_OK;
     1999
     2000                ER ret = wai_sem(SEM_FILEDESC);
     2001                if (ret < 0) {
     2002                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     2003                }
     2004                socket_t *socket = (socket_t *)fp->exinf;
     2005                socket->len = len;
     2006                if (socket->input != NULL) {
     2007                        ret = rel_net_buf(socket->input);
     2008                        if (ret < 0) {
     2009                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     2010                        }
     2011                }
     2012                socket->input = udppara->input;
     2013                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     2014                memset(&socket->raddr4, 0, sizeof(struct sockaddr_in));
     2015                socket->raddr4.sin_family = AF_INET;
     2016                socket->raddr4.sin_port = htons(udppara->rep4.portno);
     2017                socket->raddr4.sin_addr.s_addr = htonl(udppara->rep4.ipaddr);
     2018                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     2019                ret = sig_sem(SEM_FILEDESC);
     2020                if (ret < 0) {
     2021                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     2022                }
     2023
     2024                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     2025
     2026                set_flg(FLG_SELECT_WAIT, flgptn);
     2027                return E_OK;
     2028        }
     2029        case TFN_UDP_CRE_CEP:
     2030                return E_OK;
     2031
     2032        case TFN_UDP_RCV_DAT:
     2033                len = *(int *)p_parblk;
     2034                if ((len <= 0) || (fp->exinf == NULL))
     2035                        return E_OK;
     2036
     2037                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     2038
     2039                set_flg(FLG_SELECT_WAIT, flgptn);
     2040                return E_OK;
     2041
     2042        case TFN_UDP_SND_DAT:
     2043                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     2044
     2045                set_flg(FLG_SELECT_WAIT, flgptn);
     2046                return E_OK;
     2047
     2048        case TFN_UDP_CAN_CEP:
     2049                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     2050
     2051                set_flg(FLG_SELECT_WAIT, flgptn);
     2052                return E_OK;
     2053
     2054        case TFN_UDP_DEL_CEP:
     2055                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     2056                return E_OK;
     2057
     2058        default:
     2059                return E_OK;
     2060        }
     2061}
     2062
     2063ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk)
     2064{
     2065        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     2066        FLGPTN flgptn = 0;
     2067        int len;
     2068
     2069        if (fp == NULL)
     2070                return E_PAR;
     2071
     2072        int fd = fp->fd;
     2073        FD_SET(fd, (fd_set *)&flgptn);
     2074
     2075        switch (fncd) {
     2076        case TEV_UDP_RCV_DAT:
     2077        {
     2078                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     2079                len = udppara->len;
     2080                if ((len <= 0) || (fp->exinf == NULL))
     2081                        return E_OK;
     2082
     2083                ER ret = wai_sem(SEM_FILEDESC);
     2084                if (ret < 0) {
     2085                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     2086                }
     2087                socket_t *socket = (socket_t *)fp->exinf;
     2088                socket->len = len;
     2089                if (socket->input != NULL) {
     2090                        ret = rel_net_buf(socket->input);
     2091                        if (ret < 0) {
     2092                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     2093                        }
     2094                }
     2095                socket->input = udppara->input;
     2096                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     2097                memset(&socket->raddr6, 0, sizeof(struct sockaddr_in6));
     2098                socket->raddr6.sin6_family = AF_INET;
     2099                socket->raddr6.sin6_port = htons(udppara->rep6.portno);
     2100                addrcpy(&socket->raddr6.sin6_addr, &udppara->rep6.ipaddr, 16);
     2101                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     2102                ret = sig_sem(SEM_FILEDESC);
     2103                if (ret < 0) {
     2104                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     2105                }
     2106
     2107                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     2108
     2109                set_flg(FLG_SELECT_WAIT, flgptn);
     2110                return E_OK;
     2111        }
     2112        case TFN_UDP_CRE_CEP:
     2113                return E_OK;
     2114
     2115        case TFN_UDP_RCV_DAT:
     2116                len = *(int *)p_parblk;
     2117                if ((len <= 0) || (fp->exinf == NULL))
     2118                        return E_OK;
     2119
     2120                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     2121
     2122                set_flg(FLG_SELECT_WAIT, flgptn);
     2123                return E_OK;
     2124
     2125        case TFN_UDP_SND_DAT:
     2126                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     2127
     2128                set_flg(FLG_SELECT_WAIT, flgptn);
     2129                return E_OK;
     2130
     2131        case TFN_UDP_CAN_CEP:
     2132                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     2133
     2134                set_flg(FLG_SELECT_WAIT, flgptn);
     2135                return E_OK;
     2136
     2137        case TFN_UDP_DEL_CEP:
     2138                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     2139                return E_OK;
     2140
     2141        default:
     2142                return E_OK;
     2143        }
    8342144}
    8352145
    … …  
    9042214}
    9052215#endif
     2216
     2217// musl-1.1.18/network/lookup.h
     2218struct address {
     2219        int family;
     2220        unsigned scopeid;
     2221        uint8_t addr[16];
     2222        int sortkey;
     2223};
     2224
     2225#define MAXNS 3
     2226
     2227struct resolvconf {
     2228        struct address ns[MAXNS];
     2229        unsigned nns, attempts, ndots;
     2230        unsigned timeout;
     2231};
     2232
     2233// musl-1.1.18/network/resolvconf.c
     2234int __get_resolv_conf(struct resolvconf *conf, char *search, size_t search_sz)
     2235{
     2236        int nns = 0;
     2237
     2238        conf->ndots = 1;
     2239        conf->timeout = 5;
     2240        conf->attempts = 2;
     2241        if (search) *search = 0;
     2242
     2243#if defined(SUPPORT_INET4)
     2244        T_IN4_ADDR      in4_addr;
     2245        conf->ns[nns].family = AF_INET;
     2246        conf->ns[nns].scopeid = 0;
     2247        dns_in4_get_addr(&in4_addr);
     2248        *(uint32_t *)conf->ns[nns].addr = ntohl(in4_addr);
     2249        nns++;
     2250#endif
     2251
     2252#if defined(SUPPORT_INET6)
     2253        conf->ns[nns].family = AF_INET6;
     2254        conf->ns[nns].scopeid = 0;
     2255        dns_in6_get_addr((T_IN6_ADDR *)conf->ns[nns].addr);
     2256        nns++;
     2257#endif
     2258        conf->nns = nns;
     2259
     2260        return 0;
     2261}
Note: See TracChangeset for help on using the changeset viewer.