/*
 * Copyright (c) 1991-1994  Sony Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name of Sony Corporation
 * shall not be used in advertising or otherwise to promote the sale, use
 * or other dealings in this Software without prior written authorization
 * from Sony Corporation.
 *
 */

#include "sj_kcnv.h"
#include <stdlib.h>
#include <string.h>
#include <pwd.h>
#include <setjmp.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include "sj3cmd.h"
#include "sj3err.h"
#include "Dict.h"
#include "server.h"

#define SJIS_PROTO 1
#define EUC_PROTO 2

extern Global* work_base;
extern STDY*   stdy_base;
extern int     serv_errno;

extern int     client_num;
extern Client* client;
extern Client* cur_client;
extern int     client_fd;

extern char* dict_dir;
extern int   dir_mode;
extern int   file_mode;

static unsigned char buf1[YomiBufSize];
static unsigned char buf2[YomiBufSize];
static unsigned char buf3[YomiBufSize];
static unsigned char buf4[YomiBufSize];
static unsigned char kbuf[KanjiBufSize];
static unsigned char skbuf[KanjiBufSize];

static jmp_buf	 error_ret;
static WorkArea* worklist = NULL;
static Client*	 cur_cli;

static unsigned char defaultchar[2] = {(unsigned char)0x81, (unsigned char)0x40};
static int	     defuse = 0, defuse2 = 0;

DictFile* opendict(char* name, char* passwd);
int	  closedict(DictFile* dfp);
StdyFile* openstdy(char* name, char* passwd);
int	  closestdy(StdyFile* sfp);

unsigned char* put_ndata(unsigned char* p, int n);
unsigned char* put_string(unsigned char* p);

int make_full_path(char* path) {
	char  tmp[PathNameLen];
	char* index;
	int   i;

	if(!path || !*path) return ERROR;

	i = strlen(dict_dir) + 1 + strlen(path) + 1;
	if(i > sizeof(tmp)) return ERROR;

	strlcpy(tmp, path, sizeof(tmp));
	index = strtok(tmp, "/");
	do {
		if(!strcmp(index, "..")) return ERROR;
	} while((index = strtok(NULL, "/")) != NULL);

	if(*path == '/') {
		if(strncmp(path, dict_dir, strlen(dict_dir)) == 0) {
			return 0;
		} else {
			return ERROR;
		}
	}
	snprintf(tmp, sizeof(tmp), "%s/%s", dict_dir, path);
	strcpy(path, tmp);
	return 0;
}

WorkArea*
alloc_workarea(void) {
	WorkArea* p;

	if(!(p = (WorkArea*)malloc(sizeof(WorkArea)))) return NULL;

	memset(p, '\0', sizeof(WorkArea));
	p->lock	  = NotLocked;
	p->refcnt = 1;

	p->link	 = worklist;
	worklist = p;

	work_base = &(p->global);
	initwork();

	return p;
}

void free_workarea(WorkArea* p) {
	if(!p) return;
	if(--(p->refcnt)) return;

	if(worklist == p)
		worklist = p->link;
	else {
		WorkArea* q;

		for(q = worklist; q; q = q->link) {
			if(q->link == p) {
				q->link = p->link;
				break;
			}
		}
	}

	if(p->global.Jdictlist)
		close_dictlist(p->global.Jdictlist);

	free((char*)p);
}

void exec_connect(void) {
	int	       version;
	char	       hostname[HostNameLen];
	char	       username[UserNameLen];
	char	       progname[ProgNameLen];
	WorkArea*      wp;
	struct passwd* pw;

	version = get_int();
	get_nstring(hostname, sizeof(hostname));
	get_nstring(username, sizeof(username));
	get_nstring(progname, sizeof(progname));

	if(cur_cli->work) longjmp(error_ret, SJ3_AlreadyConnected);

	if(version < 0)
		longjmp(error_ret, SJ3_DifferentVersion);

	if(hostname[0] == '\0')
		longjmp(error_ret, SJ3_NoHostName);

	if(username[0] == '\0')
		longjmp(error_ret, SJ3_NoUserName);

	if(!check_user(username, hostname))
		longjmp(error_ret, SJ3_NotAllowedUser);

	if(!(wp = alloc_workarea()))
		longjmp(error_ret, SJ3_NotEnoughMemory);

	pw = getpwnam(username);
	if(pw) {
		cur_cli->uid = pw->pw_uid;
	} else {
		cur_cli->uid = 0;
	}
	cur_cli->version = version;
	strcpy(cur_cli->host, hostname);
	strcpy(cur_cli->user, username);
	strcpy(cur_cli->prog, progname);
	strncpy(cur_cli->def_char, defaultchar, 2);
	cur_cli->work = wp;

	if(version == 1)
		put_int(SJ3_NormalEnd);
	else
		put_int((-SJ3SERV_VERSION_NO));

	logging_out("connection established on %d(%s, %s, %s)",
		    cur_cli->fd, hostname, username, progname);
}

void exec_disconnect(void) {
	if(cur_cli->stdy) {
		closestdy(cur_cli->stdy);
		cur_cli->stdy = NULL;
	}
	if(cur_cli->work) {
		free_workarea(cur_cli->work);
		cur_cli->work = NULL;
	} else
		longjmp(error_ret, SJ3_NotConnected);

	put_int(SJ3_NormalEnd);
}

