Changeset 331 for EcnlProtoTool/trunk/ntshell/src

Timestamp:

Jan 21, 2018, 12:10:09 AM (6 years ago)

Author:

coas-nagasima

Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:

EcnlProtoTool/trunk/ntshell/src

Files:

• bits (added)
• bits/alltypes.h (added)
• bits/fcntl.h (added)
• bits/ioctl_fix.h (added)
• bits/signal.h (added)
• bits/socket.h (added)
• fdtable.c (modified) (15 diffs)
• features.h (added)
• io_stub.c (modified) (19 diffs)
• main.c (modified) (11 diffs)
• main.cfg (modified) (1 diff)
• main.h (modified) (1 diff)
• mbedcall.c (added)
• route_cfg.c (modified) (5 diffs)
• shellif.c (deleted)
• shellif.h (added)
• socket_stub.c (modified) (55 diffs)
• socket_stub.h (modified) (8 diffs)
• syscall.c (added)
• tinet_app_config.h (modified) (12 diffs)
• tinet_main.cfg (modified) (2 diffs)

EcnlProtoTool/trunk/ntshell/src/fdtable.c

@@ -35 +35 @@
  *  @(#) $Id$
  */
+#include "shellif.h"
 #include <stdint.h>
-#include <stdio.h>
-#include <sys/unistd.h>
-#include <limits.h>
 #include <kernel.h>
 #include <t_syslog.h>
 #include <t_stdlib.h>
 #include <sil.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <setjmp.h>
-#include "../../../musl-1.1.12/include/poll.h"
 #include "syssvc/serial.h"
 #include "syssvc/syslog.h"
@@ -61 +54 @@
 #include <net/if_var.h>
 #include <netinet/udp_var.h>
-#include <ethernet_api.h>
+//#include <ethernet_api.h>
 #include "ff.h"
 #include "socket_stub.h"
 #include "kernel_cfg.h"
+#include <string.h>
 
 #define SIO_PORTID 1
@@ -71 +65 @@
 #define IO_TYPE_SIO             1
 #define IO_TYPE_FILE    2
-#define IO_TYPE_TCP             3
-#define IO_TYPE_UDP             4
+#define IO_TYPE_DIR             3
+#define IO_TYPE_TCP             4
+#define IO_TYPE_UDP             5
 
 static struct _IO_FILE fd_table[8 * sizeof(FLGPTN)] = {
-        { 0, IO_TYPE_SIO, 0, stdio_close, stdin_read, stdio_write },
-        { 1, IO_TYPE_SIO, 0, stdio_close, stdio_read, stdout_write },
-        { 2, IO_TYPE_SIO, 0, stdio_close, stdio_read, stderr_write },
+        { 0, IO_TYPE_SIO, 0, stdio_close, stdin_read, stdio_write, sio_seek, sio_ioctl },
+        { 1, IO_TYPE_SIO, 0, stdio_close, stdio_read, stdout_write, sio_seek, sio_ioctl },
+        { 2, IO_TYPE_SIO, 0, stdio_close, stdio_read, stderr_write, sio_seek, sio_ioctl },
 };
 #define fd_table_count (sizeof(fd_table) / sizeof(fd_table[0]))
@@ -94 +89 @@
         }
 
-        return -1;
+        return -ENOMEM;
 }
 
@@ -112 +107 @@
         struct _IO_FILE *fp = id_to_fd(type, id);
         if (fp == NULL)
-                return -1;
+                return -EBADF;
 
         memset(fp, 0, sizeof(struct _IO_FILE));
@@ -136 +131 @@
         fp->read = sio_read;
         fp->write = sio_write;
+        fp->seek = sio_seek;
+        fp->ioctl = sio_ioctl;
 
         return fp;
@@ -160 +157 @@
         fp->read = file_read;
         fp->write = file_write;
+        fp->seek = file_seek;
+        fp->ioctl = file_ioctl;
 
         return fp;
@@ -172 +171 @@
 {
         return id_to_fd(IO_TYPE_FILE, fileid);
+}
+
+struct _IO_FILE *new_dir_fd(int fileid)
+{
+        int fd = new_fd(IO_TYPE_DIR, fileid);
+        if ((fd < 0) || (fd >= fd_table_count))
+                return NULL;
+
+        struct _IO_FILE *fp = &fd_table[fd];
+        fp->close = dir_close;
+        fp->read = dir_read;
+        fp->write = dir_write;
+        fp->seek = dir_seek;
+        fp->ioctl = dir_ioctl;
+
+        return fp;
+}
+
+int delete_dir_fd(int dirid)
+{
+        return delete_fd(IO_TYPE_DIR, dirid);
+}
+
+struct _IO_FILE *dirid_to_fd(int dirid)
+{
+        return id_to_fd(IO_TYPE_DIR, dirid);
 }
 
@@ -184 +209 @@
         fp->read = tcp_fd_read;
         fp->write = tcp_fd_write;
+        fp->seek = tcp_fd_seek;
+        fp->ioctl = tcp_fd_ioctl;
 
         return fp;
@@ -208 +235 @@
         fp->read = udp_fd_read;
         fp->write = udp_fd_write;
+        fp->seek = udp_fd_seek;
+        fp->ioctl = udp_fd_ioctl;
 
         return fp;
@@ -220 +249 @@
 {
         return id_to_fd(IO_TYPE_UDP, udpid);
-}
-
-int shell_isatty(int fd)
-{
-        if ((fd < 0) || (fd >= fd_table_count))
-                return 0;
-
-        struct _IO_FILE *fp = &fd_table[fd];
-        if (fp->type == IO_TYPE_SIO)
-                return 1;
-
-        return 0;
 }
 
@@ -245 +262 @@
 #define TMO_MAX INT_MAX
 
-int select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv)
+int shell_select(int n, fd_set *__restrict rfds, fd_set *__restrict wfds, fd_set *__restrict efds, struct timeval *__restrict tv)
 {
         ER ret;
@@ -277 +294 @@
         }
 
-        return -1;
-}
-
-int poll(struct pollfd *fds, nfds_t nfds, int timeout)
+        return -EBADF;
+}
+
+int shell_poll(struct pollfd *fds, nfds_t nfds, int timeout)
 {
         ER ret;
@@ -334 +351 @@
         }
 
-        return -1;
+        return -EBADF;
 }
 
@@ -541 +558 @@
         }
 }
+
+int shell_ioctl(int fd, int request, void *arg)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+
+        return fp->ioctl(fp, request, arg);
+}

EcnlProtoTool/trunk/ntshell/src/io_stub.c

@@ -35 +35 @@
  *  @(#) $Id$
  */
+#include "shellif.h"
 #include <stdint.h>
-#include <stdio.h>
-#include <sys/unistd.h>
-#include <limits.h>
-#include <fcntl.h>
 #include "ff.h"
 #include <kernel.h>
@@ -45 +42 @@
 #include <t_stdlib.h>
 #include <sil.h>
-#include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <setjmp.h>
 #include "syssvc/syslog.h"
@@ -61 +56 @@
 #include <net/if_var.h>
 #include <netinet/udp_var.h>
-#include <ethernet_api.h>
-#include "ff.h"
+//#include <ethernet_api.h>
 #include "socket_stub.h"
-#include "../../../musl-1.1.12/include/_dirent.h"
-#include "../../../musl-1.1.12/include/_termios.h"
-#include "ntstdio.h"
-
-int shell_open(const char * path, int flags)
-{
-        FRESULT res;
-
-        struct _IO_FILE *fp = new_file_fd(0);
-        if (fp == NULL)
-                return -1;
+//#include <sys/stat.h>
+#include "util/ntstdio.h"
+#include "usrcmd.h"
+#include "core/ntlibc.h"
+
+int fresult2errno(FRESULT res)
+{
+        switch (res) {
+        case FR_INVALID_OBJECT:
+                return -EINVAL;
+        case FR_TOO_MANY_OPEN_FILES:
+                return -ENOMEM;
+        case FR_NO_FILE:
+        case FR_NO_PATH:
+        case FR_INVALID_DRIVE:
+        case FR_INVALID_NAME:
+                return -ENOENT;
+        case FR_DISK_ERR:
+        case FR_NO_FILESYSTEM:
+        case FR_NOT_ENABLED:
+                return -ENODEV;
+        case FR_WRITE_PROTECTED:
+        case FR_DENIED:
+                return -EACCES;
+        case FR_EXIST:
+                return -EEXIST;
+        case FR_INT_ERR:
+        default:
+                return -EIO;
+        }
+}
+
+int shell_open(const char * path, int flags, void *arg)
+{
+        FRESULT res;
+        struct _IO_FILE *fp;
+
+        if (flags & O_DIRECTORY) {
+                fp = new_dir_fd(0);
+                if (fp == NULL)
+                        return -ENOMEM;
+
+                DIR *dir = &fp->dir;
+                FRESULT res;
+                if ((res = f_opendir(dir, path)) != FR_OK) {
+                        return fresult2errno(res);
+                }
+                return 0;
+        }
+
+        fp = new_file_fd(0);
+        if (fp == NULL)
+                return -ENOMEM;
 
         BYTE fmd = 0;
@@ -115 +151 @@
         }
 
-        return -1;
+        return fresult2errno(res);
 }
 
@@ -126 +162 @@
         }
 
