#undef LIMITED
#undef OLD_VER

#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <mes2.h>
#define USB_RETRY	5
#define MAX_BUF	200
#define MAX_ARG	128
#define MAX_HISTORY 20
#define NONE	0
#define COMMAND	1
#define SYNTAX	2
#define IOERR	3
#define DSKFULL	4
#define CMDFULL	5
#define NOFILE	6
#define MEMFULL	7
#define IGFMT	8
#define ARIGN	9
#define FSCHK	2
static char	prompt[16], echo_flag, history_flag;
static char	cmd_buf[MAX_BUF], *cmd_argv[MAX_ARG], tmp_buf[80];
static int	tftp_timeout, retvalue;
static int	values[32];
static char	*histories;
static int	max_history, cur_history;
static int	shell(int, char*);
int	stoi(char*);

typedef struct {
	int		(*function)(int, char**);
	unsigned char	command[12];
	unsigned char	min, max, opt;
} function_table;

static function_table table[] = {
	{0,"dump",	2, 3, NONE},
	{0,"setdata",	3, 4, NONE},
	{0,"dir",	1, 2, NONE},
	{0,"zeromem",	3, 3, NONE},
	{0,"ifconfig",	1, 4, NONE},
	{0,"gateway",	2, 2, NONE},
	{0,"ping",	2, 4, NONE},
	{0,"echo",	2, 2, NONE},
	{0,"del",	2, 2, NONE},
	{0,"ssid",	3, 4, NONE},
	{0,"wipm",	3, 3, NONE},
	{0,"tftp",	3, 4, NONE},
	{0,"type",	2, 2, NONE},
	{0,"pwd",	1, 1, NONE},
	{0,"cd",	2, 2, NONE},
	{0,"mount",	2, 2, NONE},
	{0,"eject",	2, 2, NONE},
	{0,"format",	2, 2, NONE},
	{0,"copy",	3, 3, NONE},
	{0,"dns",	2, 2, NONE},
	{0,"wep",	1, 6, NONE},
	{0,"wait",	2, 2, NONE},
	{0,"getssid",	2, 2, NONE},
	{0,"tftptime",	2, 2, NONE},
	{0,"ps",	1, 2, NONE},
	{0,"kill",	2, 2, NONE},
	{0,"df",	1, 1, NONE},
	{0,"sleep",	2, 2, NONE},
	{0,"regist",	2, 4, NONE},
	{0,"turbo",	2, 2, NONE},
	{0,"history",	2, 2, NONE},
	{0,"clear",	1, 1, NONE},
	{0,"date",	1, 3, NONE},
	{0,"dd",	3, 5, NONE},
	{0,"rename",	3, 3, NONE},
	{0,"ax88796",	1, 2, NONE},
	{0,"wget",	1, 3, NONE},
#ifndef OLD_VER
	{0,"port",	2, MAX_ARG, NONE},
	{0,"getdata",	2, 3, NONE},
	{0,"mkdir",	2, 2, NONE},
	{0,"meminfo",	1, 1, NONE},
	{0,"memory",	1, 2, NONE},
#endif
	{0,"",		1, MAX_ARG, NONE}
};

static int read_line(int fd, char* buffer, char** argv) {
	unsigned int	argc, n;
	int		i, p;
	unsigned char	c, cbuf[3], *ptr;

	p = 0;
	bzero(buffer, MAX_BUF);
	cur_history = 0;
	for(;;) {
		bzero(cbuf, 3);
		do {
			if(fd == 0) {
				sleep(1);
				n = read(0, (char*)cbuf, 3);
				sleep(1);
				c = cbuf[0];
			} else {
				n = read(fd, (char*)&c, 1);
				if(n == 0) return -1;
			}
		} while(n == 0);
		if(n == 3 && cbuf[0] == 0x1b && cbuf[1] == 0x5b && (cbuf[2] == 0x41 || cbuf[2] == 0x42)) {
			if(cbuf[2] == 0x41) {
				if(cur_history > (max_history - 1)) continue;
			}
			if(cbuf[2] == 0x42) {
				if(cur_history <= 0) continue;
				cur_history --;
			}
			ptr = (unsigned char*)&histories[cur_history * MAX_BUF];
			if(ptr[0] != 0) {
				strcpy(buffer, (char*)ptr);
				if(echo_flag) {
					printf("\033[80D\033[2K%s%s", prompt, buffer);
					p = strlen(buffer);
				}
			}
			if(cbuf[2] == 0x41) {
				cur_history++;
			}
			continue;
		}
		if(c >= 0x80) continue;
		if(c == '\n') break;
		if(c == '\r') break;
		if(c == 0x7f) c = 8;
		if(c == 8) {
			if(p > 0) {
				if(echo_flag) {
					putchar(8);
					putchar(' ');
					putchar(8);
				}
				p--;
			}
		} else {
			if(p <= (MAX_BUF - 2)) {
				if(echo_flag) putchar(c);
				buffer[p++] = c;
			}
		}
	}
	buffer[p] = 0;
	if(buffer[0] == 0) {
		if(echo_flag) putchar('\r');
		return 0;
	}
	if(fd == 0 && max_history > 0) {
		for(i = max_history - 2;i >= 0;i--) {
			strcpy(&histories[(i + 1) * MAX_BUF], &histories[i * MAX_BUF]);
		}
		strcpy(histories, buffer);
	}
	i = argc = 0;
	argv[argc++] = &(buffer[i]);
	while(buffer[i] != 0) {
		if(buffer[i] == ' ') {
			buffer[i] = 0;
			if(argc >= (MAX_ARG - 1)) break;
			argv[argc++] = &(buffer[i + 1]);
		}
		i++;
	}
	argv[argc] = 0;
	return argc;
}

static void err_message(int id) {
	static const char message[10][20] = {
		"Command not found.",
		"Syntax error.",
		"Disk I/O error.",
		"Disk is full.",
		"Buffer is full.",
		"File not found.",
		"Memory is full.",
		"Ignore file format.",
		"Arignment error.",
		"Unknown error."
	};
	int	i;

	i = (id > 9) ? 9 : id - 1;
#ifdef LIMITED
	if(echo_flag) printf("ERR:%s\r", message[i]);
#else
	if(echo_flag) printf("ERROR[%s]\r", message[i]);
#endif
	retvalue = -1;
}

#ifdef LIMITED
static void print_value(int value) {
	if(value >= 100000000) {
		printf("%dM", value / 1000000);
	} else if(value >= 100000) {
		printf("%dk", value / 1000);
	} else {
		printf("%d", value);
	}
}
#endif