void exec_opendict(void) {
	char   filename[PathNameLen];
	char   password[PassWordLen];
	DICT*  dict;
	DICTL *dictl, *dltp, *tmp, *tmp1;

	get_nstring(filename, sizeof(filename));
	get_nstring(password, sizeof(password));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(make_full_path(filename)) longjmp(error_ret, SJ3_TooLongParameter);

	if(!(dict = (DICT*)opendict(filename, password)))
		longjmp(error_ret, serv_errno);
	if(!dictlist && global_work_base) {
		DICTL* b_dictl = NULL;

		dltp  = global_work_base->Jdictlist;
		dictl = NULL;
		while(dltp) {
			dictl = (DICTL*)malloc(sizeof *dictl);
			if(!dictl) {
				/* XXX 2004.09.16 Hiroo Ono
				 * Fixed list deletion when malloc() returns
				 * NULL, but it will segfault anyway just after
				 * getting out of this if block.
				 * Maybe continue, break or return lack in
				 * this block, but I don't know what was
				 * intended to be done when malloc() caused
				 * an error. So just fix the list deletion bug
				 * in this block and leave the code causing
				 * segfault when malloc() fails.
				 */
				tmp = dictlist;
				while(tmp != NULL) {
					tmp1 = tmp;
					tmp  = tmp->next;
					free(tmp1);
				}
				dictlist = NULL;
			}
			if(!dictlist) dictlist = dictl;
			dictl->dict = dltp->dict;
			((DictFile*)(dictl->dict))->refcnt++;
			dictl->next = NULL;
			if(b_dictl) b_dictl->next = dictl;
			b_dictl = dictl;
			dltp	= dltp->next;
		}
	}
	for(dltp = dictlist; dltp && dltp->dict != dict; dltp = dltp->next);

	if(!dltp) {
		if(!(dictl = (DICTL*)malloc(sizeof *dictl))) {
			closedict((DictFile*)dict);
			longjmp(error_ret, SJ3_NotEnoughMemory);
		}

		dictl->dict = dict;
		dictl->next = dictlist;
		dictlist    = dictl;
	}

	if(cur_cli->work->lock == cur_cli->fd) {
		if(dict->maxunit != 0)
			lock_dict((DictFile*)dict, cur_cli->fd);
	}

	put_int(SJ3_NormalEnd);
	put_int((int)dict->dicid);
}

void exec_closedict(void) {
	TypeDicID id;
	DICTL*	  dictl;

	id = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	for(dictl = dictlist; dictl; dictl = dictl->next)
		if(dictl->dict->dicid == id) break;
	if(!dictl) longjmp(error_ret, SJ3_BadDictID);

	unlock_dict((DictFile*)(dictl->dict), cur_cli->fd);

	closedict((DictFile*)(dictl->dict));
	if(dictlist == dictl) {
		dictlist = dictl->next;
	} else {
		DICTL* p;

		for(p = dictlist; p->next; p = p->next) {
			if(p->next == dictl) {
				p->next = dictl->next;
				break;
			}
		}
	}
	free((char*)dictl);
	put_int(SJ3_NormalEnd);
}

void close_dictlist(DICTL* dictl) {
	DICTL* p;

	while(dictl) {
		unlock_dict((DictFile*)(dictl->dict), cur_cli->fd);
		closedict((DictFile*)(dictl->dict));
		p = dictl->next;
		free((char*)dictl);
		dictl = p;
	}
}

void exec_openstdy(void) {
	char	  filename[PathNameLen];
	char	  password[PassWordLen];
	StdyFile* stdy;

	get_nstring(filename, sizeof(filename));
	get_nstring(password, sizeof(password));

	if(cur_cli->stdy) longjmp(error_ret, SJ3_StdyAlreadyOpened);
	if(make_full_path(filename)) longjmp(error_ret, SJ3_TooLongParameter);

	if(!(stdy = openstdy(filename, password)))
		longjmp(error_ret, serv_errno);
	cur_cli->stdy = stdy;

	put_int(SJ3_NormalEnd);
}

void exec_closestdy(void) {
	if(!cur_cli->stdy) longjmp(error_ret, SJ3_StdyFileNotOpened);

	closestdy(cur_cli->stdy);
	cur_cli->stdy = NULL;

	put_int(SJ3_NormalEnd);
}

void exec_stdysize(void) {
	put_int(SJ3_NormalEnd);
	put_int(sizeof(STDYOUT));
}

static void
exec_lock(void) {
	int    lock;
	DICTL* dl;

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	lock = cur_cli->work->lock;
	if(lock != NotLocked && lock != cur_cli->fd)
		longjmp(error_ret, SJ3_LockedByOther);
	cur_cli->work->lock = cur_cli->fd;

	for(dl = dictlist; dl; dl = dl->next) {
		if(dl->dict->maxunit == 0) continue;
		lock_dict((DictFile*)(dl->dict), cur_cli->fd);
	}

	put_int(SJ3_NormalEnd);
}

static void
exec_unlock(void) {
	int    lock;
	DICTL* dl;

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	lock = cur_cli->work->lock;
	if(lock == NotLocked) longjmp(error_ret, SJ3_NotLocked);
	if(lock != cur_cli->fd) longjmp(error_ret, SJ3_LockedByOther);
	cur_cli->work->lock = NotLocked;

	for(dl = dictlist; dl; dl = dl->next) {
		if(dl->dict->maxunit == 0) continue;
		unlock_dict((DictFile*)(dl->dict), cur_cli->fd);
	}

	put_int(SJ3_NormalEnd);
}

static void
lock_check_for_read(void) {
	int lock;

	lock = cur_cli->work->lock;
	if(lock == NotLocked)
#ifdef SEVERE_LOCK
		longjmp(error_ret, SJ3_NotLocked);
#else
		;
#endif
	else if(lock != cur_cli->fd)
		longjmp(error_ret, SJ3_LockedByOther);
}

