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/fdtable.c

    r359 r364  
    4545#include "target_syssvc.h"
    4646#ifndef NTSHELL_NO_SOCKET
     47#include <tinet_defs.h>
    4748#include <tinet_config.h>
     49#include <net/net.h>
     50#include <net/net_endian.h>
    4851#include <netinet/in.h>
    4952#include <netinet/in_itron.h>
     
    5558#include <net/net.h>
    5659#include <net/if_var.h>
     60#include <netinet/udp.h>
    5761#include <netinet/udp_var.h>
    5862#include <netinet/tcp.h>
    5963#include <netinet/tcp_var.h>
     64#include <net/net_buf.h>
    6065#endif
    6166#include "ff.h"
     
    6974#define IO_TYPE_DIR             3
    7075#define IO_TYPE_TCP             4
    71 #define IO_TYPE_UDP             5
     76#define IO_TYPE_UDP     5
    7277
    7378static struct _IO_FILE fd_table[8 * sizeof(FLGPTN)] = {
     
    8590                        continue;
    8691
     92                memset(fp, 0, sizeof(struct _IO_FILE));
    8793                fp->fd = fd;
    8894                fp->type = type;
     
    280286#endif
    281287
     288void memor(void *dst, void *src, size_t len)
     289{
     290        uint8_t *d = (uint8_t *)dst;
     291        uint8_t *s = (uint8_t *)src;
     292        uint8_t *e = &s[len];
     293
     294        while (s < e) {
     295                *d++ |= *s++;
     296        }
     297}
     298
    282299struct fd_events {
    283300        int count;
     
    304321        }
    305322
    306         memcpy(&evts.readfds, rfds, sizeof(fd_set));
    307         memcpy(&evts.writefds, wfds, sizeof(fd_set));
    308         memcpy(&evts.errorfds, efds, sizeof(fd_set));
     323        if (rfds != NULL)
     324                memcpy(&evts.readfds, rfds, sizeof(fd_set));
     325        else
     326                memset(&evts.readfds, 0, sizeof(fd_set));
     327        if (wfds != NULL)
     328                memcpy(&evts.writefds, wfds, sizeof(fd_set));
     329        else
     330                memset(&evts.writefds, 0, sizeof(fd_set));
     331        if (efds != NULL)
     332                memcpy(&evts.errorfds, efds, sizeof(fd_set));
     333        else
     334                memset(&evts.errorfds, 0, sizeof(fd_set));
    309335        evts.count = 0;
    310336
    311337        ret = shell_get_evts(&evts, tmout);
     338        if (rfds != NULL)
     339                memset(rfds, 0, sizeof(fd_set));
     340        if (wfds != NULL)
     341                memset(wfds, 0, sizeof(fd_set));
     342        if (efds != NULL)
     343                memset(efds, 0, sizeof(fd_set));
    312344        if (ret == E_OK) {
    313                 memcpy(rfds, &evts.readfds, sizeof(fd_set));
    314                 memcpy(wfds, &evts.writefds, sizeof(fd_set));
    315                 memcpy(efds, &evts.errorfds, sizeof(fd_set));
     345                if (rfds != NULL)
     346                        memor(rfds, &evts.readfds, sizeof(fd_set));
     347                if (wfds != NULL)
     348                        memor(wfds, &evts.writefds, sizeof(fd_set));
     349                if (efds != NULL)
     350                        memor(efds, &evts.errorfds, sizeof(fd_set));
    316351                return evts.count;
    317352        }
    318353        if (ret == E_TMOUT) {
    319                 memset(rfds, 0, sizeof(fd_set));
    320                 memset(wfds, 0, sizeof(fd_set));
    321                 memset(efds, 0, sizeof(fd_set));
    322354                return 0;
    323355        }
     
    441473        struct _IO_FILE *fp = tcpid_to_fd(cepid);
    442474        FLGPTN flgptn = 0;
     475        ER ret;
     476        int len;
    443477
    444478        if (fp == NULL)
     
    449483
    450484        switch (fncd) {
     485        case TFN_TCP_RCV_BUF:
     486                len = *(int *)p_parblk;
     487                if (len <= 0)
     488                        return E_OK;
     489
     490                ret = wai_sem(SEM_FILEDESC);
     491                if (ret < 0) {
     492                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     493                }
     494                fp->psock->len += len;
     495                ret = sig_sem(SEM_FILEDESC);
     496                if (ret < 0) {
     497                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     498                }
     499
     500                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     501
     502                set_flg(FLG_SELECT_WAIT, flgptn);
     503                return E_OK;
     504
    451505        case TFN_TCP_RCV_DAT:
     506                len = *(int *)p_parblk;
     507                if (len <= 0)
     508                        return E_OK;
     509
     510                ret = wai_sem(SEM_FILEDESC);
     511                if (ret < 0) {
     512                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     513                }
     514                fp->psock->len += len;
     515                ret = sig_sem(SEM_FILEDESC);
     516                if (ret < 0) {
     517                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     518                }
     519
    452520                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    453521
     
    484552        struct _IO_FILE *fp = udpid_to_fd(cepid);
    485553        FLGPTN flgptn = 0;
     554        int len;
    486555
    487556        if (fp == NULL)
     
    492561
    493562        switch (fncd) {
     563        case TEV_UDP_RCV_DAT:
     564        {
     565                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     566                len = udppara->len;
     567                if (len <= 0)
     568                        return E_OK;
     569
     570                ER ret = wai_sem(SEM_FILEDESC);
     571                if (ret < 0) {
     572                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     573                }
     574                fp->psock->len = len;
     575                if (fp->psock->input != NULL) {
     576                        ret = rel_net_buf(fp->psock->input);
     577                        if (ret < 0) {
     578                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     579                        }
     580                }
     581                fp->psock->input = udppara->input;
     582                fp->psock->buf = GET_UDP_SDU(udppara->input, udppara->off);
     583                memset(&fp->psock->raddr4, 0, sizeof(fp->psock->raddr4));
     584                fp->psock->raddr4.sin_family = AF_INET;
     585                fp->psock->raddr4.sin_port = htons(udppara->rep4.portno);
     586                fp->psock->raddr4.sin_addr.s_addr = htonl(udppara->rep4.ipaddr);
     587                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     588                ret = sig_sem(SEM_FILEDESC);
     589                if (ret < 0) {
     590                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     591                }
     592
     593                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     594
     595                set_flg(FLG_SELECT_WAIT, flgptn);
     596                return E_OK;
     597        }
    494598        case TFN_UDP_CRE_CEP:
     599                return E_OK;
     600
    495601        case TFN_UDP_RCV_DAT:
     602                len = *(int *)p_parblk;
     603                if (len <= 0)
     604                        return E_OK;
     605
    496606                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    497607
     
    524634ER shell_get_evts(struct fd_events *evts, TMO tmout)
    525635{
    526         ER ret;
    527         FLGPTN waitptn, flgptn = 0, readfds = 0, writefds = 0;
    528         struct _IO_FILE *fp = NULL;
    529636        int count = 0;
    530 
    531         stdio_update_evts();
     637        SYSTIM prev, now;
     638
     639        get_tim(&prev);
     640
     641        for (;;) {
     642                ER ret;
     643                FLGPTN waitptn, flgptn, readfds = 0, writefds = 0;
     644                struct _IO_FILE *fp = NULL;
     645
     646                stdio_update_evts();
    532647
    533648#ifndef NTSHELL_NO_SOCKET
    534         waitptn = *((FLGPTN *)&evts->errorfds);
     649                waitptn = *((FLGPTN *)&evts->errorfds);
    535650#else
    536         waitptn = *((FLGPTN *)&evts->readfds) | *((FLGPTN *)&evts->errorfds);
     651                waitptn = *((FLGPTN *)&evts->readfds) | *((FLGPTN *)&evts->errorfds);
    537652#endif
    538         for (int fd = 0; fd < fd_table_count; fd++) {
    539                 fp = &fd_table[fd];
     653                for (int fd = 0; fd < fd_table_count; fd++) {
     654                        fp = &fd_table[fd];
    540655
    541656#ifndef NTSHELL_NO_SOCKET
    542                 if (FD_ISSET(fd, &evts->readfds)) {
    543                         if ((fp->type == IO_TYPE_TCP)
    544                                 && (GET_TCP_CEP(fp->psock->cepid)->rwbuf_count > 0)) {
    545                                 FD_SET(fd, (fd_set *)&readfds);
    546                                 count++;
    547                                 if (fp->readevt_w == fp->readevt_r) fp->readevt_r--;
     657                        if (FD_ISSET(fd, &evts->readfds)) {
     658                                if ((fp->type == IO_TYPE_TCP) && (fp->psock->cepid != 0)) {
     659                                        if (fp->psock->len == 0) {
     660                                                ret = tcp_rcv_buf(fp->psock->cepid, &fp->psock->input, TMO_NBLK);
     661                                                if ((ret != E_WBLK) && (ret != E_OBJ) && (ret < 0)) {
     662                                                        syslog(LOG_ERROR, "tcp_rcv_buf => %d", ret);
     663                                                        //return ret;
     664                                                }
     665                                                if (ret > 0) {
     666                                                        ret = wai_sem(SEM_FILEDESC);
     667                                                        if (ret < 0) {
     668                                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     669                                                        }
     670                                                        fp->psock->len += ret;
     671                                                        ret = sig_sem(SEM_FILEDESC);
     672                                                        if (ret < 0) {
     673                                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     674                                                        }
     675                                                }
     676                                        }
     677                                        else ret = 1;
     678                                        if (ret > 0) {
     679                                                FD_SET(fd, (fd_set *)&readfds);
     680                                                count++;
     681                                                if (fp->readevt_w == fp->readevt_r) fp->readevt_r--;
     682                                        }
     683                                }
     684                                else if ((fp->type == IO_TYPE_UDP) && (fp->psock->cepid != 0)) {
     685                                        if (fp->psock->input != NULL) {
     686                                                FD_SET(fd, (fd_set *)&readfds);
     687                                                count++;
     688                                                if (fp->readevt_w == fp->readevt_r) fp->readevt_r--;
     689                                        }
     690                                }
     691                                else {
     692                                        FD_SET(fd, (fd_set *)&waitptn);
     693                                }
    548694                        }
    549                         else {
    550                                 FD_SET(fd, (fd_set *)&waitptn);
     695#endif
     696                        if (FD_ISSET(fd, &evts->writefds)) {
     697                                if (fp->writeevt_w == fp->writeevt_r) {
     698                                        FD_SET(fd, (fd_set *)&writefds);
     699                                        count++;
     700                                        if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_r--;
     701                                }
     702                                else {
     703                                        FD_SET(fd, (fd_set *)&waitptn);
     704                                }
    551705                        }
    552706                }
    553 #endif
    554                 if (FD_ISSET(fd, &evts->writefds)) {
    555                         if (fp->writable) {
    556                                 FD_SET(fd, (fd_set *)&writefds);
     707                memset(evts, 0, sizeof(*evts));
     708
     709                if (waitptn == 0) {
     710                        memcpy(&evts->readfds, &readfds, sizeof(evts->readfds));
     711                        memcpy(&evts->writefds, &writefds, sizeof(evts->writefds));
     712                        evts->count = count;
     713                        return E_OK;
     714                }
     715                else if ((readfds | writefds) != 0) {
     716                        set_flg(FLG_SELECT_WAIT, (readfds | writefds));
     717                }
     718
     719                /* イベント待ち */
     720                flgptn = 0;
     721                ret = twai_flg(FLG_SELECT_WAIT, waitptn, TWF_ORW, &flgptn, tmout);
     722                if (ret != E_OK) {
     723                        if (ret != E_TMOUT) {
     724                                syslog(LOG_ERROR, "twai_flg => %d", ret);
     725                                return ret;
     726                        }
     727
     728                        stdio_flgptn(&flgptn);
     729
     730                        if (flgptn == 0)
     731                                return E_TMOUT;
     732                }
     733                flgptn &= waitptn;
     734
     735                /* 受け取ったフラグのみクリア */
     736                ret = clr_flg(FLG_SELECT_WAIT, ~flgptn);
     737                if (ret != E_OK) {
     738                        syslog(LOG_ERROR, "clr_flg => %d", ret);
     739                }
     740
     741                count = 0;
     742                for (int fd = 0; fd < fd_table_count; fd++) {
     743                        if (!FD_ISSET(fd, (fd_set *)&waitptn))
     744                                continue;
     745
     746                        fp = &fd_table[fd];
     747
     748                        if (fp->readevt_w != fp->readevt_r) {
     749                                fp->readevt_r++;
     750                                FD_SET(fd, &evts->readfds);
    557751                                count++;
    558752                        }
    559                         else {
    560                                 FD_SET(fd, (fd_set *)&waitptn);
     753                        if (fp->writeevt_w != fp->writeevt_r) {
     754                                fp->writeevt_r++;
     755                                fp->writable = 1;
    561756                        }
    562                 }
    563         }
    564         memset(evts, 0, sizeof(*evts));
    565 
    566         if (waitptn == 0) {
    567                 memcpy(&evts->readfds, &readfds, sizeof(evts->readfds));
    568                 memcpy(&evts->writefds, &writefds, sizeof(evts->writefds));
    569                 evts->count = count;
    570                 return E_OK;
    571         }
    572         else if ((readfds | writefds) != 0){
    573                 set_flg(FLG_SELECT_WAIT, (readfds | writefds));
    574         }
    575 
    576         /* イベント待ち */
    577         ret = twai_flg(FLG_SELECT_WAIT, waitptn, TWF_ORW, &flgptn, tmout);
    578         if (ret != E_OK) {
    579                 if (ret != E_TMOUT) {
    580                         syslog(LOG_ERROR, "twai_flg => %d", ret);
    581                         return ret;
    582                 }
    583 
    584                 stdio_flgptn(&flgptn);
    585 
    586                 if (flgptn == 0)
     757                        if (fp->writable) {
     758                                FD_SET(fd, &evts->writefds);
     759                                count++;
     760                        }
     761                        if (fp->errorevt_w != fp->errorevt_r) {
     762                                fp->errorevt_r++;
     763                                FD_SET(fd, &evts->errorfds);
     764                                count++;
     765                        }
     766                }
     767
     768                if (count > 0)
     769                        break;
     770
     771                get_tim(&now);
     772
     773                SYSTIM elapse = now - prev;
     774                if (elapse > tmout)
    587775                        return E_TMOUT;
    588         }
    589         flgptn &= waitptn;
    590 
    591         /* 受け取ったフラグのみクリア */
    592         ret = clr_flg(FLG_SELECT_WAIT, ~flgptn);
    593         if (ret != E_OK) {
    594                 syslog(LOG_ERROR, "clr_flg => %d", ret);
    595         }
    596 
    597         count = 0;
    598         for (int fd = 0; fd < fd_table_count; fd++) {
    599                 if (!FD_ISSET(fd, (fd_set *)&waitptn))
    600                         continue;
    601 
    602                 fp = &fd_table[fd];
    603 
    604                 if (fp->readevt_w != fp->readevt_r) {
    605                         fp->readevt_r++;
    606                         FD_SET(fd, &evts->readfds);
    607                         count++;
    608                 }
    609                 if (fp->writeevt_w != fp->writeevt_r) {
    610                         fp->writeevt_r++;
    611                         fp->writable = 1;
    612                 }
    613                 if (fp->writable) {
    614                         FD_SET(fd, &evts->writefds);
    615                         count++;
    616                 }
    617                 if (fp->errorevt_w != fp->errorevt_r) {
    618                         fp->errorevt_r++;
    619                         FD_SET(fd, &evts->errorfds);
    620                         count++;
    621                 }
    622         }
     776
     777                prev = now;
     778                tmout -= elapse;
     779        }
     780
    623781        evts->count = count;
    624782
     
    676834}
    677835
    678 ssize_t shell_send(int fd, const void *buf, size_t len, int flags)
    679 {
    680         return -ENOMEM;
    681 }
    682 
    683836ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
    684837{
     
    691844}
    692845
    693 ssize_t shell_recv(int fd, void *buf, size_t len, int flags)
    694 {
    695         return -ENOMEM;
    696 }
    697 
    698 ssize_t shell_recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
     846ssize_t shell_recvfrom(int fd, void *__restrict buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
    699847{
    700848        return -ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.