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_arm/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;
    … …  
    6467#include "kernel_cfg.h"
    6568
     69#ifdef _DEBUG
     70static const char THIS_FILE[] = __FILE__;
     71#endif
     72
    6673#define SOCKET_TIMEOUT 2000000
     74
     75static int tcp_fd_close(struct SHELL_FILE *fp);
     76static size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     77static size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     78static off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     79static int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     80static bool_t tcp_fd_readable(struct SHELL_FILE *fp);
     81static void tcp_fd_delete(struct SHELL_FILE *fp);
     82
     83static int udp_fd_close(struct SHELL_FILE *fp);
     84static size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     85static size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     86static off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     87static int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     88static bool_t udp_fd_readable(struct SHELL_FILE *fp);
     89static void udp_fd_delete(struct SHELL_FILE *fp);
     90
     91IO_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 };
     92IO_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 };
    6793
    6894typedef struct id_table_t {
    … …  
    116142}
    117143
    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;
     144typedef struct SHELL_FILE SOCKET;
    124145
    125146int shell_socket(int family, int type, int protocol)
    … …  
    141162        switch (type) {
    142163        case SOCK_STREAM:
    143                 fp = new_tcp_fd(0);
     164                fp = new_fp(&IO_TYPE_TCP, 0, 0);
     165                if (fp == NULL)
     166                        return -ENOMEM;
     167
     168                fp->exinf = malloc(sizeof(socket_t));
     169                memset(fp->exinf, 0, sizeof(socket_t));
    144170                break;
    145171        case SOCK_DGRAM:
    146                 fp = new_udp_fd(0);
     172                fp = new_fp(&IO_TYPE_UDP, 0, 1);
     173                if (fp == NULL)
     174                        return -ENOMEM;
     175
     176                fp->exinf = malloc(sizeof(socket_t));
     177                memset(fp->exinf, 0, sizeof(socket_t));
    147178                break;
    148179        default:
    … …  
    150181        }
    151182
    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;
     183        socket_t *socket = (socket_t *)fp->exinf;
     184        socket->family = family;
     185        socket->type = type;
     186        socket->protocol = protocol;
     187        socket->flags = flags;
    160188
    161189        return fp->fd;
    … …  
    167195        if (fp == NULL)
    168196                return -EBADF;
    169         if (fp->psock->family != addr->sa_family)
     197        socket_t *socket = (socket_t *)fp->exinf;
     198        if (socket->family != addr->sa_family)
    170199                return -EINVAL;
    171200
    … …  
    177206                }
    178207                struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
    179                 memcpy(&fp->psock->laddr4, addr, len);
    180                 switch (fp->psock->type) {
     208                memcpy(&socket->laddr4, addr, len);
     209                switch (socket->type) {
    181210                case SOCK_STREAM: {
    182211                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    … …  
    184213                                return -ENOMEM;
    185214
    186                         fp->psock->buf_size = 512 + 512;
    187                         fp->psock->buf = malloc(fp->psock->buf_size);
     215                        socket->buf_size = 512 + 512;
     216                        socket->buf = malloc(socket->buf_size);
    188217#ifdef _DEBUG
    189                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     218                        memset(socket->buf, 0, socket->buf_size);
    190219#endif
    191                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     220                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    192221                        ret = tcp_cre_cep(cepid, &ccep);
    193222                        if (ret != E_OK) {
    … …  
    196225                        }
    197226                        fp->handle = cepid;
    198                         fp->psock->cepid = cepid;
     227                        socket->cepid = cepid;
    199228                        break;
    200229                }
    … …  
    211240                        }
    212241                        fp->handle = cepid;
    213                         fp->psock->cepid = cepid;
     242                        socket->cepid = cepid;
    214243                        break;
    215244                }
    … …  
    223252                        return -EINVAL;
    224253                }
    225                 memcpy(&fp->psock->laddr4, addr, len);
     254                memcpy(&socket->laddr4, addr, len);
    226255                break;
    227256        }
    … …  
    236265        if (fp == NULL)
    237266                return -EBADF;
    238         if (fp->psock->type != SOCK_STREAM)
     267        socket_t *socket = (socket_t *)fp->exinf;
     268        if (socket->type != SOCK_STREAM)
    239269                return -EINVAL;
    240270
    241         fp->psock->backlog = backlog;
     271        socket->backlog = backlog;
    242272
    243273        ER ret;
    244         switch (fp->psock->family) {
     274        switch (socket->family) {
    245275        case AF_INET: {
    246276                ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
    … …  
    248278                        return -ENOMEM;
    249279
    250                 struct sockaddr_in *laddr = &fp->psock->laddr4;
     280                struct sockaddr_in *laddr = &socket->laddr4;
    251281                T_TCP_CREP crep = { 0, {ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port)} };
    252282                ret = tcp_cre_rep(repid, &crep);
    … …  
    255285                        return -ENOMEM;
    256286                }
    257                 fp->psock->repid = repid;
     287                socket->repid = repid;
    258288                break;
    259289        }
    … …  
    271301        if (fp == NULL)
    272302                return -EBADF;
    273         if (fp->psock->type != SOCK_STREAM)
     303        socket_t *socket = (socket_t *)fp->exinf;
     304        if (socket->type != SOCK_STREAM)
    274305                return -EINVAL;
    275306
    276307        ER ret;
    277         switch (fp->psock->family) {
     308        switch (socket->family) {
    278309        case AF_INET: {
    279310                if (len < 8) {
    280311                        return -EINVAL;
    281312                }
    282                 if (fp->psock->cepid == 0) {
     313                if (socket->cepid == 0) {
    283314                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    284315                        if (cepid < 0)
    285316                                return -ENOMEM;
    286317
    287                         fp->psock->buf_size = 512 + 512;
    288                         fp->psock->buf = malloc(fp->psock->buf_size);
     318                        socket->buf_size = 512 + 512;
     319                        socket->buf = malloc(socket->buf_size);
    289320#ifdef _DEBUG
    290                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     321                        memset(socket->buf, 0, socket->buf_size);
    291322#endif
    292                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     323                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    293324                        ret = tcp_cre_cep(cepid, &ccep);
    294325                        if (ret != E_OK) {
    … …  
    297328                        }
    298329                        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;
     330                        socket->cepid = cepid;
     331                }
     332                struct sockaddr_in *laddr = &socket->laddr4;
     333                struct sockaddr_in *raddr = &socket->raddr4;
    303334                memset(raddr, 0, sizeof(*raddr));
    304335                memcpy(raddr, addr, len);
    305336                T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
    306337                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);
     338                ret = tcp_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
    308339                if (ret < 0) {
    309340                        return -EHOSTUNREACH;
    … …  
    324355        if (lfp == NULL)
    325356                return -EBADF;
    326         if (lfp->psock->type != SOCK_STREAM)
     357        if (((socket_t *)lfp->exinf)->type != SOCK_STREAM)
    327358                return -EINVAL;
    328359
    329         SOCKET *fp = new_tcp_fd(0);
    330         if (fp == NULL) {
     360        SOCKET *fp = new_fp(&IO_TYPE_TCP, 0, 0);
     361        if (fp == NULL)
    331362                return -ENOMEM;
    332         }
    333 
    334         memcpy(fp->psock, lfp->psock, offsetof(socket_t, buf_size));
     363
     364        fp->exinf = malloc(sizeof(socket_t));
     365        memset(fp->exinf, 0, sizeof(socket_t));
     366
     367        memcpy(fp->exinf, lfp->exinf, offsetof(socket_t, buf_size));
    335368
    336369        ER ret;
    337         switch (fp->psock->family) {
     370        socket_t *socket = (socket_t *)fp->exinf;
     371        switch (socket->family) {
    338372        case AF_INET: {
    339373                ID cepid;
    340                 if (fp->psock->cepid == 0) {
     374                if (socket->cepid == 0) {
    341375                        cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    342376                        if (cepid < 0)
    343377                                return -ENOMEM;
    344378
    345                         fp->psock->buf_size = 512 + 512;
    346                         fp->psock->buf = malloc(fp->psock->buf_size);
     379                        socket->buf_size = 512 + 512;
     380                        socket->buf = malloc(socket->buf_size);
    347381#ifdef _DEBUG
    348                         memset(fp->psock->buf, 0, fp->psock->buf_size);
     382                        memset(socket->buf, 0, socket->buf_size);
    349383#endif
    350                         T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
     384                        T_TCP_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp_callback };
    351385                        ret = tcp_cre_cep(cepid, &ccep);
    352386                        if (ret != E_OK) {
    … …  
    355389                        }
    356390                        fp->handle = cepid;
    357                         fp->psock->cepid = cepid;
     391                        socket->cepid = cepid;
    358392                }
    359393                else {
    360                         cepid = lfp->psock->cepid;
     394                        cepid = ((socket_t *)lfp->exinf)->cepid;
    361395                        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;
     396                        lfp->handle = tmax_tcp_cepid + ((socket_t *)lfp->exinf)->repid;
     397                        ((socket_t *)lfp->exinf)->cepid = 0;
     398                        ((socket_t *)lfp->exinf)->buf_size = 0;
     399                        ((socket_t *)lfp->exinf)->buf = 0;
    366400                }
    367401                T_IPV4EP rep = { 0, 0 };
    368                 ret = tcp_acp_cep(fp->psock->cepid, fp->psock->repid, &rep, TMO_FEVR);
     402                ret = tcp_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
    369403                if (ret < 0) {
    370404                        return -ENOMEM;
    371405                }
    372                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     406                struct sockaddr_in *raddr = &socket->raddr4;
    373407                memset(raddr, 0, sizeof(*raddr));
    374408                raddr->sin_family = AF_INET;
    … …  
    387421                        return -EINVAL;
    388422                }
    389                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     423                struct sockaddr_in *raddr = &socket->raddr4;
    390424                if (sz > sizeof(*raddr))
    391425                        sz = sizeof(*raddr);
    … …  
    405439
    406440        int ret = 0;
    407         switch (fp->psock->family) {
     441        socket_t *socket = (socket_t *)fp->exinf;
     442        switch (socket->family) {
    408443        case AF_INET: {
    409                 switch (fp->psock->type) {
     444                switch (socket->type) {
    410445                case SOCK_STREAM: {
    411446                        if ((addr != NULL) || (alen != 0)) {
    … …  
    414449
    415450                        if (flags & MSG_OOB) {
    416                                 ret = tcp_snd_oob(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     451                                ret = tcp_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    417452                                if (ret < 0) {
    418453                                        return -ECOMM;
    … …  
    421456                        else {
    422457                                for (;;) {
    423                                         ret = tcp_snd_dat(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     458                                        ret = tcp_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    424459                                        if (ret < 0) {
    425460                                                if (ret == E_TMOUT)
    … …  
    440475                                return -EINVAL;
    441476                        }
    442                         struct sockaddr_in *raddr = &fp->psock->raddr4;
     477                        struct sockaddr_in *raddr = &socket->raddr4;
    443478                        memset(raddr, 0, sizeof(*raddr));
    444479                        memcpy(raddr, addr, sz);
    445480                        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);
     481                        ret = udp_snd_dat(socket->cepid, &rep, (void *)buf, len,
     482                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
    448483                        if (ret < 0) {
    449484                                return (ret == E_TMOUT) ? -ETIME : -ECOMM;
    … …  
    476511
    477512        int ret = 0;
    478         switch (fp->psock->family) {
     513        socket_t *socket = (socket_t *)fp->exinf;
     514        switch (socket->family) {
    479515        case AF_INET: {
    480                 switch (fp->psock->type) {
     516                switch (socket->type) {
    481517                case SOCK_STREAM: {
    482518                        if (flags & MSG_OOB) {
    483                                 ret = tcp_rcv_oob(fp->psock->cepid, buf, len);
     519                                ret = tcp_rcv_oob(socket->cepid, buf, len);
    484520                                if (ret < 0) {
    485521                                        syslog(LOG_ERROR, "tcp_rcv_oob => %d", ret);
    … …  
    489525                        else {
    490526                                int rsz, tmp;
    491                                 if (fp->psock->input == NULL) {
     527                                if (socket->input == NULL) {
    492528                                        ret = wai_sem(SEM_FILEDESC);
    493529                                        if (ret < 0) {
    494530                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    495531                                        }
    496                                         fp->psock->len = 0;
     532                                        socket->len = 0;
    497533                                        ret = sig_sem(SEM_FILEDESC);
    498534                                        if (ret < 0) {
    499535                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
    500536                                        }
    501                                         ret = tcp_rcv_buf(fp->psock->cepid, &fp->psock->input, TMO_FEVR);
     537                                        ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
    502538                                        if (ret < 0) {
    503539                                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
    … …  
    507543                                }
    508544                                else
    509                                         rsz = fp->psock->len;
     545                                        rsz = socket->len;
    510546                                tmp = rsz;
    511547                                if (rsz > len)
    512548                                        rsz = len;
    513549                                if (rsz >= 0) {
    514                                         memcpy(buf, fp->psock->input, rsz);
     550                                        memcpy(buf, socket->input, rsz);
    515551                                        ret = wai_sem(SEM_FILEDESC);
    516552                                        if (ret < 0) {
    517553                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    518554                                        }
    519                                         fp->psock->len = tmp - rsz;
     555                                        socket->len = tmp - rsz;
    520556                                        ret = sig_sem(SEM_FILEDESC);
    521557                                        if (ret < 0) {
    … …  
    523559                                        }
    524560                                        if (tmp - rsz == 0) {
    525                                                 fp->psock->input = NULL;
     561                                                socket->input = NULL;
    526562                                        }
    527563                                        else
    528                                                 fp->psock->input = (void *)&((uint8_t *)fp->psock->input)[rsz];
    529                                         ret = tcp_rel_buf(fp->psock->cepid, rsz);
     564                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     565                                        ret = tcp_rel_buf(socket->cepid, rsz);
    530566                                        if ((ret != E_OBJ) && (ret < 0)) {
    531567                                                syslog(LOG_ERROR, "tcp_rel_buf => %d", ret);
    … …  
    538574                }
    539575                case SOCK_DGRAM: {
    540                         struct sockaddr_in *raddr = &fp->psock->raddr4;
     576                        struct sockaddr_in *raddr = &socket->raddr4;
    541577                        int rsz;
    542578                        ret = wai_sem(SEM_FILEDESC);
    … …  
    544580                                syslog(LOG_ERROR, "wai_sem => %d", ret);
    545581                        }
    546                         T_NET_BUF *input = fp->psock->input;
     582                        T_NET_BUF *input = socket->input;
    547583                        if (input == NULL) {
    548584                                ret = sig_sem(SEM_FILEDESC);
    … …  
    552588
    553589                                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);
     590                                ret = udp_rcv_dat(socket->cepid, &rep, buf, len,
     591                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
    556592                                if (ret < 0) {
    557                                         syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
     593                                        if ((socket->flags & O_NONBLOCK) == 0)
     594                                                syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
    558595                                        return (ret == E_TMOUT) ? -ETIME : -ECOMM;
    559596                                }
    … …  
    565602                                        }
    566603                                        int sz = *alen;
    567                                         memset(raddr, 0, sizeof(fp->psock->raddr4));
     604                                        memset(raddr, 0, sizeof(socket->raddr4));
    568605                                        raddr->sin_family = AF_INET;
    569606                                        raddr->sin_port = htons(rep.portno);
    570607                                        raddr->sin_addr.s_addr = htonl(rep.ipaddr);
    571                                         if (sz > sizeof(fp->psock->raddr4))
    572                                                 sz = sizeof(fp->psock->raddr4);
     608                                        if (sz > sizeof(socket->raddr4))
     609                                                sz = sizeof(socket->raddr4);
    573610                                        memcpy(addr, raddr, sz);
    574611                                        *alen = sz;
    … …  
    580617                        }
    581618                        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;
     619                                rsz = socket->len;
     620                                void *pbuf = socket->buf;
     621                                socket->input = NULL;
     622                                socket->len = 0;
     623                                socket->buf = NULL;
    587624                                if ((addr != NULL) && (alen != NULL)) {
    588625                                        int sz = *alen;
    589                                         if (sz > sizeof(fp->psock->raddr4))
    590                                                 sz = sizeof(fp->psock->raddr4);
     626                                        if (sz > sizeof(socket->raddr4))
     627                                                sz = sizeof(socket->raddr4);
    591628                                        memcpy(addr, raddr, sz);
    592629                                        *alen = sz;
    … …  
    632669
    633670        ER ret;
    634         switch (fp->psock->family) {
     671        socket_t *socket = (socket_t *)fp->exinf;
     672        switch (socket->family) {
    635673        case AF_INET: {
    636                 switch (fp->psock->type) {
     674                switch (socket->type) {
    637675                case SOCK_STREAM: {
    638                         ret = tcp_sht_cep(fp->psock->cepid);
     676                        ret = tcp_sht_cep(socket->cepid);
    639677                        if (ret < 0) {
    640678                                return -ECOMM;
    … …  
    661699
    662700        ER ret;
    663         switch (fp->psock->family) {
     701        socket_t *socket = (socket_t *)fp->exinf;
     702        switch (socket->family) {
    664703        case AF_INET: {
    665                 switch (fp->psock->type) {
     704                switch (socket->type) {
    666705                case SOCK_STREAM: {
    667706                        switch (level) {
    … …  
    669708                                switch (optname) {
    670709                                case SO_REUSEADDR:
    671                                         if (fp->psock->flags & SO_REUSEADDR) {
     710                                        if (socket->flags & SO_REUSEADDR) {
    672711                                                *(bool *)optval = true;
    673712                                        }
    … …  
    677716                                        break;
    678717                                case SO_KEEPALIVE:
    679                                         if (fp->psock->flags & SO_KEEPALIVE) {
     718                                        if (socket->flags & SO_KEEPALIVE) {
    680719                                                *(bool *)optval = true;
    681720                                        }
    … …  
    692731                                break;
    693732                        case IPPROTO_TCP:
    694                                 ret = tcp_get_opt(fp->psock->cepid, optname, (void *)optval, *optlen);
     733                                ret = tcp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    695734                                if (ret < 0) {
    696735                                        return -EINVAL;
    … …  
    706745                        switch (level) {
    707746                        case IPPROTO_UDP:
    708                                 ret = udp_get_opt(fp->psock->cepid, optname, (void *)optval, *optlen);
     747                                ret = udp_get_opt(socket->cepid, optname, (void *)optval, *optlen);
    709748                                if (ret < 0) {
    710749                                        return -EINVAL;
    … …  
    736775
    737776        ER ret;
    738         switch (fp->psock->family) {
     777        socket_t *socket = (socket_t *)fp->exinf;
     778        switch (socket->family) {
    739779        case AF_INET: {
    740                 switch (fp->psock->type) {
     780                switch (socket->type) {
    741781                case SOCK_STREAM: {
    742782                        switch (level){
    … …  
    745785                                case SO_REUSEADDR:
    746786                                        if (*(bool *)optval) {
    747                                                 fp->psock->flags |= SO_REUSEADDR;
     787                                                socket->flags |= SO_REUSEADDR;
    748788                                        }
    749789                                        else {
    750                                                 fp->psock->flags &= ~SO_REUSEADDR;
     790                                                socket->flags &= ~SO_REUSEADDR;
    751791                                        }
    752792                                        break;
    753793                                case SO_KEEPALIVE:
    754794                                        if (*(bool *)optval) {
    755                                                 fp->psock->flags |= SO_KEEPALIVE;
     795                                                socket->flags |= SO_KEEPALIVE;
    756796                                        }
    757797                                        else {
    758                                                 fp->psock->flags &= ~SO_KEEPALIVE;
     798                                                socket->flags &= ~SO_KEEPALIVE;
    759799                                        }
    760800                                        break;
    … …  
    764804                                break;
    765805                        case IPPROTO_TCP:
    766                                 ret = tcp_set_opt(fp->psock->cepid, optname, (void *)optval, optlen);
     806                                ret = tcp_set_opt(socket->cepid, optname, (void *)optval, optlen);
    767807                                if (ret < 0) {
    768808                                        return -EINVAL;
    … …  
    777817                        switch (level){
    778818                        case IPPROTO_UDP:
    779                                 ret = udp_set_opt(fp->psock->cepid, optname, (void *)optval, optlen);
     819                                ret = udp_set_opt(socket->cepid, optname, (void *)optval, optlen);
    780820                                if (ret < 0) {
    781821                                        return -EINVAL;
    … …  
    809849
    810850        socklen_t size = *len;
    811         switch (fp->psock->family) {
     851        socket_t *socket = (socket_t *)fp->exinf;
     852        switch (socket->family) {
    812853        case AF_INET: {
    813                 struct sockaddr_in *raddr = &fp->psock->raddr4;
     854                struct sockaddr_in *raddr = &socket->raddr4;
    814855                *len = sizeof(struct sockaddr_in);
    815856                if (size > sizeof(struct sockaddr_in))
    … …  
    837878
    838879        socklen_t size = *len;
    839         switch (fp->psock->family) {
     880        socket_t *socket = (socket_t *)fp->exinf;
     881        switch (socket->family) {
    840882        case AF_INET: {
    841883                const T_IN4_ADDR *laddr4 = in4_get_ifaddr(0);
    … …  
    843885                laddr.sin_family = AF_INET;
    844886                laddr.sin_addr.s_addr = htonl(*laddr4);
    845                 laddr.sin_port = fp->psock->laddr4.sin_port;
     887                laddr.sin_port = socket->laddr4.sin_port;
    846888                memset(&laddr.sin_zero, 0, sizeof(laddr.sin_zero));
    847889                *len = sizeof(struct sockaddr_in);
    … …  
    859901}
    860902
    861 int tcp_fd_close(struct _IO_FILE *fp)
     903int tcp_fd_close(struct SHELL_FILE *fp)
    862904{
    863905        ER ret, ret2;
    864906
    865         switch (fp->psock->family) {
     907        socket_t *socket = (socket_t *)fp->exinf;
     908        switch (socket->family) {
    866909        case AF_INET: {
    867                 if (fp->psock->cepid != 0) {
    868                         ID cepid = fp->psock->cepid;
     910                if (socket->cepid != 0) {
     911                        ID cepid = socket->cepid;
    869912                        ret = tcp_sht_cep(cepid);
    870913                        if (ret < 0) {
    871914                                //return -1;
    872915                        }
    873                         ret = tcp_cls_cep(cepid, (fp->psock->repid != 0) ? 0 : SOCKET_TIMEOUT);
     916                        ret = tcp_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
    874917                        ret2 = tcp_del_cep(cepid);
    875                         free(fp->psock->buf);
    876                         fp->psock->buf = NULL;
    877                         delete_tcp_fd(cepid);
     918                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
    878919                        delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    879920                        if ((ret < 0) || (ret2 < 0)) {
    … …  
    881922                        }
    882923                }
    883                 else if (fp->psock->repid != 0) {
    884                         ID repid = fp->psock->repid;
     924                else if (socket->repid != 0) {
     925                        ID repid = socket->repid;
    885926                        ret = tcp_del_rep(repid);
    886                         free(fp->psock->buf);
    887                         fp->psock->buf = NULL;
    888                         delete_tcp_fd(tmax_tcp_cepid + repid);
     927                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + repid);
    889928                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    890929                        if (ret < 0) {
    … …  
    893932                }
    894933                else {
    895                         free(fp->psock->buf);
    896                         fp->psock->buf = NULL;
    897934                        return -EINVAL;
    898935                }
    … …  
    907944}
    908945
    909 size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
     946size_t tcp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
    910947{
    911948        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    912949}
    913950
    914 size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
     951size_t tcp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
    915952{
    916953        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    917954}
    918955
    919 off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     956off_t tcp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    920957{
    921958        return -EPERM;
    922959}
    923960
    924 int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     961int tcp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
    925962{
    926963        return -EINVAL;
    927964}
    928965
    929 int udp_fd_close(struct _IO_FILE *fp)
     966bool_t tcp_fd_readable(struct SHELL_FILE *fp)
     967{
     968        ER ret;
     969
     970        socket_t *socket = (socket_t *)fp->exinf;
     971        if (socket->cepid != 0) {
     972                if (socket->len == 0) {
     973                        ret = tcp_rcv_buf(socket->cepid, &socket->input, TMO_NBLK);
     974                        if ((ret != E_WBLK) && (ret != E_OBJ) && (ret < 0)) {
     975                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     976                                //return ret;
     977                        }
     978                        if (ret > 0) {
     979                                ret = wai_sem(SEM_FILEDESC);
     980                                if (ret < 0) {
     981                                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     982                                }
     983                                socket->len += ret;
     984                                ret = sig_sem(SEM_FILEDESC);
     985                                if (ret < 0) {
     986                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     987                                }
     988                        }
     989                }
     990                else ret = 1;
     991                if (ret > 0) {
     992                        return true;
     993                }
     994        }
     995
     996        return false;
     997}
     998
     999void tcp_fd_delete(struct SHELL_FILE *fp)
     1000{
     1001        socket_t *socket = (socket_t *)fp->exinf;
     1002        free(socket->buf);
     1003        socket->buf = NULL;
     1004        free(fp->exinf);
     1005        fp->exinf = NULL;
     1006}
     1007
     1008ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
     1009{
     1010        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1011        FLGPTN flgptn = 0;
     1012        ER ret;
     1013        int len;
     1014
     1015        if (fp == NULL)
     1016                return E_PAR;
     1017
     1018        int fd = fp->fd;
     1019        FD_SET(fd, (fd_set *)&flgptn);
     1020
     1021        switch (fncd) {
     1022        case TFN_TCP_RCV_BUF:
     1023                len = *(int *)p_parblk;
     1024                if ((len <= 0) || (fp->exinf == NULL))
     1025                        return E_OK;
     1026
     1027                ret = wai_sem(SEM_FILEDESC);
     1028                if (ret < 0) {
     1029                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1030                }
     1031                socket_t *socket = (socket_t *)fp->exinf;
     1032                socket->len += len;
     1033                ret = sig_sem(SEM_FILEDESC);
     1034                if (ret < 0) {
     1035                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1036                }
     1037
     1038                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1039
     1040                set_flg(FLG_SELECT_WAIT, flgptn);
     1041                return E_OK;
     1042
     1043        case TFN_TCP_RCV_DAT:
     1044                len = *(int *)p_parblk;
     1045                if ((len <= 0) || (fp->exinf == NULL))
     1046                        return E_OK;
     1047
     1048                ret = wai_sem(SEM_FILEDESC);
     1049                if (ret < 0) {
     1050                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1051                }
     1052                socket->len += len;
     1053                ret = sig_sem(SEM_FILEDESC);
     1054                if (ret < 0) {
     1055                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1056                }
     1057
     1058                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1059
     1060                set_flg(FLG_SELECT_WAIT, flgptn);
     1061                return E_OK;
     1062
     1063        case TFN_TCP_SND_DAT:
     1064                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1065
     1066                set_flg(FLG_SELECT_WAIT, flgptn);
     1067                return E_OK;
     1068
     1069        case TFN_TCP_CAN_CEP:
     1070                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1071
     1072                set_flg(FLG_SELECT_WAIT, flgptn);
     1073                return E_OK;
     1074
     1075        case TFN_TCP_DEL_REP:
     1076                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1077                return E_OK;
     1078
     1079        case TFN_TCP_DEL_CEP:
     1080                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1081                return E_OK;
     1082
     1083        default:
     1084                return E_OK;
     1085        }
     1086}
     1087
     1088int udp_fd_close(struct SHELL_FILE *fp)
    9301089{
    9311090        ER ret;
    9321091        ID cepid;
    9331092
    934         switch (fp->psock->family) {
     1093        socket_t *socket = (socket_t *)fp->exinf;
     1094        switch (socket->family) {
    9351095        case AF_INET: {
    936                 cepid = fp->psock->cepid;
     1096                cepid = socket->cepid;
    9371097                ret = udp_del_cep(cepid);
    938                 //free(fp->psock->buf);
    939                 //fp->psock->buf = NULL;
    940                 delete_udp_fd(cepid);
     1098                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
    9411099                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    9421100                if (ret < 0) {
    … …  
    9531111}
    9541112
    955 size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
     1113size_t udp_fd_read(struct SHELL_FILE *fp, unsigned char *dst, size_t dstsz)
    9561114{
    9571115        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    9581116}
    9591117
    960 size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
     1118size_t udp_fd_write(struct SHELL_FILE *fp, const unsigned char *src, size_t srcsz)
    9611119{
    9621120        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    9631121}
    9641122
    965 off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
     1123off_t udp_fd_seek(struct SHELL_FILE *fp, off_t ofs, int org)
    9661124{
    9671125        return -EPERM;
    9681126}
    9691127
    970 int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     1128int udp_fd_ioctl(struct SHELL_FILE *fp, int req, void *arg)
    9711129{
    9721130        return -EINVAL;
     1131}
     1132
     1133bool_t udp_fd_readable(struct SHELL_FILE *fp)
     1134{
     1135        socket_t *socket = (socket_t *)fp->exinf;
     1136        if (socket->cepid != 0) {
     1137                if (socket->input != NULL) {
     1138                        return true;
     1139                }
     1140        }
     1141
     1142        return false;
     1143}
     1144
     1145void udp_fd_delete(struct SHELL_FILE *fp)
     1146{
     1147        //socket_t *socket = (socket_t *)fp->exinf;
     1148        //free(socket->buf);
     1149        //socket->buf = NULL;
     1150        free(fp->exinf);
     1151        fp->exinf = NULL;
     1152}
     1153
     1154ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk)
     1155{
     1156        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     1157        FLGPTN flgptn = 0;
     1158        int len;
     1159
     1160        if (fp == NULL)
     1161                return E_PAR;
     1162
     1163        int fd = fp->fd;
     1164        FD_SET(fd, (fd_set *)&flgptn);
     1165
     1166        switch (fncd) {
     1167        case TEV_UDP_RCV_DAT:
     1168        {
     1169                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     1170                len = udppara->len;
     1171                if ((len <= 0) || (fp->exinf == NULL))
     1172                        return E_OK;
     1173
     1174                ER ret = wai_sem(SEM_FILEDESC);
     1175                if (ret < 0) {
     1176                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1177                }
     1178                socket_t *socket = (socket_t *)fp->exinf;
     1179                socket->len = len;
     1180                if (socket->input != NULL) {
     1181                        ret = rel_net_buf(socket->input);
     1182                        if (ret < 0) {
     1183                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1184                        }
     1185                }
     1186                socket->input = udppara->input;
     1187                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     1188                memset(&socket->raddr4, 0, sizeof(socket->raddr4));
     1189                socket->raddr4.sin_family = AF_INET;
     1190                socket->raddr4.sin_port = htons(udppara->rep4.portno);
     1191                socket->raddr4.sin_addr.s_addr = htonl(udppara->rep4.ipaddr);
     1192                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     1193                ret = sig_sem(SEM_FILEDESC);
     1194                if (ret < 0) {
     1195                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1196                }
     1197
     1198                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1199
     1200                set_flg(FLG_SELECT_WAIT, flgptn);
     1201                return E_OK;
     1202        }
     1203        case TFN_UDP_CRE_CEP:
     1204                return E_OK;
     1205
     1206        case TFN_UDP_RCV_DAT:
     1207                len = *(int *)p_parblk;
     1208                if ((len <= 0) || (fp->exinf == NULL))
     1209                        return E_OK;
     1210
     1211                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1212
     1213                set_flg(FLG_SELECT_WAIT, flgptn);
     1214                return E_OK;
     1215
     1216        case TFN_UDP_SND_DAT:
     1217                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1218
     1219                set_flg(FLG_SELECT_WAIT, flgptn);
     1220                return E_OK;
     1221
     1222        case TFN_UDP_CAN_CEP:
     1223                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1224
     1225                set_flg(FLG_SELECT_WAIT, flgptn);
     1226                return E_OK;
     1227
     1228        case TFN_UDP_DEL_CEP:
     1229                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1230                return E_OK;
     1231
     1232        default:
     1233                return E_OK;
     1234        }
    9731235}
    9741236
Note: See TracChangeset for help on using the changeset viewer.