static int dump(int argc, char** argv) {
	int	  i, n, num;
	char		  *pb;
	short		  *pw;

	sscanf(argv[argc - 1], "%x", &num);
#ifdef LIMITED
	n = num + 24;
	while(num < n) {
		if(argc == 3 && argv[1][0] == 'w') {
			if(num & 1) return ARIGN;
			pw = (short*)num;
			for(i = 0;i < 4;i++) {
				if(i > 0) putchar(' ');
				printf("%04x", (int)(*pw++) & 0xffff);
			}
		} else {
			pb = (char*)num;
			for(i = 0;i < 8;i++) {
				if(i > 0 && (i % 2) == 0) putchar(' ');
				printf("%02x", (int)(*pb++) & 0xff);
			}
		}
		putchar('\r');
		num += 8;
	}
#else
	n = num + 16 * 8;
	while(num < n) {
		printf("%08x : ", num);
		if(argc == 3 && argv[1][0] == 'w') {
			if(num & 1) return ARIGN;
			pw = (short*)num;
			for(i = 0;i < 8;i++) {
				if(i == 4) printf(" ");
				printf("%04x", (int)(*pw++) & 0xffff);
			}
		} else {
			pb = (char*)num;
			for(i = 0;i < 16;i++) {
				if(i == 8) printf(" ");
				printf("%02x", (int)(*pb++) & 0xff);
			}
		}
		putchar('\r');
		num += 16;
	}
#endif
	return NONE;
}

static int execution(int argc, char** argv) {
	int	pid, waitflag;

	waitflag = 1;
	if(argv[argc - 1][0] == '&' && argv[argc - 1][1] == 0) {
		waitflag = 0;
		argv[--argc] = 0;
	}
	pid = exec(argc, argv);
	if(pid == -1) return NOFILE;
	if(waitflag == 1) {
		wait(pid);
		retvalue = ret_value();
	}
	return NONE;
}

static int set_data(int argc, char** argv) {
	int	num, data;
	char	*addrchar;
	short	*addrword;

	sscanf(argv[argc - 2], "%x", &data);
	addrchar = (char*)data;
	if(argc == 4 && argv[1][0] == 'w' && data & 1) return ARIGN; 
	addrword = (short*)data;
	sscanf(argv[argc - 1], "%x", &num);
	if(addrchar == (char*)-1 || num == -1) return SYNTAX;
	if(argc == 4 && argv[1][0] == 'w') addrword[0] = num;
	else addrchar[0] = num;
	if(echo_flag) printf(" updated.\r");
	return NONE;
}

#ifndef OLD_VER
static int get_data(int argc, char** argv) {
	int	num, data;
	char	*addrchar;
	short	*addrword;

	sscanf(argv[argc - 1], "%x", &data);
	addrchar = (char*)data;
	if(argc == 3 && argv[1][0] == 'w' && data & 1) return ARIGN; 
	addrword = (short*)data;
	if(addrchar == (char*)-1) return SYNTAX;
	if(argc == 3 && argv[1][0] == 'w') {
		num = (int)addrword[0] & 0xffff;
		if(echo_flag) printf("%04x\r", num);
	} else {
		num = (int)addrchar[0] & 0xff;
		if(echo_flag) printf("%02x\r", num);
	}
	retvalue = num;
	return NONE;
}
#endif

static int clear_memory(int argc, char** argv) {
	int	num, data;
	char*	addr;

	sscanf(argv[1], "%x", &data);
	addr = (char*)data;
	sscanf(argv[2], "%x", &num);
	if(addr == (char*)-1 || num == -1) return SYNTAX;
	bzero(addr, num);
	printf(" cleared.\r");
	return NONE;
}

static int dir(int argc, char** argv) {
	int	fd, n, len;
	char	fname[128], *ptr;
	DirEnt	ent;

	fd = SetDirent((argc == 1) ? "" : argv[1], &ent);
	if(fd == -1) return NOFILE;
	n = 0;
	while(NextRecord(fd, &ent) == 0) {
#ifdef LIMITED
		putchar('\r');
		if(ent.attr & 0x10) {
			printf("[%-10s]", ent.name);
		} else {
			printf("%-10s ", ent.name);
			print_value(ent.length);
			putchar('B');
		}
		if((n % 4) == 3) getchar();
#else
		ptr = ent.name;
  #ifndef OLD_VER
		len = get_longname(fd, fname, 127);
		if(len > 0) ptr = fname;
  #endif
		if(ent.attr & 0x10) {
			printf("[%-10s]\r", ptr);
		} else {
			printf("%-10s\t%5d[char]\r", ptr, ent.length);
		}
#endif
		n++;
	}
	close(fd);
	putchar('\r');
	return NONE;
}

#ifndef OLD_VER
// add '10.05.25 tanaka@intecs.org
static int _mkdir(int argc,char **argv) {
	if(mkdir(argv[1]) == -1) return NOFILE;
	return NONE;
}
#endif

static int remove(int argc, char** argv) {
	if(DeleteFile(argv[1]) == -1) return NOFILE;
	return NONE;
}

static int rename(int argc, char** argv) {
	if(RenameFile(argv[1], argv[2]) == -1) return NOFILE;
	return NONE;
}

static int ssid(int argc, char** argv) {
	int	i, fd, dat, net, ret;
	char	str[36], tmp[3];

	net = 0;
	fd = open(argv[1], -1);
	if(fd == -1) {
		net = get_netnum(argv[1]);
		if(net == -1) {
			return IOERR;
		}
	}
	switch(argc) {
	case 3:
		str[34] = 0;
		strncpy(str, argv[2], 34);
		break;
	case 4:
		if(argv[2][0] != 'x') return SYNTAX;
		tmp[2] = 0;
		for(i = 0;i < 34;i++) {
			if(argv[2][i * 2] == 0 || argv[2][i * 2 + 1] == 0) break;
			tmp[0] = argv[2][i * 2];
			tmp[1] = argv[2][i * 2 + 1];
			sscanf(tmp, "%x", &dat);
			str[i] = dat;
		}
		str[i] = 0;
		break;
	default:
		return SYNTAX;
	}
	if(fd == -1) {
		ret = net_ioctl(net, (int)str, WI_SETSSID);
	} else {
		ret = ioctl(fd, (int)str, WI_SETSSID);
		close(fd);
	}
	return (ret == -1) ? IOERR : NONE;
}

