/*
 *  TOPPERS ECHONET Lite Communication Middleware
 * 
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 * 
 *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
 *      免責すること．
 * 
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  の責任を負わない．
 * 
 *  @(#) $Id: shellif.c 286 2017-05-02 15:25:33Z coas-nagasima $
 */
#include <setjmp.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
#include <poll.h>
#include <stdarg.h>
#include "shellif.h"
#include "analogin_api.h"
#include "gpio_api.h"
#include "i2c_api.h"
#include "pwmout_api.h"
#include "rtc_api.h"
#include "serial_api.h"
#include "us_ticker_api.h"
#include "wait_api.h"
#include "arduino.h"
#include "usrcmd.h"
#include <sys/mman.h>
#include <signal.h>

typedef struct __dirstream DIR;

typedef void (*analogin_init_t)(analogin_t *obj, PinName pin);
typedef uint16_t (*analogin_read_u16_t)(analogin_t *obj);
typedef void (*gpio_init_t)(gpio_t *obj, PinName pin);
typedef void (*gpio_dir_t)(gpio_t *obj, PinDirection direction);
typedef int (*i2c_start_t)(i2c_t *obj);
typedef int (*i2c_stop_t)(i2c_t *obj);
typedef void (*i2c_init_t)(i2c_t *obj, PinName sda, PinName scl);
typedef int (*i2c_read_t)(i2c_t *obj, int address, char *data, int length, int stop);
typedef int (*i2c_write_t)(i2c_t *obj, int address, const char *data, int length, int stop);
typedef int (*i2c_byte_read_t)(i2c_t *obj, int last);
typedef int (*i2c_byte_write_t)(i2c_t *obj, int data);
typedef void (*pwmout_free_t)(pwmout_t* obj);
typedef void (*pwmout_init_t)(pwmout_t* obj, PinName pin);
typedef void (*pwmout_pulsewidth_us_t)(pwmout_t* obj, int us);
typedef void (*rtc_init_t)(void);
typedef void (*rtc_free_t)(void);
typedef int (*rtc_isenabled_t)(void);
typedef time_t (*rtc_read_t)(void);
typedef void (*rtc_write_t)(time_t t);
typedef void (*serial_baud_t)(serial_t *obj, int baudrate);
typedef void (*serial_init_t)(serial_t *obj, PinName tx, PinName rx);
typedef int (*serial_readable_t)(serial_t *obj);
typedef int (*serial_getc_t)(serial_t *obj);
typedef void (*serial_putc_t)(serial_t *obj, int c);
typedef uint32_t (*us_ticker_read_t)(void);
typedef void (*wait_ms_t)(int ms);
typedef bool (*SD_begin_t)();
typedef int (*usrcmd_cd_t)(int argc, char **argv);
typedef int (*usrcmd_ls_t)(int argc, char **argv);
typedef int (*usrcmd_cp_t)(int argc, char **argv);
typedef int (*usrcmd_rm_t)(int argc, char **argv);
typedef int (*usrcmd_mv_t)(int argc, char **argv);
typedef int (*usrcmd_mkdir_t)(int argc, char **argv);
typedef int (*usrcmd_hexdump_t)(int argc, char **argv);
typedef int (*usrcmd_info_t)(int argc, char **argv);
typedef int (*usrcmd_exit_t)(int argc, char **argv);
typedef void(*shell_abort_t)();
typedef void(*shell_exit_t)(int exitcd);
typedef int (*shell_kill_t)(int pid, int sig);
typedef int (*shell_gettimeofday_t)(struct timeval * tp, void * tzvp);
typedef void (*vsyslog_t)(int priority, const char *format, va_list ap);
typedef int (*shell_open_t)(const char * path, int flags);
typedef int (*shell_close_t)(int fd);
typedef int (*shell_read_t)(int fd, char *data, int len);
typedef int (*shell_write_t)(int fd, char *data, int len);
typedef int (*shell_lseek_t)(int fd, int ptr, int dir);
typedef int (*shell_fstat_t)(int fd, struct stat * st);
typedef int (*shell_stat_t)(const char *fname, struct stat *st);
typedef int (*shell_link_t)(void);
typedef int (*shell_unlink_t)(const char *path);
typedef int (*shell_isatty_t)(int fd);
typedef int (*fsync_t)(int fd);
typedef int (*ftruncate_t)(int fd, off_t length);
typedef int (*ioctl_t)(int fd, int request, va_list ap);
typedef int (*tcgetattr_t)(int fd, struct termios *termios_p);
typedef int (*tcsetattr_t)(int fd, int optional_actions, const struct termios *termios_p);
typedef int (*shell_rename_t)(const char *oldpath, const char *newpath);
typedef int (*rmdir_t)(const char *path);
typedef int (*mkdir_t)(const char *path, mode_t mode);
typedef int (*chmod_t)(const char *path, mode_t mode);
typedef char *(*getcwd_t)(char *buf, size_t size);
typedef int (*chdir_t)(const char *path);
typedef int (*chroot_t)(const char *path);
typedef int (*closedir_t)(DIR *dir);
typedef DIR *(*opendir_t)(const char *path);
typedef struct dirent *(*readdir_t)(DIR *dir);
typedef void (*rewinddir_t)(DIR *dir);
typedef void (*seekdir_t)(DIR *dir, long pos);
typedef long (*telldir_t)(DIR *dir);
typedef int (*shell_getpid_t)();
typedef int (*socket_t)(int family, int type, int protocol);
typedef int (*bind_t)(int fd, const struct sockaddr *addr, socklen_t len);
typedef int (*listen_t)(int fd, int backlog);
typedef int (*connect_t)(int fd, const struct sockaddr *addr, socklen_t len);
typedef int (*accept_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef ssize_t (*send_t)(int fd, const void *buf, size_t len, int flags);
typedef ssize_t (*sendto_t)(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen);
typedef ssize_t (*recv_t)(int fd, void *buf, size_t len, int flags);
typedef ssize_t (*recvfrom_t)(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen);
typedef int (*shutdown_t)(int fd, int how);
typedef int (*getsockopt_t)(int fd, int level, int optname, void *optval, socklen_t *optlen);
typedef int (*setsockopt_t)(int fd, int level, int optname, const void *optval, socklen_t optlen);
typedef int (*select_t)(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv);
typedef int (*poll_t)(struct pollfd *fds, nfds_t nfds, int timeout);
typedef int (*gethostname_t)(char *name, size_t len);
typedef int (*getnameinfo_t)(const struct sockaddr *sa, socklen_t sl, char *node, socklen_t nodelen, char *serv, socklen_t servlen, int flags);
typedef int (*getpeername_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef int (*getsockname_t)(int fd, struct sockaddr *addr, socklen_t *len);
typedef int (*socketpair_t)(int family, int type, int protocol, int fd[2]);

void analogin_init(analogin_t *obj, PinName pin)
{
	__imp_analogin_init(obj, pin);
}

uint16_t analogin_read_u16(analogin_t *obj)
{
	return __imp_analogin_read_u16(obj);
}

void gpio_init(gpio_t *obj, PinName pin)
{
	__imp_gpio_init(obj, pin);
}

void gpio_dir(gpio_t *obj, PinDirection direction)
{
	__imp_gpio_dir(obj, direction);
}

int i2c_start(i2c_t *obj)
{
	return __imp_i2c_start(obj);
}

int i2c_stop(i2c_t *obj)
{
	return __imp_i2c_stop(obj);
}

void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{
	__imp_i2c_init(obj, sda, scl);
}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
	return __imp_i2c_read(obj, address, data, length, stop);
}

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
	return __imp_i2c_write(obj, address, data, length, stop);
}