-        return -1;
+        return -EINVAL;
 }
 
@@ -135 +171 @@
 
         if ((res = f_read(&fp->file, data, len, &ret)) != FR_OK)
-                return -1;
+                return -EIO;
 
         return ret;
@@ -146 +182 @@
 
         if ((res = f_write(&fp->file, data, len, &ret)) != FR_OK)
-                return -1;
+                return -EIO;
 
         return ret;
 }
 
+off_t file_seek(struct _IO_FILE *fp, off_t ptr, int dir)
+{
+        switch (dir) {
+        case SEEK_SET:
+                dir = F_SEEK_SET;
+                break;
+        case SEEK_CUR:
+                dir = F_SEEK_CUR;
+                break;
+        case SEEK_END:
+                dir = F_SEEK_END;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        FRESULT res;
+        if ((res = f_seek(&fp->file, ptr, dir)) != FR_OK)
+                return -EIO;
+
+        return fp->file.fptr;
+}
+
+int file_ioctl(struct _IO_FILE *fp, int req, void *arg)
+{
+        DRESULT res;
+
+        if ((res = disk_ioctl(fp->file.fs->drv, req, arg) != RES_OK))
+                return -EINVAL;
+
+        return 0;
+}
+
 int shell_close(int fd)
 {
         struct _IO_FILE *fp = fd_to_fp(fd);
         if (fp == NULL)
-                return -1;
+                return -EBADF;
 
         return fp->close(fp);
 }
 
-int shell_read(int fd, char *data, int len)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
+ssize_t shell_read(int fd, void *data, size_t len)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
 
         return fp->read(fp, (unsigned char *)data, len);
 }
 
-int shell_write(int fd, char *data, int len)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
+int shell_readv(int fd, const struct iovec *iov, int iovcnt)
+{
+        int result = 0;
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+
+        const struct iovec *end = &iov[iovcnt];
+        for (; iov < end; iov++) {
+                result += fp->read(fp, (unsigned char *)iov->iov_base, iov->iov_len);
+        }
+
+        return result;
+}
+
+ssize_t shell_write(int fd, const void *data, size_t len)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
 
         return fp->write(fp, (unsigned char *)data, len);
 }
 
-int shell_lseek(int fd, int ptr, int dir)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
-
-        FRESULT res;
-        if ((res = f_seek(&fp->file, ptr, dir)) != FR_OK)
-                return -1;
-
-        return fp->file.fptr;
+int shell_writev(int fd, const struct iovec *iov, int iovcnt)
+{
+        int result = 0;
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+
+        const struct iovec *end = &iov[iovcnt];
+        for (; iov < end; iov++) {
+                result += fp->write(fp, (unsigned char *)iov->iov_base, iov->iov_len);
+        }
+
+        return result;
+}
+
+int shell_llseek(int fd, off_t ptr, off_t *result, int dir)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+
+        off_t ret = fp->seek(fp, ptr, dir);
+        if (ret < 0)
+                return ret;
+
+        *result = ret;
+        return 0;
 }
 
@@ -195 +295 @@
         struct _IO_FILE *fp = fd_to_fp(fd);
         if (fp == NULL)
-                return -1;
+                return -EBADF;
 
         memset(st, 0, sizeof(*st));
@@ -203 +303 @@
 }
 
-int fsync(int fd)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
-        return -1;
-}
-
-int ftruncate(int fd, off_t length)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
+int shell_fsync(int fd)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+        return -EIO;
+}
+
+int shell_ftruncate(int fd, off_t length)
+{
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
 
         FRESULT res;
         if ((res = f_truncate(&fp->file)) != FR_OK)
-                return -1;
-
-        return 0;
-}
-
-int ioctl(int fd, int request, va_list ap)
-{
-        struct _IO_FILE *fp = fd_to_fp(fd);
-        if (fp == NULL)
-                return -1;
-        return -1;
-}
-
-int tcgetattr(int fd, struct termios *termios)
+                return fresult2errno(res);
+
+        return 0;
+}
+
+int shell_fcntl(int fd, int cmd, void *arg)
+{
+        return shell_ioctl(fd, cmd, arg);
+}
+
+int sio_tcgetattr(int fd, struct termios *termios)
 {
         extern ntstdio_t ntstdio;
@@ -265 +362 @@
                 return 0;
         }
-        abort();
-        return 0;
-}
-
-int tcsetattr(int fd, int optional_actions, const struct termios *termios)
+        shell_abort();
+        return 0;
+}
+
+int sio_tcsetattr(int fd, int optional_actions, const struct termios *termios)
 {
         extern ntstdio_t ntstdio;
@@ -300 +397 @@
                 return 0;
         }
-        abort();
-        return 0;
-}
-
-int shell_stat(const char *path, struct stat *st)
+        shell_abort();
+        return 0;
+}
+
+int shell_stat(const char *__restrict path, struct stat *__restrict st)
 {
         FILINFO fi;
@@ -313 +410 @@
         fi.lfsize = sizeof lfn;
 #endif
-        if (strcmp(path, ".") == 0) {
+        if (ntlibc_strcmp(path, ".") == 0) {
                 char cwd[_MAX_LFN];
                 if ((ret = f_getcwd(cwd, sizeof(cwd))) != FR_OK) {
-                return -1;
-                }
-                int l = strlen(cwd);
+                        return fresult2errno(ret);
+                }
+                int l = ntlibc_strlen(cwd);
                 // ルートディレクトリの場合
                 if (cwd[l - 2] == ':' && cwd[l - 1] == '/') {
                         st->st_size = 0;
-                        st->st_mtime = 0;
+                        st->st_mtim.tv_nsec = 0;
+                        st->st_mtim.tv_sec = 0;
                         st->st_mode = S_IFDIR;
                         return 0;
                 }
                 if ((ret = f_stat(cwd, &fi)) != FR_OK) {
-                        return -1;
+                        return fresult2errno(ret);
                 }
         }
         else if ((ret = f_stat(path, &fi)) != FR_OK) {
-                return -1;
+                return fresult2errno(ret);
         }
 
         st->st_size = fi.fsize;
-        st->st_mtime = fi.fdate + fi.ftime;
+        st->st_mtim.tv_nsec = 0;
+        st->st_mtim.tv_sec = fi.fdate + fi.ftime;
         st->st_mode  = (S_IRUSR | S_IRGRP | S_IROTH);
         st->st_mode |= (fi.fattrib & AM_RDO) ? 0 : (S_IWUSR | S_IWGRP | S_IWOTH);
@@ -343 +442 @@
 }
 
-int shell_link(void)
-{
-        return -1;
+int shell_lstat(const char *__restrict path, struct stat *__restrict st)
+{
+        return shell_stat(path, st);
+}
+
+int shell_link(const char *a, const char *b)
+{
+        return -EPERM;
 }
 
@@ -353 +457 @@
 
         if ((res = f_unlink(path)) != FR_OK)
-                return -1;
-
-        return 0;
-}
-
-int rmdir(const char *path)
+                return -EIO;
+
+        return 0;
+}
+
+int shell_rmdir(const char *path)
 {
         FRESULT res;
 
         if ((res = f_unlink(path)) != FR_OK)
-                return -1;
+                return -EIO;
 
         return 0;
@@ -373 +477 @@
 
         if ((res = f_rename(oldpath, newpath)) != FR_OK)
-                return -1;
-        return 0;
-}
-
-int mkdir(const char *path, mode_t mode)
+                return fresult2errno(res);
+        return 0;
+}
+
+#define S_IREAD S_IRUSR
+#define S_IWRITE S_IWUSR
+
+int shell_mkdir(const char *path, mode_t mode)
 {
         FRESULT res;
 
         if ((res = f_mkdir(path)) != FR_OK)
-                return -1;
+                return fresult2errno(res);
 
         BYTE attr = 0;
@@ -397 +504 @@
 
         if((res = f_chmod(path, attr, mask)) != FR_OK) {
-                return -1;
-        }
-
-        return 0;
-}
-
-int chmod(const char *path, mode_t mode)
-{
-        FRESULT ret;
+                return fresult2errno(res);
+        }
+
+        return 0;
+}
+
+int shell_chmod(const char *path, mode_t mode)
+{
+        FRESULT res;
         BYTE attr = 0;
         BYTE mask = AM_RDO | AM_SYS; // AM_ARC, AM_HID
@@ -418 +525 @@
         }
 