static int wi_pm(int argc, char** argv) {
	int	flag, fd, ret, net;
	int	ip, mask;
	char	buf[6];

	if(argv[2][0] != 'o') return SYNTAX;
	switch(argv[2][1]) {
	case 'n':
		flag = 1;
		break;
	case 'f':
		flag = 0;
		break;
	default:
		return SYNTAX;
	}
	fd = open(argv[1], -1);
	if(fd == -1) {
		net = get_netnum(argv[1]);
		if(net == -1) return IOERR;
		ret = get_ipinfo(net, &ip, &mask, buf);
		if(ret == -1) return IOERR;
		ifdown(net);
		fd = open(argv[1], -1);
		if(fd == -1) return IOERR;
		ret = ioctl(fd, flag, WI_PMGTON);
		close(fd);
		ifconfig(argv[1], ip, mask);
	} else {
		ret = ioctl(fd, flag, WI_PMGTON);
		close(fd);
	}
	return (ret == -1) ? IOERR : NONE;
}

static void if_info(int num) {
	int	i, ip, mask, n, ret;
	char	buf[6];

	ret = get_ipinfo(num, &ip, &mask, buf);
	if(ret == -1) return;
#ifdef LIMITED
	printf("IP%d :", num);
#else
	printf("net%d\tIP Address:", num);
#endif
	for(i = 0;i < 4;i++) {
		if(i > 0) putchar('.');
		n = (ip >> ((3 - i) * 8)) & 0xff;
		printf("%d", n);
	}
#ifdef LIMITED
	printf("\rMask:");
#else
	printf(" Netmask:");
#endif
	for(i = 0;i < 4;i++) {
		if(i > 0) putchar('.');
		n = (mask >> ((3 - i) * 8)) & 0xff;
		printf("%d", n);
	}
#ifdef LIMITED
	printf("\r");
#else
	printf(" MAC:");
#endif
	for(i = 0;i < 5;i++) printf("%02x:", (int)buf[i] & 0xff);
#ifdef LIMITED
	printf("%02x\r", (int)buf[i] & 0xff);
#else
	printf("%02x\r\r", (int)buf[i] & 0xff);
#endif
}

static int if_config(int argc, char** argv) {
	int	i, ip, mask, n, ret, net;

	if(argc == 2) return SYNTAX;
	if(argc == 1 && echo_flag) {
		for(i = 0;i < 4;i++) if_info(i);
		return NONE;
	}
	if(memcmp(argv[2], "down", 4) == 0) {
		sscanf(argv[1], "%d", &net);
		n = ifdown(net);
		if(n == -1) return IOERR;
		return NONE;
	}
	ip = strtoip(argv[2], &ret);
	if(ret == -1) return SYNTAX;
	if(argc == 4) {
		mask = strtoip(argv[3], &ret);
		if(ret == -1) return SYNTAX;
	} else {
		mask = IPADDR(255,255,255,0);
	}
	n = ifconfig(argv[1], ip, mask);
	if(n == -1) return IOERR;
	if(echo_flag) if_info(n);
	return NONE;
}

static int gateway(int argc, char** argv) {
	int	ip;

	ip = gethostbyname(argv[1]);
	if(ip == 0) return SYNTAX;
	set_gateway(ip);
	return NONE;
}

static int set_dns(int argc, char** argv) {
	int	ip, ret;

	ip = strtoip(argv[1], &ret);
	if(ret == -1) return SYNTAX;
	dns_server(ip);
	return NONE;
}

static void tftp_message() {
	putchar('.');
}

static int tftp(int argc, char** argv) {
	int	ip;
	char	*name;

	if(argc == 4 && argv[1][0] != '-') return SYNTAX;
	ip = gethostbyname(argv[2]);
	if(ip == 0) return IOERR;
	if(argc == 3) {
		name = strrchr(argv[1], '/');
		if(name == 0) name = argv[1];
		if(tftp_load(ip, name, tftp_message, tftp_timeout) == -1) return IOERR;
	} else {
		name = strrchr(argv[3], '/');
		if(name == 0) name = argv[3];
		if(tftp_save(ip, name, tftp_message, tftp_timeout) == -1) return IOERR;
	}
	return NONE;
}

static int set_tftp_timeout(int argc, char** argv) {
	sscanf(argv[1], "%d", &tftp_timeout);
	printf("Timeout of tftp is %d[sec].\r", tftp_timeout);
	return NONE;
}

static int _ping(int argc, char** argv) {
	int		i, size, times, success, per;
	unsigned int	ip;

	size = 64;
	times = 6;
	success = 0;
	ip = gethostbyname(argv[1]);
	if(ip == 0) return SYNTAX;
	for(i = 2;i < argc;i++) {
		switch(argv[i][0]) {
		case 'N':
		case 'n':
			sscanf(&argv[i][1], "%d", &times);
			break;
		case 'S':
		case 's':
			sscanf(&argv[i][1], "%d", &size);
			break;
		default:
			return SYNTAX;
		}
	}
#ifdef LIMITED
	printf("Ping %s\r", argv[1]);
	for(i = 0;i < times;i++) {
		int	ret;
		
		ret = ping(ip,size);
		if(ret == -1) {
			printf("Request timed out.\r");
		} else {
			success++;
			printf("Re:%s\r", argv[1]);
			sleep(1200);
		}
	}
#else
	printf("Pinging %s", argv[1]);
	printf(" of data.\r");
	for(i = 0;i < times;i++) {
		int	ret;
		
		ret = ping(ip,size);
		if(ret == -1) {
			printf("Request timed out.\r");
		} else {
			success++;
			printf("Reply from %s: Size=%d Seq=%d\r", argv[1], size, i + 1);
			sleep(1200);
		}
	}
#endif
	per = times - success;
	per = (per * 100) / times;
	printf("%d transmitted, %d received, %d%% loss\r", times, success, per);
	return NONE;
}

static int echo(int argc, char** argv) {
	if(strcmp(argv[1], "off") == 0) echo_flag = 0;
	else if(strcmp(argv[1], "on") == 0) echo_flag = 1;
	else return SYNTAX;
	return NONE;
}

static int type(int argc, char** argv) {
	int	fd, n;
	char	c;

	fd = open(argv[1], OptRead);
	if(fd == -1) return IOERR;
	n = read(fd, &c, 1);
	while(n > 0) {
		if(c != '\n') putchar(c);
		n = read(fd, &c, 1);
	}
	close(fd);
	return NONE;
}

#define	COPYBLKSIZ	512

static int copy(int argc, char** argv) {
	int	fdin, fdout, n, c, m;
	char	*buf;

	buf = malloc(COPYBLKSIZ);
	if(buf == 0) return MEMFULL;
	fdin = open(argv[1], OptRead);
	if(fdin == -1) {
		free(buf);
		return IOERR;
	}
	fdout = open(argv[2], OptWrite);
	if(fdout == -1) {
		close(fdin);
		free(buf);
		return IOERR;
	}
	m = c = 0;
	do {
		n = read(fdin, buf, COPYBLKSIZ);
		write(fdout, buf, n);
		if(++c > 16) {
			if(++m > 78) {
				putchar('\r');
				m = 0;
			}
			putchar('.');
			c = 0;
		}
	} while(n == COPYBLKSIZ);
	close(fdin);
	close(fdout);
	free(buf);
	return NONE;
}

