Ignore:
Timestamp:
Feb 1, 2019, 9:57:09 PM (5 years ago)
Author:
coas-nagasima
Message:

TINETとSocket APIなどを更新

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r337 r364  
    4242#include <sil.h>
    4343#include "syssvc/syslog.h"
     44#include <tinet_defs.h>
    4445#include <tinet_config.h>
     46#include <net/net.h>
     47#include <net/net_endian.h>
    4548#include <netinet/in.h>
    4649#include <netinet/in_itron.h>
    … …  
    5356#include <net/if_var.h>
    5457#include <netinet/udp_var.h>
     58#include <net/net_buf.h>
    5559//#include <netinet/tcp_var.h>
    5660#include <netapp/resolver.h>
    … …  
    5862#include "ff.h"
    5963#include "socket_stub.h"
     64#include "kernel_cfg.h"
    6065
    6166#define SOCKET_TIMEOUT 2000000
    … …  
    181186                        fp->psock->buf_size = 512 + 512;
    182187                        fp->psock->buf = malloc(fp->psock->buf_size);
     188#ifdef _DEBUG
     189                        memset(fp->psock->buf, 0, fp->psock->buf_size);
     190#endif
    183191                        T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
    184192                        ret = tcp_cre_cep(cepid, &ccep);
    … …  
    279287                        fp->psock->buf_size = 512 + 512;
    280288                        fp->psock->buf = malloc(fp->psock->buf_size);
     289#ifdef _DEBUG
     290                        memset(fp->psock->buf, 0, fp->psock->buf_size);
     291#endif
    281292                        T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
    282293                        ret = tcp_cre_cep(cepid, &ccep);
    … …  
    298309                        return -EHOSTUNREACH;
    299310                }
    300                 fp->writable = 1;
    301311                break;
    302312        }
    … …  
    322332        }
    323333
    324         memcpy(&fp->psock, &lfp->psock, sizeof(fp->psock));
     334        memcpy(fp->psock, lfp->psock, offsetof(socket_t, buf_size));
    325335
    326336        ER ret;
    … …  
    335345                        fp->psock->buf_size = 512 + 512;
    336346                        fp->psock->buf = malloc(fp->psock->buf_size);
     347#ifdef _DEBUG
     348                        memset(fp->psock->buf, 0, fp->psock->buf_size);
     349#endif
    337350                        T_TCP_CCEP ccep = { 0, fp->psock->buf, 512, &fp->psock->buf[512], 512, (FP)socket_tcp_callback };
    338351                        ret = tcp_cre_cep(cepid, &ccep);
    … …  
    346359                else {
    347360                        cepid = lfp->psock->cepid;
     361                        fp->handle = cepid;
    348362                        lfp->handle = tmax_tcp_cepid + lfp->psock->repid;
    349363                        lfp->psock->cepid = 0;
    … …  
    356370                        return -ENOMEM;
    357371                }
    358                 fp->writable = 1;
    359372                struct sockaddr_in *raddr = &fp->psock->raddr4;
    360373                memset(raddr, 0, sizeof(*raddr));
    … …  
    384397}
    385398
    386 ssize_t shell_send(int fd, const void *buf, size_t len, int flags)
     399ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
    387400{
    388401        SOCKET *fp = fd_to_fp(fd);
    … …  
    396409                switch (fp->psock->type) {
    397410                case SOCK_STREAM: {
    398                         fp->writable = 0;
     411                        if ((addr != NULL) || (alen != 0)) {
     412                                return -EISCONN;
     413                        }
     414
    399415                        if (flags & MSG_OOB) {
    400416                                ret = tcp_snd_oob(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    … …  
    404420                        }
    405421                        else {
    406                                 ret = tcp_snd_dat(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    407                                 if (ret < 0) {
    408                                         return -ECOMM;
    409                                 }
    410                         }
    411                         break;
    412                 }
    413                 case SOCK_DGRAM: {
    414                         return -EINVAL;
    415                 }
    416                 }
    417                 break;
    418         }
    419         case AF_INET6: {
    420                 return -EAFNOSUPPORT;
    421         }
    422         }
    423 
    424         return ret;
    425 }
    426 
    427 ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
    428 {
    429         SOCKET *fp = fd_to_fp(fd);
    430         if (fp == NULL) {
    431                 return -EBADF;
    432         }
    433 
    434         int ret = 0;
    435         switch (fp->psock->family) {
    436         case AF_INET: {
    437                 switch (fp->psock->type) {
    438                 case SOCK_STREAM: {
    439                         if ((addr != NULL) && (alen != 0)) {
    440                                 return -EINVAL;
    441                         }
    442 
    443                         fp->writable = 0;
    444                         if (flags & MSG_OOB) {
    445                                 ret = tcp_snd_oob(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    446                                 if (ret < 0) {
    447                                         return -ECOMM;
    448                                 }
    449                         }
    450                         else {
    451                                 ret = tcp_snd_dat(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
    452                                 if (ret < 0) {
    453                                         return -ECOMM;
    454                                 }
     422                                for (;;) {
     423                                        ret = tcp_snd_dat(fp->psock->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     424                                        if (ret < 0) {
     425                                                if (ret == E_TMOUT)
     426                                                        return -ETIME;
     427                                                return -ECOMM;
     428                                        }
     429                                        len -= ret;
     430                                        if (len <= 0)
     431                                                break;
     432                                        buf = (const void *)&((uint8_t *)buf)[ret];
     433                                }
    455434                        }
    456435                        break;
    … …  
    458437                case SOCK_DGRAM: {
    459438                        int sz = alen;
    460                         if (sz < 8) {
     439                        if ((addr == NULL) || (sz < 8)) {
    461440                                return -EINVAL;
    462441                        }
    … …  
    465444                        memcpy(raddr, addr, sz);
    466445                        T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    467                         fp->writable = 0;
    468446                        ret = udp_snd_dat(fp->psock->cepid, &rep, (void *)buf, len,
    469                                 (fp->psock->flags & O_NONBLOCK) ? 0 : SOCKET_TIMEOUT);
     447                                (fp->psock->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
    470448                        if (ret < 0) {
    471                                 return -ECOMM;
     449                                return (ret == E_TMOUT) ? -ETIME : -ECOMM;
    472450                        }
    473451                        break;
    … …  
    490468}
    491469
    492 ssize_t shell_recv(int fd, void *buf, size_t len, int flags)
     470ssize_t shell_recvfrom(int fd, void *__restrict buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
    493471{
    494472        SOCKET *fp = fd_to_fp(fd);
    … …  
    505483                                ret = tcp_rcv_oob(fp->psock->cepid, buf, len);
    506484                                if (ret < 0) {
     485                                        syslog(LOG_ERROR, "tcp_rcv_oob => %d", ret);
    507486                                        return -ECOMM;
    508487                                }
    509488                        }
    510489                        else {
    511                                 ret = tcp_rcv_dat(fp->psock->cepid, buf, len, TMO_FEVR);
     490                                int rsz, tmp;
     491                                if (fp->psock->input == NULL) {
     492                                        ret = wai_sem(SEM_FILEDESC);
     493                                        if (ret < 0) {
     494                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     495                                        }
     496                                        fp->psock->len = 0;
     497                                        ret = sig_sem(SEM_FILEDESC);
     498                                        if (ret < 0) {
     499                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     500                                        }
     501                                        ret = tcp_rcv_buf(fp->psock->cepid, &fp->psock->input, TMO_FEVR);
     502                                        if (ret < 0) {
     503                                                syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     504                                                return -ECOMM;
     505                                        }
     506                                        rsz = ret;
     507                                }
     508                                else
     509                                        rsz = fp->psock->len;
     510                                tmp = rsz;
     511                                if (rsz > len)
     512                                        rsz = len;
     513                                if (rsz >= 0) {
     514                                        memcpy(buf, fp->psock->input, rsz);
     515                                        ret = wai_sem(SEM_FILEDESC);
     516                                        if (ret < 0) {
     517                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     518                                        }
     519                                        fp->psock->len = tmp - rsz;
     520                                        ret = sig_sem(SEM_FILEDESC);
     521                                        if (ret < 0) {
     522                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     523                                        }
     524                                        if (tmp - rsz == 0) {
     525                                                fp->psock->input = NULL;
     526                                        }
     527                                        else
     528                                                fp->psock->input = (void *)&((uint8_t *)fp->psock->input)[rsz];
     529                                        ret = tcp_rel_buf(fp->psock->cepid, rsz);
     530                                        if ((ret != E_OBJ) && (ret < 0)) {
     531                                                syslog(LOG_ERROR, "tcp_rel_buf => %d", ret);
     532                                                //return -ECOMM;
     533                                        }
     534                                }
     535                                ret = rsz;
     536                        }
     537                        break;
     538                }
     539                case SOCK_DGRAM: {
     540                        struct sockaddr_in *raddr = &fp->psock->raddr4;
     541                        int rsz;
     542                        ret = wai_sem(SEM_FILEDESC);
     543                        if (ret < 0) {
     544                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     545                        }
     546                        T_NET_BUF *input = fp->psock->input;
     547                        if (input == NULL) {
     548                                ret = sig_sem(SEM_FILEDESC);
    512549                                if (ret < 0) {
    513                                         return -ECOMM;
    514                                 }
    515                         }
    516                         break;
    517                 }
    518                 case SOCK_DGRAM: {
    519                         T_IPV4EP rep = { 0, 0 };
    520                         ret = udp_rcv_dat(fp->psock->cepid, &rep, buf, len, (fp->psock->flags & O_NONBLOCK) ? 0 : TMO_FEVR);
    521                         if (ret < 0) {
    522                                 return -ECOMM;
    523                         }
    524                 }
    525                 }
    526                 break;
    527         }
    528         case AF_INET6: {
    529                 return -EAFNOSUPPORT;
    530         }
    531         }
    532 
    533         return ret;
    534 }
    535 
    536 ssize_t shell_recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
    537 {
    538         SOCKET *fp = fd_to_fp(fd);
    539         if (fp == NULL) {
    540                 return -EBADF;
    541         }
    542 
    543         int ret = 0;
    544         switch (fp->psock->family) {
    545         case AF_INET: {
    546                 switch (fp->psock->type) {
    547                 case SOCK_STREAM: {
    548                         if (flags & MSG_OOB) {
    549                                 ret = tcp_rcv_oob(fp->psock->cepid, buf, len);
     550                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     551                                }
     552
     553                                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);
    550556                                if (ret < 0) {
    551                                         return -ECOMM;
     557                                        syslog(LOG_ERROR, "udp_rcv_buf => %d", ret);
     558                                        return (ret == E_TMOUT) ? -ETIME : -ECOMM;
     559                                }
     560                                rsz = ret;
     561                                if ((addr != NULL) && (alen != NULL)) {
     562                                        ret = wai_sem(SEM_FILEDESC);
     563                                        if (ret < 0) {
     564                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     565                                        }
     566                                        int sz = *alen;
     567                                        memset(raddr, 0, sizeof(fp->psock->raddr4));
     568                                        raddr->sin_family = AF_INET;
     569                                        raddr->sin_port = htons(rep.portno);
     570                                        raddr->sin_addr.s_addr = htonl(rep.ipaddr);
     571                                        if (sz > sizeof(fp->psock->raddr4))
     572                                                sz = sizeof(fp->psock->raddr4);
     573                                        memcpy(addr, raddr, sz);
     574                                        *alen = sz;
     575                                        ret = sig_sem(SEM_FILEDESC);
     576                                        if (ret < 0) {
     577                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     578                                        }
    552579                                }
    553580                        }
    554581                        else {
    555                                 ret = tcp_rcv_dat(fp->psock->cepid, buf, len, TMO_FEVR);
     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;
     587                                if ((addr != NULL) && (alen != NULL)) {
     588                                        int sz = *alen;
     589                                        if (sz > sizeof(fp->psock->raddr4))
     590                                                sz = sizeof(fp->psock->raddr4);
     591                                        memcpy(addr, raddr, sz);
     592                                        *alen = sz;
     593                                }
     594                                ret = sig_sem(SEM_FILEDESC);
    556595                                if (ret < 0) {
    557                                         return -ECOMM;
    558                                 }
    559                         }
    560                         break;
    561                 }
    562                 case SOCK_DGRAM: {
    563                         T_IPV4EP rep = { 0, 0 };
    564                         ret = udp_rcv_dat(fp->psock->cepid, &rep, buf, len, TMO_FEVR);
    565                         if (ret < 0) {
    566                                 return -ECOMM;
    567                         }
    568                         int sz = *alen;
    569                         struct sockaddr_in raddr;
    570                         memset(&raddr, 0, sizeof(raddr));
    571                         raddr.sin_family = AF_INET;
    572                         raddr.sin_port = htons(rep.portno);
    573                         raddr.sin_addr.s_addr = htonl(rep.ipaddr);
    574                         if (sz > sizeof(raddr))
    575                                 sz = sizeof(raddr);
    576                         memcpy(addr, &raddr, sz);
     596                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     597                                }
     598                                if (rsz > len)
     599                                        rsz = len;
     600                                memcpy(buf, pbuf, rsz);
     601                                ret = rel_net_buf(input);
     602                                if (ret < 0) {
     603                                        syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     604                                        //return -ECOMM;
     605                                }
     606                        }
     607                        ret = rsz;
    577608                }
    578609                }
    … …  
    830861int tcp_fd_close(struct _IO_FILE *fp)
    831862{
    832         ER ret;
    833 
    834         free(fp->psock->buf);
    835         fp->psock->buf = NULL;
     863        ER ret, ret2;
    836864
    837865        switch (fp->psock->family) {
    … …  
    844872                        }
    845873                        ret = tcp_cls_cep(cepid, (fp->psock->repid != 0) ? 0 : SOCKET_TIMEOUT);
    846                         if (ret < 0) {
    847                                 //return -1;
    848                         }
    849                         ret = tcp_del_cep(cepid);
     874                        ret2 = tcp_del_cep(cepid);
     875                        free(fp->psock->buf);
     876                        fp->psock->buf = NULL;
    850877                        delete_tcp_fd(cepid);
    851878                        delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    852                         if (ret < 0) {
    853                                 return -EINVAL;
     879                        if ((ret < 0) || (ret2 < 0)) {
     880                                return (ret == E_TMOUT) ? -ETIME : -EINVAL;
    854881                        }
    855882                }
    … …  
    857884                        ID repid = fp->psock->repid;
    858885                        ret = tcp_del_rep(repid);
     886                        free(fp->psock->buf);
     887                        fp->psock->buf = NULL;
    859888                        delete_tcp_fd(tmax_tcp_cepid + repid);
    860889                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    … …  
    864893                }
    865894                else {
     895                        free(fp->psock->buf);
     896                        fp->psock->buf = NULL;
    866897                        return -EINVAL;
    867898                }
    … …  
    878909size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    879910{
    880         return shell_recv(fp->fd, dst, dstsz, 0);
     911        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    881912}
    882913
    883914size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    884915{
    885         return shell_send(fp->fd, src, srcsz, 0);
     916        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    886917}
    887918
    … …  
    901932        ID cepid;
    902933
    903         free(fp->psock->buf);
    904         fp->psock->buf = NULL;
    905 
    906934        switch (fp->psock->family) {
    907935        case AF_INET: {
    908936                cepid = fp->psock->cepid;
    909937                ret = udp_del_cep(cepid);
     938                //free(fp->psock->buf);
     939                //fp->psock->buf = NULL;
    910940                delete_udp_fd(cepid);
    911941                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    … …  
    925955size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    926956{
    927         return shell_recv(fp->fd, dst, dstsz, 0);
     957        return shell_recvfrom(fp->fd, dst, dstsz, 0, NULL, NULL);
    928958}
    929959
    930960size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    931961{
    932         return shell_send(fp->fd, src, srcsz, 0);
     962        return shell_sendto(fp->fd, src, srcsz, 0, NULL, 0);
    933963}
    934964
Note: See TracChangeset for help on using the changeset viewer.