-        if((ret = f_chmod(path, attr, mask)) != FR_OK) {
-                return -1;
-        }
-
-        return 0;
-}
-
-char *getcwd(char *buf, size_t size)
+        if((res = f_chmod(path, attr, mask)) != FR_OK) {
+                return fresult2errno(res);
+        }
+
+        return 0;
+}
+
+char *shell_getcwd(char *buf, size_t size)
 {
         FRESULT ret;
@@ -435 +542 @@
 }
 
-int chdir(const char *path)
-{
-        FRESULT ret;
-        if ((ret = f_chdir(path)) != FR_OK) {
-                return -1;
-        }
-
-        return 0;
-}
-
-int chroot(const char *path)
-{
-        abort();
-        return -1;
-}
-
-DIR *opendir(const char *path)
-{
-        DIR *dir = malloc(sizeof(DIR) + sizeof(struct dirent));
-        FRESULT ret;
-        if ((ret = f_opendir(dir, path)) != FR_OK) {
-                free(dir);
-                return NULL;
-        }
-
-        dir->dirent = &dir[1];
-        return dir;
-}
-
-int closedir(DIR *dir)
-{
-        FRESULT ret;
-        if ((ret = f_closedir(dir)) != FR_OK) {
-                free(dir);
-                return -1;
-        }
-
-        free(dir);
-        return 0;
-}
-
-struct dirent *readdir(DIR *dir)
-{
-        struct dirent *de = dir->dirent;
+int shell_chdir(const char *path)
+{
+        FRESULT res;
+        if ((res = f_chdir(path)) != FR_OK) {
+                return fresult2errno(res);
+        }
+
+        return 0;
+}
+
+int shell_chroot(const char *path)
+{
+        shell_abort();
+        return -EPERM;
+}
+
+int dir_close(struct _IO_FILE *fp)
+{
+        FRESULT res;
+        if ((res = f_closedir(&fp->dir)) != FR_OK) {
+                return fresult2errno(res);
+        }
+
+        return 0;
+}
+
+int shell_getdents(int fd, struct dirent *de, size_t len)
+{
+        if (len < sizeof(struct dirent))
+                return -EINVAL;
+
+        struct _IO_FILE *fp = fd_to_fp(fd);
+        if (fp == NULL)
+                return -EBADF;
+
         FILINFO fno;
 #if _USE_LFN
@@ -485 +583 @@
         fno.lfsize = sizeof lfn;
 #endif
-        FRESULT ret;
-        if ((ret = f_readdir(dir, &fno)) != FR_OK || fno.fname[0] == '\0') {
-                return NULL;
+        FRESULT res;
+        if ((res = f_readdir(&fp->dir, &fno)) != FR_OK || fno.fname[0] == '\0') {
+                return fresult2errno(res);
         }
 
         memset(de, 0, sizeof(*de));
 #if _USE_LFN
-        strlcpy(de->d_name, *fno.lfname ? fno.lfname : fno.fname, sizeof(de->d_name));
+        ntlibc_strlcpy(de->d_name, *fno.lfname ? fno.lfname : fno.fname, sizeof(de->d_name));
 #else
-        strlcpy(de->d_name, fno.fname, sizeof(de->d_name));
+        ntlibc_strlcpy(de->d_name, fno.fname, sizeof(de->d_name));
 #endif
 
-        return de;
-}
-
-void rewinddir(DIR *dir)
-{
-        FRESULT ret;
-        if ((ret = f_rewinddir(dir)) != FR_OK) {
-                return;
-        }
-}
-
-void seekdir(DIR *dir, long pos)
-{
-        abort();
-}
-
-long telldir(DIR *dir)
-{
-        abort();
-        return 0;
-}
-
-int shell_getpid(int n)
+        return 0;
+}
+
+size_t dir_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
+{
+        return -EPERM;
+}
+
+size_t dir_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
+{
+        return -EPERM;
+}
+
+off_t dir_seek(struct _IO_FILE *fp, off_t ptr, int dir)
+{
+        FRESULT res;
+
+        if (dir != SEEK_SET)
+                return -EINVAL;
+
+        if (ptr == 0) {
+                if ((res = f_rewinddir(&fp->dir)) != FR_OK) {
+                        return fresult2errno(res);
+                }
+        }
+        else {
+                FILINFO fno;
+#if _USE_LFN
+                static char lfn[_MAX_LFN + 1];   /* Buffer to store the LFN */
+                fno.lfname = lfn;
+                fno.lfsize = sizeof lfn;
+#endif
+                if ((res = f_rewinddir(&fp->dir)) != FR_OK) {
+                        return fresult2errno(res);
+                }
+
+                for (int i = 0; i < ptr; i++) {
+                        if ((res = f_readdir(&fp->dir, &fno)) != FR_OK || fno.fname[0] == '\0') {
+                                return fresult2errno(res);
+                        }
+                }
+        }
+
+        return ptr;
+}
+
+int dir_ioctl(struct _IO_FILE *fp, int req, void *arg)
+{
+        return -EINVAL;
+}
+
+pid_t shell_getpid(void)
 {
         return 1;
 }
+
+int shell_access(const char *path, int mode)
+{
+        struct stat st;
+        int ret;
+
+        ret = shell_stat(path, &st);
+        if (ret != 0)
+                return ret;
+
+        return 0;
+}
+
+//#include "../musl-1.1.18/include/bits/limits.h"
+#define PAGE_SIZE 4096
+
+uint32_t  __CmdBase;
+uint32_t  __CmdLimit;
+
+void *shell_brk(void *addr)
+{
+        if (addr == 0) {
+                return (void *)((intptr_t)&__CmdBase + 0x20000);
+        }
+        if ((addr >= (intptr_t)&__CmdBase + 0x20000) && (addr < &__CmdLimit)) {
+                return addr;
+        }
+        return (void *)-1;
+}
+
+void *shell_mmap2(void *start, size_t length, int prot, int flags, int fd, off_t pgoffset)
+{
+        if (fd != -1)
+                return -EINVAL;
+
+        if ((length >= 0) && (length <= (intptr_t)&__CmdLimit - (intptr_t)&__CmdBase - 0x20000)) {
+                return &__CmdBase + 0x20000;
+        }
+        return (void *)-1;
+}
+
+int shell_mprotect(void *addr, size_t len, int prot)
+{
+        //if ((addr >= (intptr_t)&__CmdBase + 0x20000) && ((intptr_t)addr + len < &__CmdLimit)) {
+                return 0;
+        //}
+        //return -1;
+}

EcnlProtoTool/trunk/ntshell/src/main.c

@@ -40 +40 @@
  */
 
+#include "shellif.h"
 #include <kernel.h>
-#include <t_syslog.h>
 #include <t_stdlib.h>
 #include <sil.h>
-#include <stdlib.h>
+#include <setjmp.h>
 #include <string.h>
-#include <stdio.h>
-#include <setjmp.h>
 #include "syssvc/serial.h"
 #include "syssvc/syslog.h"
@@ -64 +62 @@
 #include <net/if_var.h>
 #include <netinet/udp_var.h>
-#include <ethernet_api.h>
 #include "ffarch.h"
-#include "gpio_api.h"
 #include "ff.h"
 #include "websocket_fbs.h"
-#include "ntshell.h"
-#include "ntstdio.h"
+#include "core/ntshell.h"
+#include "core/ntlibc.h"
+#include "util/ntstdio.h"
 #include "usrcmd.h"
-#include "ntopt.h"
-
-#ifndef _MSC_VER
-void strcpy_s(char *dst, int size, const char *src);
-#endif
+#include "util/ntopt.h"
+#include "socket_stub.h"
 
 ID ws_api_mailboxid = MAIN_DATAQUEUE;
@@ -86 +80 @@
 ntstdio_t ntstdio;
 
-const uint8_t mac_addr[6] = {0x00, 0x30, 0x13, 0x06, 0x62, 0xC0};
-const char host_name[] = "GR-PEACH";
+const uint8_t mac_addr[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
+const struct utsname host_name = {
+        "TOPPERS/ASP3",
+    "GR-PEACH",
+    "3.1.0",
+    "3.1.0",
+    "GR-PEACH",
+    "toppers.jp"
+};
 
 static void netif_link_callback(T_IFNET *ether);
@@ -228 +229 @@
         char buf[1];
         if(serial_rea_dat(SIO_PORTID, buf, 1) != 1)
-                return -1;
+                return -EIO;
         return buf[0];
 }
@@ -305 +306 @@
 
         if (exec) {
-                strcpy_s(command, sizeof(command), "mruby -b 1:/upload/main.mrb");
+                ntlibc_strlcpy(command, "mruby -b 1:/upload/main.mrb", sizeof(command));
 
                 execute_command(1);
@@ -371 +372 @@
 }
 
-int gethostname(char *name, size_t len)
-{
-        return strlcpy(name, host_name, len);
-}
-
-static int usrcmd_ntopt_callback(int argc, char **argv, void *extobj);
+int shell_uname(struct utsname *uts)
+{
+        return memcpy(uts, &host_name, sizeof(host_name));
+}
+
+static int usrcmd_ntopt_callback(long *args, void *extobj);
 int mruby_exit_code;
 volatile int mruby_state;
-typedef void (*PowerOn_Reset_t)(int argc, char **argv);
+typedef void (*PowerOn_Reset_t)(long *args);
 jmp_buf process_exit;
 
@@ -392 +393 @@
 }
 