static int pwd(int argc, char** argv) {
	printf("[%s]\r", cwd());
	return NONE;
}

static int _cd(int argc, char** argv) {
	if(cd(argv[1]) == -1) return NOFILE;
	return NONE;
}
static int _mount(int argc, char** argv) {
	int	n1, n2, chip, info[80], class[2], r, err, u, s, spc;
	char	devname[6];
	long long	size;

#ifdef OLD_VER
	if(memcmp(argv[1], "usb", 3) == 0) {
		if(isdigit(argv[1][3])) {
			chip = argv[1][3] - '0';
			for(r = 0;r < 3;r++) {
				if(usb_mount(chip) == -1) {
					usb_eject(chip);
				} else {
					break;
				}
			}
			if(r == 3) {
				usb_eject(chip);
				return IOERR;
			}
		}
	} else if(mount(argv[1]) == -1) {
		return IOERR;
	}
#else
	if(memcmp(argv[1], "usb", 3) == 0) {
		if(isdigit(argv[1][3])) {
			chip = argv[1][3] - '0';
			for(r = 0;r < USB_RETRY;r++) {
				if(usb_mount(chip) == -1) {
					putchar('.');
					usb_eject(chip);
					continue;
				}
				for(u = 1;u <= 2;u++) {
					class[u - 1] = usb_get_class(u) >> 8;
				}
				if(class[0] == 8 || class[1] == 8) {
					spc = 0;
					for(s = 0;s < 4;s++) {
						strcpy(devname, "spc0");
						devname[3] += s;
						size = device_ctl(devname, 0, MEDIA_SIZE);
						if(size != -1) {
							spc |= 1 << s;
							device_ctl(devname,(int)info, DEV_INFO);
							size *= SECSIZ;
							n1 = size / 1000000;
							n2 = size % 1000000;
							printf("%s\rDisk capacity ", info);
							if(n1 > 0) {
								printf("%d%d[Byte]\r", n1, n2);
							} else {
								printf("%d[Byte]\r", n2);
							}
						}
					}
					if(spc == 0) {
						putchar('.');
						usb_eject(chip);
						sleep(500);
						continue;
					}
				} else {
					return NONE;
				}
				break;
			}
			if(r == USB_RETRY) {
				usb_eject(chip);
				return IOERR;
			}
		}
	} else if(mount(argv[1]) == -1) {
		return IOERR;
	} else {
		device_ctl(argv[1],(int)info, DEV_INFO);
		size = device_ctl(argv[1], 0, MEDIA_SIZE);
		size *= SECSIZ;
		n1 = size / 1000000;
		n2 = size % 1000000;
		printf("%s\rDisk capacity ", info);
		if(n1 > 0) {
			printf("%d%d[Byte]\r", n1, n2);
		} else {
			printf("%d[Byte]\r", n2);
		}
	}
#endif
	return NONE;
}

static int _eject(int argc, char** argv) {
	int	chip;

	if(memcmp(argv[1], "usb", 3) == 0) {
		if(isdigit(argv[1][3])) {
			chip = argv[1][3] - '0';
			if(usb_eject(chip) == -1) return IOERR;
		}
	} else if(eject(argv[1]) == -1) {
		return IOERR;
	}
	return NONE;
}

static int _format(int argc, char** argv) {
	if(format(argv[1]) == -1) return IOERR;
	return NONE;
}

static int _wait(int argc, char** argv) {
	int	tim;

	sscanf(argv[1], "%d", &tim);
	sleep(tim * 100);
	return NONE;
}

static int wep(int argc, char **argv) {
	int	i, key, fd, kind, ret, dat;
	char	str[14], tmp[3];

	fd = open(argv[1], -1);
	if(fd == -1) {
		printf("Usage: wep dev 64/128 1-4 string\r");
		printf("Usage: wep dev 64/128 1-4 x hexstring\r");
		printf("       wep dev\r");
		return NONE;
	}
	if(argc == 2) {
		ioctl(fd, NOWEP, WI_WEPON);
		close(fd);
		return NONE;
	}
	switch(argc) {
	case 5:
		str[13] = 0;
		strncpy(str, argv[4], 13);
		break;
	case 6:
		if(argv[4][0] != 'x') {
			close(fd);
			return SYNTAX;
		}
		tmp[2] = 0;
		for(i = 0;i < 13;i++) {
			if(argv[5][i * 2] == 0 || argv[5][i * 2 + 1] == 0) break;
			tmp[0] = argv[5][i * 2];
			tmp[1] = argv[5][i * 2 + 1];
			sscanf(tmp, "%x", &dat);
			str[i] = dat;
		}
		str[i] = 0;
		break;
	default:
		close(fd);
		return SYNTAX;
	}
	sscanf(argv[3], "%d", &key);
	ret = ioctl(fd, key, WI_SETWEPKEY);
	if(ret == -1) {
		close(fd);
		return IOERR;
	}
	switch(argv[2][0]) {
	case '6':
		kind = WEP64;
		ret = ioctl(fd, (int)str, WI_SETWEP64);
		break;
	case '1':
		kind = WEP128;
		ret = ioctl(fd, (int)str, WI_SETWEP128);
		break;
	default:
		printf("Paramater error.\r");
		close(fd);
		return SYNTAX;
	}
	if(ret != -1) ret = ioctl(fd, kind, WI_WEPON);
	close(fd);
	return (ret != -1) ? NONE : IOERR;
}

static int ps(int argc, char **argv) {
	int		pid, ret, ac;
	char		c, **av;
	struct process	info;

	for(pid = 1;;pid++) {
		ret = ps_info(pid, &info);
		if(ret == -1) break;
		if(ret == 0) continue;
		c = (info.flag & PS_WAIT) ? 'S' : 'R';
		av = info.argv;
#ifdef LIMITED
		printf("%d ", pid);
		printf("%x ", info.address);
#else
		printf("pid:%d ", pid);
		printf("base:%x ", info.address);
		if(argc == 2 && argv[1][0] == 'x') {
			printf("pc:%x ", info.pc);
			printf("sp:%x ", info.stack);
		}
		putchar(c);putchar(' ');
#endif
		for(ac = 0;;ac++) {
			if(av[ac] == 0) break;
			printf("%s ", av[ac]);
		}
		putchar('\r');
#ifndef OLD_VER
		if(argc == 2 && argv[1][0] == 'x') {
			printf("      text:%x ", info.textsize);
			printf("data:%x ", info.datasize);
			printf("bss:%x ", info.bsssize);
			printf("stack:%x ", info.stacksize);
			printf("size:%x ", info.totalsize);
			printf("tcb:%x\r", info.tcb);
		}
#endif
	}
	return NONE;
}

