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/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
     73#ifdef _DEBUG
     74static const char THIS_FILE[] = __FILE__;
     75#endif
     76
     77static int stdio_close(struct SHELL_FILE *fp);
     78static size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     79static size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     80static size_t stdin_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     81static size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     82static size_t stderr_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     83static void stdio_delete(struct SHELL_FILE *fp);
     84
     85static int sio_close(struct SHELL_FILE *fp);
     86static size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
     87static size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
     88static off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org);
     89static int sio_ioctl(struct SHELL_FILE *fp, int req, void *arg);
     90static bool_t sio_readable(struct SHELL_FILE *fp);
     91static void sio_delete(struct SHELL_FILE *fp);
     92
     93IO_TYPE IO_TYPE_STDIN = { stdio_close, stdin_read, stdio_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     94IO_TYPE IO_TYPE_STDOUT = { stdio_close, stdio_read, stdout_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     95IO_TYPE IO_TYPE_STDERR = { stdio_close, stdio_read, stderr_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
     96IO_TYPE IO_TYPE_SIO = { sio_close, sio_read, sio_write, sio_seek, sio_ioctl, sio_readable, sio_delete };
     97ntstdio_t ntstdio;
     98
     99static struct SHELL_FILE fd_table[8 * sizeof(FLGPTN)] = {
     100        { 0, &IO_TYPE_STDIN, 0, .exinf = &ntstdio },
     101        { 1, &IO_TYPE_STDOUT, 0, .exinf = &ntstdio },
     102        { 2, &IO_TYPE_STDERR, 0,.exinf = &ntstdio },
    82103};
    83104#define fd_table_count (sizeof(fd_table) / sizeof(fd_table[0]))
    84105
    85 static int new_fd(int type, int id)
    86 {
     106extern ntstdio_t ntstdio;
     107extern serial_t stdio_uart;
     108
     109unsigned char ntstdio_xi(struct ntstdio_t *handle)
     110{
     111        return serial_getc((serial_t *)handle->exinf);
     112}
     113
     114void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
     115{
     116        serial_putc((serial_t *)handle->exinf, c);
     117}
     118
     119void sys_init(intptr_t exinf)
     120{
     121        ntstdio_init(&ntstdio, NTSTDIO_OPTION_LINE_ECHO | NTSTDIO_OPTION_CANON | NTSTDIO_OPTION_LF_CRLF | NTSTDIO_OPTION_LF_CR, ntstdio_xi, ntstdio_xo);
     122        ntstdio.exinf = (void *)&stdio_uart;
     123}
     124
     125int stdio_close(struct SHELL_FILE *fp)
     126{
     127        return -EPERM;
     128}
     129
     130size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     131{
     132        return -EPERM;
     133}
     134
     135size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     136{
     137        return -EPERM;
     138}
     139
     140size_t stdin_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     141{
     142        int i = 0;
     143        while (i < len) {
     144                int c = ntstdio_getc((struct ntstdio_t *)fp->exinf);
     145                data[i++] = c;
     146                if ((c == EOF) || (c == '\n'))
     147                        break;
     148        }
     149        return i;
     150}
     151
     152size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     153{
     154        for (int i = 0; i < len; i++) {
     155                ntstdio_putc((struct ntstdio_t *)fp->exinf, data[i]);
     156        }
     157        return len;
     158}
     159
     160size_t stderr_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     161{
     162        for (int i = 0; i < len; i++) {
     163                ntstdio_putc((struct ntstdio_t *)fp->exinf, data[i]);
     164        }
     165        return len;
     166}
     167
     168void stdio_delete(struct SHELL_FILE *fp)
     169{
     170}
     171
     172int sio_close(struct SHELL_FILE *fp)
     173{
     174        return -EPERM;
     175}
     176
     177size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
     178{
     179        return -EPERM;
     180}
     181
     182size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
     183{
     184        return -EPERM;
     185}
     186
     187off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org)
     188{
     189        return -EPERM;
     190}
     191
     192int sio_ioctl(struct SHELL_FILE *fp, int request, void *arg)
     193{
     194        switch (request) {
     195        case TIOCGWINSZ:
     196                return 0;
     197        case TCGETS:
     198                return sio_tcgetattr(fp->fd, (struct termios *)arg);
     199        case TCSETS + TCSANOW:
     200        case TCSETS + TCSADRAIN:
     201        case TCSETS + TCSAFLUSH:
     202                return sio_tcsetattr(fp->fd, request - TCSETS, (const struct termios *)arg);
     203        }
     204
     205        return -EINVAL;
     206}
     207
     208bool_t sio_readable(struct SHELL_FILE *fp)
     209{
     210        return fp->readevt_w != fp->readevt_r;
     211}
     212
     213void sio_delete(struct SHELL_FILE *fp)
     214{
     215        free((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf);
     216        ((struct ntstdio_t *)fp->exinf)->exinf = NULL;
     217        free((struct ntstdio_t *)fp->exinf);
     218        fp->exinf = NULL;
     219}
     220
     221struct SHELL_FILE *new_fp(IO_TYPE *type, int id, int writable)
     222{
     223        struct SHELL_FILE *fp = NULL;
     224        ER ret;
     225
     226        ret = wai_sem(SEM_FILEDESC);
     227        if (ret < 0) {
     228                syslog(LOG_ERROR, "wai_sem => %d", ret);
     229        }
     230
    87231        for (int fd = 3; fd < fd_table_count; fd++) {
    88                 struct _IO_FILE *fp = &fd_table[fd];
    89                 if (fp->type != IO_TYPE_FREE)
     232                fp = &fd_table[fd];
     233                if (fp->type != NULL)
    90234                        continue;
    91235
    92                 memset(fp, 0, sizeof(struct _IO_FILE));
     236                memset(fp, 0, sizeof(struct SHELL_FILE));
    93237                fp->fd = fd;
    94238                fp->type = type;
    95239                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 {
     240                fp->writable = writable;
     241                break;
     242        }
     243
     244        ret = sig_sem(SEM_FILEDESC);
     245        if (ret < 0) {
     246                syslog(LOG_ERROR, "sig_sem => %d", ret);
     247        }
     248
     249        return fp;
     250}
     251
     252struct SHELL_FILE *id_to_fd(IO_TYPE *type, int id)
     253{
     254        struct SHELL_FILE *fp = NULL;
     255        ER ret;
     256
     257        ret = wai_sem(SEM_FILEDESC);
     258        if (ret < 0) {
     259                syslog(LOG_ERROR, "wai_sem => %d", ret);
     260        }
     261
    104262        for (int fd = 3; fd < fd_table_count; fd++) {
    105                 struct _IO_FILE *fp = &fd_table[fd];
     263                fp = &fd_table[fd];
    106264                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);
     265                        break;
     266        }
     267
     268        ret = sig_sem(SEM_FILEDESC);
     269        if (ret < 0) {
     270                syslog(LOG_ERROR, "sig_sem => %d", ret);
     271        }
     272
     273        return fp;
     274}
     275
     276int delete_fd_by_id(IO_TYPE *type, int id)
     277{
     278        struct SHELL_FILE *fp = id_to_fd(type, id);
    116279        if (fp == NULL)
    117280                return -EBADF;
    … …  
    120283}
    121284
    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));
     285int delete_fp(struct SHELL_FILE *fp)
     286{
     287        ER ret;
     288
     289        fp->type->delete(fp);
     290
     291        ret = wai_sem(SEM_FILEDESC);
     292        if (ret < 0) {
     293                syslog(LOG_ERROR, "wai_sem => %d", ret);
     294        }
     295
     296        memset(fp, 0, sizeof(struct SHELL_FILE));
     297
     298        ret = sig_sem(SEM_FILEDESC);
     299        if (ret < 0) {
     300                syslog(LOG_ERROR, "sig_sem => %d", ret);
     301        }
    131302
    132303        return 0;
    133304}
    134305
    135 struct _IO_FILE *fd_to_fp(int fd)
     306struct SHELL_FILE *fd_to_fp(int fd)
    136307{
    137308        if ((fd < 0) || (fd >= fd_table_count))
    … …  
    140311}
    141312
    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)
     313void memand(void *dst, void *src, size_t len)
    289314{
    290315        uint8_t *d = (uint8_t *)dst;
    … …  
    293318
    294319        while (s < e) {
    295                 *d++ |= *s++;
     320                *d++ &= *s++;
    296321        }
    297322}
    … …  
    336361
    337362        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));
    344363        if (ret == E_OK) {
    345364                if (rfds != NULL)
    346                         memor(rfds, &evts.readfds, sizeof(fd_set));
     365                        memand(rfds, &evts.readfds, sizeof(fd_set));
    347366                if (wfds != NULL)
    348                         memor(wfds, &evts.writefds, sizeof(fd_set));
     367                        memand(wfds, &evts.writefds, sizeof(fd_set));
    349368                if (efds != NULL)
    350                         memor(efds, &evts.errorfds, sizeof(fd_set));
     369                        memand(efds, &evts.errorfds, sizeof(fd_set));
    351370                return evts.count;
    352371        }
    353372        if (ret == E_TMOUT) {
     373                if (rfds != NULL)
     374                        memset(rfds, 0, sizeof(fd_set));
     375                if (wfds != NULL)
     376                        memset(wfds, 0, sizeof(fd_set));
     377                if (efds != NULL)
     378                        memset(efds, 0, sizeof(fd_set));
    354379                return 0;
    355380        }
    … …  
    419444{
    420445        int fd = STDIN_FILENO;
    421         struct _IO_FILE *fp = &fd_table[fd];
    422         T_SERIAL_RPOR rpor;
     446        struct SHELL_FILE *fp = &fd_table[fd];
    423447        FLGPTN flgptn = 0;
    424448
    425         ER ret = serial_ref_por(SIO_PORTID, &rpor);
    426         if (ret != E_OK)
    427                 return;
    428 
    429         if (rpor.reacnt != 0) {
     449        if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    430450                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    431451
    432452                FD_SET(fd, (fd_set *)&flgptn);
    433453        }
    434         if (rpor.wricnt != 0) {
     454        if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    435455                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    436456
    … …  
    447467{
    448468        int fd = STDIN_FILENO;
    449         struct _IO_FILE *fp = &fd_table[fd];
    450         T_SERIAL_RPOR rpor;
     469        struct SHELL_FILE *fp = &fd_table[fd];
    451470        *flgptn = 0;
    452471
    453         ER ret = serial_ref_por(SIO_PORTID, &rpor);
    454         if (ret != E_OK)
    455                 return;
    456 
    457         if (rpor.reacnt != 0) {
     472        if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    458473                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
    459474
    460475                FD_SET(fd, (fd_set *)flgptn);
    461476        }
    462         if (rpor.wricnt != 0) {
     477        if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
    463478                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
    464479
    … …  
    466481        }
    467482}
    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
    633483
    634484ER shell_get_evts(struct fd_events *evts, TMO tmout)
    … …  
    642492                ER ret;
    643493                FLGPTN waitptn, flgptn, readfds = 0, writefds = 0;
    644                 struct _IO_FILE *fp = NULL;
     494                struct SHELL_FILE *fp = NULL;
    645495
    646496                stdio_update_evts();
    … …  
    656506#ifndef NTSHELL_NO_SOCKET
    657507                        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                                         }
     508                                if (fp->type->readable(fp)) {
     509                                        FD_SET(fd, (fd_set *)&readfds);
     510                                        count++;
     511                                        if (fp->readevt_w == fp->readevt_r) fp->readevt_r--;
    690512                                }
    691513                                else {
    … …  
    786608void clean_fd()
    787609{
    788         struct _IO_FILE *fp = NULL;
     610        struct SHELL_FILE *fp = NULL;
    789611        for (int fd = 3; fd < fd_table_count; fd++) {
    790612                fp = &fd_table[fd];
    … …  
    792614                        continue;
    793615
    794                 fp->close(fp);
     616                fp->type->close(fp);
    795617
    796618                delete_fp(fp);
    … …  
    800622int shell_ioctl(int fd, int request, void *arg)
    801623{
    802         struct _IO_FILE *fp = fd_to_fp(fd);
     624        struct SHELL_FILE *fp = fd_to_fp(fd);
    803625        if (fp == NULL)
    804626                return -EBADF;
    805627
    806         return fp->ioctl(fp, request, arg);
     628        return fp->type->ioctl(fp, request, arg);
    807629}
    808630
Note: See TracChangeset for help on using the changeset viewer.