-static int usrcmd_ntopt_callback(int argc, char **argv, void *extobj)
-{
+typedef struct
+{
+        const cmd_table_t *table;
+        int count;
+} cmd_table_info_t;
+
+static const cmd_table_t cmdlist[] = {
+        {"cd", "change directory", usrcmd_cd },
+        {"ls", "list files", usrcmd_ls },
+        {"cp", "copy file", usrcmd_cp },
+        {"rm", "remove file", usrcmd_rm },
+        {"mv", "move file", usrcmd_mv },
+        {"mkdir", "Make directory", usrcmd_mkdir},
+        {"hexdump", "Hex dump", usrcmd_hexdump},
+        {"info", "This is a description text string for info command.", usrcmd_info},
+        {"exit", "Exit Natural Tyny Shell", usrcmd_exit},
+};
+cmd_table_info_t cmd_table_info = { cmdlist, sizeof(cmdlist) / sizeof(cmdlist[0]) };
+
+static int usrcmd_ntopt_callback(long *args, void *extobj)
+{
+        const cmd_table_t *p = cmd_table_info.table;
+        if (ntlibc_strcmp((const char *)args[1], "help") == 0) {
+                usrcmd_help(args[0], (char **)&args[1]);
+        }
+        else for (int i = 0; i < cmd_table_info.count; i++) {
+                if (ntlibc_strcmp((const char *)args[1], p->cmd) == 0) {
+                        return p->func(args[0], (char **)&args[1]);
+                }
+                p++;
+        }
         if (setjmp(process_exit) == 0) {
-                (*((PowerOn_Reset_t *)0x18200000))(argc, argv);
+                (*((PowerOn_Reset_t *)0x18200000))(args);
         }
         clean_fd();
+        return 0;
+}
+
+int usrcmd_help(int argc, char **argv)
+{
+        const cmd_table_t *p = cmd_table_info.table;
+        for (int i = 0; i < cmd_table_info.count; i++) {
+                ntstdio_puts(&ntstdio, p->cmd);
+                ntstdio_puts(&ntstdio, "\t:");
+                ntstdio_puts(&ntstdio, p->desc);
+                ntstdio_puts(&ntstdio, "\n");
+                p++;
+        }
         return 0;
 }
@@ -422 +465 @@
 
 void shell_exit(int exitcd)
+{
+        mruby_exit_code = exitcd;
+        longjmp(process_exit, 1);
+}
+
+void shell_exit_group(int exitcd)
 {
         mruby_exit_code = exitcd;
@@ -458 +507 @@
 static int cmd_execute(const char *text, void *extobj)
 {
-        strlcpy(command, text, sizeof(command));
+        ntlibc_strlcpy(command, text, sizeof(command));
         return execute_command(1);
 }
@@ -464 +513 @@
 int stdio_close(struct _IO_FILE *fp)
 {
-        return -1;
+        return -EPERM;
 }
 
 size_t stdio_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
 {
-        return -1;
+        return -EPERM;
 }
 
 size_t stdio_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
 {
-        return -1;
+        return -EPERM;
 }
 
@@ -507 +556 @@
 int sio_close(struct _IO_FILE *fp)
 {
-        return -1;
+        return -EPERM;
 }
 
 size_t sio_read(struct _IO_FILE *fp, unsigned char *data, size_t len)
 {
-        return -1;
+        return -EPERM;
 }
 
 size_t sio_write(struct _IO_FILE *fp, const unsigned char *data, size_t len)
 {
-        return -1;
-}
+        return -EPERM;
+}
+
+off_t sio_seek(struct _IO_FILE *fp, off_t ofs, int org)
+{
+        return -EPERM;
+}
+
+int sio_ioctl(struct _IO_FILE *fp, int request, void *arg)
+{
+        switch (request) {
+        case TIOCGWINSZ:
+                return 0;
+        case TCGETS:
+                return sio_tcgetattr(fp->fd, (struct termios *)arg);
+        case TCSETS + TCSANOW:
+        case TCSETS + TCSADRAIN:
+        case TCSETS + TCSAFLUSH:
+                return sio_tcsetattr(fp->fd, request - TCSETS, (const struct termios *)arg);
+        }
+
+        return -EINVAL;
+}
+
+int shell_clock_getres(clockid_t clk_id, struct timespec *res)
+{
+        if (clk_id != CLOCK_REALTIME)
+                return -EINVAL;
+
+        memset(&res->tv_sec, 0xFF, sizeof(res->tv_sec));
+        res->tv_nsec = 0;
+
+        return 0;
+}
+
+int shell_clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+        SYSTIM now = 0;
+
+        if (clk_id != CLOCK_REALTIME)
+                return -EINVAL;
+
+        get_tim(&now);
+        tp->tv_sec = now / 1000000;
+        tp->tv_nsec = (now % 1000000) * 1000;
+
+        return 0;
+}
+
+int shell_clock_settime(clockid_t clk_id, const struct timespec *tp)
+{
+        if (clk_id != CLOCK_REALTIME)
+                return -EINVAL;
+
+        rtc_write(tp->tv_sec);
+
+        return 0;
+}
+
+sigset_t g_sigmask;
+
+int shell_sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
+{
+        if (old != NULL)
+                memcpy(old, &g_sigmask, sizeof(sigset_t));
+
+        switch (how) {
+        case SIG_BLOCK:
+                for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
+                        g_sigmask.__bits[i] |= set->__bits[i];
+                }
+                break;
+        case SIG_UNBLOCK:
+                for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
+                        g_sigmask.__bits[i] &= ~set->__bits[i];
+                }
+                break;
+        case SIG_SETMASK:
+                memcpy(&g_sigmask, set, sizeof(sigset_t));
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+struct sigaction sigtable[6];
+
+int shell_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
+{
+        struct sigaction *sat;
+
+        switch(sig){
+        case SIGALRM:
+                sat = &sigtable[0];
+                break;
+        case SIGFPE:
+                sat = &sigtable[1];
+                break;
+        case SIGILL:
+                sat = &sigtable[2];
+                break;
+        case SIGSEGV:
+                sat = &sigtable[3];
+                break;
+        case SIGBUS:
+                sat = &sigtable[4];
+                break;
+        case SIGABRT:
+                sat = &sigtable[5];
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (old != NULL)
+                memcpy(old, sat, sizeof(struct sigaction));
+
+        memcpy(sat, sa, sizeof(struct sigaction));
+
+        return 0;
+}
+
+int shell_madvise(void *a, size_t b, int c)
+{
+        return 0;
+}
+

EcnlProtoTool/trunk/ntshell/src/main.cfg

@@ -61 +61 @@
 CRE_SEM(SEM_FILESYSTEM, { TA_TPRI, 1, 1 });
 
-CRE_TSK(MRUBY_TASK, { TA_NULL, 0, mruby_task, MRUBY_PRIORITY, MRUBY_STACK_SIZE, (void *)0x20600000 });
+CRE_TSK(MRUBY_TASK, { TA_NULL, 0, mruby_task, MRUBY_PRIORITY, MRUBY_STACK_SIZE, (void *)0x20100000 });
 CRE_FLG(FLG_SELECT_WAIT, { TA_WMUL, 0x00 });

EcnlProtoTool/trunk/ntshell/src/main.h

@@ -56 +56 @@
 
 #define MAIN_STACK_SIZE         2048    /* メインタスクのスタック領域のサイズ */
-#define MRUBY_STACK_SIZE        0x100000        /* mruby実行タスクのスタック領域のサイズ */
+#define MRUBY_STACK_SIZE        0x00800000      /* mruby実行タスクのスタック領域のサイズ */
 
 #define NUM_MAIN_DATAQUEUE      1       /* メインタスクで待ち受けているデータキューのサイズ */

EcnlProtoTool/trunk/ntshell/src/route_cfg.c

@@ -2 +2 @@
  *  TINET (TCP/IP Protocol Stack)
  * 
- *  Copyright (C) 2001-2009 by Dep. of Computer Science and Engineering
+ *  Copyright (C) 2001-2017 by Dep. of Computer Science and Engineering
  *                   Tomakomai National College of Technology, JAPAN
  *
@@ -44 +44 @@
 #include <netinet/in_var.h>
 
+/* IPv6 に関する定義 */
+
+#ifdef _IP6_CFG
+
+#if NUM_IN6_ROUTE_ENTRY > 0
+
+T_IN6_RTENTRY routing6_tbl[NUM_IN6_ROUTE_ENTRY];
+
+#endif  /* of #if NUM_IN6_ROUTE_ENTRY > 0 */
+
+#endif  /* of #ifdef _IP6_CFG */
+
 /* IPv4 に関する定義 */
 
-#ifdef SUPPORT_INET4
+#ifdef _IP4_CFG
 
 #ifdef SUPPORT_LOOP
 
-T_IN4_RTENTRY routing_tbl[NUM_ROUTE_ENTRY] = {
+T_IN4_RTENTRY routing4_tbl[NUM_IN4_ROUTE_ENTRY] = {
         { 0, 0, 0 },
         };
@@ -58 +70 @@
 #ifdef SUPPORT_PPP
 
-T_IN4_RTENTRY routing_tbl[NUM_ROUTE_ENTRY] = {
+T_IN4_RTENTRY routing4_tbl[NUM_IN4_ROUTE_ENTRY] = {
         { 0, 0, 0 },
         };
@@ -66 +78 @@
 #ifdef SUPPORT_ETHER
 
-T_IN4_RTENTRY routing_tbl[NUM_ROUTE_ENTRY] = {
+T_IN4_RTENTRY routing4_tbl[NUM_IN4_ROUTE_ENTRY] = {
 
         /* 異なる LAN、default gateway による間接配送      */
@@ -82 +94 @@
 #endif  /* of #ifdef SUPPORT_ETHER */
 
-#endif  /* of #ifdef SUPPORT_INET4 */
-
-/* IPv6 に関する定義 */
-
-#ifdef SUPPORT_INET6
-
-#if NUM_ROUTE_ENTRY > 0
-
-T_IN6_RTENTRY routing_tbl[NUM_ROUTE_ENTRY] = { };
-
-#endif  /* of #if NUM_ROUTE_ENTRY > 0 */
-
-#endif  /* of #ifdef SUPPORT_INET6 */
+#endif  /* of #ifdef _IP4_CFG */

EcnlProtoTool/trunk/ntshell/src/socket_stub.c

@@ -35 +35 @@
  *  @(#) $Id$
  */
-#include <sys/types.h>
-#include <stdint.h>
-#if 0
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#endif
-#include <fcntl.h>
-#include "sys/unistd.h"
-#include <stddef.h>
-#include <string.h>
-#include <stdlib.h>
+#include "shellif.h"
 #include <kernel.h>
 #include <t_syslog.h>
 #include <t_stdlib.h>
+#include <string.h>
 #include <sil.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
 #include <setjmp.h>
 #include "syssvc/syslog.h"
@@ -74 +58 @@
 #include "ff.h"
 #include "socket_stub.h"
-#define SO_REUSEADDR    2
+
+#define SOCKET_TIMEOUT 2000000
 
 typedef struct id_table_t {
@@ -107 +92 @@
 }
 
-        return -1;
+        return -ENOMEM;
 }
 
@@ -120 +105 @@
                 return 0;
         }
-        return -1;
+        return -EINVAL;
 }
 
 int delete_tcp_rep(int repid)
 {
-        delete_tcp_fd(tmax_tcp_cepid + repid);
+        return delete_tcp_fd(tmax_tcp_cepid + repid);
 }
 
@@ -145 +130 @@
 typedef struct _IO_FILE SOCKET;
 
-int socket(int family, int type, int protocol)
+int shell_socket(int family, int type, int protocol)
 {
         SOCKET *fp;
+        unsigned int flags;
 
         switch (family) {
@@ -154 +140 @@
                 break;
         default:
-                return -1;
-        }
+                return -EAFNOSUPPORT;
+        }
+
+        flags = type & (SOCK_CLOEXEC|SOCK_NONBLOCK);
+        type &= ~flags;
 
         switch (type) {
@@ -165 +154 @@
                 break;
         default:
-                return -1;
+                return -ENOPROTOOPT;
         }
 
         if (fp == NULL) {
-                return -1;
+                return -ENOMEM;
         }
 
@@ -175 +164 @@
         fp->socket.type = type;
         fp->socket.protocol = protocol;
+        fp->socket.flags = flags;
 
         return fp->fd;
 }
 
-int bind(int fd, const struct sockaddr *addr, socklen_t len)
+int shell_bind(int fd, const struct sockaddr *addr, socklen_t len)
 {
         SOCKET *fp = fd_to_fp(fd);
-        if (fp == NULL) {
-                return -1;
-        }
-
-        if (fp->socket.family != addr->sa_family) {
-                return -1;
-        }
+        if (fp == NULL)
+                return -EBADF;
+        if (fp->socket.family != addr->sa_family)
+                return -EINVAL;
 
         ER ret;
@@ -194 +181 @@
         case AF_INET: {
                 if (len < 8) {
-                        return -1;
+                        return -EINVAL;
                 }
                 struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
@@ -202 +189 @@
                         ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
                         if (cepid < 0)
-                                return -1;
+                                return -ENOMEM;
 
                         fp->socket.buf_size = 512 + 512;
                         fp->socket.buf = id_to_buff(cepid);
-                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
+                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
                         ret = tcp_cre_cep(cepid, &ccep);
                         if (ret != E_OK) {
                                 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
-                                return -1;
+                                return -ENOMEM;
                         }
                         fp->handle = cepid;
@@ -219 +206 @@
                         ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
                         if (cepid < 0)
-                                return -1;
-
-                        T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, socket_udp_callback };
+                                return -ENOMEM;
+
+                        T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, (FP)socket_udp_callback };
                         ret = udp_cre_cep(cepid, &ccep);
                         if (ret != E_OK) {
                                 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
-                                return -1;
+                                return -ENOMEM;
                         }
                         fp->handle = cepid;
@@ -232 +219 @@
                 }
                 default:
-                        return -1;
+                        return -ENOPROTOOPT;
                 }
                 break;