static int _kill(int argc, char **argv) {
	int	pid;

	sscanf(argv[1], "%d", &pid);
	return (kill(pid) != -1) ? NONE : IOERR;
}

static int _sleep(int argc, char **argv) {
	int	ms;

	sscanf(argv[1], "%d", &ms);
	sleep(ms);
	return NONE;
}

static int regist(int argc, char** argv) {
	int	i, n, ret, d;
	char	flag, name[9];

	if(argv[1][0] == '-' && argv[1][1] == 's') {
		if(argc != 4) return SYNTAX;
		flag = 0;
		n = strlen(argv[3]);
		for(i = 0;i < n;i++) {
			if(!isdigit(argv[3][i])) {
				flag = 1;
				break;
			}
		}
		if(flag == 1) {
			set_regist_string(argv[2], argv[3]);
		} else {
			n = stoi(argv[3]);
			set_regist_data(argv[2], n);
		}
	} else {
		if(argc != 2) return SYNTAX;
		if(argv[1][0] == '-' && argv[1][1] == 'l') {
			for(i = 0;;i++) {
				ret = list_regist_string(i, name);
				if(ret == -1) break;
				if(ret != 0) {
					get_regist_string(name, tmp_buf, 79);
					printf(" %s [string value]\t%s\r", name, tmp_buf);
				} else {
					ret = list_regist_data(i, name);
					if(ret != 0) {
						get_regist_data(name, &d);
						printf(" %s [fixed value]\t%d\r", name, d);
					}
				}
			}
		} else {
			ret = get_regist_string(argv[1], tmp_buf, 79);
			if(ret != -1) {
				printf("%s\r", tmp_buf);
				return NONE;
			} else {
				ret = get_regist_data(argv[1], &d);
				if(ret != -1) {
					printf("%d\r", d);
					return NONE;
				}
			}
			return IOERR;
		}
	}
	return NONE;
}

static int df(int argc, char **argv) {
	int	ret, disk, total, count, n;
	char	name[16];

	for(disk = 0;;disk++) {	
		ret = fat_status(disk, &total, &count, name);
		if(ret == -1) break;
		if(total > 0) {
#ifdef LIMITED
			printf("%s ", name);
			n = (total - count) * 512;
			print_value(n);
			putchar('/');
			print_value(total * 512);
			putchar('\r');
#else
			printf("%s\t", name);
			printf("Total %dk[Byte]\t", total / 2);
			n = (total - count) / 2;
			printf("Used %dk[byte]\t", n);
			if(n < 10) printf("\t");
			printf("%d%% free.\r", (count * 100) / total);
#endif
		}
	}
	return NONE;
}

static int get_ssid(int argc, char **argv) {
	int	net, ret;
	char	name[34];

	net = get_netnum(argv[1]);
	if(net == -1) return IOERR;
	bzero(name, 34);
	ret = net_ioctl(net, (int)name, WI_GETSSID);
	if(ret != -1) {
		printf("SSID[%s]\r", name);
	} else {
		printf("ioctl error\r");
		return IOERR;
	}
	return NONE;
}

static int turbo(int argc, char **argv) {
	if(strcmp(argv[1], "on") == 0) {
		hw_config(HW_CONFIG_TURBO, 1, 0);
		return NONE;
	} else if(strcmp(argv[1], "off") == 0) {
		hw_config(HW_CONFIG_TURBO, 0, 0);
		return NONE;
	}
	return NONE;
}

static int history(int argc, char **argv) {
	if(strcmp(argv[1], "on") == 0) {
		history_flag = 1;
		return NONE;
	} else if(strcmp(argv[1], "off") == 0) {
		history_flag = 0;
		return NONE;
	}
	return NONE;
}

static int clear_display(int argc, char **argv) {
	printf("\033[2J");
	return NONE;
}

static int date(int argc, char **argv) {
	int	value;
	Date	data;

	if(argc == 3 && argv[1][0] == '-') {
		data.word = rtcinfo(0);
		if(data.word == -1) return IOERR;
		sscanf(argv[2], "%d", &value);
		switch(argv[1][1]) {
		case 'Y':
			data.date.year = value;
			break;
		case 'M':
			data.date.month = value;
			break;
		case 'D':
			data.date.day = value;
			break;
		case 'h':
			data.date.hour = value;
			break;
		case 'm':
			data.date.minute = value;
			break;
		case 's':
			data.date.second = value;
			break;
		}
		rtcinfo(data.word);
	} else if(argc == 1) {
		data.word = rtcinfo(0);
		if(data.word == -1) return IOERR;
		printf("20%02d/%d/%d ", data.date.year, data.date.month, data.date.day);
		printf((data.date.hour / 12) ? "PM" : "AM");
		printf(" %d:%02d:%02d\r", data.date.hour % 12, data.date.minute, data.date.second);
	} else {
		return SYNTAX;
	}
	return NONE;
}

static int dd(int argc, char** argv) {
	int	fdin, fdout, n, s, c, off, count, m, i;
	char	*buf;

	if(argc == 4) return SYNTAX;
	buf = malloc(COPYBLKSIZ * 2);
	if(buf == 0) return MEMFULL;
	fdin = open(argv[1], OptRead);
	if(fdin == -1) {
		free(buf);
		return IOERR;
	}
	if(argc == 5) {
		off = stoi(argv[3]);
		count = stoi(argv[4]);
		fdout = open(argv[2], OptWrite);
		if(fdout == -1) {
			close(fdin);
			free(buf);
			return IOERR;
		}
		c = 0;
		n = 0;
		do {
			s = read(fdin, buf, COPYBLKSIZ);
			if(c >= off) {
				write(fdout, buf, s);
				n++;
				if(n >= count) break;
			}
			c++;
		} while(s == COPYBLKSIZ);
		close(fdout);
	} else {
		bzero(buf, COPYBLKSIZ * 2);
		off = stoi(argv[2]);
		seek(fdin, off / 512);
		s = read(fdin, buf, COPYBLKSIZ);
		s += read(fdin, buf + 512, COPYBLKSIZ);
		m = off % 512;
		n = m + 16 * 8;
		while(m < n) {
			printf("%08x : ", ((off >> 9) << 9) + m);
			for(i = 0;i < 16;i++) {
				if(i == 8) putchar(' ');
				printf("%02x", (int)buf[m + i] & 0xff);
			}
			putchar(' ');
			for(i = 0;i < 16;i++) {
				if(i == 8) putchar(' ');
				putchar(isprint(buf[m + i]) ? buf[m + i] : '.');
			}
			putchar('\r');
			m += 16;
		}
	}
	close(fdin);
	free(buf);
	return NONE;
}