int i2c_byte_read(i2c_t *obj, int last)
{
	return __imp_i2c_byte_read(obj, last);
}

int i2c_byte_write(i2c_t *obj, int data)
{
	return __imp_i2c_byte_write(obj, data);
}

void pwmout_free(pwmout_t* obj)
{
	__imp_pwmout_free(obj);
}

void pwmout_init(pwmout_t* obj, PinName pin)
{
	__imp_pwmout_init(obj, pin);
}

void pwmout_pulsewidth_us(pwmout_t* obj, int us)
{
	__imp_pwmout_pulsewidth_us(obj, us);
}

void rtc_init(void)
{
	__imp_rtc_init();
}

void rtc_free(void)
{
	__imp_rtc_free();
}

int rtc_isenabled(void)
{
	return __imp_rtc_isenabled();
}

time_t rtc_read(void)
{
	return __imp_rtc_read();
}

void rtc_write(time_t t)
{
	__imp_rtc_write(t);
}

void serial_baud(serial_t *obj, int baudrate)
{
	__imp_serial_baud(obj, baudrate);
}

void serial_init(serial_t *obj, PinName tx, PinName rx)
{
	__imp_serial_init(obj, tx, rx);
}

int serial_readable(serial_t *obj)
{
	return __imp_serial_readable(obj);
}