@@ -238 +225 @@
         case AF_INET6: {
                 if (len < 20) {
-                        return -1;
+                        return -EINVAL;
                 }
                 memcpy(&fp->socket.laddr4, addr, len);
@@ -248 +235 @@
 }
 
-int listen(int fd, int backlog)
+int shell_listen(int fd, int backlog)
 {
         SOCKET *fp = fd_to_fp(fd);
-        if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
-                return -1;
-        }
+        if (fp == NULL)
+                return -EBADF;
+        if (fp->socket.type != SOCK_STREAM)
+                return -EINVAL;
 
         fp->socket.backlog = backlog;
@@ -262 +250 @@
                 ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
                 if (repid < 0)
-                        return -1;
+                        return -ENOMEM;
 
                 struct sockaddr_in *laddr = &fp->socket.laddr4;
@@ -269 +257 @@
                 if (ret != E_OK) {
                         delete_id(tcp_repid_table, tcp_repid_table_count, repid);
-                        return -1;
+                        return -ENOMEM;
                 }
                 fp->socket.repid = repid;
@@ -282 +270 @@
 }
 
-int connect(int fd, const struct sockaddr *addr, socklen_t len)
+int shell_connect(int fd, const struct sockaddr *addr, socklen_t len)
 {
         SOCKET *fp = fd_to_fp(fd);
-        if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
-                return -1;
-        }
+        if (fp == NULL)
+                return -EBADF;
+        if (fp->socket.type != SOCK_STREAM)
+                return -EINVAL;
 
         ER ret;