void exec_ph2knj(int mb_flag) {
	int	       i, j, l, stdy_size, buf_size, srchead = 0, srclen;
	unsigned char *p, *q;

	i = get_nstring(buf1, sizeof(buf1));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	lock_check_for_read();

	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf2, sizeof(buf2), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		i	  = ph2knj(buf2, kbuf, sizeof(kbuf));
		p	  = kbuf;
		q	  = skbuf;
		stdy_size = sizeof(STDYOUT) + 1;
		buf_size  = sizeof(skbuf);

		while(*p) {
			srchead += *p;
			srclen = *p;
			buf_size -= stdy_size;
			if(buf_size <= 0) goto CCONVERR;
			memcpy(p, q, stdy_size);
			p += stdy_size;
			q += stdy_size;
			l = sj3_str_euctosjis(q, buf_size, p, cur_cli->def_char, &defuse);
			if(l < 0) goto CCONVERR;
			if(defuse) {
				memcpy(&(buf2[srchead - srclen]), buf3, srclen);
				buf3[srclen] = '\0';
				j	     = cl2knj(buf3, srclen, buf4);
				l	     = sj3_str_euctosjis(q, buf_size, &(buf4[stdy_size]),
								 cur_cli->def_char, &defuse);
				while(defuse && (j == srclen)) {
					j = nextcl(buf4, 0);
					l = sj3_str_euctosjis(q, buf_size, &(buf4[stdy_size]),
							      cur_cli->def_char, &defuse);
					if(l < 0) goto CCONVERR;
				}
				if(!defuse && (j == srclen)) {
					memcpy(buf4, q - stdy_size, stdy_size);
				} else {
					l = sj3_str_euctosjis(q, buf_size, buf3,
							      cur_cli->def_char, &defuse);
					if((l < 0) || defuse) goto CCONVERR;
				}
			}
			p += strlen(p) + 1;
			q += l + 1;
			buf_size -= l + 1;
		}
		*q = '\0';
		p  = skbuf;
	} else {
		i = ph2knj(buf1, kbuf, sizeof(kbuf));
		p = kbuf;
	}

	put_int(SJ3_NormalEnd);
	put_int(i);
	while(*p) {
		put_byte(*p);
		p++;
		p = put_ndata(p, sizeof(STDYOUT));
		p = put_string(p);
	}
	put_byte(0);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_cl2knj(int mb_flag) {
	int	       len, stdy_size, buf_size;
	int	       i, j, l;
	unsigned char *ptr, *q;

	len = get_int();
	i   = get_nstring(buf1, sizeof(buf1));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	lock_check_for_read();

	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf2, sizeof(buf2), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		i	  = cl2knj(buf2, strlen(buf2), kbuf);
		ptr	  = kbuf;
		q	  = skbuf;
		buf_size  = sizeof(skbuf);
		stdy_size = sizeof(STDYOUT);

		memcpy(ptr, q, stdy_size);
		ptr += stdy_size;
		q += stdy_size;
		buf_size -= stdy_size;
		l = sj3_str_euctosjis(q, buf_size, ptr,
				      cur_cli->def_char, &defuse);
		if(l < 0) goto CCONVERR;
		if(defuse) {
			j = strlen(buf2);
			while(defuse && (i == j)) {
				i = nextcl(buf4, 0);
				l = sj3_str_euctosjis(q, buf_size, &(buf4[stdy_size]),
						      cur_cli->def_char, &defuse);
				if(l < 0) goto CCONVERR;
			}
			if(!defuse && (j == i)) {
				memcpy(buf4, q - stdy_size, stdy_size);
			} else {
				l = sj3_str_euctosjis(q, buf_size, buf2,
						      cur_cli->def_char, &defuse);
				if((l < 0) || defuse) goto CCONVERR;
				i = l;
			}
		}
		ptr = skbuf;
	} else {
		i   = cl2knj(buf1, len, kbuf);
		ptr = kbuf;
	}

	put_int(SJ3_NormalEnd);
	put_int(i);
	ptr = put_ndata(ptr, sizeof(STDYOUT));
	put_string(ptr);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_nextcl(int mb_flag) {
	int	       mode, stdy_size, buf_size;
	int	       i, l;
	unsigned char *ptr, *q;

	mode = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	lock_check_for_read();

	i = nextcl(kbuf, mode);
	if(mb_flag == SJIS_PROTO) {
		ptr	  = kbuf;
		q	  = skbuf;
		buf_size  = sizeof(skbuf);
		stdy_size = sizeof(STDYOUT);

		memcpy(ptr, q, stdy_size);
		ptr += stdy_size;
		q += stdy_size;
		buf_size -= stdy_size;
		l = sj3_str_euctosjis(q, buf_size, ptr, cur_cli->def_char, &defuse);
		if(l < 0) goto CCONVERR;
		while(defuse && i) {
			i = nextcl(kbuf, mode);
			l = sj3_str_euctosjis(q, buf_size, &(kbuf[stdy_size]),
					      cur_cli->def_char, &defuse);
			if(l < 0) goto CCONVERR;
		}
		if(!defuse && i) {
			memcpy(kbuf, q - stdy_size, stdy_size);
		} else {
			put_int(SJ3_NoMoreDouonWord);
			return;
		}
		ptr = skbuf;
	} else {
		ptr = kbuf;
	}

	put_int(SJ3_NormalEnd);
	put_int(i);
	ptr = put_ndata(ptr, sizeof(STDYOUT));
	put_string(ptr);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_prevcl(int mb_flag) {
	int	       mode, stdy_size, buf_size;
	int	       i, l;
	unsigned char *ptr, *q;

	mode = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	lock_check_for_read();

	i = prevcl(kbuf, mode);
	if(mb_flag == SJIS_PROTO) {
		ptr	  = kbuf;
		q	  = skbuf;
		buf_size  = sizeof(skbuf);
		stdy_size = sizeof(STDYOUT);

		memcpy(ptr, q, stdy_size);
		ptr += stdy_size;
		q += stdy_size;
		buf_size -= stdy_size;
		l = sj3_str_euctosjis(q, buf_size, ptr, cur_cli->def_char, &defuse);
		if(l < 0) goto CCONVERR;
		while(defuse && i) {
			i = prevcl(kbuf, mode);
			l = sj3_str_euctosjis(q, buf_size, &(kbuf[stdy_size]),
					      cur_cli->def_char, &defuse);
			if(l < 0) goto CCONVERR;
		}
		if(!defuse && i) {
			memcpy(kbuf, q - stdy_size, stdy_size);
		} else {
			put_int(SJ3_NoMoreDouonWord);
			return;
		}
		ptr = skbuf;
	} else {
		ptr = kbuf;
	}

	put_int(SJ3_NormalEnd);
	put_int(i);
	ptr = put_ndata(ptr, sizeof(STDYOUT));
	put_string(ptr);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_cl2knj_cnt(int mb_flag) {
	int len, buf_size, stdy_size;
	int i;
	int cnt = 0;

	len = get_int();
	i   = get_nstring(buf1, sizeof(buf1));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	lock_check_for_read();

	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf2, sizeof(buf2), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		i	  = cl2knj(buf2, len, kbuf);
		stdy_size = sizeof(STDYOUT);
		buf_size  = sizeof(skbuf) - stdy_size;
	} else {
		i = cl2knj(buf1, len, kbuf);
	}
	if(i) {
		while(i == len) {
			if(mb_flag == SJIS_PROTO) {
				if(sj3_str_euctosjis(skbuf, buf_size,
						     &(kbuf[stdy_size]),
						     cur_cli->def_char, &defuse) < 0)
					goto CCONVERR;
				if(!defuse) cnt++;
			} else
				cnt++;
			i = nextcl(kbuf, 0);
		}
	}

	put_int(SJ3_NormalEnd);
	put_int(cnt);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_cl2knj_all(int mb_flag) {
	int	       len, stdy_size, buf_size;
	int	       i, l;
	unsigned char *ptr, *q;

	len = get_int();
	i   = get_nstring(buf1, sizeof(buf1));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	lock_check_for_read();

	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf2, sizeof(buf2), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		len	  = strlen(buf2);
		i	  = cl2knj(buf2, len, kbuf);
		ptr	  = kbuf;
		q	  = skbuf;
		buf_size  = sizeof(skbuf);
		stdy_size = sizeof(STDYOUT);

		memcpy(ptr, q, stdy_size);
		ptr += stdy_size;
		q += stdy_size;
		buf_size -= stdy_size;
		l = sj3_str_euctosjis(q, buf_size, ptr, cur_cli->def_char, &defuse);
		if(l < 0) goto CCONVERR;
		if(defuse) {
			while(defuse && (i == len)) {
				i = nextcl(kbuf, 0);
				l = sj3_str_euctosjis(q, buf_size,
						      &(kbuf[stdy_size]),
						      cur_cli->def_char, &defuse);
				if(l < 0) goto CCONVERR;
			}
			if(!defuse && (i == len)) {
				memcpy(kbuf, q - stdy_size, stdy_size);
			} else {
				put_int(SJ3_NoMoreDouonWord);
				return;
			}
		}
		ptr = skbuf;
	} else {
		i   = cl2knj(buf1, len, kbuf);
		ptr = kbuf;
	}
	put_int(SJ3_NormalEnd);
	if(i) {
		while(i == len) {
			put_int(i);
			ptr = put_ndata(ptr, sizeof(STDYOUT));
			put_string(ptr);
			i = nextcl(kbuf, 0);
			if(mb_flag == SJIS_PROTO) {
				ptr	  = kbuf;
				q	  = skbuf;
				buf_size  = sizeof(skbuf);
				stdy_size = sizeof(STDYOUT);

				memcpy(ptr, q, stdy_size);
				ptr += stdy_size;
				q += stdy_size;
				buf_size -= stdy_size;
				l = sj3_str_euctosjis(q, buf_size, ptr,
						      cur_cli->def_char, &defuse);
				if(l < 0) goto CCONVERR;
				if(defuse) {
					while(defuse && (i == len)) {
						i = nextcl(kbuf, 0);
						l = sj3_str_euctosjis(q, buf_size,
								      &(kbuf[stdy_size]),
								      cur_cli->def_char,
								      &defuse);
						if(l < 0) goto CCONVERR;
					}
					if(!defuse && (len == i)) {
						memcpy(kbuf,
						       q - stdy_size, stdy_size);
					}
				}
				ptr = skbuf;
			} else {
				ptr = kbuf;
			}
		}
	}
	put_int(0);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_study(void) {
	int	err;
	STDYOUT stdy;

	get_ndata(&stdy, sizeof(stdy));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(!stdy_base) longjmp(error_ret, SJ3_StdyFileNotOpened);
	lock_check_for_read();

	err = study(&stdy);

	switch(err) {
	case StudyNoDict:
		err = SJ3_StdyFileNotOpened;
		break;
	case StudyNormEnd:
	case StudyFullArea:
	case StudyNotStudy:
		err = SJ3_NormalEnd;
		break;
	case StudyError:
	default:
		err = SJ3_InternalError;
		break;
	}
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	put_int(err);
}

void exec_clstudy(int mb_flag) {
	int	err;
	STDYOUT stdy;

	err = get_nstring(buf1, sizeof(buf1));
	err |= get_nstring(buf2, sizeof(buf2));
	get_ndata(&stdy, sizeof(stdy));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(!stdy_base) longjmp(error_ret, SJ3_StdyFileNotOpened);
	if(err) longjmp(error_ret, SJ3_TooLongParameter);
	lock_check_for_read();

	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf3, sizeof(buf3), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		if(sj3_str_sjistoeuc(buf4, sizeof(buf4), buf2,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		err = clstudy(buf3, buf4, &stdy);
	} else {
		err = clstudy(buf1, buf2, &stdy);
	}

	switch(err) {
	case ClstudyNoDict:
		err = SJ3_StdyFileNotOpened;
		break;
	case ClstudyNormEnd:
		err = SJ3_NormalEnd;
		break;
	case ClstudyParaErr:
	case ClstudyYomiErr:
		err = SJ3_IllegalParameter;
		break;
	case ClstudyNoArea:
		err = SJ3_TooSmallStdyArea;
		break;
	default:
		err = SJ3_InternalError;
		break;
	}
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	put_int(err);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_adddict(int mb_flag) {
	TypeDicID dicid;
	TypeGram  gram;
	int	  err;
	int	  err1;
	DICTL*	  dl;

	dicid = get_int();
	err   = get_nstring(buf1, sizeof(buf1));
	err1  = get_nstring(buf2, sizeof(buf2));
	gram  = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(err) longjmp(error_ret, SJ3_BadYomiString);
	if(err1) longjmp(error_ret, SJ3_BadKanjiString);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);
	if(dl->dict->maxunit == 0)
		longjmp(error_ret, SJ3_ReadOnlyDict);
	if(is_dict_locked((DictFile*)(dl->dict)))
		longjmp(error_ret, SJ3_DictLocked);

	debug_out(2, "adddic %s:%s:%d ", buf1, buf2, gram);
	seldict(dicid);
	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf3, sizeof(buf3), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		if(sj3_str_sjistoeuc(buf4, sizeof(buf4), buf2,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		err = adddic(buf3, buf4, gram);
	} else {
		err = adddic(buf1, buf2, gram);
	}

	if(err & AD_NotUserDict) err = SJ3_ReadOnlyDict;
	else if(err & AD_BadYomi)
		err = SJ3_BadYomiString;
	else if(err & AD_BadKanji)
		err = SJ3_BadKanjiString;
	else if(err & AD_BadHinsi)
		err = SJ3_BadHinsiCode;
	else if(err & AD_ArExist)
		err = SJ3_AlreadyExistWord;
	else if(err & AD_OvflwDouBlk)
		err = SJ3_NoMoreDouonWord;
	else if(err & AD_OvflwDouNum)
		err = SJ3_NoMoreDouonWord;
	else if(err & AD_OvflwUsrDic)
		err = SJ3_NoMoreUserDict;
	else if(err & AD_OvflwIndex)
		err = SJ3_NoMoreIndexBlock;
	else if(err)
		err = SJ3_AddDictFailed;
	else
		err = SJ3_NormalEnd;
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	put_int(err);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_deldict(int mb_flag) {
	TypeDicID dicid;
	TypeGram  gram;
	int	  err;
	int	  err1;
	DICTL*	  dl;

	dicid = get_int();
	err   = get_nstring(buf1, sizeof(buf1));
	err1  = get_nstring(buf2, sizeof(buf2));
	gram  = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(err) longjmp(error_ret, SJ3_BadYomiString);
	if(err1) longjmp(error_ret, SJ3_BadKanjiString);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);
	if(dl->dict->maxunit == 0)
		longjmp(error_ret, SJ3_ReadOnlyDict);
	if(is_dict_locked((DictFile*)(dl->dict)))
		longjmp(error_ret, SJ3_DictLocked);

	seldict(dicid);
	if(mb_flag == SJIS_PROTO) {
		if(sj3_str_sjistoeuc(buf3, sizeof(buf3), buf1,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		if(sj3_str_sjistoeuc(buf4, sizeof(buf4), buf2,
				     cur_cli->def_char, &defuse) < 0)
			goto CCONVERR;
		err = deldic(buf3, buf4, gram);
	} else {
		err = deldic(buf1, buf2, gram);
	}

	if(err & AD_NotUserDict) err = SJ3_ReadOnlyDict;
	else if(err & AD_BadYomi)
		err = SJ3_BadYomiString;
	else if(err & AD_BadKanji)
		err = SJ3_BadKanjiString;
	else if(err & AD_BadHinsi)
		err = SJ3_BadHinsiCode;
	else if(err & AD_NoMidasi)
		err = SJ3_NoSuchWord;
	else if(err & AD_NoHinsi)
		err = SJ3_NoSuchWord;
	else if(err & AD_NoKanji)
		err = SJ3_NoSuchWord;
	else if(err)
		err = SJ3_DelDictFailed;
	else
		err = SJ3_NormalEnd;
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	put_int(err);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_getdict(int mb_flag) {
	TypeDicID      dicid;
	int	       err, buf_size, l;
	DICTL*	       dl;
	unsigned char *ptr, *q;

	dicid = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);

	lock_check_for_read();

	seldict(dicid);
	err = getusr(kbuf);
	if(err) {
		if(mb_flag == SJIS_PROTO) {
			buf_size = sizeof(skbuf);
			ptr	 = kbuf;
			q	 = skbuf;
			l	 = sj3_str_euctosjis(q, buf_size, ptr,
						     cur_cli->def_char, &defuse);
			if(l < 0) goto CCONVERR;
			ptr += strlen(ptr) + 1;
			q += l + 1;
			buf_size -= l + 1;
			l = sj3_str_euctosjis(q, buf_size, ptr,
					      cur_cli->def_char, &defuse2);
			if(l < 0) goto CCONVERR;
			if(defuse || defuse2) {
				while((defuse || defuse2) && err) {
					ptr	 = kbuf;
					q	 = skbuf;
					buf_size = sizeof(skbuf);
					err	 = nextusr(kbuf);
					if(!err) break;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse);
					if(l < 0) goto CCONVERR;
					ptr += strlen(ptr) + 1;
					q += l + 1;
					buf_size -= l + 1;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse2);
					if(l < 0) goto CCONVERR;
				}
				if(!err) {
					longjmp(error_ret, SJ3_NoMoreDictData);
				}
			}
			ptr += strlen(ptr) + 1;
			q += l + 1;
			*q  = *ptr;
			ptr = skbuf;
		} else {
			ptr = kbuf;
		}

		put_int(SJ3_NormalEnd);
		ptr = put_string(ptr);
		ptr = put_string(ptr);
		put_int(*ptr);
	} else
		longjmp(error_ret, SJ3_NoMoreDictData);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_nextdict(int mb_flag) {
	TypeDicID      dicid;
	int	       err, buf_size, l;
	DICTL*	       dl;
	unsigned char *ptr, *q;

	dicid = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);

	lock_check_for_read();

	seldict(dicid);
	err = nextusr(kbuf);
	if(err) {
		if(mb_flag == SJIS_PROTO) {
			buf_size = sizeof(skbuf);
			ptr	 = kbuf;
			q	 = skbuf;
			l	 = sj3_str_euctosjis(q, buf_size, ptr, cur_cli->def_char,
						     &defuse);
			if(l < 0) goto CCONVERR;
			ptr += strlen(ptr) + 1;
			q += l + 1;
			buf_size -= l + 1;
			l = sj3_str_euctosjis(q, buf_size, ptr, cur_cli->def_char,
					      &defuse2);
			if(l < 0) goto CCONVERR;
			if(defuse || defuse2) {
				while((defuse || defuse2) && err) {
					ptr	 = kbuf;
					q	 = skbuf;
					buf_size = sizeof(skbuf);
					err	 = nextusr(kbuf);
					if(!err) break;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse);
					if(l < 0) goto CCONVERR;
					ptr += strlen(ptr) + 1;
					q += l + 1;
					buf_size -= l + 1;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse2);
					if(l < 0) goto CCONVERR;
				}
				if(!err) {
					longjmp(error_ret, SJ3_NoMoreDictData);
				}
			}
			ptr += strlen(ptr) + 1;
			q += l + 1;
			*q  = *ptr;
			ptr = skbuf;
		} else {
			ptr = kbuf;
		}

		put_int(SJ3_NormalEnd);
		ptr = put_string(ptr);
		ptr = put_string(ptr);
		put_int(*ptr);
	} else
		longjmp(error_ret, SJ3_NoMoreDictData);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_prevdict(int mb_flag) {
	TypeDicID      dicid;
	int	       err, buf_size, l;
	DICTL*	       dl;
	unsigned char *ptr, *q;

	dicid = get_int();

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);

	lock_check_for_read();

	seldict(dicid);
	err = prevusr(kbuf);
	if(err) {
		if(mb_flag == SJIS_PROTO) {
			buf_size = sizeof(skbuf);
			ptr	 = kbuf;
			q	 = skbuf;
			l	 = sj3_str_euctosjis(q, buf_size, ptr,
						     cur_cli->def_char, &defuse);
			if(l < 0) goto CCONVERR;
			ptr += strlen(ptr) + 1;
			q += l + 1;
			buf_size -= l + 1;
			l = sj3_str_euctosjis(q, buf_size, ptr,
					      cur_cli->def_char, &defuse2);
			if(l < 0) goto CCONVERR;
			if(defuse || defuse2) {
				while((defuse || defuse2) && err) {
					ptr	 = kbuf;
					q	 = skbuf;
					buf_size = sizeof(skbuf);
					err	 = prevusr(kbuf);
					if(!err) break;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse);
					if(l < 0) goto CCONVERR;
					ptr += strlen(ptr) + 1;
					q += l + 1;
					buf_size -= l + 1;
					l = sj3_str_euctosjis(q, buf_size, ptr,
							      cur_cli->def_char,
							      &defuse2);
					if(l < 0) goto CCONVERR;
				}
				if(!err) {
					longjmp(error_ret, SJ3_NoMoreDictData);
				}
			}
			ptr += strlen(ptr) + 1;
			q += l + 1;
			*q  = *ptr;
			ptr = skbuf;
		} else {
			ptr = kbuf;
		}

		put_int(SJ3_NormalEnd);
		ptr = put_string(ptr);
		ptr = put_string(ptr);
		put_int(*ptr);
	} else
		longjmp(error_ret, SJ3_NoMoreDictData);
	return;
CCONVERR:
	put_int(SJ3_CannotCodeConvert);
	return;
}

void exec_makedict(void) {
	struct stat sbuf;
	char	    path[PathNameLen];
	int	    err;
	int	    ofslen;
	int	    idxlen;
	int	    seglen;
	int	    segnum;

	err    = get_nstring(path, sizeof(path));
	idxlen = get_int();
	seglen = get_int();
	segnum = get_int();
	if(err) longjmp(error_ret, SJ3_TooLongParameter);
	if(make_full_path(path)) longjmp(error_ret, SJ3_TooLongParameter);

	if((stat(path, &sbuf) != ERROR) || (errno != ENOENT)) {
		longjmp(error_ret, SJ3_IllegalDictFile);
	}
	err = makedict(path, idxlen, seglen, segnum);
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	chmod(path, (file_mode & MODE_MASK));
	chown(path, cur_client->uid, -1);
	put_int(err);
}

void exec_makestdy(void) {
	struct stat sbuf;
	char	    path[PathNameLen];
	int	    err;
	int	    stynum;
	int	    clstep;
	int	    cllen;

	err    = get_nstring(path, sizeof(path));
	stynum = get_int();
	clstep = get_int();
	cllen  = get_int();
	if(err) longjmp(error_ret, SJ3_TooLongParameter);
	if(make_full_path(path)) longjmp(error_ret, SJ3_TooLongParameter);

	if((stat(path, &sbuf) != ERROR) || (errno != ENOENT)) {
		longjmp(error_ret, SJ3_IllegalStdyFile);
	}
	err = makestdy(path, stynum, clstep, cllen);
	if(err != SJ3_NormalEnd) longjmp(error_ret, err);
	chmod(path, (file_mode & MODE_MASK));
	chown(path, cur_client->uid, -1);
	put_int(err);
}

void exec_access(void) {
	char path[PathNameLen];
	int  mode;
	int  i;

	i    = get_nstring(path, sizeof(path));
	mode = get_int();
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	if(make_full_path(path)) longjmp(error_ret, SJ3_TooLongParameter);

	put_int(access(path, mode));
}

void exec_makedir(void) {
	char path[PathNameLen];
	int  i;

	i = get_nstring(path, sizeof(path));
	if(i) longjmp(error_ret, SJ3_TooLongParameter);
	if(make_full_path(path)) longjmp(error_ret, SJ3_TooLongParameter);

	if(mkdir(path, dir_mode)) {
		if(errno == EEXIST)
			longjmp(error_ret, SJ3_DirAlreadyExist);
		else
			longjmp(error_ret, SJ3_CannotCreateDir);
	}
	chmod(path, (dir_mode & MODE_MASK));

	put_int(SJ3_NormalEnd);
}

void exec_who(void) {
	int	i;
	Client* cli;

	i   = 0;
	cli = client;
	while((i <= client_num) && cli) {
		i++;
		cli = cli->next;
	}
	if(i < client_num) {
		put_int(i);
	} else {
		put_int(client_num);
	}
	for(i = 0, cli = client; (i < client_num) && cli; i++, cli = cli->next) {
		put_int(cli->fd);
		put_string(cli->host);
		put_string(cli->user);
		put_string(cli->prog);
	}
}

void exec_kill(void) {
	put_int(SJ3_NormalEnd);
	put_flush();

	server_terminate();
}

void exec_quit(void) {
	if(client_num > 1) longjmp(error_ret, SJ3_UserConnected);
	exec_kill();
}

void exec_version(void) {
	extern char *version_number, *time_stamp;
	static char* Version   = "version : ";
	static char* TimeStamp = "times-stamp : ";

	put_int(SJ3_NormalEnd);
	put_ndata(Version, strlen(Version));
	put_string(version_number);
	put_ndata(TimeStamp, strlen(TimeStamp));
	put_string(time_stamp);
	put_string(NULL);
}

void exec_dictpass(void) {
	TypeDicID dicid;
	char	  buf[PasswdLen + 1];
	int	  err;
	DICTL*	  dl;

	dicid = get_int();
	err   = get_nstring(buf, sizeof(buf));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(err) longjmp(error_ret, SJ3_TooLongPasswd);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);

	if(set_dictpass(dl->dict, buf)) longjmp(error_ret, serv_errno);
	put_int(SJ3_NormalEnd);
}