#define EEP_CS	0x10
#define EEP_CLK	0x80
#define EEP_DI	0x20
#define EEP_DO	0x40
#define EEP_DIR	0x02

#define	EEP_WRITE_ENABLE	0x13f
#define	EEP_WRITE_DISABLE	0x100
#define	EEP_ERASE_WORD	0x1c0

#define EEP_REG 0x14

#define eewait() {volatile int w;for(w = 0;w < 250;w++);}
#define eesetbit(bit)	eereg[EEP_REG] |= bit
#define eeresbit(bit)	eereg[EEP_REG] &= ~(bit)
#define eegetbit(bit)	(eereg[EEP_REG] & (bit))

static volatile char *eereg;

static void cmd_general(int cmd, int size, int wait) {
	int	i, mask;

	mask = 1 << (size - 1);
	eeresbit(EEP_CLK);
	eesetbit(EEP_CS | EEP_DI);
	eewait();
	for(i = 0;i < size;i++) {
		if(cmd & mask) {
			eesetbit(EEP_DI);
		} else {
			eeresbit(EEP_DI);
		}
		eesetbit(EEP_CLK);		
		eewait();
		eeresbit(EEP_CLK);
		eewait();
		cmd <<= 1;
	}
	if(wait) {
		eewait();
		eeresbit(EEP_CS);
		eewait();
		eesetbit(EEP_CS);
		sleep(20);
		eeresbit(EEP_CS);
		eewait();
	}
}

static void write_word(int addr, int data) {
	int	i, cmd;

	cmd = (5 << 22) | ((addr & 0x3f) << 16) | (data & 0xffff);
	cmd_general(cmd, 25, 1);
}

static int read_word(int addr) {
	int	i, cmd;

	cmd = (6 << 6) | (addr & 0x3f);
	cmd_general(cmd, 9, 0);
	eesetbit(EEP_DIR);
	cmd = 0;
	for(i = 0;i < 16;i++) {
		cmd <<= 1;
		eesetbit(EEP_CLK);		
		eewait();
		cmd |= eegetbit(EEP_DO) ? 1 : 0;
		eeresbit(EEP_CLK);
		eewait();
	}
	eeresbit(EEP_CS + EEP_DIR);
	eewait();
	return cmd;
}

static int ax88796(int argc, char** argv) {
	unsigned int	i, phy, data;
	unsigned char	c;

	if(argc == 1) {
		printf("ax88796 [ 100fd | 100hd | 10fd | 10hd | 100auto | 10auto | auto ]\r");
		return NONE;
	}
	if(memcmp(argv[1], "100f", 4) == 0) {
		phy = 4;
	} else if(memcmp(argv[1], "100h", 4) == 0) {
		phy = 5;
	} else if(memcmp(argv[1], "10f", 3) == 0) {
		phy = 6;
	} else if(memcmp(argv[1], "10h", 3) == 0) {
		phy = 7;
	} else if(memcmp(argv[1], "100a", 4) == 0) {
		phy = 1;
	} else if(memcmp(argv[1], "10a", 3) == 0) {
		phy = 2;
	} else if(memcmp(argv[1], "auto", 4) == 0) {
		phy = 0;
	} else {
		return SYNTAX;
	}
#if defined(__sh2__)
	eereg = (volatile char*)((memcmp((char*)0, (char*)0x400000, 0x80) == 0) ? 0x8000000 : 0x800000);
#endif
#if defined(__sh3__)
	eereg = (volatile char*)0xb0000000;
#endif
#if defined(__arm__)
	eereg = (volatile char*)0x62000000;
#endif
	set_buswidth((int)eereg, 8, 15);
	data = read_word(2) & 0xf8ff;
	data |= phy << 8;
	cmd_general(EEP_WRITE_ENABLE, 9, 1);
	write_word(2, data);
	cmd_general(EEP_WRITE_DISABLE, 9, 1);
	data = (read_word(2) >> 8) & 0x0007;
	printf("Phy mode ");
	switch(data) {
	case 0:
		printf("10/100Base auto");
		break;
	case 1:
		printf("100Base auto");
		break;
	case 2:
		printf("10Base auto");
		break;
	case 4:
		printf("100Base full duplex");
		break;
	case 5:
		printf("100Base half duplex");
		break;
	case 6:
		printf("10Base full duplex");
		break;
	case 7:
		printf("10Base half duplex");
		break;
	default:
		return IOERR;
	}
	printf(", please power off.\r");
	return NONE;
}

#define WGETBUFSIZ 1500

static int wget_status(char *buffer, int len) {
	int	i, c, start, size;

	start = 0;
	size = 0;
	c = 0;
	for(i = 0;i < len;i++) {
		if(buffer[i] < ' ') {
			if(c == 0) {
				write(0, buffer + start, size);
				putchar('\r');
			}
			c++;
			size = 0;
		} else {
			c = 0;
			if(size == 0) start = i;
			size++;
		}
		if(c >= 4) break;
	}
	i++;
	return i;
}

static int wget(int argc, char **argv) {
	int		i, sock, ret, len, count, total, off, fd;
	unsigned int	host;
	struct sockaddr	server;
	char		*buffer, *name;

	if(argc == 2) return SYNTAX;
	if(argc == 1) {
		printf("Usage : wget [host] [path]\r");
		return NONE;
	}
	name = strrchr(argv[2], '/');
	if(name == NULL) {
		name = argv[2];
	} else {
		name++;
	}
	fd = open(name, OptWrite);
	host = gethostbyname(argv[1]) ;
	if(host == 0) {
		printf("WEB Server not found\r");
		return IOERR;
	}
	sock = tcp_socket(0);
	if(host == 0) {
		printf("tcp_socket not found\r");
		return IOERR;
	}
	server.sin_addr = host;
	server.sin_port = 80;
	ret = tcp_connect(sock, &server);
	if(ret == -1) {
		tcp_close(sock);
		printf("WEB Server connection failed\r") ;
		return IOERR;
	}
	tcp_timeout(sock, 2000);
	buffer = (char *)malloc(WGETBUFSIZ);
	if(buffer <= 0) {
		tcp_close(sock);
		return MEMFULL;
	}
	strcpy(buffer, "GET ");
	strcat(buffer, argv[2]);
	strcat(buffer, " HTTP/1.1\nHost: ");
	strcat(buffer, argv[1]);
	strcat(buffer, "\nConnection: Close\n\n");
	tcp_write(sock, buffer, strlen(buffer));
	total = 0;
	count = 0;
	bzero(buffer, WGETBUFSIZ);
	for(;;) {
		len = tcp_read(sock, buffer, WGETBUFSIZ);
		if(len > 0) {
			if(count == 0) {
				off = wget_status(buffer, len);
				write(fd, buffer + off, len - off);
			} else {
				write(fd, buffer, len);
			}
			count++;
			total += len;
		} else if(tcp_status(sock) == -1) {
			break;
		}
	}
	printf( "\r%d packets / %d bytes received.\r", count, total - off) ;
	close(fd);
	free(buffer) ;
	tcp_timeout(sock, 0);
	tcp_close(sock);
	return NONE;
}