@@ -293 +282 @@
         case AF_INET: {
                 if (len < 8) {
-                        return -1;
+                        return -EINVAL;
                 }
                 if (fp->socket.cepid == 0) {
                         ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
                         if (cepid < 0)
-                                return -1;
+                                return -ENOMEM;
 
                         fp->socket.buf_size = 512 + 512;
                         fp->socket.buf = id_to_buff(cepid);
-                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
+                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
                         ret = tcp_cre_cep(cepid, &ccep);
                         if (ret != E_OK) {
                                 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
-                                return -1;
+                                return -ENOMEM;
                         }
                         fp->handle = cepid;
@@ -317 +306 @@
                 T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
                 T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
-                ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, TMO_FEVR);
+                ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, SOCKET_TIMEOUT);
                 if (ret < 0) {
-                        return -1;
+                        return -EHOSTUNREACH;
                 }
                 break;
@@ -331 +320 @@
 }
 
-int accept(int fd, struct sockaddr *addr, socklen_t *len)
+int shell_accept(int fd, struct sockaddr *__restrict addr, socklen_t *__restrict len)
 {
         SOCKET *lfp = fd_to_fp(fd);
-        if ((lfp == NULL) || (lfp->socket.type != SOCK_STREAM)) {
-                return -1;
-        }
+        if (lfp == NULL)
+                return -EBADF;
+        if (lfp->socket.type != SOCK_STREAM)
+                return -EINVAL;
 
         SOCKET *fp = new_tcp_fd(0);
         if (fp == NULL) {
-                return -1;
+                return -ENOMEM;
         }
 
@@ -352 +342 @@
                         cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
                         if (cepid < 0)
-                                return -1;
+                                return -ENOMEM;
 
                         fp->socket.buf_size = 512 + 512;
                         fp->socket.buf = id_to_buff(cepid);
-                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
+                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
                         ret = tcp_cre_cep(cepid, &ccep);
                         if (ret != E_OK) {
                                 delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
-                                return -1;
+                                return -ENOMEM;
                         }
                         fp->handle = cepid;
@@ -375 +365 @@
                 ret = tcp_acp_cep(fp->socket.cepid, fp->socket.repid, &rep, TMO_FEVR);
                 if (ret < 0) {
-                        return -1;
+                        return -ENOMEM;
                 }
                 struct sockaddr_in *raddr = &fp->socket.raddr4;
@@ -385 +375 @@
         }
         case AF_INET6: {
-                break;
+                return -EAFNOSUPPORT;
         }
         }
@@ -392 +382 @@
                 int sz = *len;
                 if (sz < 8) {
-                        return -1;
+                        return -EINVAL;
                 }
                 struct sockaddr_in *raddr = &fp->socket.raddr4;
@@ -404 +394 @@
 }
 
-ssize_t send(int fd, const void *buf, size_t len, int flags)
+ssize_t shell_send(int fd, const void *buf, size_t len, int flags)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -417 +407 @@
                 case SOCK_STREAM: {
                         if (flags & MSG_OOB) {
-                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
+                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
                         else {
-                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
+                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -431 +421 @@
                 }
                 case SOCK_DGRAM: {
-                        return -1;
-                }
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                        return -EINVAL;
+                }
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -444 +434 @@
 }
 
-ssize_t sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
+ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -457 +447 @@
                 case SOCK_STREAM: {
                         if ((addr != NULL) && (alen != 0)) {
-                                return -1;
+                                return -EINVAL;
                         }
 
                         if (flags & MSG_OOB) {
-                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
+                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
                         else {
-                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
+                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -477 +467 @@
                         int sz = alen;
                         if (sz < 8) {
-                                return -1;
+                                return -EINVAL;
                         }
                         struct sockaddr_in *raddr = &fp->socket.raddr4;
@@ -483 +473 @@
                         memcpy(raddr, addr, sz);
                         T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
-                        ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len, TMO_FEVR);
+                        ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len,
+                                (fp->socket.flags & O_NONBLOCK) ? 0 : SOCKET_TIMEOUT);
                         if (ret < 0) {
-                                return -1;
-                        }
-                        break;
-                }
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                                return -ECOMM;
+                        }
+                        break;
+                }
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -500 +491 @@
 }
 
-ssize_t recv(int fd, void *buf, size_t len, int flags)
+ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
+{
+        no_implement("sendmsg\n");
+        return -ENOSYS;
+}
+
+ssize_t shell_recv(int fd, void *buf, size_t len, int flags)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -515 +512 @@
                                 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -521 +518 @@
                                 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -528 +525 @@
                 case SOCK_DGRAM: {
                         T_IPV4EP rep = { 0, 0 };
-                        ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
+                        ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, (fp->socket.flags & O_NONBLOCK) ? 0 : TMO_FEVR);
                         if (ret < 0) {
-                                return -1;
-                        }
-                }
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                                return -ECOMM;
+                        }
+                }
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -544 +541 @@
 }
 
-ssize_t recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen)
+ssize_t shell_recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -559 +556 @@
                                 ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -565 +562 @@
                                 ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -ECOMM;
                                 }
                         }
@@ -574 +571 @@
                         ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
                         if (ret < 0) {
-                                return -1;
+                                return -ECOMM;
                         }
                         int sz = *alen;
@@ -590 +587 @@
         }
         case AF_INET6: {
-                break;
+                return -EAFNOSUPPORT;
         }
         }
@@ -597 +594 @@
 }
 
-int shutdown(int fd, int how)
+ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
+{
+        no_implement("recvmsg\n");
+        return -ENOSYS;
+}
+
+int shell_shutdown(int fd, int how)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -611 +614 @@
                         ret = tcp_sht_cep(fp->socket.cepid);
                         if (ret < 0) {
-                                return -1;
-                        }
-                        break;
-                }
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                                return -ECOMM;
+                        }
+                        break;
+                }
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -626 +629 @@
 }
 
-int getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
+int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *__restrict optlen)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -650 +653 @@
                                 ret = tcp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -EINVAL;
                                 }
                                 *optlen = ret;
@@ -660 +663 @@
                         ret = udp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
                         if (ret < 0) {
-                                return -1;
+                                return -EINVAL;
                         }
                         *optlen = ret;
@@ -669 +672 @@
         }
         case AF_INET6: {
-                break;
+                return -EAFNOSUPPORT;
         }
         }
@@ -676 +679 @@
 }
 
-int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
+int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
 {
         SOCKET *fp = fd_to_fp(fd);
         if (fp == NULL) {
-                return -1;
+                return -EBADF;
         }
 
@@ -700 +703 @@
                                 ret = tcp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
                                 if (ret < 0) {
-                                        return -1;
+                                        return -EINVAL;
                                 }
                                 break;
@@ -709 +712 @@
                         ret = udp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
                         if (ret < 0) {
-                                return -1;
-                        }
-                        break;
-                }
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                                return -EINVAL;
+                        }
+                        break;
+                }
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -735 +738 @@
                                 //return -1;
                         }
-                        ret = tcp_cls_cep(cepid, TMO_FEVR);
+                        ret = tcp_cls_cep(cepid, (fp->socket.repid != 0) ? 0 : SOCKET_TIMEOUT);
                         if (ret < 0) {
                                 //return -1;
@@ -743 +746 @@
                         delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
                         if (ret < 0) {
-                                return -1;
+                                return -EINVAL;
                         }
                 }
