[352] | 1 | /*
|
---|
| 2 | * TOPPERS ECHONET Lite Communication Middleware
|
---|
| 3 | *
|
---|
| 4 | * Copyright (C) 2017 Cores Co., Ltd. Japan
|
---|
| 5 | *
|
---|
| 6 | * 上記著作権者は,以下の(1)~(4)の条件を満たす場合に限り,本ソフトウェ
|
---|
| 7 | * ア(本ソフトウェアを改変したものを含む.以下同じ)を使用・複製・改
|
---|
| 8 | * 変・再配布(以下,利用と呼ぶ)することを無償で許諾する.
|
---|
| 9 | * (1) 本ソフトウェアをソースコードの形で利用する場合には,上記の著作
|
---|
| 10 | * 権表示,この利用条件および下記の無保証規定が,そのままの形でソー
|
---|
| 11 | * スコード中に含まれていること.
|
---|
| 12 | * (2) 本ソフトウェアを,ライブラリ形式など,他のソフトウェア開発に使
|
---|
| 13 | * 用できる形で再配布する場合には,再配布に伴うドキュメント(利用
|
---|
| 14 | * 者マニュアルなど)に,上記の著作権表示,この利用条件および下記
|
---|
| 15 | * の無保証規定を掲載すること.
|
---|
| 16 | * (3) 本ソフトウェアを,機器に組み込むなど,他のソフトウェア開発に使
|
---|
| 17 | * 用できない形で再配布する場合には,次のいずれかの条件を満たすこ
|
---|
| 18 | * と.
|
---|
| 19 | * (a) 再配布に伴うドキュメント(利用者マニュアルなど)に,上記の著
|
---|
| 20 | * 作権表示,この利用条件および下記の無保証規定を掲載すること.
|
---|
| 21 | * (b) 再配布の形態を,別に定める方法によって,TOPPERSプロジェクトに
|
---|
| 22 | * 報告すること.
|
---|
| 23 | * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
|
---|
| 24 | * 害からも,上記著作権者およびTOPPERSプロジェクトを免責すること.
|
---|
| 25 | * また,本ソフトウェアのユーザまたはエンドユーザからのいかなる理
|
---|
| 26 | * 由に基づく請求からも,上記著作権者およびTOPPERSプロジェクトを
|
---|
| 27 | * 免責すること.
|
---|
| 28 | *
|
---|
| 29 | * 本ソフトウェアは,無保証で提供されているものである.上記著作権者お
|
---|
| 30 | * よびTOPPERSプロジェクトは,本ソフトウェアに関して,特定の使用目的
|
---|
| 31 | * に対する適合性も含めて,いかなる保証も行わない.また,本ソフトウェ
|
---|
| 32 | * アの利用により直接的または間接的に生じたいかなる損害に関しても,そ
|
---|
| 33 | * の責任を負わない.
|
---|
| 34 | *
|
---|
| 35 | * @(#) $Id$
|
---|
| 36 | */
|
---|
| 37 | #include "shellif.h"
|
---|
| 38 | #include <stdint.h>
|
---|
| 39 | #include <kernel.h>
|
---|
| 40 | #include <t_syslog.h>
|
---|
| 41 | #include <t_stdlib.h>
|
---|
| 42 | #include <sil.h>
|
---|
| 43 | #include "syssvc/serial.h"
|
---|
| 44 | #include "syssvc/syslog.h"
|
---|
| 45 | #include "target_syssvc.h"
|
---|
| 46 | #ifndef NTSHELL_NO_SOCKET
|
---|
[364] | 47 | #include <tinet_defs.h>
|
---|
[352] | 48 | #include <tinet_config.h>
|
---|
[364] | 49 | #include <net/net.h>
|
---|
| 50 | #include <net/net_endian.h>
|
---|
[352] | 51 | #include <netinet/in.h>
|
---|
| 52 | #include <netinet/in_itron.h>
|
---|
| 53 | #include <tinet_nic_defs.h>
|
---|
| 54 | #include <tinet_cfg.h>
|
---|
| 55 | #include <netinet/in_var.h>
|
---|
| 56 | #include <net/ethernet.h>
|
---|
| 57 | #include <net/if6_var.h>
|
---|
| 58 | #include <net/net.h>
|
---|
| 59 | #include <net/if_var.h>
|
---|
[364] | 60 | #include <netinet/udp.h>
|
---|
[352] | 61 | #include <netinet/udp_var.h>
|
---|
| 62 | #include <netinet/tcp.h>
|
---|
| 63 | #include <netinet/tcp_var.h>
|
---|
[364] | 64 | #include <net/net_buf.h>
|
---|
[352] | 65 | #endif
|
---|
| 66 | #include "ff.h"
|
---|
| 67 | #include "socket_stub.h"
|
---|
| 68 | #include "kernel_cfg.h"
|
---|
| 69 | #include <string.h>
|
---|
[374] | 70 | #include "util/ntstdio.h"
|
---|
| 71 | #include "hal/serial_api.h"
|
---|
[352] | 72 |
|
---|
[374] | 73 | #ifdef _DEBUG
|
---|
| 74 | static const char THIS_FILE[] = __FILE__;
|
---|
| 75 | #endif
|
---|
[352] | 76 |
|
---|
[374] | 77 | static int stdio_close(struct SHELL_FILE *fp);
|
---|
| 78 | static size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
|
---|
| 79 | static size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
|
---|
| 80 | static size_t stdin_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
|
---|
| 81 | static size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
|
---|
| 82 | static size_t stderr_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
|
---|
| 83 | static void stdio_delete(struct SHELL_FILE *fp);
|
---|
| 84 |
|
---|
| 85 | static int sio_close(struct SHELL_FILE *fp);
|
---|
| 86 | static size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len);
|
---|
| 87 | static size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len);
|
---|
| 88 | static off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org);
|
---|
| 89 | static int sio_ioctl(struct SHELL_FILE *fp, int req, void *arg);
|
---|
| 90 | static bool_t sio_readable(struct SHELL_FILE *fp);
|
---|
| 91 | static void sio_delete(struct SHELL_FILE *fp);
|
---|
| 92 |
|
---|
| 93 | IO_TYPE IO_TYPE_STDIN = { stdio_close, stdin_read, stdio_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
|
---|
| 94 | IO_TYPE IO_TYPE_STDOUT = { stdio_close, stdio_read, stdout_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
|
---|
| 95 | IO_TYPE IO_TYPE_STDERR = { stdio_close, stdio_read, stderr_write, sio_seek, sio_ioctl, sio_readable, stdio_delete };
|
---|
| 96 | IO_TYPE IO_TYPE_SIO = { sio_close, sio_read, sio_write, sio_seek, sio_ioctl, sio_readable, sio_delete };
|
---|
| 97 | ntstdio_t ntstdio;
|
---|
| 98 |
|
---|
| 99 | static 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 },
|
---|
[352] | 103 | };
|
---|
| 104 | #define fd_table_count (sizeof(fd_table) / sizeof(fd_table[0]))
|
---|
| 105 |
|
---|
[374] | 106 | extern ntstdio_t ntstdio;
|
---|
| 107 | extern serial_t stdio_uart;
|
---|
| 108 |
|
---|
| 109 | unsigned char ntstdio_xi(struct ntstdio_t *handle)
|
---|
[352] | 110 | {
|
---|
[374] | 111 | return serial_getc((serial_t *)handle->exinf);
|
---|
| 112 | }
|
---|
[352] | 113 |
|
---|
[374] | 114 | void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
|
---|
| 115 | {
|
---|
| 116 | serial_putc((serial_t *)handle->exinf, c);
|
---|
| 117 | }
|
---|
[352] | 118 |
|
---|
[374] | 119 | void 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;
|
---|
[352] | 123 | }
|
---|
| 124 |
|
---|
[374] | 125 | int stdio_close(struct SHELL_FILE *fp)
|
---|
[352] | 126 | {
|
---|
[374] | 127 | return -EPERM;
|
---|
| 128 | }
|
---|
[352] | 129 |
|
---|
[374] | 130 | size_t stdio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
|
---|
| 131 | {
|
---|
| 132 | return -EPERM;
|
---|
[352] | 133 | }
|
---|
| 134 |
|
---|
[374] | 135 | size_t stdio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
|
---|
[352] | 136 | {
|
---|
[374] | 137 | return -EPERM;
|
---|
| 138 | }
|
---|
[352] | 139 |
|
---|
[374] | 140 | size_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;
|
---|
[352] | 150 | }
|
---|
| 151 |
|
---|
[374] | 152 | size_t stdout_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
|
---|
[352] | 153 | {
|
---|
[374] | 154 | for (int i = 0; i < len; i++) {
|
---|
| 155 | ntstdio_putc((struct ntstdio_t *)fp->exinf, data[i]);
|
---|
| 156 | }
|
---|
| 157 | return len;
|
---|
| 158 | }
|
---|
[352] | 159 |
|
---|
[374] | 160 | size_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;
|
---|
[352] | 166 | }
|
---|
| 167 |
|
---|
[374] | 168 | void stdio_delete(struct SHELL_FILE *fp)
|
---|
[352] | 169 | {
|
---|
| 170 | }
|
---|
| 171 |
|
---|
[374] | 172 | int sio_close(struct SHELL_FILE *fp)
|
---|
[352] | 173 | {
|
---|
[374] | 174 | return -EPERM;
|
---|
| 175 | }
|
---|
[352] | 176 |
|
---|
[374] | 177 | size_t sio_read(struct SHELL_FILE *fp, unsigned char *data, size_t len)
|
---|
| 178 | {
|
---|
| 179 | return -EPERM;
|
---|
[352] | 180 | }
|
---|
| 181 |
|
---|
[374] | 182 | size_t sio_write(struct SHELL_FILE *fp, const unsigned char *data, size_t len)
|
---|
[352] | 183 | {
|
---|
[374] | 184 | return -EPERM;
|
---|
[352] | 185 | }
|
---|
| 186 |
|
---|
[374] | 187 | off_t sio_seek(struct SHELL_FILE *fp, off_t ofs, int org)
|
---|
[352] | 188 | {
|
---|
[374] | 189 | return -EPERM;
|
---|
[352] | 190 | }
|
---|
| 191 |
|
---|
[374] | 192 | int sio_ioctl(struct SHELL_FILE *fp, int request, void *arg)
|
---|
[352] | 193 | {
|
---|
[374] | 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 | }
|
---|
[352] | 204 |
|
---|
[374] | 205 | return -EINVAL;
|
---|
[352] | 206 | }
|
---|
| 207 |
|
---|
[374] | 208 | bool_t sio_readable(struct SHELL_FILE *fp)
|
---|
[352] | 209 | {
|
---|
[374] | 210 | return fp->readevt_w != fp->readevt_r;
|
---|
[352] | 211 | }
|
---|
| 212 |
|
---|
[374] | 213 | void sio_delete(struct SHELL_FILE *fp)
|
---|
[352] | 214 | {
|
---|
[374] | 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;
|
---|
[352] | 219 | }
|
---|
| 220 |
|
---|
[374] | 221 | struct SHELL_FILE *new_fp(IO_TYPE *type, int id, int writable)
|
---|
[352] | 222 | {
|
---|
[374] | 223 | struct SHELL_FILE *fp = NULL;
|
---|
| 224 | ER ret;
|
---|
[352] | 225 |
|
---|
[374] | 226 | ret = wai_sem(SEM_FILEDESC);
|
---|
| 227 | if (ret < 0) {
|
---|
| 228 | syslog(LOG_ERROR, "wai_sem => %d", ret);
|
---|
| 229 | }
|
---|
[352] | 230 |
|
---|
[374] | 231 | for (int fd = 3; fd < fd_table_count; fd++) {
|
---|
| 232 | fp = &fd_table[fd];
|
---|
| 233 | if (fp->type != NULL)
|
---|
| 234 | continue;
|
---|
| 235 |
|
---|
| 236 | memset(fp, 0, sizeof(struct SHELL_FILE));
|
---|
| 237 | fp->fd = fd;
|
---|
| 238 | fp->type = type;
|
---|
| 239 | fp->handle = id;
|
---|
| 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 |
|
---|
[352] | 249 | return fp;
|
---|
| 250 | }
|
---|
| 251 |
|
---|
[374] | 252 | struct SHELL_FILE *id_to_fd(IO_TYPE *type, int id)
|
---|
[352] | 253 | {
|
---|
[374] | 254 | struct SHELL_FILE *fp = NULL;
|
---|
| 255 | ER ret;
|
---|
[352] | 256 |
|
---|
[374] | 257 | ret = wai_sem(SEM_FILEDESC);
|
---|
| 258 | if (ret < 0) {
|
---|
| 259 | syslog(LOG_ERROR, "wai_sem => %d", ret);
|
---|
| 260 | }
|
---|
[352] | 261 |
|
---|
[374] | 262 | for (int fd = 3; fd < fd_table_count; fd++) {
|
---|
| 263 | fp = &fd_table[fd];
|
---|
| 264 | if ((fp->type == type) && (fp->handle == id))
|
---|
| 265 | break;
|
---|
| 266 | }
|
---|
[352] | 267 |
|
---|
[374] | 268 | ret = sig_sem(SEM_FILEDESC);
|
---|
| 269 | if (ret < 0) {
|
---|
| 270 | syslog(LOG_ERROR, "sig_sem => %d", ret);
|
---|
| 271 | }
|
---|
[352] | 272 |
|
---|
| 273 | return fp;
|
---|
| 274 | }
|
---|
| 275 |
|
---|
[374] | 276 | int delete_fd_by_id(IO_TYPE *type, int id)
|
---|
[352] | 277 | {
|
---|
[374] | 278 | struct SHELL_FILE *fp = id_to_fd(type, id);
|
---|
| 279 | if (fp == NULL)
|
---|
| 280 | return -EBADF;
|
---|
[352] | 281 |
|
---|
[374] | 282 | return delete_fp(fp);
|
---|
[352] | 283 | }
|
---|
| 284 |
|
---|
[374] | 285 | int delete_fp(struct SHELL_FILE *fp)
|
---|
[352] | 286 | {
|
---|
[374] | 287 | ER ret;
|
---|
[352] | 288 |
|
---|
[374] | 289 | fp->type->delete(fp);
|
---|
[352] | 290 |
|
---|
[374] | 291 | ret = wai_sem(SEM_FILEDESC);
|
---|
| 292 | if (ret < 0) {
|
---|
| 293 | syslog(LOG_ERROR, "wai_sem => %d", ret);
|
---|
| 294 | }
|
---|
[352] | 295 |
|
---|
[374] | 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 | }
|
---|
| 302 |
|
---|
| 303 | return 0;
|
---|
[352] | 304 | }
|
---|
| 305 |
|
---|
[374] | 306 | struct SHELL_FILE *fd_to_fp(int fd)
|
---|
[352] | 307 | {
|
---|
[374] | 308 | if ((fd < 0) || (fd >= fd_table_count))
|
---|
| 309 | return NULL;
|
---|
| 310 | return &fd_table[fd];
|
---|
[352] | 311 | }
|
---|
| 312 |
|
---|
[374] | 313 | void memand(void *dst, void *src, size_t len)
|
---|
[364] | 314 | {
|
---|
| 315 | uint8_t *d = (uint8_t *)dst;
|
---|
| 316 | uint8_t *s = (uint8_t *)src;
|
---|
| 317 | uint8_t *e = &s[len];
|
---|
| 318 |
|
---|
| 319 | while (s < e) {
|
---|
[374] | 320 | *d++ &= *s++;
|
---|
[364] | 321 | }
|
---|
| 322 | }
|
---|
| 323 |
|
---|
[352] | 324 | struct fd_events {
|
---|
| 325 | int count;
|
---|
| 326 | fd_set readfds;
|
---|
| 327 | fd_set writefds;
|
---|
| 328 | fd_set errorfds;
|
---|
| 329 | };
|
---|
| 330 |
|
---|
| 331 | ER shell_get_evts(struct fd_events *evts, TMO tmout);
|
---|
| 332 |
|
---|
| 333 | #define TMO_MAX INT_MAX
|
---|
| 334 |
|
---|
| 335 | int shell_select(int n, fd_set *__restrict rfds, fd_set *__restrict wfds, fd_set *__restrict efds, struct timeval *__restrict tv)
|
---|
| 336 | {
|
---|
| 337 | ER ret;
|
---|
| 338 | TMO tmout = TMO_FEVR;
|
---|
| 339 | struct fd_events evts;
|
---|
| 340 |
|
---|
| 341 | if (tv != NULL) {
|
---|
| 342 | if (tv->tv_sec < (TMO_MAX / 1000000))
|
---|
| 343 | tmout = tv->tv_sec * 1000000 + tv->tv_usec;
|
---|
| 344 | else
|
---|
| 345 | tmout = TMO_MAX;
|
---|
| 346 | }
|
---|
| 347 |
|
---|
[364] | 348 | if (rfds != NULL)
|
---|
| 349 | memcpy(&evts.readfds, rfds, sizeof(fd_set));
|
---|
| 350 | else
|
---|
| 351 | memset(&evts.readfds, 0, sizeof(fd_set));
|
---|
| 352 | if (wfds != NULL)
|
---|
| 353 | memcpy(&evts.writefds, wfds, sizeof(fd_set));
|
---|
| 354 | else
|
---|
| 355 | memset(&evts.writefds, 0, sizeof(fd_set));
|
---|
| 356 | if (efds != NULL)
|
---|
| 357 | memcpy(&evts.errorfds, efds, sizeof(fd_set));
|
---|
| 358 | else
|
---|
| 359 | memset(&evts.errorfds, 0, sizeof(fd_set));
|
---|
[352] | 360 | evts.count = 0;
|
---|
| 361 |
|
---|
| 362 | ret = shell_get_evts(&evts, tmout);
|
---|
| 363 | if (ret == E_OK) {
|
---|
[364] | 364 | if (rfds != NULL)
|
---|
[374] | 365 | memand(rfds, &evts.readfds, sizeof(fd_set));
|
---|
[364] | 366 | if (wfds != NULL)
|
---|
[374] | 367 | memand(wfds, &evts.writefds, sizeof(fd_set));
|
---|
[364] | 368 | if (efds != NULL)
|
---|
[374] | 369 | memand(efds, &evts.errorfds, sizeof(fd_set));
|
---|
[352] | 370 | return evts.count;
|
---|
| 371 | }
|
---|
| 372 | if (ret == E_TMOUT) {
|
---|
[374] | 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));
|
---|
[352] | 379 | return 0;
|
---|
| 380 | }
|
---|
| 381 |
|
---|
| 382 | return -EBADF;
|
---|
| 383 | }
|
---|
| 384 |
|
---|
| 385 | int shell_poll(struct pollfd *fds, nfds_t nfds, int timeout)
|
---|
| 386 | {
|
---|
| 387 | ER ret;
|
---|
| 388 | TMO tmout;
|
---|
| 389 | struct fd_events evts;
|
---|
| 390 |
|
---|
| 391 | if(timeout < 0)
|
---|
| 392 | tmout = TMO_FEVR;
|
---|
| 393 | else if (timeout < (TMO_MAX / 1000))
|
---|
| 394 | tmout = timeout * 1000;
|
---|
| 395 | else
|
---|
| 396 | tmout = TMO_MAX;
|
---|
| 397 |
|
---|
| 398 | memset(&evts, 0, sizeof(evts));
|
---|
| 399 |
|
---|
| 400 | for (int i = 0; i < nfds; i++) {
|
---|
| 401 | struct pollfd *pfd = &fds[i];
|
---|
| 402 | int fd = pfd->fd;
|
---|
| 403 | if ((fd < 0) || (fd >= fd_table_count))
|
---|
| 404 | continue;
|
---|
| 405 |
|
---|
| 406 | if (pfd->events & POLLIN)
|
---|
| 407 | FD_SET(fd, &evts.readfds);
|
---|
| 408 | if (pfd->events & POLLOUT)
|
---|
| 409 | FD_SET(fd, &evts.writefds);
|
---|
| 410 | if (pfd->events & POLLERR)
|
---|
| 411 | FD_SET(fd, &evts.errorfds);
|
---|
| 412 | pfd->revents = 0;
|
---|
| 413 | }
|
---|
| 414 |
|
---|
| 415 | ret = shell_get_evts(&evts, tmout);
|
---|
| 416 | if (ret == E_OK) {
|
---|
| 417 | int result = 0;
|
---|
| 418 | for (int i = 0; i < nfds; i++) {
|
---|
| 419 | struct pollfd *pfd = &fds[i];
|
---|
| 420 | int fd = pfd->fd;
|
---|
| 421 | if ((fd < 0) || (fd >= fd_table_count))
|
---|
| 422 | continue;
|
---|
| 423 |
|
---|
| 424 | if (FD_ISSET(fd, &evts.readfds))
|
---|
| 425 | pfd->revents |= POLLIN;
|
---|
| 426 | if (FD_ISSET(fd, &evts.writefds))
|
---|
| 427 | pfd->revents |= POLLOUT;
|
---|
| 428 | if (FD_ISSET(fd, &evts.errorfds))
|
---|
| 429 | pfd->revents |= POLLERR;
|
---|
| 430 | if (pfd->revents != 0)
|
---|
| 431 | result++;
|
---|
| 432 | }
|
---|
| 433 | return result;
|
---|
| 434 | }
|
---|
| 435 | if (ret == E_TMOUT) {
|
---|
| 436 | return 0;
|
---|
| 437 | }
|
---|
| 438 |
|
---|
| 439 | return -EBADF;
|
---|
| 440 | }
|
---|
| 441 |
|
---|
| 442 | /* TODO:コールバック化したい */
|
---|
| 443 | void stdio_update_evts()
|
---|
| 444 | {
|
---|
| 445 | int fd = STDIN_FILENO;
|
---|
[374] | 446 | struct SHELL_FILE *fp = &fd_table[fd];
|
---|
[352] | 447 | FLGPTN flgptn = 0;
|
---|
| 448 |
|
---|
[374] | 449 | if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
|
---|
[352] | 450 | if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
|
---|
| 451 |
|
---|
| 452 | FD_SET(fd, (fd_set *)&flgptn);
|
---|
| 453 | }
|
---|
[374] | 454 | if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
|
---|
[352] | 455 | if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
|
---|
| 456 |
|
---|
| 457 | FD_SET(fd, (fd_set *)&flgptn);
|
---|
| 458 | }
|
---|
| 459 |
|
---|
| 460 | if (flgptn != 0) {
|
---|
| 461 | set_flg(FLG_SELECT_WAIT, flgptn);
|
---|
| 462 | }
|
---|
| 463 | }
|
---|
| 464 |
|
---|
| 465 | /* TODO:コールバック化したい */
|
---|
| 466 | void stdio_flgptn(FLGPTN *flgptn)
|
---|
| 467 | {
|
---|
| 468 | int fd = STDIN_FILENO;
|
---|
[374] | 469 | struct SHELL_FILE *fp = &fd_table[fd];
|
---|
[352] | 470 | *flgptn = 0;
|
---|
| 471 |
|
---|
[374] | 472 | if (serial_readable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
|
---|
[352] | 473 | if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
|
---|
| 474 |
|
---|
| 475 | FD_SET(fd, (fd_set *)flgptn);
|
---|
| 476 | }
|
---|
[374] | 477 | if (serial_writable((serial_t *)((struct ntstdio_t *)fp->exinf)->exinf)) {
|
---|
[352] | 478 | if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
|
---|
| 479 |
|
---|
| 480 | FD_SET(fd, (fd_set *)flgptn);
|
---|
| 481 | }
|
---|
| 482 | }
|
---|
| 483 |
|
---|
| 484 | ER shell_get_evts(struct fd_events *evts, TMO tmout)
|
---|
| 485 | {
|
---|
| 486 | int count = 0;
|
---|
[364] | 487 | SYSTIM prev, now;
|
---|
[352] | 488 |
|
---|
[364] | 489 | get_tim(&prev);
|
---|
[352] | 490 |
|
---|
[364] | 491 | for (;;) {
|
---|
| 492 | ER ret;
|
---|
| 493 | FLGPTN waitptn, flgptn, readfds = 0, writefds = 0;
|
---|
[374] | 494 | struct SHELL_FILE *fp = NULL;
|
---|
[364] | 495 |
|
---|
| 496 | stdio_update_evts();
|
---|
| 497 |
|
---|
[352] | 498 | #ifndef NTSHELL_NO_SOCKET
|
---|
[364] | 499 | waitptn = *((FLGPTN *)&evts->errorfds);
|
---|
[352] | 500 | #else
|
---|
[364] | 501 | waitptn = *((FLGPTN *)&evts->readfds) | *((FLGPTN *)&evts->errorfds);
|
---|
[352] | 502 | #endif
|
---|
[364] | 503 | for (int fd = 0; fd < fd_table_count; fd++) {
|
---|
| 504 | fp = &fd_table[fd];
|
---|
[352] | 505 |
|
---|
| 506 | #ifndef NTSHELL_NO_SOCKET
|
---|
[364] | 507 | if (FD_ISSET(fd, &evts->readfds)) {
|
---|
[374] | 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--;
|
---|
[364] | 512 | }
|
---|
| 513 | else {
|
---|
| 514 | FD_SET(fd, (fd_set *)&waitptn);
|
---|
| 515 | }
|
---|
| 516 | }
|
---|
| 517 | #endif
|
---|
| 518 | if (FD_ISSET(fd, &evts->writefds)) {
|
---|
| 519 | if (fp->writeevt_w == fp->writeevt_r) {
|
---|
| 520 | FD_SET(fd, (fd_set *)&writefds);
|
---|
| 521 | count++;
|
---|
| 522 | if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_r--;
|
---|
| 523 | }
|
---|
| 524 | else {
|
---|
| 525 | FD_SET(fd, (fd_set *)&waitptn);
|
---|
| 526 | }
|
---|
| 527 | }
|
---|
| 528 | }
|
---|
| 529 | memset(evts, 0, sizeof(*evts));
|
---|
| 530 |
|
---|
| 531 | if (waitptn == 0) {
|
---|
| 532 | memcpy(&evts->readfds, &readfds, sizeof(evts->readfds));
|
---|
| 533 | memcpy(&evts->writefds, &writefds, sizeof(evts->writefds));
|
---|
| 534 | evts->count = count;
|
---|
| 535 | return E_OK;
|
---|
| 536 | }
|
---|
| 537 | else if ((readfds | writefds) != 0) {
|
---|
| 538 | set_flg(FLG_SELECT_WAIT, (readfds | writefds));
|
---|
| 539 | }
|
---|
| 540 |
|
---|
| 541 | /* イベント待ち */
|
---|
| 542 | flgptn = 0;
|
---|
| 543 | ret = twai_flg(FLG_SELECT_WAIT, waitptn, TWF_ORW, &flgptn, tmout);
|
---|
| 544 | if (ret != E_OK) {
|
---|
| 545 | if (ret != E_TMOUT) {
|
---|
| 546 | syslog(LOG_ERROR, "twai_flg => %d", ret);
|
---|
| 547 | return ret;
|
---|
| 548 | }
|
---|
| 549 |
|
---|
| 550 | stdio_flgptn(&flgptn);
|
---|
| 551 |
|
---|
| 552 | if (flgptn == 0)
|
---|
| 553 | return E_TMOUT;
|
---|
| 554 | }
|
---|
| 555 | flgptn &= waitptn;
|
---|
| 556 |
|
---|
| 557 | /* 受け取ったフラグのみクリア */
|
---|
| 558 | ret = clr_flg(FLG_SELECT_WAIT, ~flgptn);
|
---|
| 559 | if (ret != E_OK) {
|
---|
| 560 | syslog(LOG_ERROR, "clr_flg => %d", ret);
|
---|
| 561 | }
|
---|
| 562 |
|
---|
| 563 | count = 0;
|
---|
| 564 | for (int fd = 0; fd < fd_table_count; fd++) {
|
---|
| 565 | if (!FD_ISSET(fd, (fd_set *)&waitptn))
|
---|
| 566 | continue;
|
---|
| 567 |
|
---|
| 568 | fp = &fd_table[fd];
|
---|
| 569 |
|
---|
| 570 | if (fp->readevt_w != fp->readevt_r) {
|
---|
| 571 | fp->readevt_r++;
|
---|
| 572 | FD_SET(fd, &evts->readfds);
|
---|
[352] | 573 | count++;
|
---|
| 574 | }
|
---|
[364] | 575 | if (fp->writeevt_w != fp->writeevt_r) {
|
---|
| 576 | fp->writeevt_r++;
|
---|
| 577 | fp->writable = 1;
|
---|
[352] | 578 | }
|
---|
| 579 | if (fp->writable) {
|
---|
[364] | 580 | FD_SET(fd, &evts->writefds);
|
---|
[352] | 581 | count++;
|
---|
| 582 | }
|
---|
[364] | 583 | if (fp->errorevt_w != fp->errorevt_r) {
|
---|
| 584 | fp->errorevt_r++;
|
---|
| 585 | FD_SET(fd, &evts->errorfds);
|
---|
| 586 | count++;
|
---|
[352] | 587 | }
|
---|
| 588 | }
|
---|
| 589 |
|
---|
[364] | 590 | if (count > 0)
|
---|
| 591 | break;
|
---|
[352] | 592 |
|
---|
[364] | 593 | get_tim(&now);
|
---|
[352] | 594 |
|
---|
[364] | 595 | SYSTIM elapse = now - prev;
|
---|
| 596 | if (elapse > tmout)
|
---|
[352] | 597 | return E_TMOUT;
|
---|
| 598 |
|
---|
[364] | 599 | prev = now;
|
---|
| 600 | tmout -= elapse;
|
---|
[352] | 601 | }
|
---|
| 602 |
|
---|
| 603 | evts->count = count;
|
---|
| 604 |
|
---|
| 605 | return E_OK;
|
---|
| 606 | }
|
---|
| 607 |
|
---|
| 608 | void clean_fd()
|
---|
| 609 | {
|
---|
[374] | 610 | struct SHELL_FILE *fp = NULL;
|
---|
[352] | 611 | for (int fd = 3; fd < fd_table_count; fd++) {
|
---|
| 612 | fp = &fd_table[fd];
|
---|
| 613 | if ((fp->type == 0) || (fp->fd == 0))
|
---|
| 614 | continue;
|
---|
| 615 |
|
---|
[374] | 616 | fp->type->close(fp);
|
---|
[352] | 617 |
|
---|
| 618 | delete_fp(fp);
|
---|
| 619 | }
|
---|
| 620 | }
|
---|
| 621 |
|
---|
| 622 | int shell_ioctl(int fd, int request, void *arg)
|
---|
| 623 | {
|
---|
[374] | 624 | struct SHELL_FILE *fp = fd_to_fp(fd);
|
---|
[352] | 625 | if (fp == NULL)
|
---|
| 626 | return -EBADF;
|
---|
| 627 |
|
---|
[374] | 628 | return fp->type->ioctl(fp, request, arg);
|
---|
[352] | 629 | }
|
---|
| 630 |
|
---|
| 631 | #ifdef NTSHELL_NO_SOCKET
|
---|
| 632 |
|
---|
| 633 | int shell_socket(int family, int type, int protocol)
|
---|
| 634 | {
|
---|
| 635 | return -ENOMEM;
|
---|
| 636 | }
|
---|
| 637 |
|
---|
| 638 | int shell_bind(int fd, const struct sockaddr *addr, socklen_t len)
|
---|
| 639 | {
|
---|
| 640 | return -ENOMEM;
|
---|
| 641 | }
|
---|
| 642 |
|
---|
| 643 | int shell_listen(int fd, int backlog)
|
---|
| 644 | {
|
---|
| 645 | return -ENOMEM;
|
---|
| 646 | }
|
---|
| 647 |
|
---|
| 648 | int shell_connect(int fd, const struct sockaddr *addr, socklen_t len)
|
---|
| 649 | {
|
---|
| 650 | return -ENOMEM;
|
---|
| 651 | }
|
---|
| 652 |
|
---|
| 653 | int shell_accept(int fd, struct sockaddr *__restrict addr, socklen_t *__restrict len)
|
---|
| 654 | {
|
---|
| 655 | return -ENOMEM;
|
---|
| 656 | }
|
---|
| 657 |
|
---|
| 658 | ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
|
---|
| 659 | {
|
---|
| 660 | return -ENOMEM;
|
---|
| 661 | }
|
---|
| 662 |
|
---|
| 663 | ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
|
---|
| 664 | {
|
---|
| 665 | return -ENOMEM;
|
---|
| 666 | }
|
---|
| 667 |
|
---|
[364] | 668 | ssize_t shell_recvfrom(int fd, void *__restrict buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
|
---|
[352] | 669 | {
|
---|
| 670 | return -ENOMEM;
|
---|
| 671 | }
|
---|
| 672 |
|
---|
| 673 | ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
|
---|
| 674 | {
|
---|
| 675 | return -ENOMEM;
|
---|
| 676 | }
|
---|
| 677 |
|
---|
| 678 | int shell_shutdown(int fd, int how)
|
---|
| 679 | {
|
---|
| 680 | return -ENOMEM;
|
---|
| 681 | }
|
---|
| 682 |
|
---|
| 683 | int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *__restrict optlen)
|
---|
| 684 | {
|
---|
| 685 | return -ENOMEM;
|
---|
| 686 | }
|
---|
| 687 |
|
---|
| 688 | int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
|
---|
| 689 | {
|
---|
| 690 | return -ENOMEM;
|
---|
| 691 | }
|
---|
| 692 |
|
---|
| 693 | int shell_getpeername(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
|
---|
| 694 | {
|
---|
| 695 | return -ENOMEM;
|
---|
| 696 | }
|
---|
| 697 |
|
---|
| 698 | int shell_getsockname(int fd, struct sockaddr *restrict addr, socklen_t *restrict len)
|
---|
| 699 | {
|
---|
| 700 | return -ENOMEM;
|
---|
| 701 | }
|
---|
| 702 | #endif
|
---|