#ifndef OLD_VER
int port(int argc, char **argv) {
	int	num, bit, i;
	IOREG	*reg;

	if(argc == 2) {
		num = port2num(argv[1]);
		if(num == -1) return IOERR;
		bit = port2bit(argv[1]);
		reg = get_dr(num);
		if(echo_flag) printf((*reg & (1 << bit)) ? "on\r" : "off\r");
		retvalue = (*reg & (1 << bit)) ? 1 : 0;
	} else {
		for(i = 1;i < argc;i += 2) {
			num = port2num(argv[i]);
			if(num == -1) return IOERR;
			bit = port2bit(argv[i]);
			reg = get_dr(num);
			if(memcmp(argv[i + 1], "out", 3) == 0) {
				ddr_set(num, 1 << bit);
			} else if(memcmp(argv[i + 1], "in", 2) == 0) {
				ddr_reset(num, 1 << bit);
			} else if(memcmp(argv[i + 1], "on", 2) == 0) {
				*reg |= 1 << bit;
			} else if(memcmp(argv[i + 1], "off", 3) == 0) {
				*reg &= ~(1 << bit);
			} else if(memcmp(argv[i + 1], "neg", 3) == 0) {
				*reg ^= 1 << bit;
			}
		}
	}
	return NONE;
}

int memory(int argc, char **argv) {
	struct process	info;
	int	pid, id, size, ret, dc;
	char	*ptr;

	id = 0;
	if(argc == 2) {
		sscanf(argv[1], "%d", &id);
		if(id < 2) id = 0;
	}
	for(pid = 0;;pid++) {
		if(pid > 0) {
			ret = ps_info(pid, &info);
			if(ret == -1) break;
			if(ret == 0) continue;
		}
		if(argc == 1 || pid == id) {
			if(argc == 1) {
				if(pid == 0) {
					printf("ProcessID SYSTEM\r", pid);
				} else {
					printf("ProcessID %d\r", pid);
				}
			}
			ptr = 0;
			dc = 0;
			while((size = memory_list(pid, &ptr)) != -1) {
				printf("%08x-%08x ", (int)ptr, (int)ptr + size - 1);
				ptr = &ptr[size];
				if(dc++ == 3) {
					dc = 0;
					putchar('\r');
				}
			}
			putchar('\r');
			if(argc == 2) break;
		}
	}
	return NONE;
}

int meminfo(int argc, char **argv) {
	int	memid, total, usage;

	for(memid = 0;;memid++) {
		if(memory_usage(memid, &total, &usage) == -1) break;
		printf("Block%d\tTotal %d[byte]\tUsage %d[byte]", memid, total, usage);
		printf("\t%d.%02d[%%]\r", (usage * 100) / total, ((usage * 10000) / total) % 100);
	}
	return NONE;
}

#endif

#define OTHER_DATA	1
#define VALUE_DATA	2
#define CONST_DATA	3

#define EXIT_CMD	1
#define GOTO_CMD	2

#define GET_VALUE	0
#define SET_VALUE	1

static int cmd_line(int argc, char **argv) {
	int	ret, i, fd;
	char	*ext;

	if(strcmp(argv[0], "Exit") == 0) return EXIT_CMD;
	if(strcmp(argv[0], "Goto") == 0) return GOTO_CMD;
	ext = strchr(argv[0], '.');
	if(ext != 0 && strcmp(ext, ".bat") == 0) {
		char	name[64];

		name[63] = 0;
		strncpy(name, argv[0], 63);
		fd = open(name, OptRead);
		if(fd == -1) {
			err_message(NOFILE);
		} else {
			fd = shell(fd, name);
			close(fd);
		}
	} else {
		retvalue = 0;
		for(i = 0;;i++) {
			if(strcmp(argv[0], (char*)table[i].command) == 0 || table[i].command[0] == 0) {
				if(argc >= table[i].min && argc <= table[i].max) {
					ret = (*(table[i].function))(argc, argv);
					if(ret > NONE) err_message(ret);
				} else {
					err_message(SYNTAX);
				}
				break;
			}
			if(table[i].command[0] == 0) break;
		}
	}
	return 0;
}

static int access_value(char *arg, int *data, int op) {
	int	i, n, flag;

	n = strlen(arg);
	flag = 1;
	i = 0;
	if(arg[0] == '-') i++;
	for(;i < n;i++) {
		if(!isdigit(arg[i])) {
			flag = 0;
			break;
		}
	}
	if(n == 1 && arg[0] >= 'A' && arg[0] <= 'Z') {
		n = 'A' - arg[0];
		switch(op) {
		case GET_VALUE:
			*data = values[n];
			break;
		case SET_VALUE:
			values[n] = *data;
			break;
		}
		return VALUE_DATA;
	} else if(flag == 1) {
		*data = atoi(arg);
		return CONST_DATA;
	}
	return OTHER_DATA;
}