@@ -752 +755 @@
                         delete_id(tcp_repid_table, tcp_repid_table_count, repid);
                         if (ret < 0) {
-                                return -1;
+                                return -EINVAL;
                         }
                 }
                 else {
-                        return -1;
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                        return -EINVAL;
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -770 +773 @@
 size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
 {
-        return recv(fp->fd, dst, dstsz, 0);
+        return shell_recv(fp->fd, dst, dstsz, 0);
 }
 
 size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
 {
-        return send(fp->fd, src, srcsz, 0);
+        return shell_send(fp->fd, src, srcsz, 0);
 }
 
 off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
 {
-        return -1;
+        return -EPERM;
+}
+
+int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
+{
+        return -EINVAL;
 }
 
@@ -794 +802 @@
                 delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
                 if (ret < 0) {
-                        return -1;
-                }
-                break;
-        }
-        case AF_INET6: {
-                break;
+                        return -EINVAL;
+                }
+                break;
+        }
+        case AF_INET6: {
+                return -EAFNOSUPPORT;
         }
         }
@@ -808 +816 @@
 size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
 {
-        return recv(fp->fd, dst, dstsz, 0);
+        return shell_recv(fp->fd, dst, dstsz, 0);
 }
 
 size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
 {
-        return send(fp->fd, src, srcsz, 0);
+        return shell_send(fp->fd, src, srcsz, 0);
 }
 
 off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
 {
-        return -1;
+        return -EPERM;
+}
+
+int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
+{
+        return -EINVAL;
 }
 

EcnlProtoTool/trunk/ntshell/src/socket_stub.h

@@ -38 +38 @@
 #define SOCKET_STUB_H
 
-typedef unsigned socklen_t;
-typedef unsigned short sa_family_t;
-
-struct sockaddr {
-        sa_family_t sa_family;
-        char sa_data[14];
-};
-
 struct addrinfo {
         int ai_flags;
@@ -57 +49 @@
 };
 
-#define AF_INET         2
-#define AF_INET6        10
-
-#define SOCK_STREAM     1
-#define SOCK_DGRAM      2
-
 typedef uint16_t in_port_t;
 typedef uint32_t in_addr_t;
@@ -82 +68 @@
         } __in6_union;
 };
-#define s6_addr __in6_union.__s6_addr
-#define s6_addr16 __in6_union.__s6_addr16
-#define s6_addr32 __in6_union.__s6_addr32
+//#define s6_addr __in6_union.__s6_addr
+//#define s6_addr16 __in6_union.__s6_addr16
+//#define s6_addr32 __in6_union.__s6_addr32
 
 struct sockaddr_in6
@@ -94 +80 @@
         uint32_t        sin6_scope_id;
 };
-
-#define MSG_OOB       0x0001
 
 typedef struct socket_t {
@@ -124 +108 @@
         size_t (*read)(struct _IO_FILE *, unsigned char *, size_t);
         size_t (*write)(struct _IO_FILE *, const unsigned char *, size_t);
+        off_t (*seek)(struct _IO_FILE *, off_t, int);
+        int (*ioctl)(struct _IO_FILE *, int, void *);
         int readevt_r;
         int readevt_w;
@@ -132 +118 @@
         union {
                 FIL file;
+                struct {
+                        DIR dir;
+                        struct dirent dirent;
+                };
                 socket_t socket;
         };
@@ -156 +146 @@
 extern size_t sio_read(struct _IO_FILE *fp, unsigned char *data, size_t len);
 extern size_t sio_write(struct _IO_FILE *fp, const unsigned char *data, size_t len);
+extern off_t sio_seek(struct _IO_FILE *fp, off_t ofs, int org);
+extern int sio_ioctl(struct _IO_FILE *fp, int req, void *arg);
 
 extern int file_close(struct _IO_FILE *fp);
 extern size_t file_read(struct _IO_FILE *fp, unsigned char *data, size_t len);
 extern size_t file_write(struct _IO_FILE *fp, const unsigned char *data, size_t len);
+extern off_t file_seek(struct _IO_FILE *fp, off_t ofs, int org);
+extern int file_ioctl(struct _IO_FILE *fp, int req, void *arg);
+
+extern int dir_close(struct _IO_FILE *fp);
+extern size_t dir_read(struct _IO_FILE *fp, unsigned char *data, size_t len);
+extern size_t dir_write(struct _IO_FILE *fp, const unsigned char *data, size_t len);
+extern off_t dir_seek(struct _IO_FILE *fp, off_t ofs, int org);
+extern int dir_ioctl(struct _IO_FILE *fp, int req, void *arg);
 
 extern int tcp_fd_close(struct _IO_FILE *fp);
 extern size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *data, size_t len);
 extern size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *data, size_t len);
+extern off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org);
+extern int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg);
 
 extern int udp_fd_close(struct _IO_FILE *fp);
 extern size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *data, size_t len);
 extern size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *data, size_t len);
+extern off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org);
+extern int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg);
 
 struct _IO_FILE *fd_to_fp(int fd);
@@ -179 +183 @@
 struct _IO_FILE *fileid_to_fd(int fileid);
 
+struct _IO_FILE *new_dir_fd(int dirid);
+int delete_dir_fd(int dirid);
+struct _IO_FILE *dirid_to_fd(int dirid);
+
 struct _IO_FILE *new_tcp_fd(int tcpid);
 int delete_tcp_fd(int tcpid);

EcnlProtoTool/trunk/ntshell/src/tinet_app_config.h

@@ -2 +2 @@
  *  TINET (TCP/IP Protocol Stack)
  * 
- *  Copyright (C) 2001-2009 by Dep. of Computer Science and Engineering
+ *  Copyright (C) 2001-2012 by Dep. of Computer Science and Engineering
  *                   Tomakomai National College of Technology, JAPAN
  *
@@ -62 +62 @@
 
 /*
- *  TCPの能動オープンのみサポートすることを指定する。
- */
-
-#ifdef UNDEF_TCP_CFG_PASSIVE_OPEN
-#undef TCP_CFG_PASSIVE_OPEN
-#endif
-
-/*
  *  TCP 通信端点の送受信ウィンドバッファの省コピー機能
  *    注意: Makefile で指定している。
@@ -98 +90 @@
 #ifdef USE_TCP_MSS_SEG
 
+#ifdef SUPPORT_INET6
+
+#define TCP_CFG_SWBUF_CSAVE_MAX_SIZE    (IF_HDR_SIZE + IPV6_MMTU)       /* 最大サイズ */
+
+#else   /* of #ifdef SUPPORT_INET6 */
+
 #ifdef SUPPORT_INET4
 #define TCP_CFG_SWBUF_CSAVE_MAX_SIZE    (IF_HDR_SIZE + IP4_MSS)         /* 最大サイズ */
 #endif
 
-#ifdef SUPPORT_INET6
-#define TCP_CFG_SWBUF_CSAVE_MAX_SIZE    (IF_HDR_SIZE + IPV6_MMTU)       /* 最大サイズ */
-#endif
+#endif  /* of #ifdef SUPPORT_INET6 */
 
 #else   /* of #ifdef USE_TCP_MSS_SEG */
@@ -135 +131 @@
 #endif
 
+#ifdef SUPPORT_INET6
+
+#define MAX_TCP_SND_SEG                 TCP6_MSS
+
+#else   /* of #ifdef SUPPORT_INET6 */
+
 #ifdef SUPPORT_INET4
 #define MAX_TCP_SND_SEG                 TCP_MSS
 #endif
 
-#ifdef SUPPORT_INET6
-#define MAX_TCP_SND_SEG                 TCP6_MSS
-#endif
+#endif  /* of #ifdef SUPPORT_INET6 */
 
 #endif  /* of #ifdef USE_TCP_MSS_SEG */
@@ -155 +155 @@
 #endif
 
+#ifdef SUPPORT_INET6
+
+#define DEF_TCP_RCV_SEG                 TCP6_MSS
+
+#else   /* of #ifdef SUPPORT_INET6 */
+
 #ifdef SUPPORT_INET4
 #define DEF_TCP_RCV_SEG                 TCP_MSS
 #endif
 
-#ifdef SUPPORT_INET6
-#define DEF_TCP_RCV_SEG                 TCP6_MSS
-#endif
+#endif  /* of #ifdef SUPPORT_INET6 */
 
 #endif  /* of #ifdef USE_TCP_MSS_SEG */
@@ -235 +239 @@
 #define UDP_CFG_EXTENTIONS
 