int serial_getc(serial_t *obj)
{
	return __imp_serial_getc(obj);
}

void serial_putc(serial_t *obj, int c)
{
	__imp_serial_putc(obj, c);
}

uint32_t us_ticker_read(void)
{
	return __imp_us_ticker_read();
}

void wait_ms(int ms)
{
	__imp_wait_ms(ms);
}

bool SD_begin()
{
	return __imp_SD_begin();
}

int usrcmd_cd(int argc, char **argv)
{
	return __imp_usrcmd_cd(argc, argv);
}

int usrcmd_ls(int argc, char **argv)
{
	return __imp_usrcmd_ls(argc, argv);
}

int usrcmd_cp(int argc, char **argv)
{
	return __imp_usrcmd_cp(argc, argv);
}

int usrcmd_rm(int argc, char **argv)
{
	return __imp_usrcmd_rm(argc, argv);
}

int usrcmd_mv(int argc, char **argv)
{
	return __imp_usrcmd_mv(argc, argv);
}

int usrcmd_mkdir(int argc, char **argv)
{
	return __imp_usrcmd_mkdir(argc, argv);
}

int usrcmd_hexdump(int argc, char **argv)
{
	return __imp_usrcmd_hexdump(argc, argv);
}

int usrcmd_info(int argc, char **argv)
{
	return __imp_usrcmd_info(argc, argv);
}

int usrcmd_exit(int argc, char **argv)
{
	return __imp_usrcmd_exit(argc, argv);
}

void abort()
{
	__imp_shell_abort();
}

void _exit(int exitcd)
{
	__imp_shell_exit(exitcd);
}

int _kill(int pid, int sig)
{
	return __imp_shell_kill(pid, sig);
}

int _gettimeofday(struct timeval * tp, void * tzvp)
{
	return __imp_shell_gettimeofday(tp, tzvp);
}

void vsyslog(int priority, const char *format, va_list ap)
{
	__imp_vsyslog(priority, format, ap);
}

void syslog(int priority, const char *format, ...)
{
	va_list ap;
	va_start(ap, format);
	vsyslog(priority, format, ap);
	va_end(ap);
}

int _open(const char * path, int flags)
{
	return __imp_shell_open(path, flags);
}

int _close(int fd)
{
	return __imp_shell_close(fd);
}

int _read(int fd, char *data, int len)
{
	return __imp_shell_read(fd, data, len);
}

int _write(int fd, char *data, int len)
{
	return __imp_shell_write(fd, data, len);
}

int _lseek(int fd, int ptr, int dir)
{
	return __imp_shell_lseek(fd, ptr, dir);
}

int _fstat(int fd, struct stat * st)
{
	return __imp_shell_fstat(fd, st);
}

int _stat(const char *fname, struct stat *st)
{
	return __imp_shell_stat(fname, st);
}

int _link(void)
{
	return __imp_shell_link();
}

int _unlink(const char *path)
{
	return __imp_shell_unlink(path);
}

int _isatty(int fd)
{
	return __imp_shell_isatty(fd);
}