static int shell(int fd, char *name) {
	int	i, n, argc, data, data2, result, status, argoff, err;
	char	echo_save, label[16];

	for(i = 0;i < 32;i++) values[i] = 0;
#ifdef LIMITED
	strcpy(prompt, ">");
#else
	strcpy(prompt, "MES >");
#endif
	for(;;) {
		if(fd == 0) printf(prompt);
		argc = read_line(fd, cmd_buf, cmd_argv);
		if(fd != 0 && argc == -1) return fd;
		if(argc < 1) continue;
		if(echo_flag) putchar('\r');
		if(argc >= MAX_ARG) {
			err_message(CMDFULL);
			continue;
		}
		status = 0;
		n = strlen(cmd_argv[0]);
		if(cmd_argv[0][n - 1] == ':') continue;
		if(strcmp(cmd_argv[0], "Loop") == 0) {
			for(;;) cmd_line(argc - 1, &cmd_argv[1]);
		} else if(argc > 2 && access_value(cmd_argv[0], &data, GET_VALUE) == VALUE_DATA && strcmp(cmd_argv[1], "=") == 0) {
			if(access_value(cmd_argv[2], &data, GET_VALUE) != OTHER_DATA) {
				err = 0;
				if(argc == 5 && access_value(cmd_argv[4], &data2, GET_VALUE) != OTHER_DATA) {
					switch(cmd_argv[3][0]) {
					case '+':
						result = data + data2;
						break;
					case '-':
						result = data - data2;
						break;
					case '*':
						result = data * data2;
						break;
					case '/':
						result = data / data2;
						break;
					case '%':
						result = data % data2;
						break;
					default:
						err = 1;
						err_message(SYNTAX);
					}
					data = result;
				}
				if(err == 0) access_value(cmd_argv[0], &data, SET_VALUE);
			} else {
				argoff = 2;
				status = cmd_line(argc - 2, &cmd_argv[2]);
				data = retvalue;
				access_value(cmd_argv[0], &data, SET_VALUE);
			}
		} else if(argc == 2 && access_value(cmd_argv[1], &data, GET_VALUE) != OTHER_DATA && strcmp(cmd_argv[0], "Print") == 0) {
			printf("%d\r", data);
		} else if(argc > 4 && access_value(cmd_argv[1], &data, GET_VALUE) != OTHER_DATA && access_value(cmd_argv[3], &data2, GET_VALUE) != OTHER_DATA && strcmp(cmd_argv[0], "If") == 0) {
			argoff = 4;
			switch(cmd_argv[2][0]) {
			case '=':
				if(data == data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '!':
				if(data != data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '>':
				if(data > data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			case '<':
				if(data < data2) status = cmd_line(argc - 4, &cmd_argv[4]);
				break;
			default:
				err_message(SYNTAX);
			}
		} else {
			argoff = 0;
			status = cmd_line(argc, &cmd_argv[0]);
		}
		switch(status) {
		case EXIT_CMD:
			return fd;
		case GOTO_CMD:
			if(fd == 0 || argc != (argoff + 2)) {
				err_message(SYNTAX);
				break;
			}
			label[14] = 0;
			strncpy(label, cmd_argv[argoff + 1], 14);
			strcat(label, ":");
			close(fd);
			fd = open(name, OptRead);
			for(;;) {
				echo_save = echo_flag;
				echo_flag = 0;
				argc = read_line(fd, cmd_buf, cmd_argv);
				echo_flag = echo_save;
				if(fd != 0 && argc == -1) {
					err_message(SYNTAX);
					return fd;
				}
				if(strcmp(cmd_argv[0], label) == 0) break;
			}
			break;
		}
	}
	return fd;
}

static void autoexec() {
	int	fd;

	fd = open("autoexec.bat", OptRead);
	if(fd == -1) return;
	fd = shell(fd, "autoexec.bat");
	close(fd);
}

int main() {
	int	version, rev, chip;

	table[0].function = dump;
	table[1].function = set_data;
	table[2].function = dir;
	table[3].function = clear_memory;
	table[4].function = if_config;
	table[5].function = gateway;
	table[6].function = _ping;
	table[7].function = echo;
	table[8].function = remove;
	table[9].function = ssid;
	table[10].function = wi_pm;
	table[11].function = tftp;
	table[12].function = type;
	table[13].function = pwd;
	table[14].function = _cd;
	table[15].function = _mount;
	table[16].function = _eject;
	table[17].function = _format;
	table[18].function = copy;
	table[19].function = set_dns;
	table[20].function = wep;
	table[21].function = _wait;
	table[22].function = get_ssid;
	table[23].function = set_tftp_timeout;
	table[24].function = ps;
	table[25].function = _kill;
	table[26].function = df;
	table[27].function = _sleep;
	table[28].function = regist;
	table[29].function = turbo;
	table[30].function = history;
	table[31].function = clear_display;
	table[32].function = date;
	table[33].function = dd;
	table[34].function = rename;
	table[35].function = ax88796;
	table[36].function = wget;
#ifdef OLD_VER
	table[37].function = execution;
#else
	table[37].function = port;
	table[38].function = get_data;
	table[39].function = _mkdir;		//modify '10.05.25 tanaka@intecs.org
	table[40].function = meminfo;
	table[41].function = memory;
	table[42].function = execution;
#endif
	echo_flag = 1;
	history_flag = 0;
	tftp_timeout = 10;
	version = mesver();
	chip = version >> 24;
	rev = version & 0xff;
	version >>= 8;
	histories = malloc(MAX_HISTORY * MAX_BUF);
	max_history = (histories == 0) ? 0 : MAX_HISTORY;
	if(max_history > 0) bzero(histories, max_history * MAX_BUF);
#ifdef LIMITED
	if(rev < 128) {
		printf("MES Ver%d.%d Rev%02d\r", (version >> 8) & 0xff, version & 0xff, rev);
	} else {
		rev = 256 - rev;
		printf("MES Ver%d.%d Beta%02d\r", (version >> 8) & 0xff, version & 0xff, rev);
	}
	printf("\033[>5l");
#else
	printf("\033[2J\033[%d;%dH",10,1);
	printf("\t\t+--------------------------------------------+\r");
	if(rev < 128) {
		printf("\t\t| Micro Embeded System Ver%d.%d Rev%02d ", (version >> 8) & 0xff, version & 0xff, rev);
	} else {
		rev = 256 - rev;
		printf("\t\t| Micro Embeded System Ver%d.%d beta%02d ", (version >> 8) & 0xff, version & 0xff, rev);
	}
	switch(chip) {
	case CHIP_7045:
		printf("(SH714x) |\r");
		break;
	case CHIP_7085:
		printf("(SH708x) |\r");
		break;
	case CHIP_7216:
		printf("(SH7216) |\r");
		break;
	case CHIP_7706:
		printf("(SH7706) |\r");
		break;
	case CHIP_7721:
		printf("(SH7721) |\r");
		break;
	case CHIP_7730:
		printf("(SH7730) |\r");
		break;
	case CHIP_7763:
		printf("(SH7763) |\r");
		break;
#ifndef OLD_VER
	case CHIP_710:
		printf("(STR710) |\r");
		break;
#endif
	default:
		printf("(Undef)  |\r");
	}
	printf("\t\t+--------------------------------------------+\r");
	printf("\033[%d;%dH",24,1);
#endif
	autoexec();
	shell(0, 0);
	if(max_history > 0) free(histories);
	return 0;
}