+/* IPv6 に関する定義 */
+
+#ifdef SUPPORT_PPP
+
+#define NUM_IN6_STATIC_ROUTE_ENTRY      0
+#define NUM_IN6_REDIRECT_ROUTE_ENTRY    0
+
+#endif  /* of #ifdef SUPPORT_PPP */
+
+#ifdef SUPPORT_LOOP
+
+#define NUM_IN6_STATIC_ROUTE_ENTRY      0
+#define NUM_IN6_REDIRECT_ROUTE_ENTRY    0
+
+#endif  /* of #ifdef SUPPORT_LOOP */
+
+#ifdef SUPPORT_ETHER
+
+#define NUM_IN6_STATIC_ROUTE_ENTRY      0
+#define NUM_IN6_REDIRECT_ROUTE_ENTRY    1
+
+#endif  /* of #ifdef SUPPORT_ETHER */
+
 /* IPv4 に関する定義 */
-
-#ifdef SUPPORT_INET4
 
 #ifdef SUPPORT_PPP
@@ -253 +278 @@
 #endif
 
-#define NUM_STATIC_ROUTE_ENTRY          1
-#define NUM_REDIRECT_ROUTE_ENTRY        0
+#define NUM_IN4_STATIC_ROUTE_ENTRY      1
+#define NUM_IN4_REDIRECT_ROUTE_ENTRY    0
 
 #endif  /* of #ifdef SUPPORT_PPP */
@@ -260 +285 @@
 #ifdef SUPPORT_ETHER
 
-#ifdef DHCP_CFG
+#ifdef DHCP4_CLI_CFG
 
 #define IPV4_ADDR_LOCAL                 MAKE_IPV4_ADDR(0,0,0,0)
@@ -266 +291 @@
 #define IPV4_ADDR_DEFAULT_GW            MAKE_IPV4_ADDR(0,0,0,0)
 
-#else   /* of #ifdef DHCP_CFG */
+#else   /* of #ifdef DHCP4_CLI_CFG */
 
 #define IPV4_ADDR_LOCAL                 MAKE_IPV4_ADDR(192,168,137,110)
@@ -272 +297 @@
 #define IPV4_ADDR_DEFAULT_GW            MAKE_IPV4_ADDR(192,168,137,1)
 
-#endif  /* of #ifdef DHCP_CFG */
-
-#define NUM_STATIC_ROUTE_ENTRY          3
-#define NUM_REDIRECT_ROUTE_ENTRY        1
+#endif  /* of #ifdef DHCP4_CLI_CFG */
+
+#define NUM_IN4_STATIC_ROUTE_ENTRY      3
+#define NUM_IN4_REDIRECT_ROUTE_ENTRY    1
 
 #endif  /* of #ifdef SUPPORT_ETHER */
@@ -281 +306 @@
 #ifdef SUPPORT_LOOP
 
-#define NUM_STATIC_ROUTE_ENTRY          1
-#define NUM_REDIRECT_ROUTE_ENTRY        0
+#define NUM_IN4_STATIC_ROUTE_ENTRY      1
+#define NUM_IN4_REDIRECT_ROUTE_ENTRY    0
 
 #endif  /* of #ifdef SUPPORT_LOOP */
-
-#endif  /* of #ifdef SUPPORT_INET4 */
-
-/* IPv6 に関する定義 */
-
-#ifdef SUPPORT_INET6
-
-#ifdef SUPPORT_PPP
-
-#define NUM_STATIC_ROUTE_ENTRY          0
-#define NUM_REDIRECT_ROUTE_ENTRY        0
-
-#endif  /* of #ifdef SUPPORT_PPP */
-
-#ifdef SUPPORT_LOOP
-
-#define NUM_STATIC_ROUTE_ENTRY          0
-#define NUM_REDIRECT_ROUTE_ENTRY        0
-
-#endif  /* of #ifdef SUPPORT_LOOP */
-
-#ifdef SUPPORT_ETHER
-
-#define NUM_STATIC_ROUTE_ENTRY          0
-#define NUM_REDIRECT_ROUTE_ENTRY        1
-
-#endif  /* of #ifdef SUPPORT_ETHER */
-
-#endif  /* of #ifdef SUPPORT_INET6 */
 
 /*
@@ -420 +416 @@
  *    IPv6 でのみ割り当てる。
  *
- *    RX62N Ethernet Controler のディバイスドライバ（if_rx62n）の最低割当て長は、
+ *    MBED Ethernet Controler のディバイスドライバ（if_mbed）の最低割当て長は、
  *    イーサネットフレームの最短長である 60（CRC の 4 オクテットを除き、
  *    更にアラインして 62）オクテットである。

EcnlProtoTool/trunk/ntshell/src/tinet_main.cfg

@@ -43 +43 @@
 #include "main.h"
 
+INCLUDE("netinet/ip_igmp.cfg");
+
 /* DHCP クライアント */
 /*INCLUDE("netapp/tinet_dhcp4_cli.cfg");*/
@@ -49 +51 @@
 /* ECHONET Lite UDP 通信端点 */
 
-#ifdef SUPPORT_INET4
+VRID_TCP_REP (USR_TCP_REP1);
+VRID_TCP_REP (USR_TCP_REP2);
+VRID_TCP_REP (USR_TCP_REP3);
+VRID_TCP_REP (USR_TCP_REP4);
 
-VRID_TCP4_REP (USR_TCP_REP1);
-VRID_TCP4_REP (USR_TCP_REP2);
-VRID_TCP4_REP (USR_TCP_REP3);
-VRID_TCP4_REP (USR_TCP_REP4);
+VRID_TCP_CEP (USR_TCP_CEP1);
+VRID_TCP_CEP (USR_TCP_CEP2);
+VRID_TCP_CEP (USR_TCP_CEP3);
+VRID_TCP_CEP (USR_TCP_CEP4);
+VRID_TCP_CEP (USR_TCP_CEP5);
+VRID_TCP_CEP (USR_TCP_CEP6);
+VRID_TCP_CEP (USR_TCP_CEP7);
+VRID_TCP_CEP (USR_TCP_CEP8);
 
-VRID_TCP4_CEP (USR_TCP_CEP1);
-VRID_TCP4_CEP (USR_TCP_CEP2);
-VRID_TCP4_CEP (USR_TCP_CEP3);
-VRID_TCP4_CEP (USR_TCP_CEP4);
-VRID_TCP4_CEP (USR_TCP_CEP5);
-VRID_TCP4_CEP (USR_TCP_CEP6);
-VRID_TCP4_CEP (USR_TCP_CEP7);
-VRID_TCP4_CEP (USR_TCP_CEP8);
+VRID_UDP_CEP (USR_UDP_CEP1);
+VRID_UDP_CEP (USR_UDP_CEP2);
+VRID_UDP_CEP (USR_UDP_CEP3);
+VRID_UDP_CEP (USR_UDP_CEP4);
 
-VRID_UDP4_CEP (USR_UDP_CEP1);
-VRID_UDP4_CEP (USR_UDP_CEP2);
-VRID_UDP4_CEP (USR_UDP_CEP3);
-VRID_UDP4_CEP (USR_UDP_CEP4);
+VRID_UDP6_CEP (USR_UDP6_CEP1);
+VRID_UDP6_CEP (USR_UDP6_CEP2);
+VRID_UDP6_CEP (USR_UDP6_CEP3);
+VRID_UDP6_CEP (USR_UDP6_CEP4);
 
-#endif  /* of #ifdef SUPPORT_INET4 */
-
-#ifdef SUPPORT_INET6
-
-VRID_TCP6_REP (USR_TCP_REP1);
-VRID_TCP6_REP (USR_TCP_REP2);
-VRID_TCP6_REP (USR_TCP_REP3);
-VRID_TCP6_REP (USR_TCP_REP4);
-
-VRID_TCP6_CEP (USR_TCP_CEP1);
-VRID_TCP6_CEP (USR_TCP_CEP2);
-VRID_TCP6_CEP (USR_TCP_CEP3);
-VRID_TCP6_CEP (USR_TCP_CEP4);
-VRID_TCP6_CEP (USR_TCP_CEP5);
-VRID_TCP6_CEP (USR_TCP_CEP6);
-VRID_TCP6_CEP (USR_TCP_CEP7);
-VRID_TCP6_CEP (USR_TCP_CEP8);
-
-VRID_UDP6_CEP (USR_UDP_CEP1);
-VRID_UDP6_CEP (USR_UDP_CEP2);
-VRID_UDP6_CEP (USR_UDP_CEP3);
-VRID_UDP6_CEP (USR_UDP_CEP4);
-
-#endif  /* of #ifdef SUPPORT_INET6 */
-