int fsync(int fd)
{
	return __imp_fsync(fd);
}

int ftruncate(int fd, off_t length)
{
	return __imp_ftruncate(fd, length);
}

int ioctl(int fd, int request, ...)
{
	int result;
	va_list ap;
	va_start(ap, request);
	result = __imp_ioctl(fd, request, ap);
	va_end(ap);
	return result;
}

int tcgetattr(int fd, struct termios *termios_p)
{
	return __imp_tcgetattr(fd, termios_p);
}

int tcsetattr(int fd, int optional_actions, const struct termios *termios_p)
{
	return __imp_tcsetattr(fd, optional_actions, termios_p);
}

int _rename(const char *oldpath, const char *newpath)
{
	return __imp_shell_rename(oldpath, newpath);
}

int rmdir(const char *path)
{
	return __imp_rmdir(path);
}

int mkdir(const char *path, mode_t mode)
{
	return __imp_mkdir(path, mode);
}

int chmod(const char *path, mode_t mode)
{
	return __imp_chmod(path, mode);
}

char *getcwd(char *buf, size_t size)
{
	return __imp_getcwd(buf, size);
}

int chdir(const char *path)
{
	return __imp_chdir(path);
}

int chroot(const char *path)
{
	return __imp_chroot(path);
}

int closedir(DIR *dir)
{
	return __imp_closedir(dir);
}

DIR *opendir(const char *path)
{
	return __imp_opendir(path);
}

struct dirent *readdir(DIR *dir)
{
	return __imp_readdir(dir);
}

void rewinddir(DIR *dir)
{
	__imp_rewinddir(dir);
}

void seekdir(DIR *dir, long pos)
{
	__imp_seekdir(dir, pos);
}

long telldir(DIR *dir)
{
	return __imp_telldir(dir);
}

int _getpid()
{
	return __imp_shell_getpid();
}

int socket(int family, int type, int protocol)
{
	return __imp_socket(family, type, protocol);
}

int bind(int fd, const struct sockaddr *addr, socklen_t len)
{
	return __imp_bind(fd, addr, len);
}

int listen(int fd, int backlog)
{
	return __imp_listen(fd, backlog);
}

int connect(int fd, const struct sockaddr *addr, socklen_t len)
{
	return __imp_connect(fd, addr, len);
}

int accept(int fd, struct sockaddr *addr, socklen_t *len)
{
	return __imp_accept(fd, addr, len);
}

ssize_t send(int fd, const void *buf, size_t len, int flags)
{
	return __imp_send(fd, buf, len, flags);
}

ssize_t sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
{
	return __imp_sendto(fd, buf, len, flags, addr, alen);
}

ssize_t recv(int fd, void *buf, size_t len, int flags)
{
	return __imp_recv(fd, buf, len, flags);
}

ssize_t recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen)
{
	return __imp_recvfrom(fd, buf, len, flags, addr, alen);
}

int shutdown(int fd, int how)
{
	return __imp_shutdown(fd, how);
}

int getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
{
	return __imp_getsockopt(fd, level, optname, optval, optlen);
}

int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
{
	return __imp_setsockopt(fd, level, optname, optval, optlen);
}

int select(int n, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tv)
{
	return __imp_select(n, rfds, wfds, efds, tv);
}

int poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
	return __imp_poll(fds, nfds, timeout);
}

unsigned if_nametoindex(const char *name)
{
	return 1;
}

int gethostname(char *name, size_t len)
{
	return __imp_gethostname(name, len);
}

int getnameinfo(const struct sockaddr *sa, socklen_t sl,
	char *node, socklen_t nodelen,
	char *serv, socklen_t servlen,
	int flags)
{
	return __imp_getnameinfo(sa, sl, node, nodelen, serv, servlen, flags);
}

int getpeername(int fd, struct sockaddr *addr, socklen_t *len)
{
	return __imp_getpeername(fd, addr, len);
}

int getsockname(int fd, struct sockaddr *addr, socklen_t *len)
{
	return __imp_getsockname(fd, addr, len);
}

