1 /*
2 * $Id: js.c,v 2.69.2.4 2000/08/04 05:37:22 kaneda Exp $
3 */
4
5 /*
6 WNN6 CLIENT LIBRARY--SOFTWARE LICENSE TERMS AND CONDITIONS
7
8
9 Wnn6 Client Library :
10 (C) Copyright OMRON Corporation. 1995,1998,2000 all rights reserved.
11 (C) Copyright OMRON Software Co., Ltd. 1995,1998,2000 all rights reserved.
12
13 Wnn Software :
14 (C) Copyright Kyoto University Research Institute for Mathematical Sciences
15 1987, 1988, 1989, 1990, 1991, 1992, 1993
16 (C) Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1993
17 (C) Copyright ASCTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992, 1993
18
19 Preamble
20
21 These Wnn6 Client Library--Software License Terms and Conditions
22 (the "License Agreement") shall state the conditions under which you are
23 permitted to copy, distribute or modify the software which can be used
24 to create Wnn6 Client Library (the "Wnn6 Client Library"). The License
25 Agreement can be freely copied and distributed verbatim, however, you
26 shall NOT add, delete or change anything on the License Agreement.
27
28 OMRON Corporation and OMRON Software Co., Ltd. (collectively referred to
29 as "OMRON") jointly developed the Wnn6 Software (development code name
30 is FI-Wnn), based on the Wnn Software. Starting from November, 1st, 1998,
31 OMRON publishes the source code of the Wnn6 Client Library, and OMRON
32 permits anyone to copy, distribute or change the Wnn6 Client Library under
33 the License Agreement.
34
35 Wnn6 Client Library is based on the original version of Wnn developed by
36 Kyoto University Research Institute for Mathematical Sciences (KURIMS),
37 OMRON Corporation and ASTEC Inc.
38
39 Article 1. Definition.
40
41 "Source Code" means the embodiment of the computer code, readable and
42 understandable by a programmer of ordinary skills. It includes related
43 source code level system documentation, comments and procedural code.
44
45 "Object File" means a file, in substantially binary form, which is directly
46 executable by a computer after linking applicable files.
47
48 "Library" means a file, composed of several Object Files, which is directly
49 executable by a computer after linking applicable files.
50
51 "Software" means a set of Source Code including information on its use.
52
53 "Wnn6 Client Library" the computer program, originally supplied by OMRON,
54 which can be used to create Wnn6 Client Library.
55
56 "Executable Module" means a file, created after linking Object Files or
57 Library, which is directly executable by a computer.
58
59 "User" means anyone who uses the Wnn6 Client Library under the License
60 Agreement.
61
62 Article 2. Copyright
63
64 2.1 OMRON Corporation and OMRON Software Co., Ltd. jointly own the Wnn6
65 Client Library, including, without limitation, its copyright.
66
67 2.2 Following words followed by the above copyright notices appear
68 in all supporting documentation of software based on Wnn6 Client Library:
69
70 This software is based on the original version of Wnn6 Client Library
71 developed by OMRON Corporation and OMRON Software Co., Ltd. and also based on
72 the original version of Wnn developed by Kyoto University Research Institute
73 for Mathematical Sciences (KURIMS), OMRON Corporation and ASTEC Inc.
74
75 Article 3. Grant
76
77 3.1 A User is permitted to make and distribute verbatim copies of
78 the Wnn6 Client Library, including verbatim of copies of the License
79 Agreement, under the License Agreement.
80
81 3.2 A User is permitted to modify the Wnn6 Client Library to create
82 Software ("Modified Software") under the License Agreement. A User
83 is also permitted to make or distribute copies of Modified Software,
84 including verbatim copies of the License Agreement with the following
85 information. Upon modifying the Wnn6 Client Library, a User MUST insert
86 comments--stating the name of the User, the reason for the modifications,
87 the date of the modifications, additional terms and conditions on the
88 part of the modifications if there is any, and potential risks of using
89 the Modified Software if they are known--right after the end of the
90 License Agreement (or the last comment, if comments are inserted already).
91
92 3.3 A User is permitted to create Library or Executable Modules by
93 modifying the Wnn6 Client Library in whole or in part under the License
94 Agreement. A User is also permitted to make or distribute copies of
95 Library or Executable Modules with verbatim copies of the License
96 Agreement under the License Agreement. Upon modifying the Wnn6 Client
97 Library for creating Library or Executable Modules, except for porting
98 a computer, a User MUST add a text file to a package of the Wnn6 Client
99 Library, providing information on the name of the User, the reason for
100 the modifications, the date of the modifications, additional terms and
101 conditions on the part of the modifications if there is any, and potential
102 risks associated with using the modified Wnn6 Client Library, Library or
103 Executable Modules if they are known.
104
105 3.4 A User is permitted to incorporate the Wnn6 Client Library in whole
106 or in part into another Software, although its license terms and
107 conditions may be different from the License Agreement, if such
108 incorporation or use associated with the incorporation does NOT violate
109 the License Agreement.
110
111 Article 4. Warranty
112
113 THE WNN6 CLIENT LIBRARY IS PROVIDED BY OMRON ON AN "AS IS" BAISIS.
114 OMRON EXPRESSLY DISLCIAMS ANY AND ALL WRRANTIES, EXPRESS OR IMPLIED,
115 INCLUDING, WITHOUT LIMITATION, WARRANTIES OF MERCHANTABILITY AND FITNESS
116 FOR A PARTICULAR PURPOSE, IN CONNECTION WITH THE WNN6 CLIENT LIBRARY
117 OR THE USE OR OTHER DEALING IN THE WNN6 CLIENT LIBRARY. IN NO EVENT
118 SHALL OMRON BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, PUNITIVE
119 OR CONSEQUENTIAL DAMAGES OF ANY KIND WHATSOEVER IN CONNECTION WITH THE
120 WNN6 CLIENT LIBRARY OR THE USE OR OTHER DEALING IN THE WNN6 CLIENT
121 LIBRARY.
122
123 ***************************************************************************
124 Wnn6 Client Library :
125 (C) Copyright OMRON Corporation. 1995,1998,2000 all rights reserved.
126 (C) Copyright OMRON Software Co., Ltd. 1995,1998,2000 all rights reserved.
127
128 Wnn Software :
129 (C) Copyright Kyoto University Research Institute for Mathematical Sciences
130 1987, 1988, 1989, 1990, 1991, 1992, 1993
131 (C) Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1993
132 (C) Copyright ASCTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992, 1993
133 ***************************************************************************
134
135 Comments on Modifications:
136 */
137
138 /* Version 4
139 */
140 /*
141 Nihongo Henkan Library
142 */
143 /*
144 entry functions
145
146 js_open_lang js_close
147 js_change_current_jserver
148 js_connect_lang js_disconnect
149 js_isconnect
150
151 js_param_get js_param_set
152
153 js_access js_mkdir
154
155 js_get_lang js_set_lang
156
157
158 extern Variables
159 int wnn_errorno;
160 */
161
162
163 #if defined(__DragonFly__)
164 #include <stdlib.h>
165 #include <string.h>
166 #include <unistd.h>
167 #include <arpa/inet.h>
168 #else
169 extern char *malloc();
170 #endif
171
172 #include <stdio.h>
173 #include <ctype.h>
174 #ifdef UX386
175 #include <X11/Xos.h>
176 #else
177 #include <fcntl.h>
178 #endif
179 #include <pwd.h>
180 #ifndef UX386
181 #include <sys/types.h>
182 #endif
183 #include <sys/stat.h>
184 #include <errno.h>
185 extern int errno;
186 #include <signal.h>
187 #include "jd_sock.h"
188 #include "commonhd.h"
189 #include "demcom.h"
190 #include "config.h"
191
192 #include "wnnerror.h"
193 #include "jslib.h"
194 #include "jllib.h"
195 #include "mt_jlib.h"
196 #include "jh.h"
197
198 #include "msg.h"
199 #include "serverdefs.h"
200
201 #ifdef SYSVR2
202 #define bzero(adr,n) memset((adr),0,(n))
203 #endif
204
205 #define JS /* For include ../etc/bdic.c */
206 #include "../etc/bdic.c"
207 /*
208 * Hideyuki Kishiba (Jul. 11, 1994)
209 * New bdic function for FI-Wnn
210 */
211 #include "../etc/fi_bdic.c"
212 #include "../etc/pwd.c"
213
214 #if !defined(__DragonFly__)
215 char *malloc();
216 #endif
217
218 typedef struct _host_address {
219 int address_len;
220 char *address;
221 } host_address;
222
223 int wnn_errorno =0;
224
225 struct msg_cat *wnn_msg_cat = NULL;
226
227 /* j Lib. */
228
229 static int current_sd; /** �����å�fd **/
230 static WNN_JSERVER_ID_INT *current_js = NULL;
231
232 /* Packet Buffers */
233 static unsigned char snd_buf[S_BUF_SIZ]; /** ���� **/
234 static int sbp=0; /** �����Хåե����ݥ����� **/
235 static int rbc= -1; /** �����Хåե����ݥ����� **/
236
237 #if defined(EAGAIN)
238 # if defined(EWOULDBLOCK)
239 # define ERRNO_CHECK(no) ((no) == EAGAIN || (no) == EWOULDBLOCK)
240 # else /* defined(EWOULDBLOCK) */
241 # define ERRNO_CHECK(no) ((no) == EAGAIN)
242 # endif /* defined(EWOULDBLOCK) */
243 #else /* defined(EAGAIN) */
244 # if defined(EWOULDBLOCK)
245 # define ERRNO_CHECK(no) ((no) == EWOULDBLOCK)
246 # else /* defined(EWOULDBLOCK) */
247 # define ERRNO_CHECK(no) (0)
248 # endif /* defined(EWOULDBLOCK) */
249 #endif /* defined(EAGAIN) */
250
251 static int _get_server_name(
252 char *server,
253 char *pserver,
254 int pserver_size,
255 int *portNO
256 );
257 static int writen();
258
259
260 /********* V4 *****************/
261 /***
262 jserver_dead Macro
263 ***/
264
265 static jmp_buf current_jserver_dead;
266
267 #define handler_of_jserver_dead(current_js) \
268 { \
269 if (current_js) { \
270 if(current_js->js_dead){ \
271 js_wnn_errorno_set=WNN_JSERVER_DEAD; \
272 } else \
273 if(setjmp(js_current_jserver_dead)){ \
274 if (!js_wnn_errorno_eql) js_wnn_errorno_set=WNN_JSERVER_DEAD; \
275 } else \
276 js_wnn_errorno_set = 0; /* here initialize wnn_errorno; */ \
277 } \
278 }
279
280 #define handler_of_jserver_dead_env(env) \
281 { \
282 if (env->js_id) { \
283 if(env->js_id->js_dead){ \
284 env_wnn_errorno_set=WNN_JSERVER_DEAD; \
285 } else \
286 if(setjmp(env_current_jserver_dead)){ \
287 if (!env_wnn_errorno_eql) env_wnn_errorno_set=WNN_JSERVER_DEAD; \
288 } else \
289 env_wnn_errorno_set = 0; /* here initialize wnn_errorno; */ \
290 } \
291 }
292
293
294 static void
set_current_js(server)295 set_current_js(server)
296 register WNN_JSERVER_ID *server;
297 {
298 current_js = (WNN_JSERVER_ID_INT *)server;
299 current_sd = current_js->orig.sd;
300 }
301
302 #undef ARGS
303 #define ARGS char
304 #define js_wnn_errorno_set wnn_errorno
305 #define js_wnn_errorno_eql wnn_errorno
306 #define env_wnn_errorno_set wnn_errorno
307 #define env_wnn_errorno_eql wnn_errorno
308 #define js_current_jserver_dead current_jserver_dead
309 #define env_current_jserver_dead current_jserver_dead
310
311 /** �ǡ�����������Τ���θ���� **/
312 static void
demon_dead(server)313 demon_dead(server)
314 ARGS *server;
315 {
316 current_js->orig.js_dead= -1;
317 js_wnn_errorno_set = WNN_JSERVER_DEAD;
318 shutdown(current_sd, 2);
319 close(current_sd);
320 #if DEBUG
321 fprintf(stderr,"jslib:JSERVER %s is Dead\n",current_js->orig.js_name);
322 #endif
323 if(current_js->orig.js_dead_env_flg){
324 longjmp(current_js->orig.js_dead_env,666);
325 }
326 longjmp(js_current_jserver_dead,666);
327 /* never reach */
328 }
329
330
331 /**
332 �����åȤ����ץ���current_sd�˥����å�fd���֤�
333 (cd�Ȥ����Τϥ��ߥ�˥��������ǥХ�����̾��)
334 **/
335 static int
cd_open(lang)336 cd_open(lang)
337 register char *lang;
338 {
339 #ifdef AF_UNIX
340 int sd;
341 struct sockaddr_un saddr; /** �����å� **/
342 char *sock_name = NULL;
343 saddr.sun_family = AF_UNIX;
344
345 /* find socket name from table by lang */
346 if (lang && *lang) {
347 if ((sock_name = wnn_get_unixdomain_of_serverdefs(lang)) == NULL) {
348 sock_name = UNIX_SOCKET_NAME;
349 }
350 } else {
351 sock_name = UNIX_SOCKET_NAME; /* Jserver */
352 }
353 strncpy(saddr.sun_path, sock_name, sizeof(saddr.sun_path) - 1);
354 saddr.sun_path[sizeof(saddr.sun_path) - 1] = '\0';
355
356 if ((sd = socket(AF_UNIX,SOCK_STREAM, 0)) == ERROR) {
357 #if DEBUG
358 xerror("jslib:Can't create socket.\n");
359 #endif
360 return -1;
361 }
362
363 #if !defined(SUN_LEN)
364 # define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
365 #endif
366 if (connect(sd,(struct sockaddr *)&saddr, SUN_LEN(&saddr)) == ERROR) {
367 #if DEBUG
368 xerror("jslib:Can't connect socket.\n");
369 #endif
370 close(sd);
371 return -1;
372 }
373 return sd;
374 #else
375 return -1;
376 #endif
377 }
378
379 static intfntype
connect_timeout()380 connect_timeout()
381 {
382 SIGNAL_RETURN;
383 }
384
385 static int
cd_open_in_core(sa,tmout)386 cd_open_in_core(sa, tmout)
387 register struct sockaddr_in *sa;
388 register int tmout;
389 {
390 int sd;
391 int ret;
392 int old_alarm = 0;
393 intfntype (*save_alarm_proc)() = NULL;
394
395 if ((sd = socket(AF_INET, SOCK_STREAM, 0)) == ERROR){
396 #if DEBUG
397 xerror("jslib:Can't create Inet socket.\n");
398 #endif
399 return -1 ;
400 }
401
402 if (tmout > 0) {
403 save_alarm_proc = signal(SIGALRM, connect_timeout);
404 old_alarm = alarm(tmout);
405 }
406 ret = connect(sd, (struct sockaddr *)sa, sizeof(struct sockaddr_in));
407 if (tmout > 0) {
408 alarm(old_alarm);
409 if (save_alarm_proc)
410 signal(SIGALRM, save_alarm_proc);
411 else
412 signal(SIGALRM, SIG_IGN);
413 }
414 if (ret == ERROR) {
415 #if DEBUG
416 xerror("jslib:Can't connect Inet socket.\n");
417 #endif
418 close(sd);
419 return -1 ;
420 }
421 return sd;
422 }
423
424 static int
cd_open_in_by_addr(addr,addrlen,port,tmout)425 cd_open_in_by_addr(addr, addrlen, port, tmout)
426 char *addr;
427 int addrlen, port, tmout;
428 {
429 struct sockaddr_in saddr_in;
430
431 bzero((char *)&saddr_in,sizeof(saddr_in));
432 bcopy(addr,(char *)&saddr_in.sin_addr, addrlen);
433 saddr_in.sin_family = AF_INET;
434 saddr_in.sin_port = port;
435 return(cd_open_in_core(&saddr_in, tmout));
436 }
437
438 typedef struct _my_serv_struct {
439 char *name;
440 int port;
441 struct _my_serv_struct *next;
442 } my_serv_struct;
443
my_getservbyname(name)444 static int my_getservbyname(name)
445 register char *name;
446 {
447 static my_serv_struct *tbl = NULL;
448 register my_serv_struct *p;
449 struct servent *sp = NULL;
450 register int len;
451
452 for (p = tbl; p; p = p->next) {
453 if (p->name && !strcmp(p->name, name)) return(p->port);
454 }
455 if (!(sp = getservbyname(name,"tcp"))) return(-1);
456 len = strlen(name);
457 if (!(p = (my_serv_struct *)malloc(sizeof(my_serv_struct) + len + 1)))
458 return(-1);
459 p->name = ((char *)p) + sizeof(my_serv_struct);
460 strcpy(p->name, name);
461 p->port = ntohs(sp->s_port);
462 p->next = tbl;
463 tbl = p;
464 return(p->port);
465 }
466
467 static int
cd_open_in(server,lang,tmout)468 cd_open_in(server, lang, tmout)
469 register char *server;
470 register char *lang;
471 register int tmout;
472 {
473 struct sockaddr_in saddr_in; /** �����å� **/
474 register struct hostent *hp;
475 int serverNO, port_num;
476 char pserver[64];
477 char sserver[64];
478 char *serv_name = NULL;
479 unsigned long ia;
480 char *inet_ntoa();
481
482 serverNO = _get_server_name(server, pserver, sizeof(pserver), &port_num);
483
484 if (port_num > 0) {
485 /* absolute port number is specified */
486 serverNO += port_num;
487 } else {
488 /* find service name from table by lang */
489 if (lang && *lang) {
490 if ((serv_name = wnn_get_service_of_serverdefs(lang)) == NULL) {
491 strncpy(sserver, SERVERNAME, sizeof(sserver) - 1);
492 } else {
493 strncpy(sserver, serv_name, sizeof(sserver) - 1);
494 }
495 } else {
496 strncpy(sserver, SERVERNAME, sizeof(sserver) - 1);
497 }
498 sserver[sizeof(sserver) - 1] = 0;
499
500 if ((port_num = my_getservbyname(sserver)) != -1) {
501 serverNO += port_num;
502 } else {
503 if (lang && *lang &&
504 (port_num = wnn_get_port_num_of_serverdefs(lang)) != -1) {
505 serverNO += port_num;
506 } else {
507 serverNO += WNN_PORT_IN;
508 }
509 }
510 }
511 bzero((char *)&saddr_in,sizeof(saddr_in));
512
513 if (isascii(pserver[0]) && isdigit(pserver[0])) {
514 ia = inet_addr(pserver);
515 saddr_in.sin_addr.s_addr = ia;
516 } else if ((hp = gethostbyname(pserver))) {
517 bcopy(hp->h_addr,(char *)&saddr_in.sin_addr, hp->h_length);
518 } else {
519 return(-1);
520 }
521 saddr_in.sin_family = AF_INET;
522 saddr_in.sin_port = htons(serverNO);
523 return(cd_open_in_core(&saddr_in, tmout));
524 }
525
526 /* get server name and return serverNo */
527 /* and return absolute port number 1993/12/07 S.Kuwari */
528 static int
_get_server_name(server,pserver,pserver_size,portNO)529 _get_server_name(server, pserver, pserver_size, portNO)
530 char *server;
531 char *pserver;
532 int pserver_size;
533 int *portNO;
534 {
535 register char *p;
536 register int port = 0, offset = 0;
537
538 strncpy(pserver, server, pserver_size - 1);
539 pserver[pserver_size - 1] = '\0';
540 if ((p = strchr(pserver, ':'))) {
541 *p = '\0';
542 if (*(p+1)) offset = atoi(p+1);
543 }
544 if ((p = strchr(pserver, '/'))) {
545 *p = '\0';
546 if (*(p+1)) port = atoi(p+1);
547 }
548 *portNO = port;
549 return(offset);
550 }
551
552 /* Packet SND/RCV subroutines */
553 static void put4com();
554
555 /* �����Ф�����ץ�ȥ�����ݡ��Ȥ��Ƥ��뤫�ɤ����Υ����å� */
556 #define check_version(cmd) \
557 (((cmd>>12) & 0xFFF) > (current_js->version & 0xFFF))
558
559 /* �����Ф��ƣɴط��������ݡ��Ȥ��Ƥ��뤫�ɤ����Υ����å� */
560 #define CHECK_FI \
561 ((current_js->version & 0xFFF) >= 0xF00)
562
563 /** �ѥ��åȤΥإå��������� **/
564 static void
snd_head(cmd,server)565 snd_head(cmd, server)
566 int cmd; /** cmd=���ޥ�� **/
567 ARGS *server;
568 {
569 sbp=0;
570 if (check_version(cmd)) {
571 js_wnn_errorno_set = WNN_NOT_SUPPORT_PACKET;
572 longjmp(js_current_jserver_dead,666);
573 }
574 put4com(cmd, server);
575 rbc= -1;
576 }
577
578 /** �ѥ��åȤΥإå��������� **/
579 static int
snd_env_head(env,cmd)580 snd_env_head(env,cmd)
581 register struct wnn_env *env;
582 int cmd; /** cmd=���ޥ�� **/
583 {
584 ARGS *args = NULL;
585
586 snd_head(cmd, args);
587 put4com(env->env_id, args);
588 return 0;
589 }
590
591 /** �ѥ��åȤΥإå��������� **/
592 static int
snd_server_head(server,cmd)593 snd_server_head(server,cmd)
594 register WNN_JSERVER_ID *server;
595 int cmd; /** cmd=���ޥ�� **/
596 {
597 ARGS *args = NULL;
598
599 snd_head(cmd, args);
600 return 0;
601 }
602
603 /** �����Хåե���ե�å��夹�� **/
604 static int
snd_flush(server)605 snd_flush(server)
606 ARGS *server;
607 {
608 if(sbp==0)return(-1);
609 writen(sbp, server);
610 sbp=0;
611 return(0);
612 }
613
614 static int
writen(n,server)615 writen(n, server)
616 int n;
617 ARGS *server;
618 {int cc,x;
619 for(cc=0;cc<n;){
620 errno = 0;
621 x=write(current_sd, &(snd_buf[cc]), n-cc );
622 if(x < 0) {
623 if (ERRNO_CHECK(errno) || errno == EINTR) {
624 continue;
625 } else {
626 demon_dead(server);
627 return -1;
628 }
629 }
630 cc+=x;
631 }
632 #if DEBUG
633 fprintf(stderr,"jslib:writen=%d\n",x);
634 /* dmp(snd_buf,x); */
635 #endif
636 return(0);
637 }
638
639 /** ������1�������� **/
640 static void
put1com(c,server)641 put1com(c, server)
642 int c;
643 ARGS *server;
644 {
645 snd_buf[sbp++]=c;
646 if(sbp>=S_BUF_SIZ){
647 writen(S_BUF_SIZ, server);
648 sbp=0;
649 }
650 }
651
652 /** ������2�������� **/
653 static void
put2com(c,server)654 put2com(c, server)
655 int c;
656 ARGS *server;
657 {
658 put1com(c>>(8*1), server);
659 put1com(c , server);
660 }
661
662 /** ������4�������� **/
663 static void
put4com(c,server)664 put4com(c, server)
665 int c;
666 ARGS *server;
667 {
668 put1com(c>>(8*3), server);
669 put1com(c>>(8*2), server);
670 put1com(c>>(8*1), server);
671 put1com(c , server);
672 }
673
674 /** �����Ф�ʸ��������� **/
675 static void
putwscom(p,server)676 putwscom(p, server)
677 register w_char *p;
678 ARGS *server;
679 {
680 if(p==NULL){ put2com(0, server); return; }
681 while(*p)put2com(*p++, server);
682 put2com(0, server);
683 }
684
685 /** �����Ф�ʸ��������� **/
686 static void
putscom(p,server)687 putscom(p, server)
688 register char *p;
689 ARGS *server;
690 {
691 if(p==NULL){ put1com(0, server); return; }
692 while(*p)put1com(*p++, server);
693 put1com(0, server);
694 }
695
696 /** �����Ф���1�Х��ȼ����� **/
697 static int
get1com(server)698 get1com(server)
699 ARGS *server;
700 {
701 static int rbp;
702 static unsigned char rcv_buf[R_BUF_SIZ]; /** ���� **/
703
704 if(rbc<=0){
705 while(1) {
706 errno = 0;
707 rbc = read(current_sd, rcv_buf, R_BUF_SIZ);
708 if(rbc <= 0) {
709 if (ERRNO_CHECK(errno)) {
710 continue;
711 } else if (rbc == 0) {
712 demon_dead(server);
713 return -1;
714 } else { /* cc == -1 */
715 if (errno != EINTR) {
716 demon_dead(server);
717 return -1;
718 }
719 continue;
720 }
721 }
722 rbp=0;
723 #if DEBUG
724 fprintf(stderr,"jslib:read:rbc=%d\n",rbc);
725 /* dmp(rcv_buf,rbc); */
726 #endif
727 break;
728 }
729 }
730 rbc--;
731 return rcv_buf[rbp++] & 0xFF ;
732 }
733
734 /** �����Ф���2�Х��ȼ����� **/
735 static int
get2com(server)736 get2com(server)
737 ARGS *server;
738 {register int h;
739 h=get1com(server);
740 return (h<<8) | get1com(server);
741 }
742
743 /** �����Ф���4�Х��ȼ����� **/
744 static int
get4com(server)745 get4com(server)
746 ARGS *server;
747 {register int h1,h2,h3;
748 h1=get1com(server) << 24 ;
749 h2=get1com(server) << 16 ;
750 h3=get1com(server) << 8 ;
751 return h1 | h2 | h3 | get1com(server);
752 }
753
754 /** �����Ф���ʸ����������� **/
755 static void
getscom(cp,server,buflen)756 getscom(cp, server, buflen)
757 register char *cp;
758 ARGS *server;
759 register int buflen;
760 {
761 register int i;
762
763 for (i = 0 ; i < buflen ; i++) {
764 if ((*cp++ = get1com(server)) == '\0')
765 break;
766 }
767 /* Buffer Overflow size? */
768 if (i >= buflen) {
769 /* �Ĥ�Υǡ������˴����� */
770 while (get1com(server) != 0)
771 ;
772 if (i > 0)
773 *(cp - 1) = '\0'; /* set null terminate */
774 }
775 }
776
777 /** �����Ф���ʸ����������� **/
778 static void
getwscom(wp,server,buflen)779 getwscom(wp, server, buflen)
780 register w_char *wp;
781 ARGS *server;
782 register int buflen; /* not bytes. "buflen" is word length. */
783 {
784 register int i;
785
786 for (i = 0 ; i < buflen ; i++) {
787 if ((*wp++ = get2com(server)) == '\0')
788 break;
789 }
790 /* Buffer Overflow size? */
791 if (i >= buflen) {
792 /* �Ĥ�Υǡ������˴����� */
793 while (get2com(server) != 0)
794 ;
795 if (i > 0)
796 *(wp - 1) = '\0'; /* set null terminate */
797 }
798 }
799
800
801
802 /* Debug Subroutines */
803 #if DEBUG
804 void
xerror(s)805 xerror(s)char *s;
806 {
807 fprintf(stderr,"%s\n",s);
808 }
809
810 void
dmp(p,c)811 dmp(p,c)char *p;
812 {
813 int i,j;
814 for(i=0;;i+=16){
815 for(j=0;j<16;j++){
816 if(c<=0){ fprintf(stderr,"\n"); return;}
817 fprintf(stderr,"%02x ",p[i+j]&0xFF);
818 c--;
819 }
820 fprintf(stderr,"\n");
821 }
822 }
823
824 #endif
825
826 /* get login name form /etc/passwd file */
827 static char*
getlogname()828 getlogname()
829 {
830 extern struct passwd *getpwuid();
831 struct passwd *p;
832
833 if ((p = getpwuid(getuid())) == NULL)
834 return(NULL);
835 return(p->pw_name);
836 }
837
838 static int
send_js_open_core(server,host,user,version)839 send_js_open_core(server, host, user, version)
840 WNN_JSERVER_ID *server;
841 char *host, *user;
842 int version;
843 {
844 int x;
845
846 handler_of_jserver_dead(server);
847 if(js_wnn_errorno_eql) return(-1);
848 snd_head(JS_OPEN, server);
849 put4com(version, server); /* H.T. */
850 putscom(host, server);
851 putscom(user, server);
852 snd_flush(server);
853 if((x = get4com(server)) == -1){
854 js_wnn_errorno_set=get4com(server);
855 return(-1);
856 }
857 return(x);
858 }
859
860
861
862 /*:::DOC_START
863 *
864 * Function Name: version_negotiation
865 * Description :
866 * ���饤����ȡ������д֤Υץ�ȥ���С�������Ĵ����Ԥ�
867 * Parameter :
868 * server : (InOut) �����о���¤�ΤؤΥݥ���
869 * host : (In) ���饤����Ȼ��ѥۥ���̾
870 * user : (In) ���饤����Ȼ��ѥ桼��̾
871 * init_version : (In) ���饤����ȤΥץ�ȥ������С�������ֹ�
872 *
873 * Return value : 0==SUCCESS, -1==ERROR
874 *
875 * Author : Hideyuki Kishiba
876 *
877 * Revision history:
878 *
879 *:::DOC_END
880 */
881 static int
version_negotiation(server,host,user,init_version)882 version_negotiation(server, host, user, init_version)
883 WNN_JSERVER_ID *server;
884 char *host, *user;
885 int init_version;
886 {
887 int version, dummy;
888
889 /* ��㡼���С����������å� */
890 if((init_version >> 12) != 4) return(-1);
891
892 if (init_version > 0x4F00) {
893 /* 4.F00 ����礭����� 4.F00 �Ǻƥȥ饤 */
894 if (send_js_open_core(server, host, user, 0x4F00) < 0) {
895 if (js_wnn_errorno_eql == WNN_BAD_VERSION) {
896 /* 4.003 �Ǻƥȥ饤 */
897 if (send_js_open_core(server, host, user, 0x4003) < 0)
898 return(-1);
899 ((WNN_JSERVER_ID_INT *)server)->version = 0x4003;
900 return(0);
901 }
902 return(-1);
903 }
904 /* �����ХС������Υ����å� */
905 if (js_version(server, &version, &dummy) == -1) return(-1);
906 if (version > 0x4F00) {
907 /* �����ХС������Ǻƥȥ饤 */
908 if (send_js_open_core(server, host, user, version) >= 0) {
909 ((WNN_JSERVER_ID_INT *)server)->version = version;
910 return(0);
911 }
912 }
913 ((WNN_JSERVER_ID_INT *)server)->version = 0x4F00;
914 } else {
915 /* 4.003 �Ǻƥȥ饤 */
916 if (send_js_open_core(server, host, user, 0x4003) < 0)
917 return(-1);
918 ((WNN_JSERVER_ID_INT *)server)->version = 0x4003;
919 }
920
921 return(0);
922 } /* End of version_negotiation */
923
924
925
926 static WNN_JSERVER_ID *
reconnect_other_host(server,user,host,tmout)927 reconnect_other_host(server, user, host, tmout)
928 WNN_JSERVER_ID *server;
929 char *user, *host;
930 int tmout;
931 {
932 char addr[32];
933 int addrlen, i, port;
934 char *new_js;
935 int x;
936 struct hostent *hp;
937
938 addrlen = get4com(server);
939 /* Buffer Overflow size? */
940 if (addrlen > sizeof(addr)) {
941 for (i = 0; i < addrlen; i++) get1com(server);
942 } else {
943 for (i = 0; i < addrlen; i++) addr[i] = get1com(server);
944 }
945 port = get4com(server);
946 js_close(server);
947
948 /* Buffer Overflow size? */
949 if (addrlen > sizeof(addr)) {
950 js_wnn_errorno_set = WNN_SOME_ERROR;
951 return NULL;
952 }
953 if (!(hp = gethostbyaddr(addr, addrlen, AF_INET))) {
954 js_wnn_errorno_set = WNN_NO_JSERVER;
955 return NULL;
956 }
957 sbp=0; /* init sndBufPointer */
958 if(!(new_js=(char *)malloc(sizeof(WNN_JSERVER_ID_INT)))){
959 js_wnn_errorno_set=WNN_ALLOC_FAIL;
960 return NULL;
961 }
962 server =(WNN_JSERVER_ID *) new_js;
963 strncpy(server->js_name, hp->h_name, sizeof(server->js_name) - 1);
964 server->js_name[sizeof(server->js_name) - 1] = '\0';
965 server->js_dead= 0;
966 server->js_dead_env_flg= 0;
967 if((current_sd= cd_open_in_by_addr(addr, addrlen, port, tmout))==-1){
968 js_wnn_errorno_set = WNN_NO_JSERVER;
969 free((char*)server);
970 current_js=NULL;
971 return NULL;
972 }
973 server->sd= current_sd;
974 ((WNN_JSERVER_ID_INT *)server)->version = JLIB_VERSION;
975 ((WNN_JSERVER_ID_INT *)server)->extensions = NULL;
976 if ((x = send_js_open_core(server, host, user, JLIB_VERSION)) == -1) {
977 x = js_wnn_errorno_eql;
978 js_wnn_errorno_set = 0;
979 if ((x != WNN_BAD_VERSION) ||
980 version_negotiation(server, host, user, JLIB_VERSION)) {
981 js_close(server); /* H.T. */
982 current_js = NULL;
983 return NULL;
984 }
985 } else if (x == 1) {
986 /* re-connect to other server */
987 return(reconnect_other_host(server, user, host, tmout));
988 }
989 return(server);
990 }
991
992 /*
993 * Lib. Functions
994 * raw lib.
995 */
996
997 /***
998 js
999 ��global
1000 ***/
1001
1002
1003 /** jserver ����³���롣jserver_id ���֤��� **/
1004 WNN_JSERVER_ID *
js_open_lang(servername,lang,tmout)1005 js_open_lang(servername, lang, tmout)
1006 register char *servername, *lang;
1007 register int tmout;
1008 {char *new_js, *username;
1009 char host[WNN_HOSTLEN],user[WNN_ENVNAME_LEN];
1010 int x;
1011 WNN_JSERVER_ID_INT *server;
1012
1013 DoOnce( &once, _InitMutexs );
1014 LockMutex(&msg_lock);
1015 if (wnn_msg_cat == NULL){
1016 char nlspath[64];
1017 strcpy(nlspath, LIBDIR);
1018 strcat(nlspath, "/%L/%N");
1019 wnn_msg_cat = msg_open("libwnn.msg", nlspath, lang, NULL);
1020 if(wnn_msg_cat == NULL){
1021 fprintf(stderr, "libwnn: Can't open message file for libwnn.a\n");
1022 }
1023 }
1024 UnlockMutex(&msg_lock);
1025
1026 if(!(new_js=(char *)malloc(sizeof(WNN_JSERVER_ID_INT)))){
1027 wnn_errorno=WNN_ALLOC_FAIL;
1028 return NULL;
1029 }
1030
1031 LockMutex(&open_lock);
1032 current_js =(WNN_JSERVER_ID_INT *) new_js;
1033 if (servername == NULL) {
1034 current_js->orig.js_name[0] = '\0';
1035 } else {
1036 strncpy(current_js->orig.js_name, servername, sizeof(current_js->orig.js_name) - 1);
1037 current_js->orig.js_name[sizeof(current_js->orig.js_name) - 1] = '\0';
1038 }
1039 current_js->orig.js_dead= 0;
1040 current_js->orig.js_dead_env_flg= 0;
1041 InitMutex(&(current_js_js_lock));
1042
1043 /*
1044 if(user == NULL || 0==strcmp(user,""))
1045 */
1046 username = getlogname();
1047 if (username) {
1048 strncpy(user, username, WNN_ENVNAME_LEN);
1049 user[WNN_ENVNAME_LEN-1] = '\0'; /* truncate by WNN_ENVNAME_LEN */
1050 } else {
1051 user[0] = '\0';
1052 }
1053 if(servername == NULL || 0==strcmp(servername,"") || 0==strcmp(servername,"unix")){
1054 strcpy(host,"unix");
1055 if((current_sd= cd_open(lang))==-1){
1056 UnlockMutex(&open_lock);
1057 wnn_errorno=WNN_SOCK_OPEN_FAIL;free((char*)current_js);current_js=NULL;
1058 return NULL;
1059 }
1060 }else{
1061 gethostname(host,WNN_HOSTLEN);
1062 host[WNN_HOSTLEN-1] = '\0'; /* truncate by WNN_HOSTLEN */
1063 if((current_sd= cd_open_in(servername, lang, tmout))==-1){
1064 UnlockMutex(&open_lock);
1065 wnn_errorno=WNN_SOCK_OPEN_FAIL;free((char*)current_js);current_js=NULL;
1066 return NULL;
1067 }
1068 }
1069 current_js->orig.sd= current_sd;
1070 current_js->version= JLIB_VERSION;
1071 current_js->extensions= NULL;
1072 server = current_js;
1073 if ((x = send_js_open_core(server, host, user, JLIB_VERSION)) == -1) {
1074 x = wnn_errorno;
1075 wnn_errorno = 0;
1076 if ((x != WNN_BAD_VERSION) ||
1077 version_negotiation(server, host, user, JLIB_VERSION)) {
1078 js_close(current_js);
1079 current_js = NULL;
1080 wnn_errorno = x;
1081 UnlockMutex(&open_lock);
1082 return NULL;
1083 }
1084 } else if (x == 1) {
1085 /* re-connect to other server */
1086 return(reconnect_other_host(server, user, host, tmout));
1087 }
1088 UnlockMutex(&open_lock);
1089 return (WNN_JSERVER_ID *)current_js;
1090 }
1091
1092
1093
1094 /** �����åȤ��������� **/
1095 /** jserver �Ȥ���³�� close ���롣 **/
1096 int
js_close(server)1097 js_close(server)
1098 WNN_JSERVER_ID *server;
1099 {
1100 register int x;
1101 WNN_JSERVER_ID_INT tmp_js_id;
1102
1103 if(server==0) return(-1);
1104 tmp_js_id = *(WNN_JSERVER_ID_INT *)server;
1105 free((char *)server);
1106 current_js = &tmp_js_id;
1107 server = (WNN_JSERVER_ID *)current_js;
1108 set_current_js(server);
1109 LockMutex(&(current_js_js_lock));
1110 /* handler of jserver dead */
1111 handler_of_jserver_dead(server);
1112 if(wnn_errorno) {
1113 UnlockMutex(&(current_js_js_lock));
1114 return(-1);
1115 }
1116 snd_head(JS_CLOSE, server);
1117 snd_flush(server);
1118 x=get4com(server);
1119 if(x==-1)wnn_errorno=get4com(server);
1120 close(current_sd);
1121 UnlockMutex(&(current_js_js_lock));
1122 return x;
1123 }
1124
1125
1126 /*
1127 jserver �Ȥδ֤� connection ��ĥ�ꡢƱ���� jserver �������˴�
1128 �����롣env_name �˴���¸�ߤ���Ķ�����ꤷ�����ˤϤ��δĶ���
1129 �֤���NULL ����ꤷ�����ˤϿ������Ķ����ä��֤���
1130 */
1131
1132 struct wnn_env *
js_connect_lang(server,env_name,lang)1133 js_connect_lang(server, env_name, lang)
1134 register char *env_name;
1135 WNN_JSERVER_ID *server;
1136 char *lang;
1137 {
1138 register int e_id;
1139 register struct wnn_env_int *env;
1140 void js_set_lang();
1141
1142 set_current_js(server);
1143 if(!(env=(struct wnn_env_int *)malloc(sizeof(struct wnn_env_int)))){
1144 js_wnn_errorno_set=WNN_ALLOC_FAIL;
1145 return NULL;
1146 }
1147 LockMutex(&(server_js_lock));
1148 handler_of_jserver_dead(server);
1149 if(js_wnn_errorno_eql) {
1150 UnlockMutex(&(server_js_lock));
1151 free(env);
1152 return(NULL);
1153 }
1154 snd_head(JS_CONNECT, server);
1155 putscom(env_name, server);
1156 snd_flush(server);
1157 e_id=get4com(server);
1158 if(e_id==-1){ js_wnn_errorno_set= get4com(server); free(env); return NULL; }
1159 UnlockMutex(&(server_js_lock));
1160 env->orig.env_id = e_id;
1161 env->orig.js_id = (WNN_JSERVER_ID *)server;
1162 env->orig.muhenkan_mode = WNN_DIC_RDONLY;
1163 env->orig.bunsetsugiri_mode = WNN_DIC_RDONLY;
1164 env->orig.kutouten_mode = 1;
1165 env->orig.kakko_mode = 1;
1166 env->orig.kigou_mode = 1;
1167 strncpy(env->orig.lang, lang, sizeof(env->orig.lang) - 1); /* set language name */
1168 env->orig.lang[sizeof(env->orig.lang) - 1] = 0;
1169 env->orig.autotune = 0;
1170 /* �ؽ�����ư�����֤γ�����������ʥǥե���� 50 ���*/
1171 env->orig.autosave = 50;
1172 return (struct wnn_env *)env;
1173 }
1174
1175
1176 /* get language value from env */
1177 char *
js_get_lang(env)1178 js_get_lang(env)
1179 struct wnn_env *env;
1180 {
1181 return(env->lang);
1182 }
1183
1184 int
js_env_exist(server,env_name)1185 js_env_exist(server,env_name)
1186 register char *env_name;
1187 register WNN_JSERVER_ID *server;
1188 {
1189 int x;
1190
1191 set_current_js(server);
1192 LockMutex(&(server_js_lock));
1193 handler_of_jserver_dead(server);
1194 if(js_wnn_errorno_eql) {
1195 UnlockMutex(&(server_js_lock));
1196 return(-1);
1197 }
1198 snd_head(JS_ENV_EXIST, server);
1199 putscom(env_name, server);
1200 snd_flush(server);
1201 x =get4com(server);
1202 UnlockMutex(&(server_js_lock));
1203 return x;
1204 }
1205
1206 int
js_env_sticky(env)1207 js_env_sticky(env)
1208 register struct wnn_env *env;
1209 {
1210 int x;
1211
1212 if(env==0) return(-1);
1213 set_current_js(env->js_id);
1214 LockMutex(&(env_js_lock));
1215 handler_of_jserver_dead_env(env);
1216 if(env_wnn_errorno_eql) {
1217 UnlockMutex(&(env_js_lock));
1218 return(-1);
1219 }
1220 snd_env_head(env,JS_ENV_STICKY);
1221 snd_flush(env->js_id);
1222 x = get4com(env->js_id);
1223 UnlockMutex(&(env_js_lock));
1224 return x;
1225 }
1226
1227 int
js_env_un_sticky(env)1228 js_env_un_sticky(env)
1229 register struct wnn_env *env;
1230 {
1231 int x;
1232
1233 if(env==0) return(-1);
1234 set_current_js(env->js_id);
1235 LockMutex(&(env_js_lock));
1236 handler_of_jserver_dead_env(env);
1237 if(env_wnn_errorno_eql) {
1238 UnlockMutex(&(env_js_lock));
1239 return(-1);
1240 }
1241 snd_env_head(env,JS_ENV_UN_STICKY);
1242 snd_flush(env->js_id);
1243 x = get4com(env->js_id);
1244 UnlockMutex(&(env_js_lock));
1245 return x;
1246 }
1247
1248 /**
1249 env �Ǽ������Ķ���̵������
1250 **/
1251 int
js_disconnect(env)1252 js_disconnect(env)
1253 register struct wnn_env *env;
1254 {register int x;
1255 if(env==0) return(-1);
1256 /* ����ϡ�free ���ʤ��㤢����Τ����ɡ����������������ʤ�����
1257 �ޤ���8�Х��Ȥ����顢���ߤ��Ĥ뤱�ɤ���������
1258 free((char *)env);
1259 */
1260 set_current_js(env->js_id);
1261 LockMutex(&(env_js_lock));
1262 handler_of_jserver_dead_env(env);
1263 if(env_wnn_errorno_eql) {
1264 UnlockMutex(&(env_js_lock));
1265 return(-1);
1266 }
1267 snd_env_head(env,JS_DISCONNECT);
1268 snd_flush(env->js_id);
1269 x=get4com(env->js_id);
1270 if(x==-1){ env_wnn_errorno_set= get4com(env->js_id); }
1271 UnlockMutex(&(env_js_lock));
1272 return x;
1273 }
1274
1275 /** �����Фȥ��ͥ��Ȥ��Ƥ��뤫 **/
1276 int
js_isconnect(env)1277 js_isconnect(env)
1278 struct wnn_env *env;
1279 {
1280 if (env && env->js_id)
1281 return(env->js_id->js_dead);
1282 return(-1);
1283 }
1284
1285 /**
1286 env �� �Ķ� �Ȥ��̿��Хåե��� flush ���롣
1287 **/
1288 void
js_flush(env)1289 js_flush(env)
1290 struct wnn_env *env;
1291 {
1292 }
1293
1294
1295
1296 /* Parameter set/get */
1297 /** �Ѵ� parameter �����ꤹ�롣 **/
1298 /** js_param_set **/
1299 int
js_param_set(env,para)1300 js_param_set(env,para)
1301 struct wnn_env *env;
1302 register struct wnn_param *para;
1303 {register int x;
1304 if(env==0) return(-1);
1305 set_current_js(env->js_id);
1306 LockMutex(&(env_js_lock));
1307 handler_of_jserver_dead_env(env);
1308 if(env_wnn_errorno_eql) {
1309 UnlockMutex(&(env_js_lock));
1310 return(-1);
1311 }
1312 snd_env_head(env,JS_PARAM_SET);
1313 put4com(para->n, env->js_id); /* ��(��)ʸ����ϤΣ� */
1314 put4com(para->nsho, env->js_id); /* ��ʸ����ξ�ʸ��κ���� */
1315 put4com(para->p1, env->js_id); /* ��������٤Υѥ��� */
1316 put4com(para->p2, env->js_id); /* ��ʸ��Ĺ�Υѥ��� */
1317 put4com(para->p3, env->js_id); /* ����Ĺ�Υѥ��� */
1318 put4com(para->p4, env->js_id); /* ���Ȥä���ӥåȤΥѥ��� */
1319 put4com(para->p5, env->js_id); /* ����Υѥ��� */
1320 put4com(para->p6, env->js_id); /* ��ʸ���ɾ���ͤΥѥ��� */
1321 put4com(para->p7, env->js_id); /* ��ʸ��Ĺ�Υѥ��� */
1322 put4com(para->p8, env->js_id); /* ��ʸ����Υѥ��� */
1323
1324 put4com(para->p9, env->js_id); /* �����ʻ� ���������� */
1325 put4com(para->p10, env->js_id); /* �����ʻ� ���ʤ����� *//* CWNN �ѿ������� */
1326 put4com(para->p11, env->js_id); /* �����ʻ� �ѿ������� *//* CWNN ��������� */
1327 put4com(para->p12, env->js_id); /* �����ʻ� ��������� *//* CWNN ����̤����� */
1328 put4com(para->p13, env->js_id); /* �����ʻ� �ij�̤����� *//* CWNN �ij�̤����� */
1329 put4com(para->p14, env->js_id); /* �����ʻ� ��°������� *//* BWNN No of koho */
1330 put4com(para->p15, env->js_id); /* �����ʻ� ����̤����� *//* CWNN Not used */
1331
1332 snd_flush(env->js_id);
1333 x=get4com(env->js_id);
1334 if(x==-1){ env_wnn_errorno_set= get4com(env->js_id);
1335 UnlockMutex(&(env_js_lock)); return -1; }
1336 UnlockMutex(&(env_js_lock));
1337 return 0;
1338 }
1339
1340 extern int js_get_autolearning_mode_core();
1341
1342 #define WNN_ENV_LOCAL_MASK \
1343 (WNN_ENV_KUTOUTEN_MASK|WNN_ENV_KAKKO_MASK|WNN_ENV_KIGOU_MASK)
1344
1345 /*:::DOC_START
1346 *
1347 * Function Name: js_set_henkan_env
1348 * Description : ����������Ѵ��Ķ������ꤹ��
1349 * Parameter :
1350 * env : (In) �Ķ��ؤΥݥ���
1351 * valuemask : (In) ͭ�������ͥӥåȥޥ���
1352 * henv : (In) �Ѵ��Ķ��ι�¤�ΤؤΥݥ���
1353 *
1354 * Return value : 0==SUCCESS, -1==ERROR
1355 *
1356 * Author : Hideyuki Kishiba
1357 *
1358 * Revision history:
1359 *
1360 *:::DOC_END
1361 */
1362 int
js_set_henkan_env(env,valuemask,henv)1363 js_set_henkan_env(env,valuemask,henv)
1364 struct wnn_env *env;
1365 unsigned long valuemask;
1366 register struct wnn_henkan_env *henv;
1367 {
1368 register int x;
1369
1370 if(env==0) return(-1);
1371 set_current_js(env->js_id);
1372 LockMutex(&(env_js_lock));
1373 handler_of_jserver_dead_env(env);
1374 if(env_wnn_errorno_eql) {
1375 UnlockMutex(&(env_js_lock));
1376 return(-1);
1377 }
1378 if (valuemask & WNN_ENV_LOCAL_MASK){
1379 if (valuemask & WNN_ENV_KUTOUTEN_MASK)
1380 env->kutouten_mode = henv->kutouten_flag;
1381 if (valuemask & WNN_ENV_KAKKO_MASK)
1382 env->kakko_mode = henv->kakko_flag;
1383 if (valuemask & WNN_ENV_KIGOU_MASK)
1384 env->kigou_mode = henv->kigou_flag;
1385 }
1386 if (!(valuemask & ~WNN_ENV_LOCAL_MASK)) {
1387 UnlockMutex(&(env_js_lock));
1388 return 0;
1389 }
1390 snd_env_head(env,JS_SET_HENKAN_ENV);
1391 put4com(valuemask, env->js_id); /* ����ӥåȥޥ��� */
1392 put4com(henv->last_is_first_flag, env->js_id); /* �ǽ����Ѻ�ͥ�� */
1393 put4com(henv->complex_flag, env->js_id); /* ʣ���ͥ�� */
1394 put4com(henv->okuri_learn_flag, env->js_id); /* ������ؽ� */
1395 put4com(henv->okuri_flag, env->js_id); /* ��������� */
1396 put4com(henv->prefix_learn_flag, env->js_id); /* ��Ƭ��ؽ� */
1397 put4com(henv->prefix_flag, env->js_id); /* ��Ƭ����� */
1398 put4com(henv->suffix_learn_flag, env->js_id); /* ������ؽ� */
1399 put4com(henv->common_learn_flag, env->js_id); /* ���Ѹ�ؽ� */
1400 put4com(henv->freq_func_flag, env->js_id); /* ���پ徺��Ψ�ؿ� */
1401 put4com(henv->numeric_flag, env->js_id); /* ���������ν��ɽ����ˡ */
1402 put4com(henv->alphabet_flag, env->js_id); /* ��������ե��٥åȤν��ɽ����ˡ */
1403 put4com(henv->symbol_flag, env->js_id); /* ��������ν��ɽ����ˡ */
1404 put4com(henv->yuragi_flag, env->js_id); /* Ĺ������餮���� */
1405 put4com(henv->rendaku_flag, env->js_id); /* Ϣ������ */
1406 put4com(henv->bunsetsugiri_flag, env->js_id); /* ʸ���ڤ�ؽ��⡼�� */
1407 put4com(henv->muhenkan_flag, env->js_id); /* ̵�Ѵ��ؽ��⡼�� */
1408 put4com(henv->fi_relation_learn_flag, env->js_id); /* �ƣɴط��ؽ��⡼�� */
1409 put4com(henv->fi_freq_func_flag, env->js_id); /* �ƣɴط����پ徺��Ψ�ؿ� */
1410
1411 snd_flush(env->js_id);
1412 x=get4com(env->js_id);
1413 if(x==-1){
1414 env_wnn_errorno_set= get4com(env->js_id);
1415 UnlockMutex(&(env_js_lock));
1416 return -1;
1417 }
1418 if (valuemask & WNN_ENV_BUNSETSUGIRI_LEARN_MASK)
1419 env->bunsetsugiri_mode = henv->bunsetsugiri_flag;
1420 if (valuemask & WNN_ENV_MUHENKAN_LEARN_MASK)
1421 env->muhenkan_mode = henv->muhenkan_flag;
1422 UnlockMutex(&(env_js_lock));
1423 return 0;
1424 } /* End of js_set_henkan_env */
1425
1426 /*:::DOC_START
1427 *
1428 * Function Name: js_set_henkan_hinsi
1429 * Description : �Ѵ��ˡʻ��ѡ��Ի��ѡˤ����ʻ췲�����ꤹ��
1430 * Parameter :
1431 * env : (In) �Ķ��ؤΥݥ���
1432 * mode : (In) ����⡼�ɡ�0 == ��������, else ���������
1433 * nhinsi : (In) �����ʻ������ == �Ի���, �� ���ѡ�
1434 * hlist : (In) �����ʻ�ꥹ�ȤؤΥݥ���
1435 *
1436 * Return value : 0==SUCCESS, -1==ERROR
1437 *
1438 * Author : Hideyuki Kishiba
1439 *
1440 * Revision history:
1441 *
1442 *:::DOC_END
1443 */
1444 int
js_set_henkan_hinsi(env,mode,nhinsi,hlist)1445 js_set_henkan_hinsi(env,mode,nhinsi,hlist)
1446 struct wnn_env *env;
1447 int mode, nhinsi, *hlist;
1448 {
1449 register int x;
1450 if(env==0) return(-1);
1451 set_current_js(env->js_id);
1452 LockMutex(&(env_js_lock));
1453 handler_of_jserver_dead_env(env);
1454 if(env_wnn_errorno_eql) {
1455 UnlockMutex(&(env_js_lock));
1456 return(-1);
1457 }
1458 snd_env_head(env,JS_SET_HENKAN_HINSI);
1459 put4com(mode, env->js_id);
1460 put4com(nhinsi, env->js_id);
1461 for(x = 0; x < abs(nhinsi); x++) put4com(hlist[x], env->js_id);
1462 snd_flush(env->js_id);
1463 x=get4com(env->js_id);
1464 if(x==-1){ env_wnn_errorno_set= get4com(env->js_id);
1465 UnlockMutex(&(env_js_lock)); return -1; }
1466 UnlockMutex(&(env_js_lock));
1467 return 0;
1468 }
1469
1470 /** js_param_get **/
1471 /** env �Ǽ������Ķ����Ѵ� parameter ����Ф��� **/
1472 int
js_param_get(env,para)1473 js_param_get(env,para)
1474 struct wnn_env *env;
1475 register struct wnn_param *para;
1476 {
1477 if(env==0) return(-1);
1478 set_current_js(env->js_id);
1479 LockMutex(&(env_js_lock));
1480 handler_of_jserver_dead_env(env);
1481 if(env_wnn_errorno_eql) {
1482 UnlockMutex(&(env_js_lock));
1483 return(-1);
1484 }
1485 snd_env_head(env,JS_PARAM_GET);
1486 snd_flush(env->js_id);
1487 if(get4com(env->js_id) == -1){
1488 env_wnn_errorno_set= get4com(env->js_id);
1489 UnlockMutex(&(env_js_lock)); return -1;
1490 }
1491 para->n=get4com(env->js_id); /* ��(��)ʸ����ϤΣ� */
1492 para->nsho=get4com(env->js_id); /* ��ʸ����ξ�ʸ��κ���� */
1493 para->p1=get4com(env->js_id); /* ��������٤Υѥ��� */
1494 para->p2=get4com(env->js_id); /* ��ʸ��Ĺ�Υѥ��� */
1495 para->p3=get4com(env->js_id); /* ����Ĺ�Υѥ��� */
1496 para->p4=get4com(env->js_id); /* ���Ȥä���ӥåȤΥѥ��� */
1497 para->p5=get4com(env->js_id); /* ����Υѥ��� */
1498 para->p6=get4com(env->js_id); /* ��ʸ���ɾ���ͤΥѥ��� */
1499 para->p7=get4com(env->js_id); /* ��ʸ��Ĺ�Υѥ��� */
1500 para->p8=get4com(env->js_id); /* ��ʸ����Υѥ��� */
1501 para->p9=get4com(env->js_id); /* �����ʻ� ���������� */
1502 para->p10=get4com(env->js_id); /* �����ʻ� ���ʤ����� */
1503 para->p11=get4com(env->js_id); /* �����ʻ� �ѿ������� */
1504 para->p12=get4com(env->js_id); /* �����ʻ� ��������� */
1505 para->p13=get4com(env->js_id); /* �����ʻ� �ij�̤����� */
1506 para->p14=get4com(env->js_id); /* �����ʻ� ��°������� */
1507 para->p15=get4com(env->js_id); /* �����ʻ� ����̤����� */
1508 UnlockMutex(&(env_js_lock));
1509 return 0;
1510 }
1511
1512 /*:::DOC_START
1513 *
1514 * Function Name: js_get_henkan_env
1515 * Description : ����������Ѵ��Ķ�������
1516 * Parameter :
1517 * env : (In) �Ķ��ؤΥݥ���
1518 * henv : (Out) �Ѵ��Ķ��ι�¤�ΤؤΥݥ���
1519 *
1520 * Return value : 0==SUCCESS, -1==ERROR
1521 *
1522 * Author : Hideyuki Kishiba
1523 *
1524 * Revision history:
1525 *
1526 *:::DOC_END
1527 */
1528 int
js_get_henkan_env(env,henv)1529 js_get_henkan_env(env,henv)
1530 struct wnn_env *env;
1531 register struct wnn_henkan_env *henv;
1532 {
1533 if(env==0) return(-1);
1534 set_current_js(env->js_id);
1535 LockMutex(&(env_js_lock));
1536 handler_of_jserver_dead_env(env);
1537 if(env_wnn_errorno_eql) {
1538 UnlockMutex(&(env_js_lock));
1539 return(-1);
1540 }
1541 snd_env_head(env,JS_GET_HENKAN_ENV);
1542 snd_flush(env->js_id);
1543 if(get4com(env->js_id) == -1){
1544 env_wnn_errorno_set= get4com(env->js_id);
1545 UnlockMutex(&(env_js_lock)); return -1;
1546 }
1547 henv->last_is_first_flag=get4com(env->js_id); /* �ǽ����Ѻ�ͥ�� */
1548 henv->complex_flag=get4com(env->js_id); /* ʣ���ͥ�� */
1549 henv->okuri_learn_flag=get4com(env->js_id); /* ������ؽ� */
1550 henv->okuri_flag=get4com(env->js_id); /* ��������� */
1551 henv->prefix_learn_flag=get4com(env->js_id); /* ��Ƭ��ؽ� */
1552 henv->prefix_flag=get4com(env->js_id); /* ��Ƭ����� */
1553 henv->suffix_learn_flag=get4com(env->js_id); /* ������ؽ� */
1554 henv->common_learn_flag=get4com(env->js_id); /* ���Ѹ�ؽ� */
1555 henv->freq_func_flag=get4com(env->js_id); /* ���پ徺��Ψ�ؿ� */
1556 henv->numeric_flag=get4com(env->js_id); /* ���������ν��ɽ����ˡ */
1557 henv->alphabet_flag=get4com(env->js_id); /* ��������ե��٥åȤν��ɽ����ˡ */
1558 henv->symbol_flag=get4com(env->js_id); /* ��������ν��ɽ����ˡ */
1559 henv->yuragi_flag=get4com(env->js_id); /* Ĺ������餮���� */
1560 henv->rendaku_flag=get4com(env->js_id); /* Ϣ������ */
1561 henv->bunsetsugiri_flag=get4com(env->js_id); /* ʸ���ڤ�ؽ��⡼�� */
1562 henv->muhenkan_flag=get4com(env->js_id); /* ̵�Ѵ��ؽ��⡼�� */
1563 henv->fi_relation_learn_flag=get4com(env->js_id); /* �ƣɴط��ؽ��⡼�� */
1564 henv->fi_freq_func_flag=get4com(env->js_id); /* �ƣɴط����پ徺��Ψ�ؿ� */
1565
1566 env->bunsetsugiri_mode = henv->bunsetsugiri_flag;
1567 env->muhenkan_mode = henv->muhenkan_flag;
1568
1569 henv->kutouten_flag = env->kutouten_mode; /* ������ */
1570 henv->kakko_flag = env->kakko_mode; /* ��� */
1571 henv->kigou_flag = env->kigou_mode; /* ���� */
1572
1573 UnlockMutex(&(env_js_lock));
1574 return 0;
1575 } /* End of js_get_henkan_env */
1576
1577 /*:::DOC_START
1578 *
1579 * Function Name: js_get_henkan_env_local
1580 * Description : �Ѵ��δĶ����⡤�饤�֥��ˤ����Τ���
1581 * ����������̡�����
1582 * Parameter :
1583 * env : (In) �Ķ��ؤΥݥ���
1584 * henv : (In) �Ѵ��Ķ��ι�¤�ΤؤΥݥ���
1585 *
1586 * Return value : 0==SUCCESS, -1==ERROR
1587 *
1588 * Author : Seiji KUWARI
1589 *
1590 * Revision history:
1591 *
1592 *:::DOC_END
1593 */
1594 int
js_get_henkan_env_local(env,henv)1595 js_get_henkan_env_local(env,henv)
1596 struct wnn_env *env;
1597 register struct wnn_henkan_env *henv;
1598 {
1599 if(env==0) return(-1);
1600 LockMutex(&(env_js_lock));
1601 if(env_wnn_errorno_eql) {
1602 UnlockMutex(&(env_js_lock));
1603 return(-1);
1604 }
1605 henv->kutouten_flag = env->kutouten_mode; /* ������ */
1606 henv->kakko_flag = env->kakko_mode; /* ��� */
1607 henv->kigou_flag = env->kigou_mode; /* ���� */
1608
1609 UnlockMutex(&(env_js_lock));
1610 return 0;
1611 }
1612
1613 /*:::DOC_START
1614 *
1615 * Function Name: js_get_henkan_hinsi
1616 * Description : �Ѵ��ˡʻ��ѡ��Ի��ѡˤ����ʻ췲������
1617 * Parameter :
1618 * env : (In) �Ķ��ؤΥݥ���
1619 * nhinsi : (Out) �����ʻ������ == �Ի���, �� ���ѡ�
1620 * hlist : (Out) �����ʻ�ꥹ�ȤؤΥݥ���
1621 *
1622 * Return value : 0==SUCCESS, -1==ERROR
1623 *
1624 * Author : Hideyuki Kishiba
1625 *
1626 * Revision history:
1627 *
1628 *:::DOC_END
1629 */
1630 int
js_get_henkan_hinsi(env,nhinsi,hlist)1631 js_get_henkan_hinsi(env,nhinsi,hlist)
1632 struct wnn_env *env;
1633 int *nhinsi, **hlist;
1634 {
1635 int i;
1636 if(env==0) return(-1);
1637 set_current_js(env->js_id);
1638 LockMutex(&(env_js_lock));
1639 handler_of_jserver_dead_env(env);
1640 if(env_wnn_errorno_eql) {
1641 UnlockMutex(&(env_js_lock));
1642 return(-1);
1643 }
1644 snd_env_head(env,JS_GET_HENKAN_HINSI);
1645 snd_flush(env->js_id);
1646 if(get4com(env->js_id) == -1){
1647 env_wnn_errorno_set= get4com(env->js_id);
1648 UnlockMutex(&(env_js_lock)); return -1;
1649 }
1650 *nhinsi = get4com(env->js_id);
1651 if(((*hlist) = (int *)malloc(abs(*nhinsi) * sizeof(int))) == NULL) {
1652 int dummy;
1653 for(i = 0; i < abs(*nhinsi); i++) dummy = get4com(env->js_id);
1654 env_wnn_errorno_set = WNN_ALLOC_FAIL;
1655 UnlockMutex(&(env_js_lock)); return -1;
1656 }
1657 for(i = 0; i < abs(*nhinsi); i++) (*hlist)[i] = get4com(env->js_id);
1658 UnlockMutex(&(env_js_lock));
1659 return 0;
1660 } /* End of js_get_henkan_hinsi */
1661
1662 /*
1663 global File Operation
1664 */
1665 /** js_mkdir **/
1666 int
js_mkdir(env,path)1667 js_mkdir(env,path)
1668 struct wnn_env *env;
1669 char *path;
1670 {register int x;
1671 if(env==0) return(-1);
1672 set_current_js(env->js_id);
1673 LockMutex(&(env_js_lock));
1674 handler_of_jserver_dead_env(env);
1675 if(env_wnn_errorno_eql) {
1676 UnlockMutex(&(env_js_lock));
1677 return(-1);
1678 }
1679 snd_env_head(env,JS_MKDIR);
1680 putscom(path, env->js_id);
1681 snd_flush(env->js_id);
1682 x=get4com(env->js_id);
1683 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
1684 UnlockMutex(&(env_js_lock));
1685 return x;
1686 }
1687
1688 /** js_access **/
1689 int
js_access(env,path,amode)1690 js_access(env,path,amode)
1691 struct wnn_env *env;
1692 char *path;
1693 int amode;
1694 {register int x;
1695 if(env==0) return(-1);
1696 set_current_js(env->js_id);
1697 LockMutex(&(env_js_lock));
1698 handler_of_jserver_dead_env(env);
1699 if(env_wnn_errorno_eql) {
1700 UnlockMutex(&(env_js_lock));
1701 return(-1);
1702 }
1703 snd_env_head(env,JS_ACCESS);
1704 put4com(amode, env->js_id);
1705 putscom(path, env->js_id);
1706 snd_flush(env->js_id);
1707 x=get4com(env->js_id);
1708 UnlockMutex(&(env_js_lock));
1709 return x;
1710 }
1711
1712 /** js_file_list_all **/
1713 static int rcv_file_list();
1714
1715 int
js_file_list_all(server,ret)1716 js_file_list_all(server,ret)
1717 WNN_JSERVER_ID *server;
1718 struct wnn_ret_buf *ret;
1719 {
1720 int x;
1721
1722 set_current_js(server);
1723 LockMutex(&(server_js_lock));
1724 handler_of_jserver_dead(server);
1725 if(js_wnn_errorno_eql) {
1726 UnlockMutex(&(server_js_lock));
1727 return(-1);
1728 }
1729 snd_server_head(server,JS_FILE_LIST_ALL);
1730 snd_flush(server);
1731 x = rcv_file_list(ret, server);
1732 UnlockMutex(&(server_js_lock));
1733 return x;
1734 }
1735
1736 /** js_file_list **/
1737 int
js_file_list(env,ret)1738 js_file_list(env,ret)
1739 struct wnn_env *env;
1740 struct wnn_ret_buf *ret;
1741 {
1742 int x;
1743
1744 if(env==0) return(-1);
1745 set_current_js(env->js_id);
1746 LockMutex(&(env_js_lock));
1747 handler_of_jserver_dead_env(env);
1748 if(env_wnn_errorno_eql) {
1749 UnlockMutex(&(env_js_lock));
1750 return(-1);
1751 }
1752 snd_env_head(env,JS_FILE_LIST);
1753 snd_flush(env->js_id);
1754 x = rcv_file_list(ret, env->js_id);
1755 UnlockMutex(&(env_js_lock));
1756 return x;
1757 }
1758
1759 static void re_alloc();
1760
1761 static int
rcv_file_list(ret,server)1762 rcv_file_list(ret, server)
1763 struct wnn_ret_buf *ret;
1764 ARGS *server;
1765 {register int i,count;
1766 WNN_FILE_INFO_STRUCT *files;
1767 count=get4com(server);
1768 re_alloc(ret,sizeof(WNN_FILE_INFO_STRUCT)*count);
1769 files=(WNN_FILE_INFO_STRUCT *)ret->buf;
1770 for(i=0;i<count;i++){
1771 files->fid= get4com(server);
1772 files->localf= get4com(server);
1773 files->ref_count= get4com(server);
1774 files->type= get4com(server);
1775 getscom(files->name, server, WNN_F_NAMELEN);
1776 files++;
1777 }
1778 return count;
1779 }
1780
1781 /** js_file_stat **/
1782 int
js_file_stat(env,path,s)1783 js_file_stat(env,path, s)
1784 struct wnn_env *env;
1785 char *path;
1786 WNN_FILE_STAT *s;
1787 {register int x;
1788 if(env==0) return(-1);
1789 set_current_js(env->js_id);
1790 LockMutex(&(env_js_lock));
1791 handler_of_jserver_dead_env(env);
1792 if(env_wnn_errorno_eql) {
1793 UnlockMutex(&(env_js_lock));
1794 return(-1);
1795 }
1796 snd_env_head(env,JS_FILE_STAT);
1797 putscom(path, env->js_id);
1798 snd_flush(env->js_id);
1799 x=get4com(env->js_id);
1800 UnlockMutex(&(env_js_lock));
1801 s->type = x;
1802 return x;
1803 }
1804
1805
1806 /** js_file_info **/
1807 int
js_file_info(env,fid,file)1808 js_file_info(env,fid,file)
1809 struct wnn_env *env;
1810 int fid;
1811 register WNN_FILE_INFO_STRUCT *file;
1812 {register int x;
1813 if(env==0) return(-1);
1814 set_current_js(env->js_id);
1815 LockMutex(&(env_js_lock));
1816 handler_of_jserver_dead_env(env);
1817 if(env_wnn_errorno_eql) {
1818 UnlockMutex(&(env_js_lock));
1819 return(-1);
1820 }
1821 snd_env_head(env,JS_FILE_INFO);
1822 put4com(fid, env->js_id);
1823 snd_flush(env->js_id);
1824 file->fid= fid;
1825 x=get4com(env->js_id);
1826 if(x==-1){
1827 env_wnn_errorno_set= get4com(env->js_id);
1828 UnlockMutex(&(env_js_lock));
1829 return(-1);
1830 }
1831 getscom(file->name, env->js_id, WNN_F_NAMELEN);
1832 file->localf= get4com(env->js_id);
1833 file->ref_count= get4com(env->js_id);
1834 file->type= get4com(env->js_id);
1835 UnlockMutex(&(env_js_lock));
1836 return 0;
1837 }
1838
1839 /** js_file_loaded **/
1840 int
js_file_loaded(server,path)1841 js_file_loaded(server,path)
1842 WNN_JSERVER_ID *server;
1843 char *path;
1844 {register int x;
1845 set_current_js(server);
1846 LockMutex(&(server_js_lock));
1847 handler_of_jserver_dead(server);
1848 if(js_wnn_errorno_eql) {
1849 UnlockMutex(&(server_js_lock));
1850 return(-1);
1851 }
1852 snd_server_head(server,JS_FILE_LOADED);
1853 putscom(path, server);
1854 snd_flush(server);
1855 x=get4com(server);
1856 UnlockMutex(&(server_js_lock));
1857 return x;
1858 }
1859
1860 /** js_file_loaded_local **/
1861 static int check_local_file();
1862 static int file_loaded_local();
1863
1864 static int
js_file_loaded_local_body(server,path)1865 js_file_loaded_local_body(server,path)
1866 WNN_JSERVER_ID *server;
1867 char *path;
1868 {int x;
1869
1870 handler_of_jserver_dead(server);
1871 if(js_wnn_errorno_eql) {
1872 return(-1);
1873 }
1874 if(check_local_file(path, server) == -1) return (-1);
1875 snd_server_head(server, JS_FILE_LOADED_LOCAL);
1876 x=file_loaded_local(path, server);
1877 return x;
1878 }
1879
1880 int
js_file_loaded_local(server,path)1881 js_file_loaded_local(server,path)
1882 WNN_JSERVER_ID *server;
1883 char *path;
1884 {
1885 int x;
1886 set_current_js(server);
1887 LockMutex(&(server_js_lock));
1888 x = js_file_loaded_local_body(server,path);
1889 UnlockMutex(&(server_js_lock));
1890 return x;
1891 }
1892
1893 static int
check_local_file(path,server)1894 check_local_file(path, server)
1895 char *path;
1896 ARGS *server;
1897 {
1898 register FILE *f;
1899 register int x;
1900 struct wnn_file_head fh;
1901 int is_compressed;
1902
1903 #ifdef WRITE_CHECK
1904 check_backup(path, NULL);
1905 #endif /* WRITE_CHECK */
1906 f=dic_fopen(path,"r", &is_compressed);
1907 if(f == NULL){
1908 js_wnn_errorno_set = WNN_OPENF_ERR;
1909 return -1;
1910 }
1911 x=input_file_header(f, &fh, NULL);
1912 if(x==-1){
1913 dic_fclose(f, is_compressed);
1914 js_wnn_errorno_set = WNN_NOT_A_FILE;
1915 return -1;
1916 }
1917 if(dic_check_inode(f, &fh, path, is_compressed) == -1){
1918 change_file_uniq(&fh, path, NULL);
1919 #ifdef WRITE_CHECK
1920 dic_fclose(f, is_compressed);
1921 f=dic_fopen(path,"r", &is_compressed);
1922 if(f == NULL){
1923 js_wnn_errorno_set = WNN_OPENF_ERR;
1924 return (-1);
1925 }
1926 #endif /* WRITE_CHECK */
1927 if(dic_check_inode(f, &fh, path, is_compressed) == -1){
1928 dic_fclose(f, is_compressed);
1929 js_wnn_errorno_set = WNN_INODE_CHECK_ERROR;
1930 return (-1);
1931 }
1932 }
1933 dic_fclose(f, is_compressed);
1934 return 0;
1935 }
1936
1937
1938 static int
file_loaded_local(path,server)1939 file_loaded_local(path, server)
1940 char *path;
1941 ARGS *server;
1942 {register int x,i;
1943 FILE *f;
1944 struct wnn_file_head fh;
1945 int is_compressed;
1946
1947 #ifdef WRITE_CHECK
1948 check_backup(path, NULL);
1949 #endif /* WRITE_CHECK */
1950 f=dic_fopen(path,"r", &is_compressed);
1951 if(f == NULL){
1952 js_wnn_errorno_set = WNN_OPENF_ERR;
1953 return -1;
1954 }
1955 x=input_file_header(f, &fh, NULL);
1956 if(x==-1){
1957 dic_fclose(f, is_compressed);
1958 js_wnn_errorno_set = WNN_NOT_A_FILE;
1959 return -1;
1960 }
1961 put4com(fh.file_uniq.time, server);
1962 put4com(fh.file_uniq.dev, server);
1963 put4com(fh.file_uniq.inode, server);
1964 for(i=0;i<WNN_HOSTLEN;i++){
1965 put1com(fh.file_uniq.createhost[i], server);
1966 }
1967
1968 snd_flush(server);
1969 x=get4com(server);
1970 dic_fclose(f, is_compressed);
1971 return x;
1972 }
1973
1974 /** js_hindo_file_create **/
1975 int
js_hindo_file_create(env,fid,fn,comment,hpasswd)1976 js_hindo_file_create(env,fid,fn,comment,hpasswd)
1977 struct wnn_env *env;
1978 int fid;
1979 char *fn;
1980 w_char *comment;
1981 char *hpasswd;
1982 {register int x;
1983 if(env==0) return(-1);
1984 set_current_js(env->js_id);
1985 LockMutex(&(env_js_lock));
1986 handler_of_jserver_dead_env(env);
1987 if(env_wnn_errorno_eql) {
1988 UnlockMutex(&(env_js_lock));
1989 return(-1);
1990 }
1991 snd_env_head(env,JS_HINDO_FILE_CREATE);
1992 put4com(fid, env->js_id);
1993 putscom(fn, env->js_id);
1994 putwscom(comment, env->js_id);
1995 putscom(hpasswd, env->js_id);
1996 snd_flush(env->js_id);
1997 x=get4com(env->js_id);
1998 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
1999 UnlockMutex(&(env_js_lock));
2000 return x;
2001 }
2002
2003 /*:::DOC_START
2004 *
2005 * Function Name: js_fi_hindo_file_create
2006 * Description : ������¦�ˣƣɴط����٥ե�������������
2007 * Parameter :
2008 * env : (In) �Ķ��ؤΥݥ���
2009 * fid : (In) �б��ƣɴط�����ե�����ɣ�
2010 * fn : (In) �ƣɴط����٥ե�����̾
2011 * comment : (In) �ƣɴط����٥ե����륳����
2012 * hpasswd : (In) �ƣɴط����٥ե�����ѥ����
2013 *
2014 * Return value : 0==SUCCESS, -1==ERROR
2015 *
2016 * Author : Hideyuki Kishiba
2017 *
2018 * Revision history:
2019 *
2020 *:::DOC_END
2021 */
2022 int
js_fi_hindo_file_create(env,fid,fn,comment,hpasswd)2023 js_fi_hindo_file_create(env, fid, fn, comment, hpasswd)
2024 struct wnn_env *env;
2025 int fid;
2026 char *fn;
2027 w_char *comment;
2028 char *hpasswd;
2029 {register int x;
2030 if(env==0) return(-1);
2031 set_current_js(env->js_id);
2032 LockMutex(&(env_js_lock));
2033 handler_of_jserver_dead_env(env);
2034 if(env_wnn_errorno_eql) {
2035 UnlockMutex(&(env_js_lock));
2036 return(-1);
2037 }
2038 snd_env_head(env,JS_FI_HINDO_FILE_CREATE);
2039 put4com(fid, env->js_id);
2040 putscom(fn, env->js_id);
2041 putwscom(comment, env->js_id);
2042 putscom(hpasswd, env->js_id);
2043 snd_flush(env->js_id);
2044 x=get4com(env->js_id);
2045 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2046 UnlockMutex(&(env_js_lock));
2047 return x;
2048 } /* End of js_fi_hindo_file_create */
2049
2050 /*:::DOC_START
2051 *
2052 * Function Name: js_dic_file_create
2053 * Description : ������¦�˼���ե�������������
2054 * Parameter :
2055 * env : (In) �Ķ��ؤΥݥ���
2056 * fn : (In) ��������ե�����̾
2057 * type : (In) ��������ե����륿����
2058 * comment : (In) ��������ե����륳����
2059 * passwd (In) ��������ե�����ѥ����
2060 * hpasswd : (In) �������������٥ѥ����
2061 *
2062 * Return value : 0==SUCCESS, -1==ERROR
2063 *
2064 * Author : Hideyuki Kishiba
2065 *
2066 * Revision history:
2067 *
2068 *:::DOC_END
2069 */
2070 int
js_dic_file_create(env,fn,type,comment,passwd,hpasswd)2071 js_dic_file_create(env, fn, type, comment, passwd, hpasswd)
2072 struct wnn_env *env;
2073 char *fn;
2074 w_char *comment;
2075 char *passwd, *hpasswd;
2076 int type;
2077 {register int x;
2078 if(env==0) return(-1);
2079 set_current_js(env->js_id);
2080 LockMutex(&(env_js_lock));
2081 handler_of_jserver_dead_env(env);
2082 if(env_wnn_errorno_eql) {
2083 UnlockMutex(&(env_js_lock));
2084 return(-1);
2085 }
2086 snd_env_head(env,JS_DIC_FILE_CREATE);
2087 putscom(fn, env->js_id);
2088 putwscom(comment, env->js_id);
2089 putscom(passwd, env->js_id);
2090 putscom(hpasswd, env->js_id);
2091 put4com(type, env->js_id);
2092 snd_flush(env->js_id);
2093 x=get4com(env->js_id);
2094 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2095 UnlockMutex(&(env_js_lock));
2096 return x;
2097 } /* End of js_dic_file_create */
2098
2099
2100 /** js_file_discard **/
2101 int
js_file_discard(env,fid)2102 js_file_discard(env,fid)
2103 struct wnn_env *env;
2104 int fid;
2105 {register int x;
2106 if(env==0) return(-1);
2107 set_current_js(env->js_id);
2108 LockMutex(&(env_js_lock));
2109 handler_of_jserver_dead_env(env);
2110 if(env_wnn_errorno_eql) {
2111 UnlockMutex(&(env_js_lock));
2112 return(-1);
2113 }
2114 snd_env_head(env,JS_FILE_DISCARD);
2115 put4com(fid, env->js_id);
2116 snd_flush(env->js_id);
2117 x=get4com(env->js_id);
2118 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2119 UnlockMutex(&(env_js_lock));
2120 return x;
2121 }
2122
2123 /** js_file_read **/
2124 int
js_file_read(env,fn)2125 js_file_read(env,fn)
2126 struct wnn_env *env;
2127 char *fn;
2128 {register int x;
2129 if(env==0) return(-1);
2130 set_current_js(env->js_id);
2131 LockMutex(&(env_js_lock));
2132 handler_of_jserver_dead_env(env);
2133 if(env_wnn_errorno_eql) {
2134 UnlockMutex(&(env_js_lock));
2135 return(-1);
2136 }
2137 snd_env_head(env,JS_FILE_READ);
2138 putscom(fn, env->js_id);
2139 snd_flush(env->js_id);
2140 x=get4com(env->js_id);
2141 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2142 UnlockMutex(&(env_js_lock));
2143 return x;
2144 }
2145
2146 /** js_file_write **/
2147 int
js_file_write(env,fid,fn)2148 js_file_write(env,fid,fn)
2149 struct wnn_env *env;
2150 int fid;
2151 char *fn;
2152 {register int x;
2153 if(env==0) return(-1);
2154 set_current_js(env->js_id);
2155 LockMutex(&(env_js_lock));
2156 handler_of_jserver_dead_env(env);
2157 if(env_wnn_errorno_eql) {
2158 UnlockMutex(&(env_js_lock));
2159 return(-1);
2160 }
2161 snd_env_head(env,JS_FILE_WRITE);
2162 put4com(fid, env->js_id);
2163 putscom(fn, env->js_id);
2164 snd_flush(env->js_id);
2165 x=get4com(env->js_id);
2166 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2167 UnlockMutex(&(env_js_lock));
2168 return x;
2169 }
2170
2171 /** js_file_receive **/
2172 static int xget1com();
2173 static void xput1com();
2174
2175 int
js_file_receive(env,fid,fn)2176 js_file_receive(env,fid,fn)
2177 struct wnn_env *env;
2178 int fid;
2179 char *fn;
2180 {register int mode, x;
2181 char file_name[1024];
2182 char buf[1024];
2183 FILE *f;
2184 int n;
2185 struct wnn_file_head fh;
2186 int i;
2187 #ifdef WRITE_CHECK
2188 char *tmp = NULL, *backup = NULL, tmp_x;
2189 int tmp_err = 0;
2190 #endif /* WRITE_CHECK */
2191 int is_compressed;
2192
2193 if(env==0) return(-1);
2194 set_current_js(env->js_id);
2195 LockMutex(&(env_js_lock));
2196 handler_of_jserver_dead_env(env);
2197 if(env_wnn_errorno_eql) {
2198 UnlockMutex(&(env_js_lock));
2199 return(-1);
2200 }
2201 snd_env_head(env,JS_FILE_RECEIVE);
2202 put4com(fid, env->js_id);
2203 snd_flush(env->js_id);
2204 /**/
2205 getscom(file_name, env->js_id, sizeof(file_name));
2206 if(fn ==NULL || strcmp(fn,"")==0){
2207 gethostname(buf, 1024);
2208 n = strlen(buf);
2209 buf[n] = C_LOCAL;
2210 buf[n+1] = 0;
2211 if(strncmp(buf, file_name, n + 1) == 0){
2212 fn = file_name + n + 1;
2213 }
2214 }
2215 #ifdef WRITE_CHECK
2216 check_backup(fn, NULL);
2217 #endif /* WRITE_CHECK */
2218 if((f = dic_fopen(fn, "r", &is_compressed)) == NULL){ /* New File */
2219 fh.file_uniq.time = fh.file_uniq.dev = fh.file_uniq.inode = 0;
2220 }else{ /* Old File Exists */
2221 if(input_file_header(f, &fh, NULL) == -1){
2222 env_wnn_errorno_set=WNN_NOT_A_FILE;
2223 dic_fclose(f, is_compressed);
2224 put4com(-1, env->js_id);snd_flush(env->js_id);
2225 UnlockMutex(&(env_js_lock));
2226 return(-1);
2227 }
2228 if( is_compressed ){
2229 env_wnn_errorno_set=NOT_SUPPORTED_OPERATION;
2230 dic_fclose(f, is_compressed);
2231 put4com(-1, env->js_id);snd_flush(env->js_id);
2232 UnlockMutex(&(env_js_lock));
2233 return(-1);
2234 }
2235 dic_fclose(f, is_compressed);
2236 }
2237 put4com(0, env->js_id); /* Ack */
2238 put4com(fh.file_uniq.time, env->js_id);
2239 put4com(fh.file_uniq.dev, env->js_id);
2240 put4com(fh.file_uniq.inode, env->js_id);
2241 for(i=0;i<WNN_HOSTLEN;i++){
2242 put1com(fh.file_uniq.createhost[i], env->js_id);
2243 }
2244
2245 snd_flush(env->js_id);
2246
2247 if((mode=get4com(env->js_id))==-1){ /* check stat */
2248 env_wnn_errorno_set= get4com(env->js_id);
2249 UnlockMutex(&(env_js_lock));
2250 return -1;
2251 }else if(mode==0){
2252 UnlockMutex(&(env_js_lock));
2253 return 0; /* need not saving */
2254 }else if(mode == 1 || mode == 3){ /* mode == 3 means the file is a new one. */
2255 #ifdef WRITE_CHECK
2256 backup = make_backup_file(fn, NULL);
2257 if ((tmp = make_tmp_file(fn, 0, &f, NULL)) == NULL) {
2258 delete_tmp_file(backup);
2259 #else /* WRITE_CHECK */
2260 if((f = fopen(fn, "w+")) == NULL){
2261 #endif /* WRITE_CHECK */
2262 env_wnn_errorno_set=WNN_FILE_WRITE_ERROR;
2263 put4com(-1, env->js_id);snd_flush(env->js_id);
2264 UnlockMutex(&(env_js_lock));
2265 return(-1);
2266 }
2267 }else if(mode == 2){
2268 #ifdef WRITE_CHECK
2269 backup = make_backup_file(fn, NULL);
2270 if ((tmp = make_tmp_file(fn, 1, &f, NULL)) == NULL) {
2271 delete_tmp_file(backup);
2272 #else /* WRITE_CHECK */
2273 if((f = fopen(fn, "r+")) == NULL){ /* New File */
2274 #endif /* WRITE_CHECK */
2275 env_wnn_errorno_set=WNN_FILE_WRITE_ERROR;
2276 put4com(-1, env->js_id);snd_flush(env->js_id);
2277 UnlockMutex(&(env_js_lock));
2278 return(-1);
2279 }
2280 }
2281 put4com(0, env->js_id); snd_flush(env->js_id); /* ACK */
2282 for(;;){
2283 if((x=xget1com(env->js_id))== -1) break; /* EOF */
2284 #ifdef WRITE_CHECK
2285 tmp_x = (char)x;
2286 if (fwrite(&tmp_x, sizeof(char), 1, f) == -1) tmp_err = 1;
2287 #else /* WRITE_CHECK */
2288 fputc(x,f);
2289 #endif /* WRITE_CHECK */
2290 }
2291 fclose(f);
2292 #ifdef WRITE_CHECK
2293 if (tmp_err == 0) {
2294 move_tmp_to_org(tmp, fn, 1);
2295 } else {
2296 delete_tmp_file(tmp);
2297 }
2298 delete_tmp_file(backup);
2299 #endif /* WRITE_CHECK */
2300
2301 x=get4com(env->js_id);
2302 if(x==-1) env_wnn_errorno_set= get4com(env->js_id);
2303 #ifdef WRITE_CHECK
2304 if (tmp_err) {
2305 env_wnn_errorno_set = WNN_FILE_WRITE_ERROR;
2306 UnlockMutex(&(env_js_lock));
2307 return(-1);
2308 }
2309 #endif /* WRITE_CHECK */
2310 UnlockMutex(&(env_js_lock));
2311 return x;
2312 }
2313
2314 static int
xget1com(server)2315 xget1com(server)
2316 ARGS *server;
2317 {register int x;
2318 if((x= get1com(server)) != 0xFF) return x;
2319 if(get1com(server) == 0xFF) return -1; /* EOF */
2320 return 0xFF;
2321 }
2322
2323 /** js_file_send **/
2324 int
js_file_send(env,fn)2325 js_file_send(env,fn)
2326 struct wnn_env *env;
2327 char *fn;
2328 {register int x;
2329 FILE *f;
2330 int n;
2331 char buf[1024],*b;
2332 register int cc,i;
2333 int is_compressed;
2334
2335 if(env==0) return(-1);
2336 set_current_js(env->js_id);
2337 LockMutex(&(env_js_lock));
2338 handler_of_jserver_dead_env(env);
2339 if(env_wnn_errorno_eql) {
2340 UnlockMutex(&(env_js_lock));
2341 return(-1);
2342 }
2343 if(check_local_file(fn, env->js_id) == -1) {
2344 UnlockMutex(&(env_js_lock));
2345 return (-1);
2346 }
2347 snd_env_head(env,JS_FILE_SEND);
2348 x=file_loaded_local(fn, env->js_id);
2349 if(x!= -1){ /* file is already loaded */
2350 if(get4com(env->js_id) == -1) {
2351 env_wnn_errorno_set= get4com(env->js_id);
2352 UnlockMutex(&(env_js_lock));
2353 return(-1);
2354 }
2355 return x;
2356 UnlockMutex(&(env_js_lock));
2357 }
2358
2359 x=get4com(env->js_id);
2360 if(x==-1){
2361 env_wnn_errorno_set= get4com(env->js_id);
2362 UnlockMutex(&(env_js_lock));
2363 return -1;
2364 }
2365
2366 gethostname(buf, 1024);
2367 n = strlen(buf);
2368 buf[n] = C_LOCAL;
2369 strcpy(buf + n + 1,fn);
2370 putscom(buf, env->js_id);
2371
2372 #ifdef WRITE_CHECK
2373 check_backup(fn, NULL);
2374 #endif /* WRITE_CHECK */
2375 if((f=dic_fopen(fn,"r", &is_compressed))== NULL){
2376 xput1com(-1, env->js_id); /* EOF */
2377 UnlockMutex(&(env_js_lock));
2378 return -1;
2379 }
2380
2381 /* send contents of file */
2382 for(;;){
2383 cc = fread(buf,1,1024,f);
2384 if(cc <= 0) break; /* EOF */
2385 for(b=buf,i=0;i<cc;i++){
2386 xput1com((int)*b++ & 0xff, env->js_id);
2387 }
2388 }
2389 dic_fclose(f, is_compressed);
2390 xput1com(-1, env->js_id); /* EOF */
2391 snd_flush(env->js_id);
2392 x=get4com(env->js_id);
2393 if(x==-1) env_wnn_errorno_set= get4com(env->js_id);
2394 UnlockMutex(&(env_js_lock));
2395 return x;
2396 }
2397
2398 static void
xput1com(d,server)2399 xput1com(d, server)
2400 int d;
2401 ARGS *server;
2402 {
2403 if(d == -1){ put1com(0xFF, server); put1com(0xFF, server); return;/* EOF */}
2404 put1com(d, server);
2405 if(d == 0xFF){ put1com(0x00, server);}
2406 }
2407
2408
2409 /*** Dic. Operation for Env. ***/
2410
2411 /** js_dic_add **/
2412 static int
js_dic_add_body(env,fid,hfid,rev,jnice,rw,hrw,pw1,pw2)2413 js_dic_add_body(env,fid,hfid,rev, jnice,rw,hrw, pw1, pw2)
2414 struct wnn_env *env;
2415 int fid,hfid,rev,jnice,rw,hrw;
2416 char *pw1, *pw2;
2417 {register int x;
2418 snd_env_head(env,JS_DIC_ADD);
2419 put4com(fid, env->js_id);
2420 put4com(hfid, env->js_id);
2421 put4com(jnice, env->js_id);
2422 put4com(rw, env->js_id);
2423 put4com(hrw, env->js_id);
2424 putscom(pw1, env->js_id);
2425 putscom(pw2, env->js_id);
2426 put4com(rev, env->js_id); /* rev is to add it as reverse dict */
2427 snd_flush(env->js_id);
2428 x=get4com(env->js_id);
2429 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2430 return x;
2431 }
2432 int
js_dic_add(env,fid,hfid,rev,jnice,rw,hrw,pw1,pw2)2433 js_dic_add(env,fid,hfid,rev, jnice,rw,hrw, pw1, pw2)
2434 struct wnn_env *env;
2435 int fid,hfid,rev,jnice,rw,hrw;
2436 char *pw1, *pw2;
2437 {register int x;
2438 if(env==0) return(-1);
2439 set_current_js(env->js_id);
2440 LockMutex(&(env_js_lock));
2441 handler_of_jserver_dead_env(env);
2442 if(env_wnn_errorno_eql) {
2443 UnlockMutex(&(env_js_lock));
2444 return(-1);
2445 }
2446 x = js_dic_add_body(env,fid,hfid,rev, jnice,rw,hrw, pw1, pw2);
2447 UnlockMutex(&(env_js_lock));
2448 return x;
2449 }
2450
2451 /*:::DOC_START
2452 *
2453 * Function Name: js_fi_dic_add_body
2454 * Description : js_fi_dic_add �Υ��֥롼����ؿ�
2455 * Parameter :
2456 * env : (In) �Ķ��ؤΥݥ���
2457 * fid : (In) �ƣɴط�����ե�����ɣ�
2458 * hfid : (In) �ƣɴط����٥ե�����ɣ�
2459 * suflag : (In) �����ƥ༭����桼������
2460 * rw : (In) ����������ǽ����Բ�ǽ
2461 * hrw : (In) ���ٹ�������ǽ����Բ�ǽ
2462 * pw1 : (In) �ƣɴط�����ե�����Υѥ����
2463 * pw2 : (In) �ƣɴط����٥ե�����Υѥ����
2464 *
2465 * Return value : -1==ERROR, else ��Ͽ�����ֹ�
2466 *
2467 * Author : Hideyuki Kishiba
2468 *
2469 * Revision history:
2470 *
2471 *:::DOC_END
2472 */
2473 static int
js_fi_dic_add_body(env,fid,hfid,suflag,rw,hrw,pw1,pw2)2474 js_fi_dic_add_body(env, fid, hfid, suflag, rw, hrw, pw1, pw2)
2475 struct wnn_env *env;
2476 int fid,hfid,suflag,rw,hrw;
2477 char *pw1, *pw2;
2478 {register int x;
2479 snd_env_head(env,JS_FI_DIC_ADD);
2480 put4com(fid, env->js_id);
2481 put4com(hfid, env->js_id);
2482 put4com(suflag, env->js_id);
2483 put4com(rw, env->js_id);
2484 put4com(hrw, env->js_id);
2485 putscom(pw1, env->js_id);
2486 putscom(pw2, env->js_id);
2487 snd_flush(env->js_id);
2488 x=get4com(env->js_id);
2489 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2490 return x;
2491 } /* End of js_fi_dic_add_body */
2492
2493 /*:::DOC_START
2494 *
2495 * Function Name: js_fi_dic_add
2496 * Description : �Ķ��ˣƣɼ�����ɲä���
2497 * Parameter :
2498 * env : (In) �Ķ��ؤΥݥ���
2499 * fid : (In) �ƣɴط�����ե�����ɣ�
2500 * hfid : (In) �ƣɴط����٥ե�����ɣ�
2501 * suflag : (In) �����ƥ༭����桼������
2502 * rw : (In) ����������ǽ����Բ�ǽ
2503 * hrw : (In) ���ٹ�������ǽ����Բ�ǽ
2504 * pw1 : (In) �ƣɴط�����ե�����Υѥ����
2505 * pw2 : (In) �ƣɴط����٥ե�����Υѥ����
2506 *
2507 * Return value : -1==ERROR, else ��Ͽ�����ֹ�
2508 *
2509 * Author : Hideyuki Kishiba
2510 *
2511 * Revision history:
2512 *
2513 *:::DOC_END
2514 */
2515 int
js_fi_dic_add(env,fid,hfid,suflag,rw,hrw,pw1,pw2)2516 js_fi_dic_add(env, fid, hfid, suflag, rw, hrw, pw1, pw2)
2517 struct wnn_env *env;
2518 int fid,hfid,suflag,rw,hrw;
2519 char *pw1, *pw2;
2520 {register int x;
2521 if(env==0) return(-1);
2522 set_current_js(env->js_id);
2523 LockMutex(&(env_js_lock));
2524 handler_of_jserver_dead_env(env);
2525 if(env_wnn_errorno_eql) {
2526 UnlockMutex(&(env_js_lock));
2527 return(-1);
2528 }
2529 /* call sub routine function */
2530 x = js_fi_dic_add_body(env, fid, hfid, suflag, rw, hrw, pw1, pw2);
2531 UnlockMutex(&(env_js_lock));
2532 return x;
2533 } /* End of js_fi_dic_add */
2534
2535 /** js_dic_delete **/
2536 int
js_dic_delete(env,dicno)2537 js_dic_delete(env,dicno)
2538 struct wnn_env *env;
2539 int dicno;
2540 {register int x;
2541 if(env==0) return(-1);
2542 set_current_js(env->js_id);
2543 LockMutex(&(env_js_lock));
2544 handler_of_jserver_dead_env(env);
2545 if(env_wnn_errorno_eql) {
2546 UnlockMutex(&(env_js_lock));
2547 return(-1);
2548 }
2549 snd_env_head(env,JS_DIC_DELETE);
2550 put4com(dicno, env->js_id);
2551 snd_flush(env->js_id);
2552 x=get4com(env->js_id);
2553 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2554 UnlockMutex(&(env_js_lock));
2555 return x;
2556 }
2557
2558 /** js_dic_use **/
2559 int
js_dic_use(env,dic_no,flag)2560 js_dic_use(env,dic_no,flag)
2561 struct wnn_env *env;
2562 int dic_no,flag;
2563 {register int x;
2564 if(env==0) return(-1);
2565 set_current_js(env->js_id);
2566 LockMutex(&(env_js_lock));
2567 handler_of_jserver_dead_env(env);
2568 if(env_wnn_errorno_eql) {
2569 UnlockMutex(&(env_js_lock));
2570 return(-1);
2571 }
2572 snd_env_head(env,JS_DIC_USE);
2573 put4com(dic_no, env->js_id);
2574 put4com(flag, env->js_id);
2575 snd_flush(env->js_id);
2576 x=get4com(env->js_id);
2577 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2578 UnlockMutex(&(env_js_lock));
2579 return x;
2580 }
2581
2582 /** js_fuzokugo_set **/
2583 int
js_fuzokugo_set(env,fid)2584 js_fuzokugo_set(env,fid)
2585 struct wnn_env *env;
2586 int fid;
2587 {register int x;
2588 if(env==0) return(-1);
2589 set_current_js(env->js_id);
2590 LockMutex(&(env_js_lock));
2591 handler_of_jserver_dead_env(env);
2592 if(env_wnn_errorno_eql) {
2593 UnlockMutex(&(env_js_lock));
2594 return(-1);
2595 }
2596 snd_env_head(env,JS_FUZOKUGO_SET);
2597 put4com(fid, env->js_id);
2598 snd_flush(env->js_id);
2599 x=get4com(env->js_id);
2600 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2601 UnlockMutex(&(env_js_lock));
2602 return x;
2603 }
2604
2605 /** js_fuzokugo_get **/
2606 int
js_fuzokugo_get(env)2607 js_fuzokugo_get(env)
2608 struct wnn_env *env;
2609 {register int x;
2610 if(env==0) return(-1);
2611 set_current_js(env->js_id);
2612 LockMutex(&(env_js_lock));
2613 handler_of_jserver_dead_env(env);
2614 if(env_wnn_errorno_eql) {
2615 UnlockMutex(&(env_js_lock));
2616 return(-1);
2617 }
2618 snd_env_head(env,JS_FUZOKUGO_GET);
2619 snd_flush(env->js_id);
2620 x=get4com(env->js_id);
2621 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
2622 UnlockMutex(&(env_js_lock));
2623 return x;
2624 }
2625
2626 static int rcv_dic_list();
2627 static void get_dic_info();
2628
2629 /*:::DOC_START
2630 *
2631 * Function Name: js_dic_list_all
2632 * Description : ���ꤵ�줿�����Ф����Ķ�����Ͽ����Ƥ���ף����
2633 * ������֤�
2634 * Parameter :
2635 * server : (In) �����ФؤΥݥ���
2636 * ret : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
2637 *
2638 * Return value : -1==ERROR, else ��Ͽ�����
2639 *
2640 * Author : Hideyuki Kishiba
2641 *
2642 * Revision history:
2643 *
2644 *:::DOC_END
2645 */
2646 int
js_dic_list_all(server,ret)2647 js_dic_list_all(server,ret)
2648 WNN_JSERVER_ID *server;
2649 struct wnn_ret_buf *ret;
2650 {
2651 int x;
2652
2653 set_current_js(server);
2654 LockMutex(&(server_js_lock));
2655 handler_of_jserver_dead(server);
2656 if(js_wnn_errorno_eql) {
2657 UnlockMutex(&(server_js_lock));
2658 return(-1);
2659 }
2660 snd_server_head(server,JS_DIC_LIST_ALL);
2661 snd_flush(server);
2662 x = rcv_dic_list(ret, server);
2663 UnlockMutex(&(server_js_lock));
2664 return x;
2665 } /* End of js_dic_list_all */
2666
2667 /*:::DOC_START
2668 *
2669 * Function Name: js_dic_list
2670 * Description : ���ꤵ�줿�Ķ�����Ͽ����Ƥ���ף���ξ�����֤�
2671 * Parameter :
2672 * env : (In) �Ķ��ؤΥݥ���
2673 * ret : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
2674 *
2675 * Return value : -1==ERROR, else ��Ͽ�����
2676 *
2677 * Author : Hideyuki Kishiba
2678 *
2679 * Revision history:
2680 *
2681 *:::DOC_END
2682 */
2683 int
js_dic_list(env,ret)2684 js_dic_list(env,ret)
2685 struct wnn_env *env;
2686 struct wnn_ret_buf *ret;
2687 {
2688 int x;
2689
2690 if(env==0) return(-1);
2691 set_current_js(env->js_id);
2692 LockMutex(&(env_js_lock));
2693 handler_of_jserver_dead_env(env);
2694 if(env_wnn_errorno_eql) {
2695 UnlockMutex(&(env_js_lock));
2696 return(-1);
2697 }
2698 snd_env_head(env,JS_DIC_LIST);
2699 snd_flush(env->js_id);
2700 x = rcv_dic_list(ret, env->js_id);
2701 UnlockMutex(&(env_js_lock));
2702 return x;
2703 } /* End of js_dic_list */
2704
2705 /*:::DOC_START
2706 *
2707 * Function Name: js_fi_dic_list_all
2708 * Description : ���ꤵ�줿�����Ф����Ķ�����Ͽ����Ƥ��뼭����⡢
2709 * ���ꤵ�줿�����ξ�����֤�
2710 * Parameter :
2711 * server : (In) �����ФؤΥݥ���
2712 * dmask : (In) ��������ޥ���
2713 * ret : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
2714 *
2715 * Return value : -1==ERROR, else ��Ͽ�����
2716 *
2717 * Author : Hideyuki Kishiba
2718 *
2719 * Revision history:
2720 *
2721 *:::DOC_END
2722 */
2723 int
js_fi_dic_list_all(server,dmask,ret)2724 js_fi_dic_list_all(server, dmask, ret)
2725 WNN_JSERVER_ID *server;
2726 unsigned long dmask;
2727 struct wnn_ret_buf *ret;
2728 {
2729 int x;
2730
2731 set_current_js(server);
2732
2733 /* �����Ф� FI-Wnn ������ΥС������ʤ顢����� dic_list ̿������� */
2734 if(!CHECK_FI) return(js_dic_list_all(server, ret));
2735
2736 LockMutex(&(server_js_lock));
2737 handler_of_jserver_dead(server);
2738 if(js_wnn_errorno_eql) {
2739 UnlockMutex(&(server_js_lock));
2740 return(-1);
2741 }
2742 snd_server_head(server,JS_FI_DIC_LIST_ALL);
2743 put4com(dmask, server);
2744 snd_flush(server);
2745 x = rcv_dic_list(ret, server);
2746 UnlockMutex(&(server_js_lock));
2747 return x;
2748 } /* End of js_fi_dic_list_all */
2749
2750 /*:::DOC_START
2751 *
2752 * Function Name: js_fi_dic_list
2753 * Description : ���ꤵ�줿�Ķ�����Ͽ����Ƥ��뼭����⡢
2754 * ���ꤵ�줿�����ξ�����֤�
2755 * Parameter :
2756 * env : (In) �Ķ��ؤΥݥ���
2757 * dmask : (In) ��������ޥ���
2758 * ret : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
2759 *
2760 * Return value : -1==ERROR, else ��Ͽ�����
2761 *
2762 * Author : Hideyuki Kishiba
2763 *
2764 * Revision history:
2765 *
2766 *:::DOC_END
2767 */
2768 int
js_fi_dic_list(env,dmask,ret)2769 js_fi_dic_list(env, dmask, ret)
2770 struct wnn_env *env;
2771 unsigned long dmask;
2772 struct wnn_ret_buf *ret;
2773 {
2774 int x;
2775
2776 if(env==0) return(-1);
2777 set_current_js(env->js_id);
2778
2779 /* �����Ф� FI-Wnn ������ΥС������ʤ顢����� dic_list ̿������� */
2780 if(!CHECK_FI) return(js_dic_list(env, ret));
2781
2782 LockMutex(&(env_js_lock));
2783 handler_of_jserver_dead_env(env);
2784 if(env_wnn_errorno_eql) {
2785 UnlockMutex(&(env_js_lock));
2786 return(-1);
2787 }
2788 snd_env_head(env,JS_FI_DIC_LIST);
2789 put4com(dmask, env->js_id);
2790 snd_flush(env->js_id);
2791 x = rcv_dic_list(ret, env->js_id);
2792 UnlockMutex(&(env_js_lock));
2793 return x;
2794 } /* End of js_fi_dic_list */
2795
2796 /*:::DOC_START
2797 *
2798 * Function Name: rcv_dic_list
2799 * Description : ��������������ѹ�¤�Τ��ΰ����ݤ���
2800 * Parameter :
2801 * ret : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
2802 * server : (In) �����ФؤΥݥ���
2803 *
2804 * Return value : -1==ERROR, else ��Ͽ�����
2805 *
2806 * Author : Hideyuki Kishiba
2807 *
2808 * Revision history:
2809 *
2810 *:::DOC_END
2811 */
2812 static int
rcv_dic_list(ret,server)2813 rcv_dic_list(ret, server)
2814 struct wnn_ret_buf *ret;
2815 ARGS *server;
2816 {register int i,count;
2817 register WNN_DIC_INFO *dic;
2818 if((count=get4com(server)) == -1) {
2819 js_wnn_errorno_set = get4com(server);
2820 return(-1);
2821 }
2822 re_alloc(ret, sizeof(WNN_DIC_INFO)*(count + 1));
2823
2824 dic=(WNN_DIC_INFO *)ret->buf;
2825 for(i=0;i<count;i++){
2826 get_dic_info(dic, server);
2827 dic++;
2828 }
2829 dic->dic_no = -1;
2830 return count;
2831 } /* End of rcv_dic_list */
2832
2833 /*:::DOC_START
2834 *
2835 * Function Name: get_dic_info
2836 * Description : ��������������������
2837 * Parameter :
2838 * dic : (Out) ��������������ѹ�¤�ΤؤΥݥ���
2839 * server : (In) �����ФؤΥݥ���
2840 *
2841 * Return value : -1==ERROR, else ��Ͽ�����
2842 *
2843 * Author : Hideyuki Kishiba
2844 *
2845 * Revision history:
2846 *
2847 *:::DOC_END
2848 */
2849 static void
get_dic_info(dic,server)2850 get_dic_info(dic, server)
2851 register WNN_DIC_INFO *dic;
2852 ARGS *server;
2853 {
2854 dic->dic_no =get4com(server); /* dic_No */
2855 dic->body =get4com(server); /* body fid */
2856 dic->hindo =get4com(server); /* hindo fid */
2857 dic->rw =get4com(server); /* r/w */
2858 dic->hindo_rw =get4com(server); /* hindo r/w */
2859 dic->enablef =get4com(server); /* enable/disable */
2860 dic->nice =get4com(server); /* nice */
2861 dic->rev = get4com(server);
2862 /* added H.T */
2863 getwscom(dic->comment, server, WNN_COMMENT_LEN);
2864 getscom(dic->fname, server, WNN_F_NAMELEN);
2865 getscom(dic->hfname, server, WNN_F_NAMELEN);
2866 getscom(dic->passwd, server, WNN_PASSWD_LEN);
2867 getscom(dic->hpasswd, server, WNN_PASSWD_LEN);
2868 dic->type = get4com(server);
2869 dic->gosuu = get4com(server);
2870 dic->localf = get4com(server);
2871 dic->hlocalf = get4com(server);
2872 } /* End of get_dic_info */
2873
2874 /*:::DOC_START
2875 *
2876 * Function Name: rcv_fzk_list
2877 * Description : ��°������������ѹ�¤�Τ��ΰ����ݤ���
2878 * ������������������
2879 * Parameter :
2880 * curfzk : (Out) �����ѥե����뼱�̻�
2881 * ret : (Out) ��°������������ѹ�¤�ΤؤΥݥ���
2882 * server : (In) �����ФؤΥݥ���
2883 *
2884 * Return value : -1==ERROR, else �ɹ�����°���
2885 *
2886 * Author : Hideyuki Kishiba
2887 *
2888 * Revision history:
2889 *
2890 *:::DOC_END
2891 */
2892 static int
rcv_fzk_list(curfzk,ret,server)2893 rcv_fzk_list(curfzk, ret, server)
2894 int *curfzk;
2895 WNN_FZK_INFO **ret;
2896 ARGS *server;
2897 {
2898 register int i, count;
2899 register WNN_FZK_INFO *fzk;
2900
2901 /* �ɹ�����°����������ѥե����뼱�̻Ҥ������� */
2902 if((count = get4com(server)) == -1) {
2903 js_wnn_errorno_set = get4com(server);
2904 return(-1);
2905 }
2906 *curfzk = get4com(server);
2907
2908 /* �����������ѹ�¤�Τ��ΰ����ݤ��� */
2909 if(((*ret) = (WNN_FZK_INFO *)malloc((count + 1) *
2910 sizeof(WNN_FZK_INFO))) == NULL) {
2911 WNN_FZK_INFO dummy;
2912 for(i = 0; i < count; i++){
2913 getwscom(dummy.comment, server, WNN_COMMENT_LEN);
2914 getscom(dummy.fname, server, WNN_F_NAMELEN);
2915 }
2916 js_wnn_errorno_set = WNN_ALLOC_FAIL;
2917 return(-1);
2918 }
2919 fzk = (WNN_FZK_INFO *)*ret;
2920
2921 /* ��°������������ */
2922 for(i = 0; i < count; i++){
2923 getwscom(fzk->comment, server, WNN_COMMENT_LEN);
2924 getscom(fzk->fname, server, WNN_F_NAMELEN);
2925 fzk++;
2926 }
2927
2928 fzk->fname[0] = 0;
2929 return count;
2930 } /* End of rcv_fzk_list */
2931
2932 /*:::DOC_START
2933 *
2934 * Function Name: js_fuzokugo_list
2935 * Description : ���ꤵ�줿�����Ф��ɤ߹��ޤ�Ƥ�������°������
2936 * �Ķ��˸������ꤵ��Ƥ������μ��̻Ҥ��֤�
2937 * Parameter :
2938 * env : (In) �Ķ��ؤΥݥ���
2939 * curfzk : (Out) �����ѥե����뼱�̻�
2940 * ret : (Out) ��°������������ѹ�¤�ΤؤΥݥ���
2941 *
2942 * Return value : -1==ERROR, else �ɹ�����°���
2943 *
2944 * Author : Hideyuki Kishiba
2945 *
2946 * Revision history:
2947 *
2948 *:::DOC_END
2949 */
2950 int
js_fuzokugo_list(env,curfzk,ret)2951 js_fuzokugo_list(env, curfzk, ret)
2952 struct wnn_env *env;
2953 int *curfzk;
2954 WNN_FZK_INFO **ret;
2955 {
2956 register int x;
2957
2958 if(env==0) return(-1);
2959 set_current_js(env->js_id);
2960 LockMutex(&(env_js_lock));
2961 handler_of_jserver_dead_env(env);
2962 if(env_wnn_errorno_eql) {
2963 UnlockMutex(&(env_js_lock));
2964 return(-1);
2965 }
2966 snd_env_head(env,JS_FUZOKUGO_LIST);
2967 snd_flush(env->js_id);
2968 x = rcv_fzk_list(curfzk, ret, env->js_id);
2969 UnlockMutex(&(env_js_lock));
2970 return x;
2971 } /* End of js_fuzokugo_list */
2972
2973 /*** Dic. Operation by dic_No. ***/
2974
2975 /** js_word_add **/
2976 int
js_word_add(env,dic_no,yomi,kanji,comment,hinshi,init_hindo)2977 js_word_add(env,dic_no,yomi,kanji,comment,hinshi,init_hindo)
2978 struct wnn_env *env;
2979 int dic_no;
2980 w_char *yomi,*kanji,*comment;
2981 int hinshi,init_hindo;
2982 {register int x;
2983 if(env==0) return(-1);
2984 set_current_js(env->js_id);
2985 LockMutex(&(env_js_lock));
2986 handler_of_jserver_dead_env(env);
2987 if(env_wnn_errorno_eql) {
2988 UnlockMutex(&(env_js_lock));
2989 return(-1);
2990 }
2991 snd_env_head(env,JS_WORD_ADD);
2992 put4com(dic_no, env->js_id);
2993 putwscom(yomi, env->js_id);
2994 putwscom(kanji, env->js_id);
2995 putwscom(comment, env->js_id);
2996 put4com(hinshi, env->js_id);
2997 put4com(init_hindo, env->js_id);
2998 snd_flush(env->js_id);
2999 x=get4com(env->js_id);
3000 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
3001 UnlockMutex(&(env_js_lock));
3002 return x;
3003 }
3004
3005 /** js_word_delete **/
3006 int
js_word_delete(env,dic_no,entry)3007 js_word_delete(env,dic_no,entry)
3008 struct wnn_env *env;
3009 int dic_no;
3010 int entry;
3011 {register int x;
3012 if(env==0) return(-1);
3013 set_current_js(env->js_id);
3014 LockMutex(&(env_js_lock));
3015 handler_of_jserver_dead_env(env);
3016 if(env_wnn_errorno_eql) {
3017 UnlockMutex(&(env_js_lock));
3018 return(-1);
3019 }
3020 snd_env_head(env,JS_WORD_DELETE);
3021 put4com(dic_no, env->js_id);
3022 put4com(entry, env->js_id);
3023 snd_flush(env->js_id);
3024 x=get4com(env->js_id);
3025 if(x==-1)env_wnn_errorno_set= get4com(env->js_id);
3026 UnlockMutex(&(env_js_lock));
3027 return x;
3028 }
3029
3030
3031 /** js_word_search **/
3032 static int rcv_word_data();
3033
3034 int
js_word_search(env,dic_no,yomi,ret)3035 js_word_search(env,dic_no,yomi,ret)
3036 struct wnn_env *env;
3037 int dic_no;
3038 w_char *yomi;
3039 struct wnn_ret_buf *ret;
3040 {
3041 int x;
3042
3043 if(env==0) return(-1);
3044 set_current_js(env->js_id);
3045 LockMutex(&(env_js_lock));
3046 handler_of_jserver_dead_env(env);
3047 if(env_wnn_errorno_eql) {
3048 UnlockMutex(&(env_js_lock));
3049 return(-1);
3050 }
3051 snd_env_head(env,JS_WORD_SEARCH);
3052 put4com(dic_no, env->js_id);
3053 putwscom(yomi, env->js_id);
3054 snd_flush(env->js_id);
3055 x = rcv_word_data(ret, yomi, env->js_id);
3056 UnlockMutex(&(env_js_lock));
3057 return x;
3058 }
3059
3060 /** js_word_search_by_env **/
3061 int
js_word_search_by_env(env,yomi,ret)3062 js_word_search_by_env(env,yomi,ret)
3063 struct wnn_env *env;
3064 w_char *yomi;
3065 struct wnn_ret_buf *ret;
3066 {
3067 int x;
3068
3069 if(env==0) return(-1);
3070 set_current_js(env->js_id);
3071 LockMutex(&(env_js_lock));
3072 handler_of_jserver_dead_env(env);
3073 if(env_wnn_errorno_eql) {
3074 UnlockMutex(&(env_js_lock));
3075 return(-1);
3076 }
3077 snd_env_head(env,JS_WORD_SEARCH_BY_ENV);
3078 putwscom(yomi, env->js_id);
3079 snd_flush(env->js_id);
3080 x = rcv_word_data(ret, yomi, env->js_id);
3081 UnlockMutex(&(env_js_lock));
3082 return x;
3083 }
3084
3085 /** js_word_info **/
3086 int
js_word_info(env,dic_no,entry,ret)3087 js_word_info(env,dic_no,entry,ret)
3088 struct wnn_env *env;
3089 int dic_no,entry;
3090 struct wnn_ret_buf *ret;
3091 {register int x;
3092 w_char yomi[LENGTHYOMI];
3093
3094 if(env==0) return(-1);
3095 set_current_js(env->js_id);
3096 LockMutex(&(env_js_lock));
3097 handler_of_jserver_dead_env(env);
3098 if(env_wnn_errorno_eql) {
3099 UnlockMutex(&(env_js_lock));
3100 return(-1);
3101 }
3102 snd_env_head(env,JS_WORD_INFO);
3103 put4com(dic_no, env->js_id);
3104 put4com(entry, env->js_id);
3105 snd_flush(env->js_id);
3106 x=get4com(env->js_id);
3107 if(x==-1){
3108 env_wnn_errorno_set= get4com(env->js_id);
3109 UnlockMutex(&(env_js_lock));
3110 return(-1);
3111 }
3112 getwscom(yomi, env->js_id, sizeof(yomi) / sizeof(w_char));
3113 rcv_word_data(ret, yomi, env->js_id);
3114 UnlockMutex(&(env_js_lock));
3115 return(0);
3116 }
3117
3118 int
js_word_comment_set(env,dic_no,entry,comment)3119 js_word_comment_set(env, dic_no, entry, comment)
3120 struct wnn_env *env;
3121 int dic_no,entry;
3122 w_char *comment;
3123 {
3124 register int x;
3125 if(env==0) return(-1);
3126 set_current_js(env->js_id);
3127 LockMutex(&(env_js_lock));
3128 handler_of_jserver_dead_env(env);
3129 if(env_wnn_errorno_eql) {
3130 UnlockMutex(&(env_js_lock));
3131 return(-1);
3132 }
3133 snd_env_head(env,JS_WORD_COMMENT_SET);
3134 put4com(dic_no, env->js_id);
3135 put4com(entry, env->js_id);
3136 putwscom(comment, env->js_id);
3137 snd_flush(env->js_id);
3138 x=get4com(env->js_id);
3139 if(x==-1){
3140 env_wnn_errorno_set= get4com(env->js_id);
3141 UnlockMutex(&(env_js_lock));
3142 return(-1);
3143 }
3144 UnlockMutex(&(env_js_lock));
3145 return(0);
3146 }
3147
3148 /** rcv for word_search **/
3149 static int
rcv_word_data(ret,yomi,server)3150 rcv_word_data(ret, yomi, server)
3151 struct wnn_ret_buf *ret;
3152 w_char *yomi; /* Yomi is not sent from server
3153 * (at least for the time being).
3154 */
3155 ARGS *server;
3156 {register int x, j_c,k_c, databytes, wlen;
3157 w_char *k;
3158 w_char wbuf[LENGTHKANJI];
3159 register struct wnn_jdata *jd;
3160 register int cnt, error_flag;
3161
3162 j_c = get4com(server);
3163 k_c = get4com(server);
3164 databytes = sizeof(w_char)*(k_c + j_c * 3 + j_c * wnn_Strlen(yomi));
3165 re_alloc(ret, sizeof(struct wnn_jdata)*(j_c + 1) + databytes);
3166 jd=(struct wnn_jdata *)ret->buf;
3167 for(cnt = 0;;cnt++){
3168 jd->dic_no = x = get4com(server);
3169 if(x==-1) break;
3170 jd->serial = get4com(server);
3171 jd->hinshi = get4com(server);
3172 jd->hindo = get4com(server); jd->ima = get4com(server);
3173 jd->int_hindo = get4com(server); jd->int_ima = get4com(server);
3174 jd++;
3175 }
3176 jd++;
3177 k= (w_char *)jd;
3178 jd=(struct wnn_jdata *)ret->buf;
3179 error_flag = 0;
3180 for(;;){
3181 if(jd->dic_no==-1) break;
3182
3183 if (!error_flag) {
3184 wlen = wnn_Strlen(yomi) + 1;
3185 if ((wlen * sizeof(w_char)) > databytes) {
3186 error_flag = 1;
3187 } else {
3188 jd->yomi = k; /* Copy Yomi */
3189 wnn_Strcpy(k, yomi);
3190 k+= wlen;
3191 databytes -= (wlen * sizeof(w_char));
3192 }
3193 }
3194
3195 getwscom(wbuf, server, sizeof(wbuf) / sizeof(w_char));
3196 if (!error_flag) {
3197 wlen = wnn_Strlen(wbuf) + 1;
3198 if ((wlen * sizeof(w_char)) > databytes) {
3199 error_flag = 1;
3200 } else {
3201 jd->kanji = k; /* Get Kanji */
3202 wnn_Strcpy(k, wbuf);
3203 k+= wlen;
3204 databytes -= (wlen * sizeof(w_char));
3205 }
3206 }
3207
3208 getwscom(wbuf, server, sizeof(wbuf) / sizeof(w_char));
3209 if (!error_flag) {
3210 wlen = wnn_Strlen(wbuf) + 1;
3211 if ((wlen * sizeof(w_char)) > databytes) {
3212 error_flag = 1;
3213 } else {
3214 jd->com = k; /* Get Comment */
3215 wnn_Strcpy(k, wbuf);
3216 k+= wlen;
3217 databytes -= (wlen * sizeof(w_char));
3218 }
3219 }
3220 jd++;
3221 }
3222 return cnt;
3223 }
3224
3225
3226 /** js_dic_info **/
3227 int
js_dic_info(env,dic_no,ret)3228 js_dic_info(env,dic_no,ret)
3229 struct wnn_env *env;
3230 int dic_no;
3231 register WNN_DIC_INFO *ret;
3232 {register int x;
3233 if(env==0) return(-1);
3234 set_current_js(env->js_id);
3235 LockMutex(&(env_js_lock));
3236 handler_of_jserver_dead_env(env);
3237 if(env_wnn_errorno_eql) {
3238 UnlockMutex(&(env_js_lock));
3239 return(-1);
3240 }
3241 snd_env_head(env,JS_DIC_INFO);
3242 put4com(dic_no, env->js_id);
3243 snd_flush(env->js_id);
3244 x=get4com(env->js_id);
3245 if(x==-1){
3246 env_wnn_errorno_set = get4com(env->js_id);
3247 UnlockMutex(&(env_js_lock));
3248 return x;
3249 }
3250 get_dic_info(ret, env->js_id);
3251 UnlockMutex(&(env_js_lock));
3252 return dic_no;
3253 }
3254
3255 /** js_who **/
3256 int
js_who(server,ret)3257 js_who(server,ret)
3258 WNN_JSERVER_ID *server;
3259 struct wnn_ret_buf *ret;
3260 {register int i,j,c;
3261 WNN_JWHO *w;
3262 set_current_js(server);
3263 LockMutex(&(server_js_lock));
3264 handler_of_jserver_dead(server);
3265 if(js_wnn_errorno_eql) {
3266 UnlockMutex(&(server_js_lock));
3267 return(-1);
3268 }
3269 snd_server_head(server,JS_WHO);
3270 snd_flush(server);
3271
3272 c=get4com(server);
3273 if(c==-1){
3274 js_wnn_errorno_set= get4com(server);
3275 UnlockMutex(&(server_js_lock));
3276 return -1;
3277 }
3278
3279 re_alloc(ret, sizeof(WNN_JWHO)*c);
3280 w=(WNN_JWHO *)ret->buf;
3281 for(i=0;i<c;i++){
3282 w->sd=get4com(server);
3283 getscom(w->user_name, server, sizeof(w->user_name));
3284 getscom(w->host_name, server, sizeof(w->host_name));
3285 for(j=0;j<WNN_MAX_ENV_OF_A_CLIENT;j++){
3286 (w->env)[j]=get4com(server);
3287 }
3288 w++;
3289 }
3290 UnlockMutex(&(server_js_lock));
3291 return(c);
3292 }
3293
3294 /** jserver ������ƤδĶ��˴ؤ����������롣
3295 (���鵻)
3296 **/
3297 int
js_env_list(server,ret)3298 js_env_list(server,ret)
3299 WNN_JSERVER_ID *server;
3300 struct wnn_ret_buf *ret;
3301 {register int i,j,c;
3302 WNN_ENV_INFO *w;
3303 set_current_js(server);
3304 LockMutex(&(server_js_lock));
3305 handler_of_jserver_dead(server);
3306 if(js_wnn_errorno_eql) {
3307 UnlockMutex(&(server_js_lock));
3308 return(-1);
3309 }
3310 snd_server_head(server,JS_ENV_LIST);
3311 snd_flush(server);
3312
3313 c=get4com(server);
3314 if(c==-1){
3315 js_wnn_errorno_set= get4com(server);
3316 UnlockMutex(&(server_js_lock));
3317 return -1;
3318 }
3319
3320 re_alloc(ret, sizeof(WNN_ENV_INFO)*c);
3321 w=(WNN_ENV_INFO *)ret->buf;
3322 for(i=0;i<c;i++){
3323 w->env_id = get4com(server);
3324 getscom(w->env_name, server, WNN_ENVNAME_LEN);
3325 w->ref_count=get4com(server);
3326 w->fzk_fid=get4com(server);
3327 w->jishomax=get4com(server);
3328 for(j=0;j<WNN_MAX_JISHO_OF_AN_ENV;j++){
3329 (w->jisho)[j]= get4com(server);
3330 }
3331 for(j=0;j<WNN_MAX_FILE_OF_AN_ENV;j++){
3332 (w->file)[j]= get4com(server);
3333 }
3334 w++;
3335 }
3336 UnlockMutex(&(server_js_lock));
3337 return(c);
3338 }
3339
3340 /****
3341
3342 ****/
3343 /*:::DOC_START
3344 *
3345 * Function Name: js_hindo_set
3346 * Description : ���ꤵ�줿����κ��ӥåȡ����٤����ꤹ��
3347 * Parameter :
3348 * env : (In) �Ķ��ؤΥݥ���
3349 * dic : (In) ���䤬��Ͽ����Ƥ��뼭���ֹ�
3350 * entry : (In) ����Υ���ȥ��ֹ�
3351 * ima : (In) ���ӥåȤ�������ˡ�ե饰
3352 * hindo : (In) ���٤�������ˡ�ե饰
3353 *
3354 * Return value : 0==SUCCESS, -1==ERROR
3355 *
3356 * Author : Hideyuki Kishiba
3357 *
3358 * Revision history:
3359 *
3360 *:::DOC_END
3361 */
3362 int
js_hindo_set(env,dic,entry,ima,hindo)3363 js_hindo_set(env,dic,entry,ima,hindo)
3364 struct wnn_env *env;
3365 int dic, entry, ima,hindo;
3366 {register int x;
3367 if(env==0) return(-1);
3368 set_current_js(env->js_id);
3369 LockMutex(&(env_js_lock));
3370 handler_of_jserver_dead_env(env);
3371 if(env_wnn_errorno_eql) {
3372 UnlockMutex(&(env_js_lock));
3373 return(-1);
3374 }
3375 snd_env_head(env,JS_HINDO_SET);
3376
3377 put4com(dic, env->js_id);
3378 put4com(entry, env->js_id);
3379 put4com(ima, env->js_id);
3380 put4com(hindo, env->js_id);
3381 snd_flush(env->js_id);
3382 if((x=get4com(env->js_id))==-1){
3383 env_wnn_errorno_set= get4com(env->js_id);
3384 UnlockMutex(&(env_js_lock)); return -1;
3385 }
3386 UnlockMutex(&(env_js_lock));
3387 return x;
3388 } /* End of js_hindo_set */
3389
3390 /*:::DOC_START
3391 *
3392 * Function Name: js_set_fi_priority
3393 * Description : ����ƣɴط��ǡ����Σƣɴط���³���ӥåȤ�
3394 * �ƣɴط���³���٤����ꤹ��
3395 * Parameter :
3396 * env : (In) �Ķ��ؤΥݥ���
3397 * fi_rel_entry : (In) ���ѣƣɴط������ѹ�¤�ΤؤΥݥ���
3398 *
3399 * Return value : 0==SUCCESS, -1==ERROR
3400 *
3401 * Author : Hideyuki Kishiba
3402 *
3403 * Revision history:
3404 *
3405 *:::DOC_END
3406 */
3407 int
js_set_fi_priority(env,fi_rel_entry)3408 js_set_fi_priority(env, fi_rel_entry)
3409 struct wnn_env *env;
3410 struct wnn_fi_rel_buf *fi_rel_entry;
3411 {
3412 register int x;
3413
3414 if(env==0) return(-1);
3415 set_current_js(env->js_id);
3416
3417 /* �����Ф��ƣɳؽ����ݡ��Ȥ��Ƥ��ʤ����ϲ��⤷�ʤ� */
3418 if(!CHECK_FI) return(0);
3419
3420 LockMutex(&(env_js_lock));
3421 handler_of_jserver_dead_env(env);
3422 if(env_wnn_errorno_eql) {
3423 UnlockMutex(&(env_js_lock));
3424 return(-1);
3425 }
3426 snd_env_head(env,JS_SET_FI_PRIORITY);
3427
3428 put4com(fi_rel_entry->num, env->js_id);
3429 for(x = 0; x < fi_rel_entry->num; x++) {
3430 put4com(fi_rel_entry->fi_buf[x].fi_dic_no, env->js_id);
3431 put4com(fi_rel_entry->fi_buf[x].dic_no, env->js_id);
3432 put4com(fi_rel_entry->fi_buf[x].entry, env->js_id);
3433 put4com(fi_rel_entry->fi_buf[x].offset, env->js_id);
3434 put4com(fi_rel_entry->fi_buf[x].fi_hindo, env->js_id);
3435 put4com(fi_rel_entry->fi_buf[x].fi_ima, env->js_id);
3436 }
3437 snd_flush(env->js_id);
3438
3439 if((x = get4com(env->js_id)) == -1) {
3440 env_wnn_errorno_set= get4com(env->js_id);
3441 UnlockMutex(&(env_js_lock)); return -1;
3442 }
3443 UnlockMutex(&(env_js_lock));
3444 return x;
3445 } /* End of js_set_fi_priority */
3446
3447 /*:::DOC_START
3448 *
3449 * Function Name: js_optimize_fi
3450 * Description : ���ꤵ�줿������κ��ӥåȡ����٤����ꤷ���Ƴؽ�����
3451 * ����Ƭ�졦�����ࡦ���Ѹ졦�����졦�ƣɡˤ�Ԥ�
3452 * Parameter :
3453 * env : (In) �Ķ��ؤΥݥ���
3454 * nkouho : (In) ��������
3455 * dic : (In) ���䤬��Ͽ����Ƥ��뼭���ֹ�����ؤΥݥ���
3456 * entry (In) ����Υ���ȥ��ֹ�����ؤΥݥ���
3457 * ima : (In) ���ӥåȤ�������ˡ�ե饰����ؤΥݥ���
3458 * hindo : (In) ���٤�������ˡ�ե饰����ؤΥݥ���
3459 * kmoji : (In) ����ʸ��������°��ʤ�������ؤΥݥ���
3460 * kouho : (In) ����ʸ�������°�줢�������ؤΥݥ���
3461 *
3462 * Return value : 0==SUCCESS, -1==ERROR
3463 *
3464 * Author : Hideyuki Kishiba
3465 *
3466 * Revision history:
3467 *
3468 *:::DOC_END
3469 */
3470 int
js_optimize_fi(env,nkouho,dic,entry,ima,hindo,kmoji,kouho)3471 js_optimize_fi(env,nkouho,dic,entry,ima,hindo,kmoji,kouho)
3472 struct wnn_env *env;
3473 int nkouho, *dic, *entry, *ima, *hindo, *kmoji;
3474 w_char **kouho;
3475 {
3476 register int x, i;
3477
3478 x = 0;
3479 if(env==0) return(-1);
3480 set_current_js(env->js_id);
3481
3482 /* �����Ф��ƣɳؽ����ݡ��Ȥ��Ƥ��ʤ����ϡ�
3483 �������������ץ�ȥ����������������� */
3484 if(!CHECK_FI) {
3485 for(i = 0; i < nkouho; i++) {
3486 x = js_hindo_set(env, dic[i], entry[i], ima[i], hindo[i]);
3487 if(x == -1) return(-1);
3488 }
3489 return(x);
3490 }
3491
3492 LockMutex(&(env_js_lock));
3493 handler_of_jserver_dead_env(env);
3494 if(env_wnn_errorno_eql) {
3495 UnlockMutex(&(env_js_lock));
3496 return(-1);
3497 }
3498 snd_env_head(env,JS_OPTIMIZE_FI);
3499
3500 put4com(nkouho, env->js_id);
3501 for(x = 0; x < nkouho; x++) {
3502 put4com(dic[x], env->js_id);
3503 put4com(entry[x], env->js_id);
3504 put4com(ima[x], env->js_id);
3505 put4com(hindo[x], env->js_id);
3506 put4com(kmoji[x], env->js_id);
3507 putwscom(kouho[x], env->js_id);
3508 }
3509 snd_flush(env->js_id);
3510
3511 if((x = get4com(env->js_id)) == -1) {
3512 env_wnn_errorno_set= get4com(env->js_id);
3513 UnlockMutex(&(env_js_lock)); return -1;
3514 }
3515 UnlockMutex(&(env_js_lock));
3516 return x;
3517 } /* End of js_optimize_fi */
3518
3519
3520 /****
3521 Henkan
3522 ****/
3523
3524 static void
put_fzk_vec(hinsi,fzk,vec,vec1,server)3525 put_fzk_vec(hinsi,fzk,vec,vec1, server)
3526 int hinsi;
3527 w_char *fzk;
3528 int vec;
3529 int vec1;
3530 ARGS *server;
3531 {
3532 put4com(hinsi, server);
3533 putwscom(fzk, server);
3534 put4com(vec, server);
3535 put4com(vec1, server);
3536 }
3537
3538 /**
3539 kanren
3540 **/
3541 static int rcv_dai(), rcv_fi_rel_data();
3542 static void rcv_sho_x();
3543 static void rcv_sho_kanji();
3544
3545 int
js_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,rb)3546 js_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,rb)
3547 struct wnn_env *env;
3548 w_char *yomi;
3549 int hinsi;
3550 w_char *fzk;
3551 int vec;
3552 int vec1;
3553 int vec2;
3554 struct wnn_ret_buf *rb;
3555 {
3556 int x;
3557
3558 if(env==0) return(-1);
3559 set_current_js(env->js_id);
3560 LockMutex(&(env_js_lock));
3561 handler_of_jserver_dead_env(env);
3562 if(env_wnn_errorno_eql) {
3563 UnlockMutex(&(env_js_lock));
3564 return(-1);
3565 }
3566 snd_env_head(env,JS_KANREN);
3567 putwscom(yomi, env->js_id);
3568 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
3569 put4com(vec2, env->js_id);
3570 snd_flush(env->js_id);
3571 x = rcv_dai(rb, env->js_id);
3572 UnlockMutex(&(env_js_lock));
3573 return x;
3574 }
3575
3576 /*:::DOC_START
3577 *
3578 * Function Name: js_fi_kanren
3579 * Description : Ϣʸ��ƣ��Ѵ���Ԥ�����̤�������
3580 * Parameter :
3581 * env : (In) �Ķ��ؤΥݥ���
3582 * yomi: (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
3583 * hinsi (In) ����ʸ����ʻ��ֹ�
3584 * fzk : (In) ����ʸ�����°��ʸ����ؤΥݥ���
3585 * vec : (In) ��ü�٥��ȥ룱
3586 * vec1 : (In) ��ü�٥��ȥ룲
3587 * vec2 : (In) Ϣʸ���Ѵ��������ʸ��ν�ü�٥��ȥ�
3588 * prev : (In) ľ������ʸ�����¤�ΤؤΥݥ���
3589 * rb : (Out) �Ѵ���������ѹ�¤�ΤؤΥݥ���
3590 * fi_rb : (Out) ���ѣƣɴط������ѹ�¤�ΤؤΥݥ���
3591 *
3592 * Return value : 0==SUCCESS, -1==ERROR
3593 *
3594 * Author : Hideyuki Kishiba
3595 *
3596 * Revision history:
3597 *
3598 *:::DOC_END
3599 */
3600 int
js_fi_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,prev,rb,fi_rb)3601 js_fi_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,prev,rb,fi_rb)
3602 struct wnn_env *env;
3603 w_char *yomi;
3604 int hinsi;
3605 w_char *fzk;
3606 int vec;
3607 int vec1;
3608 int vec2;
3609 struct wnn_prev_bun *prev;
3610 struct wnn_ret_buf *rb;
3611 struct wnn_fi_rel_buf *fi_rb;
3612 {
3613 int x;
3614
3615 if(env==0) return(-1);
3616 set_current_js(env->js_id);
3617
3618 /* �����Ф��ƣ��Ѵ����ݡ��Ȥ��Ƥ��ʤ����ϡ������Ϣʸ�����
3619 �ץ�ȥ�������� */
3620 if(!CHECK_FI) return(js_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,rb));
3621
3622 LockMutex(&(env_js_lock));
3623 handler_of_jserver_dead_env(env);
3624 if(env_wnn_errorno_eql) {
3625 UnlockMutex(&(env_js_lock));
3626 return(-1);
3627 }
3628 snd_env_head(env,JS_FI_KANREN);
3629 putwscom(yomi, env->js_id);
3630 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
3631 put4com(vec2, env->js_id);
3632 /* ľ������ʸ����� */
3633 for(x = 0; x < WNN_PREV_BUN_SUU; x++) {
3634 put4com(prev[x].dic_no, env->js_id); /* Wnn �����ֹ� */
3635 put4com(prev[x].entry, env->js_id); /* ����ȥ��ֹ� */
3636 put4com(prev[x].jirilen, env->js_id); /* ��Ω���ɤ�Ĺ */
3637 put4com(prev[x].hinsi, env->js_id); /* �ʻ��ֹ� */
3638 putwscom((prev[x].kouho + prev[x].real_kanjilen), env->js_id);
3639 /* ��°��ʸ���� */
3640 }
3641 snd_flush(env->js_id);
3642
3643 /* Ϣʸ��ƣ��Ѵ���̤������� */
3644 x = rcv_dai(rb, env->js_id);
3645 /* ���ѣƣɴط��������� */
3646 if(x != -1) {
3647 if(rcv_fi_rel_data(fi_rb, env->js_id) == -1) x = -1;
3648 }
3649
3650 UnlockMutex(&(env_js_lock));
3651 return x;
3652 } /* End of js_fi_kanren */
3653
3654 /* rcv dai */
3655 static int
rcv_dai(ret,server)3656 rcv_dai(ret, server)
3657 struct wnn_ret_buf *ret;
3658 ARGS *server;
3659 {int dai_cnt,sho_sum,kanji_sum,d_size,s_size,k_size,x;
3660 register int i;
3661 struct wnn_dai_bunsetsu *dai_list;
3662 register struct wnn_dai_bunsetsu *dp;
3663 struct wnn_sho_bunsetsu *sho_list;
3664 register struct wnn_sho_bunsetsu *sp;
3665 w_char *kanji,*kp;
3666
3667 dai_cnt = get4com(server);
3668 if(dai_cnt == -1){ /* error dayo */
3669 js_wnn_errorno_set = get4com(server);
3670 return -1;
3671 }
3672 sho_sum = get4com(server);
3673 kanji_sum = get4com(server);
3674
3675 d_size=sizeof(struct wnn_dai_bunsetsu)*dai_cnt;
3676 s_size=sizeof(struct wnn_sho_bunsetsu)*sho_sum;
3677 k_size=sizeof(w_char)*kanji_sum;
3678
3679 /* re_alloc(ret, d_size+s_size+k_size); Seems This cause Bug?? H.T.*/
3680 re_alloc(ret, d_size+s_size+k_size);
3681
3682 dai_list = ( struct wnn_dai_bunsetsu *) ret->buf;
3683 sho_list = ( struct wnn_sho_bunsetsu *)((char *)ret->buf + d_size);
3684 kanji = (w_char *)((char *)ret->buf + d_size + s_size);
3685
3686 for(dp = dai_list,i=0; i<dai_cnt; i++){
3687 dp -> end = get4com(server);
3688 dp -> start = get4com(server);
3689 dp -> sbncnt = get4com(server);
3690 dp -> hyoka = get4com(server);
3691 dp++;
3692 }
3693
3694 for(dp = dai_list, sp = sho_list, i=0; i<dai_cnt; i++){
3695 dp -> sbn = sp;
3696 x = dp -> sbncnt;
3697 rcv_sho_x(sp,x, server);
3698 sp += x;
3699 dp++;
3700 }
3701
3702 for(dp=dai_list, kp=kanji, i=0; i<dai_cnt; i++){
3703 rcv_sho_kanji(dp->sbn,dp->sbncnt,&kp,&k_size,server);
3704 dp++;
3705 }
3706 return dai_cnt;
3707 }
3708
3709 /* rcv sho routines */
3710 static void
rcv_sho_x(sho_list,sho_cnt,server)3711 rcv_sho_x(sho_list,sho_cnt, server)
3712 register struct wnn_sho_bunsetsu *sho_list;
3713 int sho_cnt;
3714 ARGS *server;
3715 {register int i;
3716 for(i=0;i<sho_cnt;i++){
3717 sho_list -> end = get4com(server);
3718 sho_list -> start = get4com(server);
3719 sho_list -> jiriend = get4com(server);
3720 sho_list -> dic_no = get4com(server);
3721 sho_list -> entry = get4com(server);
3722 sho_list -> hindo = get4com(server);
3723 sho_list -> ima = get4com(server);
3724 sho_list -> hinsi = get4com(server);
3725 sho_list -> status = get4com(server);
3726 sho_list -> status_bkwd = get4com(server);
3727 sho_list ->kangovect = get4com(server);
3728 sho_list -> hyoka = get4com(server);
3729 sho_list++;
3730 }
3731 }
3732
3733 static void
rcv_sho_kanji(sho_list,sho_cnt,kanji,kanjibytes,server)3734 rcv_sho_kanji(sho_list,sho_cnt,kanji,kanjibytes,server)
3735 struct wnn_sho_bunsetsu *sho_list;
3736 int sho_cnt;
3737 w_char **kanji;
3738 int *kanjibytes;
3739 ARGS *server;
3740 {
3741 register w_char *k;
3742 register int i, bytes, error_flag, wlen;
3743 w_char wbuf[LENGTHKANJI];
3744
3745 k = *kanji;
3746 bytes = *kanjibytes;
3747 if (bytes <= 0)
3748 error_flag = 1;
3749 else
3750 error_flag = 0;
3751
3752 for(i=0;i<sho_cnt;i++){
3753 getwscom(wbuf, server, sizeof(wbuf) / sizeof(w_char));
3754 if (!error_flag) {
3755 wlen = wnn_Strlen(wbuf) + 1;
3756 if ((wlen * sizeof(w_char)) > bytes) {
3757 error_flag = 1;
3758 } else {
3759 sho_list->kanji = k;
3760 wnn_Strcpy(k, wbuf);
3761 k += wlen;
3762 bytes -= (wlen * sizeof(w_char));
3763 }
3764 }
3765
3766 getwscom(wbuf, server, sizeof(wbuf) / sizeof(w_char));
3767 if (!error_flag) {
3768 wlen = wnn_Strlen(wbuf) + 1;
3769 if ((wlen * sizeof(w_char)) > bytes) {
3770 error_flag = 1;
3771 } else {
3772 sho_list->yomi = k;
3773 wnn_Strcpy(k, wbuf);
3774 k += wlen;
3775 bytes -= (wlen * sizeof(w_char));
3776 }
3777 }
3778
3779 getwscom(wbuf, server, sizeof(wbuf) / sizeof(w_char));
3780 if (!error_flag) {
3781 wlen = wnn_Strlen(wbuf) + 1;
3782 if ((wlen * sizeof(w_char)) > bytes) { /* '>=' �ǤϤʤ� */
3783 error_flag = 1;
3784 } else {
3785 sho_list->fuzoku = k;
3786 wnn_Strcpy(k, wbuf);
3787 k += wlen;
3788 bytes -= (wlen * sizeof(w_char));
3789 }
3790 }
3791 sho_list++;
3792 }
3793 *kanji = k;
3794 *kanjibytes = bytes;
3795 }
3796
3797
3798 static int
rcv_sho(ret,server)3799 rcv_sho(ret, server)
3800 struct wnn_ret_buf *ret;
3801 ARGS *server;
3802 {int sho_sum,kanji_sum,s_size,k_size;
3803 struct wnn_sho_bunsetsu *sho_list;
3804 w_char *kanji,*kp;
3805
3806 sho_sum = get4com(server);
3807 if(sho_sum == -1){ /* error dayo */
3808 js_wnn_errorno_set = get4com(server);
3809 return -1;
3810 }
3811 kanji_sum = get4com(server);
3812
3813 s_size=sizeof(struct wnn_sho_bunsetsu)*sho_sum;
3814 k_size=sizeof(w_char)*kanji_sum;
3815
3816 re_alloc(ret, s_size+k_size);
3817
3818 sho_list = ( struct wnn_sho_bunsetsu *)((char *)ret->buf);
3819 kanji = (w_char *)((char *)ret->buf + s_size);
3820
3821 rcv_sho_x(sho_list,sho_sum, server);
3822 kp=kanji;
3823 rcv_sho_kanji(sho_list,sho_sum,&kp,&k_size,server);
3824 return sho_sum;
3825 }
3826
3827 /*:::DOC_START
3828 *
3829 * Function Name: rcv_fi_rel_data
3830 * Description : Ϣʸ��ƣ��Ѵ��˻��Ѥ����ƣɴط������������
3831 * Parameter :
3832 * ret : (Out) ���ѣƣɴط������ѹ�¤�ΤؤΥݥ���
3833 * server : (In) �о� jserver ����¤�ΤؤΥݥ���
3834 *
3835 * Return value : 0==SUCCESS, -1==ERROR
3836 *
3837 * Author : Hideyuki Kishiba
3838 *
3839 * Revision history:
3840 *
3841 *:::DOC_END
3842 */
3843 static int
rcv_fi_rel_data(ret,server)3844 rcv_fi_rel_data(ret, server)
3845 struct wnn_fi_rel_buf *ret;
3846 ARGS *server;
3847 {
3848 register int i, fi_num;
3849 struct fi_rel_data *fi_data;
3850
3851 fi_num = get4com(server); /* ���ѣƣɴط��� */
3852 if(fi_num == 0) return(0); /* ���ѣƣɴط����ʤ��ä� */
3853
3854 if(ret->size < ret->num + fi_num) {
3855 /* �����ˣƣɴط��ǡ�����¤���������ݤ��� */
3856 fi_data = (struct fi_rel_data *)
3857 malloc((ret->num + fi_num) * sizeof(struct fi_rel_data));
3858
3859 /* ���˻��Ѥ��Ƥ����ƣɴط��ǡ������ԡ����� */
3860 if(fi_data) {
3861 if(ret->fi_buf) {
3862 bcopy(ret->fi_buf, fi_data, ret->num * sizeof(struct fi_rel_data));
3863 free((char *)ret->fi_buf);
3864 }
3865 }
3866 ret->fi_buf = fi_data;
3867 ret->size = ret->num + fi_num;
3868 }
3869
3870 /* �ƣɴط��ǡ�����¤���������ݤǤ������� */
3871 if(ret->fi_buf == NULL) {
3872 int dummy;
3873 for(i = 0; i < 4 * fi_num; i++) dummy = get4com(server);
3874 js_wnn_errorno_set = WNN_MALLOC_ERR;
3875 return(-1);
3876 }
3877
3878 /* ���ѣƣɴط��ǡ����������� */
3879 fi_data = ret->fi_buf + ret->num;
3880 for(i = 0; i < fi_num; i++, fi_data++) {
3881 fi_data->fi_dic_no = get4com(server);
3882 fi_data->dic_no = get4com(server);
3883 fi_data->entry = get4com(server);
3884 fi_data->offset = get4com(server);
3885 fi_data->fi_hindo = WNN_HINDO_NOP;
3886 fi_data->fi_ima = WNN_IMA_OFF;
3887 }
3888 ret->num = ret->num + fi_num;
3889 return(0);
3890 } /* End of rcv_fi_rel_data */
3891
3892 /**
3893 kantan
3894 **/
3895 int
js_kantan_dai(env,yomi,hinsi,fzk,vec,vec1,rb)3896 js_kantan_dai(env,yomi,hinsi,fzk,vec,vec1,rb)
3897 struct wnn_env *env;
3898 w_char *yomi;
3899 int hinsi;
3900 w_char *fzk;
3901 int vec;
3902 int vec1;
3903 struct wnn_ret_buf *rb;
3904 {
3905 int x;
3906
3907 if(env==0) return(-1);
3908 set_current_js(env->js_id);
3909 LockMutex(&(env_js_lock));
3910 handler_of_jserver_dead_env(env);
3911 if(env_wnn_errorno_eql) {
3912 UnlockMutex(&(env_js_lock));
3913 return(-1);
3914 }
3915 snd_env_head(env,JS_KANTAN_DAI);
3916 putwscom(yomi, env->js_id);
3917 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
3918 snd_flush(env->js_id);
3919 x = rcv_dai(rb, env->js_id);
3920 UnlockMutex(&(env_js_lock));
3921 return x;
3922 }
3923
3924 int
js_kantan_sho(env,yomi,hinsi,fzk,vec,vec1,rb)3925 js_kantan_sho(env,yomi,hinsi,fzk,vec,vec1,rb)
3926 struct wnn_env *env;
3927 w_char *yomi;
3928 int hinsi;
3929 w_char *fzk;
3930 int vec;
3931 int vec1;
3932 struct wnn_ret_buf *rb;
3933 {int sbncnt;
3934 if(env==0) return(-1);
3935 set_current_js(env->js_id);
3936 LockMutex(&(env_js_lock));
3937 handler_of_jserver_dead_env(env);
3938 if(env_wnn_errorno_eql) {
3939 UnlockMutex(&(env_js_lock));
3940 return(-1);
3941 }
3942 snd_env_head(env,JS_KANTAN_SHO);
3943 putwscom(yomi, env->js_id);
3944 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
3945 snd_flush(env->js_id);
3946
3947 sbncnt = rcv_sho(rb, env->js_id);
3948 UnlockMutex(&(env_js_lock));
3949 return sbncnt;
3950 }
3951
3952 /**
3953 kanzen
3954 **/
3955 int
js_kanzen_dai(env,yomi,hinsi,fzk,vec,vec1,rb)3956 js_kanzen_dai(env,yomi,hinsi,fzk,vec,vec1,rb)
3957 struct wnn_env *env;
3958 w_char *yomi;
3959 int hinsi;
3960 w_char *fzk;
3961 int vec;
3962 int vec1;
3963 struct wnn_ret_buf *rb;
3964 {
3965 int x;
3966
3967 if(env==0) return(-1);
3968 set_current_js(env->js_id);
3969 LockMutex(&(env_js_lock));
3970 handler_of_jserver_dead_env(env);
3971 if(env_wnn_errorno_eql) {
3972 UnlockMutex(&(env_js_lock));
3973 return(-1);
3974 }
3975 snd_env_head(env,JS_KANZEN_DAI);
3976 putwscom(yomi, env->js_id);
3977 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
3978 snd_flush(env->js_id);
3979 x = rcv_dai(rb, env->js_id);
3980 UnlockMutex(&(env_js_lock));
3981 return x;
3982 }
3983
3984
3985 int
js_kanzen_sho(env,yomi,hinsi,fzk,vec,vec1,rb)3986 js_kanzen_sho(env,yomi,hinsi,fzk,vec,vec1,rb)
3987 struct wnn_env *env;
3988 w_char *yomi;
3989 int hinsi;
3990 w_char *fzk;
3991 int vec;
3992 int vec1;
3993 struct wnn_ret_buf *rb;
3994 {int sbncnt;
3995 if(env==0) return(-1);
3996 set_current_js(env->js_id);
3997 LockMutex(&(env_js_lock));
3998 handler_of_jserver_dead_env(env);
3999 if(env_wnn_errorno_eql) {
4000 UnlockMutex(&(env_js_lock));
4001 return(-1);
4002 }
4003 snd_env_head(env,JS_KANZEN_SHO);
4004 putwscom(yomi, env->js_id);
4005 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
4006 snd_flush(env->js_id);
4007
4008 sbncnt = rcv_sho(rb, env->js_id);
4009 UnlockMutex(&(env_js_lock));
4010 return sbncnt;
4011 }
4012
4013 /**
4014 henkan with data
4015 **/
4016 int
js_henkan_with_data(env,fuku,nhinsi,hlist,henkan,yomi,hinsi,fzk,vec,vec1,vec2,rb)4017 js_henkan_with_data(env,fuku,nhinsi,hlist,henkan,yomi,hinsi,fzk,vec,vec1,vec2,rb)
4018 struct wnn_env *env;
4019 int fuku, nhinsi, *hlist, henkan;
4020 w_char *yomi;
4021 int hinsi;
4022 w_char *fzk;
4023 int vec;
4024 int vec1;
4025 int vec2;
4026 struct wnn_ret_buf *rb;
4027 {
4028 int x, i, loop = abs(nhinsi);
4029
4030 if(env==0) return(-1);
4031 set_current_js(env->js_id);
4032 LockMutex(&(env_js_lock));
4033 handler_of_jserver_dead_env(env);
4034 if(env_wnn_errorno_eql) {
4035 UnlockMutex(&(env_js_lock));
4036 return(-1);
4037 }
4038 snd_env_head(env,JS_HENKAN_WITH_DATA);
4039 put4com(fuku, env->js_id); /* ʣ���ͥ�� */
4040 put4com(nhinsi, env->js_id); /* �Ѵ������ʻ�� */
4041 for(i = 0; i < loop; i++)
4042 put4com(hlist[i], env->js_id); /* �Ѵ������ʻ��ֹ� */
4043 put4com(henkan, env->js_id); /* �Ѵ����� */
4044 putwscom(yomi, env->js_id);
4045 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
4046 put4com(vec2, env->js_id);
4047 snd_flush(env->js_id);
4048
4049 switch(henkan) {
4050 case WNN_KANREN:
4051 case WNN_KANTAN_DAI:
4052 case WNN_KANZEN_DAI:
4053 x = rcv_dai(rb, env->js_id);
4054 break;
4055 case WNN_KANTAN_SHO:
4056 case WNN_KANZEN_SHO:
4057 x = rcv_sho(rb, env->js_id);
4058 break;
4059 default:
4060 x = get4com(env->js_id);
4061 env_wnn_errorno_set= get4com(env->js_id);
4062 }
4063 UnlockMutex(&(env_js_lock));
4064 return x;
4065 }
4066
4067 /** js_version **/
4068 int
js_version(server,serv,libv)4069 js_version(server,serv,libv)
4070 int *serv,*libv;
4071 WNN_JSERVER_ID *server;
4072 {
4073 set_current_js(server);
4074 LockMutex(&(server_js_lock));
4075 handler_of_jserver_dead(server);
4076 if(js_wnn_errorno_eql) {
4077 UnlockMutex(&(server_js_lock));
4078 return(-1);
4079 }
4080 snd_server_head(server, JS_VERSION);
4081 snd_flush(server);
4082 *libv= JLIB_VERSION;
4083 *serv = get4com(server);
4084 UnlockMutex(&(server_js_lock));
4085 return *serv;
4086 }
4087
4088 static void
re_alloc(ret,size)4089 re_alloc(ret,size)
4090 register struct wnn_ret_buf *ret;
4091 int size;
4092 {
4093 if(ret->size < size){
4094 if(ret->buf)
4095 free((char *)ret->buf);
4096 ret->buf = malloc(size);
4097 ret->size = size;
4098 }
4099 }
4100
4101 int
js_kill(server)4102 js_kill(server)
4103 WNN_JSERVER_ID *server;
4104 {
4105 int x;
4106 set_current_js(server);
4107 LockMutex(&(server_js_lock));
4108 handler_of_jserver_dead(server);
4109 if(js_wnn_errorno_eql) {
4110 UnlockMutex(&(server_js_lock));
4111 return(-1);
4112 }
4113 snd_server_head(server, JS_KILL);
4114 snd_flush(server);
4115 x = get4com(server);
4116 UnlockMutex(&(server_js_lock));
4117 return(x);
4118 }
4119
4120 int
js_file_remove(server,n,pwd)4121 js_file_remove(server, n, pwd)
4122 WNN_JSERVER_ID *server;
4123 char *n, *pwd;
4124 {
4125 register int x;
4126 set_current_js(server);
4127 LockMutex(&(server_js_lock));
4128 handler_of_jserver_dead(server);
4129 if(js_wnn_errorno_eql) {
4130 UnlockMutex(&(server_js_lock));
4131 return(-1);
4132 }
4133 snd_server_head(server,JS_FILE_REMOVE);
4134 putscom(n, server);
4135 putscom(pwd, server);
4136 snd_flush(server);
4137 if((x=get4com(server))==-1){
4138 js_wnn_errorno_set= get4com(server);
4139 UnlockMutex(&(server_js_lock));
4140 return -1;
4141 }
4142 UnlockMutex(&(server_js_lock));
4143 return(x);
4144 }
4145
4146 int
js_file_remove_client(server,n,pwd)4147 js_file_remove_client(server, n, pwd)
4148 WNN_JSERVER_ID *server;
4149 char *n, *pwd;
4150 {
4151 struct wnn_file_head fh;
4152 register FILE *fp;
4153 int is_compressed;
4154
4155 set_current_js(server);
4156 LockMutex(&(server_js_lock));
4157 handler_of_jserver_dead(server);
4158 if(js_wnn_errorno_eql) {
4159 UnlockMutex(&(server_js_lock));
4160 return(-1);
4161 }
4162 if(js_file_loaded_local_body(server, n) != -1){
4163 js_wnn_errorno_set = WNN_FILE_IN_USE;
4164 UnlockMutex(&(server_js_lock));
4165 return(-1);
4166 }
4167 #ifdef WRITE_CHECK
4168 check_backup(n, NULL);
4169 #endif /* WRITE_CHECK */
4170 if((fp=dic_fopen(n,"r", &is_compressed)) == NULL){
4171 js_wnn_errorno_set = WNN_FILE_READ_ERROR;
4172 UnlockMutex(&(server_js_lock));
4173 return(-1);
4174 }
4175 if(input_file_header(fp, &fh, NULL) == -1){
4176 dic_fclose(fp, is_compressed);
4177 UnlockMutex(&(server_js_lock));
4178 return(-1);
4179 }
4180 dic_fclose(fp, is_compressed);
4181 if(!check_pwd(pwd, fh.file_passwd)){
4182 js_wnn_errorno_set = WNN_INCORRECT_PASSWD;
4183 UnlockMutex(&(server_js_lock));
4184 return(-1);
4185 }
4186 if(unlink(n) == -1){
4187 js_wnn_errorno_set = WNN_UNLINK;
4188 UnlockMutex(&(server_js_lock));
4189 return(-1);
4190 }
4191 UnlockMutex(&(server_js_lock));
4192 return(0);
4193 }
4194
4195 /*:::DOC_START
4196 *
4197 * Function Name: js_dic_file_create_client
4198 * Description : ���饤�����¦�˼���ե�������������
4199 * Parameter :
4200 * env : (In) �Ķ��ؤΥݥ���
4201 * fn : (In) ��������ե�����̾
4202 * type : (In) ��������ե����륿����
4203 * com : (In) ��������ե����륳����
4204 * passwd (In) ��������ե�����ѥ����
4205 * hpasswd : (In) �������������٥ѥ����
4206 *
4207 * Return value : 0==SUCCESS, -1==ERROR
4208 *
4209 * Author : Hideyuki Kishiba
4210 *
4211 * Revision history:
4212 *
4213 *:::DOC_END
4214 */
4215 int
js_dic_file_create_client(env,fn,type,com,passwd,hpasswd)4216 js_dic_file_create_client(env, fn, type, com, passwd, hpasswd)
4217 struct wnn_env *env;
4218 int type;
4219 char *fn;
4220 w_char *com;
4221 char *passwd, *hpasswd;
4222 {
4223 int x, js_jishonum;
4224
4225 if(env==0) return(-1);
4226 LockMutex(&(env_js_lock));
4227 /*
4228 * Hideyuki Kishiba (Jul. 7, 1994)
4229 * �ƣɴط��������롼�����ޡ�������κ����������ɲ�
4230 */
4231 if(type != WNN_REV_DICT &&
4232 type != CWNN_REV_DICT &&
4233 type != BWNN_REV_DICT &&
4234 type != WNN_UD_DICT &&
4235 type != WNN_FI_USER_DICT &&
4236 type != WNN_GROUP_DICT &&
4237 type != WNN_MERGE_DICT){
4238 env_wnn_errorno_set = WNN_NOT_A_UD;
4239 UnlockMutex(&(env_js_lock));
4240 return(-1);
4241 }
4242 if(type == WNN_FI_USER_DICT) { /* �ƣɴط���������ؿ���Ƥ� */
4243 int i, j;
4244 unsigned char njisho;
4245 struct wnn_file_uniq duniq[WNN_MAX_JISHO_OF_AN_ENV];
4246 int dprimary[WNN_MAX_JISHO_OF_AN_ENV];
4247
4248 /* ��³�����������primary index table��file uniq�ˤμ������ */
4249 set_current_js(env->js_id);
4250 handler_of_jserver_dead_env(env);
4251 if(env_wnn_errorno_eql) {
4252 UnlockMutex(&(env_js_lock));
4253 return(-1);
4254 }
4255 snd_env_head(env, JS_DIC_FILE_CREATE_CLIENT);
4256 snd_flush(env->js_id);
4257 x = get4com(env->js_id);
4258 if(x == -1) {
4259 env_wnn_errorno_set = get4com(env->js_id);
4260 UnlockMutex(&(env_js_lock));
4261 return(-1);
4262 }
4263 js_jishonum = get1com(env->js_id); /* ��³�������� */
4264 if (js_jishonum > WNN_MAX_JISHO_OF_AN_ENV)
4265 njisho = WNN_MAX_JISHO_OF_AN_ENV;
4266 else
4267 njisho = js_jishonum;
4268 for(i = 0; i < njisho; i++) {
4269 /* ��³������� file uniq */
4270 duniq[i].time = get4com(env->js_id);
4271 duniq[i].dev = get4com(env->js_id);
4272 duniq[i].inode = get4com(env->js_id);
4273 for(j = 0; j < WNN_HOSTLEN; j++){
4274 duniq[i].createhost[j] = get1com(env->js_id);
4275 }
4276 /* ��³���������Ͽ���ÿ� */
4277 dprimary[i] = get4com(env->js_id);
4278 }
4279 if (js_jishonum > WNN_MAX_JISHO_OF_AN_ENV) {
4280 js_jishonum -= WNN_MAX_JISHO_OF_AN_ENV;
4281 for(i = 0; i < js_jishonum; i++) {
4282 get4com(env->js_id);
4283 get4com(env->js_id);
4284 get4com(env->js_id);
4285 for(j = 0; j < WNN_HOSTLEN; j++){
4286 get1com(env->js_id);
4287 }
4288 get4com(env->js_id);
4289 }
4290 }
4291 x = create_null_fi_dic(fn, com, passwd, hpasswd, type, njisho, duniq, dprimary, NULL);
4292
4293 } else /* �ף�������ؿ���Ƥ� */
4294 x = create_null_dic(fn,com, passwd, hpasswd, type, NULL);
4295
4296 if(x == -1){
4297 env_wnn_errorno_set = WNN_FILE_CREATE_ERROR;
4298 UnlockMutex(&(env_js_lock));
4299 return(-1);
4300 }
4301 UnlockMutex(&(env_js_lock));
4302 return(0);
4303 } /* End of js_dic_file_create_client */
4304
4305
4306 /** js_hindo_file_create_client **/
4307 int
js_hindo_file_create_client(env,fid,fn,com,hpasswd)4308 js_hindo_file_create_client(env,fid,fn,com,hpasswd)
4309 struct wnn_env *env;
4310 int fid;
4311 char *fn;
4312 w_char *com;
4313 char *hpasswd;
4314 {
4315 register int x;
4316 struct wnn_file_uniq funiq;
4317 int serial;
4318 register int i;
4319
4320 if(env==0) return(-1);
4321 set_current_js(env->js_id);
4322 LockMutex(&(env_js_lock));
4323 handler_of_jserver_dead_env(env);
4324 if(env_wnn_errorno_eql) {
4325 UnlockMutex(&(env_js_lock));
4326 return(-1);
4327 }
4328 snd_env_head(env,JS_HINDO_FILE_CREATE_CLIENT);
4329 put4com(fid, env->js_id);
4330 snd_flush(env->js_id);
4331 x = get4com(env->js_id);
4332 if(x == -1){
4333 env_wnn_errorno_set = get4com(env->js_id);
4334 UnlockMutex(&(env_js_lock));
4335 return(-1);
4336 }
4337 serial = get4com(env->js_id);
4338 funiq.time = get4com(env->js_id);
4339 funiq.dev = get4com(env->js_id);
4340 funiq.inode = get4com(env->js_id);
4341 for(i=0;i<WNN_HOSTLEN;i++){
4342 funiq.createhost[i]=get1com(env->js_id);
4343 }
4344 if(create_hindo_file(&funiq,fn,com,hpasswd,serial, NULL, NULL) == -1){
4345 env_wnn_errorno_set = WNN_FILE_CREATE_ERROR;
4346 UnlockMutex(&(env_js_lock));
4347 return(-1);
4348 }
4349 UnlockMutex(&(env_js_lock));
4350 return(0);
4351 }
4352
4353 /*:::DOC_START
4354 *
4355 * Function Name: js_fi_hindo_file_create_client
4356 * Description : ���饤�����¦�ˣƣɴط����٥ե�������������
4357 * Parameter :
4358 * env : (In) �Ķ��ؤΥݥ���
4359 * fid : (In) �б��ƣɴط�����ե�����ɣ�
4360 * fn : (In) �ƣɴط����٥ե�����̾
4361 * com : (In) �ƣɴط����٥ե����륳����
4362 * hpasswd : (In) �ƣɴط����٥ե�����ѥ����
4363 *
4364 * Return value : 0==SUCCESS, -1==ERROR
4365 *
4366 * Author : Hideyuki Kishiba
4367 *
4368 * Revision history:
4369 *
4370 *:::DOC_END
4371 */
4372 int
js_fi_hindo_file_create_client(env,fid,fn,com,hpasswd)4373 js_fi_hindo_file_create_client(env, fid, fn, com, hpasswd)
4374 struct wnn_env *env;
4375 int fid;
4376 char *fn;
4377 w_char *com;
4378 char *hpasswd;
4379 {
4380 register int x;
4381 struct wnn_file_uniq funiq;
4382 unsigned char njisho;
4383 int *primary;
4384 register int i;
4385
4386 if(env==0) return(-1);
4387 set_current_js(env->js_id);
4388 LockMutex(&(env_js_lock));
4389 handler_of_jserver_dead_env(env);
4390 if(env_wnn_errorno_eql) {
4391 UnlockMutex(&(env_js_lock));
4392 return(-1);
4393 }
4394 snd_env_head(env,JS_FI_HINDO_FILE_CREATE_CLIENT);
4395 put4com(fid, env->js_id);
4396 snd_flush(env->js_id);
4397 x = get4com(env->js_id);
4398 if(x == -1){
4399 env_wnn_errorno_set = get4com(env->js_id);
4400 UnlockMutex(&(env_js_lock));
4401 return(-1);
4402 }
4403 funiq.time = get4com(env->js_id);
4404 funiq.dev = get4com(env->js_id);
4405 funiq.inode = get4com(env->js_id);
4406 for(i=0;i<WNN_HOSTLEN;i++){
4407 funiq.createhost[i]=get1com(env->js_id);
4408 }
4409 njisho = get1com(env->js_id);
4410 if((primary = (int *)malloc(njisho * sizeof(int))) == NULL) {
4411 env_wnn_errorno_set = WNN_MALLOC_ERR;
4412 UnlockMutex(&(env_js_lock));
4413 return(-1);
4414 }
4415 for(i = 0; i < njisho; i++)
4416 primary[i] = get4com(env->js_id);
4417 if(create_fi_hindo_file(&funiq,fn,com,hpasswd,njisho,primary,NULL) == -1){
4418 free(primary);
4419 env_wnn_errorno_set = WNN_FILE_CREATE_ERROR;
4420 UnlockMutex(&(env_js_lock));
4421 return(-1);
4422 }
4423 free(primary);
4424 UnlockMutex(&(env_js_lock));
4425 return(0);
4426 } /* End of js_fi_hindo_file_create_client */
4427
4428 int
js_file_comment_set(env,fid,comment)4429 js_file_comment_set(env, fid, comment)
4430 struct wnn_env *env;
4431 int fid;
4432 w_char *comment;
4433 {
4434 register int x;
4435 if(env==0) return(-1);
4436 set_current_js(env->js_id);
4437 LockMutex(&(env_js_lock));
4438 handler_of_jserver_dead_env(env);
4439 if(env_wnn_errorno_eql) {
4440 UnlockMutex(&(env_js_lock));
4441 return(-1);
4442 }
4443 snd_env_head(env,JS_FILE_COMMENT_SET);
4444 put4com(fid, env->js_id);
4445 putwscom(comment, env->js_id);
4446 snd_flush(env->js_id);
4447 x=get4com(env->js_id);
4448 if(x==-1){
4449 env_wnn_errorno_set= get4com(env->js_id);
4450 UnlockMutex(&(env_js_lock));
4451 return(-1);
4452 }
4453 UnlockMutex(&(env_js_lock));
4454 return(0);
4455 }
4456
4457 /*
4458 * Hinsi Primitives
4459 */
4460
4461 int
js_hinsi_name(server,no,rb)4462 js_hinsi_name(server, no, rb)
4463 WNN_JSERVER_ID *server;
4464 int no;
4465 struct wnn_ret_buf *rb;
4466 {
4467 register int size;
4468
4469 set_current_js(server);
4470 LockMutex(&(server_js_lock));
4471 handler_of_jserver_dead(server);
4472 if(js_wnn_errorno_eql) {
4473 UnlockMutex(&(server_js_lock));
4474 return(-1);
4475 }
4476 snd_server_head(server,JS_HINSI_NAME);
4477 put4com(no, server);
4478 snd_flush(server);
4479 if((size = get4com(server)) == -1){
4480 js_wnn_errorno_set = get4com(server);
4481 UnlockMutex(&(server_js_lock));
4482 return(-1);
4483 }
4484 re_alloc(rb,sizeof(w_char)*(size + 1));
4485 getwscom((w_char *)rb->buf, server, size + 1);
4486 UnlockMutex(&(server_js_lock));
4487 return(0);
4488 }
4489
4490
4491 int
js_hinsi_number(server,name)4492 js_hinsi_number(server, name)
4493 WNN_JSERVER_ID *server;
4494 w_char *name;
4495 {
4496 register int no;
4497
4498 set_current_js(server);
4499 LockMutex(&(server_js_lock));
4500 handler_of_jserver_dead(server);
4501 if(js_wnn_errorno_eql) {
4502 UnlockMutex(&(server_js_lock));
4503 return(-1);
4504 }
4505 snd_server_head(server,JS_HINSI_NUMBER);
4506 putwscom(name, server);
4507 snd_flush(server);
4508 if((no = get4com(server)) == -1){
4509 js_wnn_errorno_set = get4com(server);
4510 UnlockMutex(&(server_js_lock));
4511 return(-1);
4512 }
4513 UnlockMutex(&(server_js_lock));
4514 return(no);
4515 }
4516
4517 int
js_hinsi_list(env,dic_no,name,rb)4518 js_hinsi_list(env, dic_no, name, rb)
4519 struct wnn_env *env;
4520 int dic_no;
4521 w_char *name;
4522 struct wnn_ret_buf *rb;
4523 {
4524 int wtotal;
4525 int count;
4526 register w_char *s;
4527 register w_char **r;
4528 register int k, wlen, error_flag;
4529 w_char wbuf[LENGTHKANJI];
4530
4531 if(env==0) return(-1);
4532 set_current_js(env->js_id);
4533 LockMutex(&(env_js_lock));
4534 handler_of_jserver_dead_env(env);
4535 if(env_wnn_errorno_eql) {
4536 UnlockMutex(&(env_js_lock));
4537 return(-1);
4538 }
4539 snd_env_head(env,JS_HINSI_LIST);
4540 put4com(dic_no, env->js_id);
4541 putwscom(name, env->js_id);
4542 snd_flush(env->js_id);
4543 if((count = get4com(env->js_id)) == -1){
4544 env_wnn_errorno_set = get4com(env->js_id);
4545 UnlockMutex(&(env_js_lock));
4546 return(-1);
4547 }
4548 wtotal = get4com(env->js_id);
4549 wtotal += 1;
4550 re_alloc(rb,sizeof(w_char)*(wtotal) + count * sizeof(w_char *) );
4551 r = (w_char **)rb->buf;
4552 s = (w_char *)((w_char **)rb->buf + count);
4553 error_flag = 0;
4554 for(k = 0 ; k < count ; k++){
4555 getwscom(wbuf, env->js_id, sizeof(wbuf) / sizeof(w_char));
4556 if (!error_flag) {
4557 wlen = wnn_Strlen(wbuf) + 1;
4558 if (wlen > wtotal) {
4559 error_flag = 1;
4560 } else {
4561 *r++ = s;
4562 wnn_Strcpy(s, wbuf);
4563 s += wlen;
4564 wtotal -= wlen;
4565 }
4566 }
4567 }
4568 UnlockMutex(&(env_js_lock));
4569 return(count);
4570 }
4571
4572 int
js_hinsi_dicts(env,no,rb)4573 js_hinsi_dicts(env, no, rb)
4574 struct wnn_env *env;
4575 int no;
4576 struct wnn_ret_buf *rb;
4577 {
4578 register int k, count;
4579 int *p;
4580
4581 if(env==0) return(-1);
4582 set_current_js(env->js_id);
4583 LockMutex(&(env_js_lock));
4584 handler_of_jserver_dead_env(env);
4585 if(env_wnn_errorno_eql) {
4586 UnlockMutex(&(env_js_lock));
4587 return(-1);
4588 }
4589 snd_env_head(env,JS_HINSI_DICTS);
4590 put4com(no, env->js_id);
4591 snd_flush(env->js_id);
4592 if((count = get4com(env->js_id)) == -1){
4593 env_wnn_errorno_set = get4com(env->js_id);
4594 UnlockMutex(&(env_js_lock));
4595 return(-1);
4596 }
4597 re_alloc(rb,sizeof(int) * (count + 1));
4598 p = (int *)rb->buf;
4599
4600 for(k = 0 ; k < count ; k++){
4601 *p++ = get4com(env->js_id);
4602 }
4603 UnlockMutex(&(env_js_lock));
4604 return(count);
4605 }
4606
4607
4608 char *wnn_dic_types[] = {"","����","��Ͽ","�հ�","����","����","FI����","FI�桼��","FI����","���롼��","�ޡ���"};
4609
4610 char *cwnn_dic_types[] = {"","�̶�","��¼","ƴ��","����"};
4611 char *bwnn_dic_types[] = {"","�̶�","��¼","����","����"};
4612
4613 char *kwnn_dic_types[] = {"","����","���","����","����"};
4614 /* ͳ�� ���� ��� ��Ю */
4615
4616
4617 /* New primitives 9/8 */
4618
4619 int
js_file_password_set(env,fid,which,old,new)4620 js_file_password_set(env, fid, which, old, new)
4621 struct wnn_env *env;
4622 int fid;
4623 int which; /* 1 for dic, 2 for hindo 3(0) for both*/
4624 char *old, *new;
4625 {
4626 register int x;
4627 if(env==0) return(-1);
4628 set_current_js(env->js_id);
4629 LockMutex(&(env_js_lock));
4630 handler_of_jserver_dead_env(env);
4631 if(env_wnn_errorno_eql) {
4632 UnlockMutex(&(env_js_lock));
4633 return(-1);
4634 }
4635 snd_env_head(env,JS_FILE_PASSWORD_SET);
4636 put4com(fid, env->js_id);
4637 put4com(which, env->js_id);
4638 putscom(old, env->js_id);
4639 putscom(new, env->js_id);
4640 snd_flush(env->js_id);
4641 x=get4com(env->js_id);
4642 if(x==-1){
4643 env_wnn_errorno_set= get4com(env->js_id);
4644 UnlockMutex(&(env_js_lock));
4645 return(-1);
4646 }
4647 UnlockMutex(&(env_js_lock));
4648 return(0);
4649 }
4650
4651 int
js_hinsi_table_set(env,dic_no,hinsi_table)4652 js_hinsi_table_set(env, dic_no, hinsi_table)
4653 struct wnn_env *env;
4654 int dic_no;
4655 w_char *hinsi_table;
4656 {
4657 int x;
4658 if(env==0) return(-1);
4659 set_current_js(env->js_id);
4660 LockMutex(&(env_js_lock));
4661 handler_of_jserver_dead_env(env);
4662 if(env_wnn_errorno_eql) {
4663 UnlockMutex(&(env_js_lock));
4664 return(-1);
4665 }
4666 snd_env_head(env,JS_HINSI_TABLE_SET);
4667 put4com(dic_no, env->js_id);
4668 putwscom(hinsi_table, env->js_id);
4669 snd_flush(env->js_id);
4670 x=get4com(env->js_id);
4671 if(x==-1){
4672 env_wnn_errorno_set= get4com(env->js_id);
4673 UnlockMutex(&(env_js_lock));
4674 return(-1);
4675 }
4676 UnlockMutex(&(env_js_lock));
4677 return(0);
4678 }
4679
4680 /* Start of packets in 4004 */
4681 int
js_open_extension(server,ext_name)4682 js_open_extension(server, ext_name)
4683 WNN_JSERVER_ID *server;
4684 char *ext_name;
4685 {
4686 register wnn_extension_set *p;
4687
4688 if (!ext_name || !*ext_name) {
4689 js_wnn_errorno_set = WNN_NOT_SUPPORT_EXTENSION;
4690 return(-1);
4691 }
4692 for (p = ((WNN_JSERVER_ID_INT *)server)->extensions;
4693 p && p->id && p->name; p++) {
4694 if (!strcmp(p->name, ext_name)) {
4695 return(p->id);
4696 }
4697 }
4698 js_wnn_errorno_set = WNN_NOT_SUPPORT_EXTENSION;
4699 return(0);
4700 }
4701
4702 int
js_get_extension(server,ret)4703 js_get_extension(server, ret)
4704 WNN_JSERVER_ID *server;
4705 char ***ret;
4706 {
4707 register wnn_extension_set *p;
4708 register char *s, **l;
4709 int total = 0, num = 0;
4710
4711 if (!((WNN_JSERVER_ID_INT *)server)->extensions) {
4712 js_wnn_errorno_set = WNN_NOT_SUPPORT_PACKET;
4713 return(-1);
4714 }
4715 for (p = ((WNN_JSERVER_ID_INT *)server)->extensions;
4716 p && p->id && p->name; p++) {
4717 total += strlen(p->name) + 1;
4718 num++;
4719 }
4720 if (num == 0) return(0);
4721 if (!(l = (char **)(s = malloc((sizeof(char *) * num) + total)))) {
4722 js_wnn_errorno_set = WNN_MALLOC_ERR;
4723 return(-1);
4724 }
4725 *ret = l;
4726 s += sizeof(char *) * num;
4727 for (p = ((WNN_JSERVER_ID_INT *)server)->extensions;
4728 p && p->id && p->name; p++) {
4729 *l++ = s;
4730 strcpy(s, p->name);
4731 s += strlen(s) + 1;
4732 }
4733 return(num);
4734 }
4735
4736
4737 static int
access_host_core(server,ha,enable,ule)4738 access_host_core(server, ha, enable, ule)
4739 WNN_JSERVER_ID *server;
4740 host_address *ha;
4741 int enable, ule;
4742 {
4743 register int x;
4744 register char *p;
4745
4746 handler_of_jserver_dead(server);
4747 if (js_wnn_errorno_eql) return(-1);
4748 if (enable) {
4749 snd_server_head(server, JS_ACCESS_ADD_HOST);
4750 put4com(ule, server);
4751 } else {
4752 snd_server_head(server, JS_ACCESS_REMOVE_HOST);
4753 }
4754 put4com(ha->address_len, server);
4755 p = ha->address;
4756 for (x = 0; x < ha->address_len; x++) put1com(*p++, server);
4757 snd_flush(server);
4758 x=get4com(server);
4759 if(x==-1){
4760 js_wnn_errorno_set= get4com(server);
4761 return(-1);
4762 }
4763 return(x);
4764 }
4765
4766 static int
access_host(server,host,enable,ule)4767 access_host(server, host, enable, ule)
4768 WNN_JSERVER_ID *server;
4769 char *host;
4770 int enable, ule;
4771 {
4772 struct hostent *hp;
4773 struct in_addr addr;
4774 host_address ha;
4775 char **l;
4776 int x;
4777
4778 if ((addr.s_addr = inet_addr(host)) != -1) {
4779 ha.address = (char *)&addr.s_addr;
4780 ha.address_len = sizeof(addr.s_addr);
4781 x = access_host_core(server, &ha, enable, ule);
4782 return(x);
4783 } else if ((hp = gethostbyname(host)) && hp->h_addrtype == AF_INET) {
4784 ha.address_len = sizeof(addr.s_addr);
4785 for (l = hp->h_addr_list; *l; l++) {
4786 ha.address = *l;
4787 if ((x = access_host_core(server, &ha, enable, ule)) == -1) {
4788 return(-1);
4789 }
4790 }
4791 return(0);
4792 } else {
4793 js_wnn_errorno_set = WNN_ACCESS_NO_HOST;
4794 return(-1);
4795 }
4796 }
4797
4798 int
js_access_add_host(server,host,ule)4799 js_access_add_host(server, host, ule)
4800 WNN_JSERVER_ID *server;
4801 char *host;
4802 int ule;
4803 {
4804 int x;
4805
4806 set_current_js(server);
4807 LockMutex(&(server_js_lock));
4808 x = access_host(server, host, 1, ule);
4809 UnlockMutex(&(server_js_lock));
4810 return(x);
4811 }
4812
4813 int
js_access_remove_host(server,host)4814 js_access_remove_host(server, host)
4815 WNN_JSERVER_ID *server;
4816 char *host;
4817 {
4818 int x;
4819
4820 set_current_js(server);
4821 LockMutex(&(server_js_lock));
4822 x = access_host(server, host, 0, 0);
4823 UnlockMutex(&(server_js_lock));
4824 return(x);
4825 }
4826
4827 static int
access_user_core(server,ha,user,enable)4828 access_user_core(server, ha, user, enable)
4829 WNN_JSERVER_ID *server;
4830 host_address *ha;
4831 char *user;
4832 int enable;
4833 {
4834 register int x;
4835 register char *p;
4836
4837 handler_of_jserver_dead(server);
4838 if (js_wnn_errorno_eql) return(-1);
4839 if (enable) {
4840 snd_server_head(server, JS_ACCESS_ADD_USER);
4841 } else {
4842 snd_server_head(server, JS_ACCESS_REMOVE_USER);
4843 }
4844 put4com(ha->address_len, server);
4845 p = ha->address;
4846 for (x = 0; x < ha->address_len; x++) put1com(*p++, server);
4847 putscom(user, server);
4848 snd_flush(server);
4849 x=get4com(server);
4850 if(x==-1){
4851 js_wnn_errorno_set= get4com(server);
4852 return(-1);
4853 }
4854 return(x);
4855 }
4856
4857 static int
access_user(server,host,user,enable)4858 access_user(server, host, user, enable)
4859 WNN_JSERVER_ID *server;
4860 char *host, *user;
4861 int enable;
4862 {
4863 struct hostent *hp;
4864 struct in_addr addr;
4865 host_address ha;
4866 char **l;
4867 int x;
4868
4869 if (!host || !*host) {
4870 ha.address = NULL;
4871 ha.address_len = 0;
4872 x = access_user_core(server, &ha, user, enable);
4873 return(x);
4874 } else if ((addr.s_addr = inet_addr(host)) != -1) {
4875 ha.address = (char *)&addr.s_addr;
4876 ha.address_len = sizeof(addr.s_addr);
4877 x = access_user_core(server, &ha, user, enable);
4878 return(x);
4879 } else if ((hp = gethostbyname(host)) && hp->h_addrtype == AF_INET) {
4880 ha.address_len = sizeof(addr.s_addr);
4881 for (l = hp->h_addr_list; *l; l++) {
4882 ha.address = *l;
4883 if ((x = access_user_core(server, &ha, user, enable)) == -1) {
4884 return(-1);
4885 }
4886 }
4887 return(0);
4888 } else {
4889 js_wnn_errorno_set = WNN_ACCESS_NO_USER;
4890 return(-1);
4891 }
4892 }
4893
4894 int
js_access_add_user(server,host,user)4895 js_access_add_user(server, host, user)
4896 WNN_JSERVER_ID *server;
4897 char *host, *user;
4898 {
4899 int x;
4900
4901 set_current_js(server);
4902 LockMutex(&(server_js_lock));
4903 x = access_user(server, host, user, 1);
4904 UnlockMutex(&(server_js_lock));
4905 return(x);
4906 }
4907
4908 int
js_access_remove_user(server,host,user)4909 js_access_remove_user(server, host, user)
4910 WNN_JSERVER_ID *server;
4911 char *host, *user;
4912 {
4913 int x;
4914
4915 set_current_js(server);
4916 LockMutex(&(server_js_lock));
4917 x = access_user(server, host, user, 0);
4918 UnlockMutex(&(server_js_lock));
4919 return(x);
4920 }
4921
4922 static int
access_control(server,enable)4923 access_control(server, enable)
4924 WNN_JSERVER_ID *server;
4925 int enable;
4926 {
4927 int x;
4928
4929 handler_of_jserver_dead(server);
4930 if (js_wnn_errorno_eql) return(-1);
4931 if (enable) {
4932 snd_server_head(server, JS_ACCESS_ENABLE);
4933 } else {
4934 snd_server_head(server, JS_ACCESS_DISABLE);
4935 }
4936 snd_flush(server);
4937 x=get4com(server);
4938 if(x==-1){
4939 js_wnn_errorno_set= get4com(server);
4940 return(-1);
4941 }
4942 return(x);
4943 }
4944
4945 int
js_access_enable(server)4946 js_access_enable(server)
4947 WNN_JSERVER_ID *server;
4948 {
4949 int x;
4950
4951 set_current_js(server);
4952 LockMutex(&(server_js_lock));
4953 x = access_control(server, 1);
4954 UnlockMutex(&(server_js_lock));
4955 return(x);
4956 }
4957
4958 int
js_access_disable(server)4959 js_access_disable(server)
4960 WNN_JSERVER_ID *server;
4961 {
4962 int x;
4963
4964 set_current_js(server);
4965 LockMutex(&(server_js_lock));
4966 x = access_control(server, 0);
4967 UnlockMutex(&(server_js_lock));
4968 return(x);
4969 }
4970
4971 static int
get_host_name_len(host_p)4972 get_host_name_len(host_p)
4973 host_address *host_p;
4974 {
4975 char *p;
4976 register struct hostent *hp;
4977 int user_len = 0;
4978 char address[32];
4979 char *inet_ntoa();
4980
4981 if ((p = strchr(host_p->address, ':'))) {
4982 user_len = strlen(p);
4983 }
4984
4985 bcopy((char *)host_p->address, address, host_p->address_len);
4986 if ((hp = gethostbyaddr (address, host_p->address_len, AF_INET))) {
4987 return(strlen(hp->h_name) + user_len);
4988 }
4989 if (!(p = inet_ntoa(*((struct in_addr *)(address))))) return(0);
4990 return(strlen(p) + user_len);
4991 }
4992
4993 static int
get_host_name(host_p,host)4994 get_host_name(host_p, host)
4995 host_address *host_p;
4996 char *host;
4997 {
4998 char *p, *user;
4999 register struct hostent *hp;
5000 int user_len = 0;
5001 char address[32];
5002 char *inet_ntoa();
5003
5004 if ((user = strchr(host_p->address, ':'))) {
5005 user_len = strlen(user);
5006 }
5007
5008 bcopy((char *)host_p->address, address, host_p->address_len);
5009 if ((hp = gethostbyaddr (address, host_p->address_len, AF_INET))) {
5010 strcpy(host, hp->h_name);
5011 if (user) strcat(host, user);
5012 return(strlen(host));
5013 }
5014 if (!(p = inet_ntoa(*((struct in_addr *)(address))))) return(0);
5015 strcpy(host, p);
5016 if (user) strcat(host, user);
5017 return(strlen(host));
5018 }
5019
5020 char **
js_access_get_info(server,enable,ret_num)5021 js_access_get_info(server, enable, ret_num)
5022 WNN_JSERVER_ID *server;
5023 int *enable;
5024 int *ret_num;
5025 {
5026 int i, j, host_num, except_num, total_num, bytes, total, error_flag;
5027 register char *p, **out, *save, **out_save;
5028 host_address *host_p;
5029 char dummy[1024];
5030
5031 *ret_num = -1;
5032 set_current_js(server);
5033 LockMutex(&(server_js_lock));
5034 handler_of_jserver_dead(server);
5035 if (js_wnn_errorno_eql) {
5036 UnlockMutex(&(server_js_lock));
5037 return(NULL);
5038 }
5039 snd_server_head(server, JS_ACCESS_GET_INFO);
5040 snd_flush(server);
5041 *enable = get4com(server);
5042 if(*enable == -1){
5043 js_wnn_errorno_set= get4com(server);
5044 UnlockMutex(&(server_js_lock));
5045 return((char **)NULL);
5046 }
5047 bytes = get4com(server);
5048 host_num = get4com(server);
5049 except_num = get4com(server);
5050 total_num = host_num + except_num;
5051 if (total_num == 0) {
5052 *ret_num = 0;
5053 UnlockMutex(&(server_js_lock));
5054 return((char **)NULL);
5055 }
5056 if (!(save = p = malloc((sizeof(host_address) * total_num) + bytes))) {
5057 for (i = 0; i < bytes; i++) get1com(server);
5058 js_wnn_errorno_set = WNN_MALLOC_ERR;
5059 return((char **)NULL);
5060 }
5061 host_p = (host_address *)p;
5062 p += sizeof(host_address) * total_num;
5063 error_flag = 0;
5064 for (i = 0; i < host_num; i++, host_p++) {
5065 host_p->address_len = get4com(server);
5066 if ((host_p->address_len >= bytes) || (bytes <= 0) || error_flag) {
5067 error_flag = 1;
5068 for (j = 0; j < host_p->address_len; j++) get1com(server);
5069 if (get4com(server))
5070 getscom(dummy, server, sizeof(dummy));
5071 } else {
5072 for (j = 0; j < host_p->address_len; j++) p[j] = get1com(server);
5073 host_p->address = p;
5074 p += host_p->address_len;
5075 bytes -= host_p->address_len;
5076 if (get4com(server)) {
5077 *p++ = ':';
5078 bytes--;
5079 getscom(p, server, bytes);
5080 if (bytes > 0) {
5081 p += strlen(p) + 1;
5082 bytes -= strlen(p) + 1;
5083 }
5084 } else {
5085 *p++ = '\0';
5086 bytes--;
5087 }
5088 }
5089 }
5090 for (i = 0; i < except_num; i++, host_p++) {
5091 if ((bytes <= 0) || error_flag) {
5092 error_flag = 1;
5093 getscom(dummy, server, sizeof(dummy));
5094 } else {
5095 host_p->address = p;
5096 *p++ = '@';
5097 bytes--;
5098 getscom(p, server, bytes);
5099 if (bytes > 0) {
5100 p += strlen(p) + 1;
5101 bytes -= strlen(p) + 1;
5102 host_p->address_len = strlen(host_p->address);
5103 }
5104 }
5105 }
5106 if (error_flag) {
5107 free((char *)save);
5108 js_wnn_errorno_set = WNN_SOME_ERROR;
5109 UnlockMutex(&(server_js_lock));
5110 return((char **)NULL);
5111 }
5112 for (host_p = (host_address *)save, total = 0, i = 0;
5113 i < total_num; i++, host_p++) {
5114 if (host_p->address_len > 0 && host_p->address[0] == '@')
5115 total += strlen(host_p->address); /* exceptional user name */
5116 else
5117 total += get_host_name_len(host_p);
5118 }
5119 if (!(p = malloc((sizeof(char *) * total_num) + total + total_num))) {
5120 free((char *)save);
5121 js_wnn_errorno_set = WNN_MALLOC_ERR;
5122 UnlockMutex(&(server_js_lock));
5123 return((char **)NULL);
5124 }
5125 out = out_save = (char **)p;
5126 p += (sizeof(char *) * total_num);
5127 for (host_p = (host_address *)save, i = 0; i < total_num; i++, host_p++) {
5128 *out++ = p;
5129 if (host_p->address_len > 0 && host_p->address[0] == '@') {
5130 strcpy(p, host_p->address) /* exceptional user name */;
5131 p += strlen(host_p->address) + 1;
5132 } else
5133 p += get_host_name(host_p, p) + 1;
5134 }
5135 free((char *)save);
5136 *ret_num = total_num;
5137 UnlockMutex(&(server_js_lock));
5138 return(out_save);
5139 }
5140
5141 /*:::DOC_START
5142 *
5143 * Function Name: js_is_loaded_temporary_dic
5144 * Description :
5145 * �ƥ�ݥ�꼭���Ķ��ˤ��뤫�ɤ�����Ĵ�٤�
5146 * Parameter :
5147 * env : (In) �Ķ��ؤΥݥ���
5148 *
5149 * Return value : 1==EXIST, 0==NO EXIST, -1==ERROR
5150 *
5151 * Author : Seiji KUWARI
5152 *
5153 * Revision history:
5154 *
5155 *:::DOC_END
5156 */
5157 int
js_is_loaded_temporary_dic(env)5158 js_is_loaded_temporary_dic(env)
5159 struct wnn_env *env;
5160 {
5161 register int x = 0;
5162
5163 if(!env) return(-1);
5164 set_current_js(env->js_id);
5165 LockMutex(&(env_js_lock));
5166 handler_of_jserver_dead_env(env);
5167 if(env_wnn_errorno_eql) {
5168 UnlockMutex(&(env_js_lock));
5169 return(-1);
5170 }
5171 snd_env_head(env,JS_IS_LOADED_TEMPORARY_DIC);
5172 snd_flush(env->js_id);
5173 x=get4com(env->js_id);
5174 if (x == -1) {
5175 wnn_errorno = get4com(env->js_id);
5176 }
5177 UnlockMutex(&(env_js_lock));
5178 return x;
5179 }
5180
5181 /*:::DOC_START
5182 *
5183 * Function Name: js_temporary_dic_delete
5184 * Description :
5185 * �ƥ�ݥ�꼭���Ķ����ɲä���
5186 * Parameter :
5187 * env : (In) �Ķ��ؤΥݥ���
5188 *
5189 * Return value : 0==SUCCESS, -1==ERROR
5190 *
5191 * Author : Seiji KUWARI
5192 *
5193 * Revision history:
5194 *
5195 *:::DOC_END
5196 */
5197 int
js_temporary_dic_add(env,rev)5198 js_temporary_dic_add(env, rev)
5199 struct wnn_env *env;
5200 int rev;
5201 {
5202 register int x = 0;
5203
5204 if(!env) return(-1);
5205 set_current_js(env->js_id);
5206 LockMutex(&(env_js_lock));
5207 handler_of_jserver_dead_env(env);
5208 if(env_wnn_errorno_eql) {
5209 UnlockMutex(&(env_js_lock));
5210 return(-1);
5211 }
5212 snd_env_head(env,JS_TEMPORARY_DIC_ADD);
5213 put4com(rev, env->js_id);
5214 snd_flush(env->js_id);
5215 x=get4com(env->js_id);
5216 if (x == -1) wnn_errorno = get4com(env->js_id);
5217 UnlockMutex(&(env_js_lock));
5218 return x;
5219 }
5220
5221 /*:::DOC_START
5222 *
5223 * Function Name: js_temporary_dic_delete
5224 * Description :
5225 * �ƥ�ݥ�꼭���Ķ�����������
5226 * Parameter :
5227 * env : (In) �Ķ��ؤΥݥ���
5228 *
5229 * Return value : 0==SUCCESS, -1==ERROR
5230 *
5231 * Author : Seiji KUWARI
5232 *
5233 * Revision history:
5234 *
5235 *:::DOC_END
5236 */
5237 int
js_temporary_dic_delete(env)5238 js_temporary_dic_delete(env)
5239 struct wnn_env *env;
5240 {
5241 register int x;
5242
5243 if(!env) return(-1);
5244 set_current_js(env->js_id);
5245 LockMutex(&(env_js_lock));
5246 handler_of_jserver_dead_env(env);
5247 if(env_wnn_errorno_eql) {
5248 UnlockMutex(&(env_js_lock));
5249 return(-1);
5250 }
5251 snd_env_head(env,JS_TEMPORARY_DIC_DELETE);
5252 snd_flush(env->js_id);
5253 x=get4com(env->js_id);
5254 if (x == -1) wnn_errorno = get4com(env->js_id);
5255 UnlockMutex(&(env_js_lock));
5256 return x;
5257 }
5258
5259 /*:::DOC_START
5260 *
5261 * Function Name: js_temporary_word_add
5262 * Description :
5263 * �ƥ�ݥ�꼭���ñ�����Ͽ���롣
5264 * Parameter :
5265 * env : (In) �Ķ��ؤΥݥ���
5266 * yomi : (In) �ɤ�
5267 * kanji : (In) ����
5268 * comment : (In) ������
5269 * hinsi : (In) �ʻ�
5270 * init_hindo :(In) �������
5271 *
5272 * Return value : 0==SUCCESS, -1==ERROR
5273 *
5274 * Author : Seiji KUWARI
5275 *
5276 * Revision history:
5277 *
5278 *:::DOC_END
5279 */
5280 int
js_temporary_word_add(env,yomi,kanji,comment,hinshi,init_hindo)5281 js_temporary_word_add(env, yomi, kanji, comment, hinshi, init_hindo)
5282 struct wnn_env *env;
5283 w_char *yomi,*kanji,*comment;
5284 int hinshi,init_hindo;
5285 {
5286 register int x;
5287
5288 if(!env) return(-1);
5289 set_current_js(env->js_id);
5290 LockMutex(&(env_js_lock));
5291 handler_of_jserver_dead_env(env);
5292 if(env_wnn_errorno_eql) {
5293 UnlockMutex(&(env_js_lock));
5294 return(-1);
5295 }
5296 snd_env_head(env,JS_TEMPORARY_WORD_ADD);
5297 putwscom(yomi, env->js_id);
5298 putwscom(kanji, env->js_id);
5299 putwscom(comment, env->js_id);
5300 put4com(hinshi, env->js_id);
5301 put4com(init_hindo, env->js_id);
5302 snd_flush(env->js_id);
5303 x=get4com(env->js_id);
5304 if (x == -1) wnn_errorno = get4com(env->js_id);
5305 UnlockMutex(&(env_js_lock));
5306 return x;
5307 }
5308
5309 /*:::DOC_START
5310 *
5311 * Function Name: js_autolearning_word_add
5312 * Description :
5313 * ��ư��Ͽ��ñ�����Ͽ���롣
5314 * Parameter :
5315 * env : (In) �Ķ��ؤΥݥ���
5316 * type : (In) �ؽ����륿����(��������/ʸ���ڤ�)
5317 * yomi : (In) �ɤ�
5318 * kanji : (In) ����
5319 * comment : (In) ������
5320 * hinsi : (In) �ʻ�
5321 * init_hindo :(In) �������
5322 *
5323 * Return value : 0==SUCCESS, -1==ERROR
5324 *
5325 * Author : Seiji KUWARI
5326 *
5327 * Revision history:
5328 *
5329 *:::DOC_END
5330 */
5331 int
js_autolearning_word_add(env,type,yomi,kanji,comment,hinshi,init_hindo)5332 js_autolearning_word_add(env, type, yomi, kanji, comment, hinshi, init_hindo)
5333 struct wnn_env *env;
5334 w_char *yomi,*kanji,*comment;
5335 int type, hinshi,init_hindo;
5336 {
5337 register int x;
5338
5339 if(!env) return(-1);
5340 set_current_js(env->js_id);
5341 LockMutex(&(env_js_lock));
5342 handler_of_jserver_dead_env(env);
5343 if(env_wnn_errorno_eql) {
5344 UnlockMutex(&(env_js_lock));
5345 return(-1);
5346 }
5347 snd_env_head(env,JS_AUTOLEARNING_WORD_ADD);
5348 put4com(type, env->js_id);
5349 putwscom(yomi, env->js_id);
5350 putwscom(kanji, env->js_id);
5351 putwscom(comment, env->js_id);
5352 put4com(hinshi, env->js_id);
5353 put4com(init_hindo, env->js_id);
5354 snd_flush(env->js_id);
5355 x=get4com(env->js_id);
5356 if (x == -1) wnn_errorno = get4com(env->js_id);
5357 UnlockMutex(&(env_js_lock));
5358 return x;
5359 }
5360
5361 /*:::DOC_START
5362 *
5363 * Function Name: js_set_autolearning_dic
5364 * Description :
5365 * ��ư��Ͽ�Ѥμ������Ͽ����
5366 * Parameter :
5367 * env : (In) �Ķ��ؤΥݥ���
5368 * type : (In) ����Υ�����(��������/ʸ���ڤ�)
5369 * dic_no : (In) �����ֹ�
5370 *
5371 * Return value : 0==SUCCESS, -1==ERROR
5372 *
5373 * Author : Seiji KUWARI
5374 *
5375 * Revision history:
5376 *
5377 *:::DOC_END
5378 */
5379 int
js_set_autolearning_dic(env,type,dic_no)5380 js_set_autolearning_dic(env, type, dic_no)
5381 register struct wnn_env *env;
5382 register int type, dic_no;
5383 {
5384 int x;
5385
5386 if(!env) return(-1);
5387 set_current_js(env->js_id);
5388 LockMutex(&(env_js_lock));
5389 handler_of_jserver_dead_env(env);
5390 if(env_wnn_errorno_eql) {
5391 UnlockMutex(&(env_js_lock));
5392 return(-1);
5393 }
5394 snd_env_head(env,JS_SET_AUTOLEARNING_DIC);
5395 put4com(type, env->js_id);
5396 put4com(dic_no, env->js_id);
5397 snd_flush(env->js_id);
5398 x=get4com(env->js_id);
5399 if (x == -1) wnn_errorno = get4com(env->js_id);
5400 UnlockMutex(&(env_js_lock));
5401 return(x);
5402 }
5403
5404 /*:::DOC_START
5405 *
5406 * Function Name: js_get_autolearning_dic
5407 * Description :
5408 * ��ư��Ͽ�Ѥμ����Ĵ�٤�
5409 * Parameter :
5410 * env : (In) �Ķ��ؤΥݥ���
5411 * type : (In) ����Υ�����(��������/ʸ���ڤ�)
5412 *
5413 * Return value : -1==ERROR, ELSE==������ֹ�
5414 *
5415 * Author : Seiji KUWARI
5416 *
5417 * Revision history:
5418 *
5419 *:::DOC_END
5420 */
5421 int
js_get_autolearning_dic(env,type)5422 js_get_autolearning_dic(env, type)
5423 register struct wnn_env *env;
5424 register int type;
5425 {
5426 register int x;
5427
5428 if(!env) return(-1);
5429 set_current_js(env->js_id);
5430 LockMutex(&(env_js_lock));
5431 handler_of_jserver_dead_env(env);
5432 if(env_wnn_errorno_eql) {
5433 UnlockMutex(&(env_js_lock));
5434 return(-1);
5435 }
5436 snd_env_head(env,JS_GET_AUTOLEARNING_DIC);
5437 put4com(type, env->js_id);
5438 snd_flush(env->js_id);
5439 x=get4com(env->js_id);
5440 if (x == -1) {
5441 UnlockMutex(&(env_js_lock));
5442 wnn_errorno = get4com(env->js_id);
5443 return -1;
5444 }
5445 x=get4com(env->js_id);
5446 UnlockMutex(&(env_js_lock));
5447 return(x);
5448 }
5449
5450
5451 /* For wnnoffline */
5452 #ifdef WNNOFFLINE
5453 int
js_lock(server)5454 js_lock(server)
5455 WNN_JSERVER_ID *server;
5456 {
5457 int x;
5458
5459 set_current_js(server);
5460 LockMutex(&(server_js_lock));
5461 handler_of_jserver_dead(server);
5462 if(js_wnn_errorno_eql) {
5463 UnlockMutex(&(server_js_lock));
5464 return(-1);
5465 }
5466 snd_server_head(server,JS_LOCK);
5467 snd_flush(server);
5468 if((x=get4com(server)) == -1) {
5469 js_wnn_errorno_set = get4com(server);
5470 }
5471 UnlockMutex(&(server_js_lock));
5472 return x;
5473 }
5474
5475 int
js_unlock(server)5476 js_unlock(server)
5477 WNN_JSERVER_ID *server;
5478 {
5479 int x;
5480
5481 set_current_js(server);
5482 LockMutex(&(server_js_lock));
5483 handler_of_jserver_dead(server);
5484 if(js_wnn_errorno_eql) {
5485 UnlockMutex(&(server_js_lock));
5486 return(-1);
5487 }
5488 snd_server_head(server,JS_UNLOCK);
5489 snd_flush(server);
5490 if((x=get4com(server)) == -1) {
5491 js_wnn_errorno_set = get4com(server);
5492 }
5493 UnlockMutex(&(server_js_lock));
5494 return x;
5495 }
5496 #endif /* WNNOFFLINE */
5497
5498
5499 /*:::DOC_START
5500 *
5501 * Function Name:
5502 * rcv_dai_sim, rcv_sho_x_sim, rcv_sho_kanji_sim, rcv_sho_sim
5503 * Description :
5504 * emulate rcv_dai etc. for local test
5505 * Parameter : same as emulated (omitted)
5506 *
5507 * Return value : same as emulated (omitted)
5508 *
5509 * Author : fujimori
5510 *
5511 * Revision history:
5512 * 20-Dec-94: initial release
5513 *
5514 *:::DOC_END
5515 */
5516
5517
5518
5519 /*:::DOC_START
5520 *
5521 * Function Name: js_ikeiji_with_data
5522 * Description :
5523 * �Ѵ��ѳƼ�ǡ�����ʣ����Ѵ����Ѵ��ʻ�ꥹ�ȡˤ�
5524 * ���ꤷ�ơ��۷��� �Ѵ�������Ԥʤ�
5525 * Parameter :
5526 * env : (In) �Ķ��ؤΥݥ���
5527 * fuku : (In) ʣ����Ѵ�
5528 * nhinsi : (In) �ʻ�ο�
5529 * hlist : (In) �ʻ�ꥹ��
5530 * henkan : (In) �Ѵ��Υ�����
5531 * yomi : (In) ��������
5532 * hinsi : (In) ������̤��ʻ�
5533 * fzk : (In) ��°��ξ���
5534 * vec : (In) ��³�ξ���
5535 * vec1 : (In) ��³�ξ��� 1
5536 * vec2 : (In) ��³�ξ��� 2
5537 * cur_bun : (In) ʸ��ξ���
5538 * yomi_orig : (In) �ɤ�
5539 * rb : (Out) ������
5540 *
5541 * Return value : ��ʸ��ο�
5542 *
5543 * Author : fujimori
5544 *
5545 * Revision history:
5546 * 20-Dec-94: initial release
5547 *
5548 *:::DOC_END
5549 */
5550 int
js_ikeiji_with_data(env,fuku,nhinsi,hlist,henkan,yomi,hinsi,fzk,vec,vec1,vec2,cur_bun,yomi_orig,rb)5551 js_ikeiji_with_data(env,fuku,nhinsi,hlist,henkan,yomi,hinsi,fzk,vec,vec1,vec2,
5552 cur_bun, yomi_orig,
5553 rb)
5554 struct wnn_env *env;
5555 int fuku, nhinsi, *hlist, henkan;
5556 w_char *yomi;
5557 int hinsi;
5558 w_char *fzk;
5559 int vec;
5560 int vec1;
5561 int vec2;
5562 WNN_BUN *cur_bun;
5563 w_char *yomi_orig;
5564 struct wnn_ret_buf *rb;
5565 {
5566 int x;
5567 int i, loop = abs(nhinsi);
5568
5569 int for_ret_status;
5570 int for_ret_status_bkwd;
5571
5572 for_ret_status = (cur_bun->dai_top)? WNN_NOT_CONNECT : WNN_CONNECT;
5573 /* where are WNN_SENTOU and WNN_GIJI gone to ? */
5574 for_ret_status_bkwd = (cur_bun->dai_end)? WNN_NOT_CONNECT_BK : WNN_CONNECT_BK;
5575
5576
5577 if(env==0) return(-1);
5578 set_current_js(env->js_id);
5579 LockMutex(&(env_js_lock));
5580 handler_of_jserver_dead_env(env);
5581 if(env_wnn_errorno_eql) {
5582 UnlockMutex(&(env_js_lock));
5583 return(-1);
5584 }
5585
5586
5587 snd_env_head(env,JS_HENKAN_IKEIJI);
5588 put4com(fuku, env->js_id); /* ʣ���ͥ�� */
5589 put4com(nhinsi, env->js_id); /* �Ѵ������ʻ�� */
5590 for(i = 0; i < loop; i++)
5591 put4com(hlist[i], env->js_id); /* �Ѵ������ʻ��ֹ� */
5592 put4com(henkan, env->js_id); /* �Ѵ����� */
5593 putwscom(yomi, env->js_id);
5594 put_fzk_vec(hinsi,fzk,vec,vec1, env->js_id);
5595 put4com(vec2, env->js_id);
5596 /* need fugokugo-len, hinsi, etc */
5597 put4com( (int) (cur_bun->yomilen - cur_bun->jirilen), env->js_id);
5598 put4com(cur_bun->hinsi, env->js_id);
5599
5600 /* more */
5601 put4com( cur_bun->hyoka, env->js_id);
5602 /* for ret_sho_hyoka in jserver */
5603 put4com( cur_bun->daihyoka, env->js_id);
5604 /* for ret_hyoka in jserver */
5605 put4com( for_ret_status /* (wnn_sho_bunsetsu*)->status */ , env->js_id);
5606 /* for ret_status in jserver */
5607 put4com( for_ret_status_bkwd /* (wnn_sho_bunsetsu*)->status_bkwd */ , env->js_id);
5608 /* for int ret_status_bkwd in jserver */
5609 put4com( cur_bun->kangovect, env->js_id);
5610 /* for ret_kangovect in jserver */
5611 /* �Ѵ��ɤ�ʸ��������Ф��������� ����� ������ ���Ϥ� */
5612 putwscom(yomi_orig, env->js_id);
5613 /* for ret_yomi_orig[i] in jserver */
5614 put4com( cur_bun->jirilen, env->js_id);
5615 /* for ret_jirilen_orig in jserver */
5616 put4com( cur_bun->yomilen, env->js_id);
5617 /* for ret_yomilen_orig in jserver */
5618 put4com( cur_bun->kanjilen, env->js_id);
5619 /* for ret_kanjilen_orig in jserver */
5620 put4com( cur_bun->real_kanjilen, env->js_id);
5621 /* for ret_real_kanjilen_orig in jserver */
5622
5623 snd_flush(env->js_id);
5624
5625 switch(henkan) {
5626 case WNN_IKEIJI_DAI:
5627 x = rcv_dai(rb, env->js_id);
5628 break;
5629 default:
5630 x = get4com(env->js_id);
5631 env_wnn_errorno_set= get4com(env->js_id);
5632 }
5633 UnlockMutex(&(env_js_lock));
5634 return x;
5635 }
5636 /* end of js_ikeiji_with_data */
5637
5638
5639