void exec_dictcmnt(void) {
	TypeDicID dicid;
	char	  buf[CommentLength + 1];
	int	  err;
	DICTL*	  dl;

	dicid = get_int();
	err   = get_nstring(buf, sizeof(buf));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(err) longjmp(error_ret, SJ3_TooLongComment);

	for(dl = dictlist; dl; dl = dl->next)
		if(dl->dict->dicid == dicid) break;
	if(!dl) longjmp(error_ret, SJ3_NoSuchDict);

	if(set_dictcmnt(dl->dict, buf)) longjmp(error_ret, serv_errno);
	put_int(SJ3_NormalEnd);
}

void exec_stdypass(void) {
	char buf[PasswdLen + 1];
	int  err;

	err = get_nstring(buf, sizeof(buf));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(!stdy_base) longjmp(error_ret, SJ3_StdyFileNotOpened);
	if(err) longjmp(error_ret, SJ3_TooLongPasswd);

	if(set_stdypass(buf)) longjmp(error_ret, serv_errno);
	put_int(SJ3_NormalEnd);
}

void exec_stdycmnt(void) {
	char buf[CommentLength + 1];
	int  err;

	err = get_nstring(buf, sizeof(buf));

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(!stdy_base) longjmp(error_ret, SJ3_StdyFileNotOpened);
	if(err) longjmp(error_ret, SJ3_TooLongComment);

	if(set_stdycmnt(buf)) longjmp(error_ret, serv_errno);
	put_int(SJ3_NormalEnd);
}