int socketpair(int family, int type, int protocol, int fd[2])
{
	return __imp_socketpair(family, type, protocol, fd);
}

char *basename(char *s)
{
	size_t i, j;
	if (!s || !*s) return ".";
	i = strlen(s) - 1;
	for (j = 0; j <= i; j++) if (s[j] == ':') { s = &s[j + 1]; i -= j; break; }
	for (; i&&s[i] == '/'; i--) s[i] = 0;
	for (; i&&s[i - 1] != '/'; i--);
	return s + i;
}

char *dirname(char *_s)
{
	char *s = _s;
	size_t i, j;
	if (!s || !*s) return ".";
	i = strlen(s) - 1;
	for (j = 0; j <= i; j++) if (s[j] == ':') { s = &s[j + 1]; i -= j; break; }
	for (; s[i] == '/'; i--) if (!i) return (s == _s) ? "/" : _s;
	for (; s[i] != '/'; i--) if (!i) return (s == _s) ? "." : _s;
	for (; s[i] == '/'; i--) if (!i) if (s == _s) return "/"; else break;
	s[i + 1] = 0;
	return _s;
}

char *realpath(const char *filename, char *resolved)
{
	char *path = getcwd(resolved, 256);

	if (path != NULL)
		strcat(path, filename);

	return path;
}

uint32_t htonl(uint32_t n)
{
	return (n >> 24) | ((n >> 8) & 0xFF00) | ((n << 8) & 0xFF0000) | (n << 24);
}

uint32_t ntohl(uint32_t n)
{
	return (n >> 24) | ((n >> 8) & 0xFF00) | ((n << 8) & 0xFF0000) | (n << 24);
}

uint16_t htons(uint16_t n)
{
	return ((n >> 8) & 0xFF) | ((n << 8) & 0xFF00);
}

uint16_t ntohs(uint16_t n)
{
	return ((n >> 8) & 0xFF) | ((n << 8) & 0xFF00);
}

int mprotect(void *addr, size_t len, int prot)
{
	return 0;
}

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
{
	return 0;
}

unsigned int Utf8_to_Utf16(const char *src, int *code_size)
{
	int i;
	unsigned int uc = 0;
	unsigned char len = 0;

	len = 0;
	if ((src[0] & 0x80) == 0) { uc = src[0] & 0x7F; len = 0; }
	else if ((src[0] & 0xE0) == 0xC0) { uc = src[0] & 0x1F; len = 1; }
	else if ((src[0] & 0xF0) == 0xE0) { uc = src[0] & 0x0F; len = 2; }
	else if ((src[0] & 0xF8) == 0xF0) { uc = src[0] & 0x07; len = 3; }
	else if ((src[0] & 0xFC) == 0xF8) { uc = src[0] & 0x03; len = 4; }
	else if ((src[0] & 0xFE) == 0xFC) { uc = src[0] & 0x01; len = 5; }

	i = 1;
	while ((i <= len) && ((src[i] & 0xC0) == 0x80)) {
		uc = (uc << 6) | (src[i] & 0x3F);
		i++;
	}

	//消費文字数設定
	*code_size = i;

	//現状、2バイト限定
	return uc;
}

int bs_char_count(char *str, int pos)
{
	int num = 1, local_pos = pos;
	char *c;

	while (1) {
		c = str + local_pos;

		if ((*c & 0x80) != 0x80)
			return num;

		if (((*c & 0xE0) == 0xC0) && (num == 2)) {
			return num;
		}
		else if (((*c & 0xF0) == 0xE0) && (num == 3)) {
			return num;
		}
		else if (((*c & 0xF8) == 0xF0) && (num == 4)) {
			return num;
		}
		else if (((*c & 0xFC) == 0xF8) && (num == 5)) {
			return num;
		}
		else if (((*c & 0xFE) == 0xFC) && (num == 6)) {
			return num;
		}
		else {
			if (local_pos > 0) {
				local_pos--;
				num++;
			}
			else
				return 0;
		}
	}

	return 0;
}