Ignore:
Timestamp:
Apr 5, 2019, 9:26:53 PM (5 years ago)
Author:
coas-nagasima
Message:

mbed関連を更新
シリアルドライバをmbedのHALを使うよう変更
ファイルディスクリプタの処理を更新

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r364 r374  
    5757#include <netinet/udp_var.h>
    5858#include <net/net_buf.h>
    59 //#include <netinet/tcp_var.h>
     59#include <netinet/udp.h>
     60#include <netinet/udp_var.h>
     61#include <netinet/tcp.h>
     62#include <netinet/tcp_var.h>
    6063#include <netapp/resolver.h>
    6164extern const ID tmax_tcp_cepid;
    … …  
    6568
    6669#define SOCKET_TIMEOUT 2000000
     70
     71#define tcp6_cre_cep tcp_cre_cep
     72#define tcp6_del_cep tcp_del_cep
     73#define tcp6_del_rep tcp_del_rep
     74#define tcp6_sht_cep tcp_sht_cep
     75#define tcp6_cls_cep tcp_cls_cep
     76#define tcp6_snd_oob tcp_snd_oob
     77#define tcp6_snd_dat tcp_snd_dat
     78#define tcp6_rcv_oob tcp_rcv_oob
     79#define tcp6_rcv_buf tcp_rcv_buf
     80#define tcp6_rel_buf tcp_rel_buf
     81#define tcp6_get_opt tcp_get_opt
     82#define tcp6_set_opt tcp_set_opt
     83
     84#define udp6_del_cep udp_del_cep
     85#define udp6_get_opt udp_get_opt
     86#define udp6_set_opt udp_set_opt
     87
     88#ifndef SUPPORT_INET6
     89
     90ER      tcp6_cre_rep (ID repid, T_TCP6_CREP *pk_crep) { return E_SYS; }
     91ER      tcp6_acp_cep (ID cepid, ID repid, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     92ER      tcp6_con_cep (ID cepid, T_IPV6EP *p_myaddr, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     93
     94ER      udp6_cre_cep (ID cepid, T_UDP6_CCEP *pk_ccep) { return E_SYS; }
     95ER_UINT udp6_snd_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     96ER_UINT udp6_rcv_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     97
     98const T_IN6_ADDR *in6_get_ifaddr (int_t index) { return NULL; }
     99
     100#endif
     101
     102ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk);
     103ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk);
     104ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk);
     105ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk);
     106
     107static int tcp_fd_close(struct SHELL_FILE *fp);
     108static size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     109static size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     110static off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     111static int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     112static bool_t tcp_fd_readable(struct SHELL_FILE *fp);
     113static void tcp_fd_delete(struct SHELL_FILE *fp);
     114
     115static int udp_fd_close(struct SHELL_FILE *fp);
     116static size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     117static size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     118static off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     119static int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     120static bool_t udp_fd_readable(struct SHELL_FILE *fp);
     121static void udp_fd_delete(struct SHELL_FILE *fp);
     122
     123IO_TYPE IO_TYPE_TCP = { tcp_fd_close, tcp_fd_read, tcp_fd_write, tcp_fd_seek, tcp_fd_ioctl, tcp_fd_readable, tcp_fd_delete };
     124IO_TYPE IO_TYPE_UDP = { udp_fd_close, udp_fd_read, udp_fd_write, udp_fd_seek, udp_fd_ioctl, udp_fd_readable, udp_fd_delete };
    67125
    68126typedef struct id_table_t {
    … …  
    84142#define tcp_cepid_table_count (sizeof(tcp_cepid_table) / sizeof(tcp_cepid_table[0]))
    85143
     144#ifdef SUPPORT_INET6
     145
     146id_table_t tcp6_repid_table[] = {
     147        {0, USR_TCP6_REP1}, {0, USR_TCP6_REP2}, {0, USR_TCP6_REP3}, {0, USR_TCP6_REP4}
     148};
     149#define tcp6_repid_table_count (sizeof(tcp6_repid_table) / sizeof(tcp6_repid_table[0]))
     150
     151id_table_t tcp6_cepid_table[] = {
     152        {0, USR_TCP6_CEP1}, {0, USR_TCP6_CEP2}, {0, USR_TCP6_CEP3}, {0, USR_TCP6_CEP4},
     153#ifndef TOPPERS_GRSAKURA
     154        {0, USR_TCP6_CEP5}, {0, USR_TCP6_CEP6}, {0, USR_TCP6_CEP7}, {0, USR_TCP6_CEP8}
     155#endif
     156};
     157#define tcp6_cepid_table_count (sizeof(tcp6_cepid_table) / sizeof(tcp6_cepid_table[0]))
     158
     159#else
     160
     161#define tcp6_repid_table NULL
     162#define tcp6_repid_table_count 0
     163
     164#define tcp6_cepid_table NULL
     165#define tcp6_cepid_table_count 0
     166
     167#endif
     168
    86169id_table_t udp_cepid_table[] = {
    87170        {0, USR_UDP_CEP1}, {0, USR_UDP_CEP2}, {0, USR_UDP_CEP3}, {0, USR_UDP_CEP4}
    … …  
    89172#define udp_cepid_table_count (sizeof(udp_cepid_table) / sizeof(udp_cepid_table[0]))
    90173
     174#ifdef SUPPORT_INET6
     175
     176id_table_t udp6_cepid_table[] = {
     177        {0, USR_UDP6_CEP1}, {0, USR_UDP6_CEP2}, {0, USR_UDP6_CEP3}, {0, USR_UDP6_CEP4}
     178};
     179#define udp6_cepid_table_count (sizeof(udp6_cepid_table) / sizeof(udp6_cepid_table[0]))
     180
     181#else
     182
     183#define udp6_cepid_table NULL
     184#define udp6_cepid_table_count 0
     185
     186#endif
     187
    91188ID new_id(id_table_t *table, int count)
    92189{
    … …  
    116213}
    117214
    118 int delete_tcp_rep(int repid)
    119 {
    120         return delete_tcp_fd(tmax_tcp_cepid + repid);
    121 }
    122 
    123 typedef struct _IO_FILE SOCKET;
     215typedef struct SHELL_FILE SOCKET;
    124216
    125217int shell_socket(int family, int type, int protocol)
    … …  
    141233        switch (type) {
    142234        case SOCK_STREAM:
    143                 fp = new_tcp_fd(0);
     235                fp = new_fp(&IO_TYPE_TCP, 0, 0);
     236                if (fp == NULL)
     237                        return -ENOMEM;
     238
     239                fp->exinf = malloc(sizeof(socket_t));
     240                memset(fp->exinf, 0, sizeof(socket_t));
    144241                break;
    145242        case SOCK_DGRAM:
    146                 fp = new_udp_fd(0);
     243                fp = new_fp(&IO_TYPE_UDP, 0, 1);
     244                if (fp == NULL)
     245                        return -ENOMEM;
     246
     247                fp->exinf = malloc(sizeof(socket_t));
     248                memset(fp->exinf, 0, sizeof(socket_t));
    147249                break;
    148250        default:
    … …  
    150252        }
    151253
    152         if (fp == NULL) {
    153                 return -ENOMEM;
    154         }
    155 
    156         fp->psock->family = family;
    157         fp->psock->type = type;
    158         fp->psock->protocol = protocol;
    159         fp->psock->flags = flags;
     254        socket_t *socket = (socket_t *)fp->exinf;
     255        socket->family = family;
     256        socket->type = type;
     257        socket->protocol = protocol;
     258        socket->flags = flags;
    160259
    161260        return fp->fd;
    … …  
    167266        if (fp == NULL)
    168267                return -EBADF;
    169         if (fp->psock->family != addr->sa_family)
     268        socket_t *socket = (socket_t *)fp->exinf;
     269        if (socket->family != addr->sa_family)
    170270                return -EINVAL;
    171271
    … …  
    177277                }
    178278                struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
    179                 memcpy(&fp->psock->laddr4, addr, len);
    180                 switch (fp->psock->type) {
     279                memcpy(&socket->laddr4, addr, len);
     280                switch (socket->type) {
    181281                case SOCK_STREAM: {
    182282                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    … …  
    184284                                return -ENOMEM;
    185285
    186                         fp->psock->buf_size = 512 + 512;
    187                         fp->psock->buf = malloc(fp->psock->buf_size);
     286                        socket->buf_size = 512 + 512;
     287                        socket->buf = malloc(socket->buf_size);
    188288#ifdef _DEBUG
    189                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     289                        memset(socket->buf, 0, socket->buf_size);
    190290#endif
    191                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     291                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    192292                        ret = tcp_cre_cep(cepid, &ccep);
    193293                        if (ret != E_OK) {
    … …  
    196296                        }
    197297                        fp->handle = cepid;
    198                         fp->psock->cepid = cepid;
     298                        socket->cepid = cepid;
    199299                        break;
    200300                }
    … …  
    211311                        }
    212312                        fp->handle = cepid;
    213                         fp->psock->cepid = cepid;
     313                        socket->cepid = cepid;
    214314                        break;
    215315                }
    … …  
    223323                        return -EINVAL;
    224324                }
    225                 memcpy(&fp->psock->laddr4, addr, len);
    226                 break;
    227         }
     325                struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
     326                memcpy(&socket->laddr6, addr, len);
     327                switch (socket->type) {
     328                case SOCK_STREAM: {
     329                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     330                        if (cepid < 0)
     331                                return -ENOMEM;
     332
     333                        socket->buf_size = 512 + 512;
     334                        socket->buf = malloc(socket->buf_size);
     335#ifdef _DEBUG
     336                        memset(socket->buf, 0, socket->buf_size);
     337#endif
     338                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     339                        ret = tcp6_cre_cep(cepid, &ccep);
     340                        if (ret != E_OK) {
     341                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     342                                return -ENOMEM;
     343                        }
     344                        fp->handle = cepid;
     345                        socket->cepid = cepid;
     346                        break;
     347                }
     348                case SOCK_DGRAM: {
     349                        ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
     350                        if (cepid < 0)
     351                                return -ENOMEM;
     352
     353                        T_UDP6_CCEP ccep = { 0, {ntohl(addr_in6->sin6_addr.__in6_union.__s6_addr), ntohs(addr_in6->sin6_port)}, (FP)socket_udp6_callback };
     354                        ret = udp6_cre_cep(cepid, &ccep);
     355                        if (ret != E_OK) {
     356                                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
     357                                return -ENOMEM;
     358                        }
     359                        fp->handle = cepid;
     360                        socket->cepid = cepid;
     361                        break;
     362                }
     363                default:
     364                        return -ENOPROTOOPT;
     365                }
     366                break;
     367        }
     368        default:
     369                return -ENOPROTOOPT;
    228370        }
    229371
    … …  
    236378        if (fp == NULL)
    237379                return -EBADF;
    238         if (fp->psock->type != SOCK_STREAM)
     380        socket_t *socket = (socket_t *)fp->exinf;
     381        if (socket->type != SOCK_STREAM)
    239382                return -EINVAL;
    240383
    241         fp->psock->backlog = backlog;
     384        socket->backlog = backlog;
    242385
    243386        ER ret;
    244         switch (fp->psock->family) {
     387        switch (socket->family) {
    245388        case AF_INET: {
    246389                ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
    … …  
    248391                        return -ENOMEM;
    249392
    250                 struct sockaddr_in *laddr = &fp->psock->laddr4;
     393                struct sockaddr_in *laddr = &socket->laddr4;
    251394                T_TCP_CREP crep = { 0, {ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port)} };
    252395                ret = tcp_cre_rep(repid, &crep);
    … …  
    255398                        return -ENOMEM;
    256399                }
    257                 fp->psock->repid = repid;
     400                socket->repid = repid;
    258401                break;
    259402        }
    260403        case AF_INET6: {
    261                 break;
    262         }
     404                ID repid = new_id(tcp6_repid_table, tcp6_repid_table_count);
     405                if (repid < 0)
     406                        return -ENOMEM;
     407
     408                struct sockaddr_in6 *laddr = &socket->laddr6;
     409                T_TCP6_CREP crep = { 0, {ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port)} };
     410                ret = tcp6_cre_rep(repid, &crep);
     411                if (ret != E_OK) {
     412                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     413                        return -ENOMEM;
     414                }
     415                socket->repid = repid;
     416                break;
     417        }
     418        default:
     419                return -ENOPROTOOPT;
    263420        }
    264421
    … …  
    271428        if (fp == NULL)
    272429                return -EBADF;
    273         if (fp->psock->type != SOCK_STREAM)
     430        socket_t *socket = (socket_t *)fp->exinf;
     431        if (socket->type != SOCK_STREAM)
    274432                return -EINVAL;
    275433
    276434        ER ret;
    277         switch (fp->psock->family) {
     435        switch (socket->family) {
    278436        case AF_INET: {
    279437                if (len < 8) {
    280438                        return -EINVAL;
    281439                }
    282                 if (fp->psock->cepid == 0) {
     440                if (socket->cepid == 0) {
    283441                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    284442                        if (cepid < 0)
    285443                                return -ENOMEM;
    286444
    287                         fp->psock->buf_size = 512 + 512;
    288                         fp->psock->buf = malloc(fp->psock->buf_size);
     445                        socket->buf_size = 512 + 512;
     446                        socket->buf = malloc(socket->buf_size);
    289447#ifdef _DEBUG
    290                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     448                        memset(socket->buf, 0, socket->buf_size);
    291449#endif
    292                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     450                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    293451                        ret = tcp_cre_cep(cepid, &ccep);
    294452                        if (ret != E_OK) {
    … …  
    297455                        }
    298456                        fp->handle = cepid;
    299                         fp->psock->cepid = cepid;
    300                 }
    301                 struct sockaddr_in *laddr = &fp->psock->laddr4;
    302                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     457                        socket->cepid = cepid;
     458                }
     459                struct sockaddr_in *laddr = &socket->laddr4;
     460                struct sockaddr_in *raddr = &socket->raddr4;
    303461                memset(raddr, 0, sizeof(*raddr));
    304462                memcpy(raddr, addr, len);
    305463                T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
    306464                T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    307                 ret = tcp_con_cep(fp->psock->cepid, &lep, &rep, SOCKET_TIMEOUT);
     465                ret = tcp_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
    308466                if (ret < 0) {
    309467                        return -EHOSTUNREACH;
    … …  
    312470        }
    313471        case AF_INET6: {
    314                 break;
    315         }
     472                if (len < 20) {
     473                        return -EINVAL;
     474                }
     475                if (socket->cepid == 0) {
     476                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     477                        if (cepid < 0)
     478                                return -ENOMEM;
     479
     480                        socket->buf_size = 512 + 512;
     481                        socket->buf = malloc(socket->buf_size);
     482#ifdef _DEBUG
     483                        memset(socket->buf, 0, socket->buf_size);
     484#endif
     485                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     486                        ret = tcp6_cre_cep(cepid, &ccep);
     487                        if (ret != E_OK) {
     488                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     489                                return -ENOMEM;
     490                        }
     491                        fp->handle = cepid;
     492                        socket->cepid = cepid;
     493                }
     494                struct sockaddr_in6 *laddr = &socket->laddr6;
     495                struct sockaddr_in6 *raddr = &socket->raddr6;
     496                memset(raddr, 0, sizeof(*raddr));
     497                memcpy(raddr, addr, len);
     498                T_IPV6EP lep = { ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port) };
     499                T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
     500                ret = tcp6_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
     501                if (ret < 0) {
     502                        return -EHOSTUNREACH;
     503                }
     504                break;
     505        }
     506        default:
     507                return -ENOPROTOOPT;
    316508        }
    317509
    … …  
    324516        if (lfp == NULL)
    325517                return -EBADF;
    326         if (lfp->psock->type != SOCK_STREAM)
     518        if (((socket_t *)lfp->exinf)->type != SOCK_STREAM)
    327519                return -EINVAL;
    328520
    329         SOCKET *fp = new_tcp_fd(0);
    330         if (fp == NULL) {
     521        SOCKET *fp = new_fp(&IO_TYPE_TCP, 0, 0);
     522        if (fp == NULL)
    331523                return -ENOMEM;
    332         }
    333 
    334         memcpy(fp->psock, lfp->psock, offsetof(socket_t, buf_size));
     524
     525        fp->exinf = malloc(sizeof(socket_t));
     526        memset(fp->exinf, 0, sizeof(socket_t));
     527
     528        memcpy(fp->exinf, lfp->exinf, offsetof(socket_t, buf_size));
    335529
    336530        ER ret;
    337         switch (fp->psock->family) {
     531        socket_t *socket = (socket_t *)fp->exinf;
     532        switch (socket->family) {
    338533        case AF_INET: {
    339534                ID cepid;
    340                 if (fp->psock->cepid == 0) {
     535                if (socket->cepid == 0) {
    341536                        cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    342537                        if (cepid < 0)
    343538                                return -ENOMEM;
    344539
    345                         fp->psock->buf_size = 512 + 512;
    346                         fp->psock->buf = malloc(fp->psock->buf_size);
     540                        socket->buf_size = 512 + 512;
     541                        socket->buf = malloc(socket->buf_size);
    347542#ifdef _DEBUG
    348                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     543                        memset(socket->buf, 0, socket->buf_size);
    349544#endif
    350                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     545                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    351546                        ret = tcp_cre_cep(cepid, &ccep);
    352547                        if (ret != E_OK) {
    … …  
    355550                        }
    356551                        fp->handle = cepid;
    357                         fp->psock->cepid = cepid;
     552                        socket->cepid = cepid;
    358553                }
    359554                else {
    360                         cepid = lfp->psock->cepid;
     555                        cepid = ((socket_t *)lfp->exinf)->cepid;
    361556                        fp->handle = cepid;
    362                         lfp->handle = tmax_tcp_cepid + lfp->psock->repid;
    363                         lfp->psock->cepid = 0;
    364                         lfp->psock->buf_size = 0;
    365                         lfp->psock->buf = 0;
     557                        lfp->handle = tmax_tcp_cepid + ((socket_t *)lfp->exinf)->repid;
     558                        ((socket_t *)lfp->exinf)->cepid = 0;
     559                        ((socket_t *)lfp->exinf)->buf_size = 0;
     560                        ((socket_t *)lfp->exinf)->buf = 0;
    366561                }
    367562                T_IPV4EP rep = { 0, 0 };
    368                 ret = tcp_acp_cep(fp->psock->cepid, fp->psock->repid, &rep, TMO_FEVR);
     563                ret = tcp_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
    369564                if (ret < 0) {
    370565                        return -ENOMEM;
    371566                }
    372                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     567                struct sockaddr_in *raddr = &socket->raddr4;
    373568                memset(raddr, 0, sizeof(*raddr));
    374569                raddr->sin_family = AF_INET;
    375570                raddr->sin_port = htons(rep.portno);
    376571                raddr->sin_addr.s_addr = htonl(rep.ipaddr);
     572
     573                if (addr != NULL && len != NULL) {
     574                        int sz = *len;
     575                        if (sz < 8) {
     576                                return -EINVAL;
     577                        }
     578                        struct sockaddr_in *raddr = &socket->raddr4;
     579                        if (sz > sizeof(*raddr))
     580                                sz = sizeof(*raddr);
     581                        memcpy(addr, raddr, sz);
     582                        *len = sizeof(*raddr);
     583                }
    377584                break;
    378585        }
    379586        case AF_INET6: {
    380                 return -EAFNOSUPPORT;
    381         }
    382         }
    383 
    384         if (addr != NULL && len != NULL) {
    385                 int sz = *len;
    386                 if (sz < 8) {
    387                         return -EINVAL;
    388                 }
    389                 struct sockaddr_in *raddr = &fp->psock->raddr4;
    390                 if (sz > sizeof(*raddr))
    391                         sz = sizeof(*raddr);
    392                 memcpy(addr, raddr, sz);
    393                 *len = sizeof(*raddr);
     587                ID cepid;
     588                if (socket->cepid == 0) {
     589                        cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     590                        if (cepid < 0)
     591                                return -ENOMEM;
     592
     593                        socket->buf_size = 512 + 512;
     594                        socket->buf = malloc(socket->buf_size);
     595#ifdef _DEBUG
     596                        memset(socket->buf, 0, socket->buf_size);
     597#endif
     598                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     599                        ret = tcp6_cre_cep(cepid, &ccep);
     600                        if (ret != E_OK) {
     601                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     602                                return -ENOMEM;
     603                        }
     604                        fp->handle = cepid;
     605                        socket->cepid = cepid;
     606                }
     607                else {
     608                        cepid = ((socket_t *)lfp->exinf)->cepid;
     609                        fp->handle = cepid;
     610                        lfp->handle = tmax_tcp6_cepid + ((socket_t *)lfp->exinf)->repid;
     611                        ((socket_t *)lfp->exinf)->cepid = 0;
     612                        ((socket_t *)lfp->exinf)->buf_size = 0;
     613                        ((socket_t *)lfp->exinf)->buf = 0;
     614                }
     615                T_IPV6EP rep = { 0, 0 };
     616                ret = tcp6_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
     617                if (ret < 0) {
     618                        return -ENOMEM;
     619                }
     620                struct sockaddr_in6 *raddr = &socket->raddr6;
     621                memset(raddr, 0, sizeof(*raddr));
     622                raddr->sin6_family = AF_INET;
     623                raddr->sin6_port = htons(rep.portno);
     624#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     625                memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
     626#else
     627                for (int i = 0; i < 16; i++)
     628                        raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
     629#endif
     630
     631                if (addr != NULL && len != NULL) {
     632                        int sz = *len;
     633                        if (sz < 8) {
     634                                return -EINVAL;
     635                        }
     636                        struct sockaddr_in6 *raddr = &socket->raddr6;
     637                        if (sz > sizeof(*raddr))
     638                                sz = sizeof(*raddr);
     639                        memcpy(addr, raddr, sz);
     640                        *len = sizeof(*raddr);
     641                }
     642                break;
     643        }
     644        default:
     645                return -ENOPROTOOPT;
    394646        }
    395647
    … …  
    405657
    406658        int ret = 0;
    407         switch (fp->psock->family) {
     659        socket_t *socket = (socket_t *)fp->exinf;
     660        switch (socket->family) {
    408661        case AF_INET: {
    409                 switch (fp->psock->type) {
     662                switch (socket->type) {
    410663                case SOCK_STREAM: {
    411664                        if ((addr != NULL) || (alen != 0)) {
    … …  
    414667
    415668                        if (flags & MSG_OOB) {
    416                                 ret = tcp_snd_oob(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     669                                ret = tcp_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    417670                                if (ret < 0) {
    418671                                        return -ECOMM;
    … …  
    421674                        else {
    422675                                for (;;) {
    423                                         ret = tcp_snd_dat(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     676                                        ret = tcp_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    424677                                        if (ret < 0) {
    425678                                                if (ret == E_TMOUT)
    … …  
    440693                                return -EINVAL;
    441694                        }
    442                         struct sockaddr_in *raddr = &fp->psock->raddr4;
     695                        struct sockaddr_in *raddr = &socket->raddr4;
    443696                        memset(raddr, 0, sizeof(*raddr));
    444697                        memcpy(raddr, addr, sz);
    445698                        T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    446                         ret = udp_snd_dat(fp->psock->cepid, &rep, (void *)buf, len,
    447                                 (fp->psock->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     699                        ret = udp_snd_dat(socket->cepid, &rep, (void *)buf, len,
     700                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
    448701                        if (ret < 0) {
    449702                                return (ret == E_TMOUT) ? -ETIME : -ECOMM;
    … …  
    455708        }
    456709        case AF_INET6: {
    457                 return -EAFNOSUPPORT;
    458         }
     710                switch (socket->type) {
     711                case SOCK_STREAM: {
     712                        if ((addr != NULL) || (alen != 0)) {
     713                                return -EISCONN;
     714                        }
     715
     716                        if (flags & MSG_OOB) {
     717                                ret = tcp6_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     718                                if (ret < 0) {
     719                                        return -ECOMM;
     720                                }
     721                        }
     722                        else {
     723                                for (;;) {
     724                                        ret = tcp6_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     725                                        if (ret < 0) {
     726                                                if (ret == E_TMOUT)
     727                                                        return -ETIME;
     728                                                return -ECOMM;
     729                                        }
     730                                        len -= ret;
     731                                        if (len <= 0)
     732                                                break;
     733                                        buf = (const void *)&((uint8_t *)buf)[ret];
     734                                }
     735                        }
     736                        break;
     737                }
     738                case SOCK_DGRAM: {
     739                        int sz = alen;
     740                        if ((addr == NULL) || (sz < 8)) {
     741                                return -EINVAL;
     742                        }
     743                        struct sockaddr_in6 *raddr = &socket->raddr6;
     744                        memset(raddr, 0, sizeof(*raddr));
     745                        memcpy(raddr, addr, sz);
     746                        T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
     747                        ret = udp6_snd_dat(socket->cepid, &rep, (void *)buf, len,
     748                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     749                        if (ret < 0) {
     750                                return (ret == E_TMOUT) ? -ETIME : -ECOMM;
     751                        }
     752                        break;
     753                }
     754                }
     755                break;
     756        }
     757        default:
     758                return -ENOPROTOOPT;
    459759        }
    460760
    … …  
    476776
    477777        int ret = 0;
    478         switch (fp->psock->family) {
     778        socket_t *socket = (socket_t *)fp->exinf;
     779        switch (socket->family) {
    479780        case AF_INET: {
    480                 switch (fp->psock->type) {
     781                switch (socket->type) {
    481782                case SOCK_STREAM: {
    482783                        if (flags & MSG_OOB) {
    483                                 ret = tcp_rcv_oob(fp->psock->cepid, buf, len);
     784                                ret = tcp_rcv_oob(socket->cepid, buf, len);
    484785                                if (ret < 0) {
    485786                                        syslog(LOG_ERROR, "tcp_rcv_oob => %d", ret);
    … …  
    489790                        else {
    490791                                int rsz, tmp;
    491                                 if (fp->psock->input == NULL) {
     792                                if (socket->input == NULL) {
    492793                                        ret = wai_sem(SEM_FILEDESC);
    493794                                        if (ret < 0) {
    494795                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    495796                                        }
    496                                         fp->psock->len = 0;
     797                                        socket->len = 0;
    497798                                        ret = sig_sem(SEM_FILEDESC);
    498799                                        if (ret < 0) {
    499800                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
    500801                                        }
    501                                         ret = tcp_rcv_buf(fp->psock->cepid, &fp->psock->input, TMO_FEVR);
     802                                        ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
    502803                                        if (ret < 0) {
    503804                                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
    … …  
    507808                                }
    508809                                else
    509                                         rsz = fp->psock->len;
     810                                        rsz = socket->len;
    510811                                tmp = rsz;
    511812                                if (rsz > len)
    512813                                        rsz = len;
    513814                                if (rsz >= 0) {
    514                                         memcpy(buf, fp->psock->input, rsz);
     815                                        memcpy(buf, socket->input, rsz);
    515816                                        ret = wai_sem(SEM_FILEDESC);
    516817                                        if (ret < 0) {
    517818                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    518819                                        }
    519                                         fp->psock->len = tmp - rsz;
     820                                        socket->len = tmp - rsz;
    520821                                        ret = sig_sem(SEM_FILEDESC);
    521822                                        if (ret < 0) {
    … …  
    523824                                        }
    524825                                        if (tmp - rsz == 0) {
    525                                                 fp->psock->input = NULL;
     826                                                socket->input = NULL;
    526827                                        }
    527828                                        else
    528                                                 fp->psock->input = (void *)&((uint8_t *)fp->psock->input)[rsz];
    529                                         ret = tcp_rel_buf(fp->psock->cepid, rsz);
     829                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     830                                        ret = tcp_rel_buf(socket->cepid, rsz);
    530831                                        if ((ret != E_OBJ) && (ret < 0)) {
    531832                                                syslog(LOG_ERROR, "tcp_rel_buf => %d", ret);
    … …  
    538839                }
    539840                case SOCK_DGRAM: {
    540                         struct sockaddr_in *raddr = &fp->psock->raddr4;
     841                        struct sockaddr_in *raddr = &socket->raddr4;
    541842                        int rsz;
    542843                        ret = wai_sem(SEM_FILEDESC);
    … …  
    544845                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    545846                        }
    546                         T_NET_BUF *input = fp->psock->input;
     847                        T_NET_BUF *input = socket->input;
    547848                        if (input == NULL) {
    548849                                ret = sig_sem(SEM_FILEDESC);
    … …  
    552853
    553854                                T_IPV4EP rep = { 0, 0 };
    554                                 ret = udp_rcv_dat(fp->psock->cepid, &rep, buf, len,
    555                                         (fp->psock->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     855                                ret = udp_rcv_dat(socket->cepid, &rep, buf, len,
     856                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
    556857                                if (ret < 0) {
    557                                         syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
     858                                        if ((socket->flags & O_NONBLOCK) == 0)
     859                                                syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
    558860                                        return (ret == E_TMOUT) ? -ETIME : -ECOMM;
    559861                                }
    … …  
    565867                                        }
    566868                                        int sz = *alen;
    567                                         memset(raddr, 0, sizeof(fp->psock->raddr4));
     869                                        memset(raddr, 0, sizeof(socket->raddr4));
    568870                                        raddr->sin_family = AF_INET;
    569871                                        raddr->sin_port = htons(rep.portno);
    570872                                        raddr->sin_addr.s_addr = htonl(rep.ipaddr);
    571                                         if (sz > sizeof(fp->psock->raddr4))
    572                                                 sz = sizeof(fp->psock->raddr4);
     873                                        if (sz > sizeof(socket->raddr4))
     874                                                sz = sizeof(socket->raddr4);
    573875                                        memcpy(addr, raddr, sz);
    574876                                        *alen = sz;
    … …  
    580882                        }
    581883                        else {
    582                                 rsz = fp->psock->len;
    583                                 void *pbuf = fp->psock->buf;
    584                                 fp->psock->input = NULL;
    585                                 fp->psock->len = 0;
    586                                 fp->psock->buf = NULL;
     884                                rsz = socket->len;
     885                                void *pbuf = socket->buf;
     886                                socket->input = NULL;
     887                                socket->len = 0;
     888                                socket->buf = NULL;
    587889                                if ((addr != NULL) && (alen != NULL)) {
    588890                                        int sz = *alen;
    589                                         if (sz > sizeof(fp->psock->raddr4))
    590                                                 sz = sizeof(fp->psock->raddr4);
     891                                        if (sz > sizeof(socket->raddr4))
     892                                                sz = sizeof(socket->raddr4);
    591893                                        memcpy(addr, raddr, sz);
    592894                                        *alen = sz;
    … …  
    611913        }
    612914        case AF_INET6: {
    613                 return -EAFNOSUPPORT;
    614         }
     915                switch (socket->type) {
     916                case SOCK_STREAM: {
     917                        if (flags & MSG_OOB) {
     918                                ret = tcp6_rcv_oob(socket->cepid, buf, len);
     919                                if (ret < 0) {
     920                                        syslog(LOG_ERROR, "tcp6_rcv_oob => %d", ret);
     921                                        return -ECOMM;
     922                                }
     923                        }
     924                        else {
     925                                int rsz, tmp;
     926                                if (socket->input == NULL) {
     927                                        ret = wai_sem(SEM_FILEDESC);
     928                                        if (ret < 0) {
     929                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     930                                        }
     931                                        socket->len = 0;
     932                                        ret = sig_sem(SEM_FILEDESC);
     933                                        if (ret < 0) {
     934                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     935                                        }
     936                                        ret = tcp6_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
     937                                        if (ret < 0) {
     938                                                syslog(LOG_ERROR, "tcp6_rcv_buf => %d", ret);
     939                                                return -ECOMM;
     940                                        }
     941                                        rsz = ret;
     942                                }
     943                                else
     944                                        rsz = socket->len;
     945                                tmp = rsz;
     946                                if (rsz > len)
     947                                        rsz = len;
     948                                if (rsz >= 0) {
     949                                        memcpy(buf, socket->input, rsz);
     950                                        ret = wai_sem(SEM_FILEDESC);
     951                                        if (ret < 0) {
     952                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     953                                        }
     954                                        socket->len = tmp - rsz;
     955                                        ret = sig_sem(SEM_FILEDESC);
     956                                        if (ret < 0) {
     957                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     958                                        }
     959                                        if (tmp - rsz == 0) {
     960                                                socket->input = NULL;
     961                                        }
     962                                        else
     963                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     964                                        ret = tcp6_rel_buf(socket->cepid, rsz);
     965                                        if ((ret != E_OBJ) && (ret < 0)) {
     966                                                syslog(LOG_ERROR, "tcp6_rel_buf => %d", ret);
     967                                                //return -ECOMM;
     968                                        }
     969                                }
     970                                ret = rsz;
     971                        }
     972                        break;
     973                }
     974                case SOCK_DGRAM: {
     975                        struct sockaddr_in6 *raddr = &socket->raddr6;
     976                        int rsz;
     977                        ret = wai_sem(SEM_FILEDESC);
     978                        if (ret < 0) {
     979                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     980                        }
     981                        T_NET_BUF *input = socket->input;
     982                        if (input == NULL) {
     983                                ret = sig_sem(SEM_FILEDESC);
     984                                if (ret < 0) {
     985                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     986                                }
     987
     988                                T_IPV6EP rep = { 0, 0 };
     989                                ret = udp6_rcv_dat(socket->cepid, &rep, buf, len,
     990                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     991                                if (ret < 0) {
     992                                        if ((socket->flags & O_NONBLOCK) == 0)
     993                                                syslog(LOG_ERROR, "udp6_rcv_buf => %d", ret);
     994                                        return (ret == E_TMOUT) ? -ETIME : -ECOMM;
     995                                }
     996                                rsz = ret;
     997                                if ((addr != NULL) && (alen != NULL)) {
     998                                        ret = wai_sem(SEM_FILEDESC);
     999                                        if (ret < 0) {
     1000                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1001                                        }
     1002                                        int sz = *alen;
     1003                                        memset(raddr, 0, sizeof(socket->raddr6));
     1004                                        raddr->sin6_family = AF_INET;
     1005                                        raddr->sin6_port = htons(rep.portno);
     1006#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1007                                        memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
     1008#else
     1009                                        for (int i = 0; i < 16; i++)
     1010                                                raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
     1011#endif
     1012                                        if (sz > sizeof(socket->raddr6))
     1013                                                sz = sizeof(socket->raddr6);
     1014                                        memcpy(addr, raddr, sz);
     1015                                        *alen = sz;
     1016                                        ret = sig_sem(SEM_FILEDESC);
     1017                                        if (ret < 0) {
     1018                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     1019                                        }
     1020                                }
     1021                        }
     1022                        else {
     1023                                rsz = socket->len;
     1024                                void *pbuf = socket->buf;
     1025                                socket->input = NULL;
     1026                                socket->len = 0;
     1027                                socket->buf = NULL;
     1028                                if ((addr != NULL) && (alen != NULL)) {
     1029                                        int sz = *alen;
     1030                                        if (sz > sizeof(socket->raddr6))
     1031                                                sz = sizeof(socket->raddr6);
     1032                                        memcpy(addr, raddr, sz);
     1033                                        *alen = sz;
     1034                                }
     1035                                ret = sig_sem(SEM_FILEDESC);
     1036                                if (ret < 0) {
     1037                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1038                                }
     1039                                if (rsz > len)
     1040                                        rsz = len;
     1041                                memcpy(buf, pbuf, rsz);
     1042                                ret = rel_net_buf(input);
     1043                                if (ret < 0) {
     1044                                        syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1045                                        //return -ECOMM;
     1046                                }
     1047                        }
     1048                        ret = rsz;
     1049                }
     1050                }
     1051                break;
     1052        }
     1053        default:
     1054                return -ENOPROTOOPT;
    6151055        }
    6161056
    … …  
    6321072
    6331073        ER ret;
    634         switch (fp->psock->family) {
     1074        socket_t *socket = (socket_t *)fp->exinf;
     1075        switch (socket->family) {
    6351076        case AF_INET: {
    636                 switch (fp->psock->type) {
     1077                switch (socket->type) {
    6371078                case SOCK_STREAM: {
    638                         ret = tcp_sht_cep(fp->psock->cepid);
     1079                        ret = tcp_sht_cep(socket->cepid);
    6391080                        if (ret < 0) {
    6401081                                return -ECOMM;
    … …  
    6461087        }
    6471088        case AF_INET6: {
    648                 return -EAFNOSUPPORT;
    649         }
     1089                switch (socket->type) {
     1090                case SOCK_STREAM: {
     1091                        ret = tcp6_sht_cep(socket->cepid);
     1092                        if (ret < 0) {
     1093                                return -ECOMM;
     1094                        }
     1095                        break;
     1096                }
     1097                }
     1098                break;
     1099        }
     1100        default:
     1101                return -ENOPROTOOPT;
    6501102        }
    6511103
    … …  
    6611113
    6621114        ER ret;
    663         switch (fp->psock->family) {
     1115        socket_t *socket = (socket_t *)fp->exinf;
     1116        switch (socket->family) {
    6641117        case AF_INET: {
    665                 switch (fp->psock->type) {
     1118                switch (socket->type) {
    6661119                case SOCK_STREAM: {
    6671120                        switch (level) {
    … …  
    6691122                                switch (optname) {
    6701123                                case SO_REUSEADDR:
    671                                         if (fp->psock->flags & SO_REUSEADDR) {
     1124                                        if (socket->flags & SO_REUSEADDR) {
    6721125                                                *(bool *)optval = true;
    6731126                                        }
    … …  
    6771130                                        break;
    6781131                                case SO_KEEPALIVE:
    679                                         if (fp->psock->flags & SO_KEEPALIVE) {
     1132                                        if (socket->flags & SO_KEEPALIVE) {
    6801133                                                *(bool *)optval = true;
    6811134                                        }
    … …  
    6921145                                break;
    6931146                        case IPPROTO_TCP:
    694                                 ret = tcp_get_opt(fp->psock->cepid, optname, (void *)optval, *optlen);
     1147                                ret = tcp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    6951148                                if (ret < 0) {
    6961149                                        return -EINVAL;
    … …  
    7061159                        switch (level) {
    7071160                        case IPPROTO_UDP:
    708                                 ret = udp_get_opt(fp->psock->cepid, optname, (void *)optval, *optlen);
     1161                                ret = udp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    7091162                                if (ret < 0) {
    7101163                                        return -EINVAL;
    … …  
    7211174        }
    7221175        case AF_INET6: {
    723                 return -EAFNOSUPPORT;
    724         }
     1176                switch (socket->type) {
     1177                case SOCK_STREAM: {
     1178                        switch (level) {
     1179                        case SOL_SOCKET:
     1180                                switch (optname) {
     1181                                case SO_REUSEADDR:
     1182                                        if (socket->flags & SO_REUSEADDR) {
     1183                                                *(bool *)optval = true;
     1184                                        }
     1185                                        else {
     1186                                                *(bool *)optval = false;
     1187                                        }
     1188                                        break;
     1189                                case SO_KEEPALIVE:
     1190                                        if (socket->flags & SO_KEEPALIVE) {
     1191                                                *(bool *)optval = true;
     1192                                        }
     1193                                        else {
     1194                                                *(bool *)optval = false;
     1195                                        }
     1196                                        break;
     1197                                case SO_ERROR:
     1198                                        *(int *)optval = 0;
     1199                                        break;
     1200                                default:
     1201                                        return -EINVAL;
     1202                                }
     1203                                break;
     1204                        case IPPROTO_TCP:
     1205                                ret = tcp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1206                                if (ret < 0) {
     1207                                        return -EINVAL;
     1208                                }
     1209                                *optlen = ret;
     1210                                break;
     1211                        default:
     1212                                return -EINVAL;
     1213                        }
     1214                        break;
     1215                }
     1216                case SOCK_DGRAM: {
     1217                        switch (level) {
     1218                        case IPPROTO_UDP:
     1219                                ret = udp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1220                                if (ret < 0) {
     1221                                        return -EINVAL;
     1222                                }
     1223                                *optlen = ret;
     1224                                break;
     1225                        default:
     1226                                return -EINVAL;
     1227                        }
     1228                        break;
     1229                }
     1230                }
     1231                break;
     1232        }
     1233        default:
     1234                return -ENOPROTOOPT;
    7251235        }
    7261236
    … …  
    7361246
    7371247        ER ret;
    738         switch (fp->psock->family) {
     1248        socket_t *socket = (socket_t *)fp->exinf;
     1249        switch (socket->family) {
    7391250        case AF_INET: {
    740                 switch (fp->psock->type) {
     1251                switch (socket->type) {
    7411252                case SOCK_STREAM: {
    7421253                        switch (level){
    … …  
    7451256                                case SO_REUSEADDR:
    7461257                                        if (*(bool *)optval) {
    747                                                 fp->psock->flags |= SO_REUSEADDR;
     1258                                                socket->flags |= SO_REUSEADDR;
    7481259                                        }
    7491260                                        else {
    750                                                 fp->psock->flags &= ~SO_REUSEADDR;
     1261                                                socket->flags &= ~SO_REUSEADDR;
    7511262                                        }
    7521263                                        break;
    7531264                                case SO_KEEPALIVE:
    7541265                                        if (*(bool *)optval) {
    755                                                 fp->psock->flags |= SO_KEEPALIVE;
     1266                                                socket->flags |= SO_KEEPALIVE;
    7561267                                        }
    7571268                                        else {
    758                                                 fp->psock->flags &= ~SO_KEEPALIVE;
     1269                                                socket->flags &= ~SO_KEEPALIVE;
    7591270                                        }
    7601271                                        break;
    … …  
    7641275                                break;
    7651276                        case IPPROTO_TCP:
    766                                 ret = tcp_set_opt(fp->psock->cepid, optname, (void *)optval, optlen);
     1277                                ret = tcp_set_opt(socket->cepid, optname, (void *)optval, optlen);
    7671278                                if (ret < 0) {
    7681279                                        return -EINVAL;
    … …  
    7771288                        switch (level){
    7781289                        case IPPROTO_UDP:
    779                                 ret = udp_set_opt(fp->psock->cepid, optname, (void *)optval, optlen);
     1290                                ret = udp_set_opt(socket->cepid, optname, (void *)optval, optlen);
    7801291                                if (ret < 0) {
    7811292                                        return -EINVAL;
    … …  
    7911302        }
    7921303        case AF_INET6: {
    793                 return -EAFNOSUPPORT;
    794         }
     1304                switch (socket->type) {
     1305                case SOCK_STREAM: {
     1306                        switch (level){
     1307                        case SOL_SOCKET:
     1308                                switch (optname) {
     1309                                case SO_REUSEADDR:
     1310                                        if (*(bool *)optval) {
     1311                                                socket->flags |= SO_REUSEADDR;
     1312                                        }
     1313                                        else {
     1314                                                socket->flags &= ~SO_REUSEADDR;
     1315                                        }
     1316                                        break;
     1317                                case SO_KEEPALIVE:
     1318                                        if (*(bool *)optval) {
     1319                                                socket->flags |= SO_KEEPALIVE;
     1320                                        }
     1321                                        else {
     1322                                                socket->flags &= ~SO_KEEPALIVE;
     1323                                        }
     1324                                        break;
     1325                                default:
     1326                                        return -EINVAL;
     1327                                }
     1328                                break;
     1329                        case IPPROTO_TCP:
     1330                                ret = tcp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1331                                if (ret < 0) {
     1332                                        return -EINVAL;
     1333                                }
     1334                                break;
     1335                        default:
     1336                                return -EINVAL;
     1337                        }
     1338                        break;
     1339                }
     1340                case SOCK_DGRAM: {
     1341                        switch (level){
     1342                        case IPPROTO_UDP:
     1343                                ret = udp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1344                                if (ret < 0) {
     1345                                        return -EINVAL;
     1346                                }
     1347                                break;
     1348                        default:
     1349                                return -EINVAL;
     1350                        }
     1351                        break;
     1352                }
     1353                }
     1354                break;
     1355        }
     1356        default:
     1357                return -ENOPROTOOPT;
    7951358        }
    7961359
    … …  
    8091372
    8101373        socklen_t size = *len;
    811         switch (fp->psock->family) {
     1374        socket_t *socket = (socket_t *)fp->exinf;
     1375        switch (socket->family) {
    8121376        case AF_INET: {
    813                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     1377                struct sockaddr_in *raddr = &socket->raddr4;
    8141378                *len = sizeof(struct sockaddr_in);
    8151379                if (size > sizeof(struct sockaddr_in))
    … …  
    8191383        }
    8201384        case AF_INET6: {
    821                 return -EAFNOSUPPORT;
    822         }
     1385                struct sockaddr_in6 *raddr = &socket->raddr6;
     1386                *len = sizeof(struct sockaddr_in6);
     1387                if (size > sizeof(struct sockaddr_in6))
     1388                        size = sizeof(struct sockaddr_in6);
     1389                memcpy(addr, raddr, size);
     1390                break;
     1391        }
     1392        default:
     1393                return -ENOPROTOOPT;
    8231394        }
    8241395
    … …  
    8371408
    8381409        socklen_t size = *len;
    839         switch (fp->psock->family) {
     1410        socket_t *socket = (socket_t *)fp->exinf;
     1411        switch (socket->family) {
    8401412        case AF_INET: {
    8411413                const T_IN4_ADDR *laddr4 = in4_get_ifaddr(0);
    … …  
    8431415                laddr.sin_family = AF_INET;
    8441416                laddr.sin_addr.s_addr = htonl(*laddr4);
    845                 laddr.sin_port = fp->psock->laddr4.sin_port;
     1417                laddr.sin_port = socket->laddr4.sin_port;
    8461418                memset(&laddr.sin_zero, 0, sizeof(laddr.sin_zero));
    8471419                *len = sizeof(struct sockaddr_in);
    … …  
    8521424        }
    8531425        case AF_INET6: {
    854                 return -EAFNOSUPPORT;
    855         }
     1426                const T_IN6_ADDR *laddr6 = in6_get_ifaddr(0);
     1427                struct sockaddr_in6 laddr;
     1428                laddr.sin6_family = AF_INET;
     1429#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1430                memcpy(laddr.sin6_addr.__in6_union.__s6_addr, laddr6->__u6_addr.__u6_addr8, 16);
     1431#else
     1432                for (int i = 0; i < 16; i++)
     1433                        laddr.sin6_addr.__in6_union.__s6_addr[i] = laddr6->__u6_addr.__u6_addr8[i];
     1434#endif
     1435                laddr.sin6_port = socket->laddr6.sin6_port;
     1436                *len = sizeof(struct sockaddr_in6);
     1437                if (size > sizeof(struct sockaddr_in6))
     1438                        size = sizeof(struct sockaddr_in6);
     1439                memcpy(addr, &laddr, size);
     1440                break;
     1441        }
     1442        default:
     1443                return -ENOPROTOOPT;
    8561444        }
    8571445
    … …  
    8591447}
    8601448
    861 int tcp_fd_close(struct _IO_FILE *fp)
     1449int tcp_fd_close(struct SHELL_FILE *fp)
    8621450{
    8631451        ER ret, ret2;
    8641452
    865         switch (fp->psock->family) {
     1453        socket_t *socket = (socket_t *)fp->exinf;
     1454        switch (socket->family) {
    8661455        case AF_INET: {
    867                 if (fp->psock->cepid != 0) {
    868                         ID cepid = fp->psock->cepid;
     1456                if (socket->cepid != 0) {
     1457                        ID cepid = socket->cepid;
    8691458                        ret = tcp_sht_cep(cepid);
    8701459                        if (ret < 0) {
    8711460                                //return -1;
    8721461                        }
    873                         ret = tcp_cls_cep(cepid, (fp->psock->repid != 0) ? 0 : SOCKET_TIMEOUT);
     1462                        ret = tcp_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
    8741463                        ret2 = tcp_del_cep(cepid);
    875                         free(fp->psock->buf);
    876                         fp->psock->buf = NULL;
    877                         delete_tcp_fd(cepid);
     1464                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
    8781465                        delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    8791466                        if ((ret < 0) || (ret2 < 0)) {
    … …  
    8811468                        }
    8821469                }
    883                 else if (fp->psock->repid != 0) {
    884                         ID repid = fp->psock->repid;
     1470                else if (socket->repid != 0) {
     1471                        ID repid = socket->repid;
    8851472                        ret = tcp_del_rep(repid);
    886                         free(fp->psock->buf);
    887                         fp->psock->buf = NULL;
    888                         delete_tcp_fd(tmax_tcp_cepid + repid);
     1473                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + repid);
    8891474                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    8901475                        if (ret < 0) {
    … …  
    8931478                }
    8941479                else {
    895                         free(fp->psock->buf);
    896                         fp->psock->buf = NULL;
    8971480                        return -EINVAL;
    8981481                }
    … …  
    9001483        }
    9011484        case AF_INET6: {
    902                 return -EAFNOSUPPORT;
    903         }
     1485                if (socket->cepid != 0) {
     1486                        ID cepid = socket->cepid;
     1487                        ret = tcp6_sht_cep(cepid);
     1488                        if (ret < 0) {
     1489                                //return -1;
     1490                        }
     1491                        ret = tcp6_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
     1492                        ret2 = tcp6_del_cep(cepid);
     1493                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1494                        delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     1495                        if ((ret < 0) || (ret2 < 0)) {
     1496                                return (ret == E_TMOUT) ? -ETIME : -EINVAL;
     1497                        }
     1498                }
     1499                else if (socket->repid != 0) {
     1500                        ID repid = socket->repid;
     1501                        ret = tcp6_del_rep(repid);
     1502                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp6_cepid + repid);
     1503                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     1504                        if (ret < 0) {
     1505                                return -EINVAL;
     1506                        }
     1507                }
     1508                else {
     1509                        return -EINVAL;
     1510                }
     1511                break;
     1512        }
     1513        default:
     1514                return -ENOPROTOOPT;
    9041515        }
    9051516
    … …  
    9071518}
    9081519
    909 size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
     1520size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
    9101521{
    9111522        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    9121523}
    9131524
    914 size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
     1525size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
    9151526{
    9161527        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    9171528}
    9181529
    919 off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     1530off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    9201531{
    9211532        return -EPERM;
    9221533}
    9231534
    924 int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     1535int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
    9251536{
    9261537        return -EINVAL;
    9271538}
    9281539
    929 int udp_fd_close(struct _IO_FILE *fp)
     1540bool_t tcp_fd_readable(struct SHELL_FILE *fp)
     1541{
     1542        ER ret;
     1543
     1544        socket_t *socket = (socket_t *)fp->exinf;
     1545        if (socket->cepid != 0) {
     1546                if (socket->len == 0) {
     1547                        ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_NBLK);
     1548                        if ((ret != E_WBLK) && (ret != E_OBJ) && (ret < 0)) {
     1549                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     1550                                //return ret;
     1551                        }
     1552                        if (ret > 0) {
     1553                                ret = wai_sem(SEM_FILEDESC);
     1554                                if (ret < 0) {
     1555                                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1556                                }
     1557                                socket->len += ret;
     1558                                ret = sig_sem(SEM_FILEDESC);
     1559                                if (ret < 0) {
     1560                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1561                                }
     1562                        }
     1563                }
     1564                else ret = 1;
     1565                if (ret > 0) {
     1566                        return true;
     1567                }
     1568        }
     1569
     1570        return false;
     1571}
     1572
     1573void tcp_fd_delete(struct SHELL_FILE *fp)
     1574{
     1575        socket_t *socket = (socket_t *)fp->exinf;
     1576        free(socket->buf);
     1577        socket->buf = NULL;
     1578        free(fp->exinf);
     1579        fp->exinf = NULL;
     1580}
     1581
     1582ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
     1583{
     1584        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1585        FLGPTN flgptn = 0;
     1586        ER ret;
     1587        int len;
     1588
     1589        if (fp == NULL)
     1590                return E_PAR;
     1591
     1592        int fd = fp->fd;
     1593        FD_SET(fd, (fd_set *)&flgptn);
     1594
     1595        switch (fncd) {
     1596        case TFN_TCP_RCV_BUF:
     1597                len = *(int *)p_parblk;
     1598                if ((len <= 0) || (fp->exinf == NULL))
     1599                        return E_OK;
     1600
     1601                ret = wai_sem(SEM_FILEDESC);
     1602                if (ret < 0) {
     1603                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1604                }
     1605                socket_t *socket = (socket_t *)fp->exinf;
     1606                socket->len += len;
     1607                ret = sig_sem(SEM_FILEDESC);
     1608                if (ret < 0) {
     1609                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1610                }
     1611
     1612                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1613
     1614                set_flg(FLG_SELECT_WAIT, flgptn);
     1615                return E_OK;
     1616
     1617        case TFN_TCP_RCV_DAT:
     1618                len = *(int *)p_parblk;
     1619                if ((len <= 0) || (fp->exinf == NULL))
     1620                        return E_OK;
     1621
     1622                ret = wai_sem(SEM_FILEDESC);
     1623                if (ret < 0) {
     1624                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1625                }
     1626                socket->len += len;
     1627                ret = sig_sem(SEM_FILEDESC);
     1628                if (ret < 0) {
     1629                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1630                }
     1631
     1632                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1633
     1634                set_flg(FLG_SELECT_WAIT, flgptn);
     1635                return E_OK;
     1636
     1637        case TFN_TCP_SND_DAT:
     1638                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1639
     1640                set_flg(FLG_SELECT_WAIT, flgptn);
     1641                return E_OK;
     1642
     1643        case TFN_TCP_CAN_CEP:
     1644                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1645
     1646                set_flg(FLG_SELECT_WAIT, flgptn);
     1647                return E_OK;
     1648
     1649        case TFN_TCP_DEL_REP:
     1650                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1651                return E_OK;
     1652
     1653        case TFN_TCP_DEL_CEP:
     1654                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1655                return E_OK;
     1656
     1657        default:
     1658                return E_OK;
     1659        }
     1660}
     1661
     1662ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk)
     1663{
     1664        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1665        FLGPTN flgptn = 0;
     1666        ER ret;
     1667        int len;
     1668
     1669        if (fp == NULL)
     1670                return E_PAR;
     1671
     1672        int fd = fp->fd;
     1673        FD_SET(fd, (fd_set *)&flgptn);
     1674
     1675        switch (fncd) {
     1676        case TFN_TCP_RCV_BUF:
     1677                len = *(int *)p_parblk;
     1678                if ((len <= 0) || (fp->exinf == NULL))
     1679                        return E_OK;
     1680
     1681                ret = wai_sem(SEM_FILEDESC);
     1682                if (ret < 0) {
     1683                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1684                }
     1685                socket_t *socket = (socket_t *)fp->exinf;
     1686                socket->len += len;
     1687                ret = sig_sem(SEM_FILEDESC);
     1688                if (ret < 0) {
     1689                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1690                }
     1691
     1692                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1693
     1694                set_flg(FLG_SELECT_WAIT, flgptn);
     1695                return E_OK;
     1696
     1697        case TFN_TCP_RCV_DAT:
     1698                len = *(int *)p_parblk;
     1699                if ((len <= 0) || (fp->exinf == NULL))
     1700                        return E_OK;
     1701
     1702                ret = wai_sem(SEM_FILEDESC);
     1703                if (ret < 0) {
     1704                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1705                }
     1706                socket->len += len;
     1707                ret = sig_sem(SEM_FILEDESC);
     1708                if (ret < 0) {
     1709                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1710                }
     1711
     1712                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1713
     1714                set_flg(FLG_SELECT_WAIT, flgptn);
     1715                return E_OK;
     1716
     1717        case TFN_TCP_SND_DAT:
     1718                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1719
     1720                set_flg(FLG_SELECT_WAIT, flgptn);
     1721                return E_OK;
     1722
     1723        case TFN_TCP_CAN_CEP:
     1724                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1725
     1726                set_flg(FLG_SELECT_WAIT, flgptn);
     1727                return E_OK;
     1728
     1729        case TFN_TCP_DEL_REP:
     1730                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1731                return E_OK;
     1732
     1733        case TFN_TCP_DEL_CEP:
     1734                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1735                return E_OK;
     1736
     1737        default:
     1738                return E_OK;
     1739        }
     1740}
     1741
     1742int udp_fd_close(struct SHELL_FILE *fp)
    9301743{
    9311744        ER ret;
    9321745        ID cepid;
    9331746
    934         switch (fp->psock->family) {
     1747        socket_t *socket = (socket_t *)fp->exinf;
     1748        switch (socket->family) {
    9351749        case AF_INET: {
    936                 cepid = fp->psock->cepid;
     1750                cepid = socket->cepid;
    9371751                ret = udp_del_cep(cepid);
    938                 //free(fp->psock->buf);
    939                 //fp->psock->buf = NULL;
    940                 delete_udp_fd(cepid);
     1752                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
    9411753                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    9421754                if (ret < 0) {
    … …  
    9461758        }
    9471759        case AF_INET6: {
    948                 return -EAFNOSUPPORT;
    949         }
     1760                cepid = socket->cepid;
     1761                ret = udp6_del_cep(cepid);
     1762                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1763                delete_id(udp6_cepid_table, udp6_cepid_table_count, cepid);
     1764                if (ret < 0) {
     1765                        return -EINVAL;
     1766                }
     1767                break;
     1768        }
     1769        default:
     1770                return -ENOPROTOOPT;
    9501771        }
    9511772
    … …  
    9531774}
    9541775
    955 size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
     1776size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
    9561777{
    9571778        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    9581779}
    9591780
    960 size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
     1781size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
    9611782{
    9621783        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    9631784}
    9641785
    965 off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     1786off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    9661787{
    9671788        return -EPERM;
    9681789}
    9691790
    970 int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     1791int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
    9711792{
    9721793        return -EINVAL;
     1794}
     1795
     1796bool_t udp_fd_readable(struct SHELL_FILE *fp)
     1797{
     1798        socket_t *socket = (socket_t *)fp->exinf;
     1799        if (socket->cepid != 0) {
     1800                if (socket->input != NULL) {
     1801                        return true;
     1802                }
     1803        }
     1804
     1805        return false;
     1806}
     1807
     1808void udp_fd_delete(struct SHELL_FILE *fp)
     1809{
     1810        //socket_t *socket = (socket_t *)fp->exinf;
     1811        //free(socket->buf);
     1812        //socket->buf = NULL;
     1813        free(fp->exinf);
     1814        fp->exinf = NULL;
     1815}
     1816
     1817ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk)
     1818{
     1819        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     1820        FLGPTN flgptn = 0;
     1821        int len;
     1822
     1823        if (fp == NULL)
     1824                return E_PAR;
     1825
     1826        int fd = fp->fd;
     1827        FD_SET(fd, (fd_set *)&flgptn);
     1828
     1829        switch (fncd) {
     1830        case TEV_UDP_RCV_DAT:
     1831        {
     1832                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     1833                len = udppara->len;
     1834                if ((len <= 0) || (fp->exinf == NULL))
     1835                        return E_OK;
     1836
     1837                ER ret = wai_sem(SEM_FILEDESC);
     1838                if (ret < 0) {
     1839                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1840                }
     1841                socket_t *socket = (socket_t *)fp->exinf;
     1842                socket->len = len;
     1843                if (socket->input != NULL) {
     1844                        ret = rel_net_buf(socket->input);
     1845                        if (ret < 0) {
     1846                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1847                        }
     1848                }
     1849                socket->input = udppara->input;
     1850                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     1851                memset(&socket->raddr4, 0, sizeof(socket->raddr4));
     1852                socket->raddr4.sin_family = AF_INET;
     1853                socket->raddr4.sin_port = htons(udppara->rep4.portno);
     1854                socket->raddr4.sin_addr.s_addr = htonl(udppara->rep4.ipaddr);
     1855                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     1856                ret = sig_sem(SEM_FILEDESC);
     1857                if (ret < 0) {
     1858                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1859                }
     1860
     1861                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1862
     1863                set_flg(FLG_SELECT_WAIT, flgptn);
     1864                return E_OK;
     1865        }
     1866        case TFN_UDP_CRE_CEP:
     1867                return E_OK;
     1868
     1869        case TFN_UDP_RCV_DAT:
     1870                len = *(int *)p_parblk;
     1871                if ((len <= 0) || (fp->exinf == NULL))
     1872                        return E_OK;
     1873
     1874                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1875
     1876                set_flg(FLG_SELECT_WAIT, flgptn);
     1877                return E_OK;
     1878
     1879        case TFN_UDP_SND_DAT:
     1880                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1881
     1882                set_flg(FLG_SELECT_WAIT, flgptn);
     1883                return E_OK;
     1884
     1885        case TFN_UDP_CAN_CEP:
     1886                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1887
     1888                set_flg(FLG_SELECT_WAIT, flgptn);
     1889                return E_OK;
     1890
     1891        case TFN_UDP_DEL_CEP:
     1892                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1893                return E_OK;
     1894
     1895        default:
     1896                return E_OK;
     1897        }
     1898}
     1899
     1900ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk)
     1901{
     1902        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     1903        FLGPTN flgptn = 0;
     1904        int len;
     1905
     1906        if (fp == NULL)
     1907                return E_PAR;
     1908
     1909        int fd = fp->fd;
     1910        FD_SET(fd, (fd_set *)&flgptn);
     1911
     1912        switch (fncd) {
     1913        case TEV_UDP_RCV_DAT:
     1914        {
     1915                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     1916                len = udppara->len;
     1917                if ((len <= 0) || (fp->exinf == NULL))
     1918                        return E_OK;
     1919
     1920                ER ret = wai_sem(SEM_FILEDESC);
     1921                if (ret < 0) {
     1922                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1923                }
     1924                socket_t *socket = (socket_t *)fp->exinf;
     1925                socket->len = len;
     1926                if (socket->input != NULL) {
     1927                        ret = rel_net_buf(socket->input);
     1928                        if (ret < 0) {
     1929                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1930                        }
     1931                }
     1932                socket->input = udppara->input;
     1933                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     1934                memset(&socket->raddr6, 0, sizeof(socket->raddr6));
     1935                socket->raddr6.sin6_family = AF_INET;
     1936                socket->raddr6.sin6_port = htons(udppara->rep6.portno);
     1937#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1938                memcpy(socket->raddr6.sin6_addr.__in6_union.__s6_addr, udppara->rep6.ipaddr.__u6_addr.__u6_addr8, 16);
     1939#else
     1940                for (int i = 0; i < 16; i++)
     1941                        socket->raddr6.sin6_addr.__in6_union.__s6_addr[i] = udppara->rep6.ipaddr.__u6_addr.__u6_addr8[i];
     1942#endif
     1943                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     1944                ret = sig_sem(SEM_FILEDESC);
     1945                if (ret < 0) {
     1946                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1947                }
     1948
     1949                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1950
     1951                set_flg(FLG_SELECT_WAIT, flgptn);
     1952                return E_OK;
     1953        }
     1954        case TFN_UDP_CRE_CEP:
     1955                return E_OK;
     1956
     1957        case TFN_UDP_RCV_DAT:
     1958                len = *(int *)p_parblk;
     1959                if ((len <= 0) || (fp->exinf == NULL))
     1960                        return E_OK;
     1961
     1962                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1963
     1964                set_flg(FLG_SELECT_WAIT, flgptn);
     1965                return E_OK;
     1966
     1967        case TFN_UDP_SND_DAT:
     1968                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1969
     1970                set_flg(FLG_SELECT_WAIT, flgptn);
     1971                return E_OK;
     1972
     1973        case TFN_UDP_CAN_CEP:
     1974                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1975
     1976                set_flg(FLG_SELECT_WAIT, flgptn);
     1977                return E_OK;
     1978
     1979        case TFN_UDP_DEL_CEP:
     1980                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1981                return E_OK;
     1982
     1983        default:
     1984                return E_OK;
     1985        }
    9731986}
    9741987
Note: See TracChangeset for help on using the changeset viewer.