void exec_stdypara(void) {
	int stynum, clstep, cllen;

	if(!work_base) longjmp(error_ret, SJ3_NotConnected);
	if(!stdy_base) longjmp(error_ret, SJ3_StdyFileNotOpened);

	get_stdysize(&stynum, &clstep, &cllen);
	put_int(SJ3_NormalEnd);
	put_int(stynum);
	put_int(clstep);
	put_int(cllen);
}

void execute_cmd(void) {
	int i;

	if((i = setjmp(error_ret)) != 0) {
		debug_out(1, "%d: error code = %d\r\n", client_fd, i);
		put_int(i);
	} else {
		cur_cli	  = cur_client;
		work_base = cur_cli->work ? &(cur_cli->work->global) : NULL;
		stdy_base = cur_cli->stdy ? &(cur_cli->stdy->stdy) : NULL;

#define CASE(X) \
	case(X): \
	{ \
		int j = X; \
		debug_out(1, "%d: %d\t", client_fd, j); \
	}
		switch(i = get_int()) {

			CASE(SJ3_CONNECT)
			exec_connect();
			break;
			CASE(SJ3_DISCONNECT)
			exec_disconnect();
			break;

			CASE(SJ3_OPENDICT)
			exec_opendict();
			break;
			CASE(SJ3_CLOSEDICT)
			exec_closedict();
			break;

			CASE(SJ3_OPENSTDY)
			exec_openstdy();
			break;
			CASE(SJ3_CLOSESTDY)
			exec_closestdy();
			break;
			CASE(SJ3_STDYSIZE)
			exec_stdysize();
			break;

			CASE(SJ3_LOCK)
			exec_lock();
			break;
			CASE(SJ3_UNLOCK)
			exec_unlock();
			break;

			CASE(SJ3_PH2KNJ)
			exec_ph2knj(SJIS_PROTO);
			break;
			CASE(SJ3_PH2KNJ_EUC)
			exec_ph2knj(EUC_PROTO);
			break;

			CASE(SJ3_CL2KNJ)
			exec_cl2knj(SJIS_PROTO);
			break;
			CASE(SJ3_CL2KNJ_EUC)
			exec_cl2knj(EUC_PROTO);
			break;
			CASE(SJ3_NEXTCL)
			exec_nextcl(SJIS_PROTO);
			break;
			CASE(SJ3_NEXTCL_EUC)
			exec_nextcl(EUC_PROTO);
			break;
			CASE(SJ3_PREVCL)
			exec_prevcl(SJIS_PROTO);
			break;
			CASE(SJ3_PREVCL_EUC)
			exec_prevcl(EUC_PROTO);
			break;
			CASE(SJ3_CL2KNJ_CNT)
			exec_cl2knj_cnt(SJIS_PROTO);
			break;
			CASE(SJ3_CL2KNJ_CNT_EUC)
			exec_cl2knj_cnt(EUC_PROTO);
			break;
			CASE(SJ3_CL2KNJ_ALL)
			exec_cl2knj_all(SJIS_PROTO);
			break;
			CASE(SJ3_CL2KNJ_ALL_EUC)
			exec_cl2knj_all(EUC_PROTO);
			break;

			CASE(SJ3_STUDY)
			exec_study();
			break;
			CASE(SJ3_CLSTUDY)
			exec_clstudy(SJIS_PROTO);
			break;
			CASE(SJ3_CLSTUDY_EUC)
			exec_clstudy(EUC_PROTO);
			break;

			CASE(SJ3_ADDDICT)
			exec_adddict(SJIS_PROTO);
			break;
			CASE(SJ3_ADDDICT_EUC)
			exec_adddict(EUC_PROTO);
			break;
			CASE(SJ3_DELDICT)
			exec_deldict(SJIS_PROTO);
			break;
			CASE(SJ3_DELDICT_EUC)
			exec_deldict(EUC_PROTO);
			break;

			CASE(SJ3_GETDICT)
			exec_getdict(SJIS_PROTO);
			break;
			CASE(SJ3_GETDICT_EUC)
			exec_getdict(EUC_PROTO);
			break;
			CASE(SJ3_NEXTDICT)
			exec_nextdict(SJIS_PROTO);
			break;
			CASE(SJ3_NEXTDICT_EUC)
			exec_nextdict(EUC_PROTO);
			break;
			CASE(SJ3_PREVDICT)
			exec_prevdict(SJIS_PROTO);
			break;
			CASE(SJ3_PREVDICT_EUC)
			exec_prevdict(EUC_PROTO);
			break;

			CASE(SJ3_MAKEDICT)
			exec_makedict();
			break;
			CASE(SJ3_MAKESTDY)
			exec_makestdy();
			break;
			CASE(SJ3_ACCESS)
			exec_access();
			break;
			CASE(SJ3_MAKEDIR)
			exec_makedir();
			break;

			CASE(SJ3_WHO)
			exec_who();
			break;
			CASE(SJ3_QUIT)
			exec_quit();
			break;
			CASE(SJ3_KILL)
			exec_kill();
			break;
			CASE(SJ3_VERSION)
			exec_version();
			break;

			CASE(SJ3_DICTPASS)
			exec_dictpass();
			break;
			CASE(SJ3_DICTCMNT)
			exec_dictcmnt();
			break;
			CASE(SJ3_STDYPASS)
			exec_stdypass();
			break;
			CASE(SJ3_STDYCMNT)
			exec_stdycmnt();
			break;
		default:
			warning_out("Illegal command");
			longjmp(error_ret, SJ3_IllegalCommand);
			break;
		}
#undef CASE
		debug_out(1, "cmd end\r\n");
	}

	put_flush();
}