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

    r364 r374  
    6868#include "kernel_cfg.h"
    6969#include <string.h>
    70 
    71 #define IO_TYPE_FREE    0
    72 #define IO_TYPE_SIO             1
    73 #define IO_TYPE_FILE    2
    74 #define IO_TYPE_DIR             3
    75 #define IO_TYPE_TCP             4
    76 #define IO_TYPE_UDP     5
    77 
    78 static struct _IO_FILE fd_table[8 * sizeof(FLGPTN)] = {
    79         { 0, IO_TYPE_SIO, 0, stdio_close, stdin_read, stdio_write, sio_seek, sio_ioctl },
    80         { 1, IO_TYPE_SIO, 0, stdio_close, stdio_read, stdout_write, sio_seek, sio_ioctl },
    81         { 2, IO_TYPE_SIO, 0, stdio_close, stdio_read, stderr_write, sio_seek, sio_ioctl },
     70#include "util/ntstdio.h"
     71#include "hal/serial_api.h"
     72
     73static int stdio_close(struct SHELL_FILE *fp);
     74static size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     75static size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     76static size_t stdin_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     77static size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     78static size_t stderr_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     79static void stdio_delete(struct SHELL_FILE *fp);
     80
     81static int sio_close(struct SHELL_FILE *fp);
     82static size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     83static size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     84static off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     85static int sio_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     86static bool_t sio_readable(struct SHELL_FILE *fp);
     87static void sio_delete(struct SHELL_FILE *fp);
     88
     89IO_TYPE IO_TYPE_STDIN = { stdio_close, stdin_read, stdio_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     90IO_TYPE IO_TYPE_STDOUT = { stdio_close, stdio_read, stdout_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     91IO_TYPE IO_TYPE_STDERR = { stdio_close, stdio_read, stderr_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     92IO_TYPE IO_TYPE_SIO = { sio_close, sio_read, sio_write, sio_seek, sio_ioctl, sio_readable, sio_delete };
     93ntstdio_t ntstdio;
     94
     95static struct SHELL_FILE fd_table[8 * sizeof(FLGPTN)] = {
     96        { 0, &IO_TYPE_STDIN, 0, .exinf = &ntstdio },
     97        { 1, &IO_TYPE_STDOUT, 0, .exinf = &ntstdio },
     98        { 2, &IO_TYPE_STDERR, 0,.exinf = &ntstdio },
    8299};
    83100#define fd_table_count (sizeof(fd_table) / sizeof(fd_table[0]))
    84101
    85 static int new_fd(int type, int id)
    86 {
     102extern ntstdio_t ntstdio;
     103serial_t stdio_uart;
     104
     105unsigned char ntstdio_xi(struct ntstdio_t *handle)
     106{
     107        return serial_getc((serial_t *)handle->exinf);
     108}
     109
     110void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
     111{
     112        serial_putc((serial_t *)handle->exinf, c);
     113}
     114
     115void sys_init(intptr_t exinf)
     116{
     117        sys_tlsf_init();
     118
     119        serial_init(&stdio_uart, STDIO_UART_TX, STDIO_UART_RX);
     120        serial_baud(&stdio_uart, UART_BAUDRATE);
     121        serial_format(&stdio_uart, 8, ParityNone, 1);
     122
     123        ntstdio_init(&ntstdio, NTSTDIO_OPTION_LINE_ECHO | NTSTDIO_OPTION_CANON | NTSTDIO_OPTION_LF_CRLF | NTSTDIO_OPTION_LF_CR, ntstdio_xi, ntstdio_xo);
     124        ntstdio.exinf = (void *)&stdio_uart;
     125}
     126
     127int stdio_close(struct SHELL_FILE *fp)
     128{
     129        return -EPERM;
     130}
     131
     132size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     133{
     134        return -EPERM;
     135}
     136
     137size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     138{
     139        return -EPERM;
     140}
     141
     142size_t stdin_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     143{
     144        int i = 0;
     145        while (i < len) {
     146                int c = ntstdio_getc((struct ntstdio_t *)fp->exinf);
     147                data[i++] = c;
     148                if ((c == EOF) || (c == '\n'))
     149                        break;
     150        }
     151        return i;
     152}
     153
     154size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     155{
     156        for (int i = 0; i < len; i++) {
     157                ntstdio_putc((struct ntstdio_t *)fp->exinf, data[i]);
     158        }
     159        return len;
     160}
     161
     162size_t stderr_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     163{
     164        for (int i = 0; i < len; i++) {
     165                ntstdio_putc((struct ntstdio_t *)fp->exinf, data[i]);
     166        }
     167        return len;
     168}
     169
     170void stdio_delete(struct SHELL_FILE *fp)
     171{
     172}
     173
     174int sio_close(struct SHELL_FILE *fp)
     175{
     176        return -EPERM;
     177}
     178
     179size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     180{
     181        return -EPERM;
     182}
     183
     184size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     185{
     186        return -EPERM;
     187}
     188
     189off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org)
     190{
     191        return -EPERM;
     192}
     193
     194int sio_ioctl(struct SHELL_FILE *fp, int request, void *arg)
     195{
     196        switch (request) {
     197        case TIOCGWINSZ:
     198                return 0;
     199        case TCGETS:
     200                return sio_tcgetattr(fp->fd, (struct termios *)arg);
     201        case TCSETS + TCSANOW:
     202        case TCSETS + TCSADRAIN:
     203        case TCSETS + TCSAFLUSH:
     204                return sio_tcsetattr(fp->fd, request - TCSETS, (const struct termios *)arg);
     205        }
     206
     207        return -EINVAL;
     208}
     209
     210bool_t sio_readable(struct SHELL_FILE *fp)
     211{
     212        return fp->readevt_w != fp->readevt_r;
     213}
     214
     215void sio_delete(struct SHELL_FILE *fp)
     216{
     217        free((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf);
     218        ((struct ntstdio_t *)fp->exinf)->exinf = NULL;
     219        free((struct ntstdio_t *)fp->exinf);
     220        fp->exinf = NULL;
     221}
     222
     223struct SHELL_FILE *new_fp(IO_TYPE *type, int id, int writable)
     224{
     225        struct SHELL_FILE *fp = NULL;
     226        ER ret;
     227
     228        ret = wai_sem(SEM_FILEDESC);
     229        if (ret < 0) {
     230                syslog(LOG_ERROR, "wai_sem => %d", ret);
     231        }
     232
    87233        for (int fd = 3; fd < fd_table_count; fd++) {
    88                 struct _IO_FILE *fp = &fd_table[fd];
    89                 if (fp->type != IO_TYPE_FREE)
     234                fp = &fd_table[fd];
     235                if (fp->type != NULL)
    90236                        continue;
    91237
    92                 memset(fp, 0, sizeof(struct _IO_FILE));
     238                memset(fp, 0, sizeof(struct SHELL_FILE));
    93239                fp->fd = fd;
    94240                fp->type = type;
    95241                fp->handle = id;
    96                 return fd;
    97         }
    98 
    99         return -ENOMEM;
    100 }
    101 
    102 static struct _IO_FILE *id_to_fd(int type, int id)
    103 {
     242                fp->writable = writable;
     243                break;
     244        }
     245
     246        ret = sig_sem(SEM_FILEDESC);
     247        if (ret < 0) {
     248                syslog(LOG_ERROR, "sig_sem => %d", ret);
     249        }
     250
     251        return fp;
     252}
     253
     254struct SHELL_FILE *id_to_fd(IO_TYPE *type, int id)
     255{
     256        struct SHELL_FILE *fp = NULL;
     257        ER ret;
     258
     259        ret = wai_sem(SEM_FILEDESC);
     260        if (ret < 0) {
     261                syslog(LOG_ERROR, "wai_sem => %d", ret);
     262        }
     263
    104264        for (int fd = 3; fd < fd_table_count; fd++) {
    105                 struct _IO_FILE *fp = &fd_table[fd];
     265                fp = &fd_table[fd];
    106266                if ((fp->type == type) && (fp->handle == id))
    107                         return fp;
    108         }
    109 
    110         return NULL;
    111 }
    112 
    113 static int delete_fd(int type, int id)
    114 {
    115         struct _IO_FILE *fp = id_to_fd(type, id);
     267                        break;
     268        }
     269
     270        ret = sig_sem(SEM_FILEDESC);
     271        if (ret < 0) {
     272                syslog(LOG_ERROR, "sig_sem => %d", ret);
     273        }
     274
     275        return fp;
     276}
     277
     278int delete_fd_by_id(IO_TYPE *type, int id)
     279{
     280        struct SHELL_FILE *fp = id_to_fd(type, id);
    116281        if (fp == NULL)
    117282                return -EBADF;
    … …  
    120285}
    121286
    122 int delete_fp(struct _IO_FILE *fp)
    123 {
    124         free(fp->pfile);
    125         fp->pfile = NULL;
    126         free(fp->pdir);
    127         fp->pdir = NULL;
    128         free(fp->psock);
    129         fp->psock = NULL;
    130         memset(fp, 0, sizeof(struct _IO_FILE));
     287int delete_fp(struct SHELL_FILE *fp)
     288{
     289        ER ret;
     290
     291        fp->type->delete(fp);
     292
     293        ret = wai_sem(SEM_FILEDESC);
     294        if (ret < 0) {
     295                syslog(LOG_ERROR, "wai_sem => %d", ret);
     296        }
     297
     298        memset(fp, 0, sizeof(struct SHELL_FILE));
     299
     300        ret = sig_sem(SEM_FILEDESC);
     301        if (ret < 0) {
     302                syslog(LOG_ERROR, "sig_sem => %d", ret);
     303        }
    131304
    132305        return 0;
    133306}
    134307
    135 struct _IO_FILE *fd_to_fp(int fd)
     308struct SHELL_FILE *fd_to_fp(int fd)
    136309{
    137310        if ((fd < 0) || (fd >= fd_table_count))
    … …  
    140313}
    141314
    142 struct _IO_FILE *new_sio_fd(int sioid)
    143 {
    144         int fd = new_fd(IO_TYPE_SIO, sioid);
    145         if ((fd < 0) || (fd >= fd_table_count))
    146                 return NULL;
    147 
    148         struct _IO_FILE *fp = &fd_table[fd];
    149         fp->close = sio_close;
    150         fp->read = sio_read;
    151         fp->write = sio_write;
    152         fp->seek = sio_seek;
    153         fp->ioctl = sio_ioctl;
    154         fp->writable = 1;
    155 
    156         return fp;
    157 }
    158 
    159 int delete_sio_fd(int sioid)
    160 {
    161         return delete_fd(IO_TYPE_SIO, sioid);
    162 }
    163 
    164 struct _IO_FILE *sioid_to_fd(int sioid)
    165 {
    166         return id_to_fd(IO_TYPE_SIO, sioid);
    167 }
    168 
    169 struct _IO_FILE *new_file_fd(int fileid)
    170 {
    171         int fd = new_fd(IO_TYPE_FILE, fileid);
    172         if ((fd < 0) || (fd >= fd_table_count))
    173                 return NULL;
    174 
    175         struct _IO_FILE *fp = &fd_table[fd];
    176         fp->close = file_close;
    177         fp->read = file_read;
    178         fp->write = file_write;
    179         fp->seek = file_seek;
    180         fp->ioctl = file_ioctl;
    181         fp->writable = 1;
    182         fp->pfile = malloc(sizeof(FIL));
    183         memset(fp->pfile, 0, sizeof(FIL));
    184 
    185         return fp;
    186 }
    187 
    188 int delete_file_fd(int fileid)
    189 {
    190         return delete_fd(IO_TYPE_FILE, fileid);
    191 }
    192 
    193 struct _IO_FILE *fileid_to_fd(int fileid)
    194 {
    195         return id_to_fd(IO_TYPE_FILE, fileid);
    196 }
    197 
    198 struct _IO_FILE *new_dir_fd(int fileid)
    199 {
    200         int fd = new_fd(IO_TYPE_DIR, fileid);
    201         if ((fd < 0) || (fd >= fd_table_count))
    202                 return NULL;
    203 
    204         struct _IO_FILE *fp = &fd_table[fd];
    205         fp->close = dir_close;
    206         fp->read = dir_read;
    207         fp->write = dir_write;
    208         fp->seek = dir_seek;
    209         fp->ioctl = dir_ioctl;
    210         fp->writable = 0;
    211         fp->pdir = malloc(sizeof(struct _IO_DIR));
    212         memset(fp->pdir, 0, sizeof(struct _IO_DIR));
    213 
    214         return fp;
    215 }
    216 
    217 int delete_dir_fd(int dirid)
    218 {
    219         return delete_fd(IO_TYPE_DIR, dirid);
    220 }
    221 
    222 struct _IO_FILE *dirid_to_fd(int dirid)
    223 {
    224         return id_to_fd(IO_TYPE_DIR, dirid);
    225 }
    226 
    227 #ifndef NTSHELL_NO_SOCKET
    228 struct _IO_FILE *new_tcp_fd(int tcpid)
    229 {
    230         int fd = new_fd(IO_TYPE_TCP, tcpid);
    231         if ((fd < 0) || (fd >= fd_table_count))
    232                 return NULL;
    233 
    234         struct _IO_FILE *fp = &fd_table[fd];
    235         fp->close = tcp_fd_close;
    236         fp->read = tcp_fd_read;
    237         fp->write = tcp_fd_write;
    238         fp->seek = tcp_fd_seek;
    239         fp->ioctl = tcp_fd_ioctl;
    240         fp->writable = 0;
    241         fp->psock = malloc(sizeof(socket_t));
    242         memset(fp->psock, 0, sizeof(socket_t));
    243 
    244         return fp;
    245 }
    246 
    247 int delete_tcp_fd(int tcpid)
    248 {
    249         return delete_fd(IO_TYPE_TCP, tcpid);
    250 }
    251 
    252 struct _IO_FILE *tcpid_to_fd(int tcpid)
    253 {
    254         return id_to_fd(IO_TYPE_TCP, tcpid);
    255 }
    256 
    257 struct _IO_FILE *new_udp_fd(int udpid)
    258 {
    259         int fd = new_fd(IO_TYPE_UDP, udpid);
    260         if ((fd < 0) || (fd >= fd_table_count))
    261                 return NULL;
    262 
    263         struct _IO_FILE *fp = &fd_table[fd];
    264         fp->close = udp_fd_close;
    265         fp->read = udp_fd_read;
    266         fp->write = udp_fd_write;
    267         fp->seek = udp_fd_seek;
    268         fp->ioctl = udp_fd_ioctl;
    269         fp->writable = 1;
    270         fp->psock = malloc(sizeof(socket_t));
    271         memset(fp->psock, 0, sizeof(socket_t));
    272 
    273         return fp;
    274 }
    275 
    276 int delete_udp_fd(int udpid)
    277 {
    278         return delete_fd(IO_TYPE_UDP, udpid);
    279 }
    280 
    281 struct _IO_FILE *udpid_to_fd(int udpid)
    282 {
    283         return id_to_fd(IO_TYPE_UDP, udpid);
    284 }
    285 
    286 #endif
    287 
    288 void memor(void *dst, void *src, size_t len)
     315void memand(void *dst, void *src, size_t len)
    289316{
    290317        uint8_t *d = (uint8_t *)dst;
    … …  
    293320
    294321        while (s < e) {
    295                 *d++ |= *s++;
     322                *d++ &= *s++;
    296323        }
    297324}
    … …  
    336363
    337364        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));
    344365        if (ret == E_OK) {
    345366                if (rfds != NULL)
    346                         memor(rfds, &evts.readfds, sizeof(fd_set));
     367                        memand(rfds, &evts.readfds, sizeof(fd_set));
    347368                if (wfds != NULL)
    348                         memor(wfds, &evts.writefds, sizeof(fd_set));
     369                        memand(wfds, &evts.writefds, sizeof(fd_set));
    349370                if (efds != NULL)
    350                         memor(efds, &evts.errorfds, sizeof(fd_set));
     371                        memand(efds, &evts.errorfds, sizeof(fd_set));
    351372                return evts.count;
    352373        }
    353374        if (ret == E_TMOUT) {
     375                if (rfds != NULL)
     376                        memset(rfds, 0, sizeof(fd_set));
     377                if (wfds != NULL)
     378                        memset(wfds, 0, sizeof(fd_set));
     379                if (efds != NULL)
     380                        memset(efds, 0, sizeof(fd_set));
    354381                return 0;
    355382        }
    … …  
    419446{
    420447        int fd = STDIN_FILENO;
    421         struct _IO_FILE *fp = &fd_table[fd];
    422         T_SERIAL_RPOR rpor;
     448        struct SHELL_FILE *fp = &fd_table[fd];
    423449        FLGPTN flgptn = 0;
    424450
    425         ER ret = serial_ref_por(SIO_PORTID, &rpor);
    426         if (ret != E_OK)
    427                 return;
    428 
    429         if (rpor.reacnt != 0) {
     451        if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    430452                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    431453
    432454                FD_SET(fd, (fd_set *)&flgptn);
    433455        }
    434         if (rpor.wricnt != 0) {
     456        if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    435457                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    436458
    … …  
    447469{
    448470        int fd = STDIN_FILENO;
    449         struct _IO_FILE *fp = &fd_table[fd];
    450         T_SERIAL_RPOR rpor;
     471        struct SHELL_FILE *fp = &fd_table[fd];
    451472        *flgptn = 0;
    452473
    453         ER ret = serial_ref_por(SIO_PORTID, &rpor);
    454         if (ret != E_OK)
    455                 return;
    456 
    457         if (rpor.reacnt != 0) {
     474        if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    458475                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    459476
    460477                FD_SET(fd, (fd_set *)flgptn);
    461478        }
    462         if (rpor.wricnt != 0) {
     479        if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    463480                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    464481
    … …  
    466483        }
    467484}
    468 
    469 #ifndef NTSHELL_NO_SOCKET
    470 
    471 ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
    472 {
    473         struct _IO_FILE *fp = tcpid_to_fd(cepid);
    474         FLGPTN flgptn = 0;
    475         ER ret;
    476         int len;
    477 
    478         if (fp == NULL)
    479                 return E_PAR;
    480 
    481         int fd = fp->fd;
    482         FD_SET(fd, (fd_set *)&flgptn);
    483 
    484         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 
    505         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 
    520                 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    521 
    522                 set_flg(FLG_SELECT_WAIT, flgptn);
    523                 return E_OK;
    524 
    525         case TFN_TCP_SND_DAT:
    526                 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    527 
    528                 set_flg(FLG_SELECT_WAIT, flgptn);
    529                 return E_OK;
    530 
    531         case TFN_TCP_CAN_CEP:
    532                 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
    533 
    534                 set_flg(FLG_SELECT_WAIT, flgptn);
    535                 return E_OK;
    536 
    537         case TFN_TCP_DEL_REP:
    538                 delete_tcp_rep(cepid);
    539                 return E_OK;
    540 
    541         case TFN_TCP_DEL_CEP:
    542                 delete_tcp_fd(cepid);
    543                 return E_OK;
    544 
    545         default:
    546                 return E_OK;
    547         }
    548 }
    549 
    550 ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk)
    551 {
    552         struct _IO_FILE *fp = udpid_to_fd(cepid);
    553         FLGPTN flgptn = 0;
    554         int len;
    555 
    556         if (fp == NULL)
    557                 return E_PAR;
    558 
    559         int fd = fp->fd;
    560         FD_SET(fd, (fd_set *)&flgptn);
    561 
    562         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         }
    598         case TFN_UDP_CRE_CEP:
    599                 return E_OK;
    600 
    601         case TFN_UDP_RCV_DAT:
    602                 len = *(int *)p_parblk;
    603                 if (len <= 0)
    604                         return E_OK;
    605 
    606                 if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    607 
    608                 set_flg(FLG_SELECT_WAIT, flgptn);
    609                 return E_OK;
    610 
    611         case TFN_UDP_SND_DAT:
    612                 if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    613 
    614                 set_flg(FLG_SELECT_WAIT, flgptn);
    615                 return E_OK;
    616 
    617         case TFN_UDP_CAN_CEP:
    618                 if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
    619 
    620                 set_flg(FLG_SELECT_WAIT, flgptn);
    621                 return E_OK;
    622 
    623         case TFN_UDP_DEL_CEP:
    624                 delete_udp_fd(cepid);
    625                 return E_OK;
    626 
    627         default:
    628                 return E_OK;
    629         }
    630 }
    631 
    632 #endif
    633485
    634486ER shell_get_evts(struct fd_events *evts, TMO tmout)
    … …  
    642494                ER ret;
    643495                FLGPTN waitptn, flgptn, readfds = 0, writefds = 0;
    644                 struct _IO_FILE *fp = NULL;
     496                struct SHELL_FILE *fp = NULL;
    645497
    646498                stdio_update_evts();
    … …  
    656508#ifndef NTSHELL_NO_SOCKET
    657509                        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                                         }
     510                                if (fp->type->readable(fp)) {
     511                                        FD_SET(fd, (fd_set *)&readfds);
     512                                        count++;
     513                                        if (fp->readevt_w == fp->readevt_r) fp->readevt_r--;
    690514                                }
    691515                                else {
    … …  
    786610void clean_fd()
    787611{
    788         struct _IO_FILE *fp = NULL;
     612        struct SHELL_FILE *fp = NULL;
    789613        for (int fd = 3; fd < fd_table_count; fd++) {
    790614                fp = &fd_table[fd];
    … …  
    792616                        continue;
    793617
    794                 fp->close(fp);
     618                fp->type->close(fp);
    795619
    796620                delete_fp(fp);
    … …  
    800624int shell_ioctl(int fd, int request, void *arg)
    801625{
    802         struct _IO_FILE *fp = fd_to_fp(fd);
     626        struct SHELL_FILE *fp = fd_to_fp(fd);
    803627        if (fp == NULL)
    804628                return -EBADF;
    805629
    806         return fp->ioctl(fp, request, arg);
     630        return fp->type->ioctl(fp, request, arg);
    807631}
    808632
Note: See TracChangeset for help on using the changeset viewer.