1 /*
2 * $Id: js.c,v 1.16 2005/04/10 15:26:37 aonoto Exp $
3 */
4
5 /*
6 * FreeWnn is a network-extensible Kana-to-Kanji conversion system.
7 * This file is part of FreeWnn.
8 *
9 * Copyright Kyoto University Research Institute for Mathematical Sciences
10 * 1987, 1988, 1989, 1990, 1991, 1992
11 * Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1999
12 * Copyright ASTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992
13 * Copyright FreeWnn Project 1999, 2000, 2001, 2002, 2003
14 *
15 * Maintainer: FreeWnn Project <freewnn@tomo.gr.jp>
16 *
17 * This library is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License as published by the Free Software Foundation; either
20 * version 2 of the License, or (at your option) any later version.
21 *
22 * This library is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * Lesser General Public License for more details.
26 *
27 * You should have received a copy of the GNU Lesser General Public
28 * License along with this library; if not, write to the
29 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
30 * Boston, MA 02111-1307, USA.
31 */
32
33 /*
34 Nihongo Henkan Library
35 */
36 /*
37 entry functions
38
39 js_open_lang js_close
40 js_change_current_jserver
41 js_connect_lang js_disconnect
42 js_isconnect
43
44 js_param_get js_param_set
45
46 js_access js_mkdir
47
48 js_get_lang js_set_lang
49
50
51 extern Variables
52 int wnn_errorno;
53 */
54
55 #if defined(HAVE_CONFIG_H)
56 #include <config.h>
57 #endif
58
59 #include <stdio.h>
60 #include <ctype.h>
61 #include <errno.h>
62 #include <signal.h>
63 #if STDC_HEADERS
64 # include <stdlib.h>
65 # include <string.h>
66 #else
67 # if HAVE_MALLOC_H
68 # include <malloc.h>
69 # endif
70 # if HAVE_STRINGS_H
71 # include <strings.h>
72 # endif
73 #endif /* STDC_HEADERS */
74 #if HAVE_FCNTL_H
75 # include <fcntl.h>
76 #endif
77 #include <pwd.h>
78 #if HAVE_UNISTD_H
79 # include <unistd.h>
80 #endif
81 #include <sys/stat.h>
82 #include <sys/types.h>
83
84 #include "jd_sock.h"
85 #include "commonhd.h"
86 #include "demcom.h"
87 #include "wnn_config.h"
88
89 #include "wnnerror.h"
90 #include "jslib.h"
91 #include "jh.h"
92
93 #include "msg.h"
94
95 #define JS /* For include ../etc/bdic.c */
96 #include "../etc/bdic.c"
97 #include "../etc/pwd.c"
98
99 /* defined in wnn_os.h & should be modified in the future */
100 /* #define bzero(adr,n) memset((adr),0,(n)) */
101
102 int wnn_errorno = 0;
103 struct msg_cat *wnn_msg_cat = NULL;
104
105 /* j Lib. */
106
107 static int current_sd; /** �����å�fd **/
108 static WNN_JSERVER_ID *current_js = NULL;
109
110
111 /* Packet Buffers */
112 static unsigned char snd_buf[S_BUF_SIZ]; /** ���� **/
113 static unsigned char *sbp = snd_buf;
114
115 #if defined(EAGAIN)
116 # if defined(EWOULDBLOCK)
117 # define ERRNO_CHECK(no) ((no) == EAGAIN || (no) == EWOULDBLOCK)
118 # else /* defined(EWOULDBLOCK) */
119 # define ERRNO_CHECK(no) ((no) == EAGAIN)
120 # endif /* defined(EWOULDBLOCK) */
121 #else /* defined(EAGAIN) */
122 # if defined(EWOULDBLOCK)
123 # define ERRNO_CHECK(no) ((no) == EWOULDBLOCK)
124 # else /* defined(EWOULDBLOCK) */
125 # define ERRNO_CHECK(no) (0)
126 # endif /* defined(EWOULDBLOCK) */
127 #endif /* defined(EAGAIN) */
128
129 static void connect_timeout ();
130 static int _get_server_name ();
131 static int writen ();
132 static int rcv_flush();
133 static char *get_unixdomain_of_serv_defs (), *get_service_of_serv_defs ();
134 static int get_port_num_of_serv_defs ();
135 void xerror ();
136
137 /********* V4 *****************/
138 /***
139 jserver_dead Macro
140 ***/
141
142 static jmp_buf current_jserver_dead;
143
144 #define handler_of_jserver_dead(err_val) \
145 { \
146 if (current_js) { \
147 if(current_js->js_dead){wnn_errorno=WNN_JSERVER_DEAD;return err_val;}\
148 if(setjmp(current_jserver_dead)){ \
149 wnn_errorno=WNN_JSERVER_DEAD; \
150 return err_val; \
151 } \
152 wnn_errorno = 0; /* here initialize wnn_errorno; */ \
153 } \
154 }
155
156 static void
set_current_js(server)157 set_current_js (server)
158 register WNN_JSERVER_ID *server;
159 {
160 current_js = server;
161 current_sd = current_js->sd;
162 }
163
164 /** �ǡ�����������Τ���θ���� **/
165 static void
daemon_dead()166 daemon_dead ()
167 {
168 current_js->js_dead = -1;
169 wnn_errorno = WNN_JSERVER_DEAD;
170 shutdown (current_sd, 2);
171 #ifdef HAVE_CLOSESOCKET
172 closesocket (current_sd);
173 #else
174 close (current_sd);
175 #endif
176 #if DEBUG
177 fprintf (stderr, "jslib:JSERVER %s is Dead\n", current_js->js_name);
178 #endif
179 if (current_js->js_dead_env_flg)
180 {
181 longjmp (current_js->js_dead_env, 666);
182 }
183 longjmp (current_jserver_dead, 666);
184 /* never reach */
185 }
186
187
188 /**
189 �����åȤ����ץ���current_sd�˥����å�fd���֤�
190 (cd�Ȥ����Τϥ��ߥ�˥��������ǥХ�����̾��)
191 **/
192 static int
cd_open_un(const char * lang)193 cd_open_un(const char *lang)
194 {
195 #if !defined(AF_UNIX)
196 return -1;
197 #else
198 int sd;
199 struct sockaddr_un saddr;
200 char *sock_name = NULL;
201 saddr.sun_family = AF_UNIX;
202
203 /* find socket name from table by lang */
204 if (lang && *lang) {
205 if ((sock_name = get_unixdomain_of_serv_defs(lang)) == NULL)
206 sock_name = sockname;
207 } else
208 sock_name = sockname; /* Jserver */
209 strcpy (saddr.sun_path, sock_name);
210
211 if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) == ERROR) {
212 #if DEBUG
213 xerror ("jslib:Can't create unix domain socket.\n");
214 #endif /* DEBUG */
215 return -1;
216 }
217
218 #if !defined(SUN_LEN)
219 # define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
220 #endif /* !defined(SUN_LEN) */
221 if (connect(sd, (struct sockaddr *)&saddr, SUN_LEN(&saddr)) == ERROR) {
222 #if DEBUG
223 xerror ("jslib:Can't connect unix domain socket.\n");
224 #endif /* DEBUG */
225 close (sd);
226 return -1;
227 }
228
229 return sd;
230 #endif
231 }
232
233 static int
cd_open_in(const char * server,const char * lang,const int timeout)234 cd_open_in(const char *server,
235 const char *lang,
236 const int timeout)
237 {
238 int sd;
239
240 struct addrinfo hints, *res, *res0;
241 struct sockaddr sa;
242 char sbuf[NI_MAXSERV];
243
244 int error;
245
246 struct servent *sp = NULL;
247 int serverNO, port_num;
248 int ret;
249 char pserver[NI_MAXHOST];
250 char sserver[NI_MAXHOST];
251 char *serv_name = NULL;
252
253 #if DEBUG
254 fprintf(stderr, "cd_open_in: Enter: server=%s, lang=%s\n",
255 server, lang);
256 #endif
257 serverNO = _get_server_name(server, pserver);
258 #if DEBUG
259 fprintf(stderr, "cd_open_in: serverNO=%d\n", serverNO);
260 #endif
261 /* find service name from table by lang */
262 if (lang && *lang) {
263 if ((serv_name = get_service_of_serv_defs (lang)) == NULL) {
264 strncpy (sserver, SERVERNAME, sizeof(sserver) - 1);
265 sserver[sizeof(sserver) - 1] = '\0';
266 } else {
267 strncpy (sserver, serv_name, sizeof(sserver) - 1);
268 sserver[sizeof(sserver) - 1] = '\0';
269 }
270 } else {
271 strncpy (sserver, SERVERNAME, sizeof(sserver) - 1);
272 sserver[sizeof(sserver) - 1] = '\0';
273 }
274
275 memset(&sa, 0, sizeof(struct sockaddr));
276 error = getnameinfo(&sa, sa.sa_len,
277 NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV);
278 if (!error) {
279 serverNO += atoi(sbuf);
280 } else {
281 if ((port_num = get_port_num_of_serv_defs (lang)) == -1)
282 serverNO += WNN_PORT_IN;
283 else
284 serverNO += port_num;
285 }
286 #if DEBUG
287 fprintf(stderr, "cd_open_in: fixed serverNO=%d\n", serverNO);
288 #endif
289 memset(&hints, 0, sizeof(hints));
290 hints.ai_family = PF_UNSPEC;
291 hints.ai_socktype = SOCK_STREAM;
292 sprintf(sbuf, "%d", serverNO);
293
294 error = getaddrinfo(pserver, sbuf, &hints, &res0);
295 if (error) {
296 xerror(gai_strerror(error));
297 return -1;
298 }
299
300 for (res = res0; res ; res = res->ai_next) {
301 switch (res->ai_family) {
302 case AF_INET:
303 #ifdef INET6
304 case AF_INET6:
305 #endif
306 sd = socket(res->ai_family,
307 res->ai_socktype,
308 res->ai_protocol);
309
310 if (sd == ERROR) {
311 switch (res->ai_family) {
312 case AF_INET:
313 xerror ("jslib:Can't create inet socket.\n");
314 #ifdef INET6
315 case AF_INET6:
316 xerror ("jslib:Can't create inet6 socket.\n");
317 #endif
318 default:
319 xerror("jslib:Cannot create socket. Unknown socket type.\n");
320 }
321
322 break;
323 }
324 if (timeout) {
325 signal(SIGALRM, connect_timeout);
326 alarm(timeout);
327 }
328 ret = connect(sd,
329 res->ai_addr,
330 res->ai_addrlen);
331 if (timeout) {
332 alarm(0);
333 signal(SIGALRM, SIG_IGN);
334 }
335 if (ret == ERROR) {
336 switch (res->ai_family) {
337 case AF_INET:
338 fprintf(stderr, "jslib:Can't connect inet socket. (sd=%d)\n", sd);
339 break;
340 #ifdef INET6
341 case AF_INET6:
342 fprintf(stderr, "jslib:Can't connect inet6 socket. (sd=%d)\n", sd);
343 break;
344 #endif
345 default:
346 xerror("jslib:Cannot connect. Unknown socket type.\n");
347 break;
348 }
349 #ifdef HAVE_CLOSESOCKET
350 closesocket(sd);
351 #else
352 close(sd);
353 #endif
354 sd = ERROR;
355 }
356 #if DEBUG
357 fprintf(stderr, "connect: sd=%d\n", sd);
358 #endif
359 freeaddrinfo(res0);
360 return sd;
361 }
362 }
363 freeaddrinfo(res0);
364 return sd;
365 }
366
367 static void
connect_timeout()368 connect_timeout()
369 {
370 }
371
372 /* get server name and return serverNo */
373 static int
_get_server_name(char * server,char * pserver)374 _get_server_name(char *server,
375 char *pserver)
376 {
377 char *p;
378 #ifdef INET6
379 int len;
380
381 if (server[0] == '[') {
382 p = strchr(server++, ']');
383 if (p) {
384 len = p-server < NI_MAXHOST - 1 ? p-server : NI_MAXHOST - 1;
385 strncpy(pserver, server, len);
386 pserver[len] = '\0';
387 } else
388 pserver[0] = '\0';
389 } else {
390 #endif
391 /* Workaround for pserver buffer overrun : Nov 11,1999 by T.Aono */
392 /* assumes pserver[NI_MAXHOST]. variable length string is not supported. */
393 strncpy(pserver, server, NI_MAXHOST - 1);
394 pserver[NI_MAXHOST - 1] = '\0';
395 p = pserver;
396 #ifdef INET6
397 }
398 #endif
399
400 for (; *p && *p != ':'; p++);
401 if (!*p) /* does not have a colon */
402 return (0);
403 *p = 0;
404 return (atoi (++p));
405 }
406
407 /* Packet SND/RCV subroutines */
408 static void put4com ();
409
410 /* send packet header */
411 static void
snd_head(int cmd)412 snd_head(int cmd)
413 {
414 sbp = snd_buf;
415 put4com(cmd);
416 rcv_flush();
417 }
418
419 /* send environment header */
420 static int
snd_env_head(struct wnn_env * env,int cmd)421 snd_env_head (struct wnn_env *env,
422 int cmd)
423 {
424 snd_head(cmd);
425 put4com(env->env_id);
426 return 0;
427 }
428
429 /* send server header */
430 static int
snd_server_head(WNN_JSERVER_ID * server,int cmd)431 snd_server_head(WNN_JSERVER_ID *server,
432 int cmd)
433 {
434 snd_head(cmd);
435 return 0;
436 }
437
438 /* flush send buffer */
439 static int
snd_flush()440 snd_flush()
441 {
442 /* empty buffer; no need to flush */
443 if (sbp == snd_buf)
444 return 0;
445
446 writen(sbp);
447 return 0;
448 }
449
450 /* send data */
451 static int
writen(unsigned char * sp)452 writen(unsigned char *sp)
453 {
454 unsigned char *bp = snd_buf;
455 int n;
456 size_t total = sp - bp;
457
458 while (bp < sp && bp <= snd_buf + sizeof(snd_buf)) {
459 #if DEBUG_IO
460 fprintf(stderr,
461 "writen: loop: sp - bp = %d\n", sp - bp);
462 #endif
463 #ifdef HAVE_SEND
464 n = send(current_sd, bp, sp - bp, 0);
465 #else
466 n = write(current_sd, bp, sp - bp);
467 #endif
468 if (n < 0) {
469 if (ERRNO_CHECK (errno) || errno == EINTR) {
470 continue;
471 } else {
472 #if DEBUG_IO
473 fprintf(stderr,
474 "writen: failed. errno=%d\n", errno);
475 #endif
476 daemon_dead();
477 return -1;
478 }
479 }
480 bp += n;
481 }
482 sbp = snd_buf;
483 #if DEBUG_IO
484 fprintf (stderr, "jslib:writen=%d\n", total);
485 #endif
486 return 0;
487 }
488
489 /* send one byte to server */
490 static void
put1com(int c)491 put1com(int c)
492 {
493 unsigned int data = c & 0xff;
494
495 #if DEBUG_IO
496 fprintf(stderr, "put1com: [%02x]\n", data);
497 #endif
498
499 /* flush buffer if full */
500 if (sbp - snd_buf >= S_BUF_SIZ) {
501 writen(sbp);
502 }
503 *(sbp++) = data;
504 }
505
506 /* send two bytes */
507 static void
put2com(int c)508 put2com(int c)
509 {
510 unsigned int data = c & 0xffff;
511 #if DEBUG_IO
512 fprintf(stderr, "put2com: [%04x]\n", data);
513 #endif
514 put1com(data >> (8 * 1));
515 put1com(data);
516 }
517
518 /* send four bytes */
519 static void
put4com(int c)520 put4com(int c)
521 {
522 unsigned int data = c & 0xffffffff;
523 #if DEBUG_IO
524 fprintf(stderr, "put4com: [%08x]\n", data);
525 #endif
526 put1com(data >> (8 * 3));
527 put1com(data >> (8 * 2));
528 put1com(data >> (8 * 1));
529 put1com(data);
530 }
531
532 /* send w_char string */
533 static void
putwscom(w_char * p)534 putwscom(w_char *p)
535 {
536 if (p == NULL) {
537 put2com(0x0000);
538 return;
539 }
540
541 #if DEBUG_IO
542 fprintf(stderr, "putwscom: [%s]\n", p);
543 #endif
544 while(*p)
545 put2com (*p++);
546 put2com(0x0000);
547 }
548
549 /* send string */
550 static void
putscom(unsigned char * p)551 putscom(unsigned char *p)
552 {
553 if (p == NULL) {
554 put1com(0x00);
555 return;
556 }
557 #if DEBUG_IO
558 fprintf(stderr, "putscom: [%s]\n", p);
559 #endif
560 while (*p)
561 put1com(*p++);
562 put1com(0);
563 }
564
565 static unsigned char rcv_buf[R_BUF_SIZ];
566 static unsigned char *rbp = rcv_buf;
567 static unsigned char *rp = rcv_buf;
568
569 static int
rcv_flush()570 rcv_flush()
571 {
572 #if DEBUG_IO
573 fprintf(stderr, "rcv_flush\n");
574 #endif
575 rbp = rp = &rcv_buf[0];
576 return 0;
577 }
578
579 static unsigned int
get1com()580 get1com()
581 {
582 int n;
583
584 #if DEBUG_IO
585 fprintf(stderr, "get1com: Enter\n");
586 #endif
587 if (rp == rbp) {
588 /* rp == rbp case; no data in rcv_buf */
589
590 rbp = rp = rcv_buf;
591
592 while (rbp == rp) {
593 errno = 0;
594 #ifdef HAVE_RECV
595 n = recv(current_sd, rcv_buf, sizeof(rcv_buf), 0);
596 #else
597 n = read(current_sd, rcv_buf, sizeof(rcv_buf));
598 #endif
599 #if DEBUG_IO
600 fprintf(stderr, "recvloop: n=%d\n", n);
601 #endif
602 if (n == 0) {
603 if (ERRNO_CHECK(errno)) {
604 continue;
605 } else {
606 daemon_dead();
607 return -1;
608 }
609 }
610 if (n < 0) {
611 if (ERRNO_CHECK(errno) || errno == EINTR) {
612 continue;
613 } else {
614 daemon_dead();
615 return -1;
616 }
617 }
618 rp += n;
619 }
620 #if DEBUG_IO
621 fprintf (stderr, "jslib:read:rp - rbp =%d\n", rp - rbp);
622 #endif
623 }
624
625 #if DEBUG_IO
626 fprintf(stderr, "get1com: data [%02x]\n", *rbp & 0xff);
627
628 fprintf(stderr, "rcv_buf: ");
629 {
630 int i;
631 for (i=0; i < rp - rbp; i++) {
632 fprintf(stderr, "[%02x]", *(rbp + i));
633 }
634 fprintf(stderr, "\n");
635 }
636 #endif
637 return (*(rbp++) & 0xff);
638 }
639
640 /* get two bytes */
641 static unsigned int
get2com()642 get2com()
643 {
644 unsigned int h;
645 #if DEBUG_IO
646 fprintf(stderr, "get2com: Enter\n");
647 #endif
648 h = get1com() << 8;
649 h |= get1com();
650
651 #if DEBUG_IO
652 fprintf(stderr, "get2com: [%04x]\n", h);
653 #endif
654 return h;
655 }
656
657 /* get four bytes */
658 static unsigned int
get4com()659 get4com()
660 {
661 unsigned int h;
662 #if DEBUG_IO
663 fprintf(stderr, "get4com: Enter\n");
664 #endif
665 h = get1com() << 24;
666 h |= get1com() << 16;
667 h |= get1com() << 8;
668 h |= get1com();
669 #if DEBUG_IO
670 fprintf(stderr, "get4com: [%08x]\n", h);
671 #endif
672 return h;
673 }
674
675 /* get string */
676 static void
getscom(unsigned char * p)677 getscom(unsigned char *p)
678 {
679 unsigned char *bp = p;
680 while (*p++ = get1com())
681 ;
682 #if DEBUG_IO
683 fprintf(stderr, "getscom: [%s]\n", bp);
684 #endif
685 }
686
687 /* get wstring */
688 static void
getwscom(w_char * p)689 getwscom(w_char *p)
690 {
691 while (*p++ = get2com ())
692 ;
693 }
694
695 #ifdef nodef
696 /* Moved from ../etc/string.c */
697 /** **/
698 static int
Strlen(s)699 Strlen (s)
700 register w_char *s;
701 {
702 register int n;
703
704 for (n = 0; *s++ != 0; n++);
705 return n;
706 }
707
708 /** **/
709 static w_char *
Strcpy(s1,s2)710 Strcpy (s1, s2)
711 register w_char *s1;
712 register w_char *s2;
713 {
714 register w_char *d;
715
716 for (d = s1; (*d++ = *s2++) != 0;);
717 return s1;
718 }
719 #endif
720
721
722 /* Debug Subroutines */
723 void
xerror(s)724 xerror (s)
725 char *s;
726 {
727 fprintf (stderr, "%s\n", s);
728 }
729
730 void
dmp(p,c)731 dmp (p, c)
732 char *p;
733 {
734 int i, j;
735 for (i = 0;; i += 16)
736 {
737 for (j = 0; j < 16; j++)
738 {
739 if (c <= 0)
740 {
741 fprintf (stderr, "\n");
742 return;
743 }
744 fprintf (stderr, "%02x ", p[i + j] & 0xFF);
745 c--;
746 }
747 fprintf (stderr, "\n");
748 }
749 }
750
751 /* get login name form /etc/passwd file */
752 static char *
getlogname()753 getlogname ()
754 {
755 struct passwd *getpwuid ();
756 return getpwuid (getuid ())->pw_name;
757 }
758
759
760
761
762 /*
763 * Lib. Functions
764 * raw lib.
765 */
766
767 /***
768 js
769 ��global
770 ***/
771
772 /** jserver ����³���롣jserver_id ���֤��� **/
773 WNN_JSERVER_ID *
js_open_lang(char * server,char * lang,int timeout)774 js_open_lang (char *server,
775 char *lang,
776 int timeout)
777 {
778 char *new_js;
779 char host[WNN_HOSTLEN];
780 char user[WNN_ENVNAME_LEN];
781 int x;
782
783 if (wnn_msg_cat == NULL) {
784 char nlspath[MAXPATHLEN];
785 strcpy (nlspath, LIBDIR);
786 strcat (nlspath, "/%L/%N");
787 wnn_msg_cat = msg_open ("libwnn.msg", nlspath, lang);
788 if (wnn_msg_cat == NULL) {
789 fprintf (stderr,
790 "libwnn: Cannot open message file for libwnn.a\n");
791 }
792 }
793
794 if (!(new_js = (char *) malloc (sizeof (WNN_JSERVER_ID)))) {
795 wnn_errorno = WNN_ALLOC_FAIL;
796 return NULL;
797 }
798
799 current_js = (WNN_JSERVER_ID *) new_js;
800 if (server == NULL) {
801 current_js->js_name[0] = '\0';
802 } else {
803 strncpy(current_js->js_name, server, sizeof (current_js->js_name) - 1);
804 current_js->js_name[sizeof (current_js->js_name) - 1] = '\0';
805 }
806
807 current_js->js_dead = 0;
808 current_js->js_dead_env_flg = 0;
809 /*
810 if(user == NULL || 0==strcmp(user,""))
811 */
812 strncpy(user, getlogname (), WNN_ENVNAME_LEN);
813 user[WNN_ENVNAME_LEN - 1] = '\0'; /* truncate by WNN_ENVNAME_LEN */
814
815 #if DEBUG
816 fprintf(stderr, "js_open_lang: server: %s\n", server);
817 #endif
818 if (server == NULL
819 || 0 == strcmp(server, "")
820 || 0 == strcmp(server, "unix")) {
821 strcpy(host, "unix");
822 if ((current_sd = cd_open_un(lang)) == -1) {
823 wnn_errorno = WNN_SOCK_OPEN_FAIL;
824 free ((char *) current_js);
825 current_js = NULL;
826 return NULL;
827 }
828 } else {
829 gethostname (host, WNN_HOSTLEN);
830 host[WNN_HOSTLEN - 1] = '\0'; /* truncate by WNN_HOSTLEN */
831 #if DEBUG
832 fprintf(stderr, "js_open_lang: before cd_open_in\n");
833 #endif
834 if ((current_sd = cd_open_in(server, lang, timeout)) == -1) {
835 wnn_errorno = WNN_SOCK_OPEN_FAIL;
836 free((char *)current_js);
837 current_js = NULL;
838 #if DEBUG
839 fprintf(stderr, "js_open_lang: cd_open_in failed\n");
840 #endif
841 return NULL;
842 }
843 #if DEBUG
844 fprintf(stderr, "js_open_lang: after cd_open_in\n");
845 #endif
846 }
847
848 #if DEBUG
849 fprintf(stderr, "current_sd=%d\n", current_sd);
850 #endif
851 current_js->sd = current_sd;
852 handler_of_jserver_dead (NULL);
853 snd_head(JS_OPEN);
854 put4com(JLIB_VERSION); /* H.T. */
855 putscom(host);
856 putscom(user);
857 snd_flush();
858
859 #if DEBUG
860 fprintf(stderr, "cd_open_in: before get4com\n");
861 #endif
862
863 if (get4com() == -1) {
864 x = wnn_errorno = get4com ();
865 js_close(current_js); /* H.T. */
866 current_js = NULL;
867 wnn_errorno = x;
868 return NULL;
869 }
870
871 return current_js;
872 }
873
874
875 /** �����åȤ��������� **/
876 /** jserver �Ȥ���³�� close ���롣 **/
877 int
js_close(server)878 js_close (server)
879 WNN_JSERVER_ID *server;
880 {
881 register int x;
882 WNN_JSERVER_ID tmp_js_id;
883 if (server == 0)
884 return (-1);
885 tmp_js_id = *server;
886 free ((char *) server);
887 current_js = &tmp_js_id;
888 current_sd = current_js->sd;
889 /* handler of jserver dead */
890 handler_of_jserver_dead (-1);
891 snd_head (JS_CLOSE);
892 snd_flush ();
893 x = get4com ();
894 if (x == -1)
895 wnn_errorno = get4com ();
896 #ifdef HAVE_CLOSESOCKET
897 closesocket (current_sd);
898 #else
899 close (current_sd);
900 #endif
901 return x;
902 }
903
904
905 /*
906 jserver �Ȥδ֤� connection ��ĥ�ꡢƱ���� jserver �������˴�
907 �����롣env_name �˴���¸�ߤ���Ķ�����ꤷ�����ˤϤ��δĶ���
908 �֤���NULL ����ꤷ�����ˤϿ������Ķ����ä��֤���
909 */
910
911 struct wnn_env *
js_connect_lang(server,env_name,lang)912 js_connect_lang (server, env_name, lang)
913 register char *env_name;
914 WNN_JSERVER_ID *server;
915 char *lang;
916 {
917 register int e_id;
918 register struct wnn_env *env;
919 void js_set_lang ();
920
921 set_current_js (server);
922 if (!(env = (struct wnn_env *) malloc (sizeof (struct wnn_env))))
923 {
924 wnn_errorno = WNN_ALLOC_FAIL;
925 return NULL;
926 }
927 handler_of_jserver_dead (NULL);
928 snd_head (JS_CONNECT);
929 putscom (env_name);
930 snd_flush ();
931 e_id = get4com ();
932 if (e_id == -1)
933 {
934 wnn_errorno = get4com ();
935 free (env);
936 return NULL;
937 }
938 env->env_id = e_id;
939 env->js_id = server;
940 strcpy (env->lang, lang); /* set language name */
941 return env;
942 }
943
944 #ifdef nodef
945 /* set language value to env */
946 void
js_set_lang(env,lang)947 js_set_lang (env, lang)
948 struct wnn_env *env;
949 register char *lang;
950 {
951 register char *p;
952 extern char *getenv ();
953
954 /* if not specified language , use $LANG */
955 if (lang == 0 || *lang == 0)
956 lang = getenv ("LANG");
957 if (lang == 0 || *lang == 0)
958 lang = WNN_DEFAULT_LANG;
959 for (p = env->lang; *lang != '.' && *lang != '@' && *lang != 0; lang++, p++)
960 *p = *lang;
961 *p = 0;
962 }
963 #endif
964
965 /* get language value from env */
966 char *
js_get_lang(env)967 js_get_lang (env)
968 struct wnn_env *env;
969 {
970 return (env->lang);
971 }
972
973 int
js_env_exist(server,env_name)974 js_env_exist (server, env_name)
975 register char *env_name;
976 register WNN_JSERVER_ID *server;
977 {
978 set_current_js (server);
979 handler_of_jserver_dead (-1);
980 snd_head (JS_ENV_EXIST);
981 putscom (env_name);
982 snd_flush ();
983 return (get4com ());
984 }
985
986 int
js_env_sticky(env)987 js_env_sticky (env)
988 register struct wnn_env *env;
989 {
990 if (env == 0)
991 return (-1);
992 set_current_js (env->js_id);
993 handler_of_jserver_dead (-1);
994 snd_env_head (env, JS_ENV_STICKY);
995 snd_flush ();
996 return (get4com ());
997 }
998
999 int
js_env_un_sticky(env)1000 js_env_un_sticky (env)
1001 register struct wnn_env *env;
1002 {
1003 if (env == 0)
1004 return (-1);
1005 set_current_js (env->js_id);
1006 handler_of_jserver_dead (-1);
1007 snd_env_head (env, JS_ENV_UN_STICKY);
1008 snd_flush ();
1009 return (get4com ());
1010 }
1011
1012 /**
1013 env �Ǽ������Ķ���̵������
1014 **/
1015 int
js_disconnect(env)1016 js_disconnect (env)
1017 register struct wnn_env *env;
1018 {
1019 register int x;
1020 struct wnn_env tmp_env;
1021 if (env == 0)
1022 return (-1);
1023 tmp_env = *env;
1024 /* ����ϡ�free ���ʤ��㤢����Τ����ɡ����������������ʤ�����
1025 �ޤ���8�Х��Ȥ����顢���ߤ��Ĥ뤱�ɤ���������
1026 free((char *)env);
1027 */
1028 set_current_js (env->js_id);
1029 handler_of_jserver_dead (NULL);
1030 snd_env_head (&tmp_env, JS_DISCONNECT);
1031 snd_flush ();
1032 x = get4com ();
1033 if (x == -1)
1034 {
1035 wnn_errorno = get4com ();
1036 }
1037 return x;
1038 }
1039
1040 /** �����Фȥ��ͥ��Ȥ��Ƥ��뤫 **/
1041 int
js_isconnect(env)1042 js_isconnect (env)
1043 register struct wnn_env *env;
1044 {
1045 if (env && env->js_id)
1046 return (env->js_id->js_dead);
1047 return (-1);
1048 }
1049
1050 /**
1051 env �� �Ķ� �Ȥ��̿��Хåե��� flush ���롣
1052 **/
1053 void
js_flush(env)1054 js_flush (env)
1055 struct wnn_env *env;
1056 {
1057 }
1058
1059
1060
1061 /* Parameter set/get */
1062 /** �Ѵ� parameter �����ꤹ�롣 **/
1063 /** js_param_set **/
1064 int
js_param_set(env,para)1065 js_param_set (env, para)
1066 struct wnn_env *env;
1067 register struct wnn_param *para;
1068 {
1069 register int x;
1070 if (env == 0)
1071 return (-1);
1072 set_current_js (env->js_id);
1073 handler_of_jserver_dead (-1);
1074 snd_env_head (env, JS_PARAM_SET);
1075 put4com (para->n); /* ��(��)ʸ����ϤΣ� */
1076 put4com (para->nsho); /* ��ʸ����ξ�ʸ��κ���� */
1077 put4com (para->p1); /* ��������٤Υѥ��� */
1078 put4com (para->p2); /* ��ʸ��Ĺ�Υѥ��� */
1079 put4com (para->p3); /* ����Ĺ�Υѥ��� */
1080 put4com (para->p4); /* ���Ȥä���ӥåȤΥѥ��� */
1081 put4com (para->p5); /* ����Υѥ��� */
1082 put4com (para->p6); /* ��ʸ���ɾ���ͤΥѥ��� */
1083 put4com (para->p7); /* ��ʸ��Ĺ�Υѥ��� */
1084 put4com (para->p8); /* ��ʸ����Υѥ��� */
1085
1086 put4com (para->p9); /* �����ʻ� ���������� */
1087 put4com (para->p10); /* �����ʻ� ���ʤ����� *//* CWNN �ѿ������� */
1088 put4com (para->p11); /* �����ʻ� �ѿ������� *//* CWNN ��������� */
1089 put4com (para->p12); /* �����ʻ� ��������� *//* CWNN ����̤����� */
1090 put4com (para->p13); /* �����ʻ� �ij�̤����� *//* CWNN �ij�̤����� */
1091 put4com (para->p14); /* �����ʻ� ��°������� *//* BWNN No of koho */
1092 put4com (para->p15); /* �����ʻ� ����̤����� *//* CWNN Not used */
1093
1094 snd_flush ();
1095 x = get4com ();
1096 if (x == -1)
1097 {
1098 wnn_errorno = get4com ();
1099 return -1;
1100 }
1101 return 0;
1102 }
1103
1104 /** js_param_get **/
1105 /** env �Ǽ������Ķ����Ѵ� parameter ����Ф��� **/
1106 int
js_param_get(env,para)1107 js_param_get (env, para)
1108 struct wnn_env *env;
1109 register struct wnn_param *para;
1110 {
1111 if (env == 0)
1112 return (-1);
1113 set_current_js (env->js_id);
1114 handler_of_jserver_dead (-1);
1115 snd_env_head (env, JS_PARAM_GET);
1116 snd_flush ();
1117 if (get4com () == -1)
1118 {
1119 wnn_errorno = get4com ();
1120 return -1;
1121 }
1122 para->n = get4com (); /* ��(��)ʸ����ϤΣ� */
1123 para->nsho = get4com (); /* ��ʸ����ξ�ʸ��κ���� */
1124 para->p1 = get4com (); /* ��������٤Υѥ��� */
1125 para->p2 = get4com (); /* ��ʸ��Ĺ�Υѥ��� */
1126 para->p3 = get4com (); /* ����Ĺ�Υѥ��� */
1127 para->p4 = get4com (); /* ���Ȥä���ӥåȤΥѥ��� */
1128 para->p5 = get4com (); /* ����Υѥ��� */
1129 para->p6 = get4com (); /* ��ʸ���ɾ���ͤΥѥ��� */
1130 para->p7 = get4com (); /* ��ʸ��Ĺ�Υѥ��� */
1131 para->p8 = get4com (); /* ��ʸ����Υѥ��� */
1132 para->p9 = get4com (); /* �����ʻ� ���������� */
1133 para->p10 = get4com (); /* �����ʻ� ���ʤ����� */
1134 para->p11 = get4com (); /* �����ʻ� �ѿ������� */
1135 para->p12 = get4com (); /* �����ʻ� ��������� */
1136 para->p13 = get4com (); /* �����ʻ� �ij�̤����� */
1137 para->p14 = get4com (); /* �����ʻ� ��°������� */
1138 para->p15 = get4com (); /* �����ʻ� ����̤����� */
1139
1140 return 0;
1141 }
1142
1143 /*
1144 global File Operation
1145 */
1146 /** js_mkdir **/
1147 int
js_mkdir(env,path)1148 js_mkdir (env, path)
1149 struct wnn_env *env;
1150 char *path;
1151 {
1152 register int x;
1153 if (env == 0)
1154 return (-1);
1155 set_current_js (env->js_id);
1156 handler_of_jserver_dead (-1);
1157 snd_env_head (env, JS_MKDIR);
1158 putscom (path);
1159 snd_flush ();
1160 x = get4com ();
1161 if (x == -1)
1162 wnn_errorno = get4com ();
1163 return x;
1164 }
1165
1166 /** js_access **/
1167 int
js_access(env,path,amode)1168 js_access (env, path, amode)
1169 struct wnn_env *env;
1170 char *path;
1171 int amode;
1172 {
1173 register int x;
1174 if (env == 0)
1175 return (-1);
1176 set_current_js (env->js_id);
1177 handler_of_jserver_dead (-1);
1178 snd_env_head (env, JS_ACCESS);
1179 put4com (amode);
1180 putscom (path);
1181 snd_flush ();
1182 x = get4com ();
1183 return x;
1184 }
1185
1186 /** js_file_list_all **/
1187 static int rcv_file_list ();
1188
1189 int
js_file_list_all(server,ret)1190 js_file_list_all (server, ret)
1191 WNN_JSERVER_ID *server;
1192 struct wnn_ret_buf *ret;
1193 {
1194 set_current_js (server);
1195 handler_of_jserver_dead (-1);
1196 snd_server_head (server, JS_FILE_LIST_ALL);
1197 snd_flush ();
1198 return rcv_file_list (ret);
1199 }
1200
1201
1202 /** js_file_list **/
1203 int
js_file_list(env,ret)1204 js_file_list (env, ret)
1205 struct wnn_env *env;
1206 struct wnn_ret_buf *ret;
1207 {
1208 if (env == 0)
1209 return (-1);
1210 set_current_js (env->js_id);
1211 handler_of_jserver_dead (-1);
1212 snd_env_head (env, JS_FILE_LIST);
1213 snd_flush ();
1214 return rcv_file_list (ret);
1215 }
1216
1217 static void re_alloc ();
1218
1219 static int
rcv_file_list(ret)1220 rcv_file_list (ret)
1221 struct wnn_ret_buf *ret;
1222 {
1223 register int i, count;
1224 WNN_FILE_INFO_STRUCT *files;
1225 count = get4com ();
1226 re_alloc (ret, sizeof (WNN_FILE_INFO_STRUCT) * count);
1227 files = (WNN_FILE_INFO_STRUCT *) ret->buf;
1228 for (i = 0; i < count; i++)
1229 {
1230 files->fid = get4com ();
1231 files->localf = get4com ();
1232 files->ref_count = get4com ();
1233 files->type = get4com ();
1234 getscom (files->name);
1235 files++;
1236 }
1237 return count;
1238 }
1239
1240 /** js_file_stat **/
1241 int
js_file_stat(env,path,s)1242 js_file_stat (env, path, s)
1243 struct wnn_env *env;
1244 char *path;
1245 WNN_FILE_STAT *s;
1246 {
1247 register int x;
1248 if (env == 0)
1249 return (-1);
1250 set_current_js (env->js_id);
1251 handler_of_jserver_dead (-1);
1252 snd_env_head (env, JS_FILE_STAT);
1253 putscom (path);
1254 snd_flush ();
1255 x = get4com ();
1256 s->type = x;
1257 return x;
1258 }
1259
1260
1261 /** js_file_info **/
1262 int
js_file_info(env,fid,file)1263 js_file_info (env, fid, file)
1264 struct wnn_env *env;
1265 int fid;
1266 register WNN_FILE_INFO_STRUCT *file;
1267 {
1268 register int x;
1269 if (env == 0)
1270 return (-1);
1271 set_current_js (env->js_id);
1272 handler_of_jserver_dead (-1);
1273 snd_env_head (env, JS_FILE_INFO);
1274 put4com (fid);
1275 snd_flush ();
1276 file->fid = fid;
1277 x = get4com ();
1278 if (x == -1)
1279 {
1280 wnn_errorno = get4com ();
1281 return (-1);
1282 }
1283 getscom (file->name);
1284 file->localf = get4com ();
1285 file->ref_count = get4com ();
1286 file->type = get4com ();
1287 return 0;
1288 }
1289
1290 /** js_file_loaded **/
1291 int
js_file_loaded(server,path)1292 js_file_loaded (server, path)
1293 WNN_JSERVER_ID *server;
1294 char *path;
1295 {
1296 register int x;
1297 set_current_js (server);
1298 handler_of_jserver_dead (-1);
1299 snd_server_head (server, JS_FILE_LOADED);
1300 putscom (path);
1301 snd_flush ();
1302 x = get4com ();
1303 return x;
1304 }
1305
1306 /** js_file_loaded_local **/
1307 static int check_local_file ();
1308 static int file_loaded_local ();
1309
1310 int
js_file_loaded_local(server,path)1311 js_file_loaded_local (server, path)
1312 WNN_JSERVER_ID *server;
1313 char *path;
1314 {
1315 int x;
1316 set_current_js (server);
1317 handler_of_jserver_dead (-1);
1318
1319 if (check_local_file (path) == -1)
1320 return (-1);
1321 snd_server_head (server, JS_FILE_LOADED_LOCAL);
1322 x = file_loaded_local (path);
1323 if (x == -1)
1324 {
1325 return -1;
1326 }
1327 return x;
1328 }
1329
1330 static int
check_local_file(path)1331 check_local_file (path)
1332 char *path;
1333 {
1334 register FILE *f;
1335 register int x;
1336 struct wnn_file_head fh;
1337
1338 #ifdef WRITE_CHECK
1339 check_backup (path);
1340 #endif /* WRITE_CHECK */
1341 f = fopen (path, "r");
1342 if (f == NULL)
1343 {
1344 wnn_errorno = WNN_OPENF_ERR;
1345 return -1;
1346 }
1347 x = input_file_header (f, &fh);
1348 if (x == -1)
1349 {
1350 fclose (f);
1351 wnn_errorno = WNN_NOT_A_FILE;
1352 return -1;
1353 }
1354 if (check_inode (f, &fh) == -1)
1355 {
1356 change_file_uniq (&fh, path);
1357 #ifdef WRITE_CHECK
1358 fclose (f);
1359 f = fopen (path, "r");
1360 if (f == NULL)
1361 {
1362 wnn_errorno = WNN_OPENF_ERR;
1363 return (-1);
1364 }
1365 #endif /* WRITE_CHECK */
1366 if (check_inode (f, &fh) == -1)
1367 {
1368 fclose (f);
1369 wnn_errorno = WNN_INODE_CHECK_ERROR;
1370 return (-1);
1371 }
1372 }
1373 fclose (f);
1374 return 0;
1375 }
1376
1377
1378 static int
file_loaded_local(path)1379 file_loaded_local (path)
1380 char *path;
1381 {
1382 register int x, i;
1383 FILE *f;
1384 struct wnn_file_head fh;
1385
1386 #ifdef WRITE_CHECK
1387 check_backup (path);
1388 #endif /* WRITE_CHECK */
1389 f = fopen (path, "r");
1390 if (f == NULL)
1391 {
1392 wnn_errorno = WNN_OPENF_ERR;
1393 return -1;
1394 }
1395 x = input_file_header (f, &fh);
1396 if (x == -1)
1397 {
1398 fclose (f);
1399 wnn_errorno = WNN_NOT_A_FILE;
1400 return -1;
1401 }
1402 put4com (fh.file_uniq.time);
1403 put4com (fh.file_uniq.dev);
1404 put4com (fh.file_uniq.inode);
1405 for (i = 0; i < WNN_HOSTLEN; i++)
1406 {
1407 put1com (fh.file_uniq.createhost[i]);
1408 }
1409
1410 snd_flush ();
1411 x = get4com ();
1412 fclose (f);
1413 return x;
1414 }
1415
1416
1417 /** js_hindo_file_create **/
1418 int
js_hindo_file_create(env,fid,fn,comment,hpasswd)1419 js_hindo_file_create (env, fid, fn, comment, hpasswd)
1420 struct wnn_env *env;
1421 int fid;
1422 char *fn;
1423 w_char *comment;
1424 char *hpasswd;
1425 {
1426 register int x;
1427 if (env == 0)
1428 return (-1);
1429 set_current_js (env->js_id);
1430 handler_of_jserver_dead (-1);
1431 snd_env_head (env, JS_HINDO_FILE_CREATE);
1432 put4com (fid);
1433 putscom (fn);
1434 putwscom (comment);
1435 putscom (hpasswd);
1436 snd_flush ();
1437 x = get4com ();
1438 if (x == -1)
1439 wnn_errorno = get4com ();
1440 return x;
1441 }
1442
1443 /** js_dic_file_create **/
1444 int
js_dic_file_create(env,fn,type,comment,passwd,hpasswd)1445 js_dic_file_create (env, fn, type, comment, passwd, hpasswd)
1446 struct wnn_env *env;
1447 char *fn;
1448 w_char *comment;
1449 char *passwd, *hpasswd;
1450 int type;
1451 {
1452 register int x;
1453 if (env == 0)
1454 return (-1);
1455 set_current_js (env->js_id);
1456 handler_of_jserver_dead (-1);
1457 snd_env_head (env, JS_DIC_FILE_CREATE);
1458 putscom (fn);
1459 putwscom (comment);
1460 putscom (passwd);
1461 putscom (hpasswd);
1462 put4com (type);
1463 snd_flush ();
1464 x = get4com ();
1465 if (x == -1)
1466 wnn_errorno = get4com ();
1467 return x;
1468 }
1469
1470
1471 /** js_file_discard **/
1472 int
js_file_discard(env,fid)1473 js_file_discard (env, fid)
1474 struct wnn_env *env;
1475 int fid;
1476 {
1477 register int x;
1478 if (env == 0)
1479 return (-1);
1480 set_current_js (env->js_id);
1481 handler_of_jserver_dead (-1);
1482 snd_env_head (env, JS_FILE_DISCARD);
1483 put4com (fid);
1484 snd_flush ();
1485 x = get4com ();
1486 if (x == -1)
1487 wnn_errorno = get4com ();
1488 return x;
1489 }
1490
1491 /** js_file_read **/
1492 int
js_file_read(env,fn)1493 js_file_read (env, fn)
1494 struct wnn_env *env;
1495 char *fn;
1496 {
1497 register int x;
1498 if (env == 0)
1499 return (-1);
1500 set_current_js (env->js_id);
1501 handler_of_jserver_dead (-1);
1502 snd_env_head (env, JS_FILE_READ);
1503 putscom (fn);
1504 snd_flush ();
1505 x = get4com ();
1506 if (x == -1)
1507 wnn_errorno = get4com ();
1508 return x;
1509 }
1510
1511 /** js_file_write **/
1512 int
js_file_write(env,fid,fn)1513 js_file_write (env, fid, fn)
1514 struct wnn_env *env;
1515 int fid;
1516 char *fn;
1517 {
1518 register int x;
1519 if (env == 0)
1520 return (-1);
1521 set_current_js (env->js_id);
1522 handler_of_jserver_dead (-1);
1523 snd_env_head (env, JS_FILE_WRITE);
1524 put4com (fid);
1525 putscom (fn);
1526 snd_flush ();
1527 x = get4com ();
1528 if (x == -1)
1529 wnn_errorno = get4com ();
1530 return x;
1531 }
1532
1533 /** js_file_receive **/
1534 static int xget1com ();
1535 static void xput1com ();
1536
1537 int
js_file_receive(env,fid,fn)1538 js_file_receive (env, fid, fn)
1539 struct wnn_env *env;
1540 int fid;
1541 char *fn;
1542 {
1543 register int mode, x;
1544 char file_name[1024];
1545 char buf[1024];
1546 FILE *f;
1547 int n;
1548 struct wnn_file_head fh;
1549 int i;
1550 #ifdef WRITE_CHECK
1551 char *tmp, *backup = NULL, tmp_x;
1552 int tmp_err = 0;
1553 #endif /* WRITE_CHECK */
1554
1555 if (env == 0)
1556 return (-1);
1557 set_current_js (env->js_id);
1558 handler_of_jserver_dead (-1);
1559 snd_env_head (env, JS_FILE_RECEIVE);
1560 put4com (fid);
1561 snd_flush ();
1562 /**/ getscom (file_name);
1563 if (fn == NULL || strcmp (fn, "") == 0)
1564 {
1565 gethostname (buf, 1024);
1566 n = strlen (buf);
1567 buf[n] = C_LOCAL;
1568 buf[n + 1] = 0;
1569 if (strncmp (buf, file_name, n + 1) == 0)
1570 {
1571 fn = file_name + n + 1;
1572 }
1573 }
1574 #ifdef WRITE_CHECK
1575 check_backup (fn);
1576 #endif /* WRITE_CHECK */
1577 if ((f = fopen (fn, "r")) == NULL)
1578 { /* New File */
1579 fh.file_uniq.time = fh.file_uniq.dev = fh.file_uniq.inode = 0;
1580 }
1581 else
1582 { /* Old File Exists */
1583 if (input_file_header (f, &fh) == -1)
1584 {
1585 wnn_errorno = WNN_NOT_A_FILE;
1586 fclose (f);
1587 put4com (-1);
1588 snd_flush ();
1589 sleep (1); /* enssure handshake */
1590 return (-1);
1591 }
1592 fclose (f);
1593 }
1594 put4com (0); /* Ack */
1595 put4com (fh.file_uniq.time);
1596 put4com (fh.file_uniq.dev);
1597 put4com (fh.file_uniq.inode);
1598 for (i = 0; i < WNN_HOSTLEN; i++)
1599 {
1600 put1com (fh.file_uniq.createhost[i]);
1601 }
1602
1603 snd_flush ();
1604
1605 if ((mode = get4com ()) == -1)
1606 { /* check stat */
1607 wnn_errorno = get4com ();
1608 return -1;
1609 }
1610 else if (mode == 0)
1611 {
1612 return 0; /* need not saving */
1613 }
1614 else if (mode == 1 || mode == 3)
1615 { /* mode == 3 means the file is a new one. */
1616 #ifdef WRITE_CHECK
1617 backup = make_backup_file (fn);
1618 if ((tmp = make_tmp_file (fn, 0, &f)) == NULL)
1619 {
1620 delete_tmp_file (backup);
1621 #else /* WRITE_CHECK */
1622 if ((f = fopen (fn, "w+")) == NULL)
1623 {
1624 #endif /* WRITE_CHECK */
1625 wnn_errorno = WNN_FILE_WRITE_ERROR;
1626 put4com (-1);
1627 snd_flush ();
1628 sleep (1); /* enssure handshake */
1629 return (-1);
1630 }
1631 }
1632 else if (mode == 2)
1633 {
1634 #ifdef WRITE_CHECK
1635 backup = make_backup_file (fn);
1636 if ((tmp = make_tmp_file (fn, 1, &f)) == NULL)
1637 {
1638 delete_tmp_file (backup);
1639 #else /* WRITE_CHECK */
1640 if ((f = fopen (fn, "r+")) == NULL)
1641 { /* New File */
1642 #endif /* WRITE_CHECK */
1643 wnn_errorno = WNN_FILE_WRITE_ERROR;
1644 put4com (-1);
1645 snd_flush ();
1646 sleep (1); /* enssure handshake */
1647 return (-1);
1648 }
1649 }
1650 put4com (0);
1651 snd_flush (); /* ACK */
1652 for (;;)
1653 {
1654 if ((x = xget1com ()) == -1)
1655 break; /* EOF */
1656 #ifdef WRITE_CHECK
1657 tmp_x = (char) x;
1658 if (fwrite (&tmp_x, sizeof (char), 1, f) == -1)
1659 tmp_err = 1;
1660 #else /* WRITE_CHECK */
1661 fputc (x, f);
1662 #endif /* WRITE_CHECK */
1663 }
1664 fclose (f);
1665 #ifdef WRITE_CHECK
1666 if (tmp_err == 0)
1667 {
1668 move_tmp_to_org (tmp, fn, 1);
1669 }
1670 else
1671 {
1672 delete_tmp_file (tmp);
1673 }
1674 delete_tmp_file (backup);
1675 #endif /* WRITE_CHECK */
1676
1677 x = get4com ();
1678 if (x == -1)
1679 wnn_errorno = get4com ();
1680 #ifdef WRITE_CHECK
1681 if (tmp_err)
1682 {
1683 wnn_errorno = WNN_FILE_WRITE_ERROR;
1684 return (-1);
1685 }
1686 #endif /* WRITE_CHECK */
1687
1688 return x;
1689 }
1690
1691 static int
xget1com()1692 xget1com ()
1693 {
1694 register int x;
1695 if ((x = get1com ()) != 0xFF)
1696 return x;
1697 if (get1com () == 0xFF)
1698 return -1; /* EOF */
1699 return 0xFF;
1700 }
1701
1702 /** js_file_send **/
1703 int
js_file_send(env,fn)1704 js_file_send (env, fn)
1705 struct wnn_env *env;
1706 char *fn;
1707 {
1708 register int x;
1709 FILE *f;
1710 int n;
1711 char buf[1024], *b;
1712 register int cc, i;
1713 if (env == 0)
1714 return (-1);
1715 set_current_js (env->js_id);
1716 handler_of_jserver_dead (-1);
1717
1718 if (check_local_file (fn) == -1)
1719 return (-1);
1720
1721 snd_env_head (env, JS_FILE_SEND);
1722 x = file_loaded_local (fn);
1723 if (x != -1)
1724 { /* file is already loaded */
1725 if (get4com () == -1)
1726 {
1727 wnn_errorno = get4com ();
1728 return (-1);
1729 }
1730 return x;
1731 }
1732
1733 x = get4com ();
1734 if (x == -1)
1735 {
1736 wnn_errorno = get4com ();
1737 return -1;
1738 }
1739
1740 gethostname (buf, 1024);
1741 n = strlen (buf);
1742 buf[n] = C_LOCAL;
1743 strcpy (buf + n + 1, fn);
1744 putscom (buf);
1745
1746 #ifdef WRITE_CHECK
1747 check_backup (fn);
1748 #endif /* WRITE_CHECK */
1749 if ((f = fopen (fn, "r")) == NULL)
1750 {
1751 xput1com (-1); /* EOF */
1752 return -1;
1753 }
1754
1755 /* send contents of file */
1756 for (;;)
1757 {
1758 cc = fread (buf, 1, 1024, f);
1759 if (cc <= 0)
1760 break; /* EOF */
1761 for (b = buf, i = 0; i < cc; i++)
1762 {
1763 xput1com ((int) *b++ & 0xff);
1764 }
1765 }
1766 fclose (f);
1767 xput1com (-1); /* EOF */
1768 snd_flush ();
1769 x = get4com ();
1770 if (x == -1)
1771 wnn_errorno = get4com ();
1772 return x;
1773 }
1774
1775 static void
xput1com(d)1776 xput1com (d)
1777 int d;
1778 {
1779 if (d == -1)
1780 {
1781 put1com (0xFF);
1782 put1com (0xFF);
1783 return; /* EOF */
1784 }
1785 put1com (d);
1786 if (d == 0xFF)
1787 {
1788 put1com (0x00);
1789 }
1790 }
1791
1792
1793 /*** Dic. Operation for Env. ***/
1794
1795 /** js_dic_add **/
1796 int
js_dic_add(env,fid,hfid,rev,jnice,rw,hrw,pw1,pw2)1797 js_dic_add (env, fid, hfid, rev, jnice, rw, hrw, pw1, pw2)
1798 struct wnn_env *env;
1799 int fid, hfid, rev, jnice, rw, hrw;
1800 char *pw1, *pw2;
1801 {
1802 register int x;
1803 if (env == 0)
1804 return (-1);
1805 set_current_js (env->js_id);
1806 handler_of_jserver_dead (-1);
1807 snd_env_head (env, JS_DIC_ADD);
1808 put4com (fid);
1809 put4com (hfid);
1810 put4com (jnice);
1811 put4com (rw);
1812 put4com (hrw);
1813 putscom (pw1);
1814 putscom (pw2);
1815 put4com (rev); /* rev is to add it as reverse dict */
1816 snd_flush ();
1817 x = get4com ();
1818 if (x == -1)
1819 wnn_errorno = get4com ();
1820 return x;
1821 }
1822
1823 /** js_dic_delete **/
1824 int
js_dic_delete(env,dicno)1825 js_dic_delete (env, dicno)
1826 struct wnn_env *env;
1827 int dicno;
1828 {
1829 register int x;
1830 if (env == 0)
1831 return (-1);
1832 set_current_js (env->js_id);
1833 handler_of_jserver_dead (-1);
1834 snd_env_head (env, JS_DIC_DELETE);
1835 put4com (dicno);
1836 snd_flush ();
1837 x = get4com ();
1838 if (x == -1)
1839 wnn_errorno = get4com ();
1840 return x;
1841 }
1842
1843 /** js_dic_use **/
1844 int
js_dic_use(env,dic_no,flag)1845 js_dic_use (env, dic_no, flag)
1846 struct wnn_env *env;
1847 int dic_no, flag;
1848 {
1849 register int x;
1850 if (env == 0)
1851 return (-1);
1852 set_current_js (env->js_id);
1853 handler_of_jserver_dead (-1);
1854 snd_env_head (env, JS_DIC_USE);
1855 put4com (dic_no);
1856 put4com (flag);
1857 snd_flush ();
1858 x = get4com ();
1859 if (x == -1)
1860 wnn_errorno = get4com ();
1861 return x;
1862 }
1863
1864 /** js_fuzokugo_set **/
1865 int
js_fuzokugo_set(env,fid)1866 js_fuzokugo_set (env, fid)
1867 struct wnn_env *env;
1868 int fid;
1869 {
1870 register int x;
1871 if (env == 0)
1872 return (-1);
1873 set_current_js (env->js_id);
1874 handler_of_jserver_dead (-1);
1875 snd_env_head (env, JS_FUZOKUGO_SET);
1876 put4com (fid);
1877 snd_flush ();
1878 x = get4com ();
1879 if (x == -1)
1880 wnn_errorno = get4com ();
1881 return x;
1882 }
1883
1884 /** js_fuzokugo_get **/
1885 int
js_fuzokugo_get(env)1886 js_fuzokugo_get (env)
1887 struct wnn_env *env;
1888 {
1889 register int x;
1890 if (env == 0)
1891 return (-1);
1892 set_current_js (env->js_id);
1893 handler_of_jserver_dead (-1);
1894 snd_env_head (env, JS_FUZOKUGO_GET);
1895 snd_flush ();
1896 x = get4com ();
1897 if (x == -1)
1898 wnn_errorno = get4com ();
1899 return x;
1900 }
1901
1902 /** js_dic_list_all **/
1903 static int rcv_dic_list ();
1904 static void get_dic_info ();
1905
1906 int
js_dic_list_all(server,ret)1907 js_dic_list_all (server, ret)
1908 WNN_JSERVER_ID *server;
1909 struct wnn_ret_buf *ret;
1910 {
1911 set_current_js (server);
1912 handler_of_jserver_dead (-1);
1913 snd_server_head (server, JS_DIC_LIST_ALL);
1914 snd_flush ();
1915 return rcv_dic_list (ret);
1916 }
1917
1918
1919 /** js_dic_list **/
1920 int
js_dic_list(env,ret)1921 js_dic_list (env, ret)
1922 struct wnn_env *env;
1923 struct wnn_ret_buf *ret;
1924 {
1925 if (env == 0)
1926 return (-1);
1927 set_current_js (env->js_id);
1928 handler_of_jserver_dead (-1);
1929 snd_env_head (env, JS_DIC_LIST);
1930 snd_flush ();
1931 return rcv_dic_list (ret);
1932 }
1933
1934 static int
rcv_dic_list(ret)1935 rcv_dic_list (ret)
1936 struct wnn_ret_buf *ret;
1937 {
1938 register int i, count;
1939 register WNN_DIC_INFO *dic;
1940 count = get4com ();
1941 re_alloc (ret, sizeof (WNN_DIC_INFO) * (count + 1));
1942
1943 dic = (WNN_DIC_INFO *) ret->buf;
1944 for (i = 0; i < count; i++)
1945 {
1946 get_dic_info (dic);
1947 dic++;
1948 }
1949 dic->dic_no = -1;
1950 return count;
1951 }
1952
1953 static void
get_dic_info(dic)1954 get_dic_info (dic)
1955 register WNN_DIC_INFO *dic;
1956 {
1957 dic->dic_no = get4com (); /* dic_No */
1958 dic->body = get4com (); /* body fid */
1959 dic->hindo = get4com (); /* hindo fid */
1960 dic->rw = get4com (); /* r/w */
1961 dic->hindo_rw = get4com (); /* hindo r/w */
1962 dic->enablef = get4com (); /* enable/disable */
1963 dic->nice = get4com (); /* nice */
1964 dic->rev = get4com ();
1965 /* added H.T */
1966 getwscom (dic->comment);
1967 getscom (dic->fname);
1968 getscom (dic->hfname);
1969 getscom (dic->passwd);
1970 getscom (dic->hpasswd);
1971 dic->type = get4com ();
1972 dic->gosuu = get4com ();
1973 dic->localf = get4com ();
1974 dic->hlocalf = get4com ();
1975 }
1976
1977 /*** Dic. Operation by dic_No. ***/
1978
1979 /** js_word_add **/
1980 int
js_word_add(env,dic_no,yomi,kanji,comment,hinshi,init_hindo)1981 js_word_add (env, dic_no, yomi, kanji, comment, hinshi, init_hindo)
1982 struct wnn_env *env;
1983 int dic_no;
1984 w_char *yomi, *kanji, *comment;
1985 int hinshi, init_hindo;
1986 {
1987 register int x;
1988 if (env == 0)
1989 return (-1);
1990 set_current_js (env->js_id);
1991 handler_of_jserver_dead (-1);
1992 snd_env_head (env, JS_WORD_ADD);
1993 put4com (dic_no);
1994 putwscom (yomi);
1995 putwscom (kanji);
1996 putwscom (comment);
1997 put4com (hinshi);
1998 put4com (init_hindo);
1999 snd_flush ();
2000 x = get4com ();
2001 if (x == -1)
2002 wnn_errorno = get4com ();
2003 return x;
2004 }
2005
2006 /** js_word_delete **/
2007 int
js_word_delete(env,dic_no,entry)2008 js_word_delete (env, dic_no, entry)
2009 struct wnn_env *env;
2010 int dic_no;
2011 int entry;
2012 {
2013 register int x;
2014 if (env == 0)
2015 return (-1);
2016 set_current_js (env->js_id);
2017 handler_of_jserver_dead (-1);
2018 snd_env_head (env, JS_WORD_DELETE);
2019 put4com (dic_no);
2020 put4com (entry);
2021 snd_flush ();
2022 x = get4com ();
2023 if (x == -1)
2024 wnn_errorno = get4com ();
2025 return x;
2026 }
2027
2028
2029 /** js_word_search **/
2030 static int rcv_word_data ();
2031
2032 int
js_word_search(env,dic_no,yomi,ret)2033 js_word_search (env, dic_no, yomi, ret)
2034 struct wnn_env *env;
2035 int dic_no;
2036 w_char *yomi;
2037 struct wnn_ret_buf *ret;
2038 {
2039 if (env == 0)
2040 return (-1);
2041 set_current_js (env->js_id);
2042 handler_of_jserver_dead (-1);
2043 snd_env_head (env, JS_WORD_SEARCH);
2044 put4com (dic_no);
2045 putwscom (yomi);
2046 snd_flush ();
2047
2048 return (rcv_word_data (ret, yomi));
2049 }
2050
2051 /** js_word_search_by_env **/
2052 int
js_word_search_by_env(env,yomi,ret)2053 js_word_search_by_env (env, yomi, ret)
2054 struct wnn_env *env;
2055 w_char *yomi;
2056 struct wnn_ret_buf *ret;
2057 {
2058 if (env == 0)
2059 return (-1);
2060 set_current_js (env->js_id);
2061 handler_of_jserver_dead (-1);
2062 snd_env_head (env, JS_WORD_SEARCH_BY_ENV);
2063 putwscom (yomi);
2064 snd_flush ();
2065
2066 return (rcv_word_data (ret, yomi));
2067 }
2068
2069 /** js_word_info **/
2070 int
js_word_info(env,dic_no,entry,ret)2071 js_word_info (env, dic_no, entry, ret)
2072 struct wnn_env *env;
2073 int dic_no, entry;
2074 struct wnn_ret_buf *ret;
2075 {
2076 register int x;
2077 w_char yomi[LENGTHYOMI];
2078
2079 if (env == 0)
2080 return (-1);
2081 set_current_js (env->js_id);
2082 handler_of_jserver_dead (-1);
2083 snd_env_head (env, JS_WORD_INFO);
2084 put4com (dic_no);
2085 put4com (entry);
2086 snd_flush ();
2087 x = get4com ();
2088 if (x == -1)
2089 {
2090 wnn_errorno = get4com ();
2091 return (-1);
2092 }
2093 getwscom (yomi);
2094 rcv_word_data (ret, yomi);
2095 return (0);
2096 }
2097
2098 int
js_word_comment_set(env,dic_no,entry,comment)2099 js_word_comment_set (env, dic_no, entry, comment)
2100 struct wnn_env *env;
2101 int dic_no, entry;
2102 w_char *comment;
2103 {
2104 register int x;
2105 if (env == 0)
2106 return (-1);
2107 set_current_js (env->js_id);
2108 handler_of_jserver_dead (-1);
2109 snd_env_head (env, JS_WORD_COMMENT_SET);
2110 put4com (dic_no);
2111 put4com (entry);
2112 putwscom (comment);
2113 snd_flush ();
2114 x = get4com ();
2115 if (x == -1)
2116 {
2117 wnn_errorno = get4com ();
2118 return (-1);
2119 }
2120 return (0);
2121 }
2122
2123 /** rcv for word_search **/
2124 static int
rcv_word_data(ret,yomi)2125 rcv_word_data (ret, yomi)
2126 struct wnn_ret_buf *ret;
2127 w_char *yomi; /* Yomi is not sent from server
2128 * (at least for the time being).
2129 */
2130 {
2131 register int x, j_c, k_c;
2132 w_char *k;
2133 register struct wnn_jdata *jd;
2134 register int cnt;
2135
2136 j_c = get4com ();
2137 k_c = get4com ();
2138 re_alloc (ret, sizeof (struct wnn_jdata) * (j_c + 1) + sizeof (w_char) * (k_c + j_c * 3 + j_c * wnn_Strlen (yomi)));
2139 jd = (struct wnn_jdata *) ret->buf;
2140 for (cnt = 0;; cnt++)
2141 {
2142 jd->dic_no = x = get4com ();
2143 if (x == -1)
2144 break;
2145 jd->serial = get4com ();
2146 jd->hinshi = get4com ();
2147 jd->hindo = get4com ();
2148 jd->ima = get4com ();
2149 jd->int_hindo = get4com ();
2150 jd->int_ima = get4com ();
2151 jd++;
2152 }
2153 jd++;
2154 k = (w_char *) jd;
2155 jd = (struct wnn_jdata *) ret->buf;
2156 for (;;)
2157 {
2158 if (jd->dic_no == -1)
2159 break;
2160
2161 jd->yomi = k; /* Copy Yomi */
2162 wnn_Strcpy (k, yomi);
2163 k += wnn_Strlen (k) + 1;
2164
2165 jd->kanji = k; /* Get Kanji */
2166 getwscom (k);
2167 k += wnn_Strlen (k) + 1;
2168
2169 jd->com = k; /* Get Comment */
2170 getwscom (k);
2171 k += wnn_Strlen (k) + 1;
2172 jd++;
2173 }
2174 return cnt;
2175 }
2176
2177
2178 /** js_dic_info **/
2179 int
js_dic_info(env,dic_no,ret)2180 js_dic_info (env, dic_no, ret)
2181 struct wnn_env *env;
2182 int dic_no;
2183 register WNN_DIC_INFO *ret;
2184 {
2185 register int x;
2186 if (env == 0)
2187 return (-1);
2188 set_current_js (env->js_id);
2189 handler_of_jserver_dead (-1);
2190 snd_env_head (env, JS_DIC_INFO);
2191 put4com (dic_no);
2192 snd_flush ();
2193 x = get4com ();
2194 if (x == -1)
2195 {
2196 return get4com ();
2197 }
2198 get_dic_info (ret);
2199 return dic_no;
2200 }
2201
2202
2203 /** js_who **/
2204 int
js_who(server,ret)2205 js_who (server, ret)
2206 WNN_JSERVER_ID *server;
2207 struct wnn_ret_buf *ret;
2208 {
2209 register int i, j, c;
2210 WNN_JWHO *w;
2211 set_current_js (server);
2212 handler_of_jserver_dead (-1);
2213 snd_server_head (server, JS_WHO);
2214 snd_flush ();
2215
2216 c = get4com ();
2217 if (c == -1)
2218 {
2219 wnn_errorno = get4com ();
2220 return -1;
2221 }
2222
2223 re_alloc (ret, sizeof (WNN_JWHO) * c);
2224 w = (WNN_JWHO *) ret->buf;
2225 for (i = 0; i < c; i++)
2226 {
2227 w->sd = get4com ();
2228 getscom (w->user_name);
2229 getscom (w->host_name);
2230 for (j = 0; j < WNN_MAX_ENV_OF_A_CLIENT; j++)
2231 {
2232 (w->env)[j] = get4com ();
2233 }
2234 w++;
2235 }
2236 return (c);
2237 }
2238
2239 /** jserver ������ƤδĶ��˴ؤ����������롣
2240 (���鵻)
2241 **/
2242 int
js_env_list(server,ret)2243 js_env_list (server, ret)
2244 WNN_JSERVER_ID *server;
2245 struct wnn_ret_buf *ret;
2246 {
2247 register int i, j, c;
2248 WNN_ENV_INFO *w;
2249 set_current_js (server);
2250 handler_of_jserver_dead (-1);
2251 snd_server_head (server, JS_ENV_LIST);
2252 snd_flush ();
2253
2254 c = get4com ();
2255 if (c == -1)
2256 {
2257 wnn_errorno = get4com ();
2258 return -1;
2259 }
2260
2261 re_alloc (ret, sizeof (WNN_ENV_INFO) * c);
2262 w = (WNN_ENV_INFO *) ret->buf;
2263 for (i = 0; i < c; i++)
2264 {
2265 w->env_id = get4com ();
2266 getscom (w->env_name);
2267 w->ref_count = get4com ();
2268 w->fzk_fid = get4com ();
2269 w->jishomax = get4com ();
2270 for (j = 0; j < WNN_MAX_JISHO_OF_AN_ENV; j++)
2271 {
2272 (w->jisho)[j] = get4com ();
2273 }
2274 for (j = 0; j < WNN_MAX_FILE_OF_AN_ENV; j++)
2275 {
2276 (w->file)[j] = get4com ();
2277 }
2278 w++;
2279 }
2280 return (c);
2281 }
2282
2283 /****
2284
2285 ****/
2286 int
js_hindo_set(env,dic,entry,ima,hindo)2287 js_hindo_set (env, dic, entry, ima, hindo)
2288 struct wnn_env *env;
2289 int dic, entry, ima, hindo;
2290 {
2291 register int x;
2292 if (env == 0)
2293 return (-1);
2294 set_current_js (env->js_id);
2295 handler_of_jserver_dead (-1);
2296 snd_env_head (env, JS_HINDO_SET);
2297
2298 put4com (dic);
2299 put4com (entry);
2300 put4com (ima);
2301 put4com (hindo);
2302 snd_flush ();
2303 if ((x = get4com ()) == -1)
2304 {
2305 wnn_errorno = get4com ();
2306 return -1;
2307 }
2308 return x;
2309 }
2310
2311
2312 /****
2313 Henkan
2314 ****/
2315
2316 static void
put_fzk_vec(hinsi,fzk,vec,vec1)2317 put_fzk_vec (hinsi, fzk, vec, vec1)
2318 int hinsi;
2319 w_char *fzk;
2320 int vec;
2321 int vec1;
2322 {
2323 put4com (hinsi);
2324 putwscom (fzk);
2325 put4com (vec);
2326 put4com (vec1);
2327 }
2328
2329 /**
2330 kanren
2331 **/
2332 static int rcv_dai ();
2333 static void rcv_sho_x ();
2334 static void rcv_sho_kanji ();
2335
2336 int
js_kanren(env,yomi,hinsi,fzk,vec,vec1,vec2,rb)2337 js_kanren (env, yomi, hinsi, fzk, vec, vec1, vec2, rb)
2338 struct wnn_env *env;
2339 w_char *yomi;
2340 int hinsi;
2341 w_char *fzk;
2342 int vec;
2343 int vec1;
2344 int vec2;
2345 struct wnn_ret_buf *rb;
2346 {
2347 if (env == 0)
2348 return (-1);
2349 set_current_js (env->js_id);
2350 handler_of_jserver_dead (-1);
2351
2352 snd_env_head (env, JS_KANREN);
2353 putwscom (yomi);
2354 put_fzk_vec (hinsi, fzk, vec, vec1);
2355 put4com (vec2);
2356 snd_flush ();
2357 return rcv_dai (rb);
2358 }
2359
2360 /* rcv dai */
2361 static int
rcv_dai(ret)2362 rcv_dai (ret)
2363 struct wnn_ret_buf *ret;
2364 {
2365 int dai_cnt, sho_sum, kanji_sum, d_size, s_size, k_size, x;
2366 register int i;
2367 struct wnn_dai_bunsetsu *dai_list;
2368 register struct wnn_dai_bunsetsu *dp;
2369 struct wnn_sho_bunsetsu *sho_list;
2370 register struct wnn_sho_bunsetsu *sp;
2371 w_char *kanji, *kp;
2372
2373 dai_cnt = get4com ();
2374 if (dai_cnt == -1)
2375 { /* error dayo */
2376 wnn_errorno = get4com ();
2377 return -1;
2378 }
2379 sho_sum = get4com ();
2380 kanji_sum = get4com ();
2381
2382 d_size = sizeof (struct wnn_dai_bunsetsu) * dai_cnt;
2383 s_size = sizeof (struct wnn_sho_bunsetsu) * sho_sum;
2384 k_size = sizeof (w_char) * kanji_sum;
2385
2386 /* re_alloc(ret, d_size+s_size+k_size); Seems This cause Bug?? H.T.*/
2387 re_alloc (ret, d_size + s_size + k_size);
2388
2389 dai_list = (struct wnn_dai_bunsetsu *) ret->buf;
2390 sho_list = (struct wnn_sho_bunsetsu *) ((char *) ret->buf + d_size);
2391 kanji = (w_char *) ((char *) ret->buf + d_size + s_size);
2392
2393 for (dp = dai_list, i = 0; i < dai_cnt; i++)
2394 {
2395 dp->end = get4com ();
2396 dp->start = get4com ();
2397 dp->sbncnt = get4com ();
2398 dp->hyoka = get4com ();
2399 dp++;
2400 }
2401
2402 for (dp = dai_list, sp = sho_list, i = 0; i < dai_cnt; i++)
2403 {
2404 dp->sbn = sp;
2405 x = dp->sbncnt;
2406 rcv_sho_x (sp, x);
2407 sp += x;
2408 dp++;
2409 }
2410
2411 for (dp = dai_list, kp = kanji, i = 0; i < dai_cnt; i++)
2412 {
2413 rcv_sho_kanji (dp->sbn, dp->sbncnt, &kp);
2414 dp++;
2415 }
2416 return dai_cnt;
2417 }
2418
2419 /* rcv sho routines */
2420 static void
rcv_sho_x(sho_list,sho_cnt)2421 rcv_sho_x (sho_list, sho_cnt)
2422 register struct wnn_sho_bunsetsu *sho_list;
2423 int sho_cnt;
2424 {
2425 register int i;
2426 for (i = 0; i < sho_cnt; i++)
2427 {
2428 sho_list->end = get4com ();
2429 sho_list->start = get4com ();
2430 sho_list->jiriend = get4com ();
2431 sho_list->dic_no = get4com ();
2432 sho_list->entry = get4com ();
2433 sho_list->hindo = get4com ();
2434 sho_list->ima = get4com ();
2435 sho_list->hinsi = get4com ();
2436 sho_list->status = get4com ();
2437 sho_list->status_bkwd = get4com ();
2438 sho_list->kangovect = get4com ();
2439 sho_list->hyoka = get4com ();
2440 sho_list++;
2441 }
2442 }
2443
2444 static void
rcv_sho_kanji(sho_list,sho_cnt,kanji)2445 rcv_sho_kanji (sho_list, sho_cnt, kanji)
2446 struct wnn_sho_bunsetsu *sho_list;
2447 int sho_cnt;
2448 w_char **kanji;
2449 {
2450 register w_char *k;
2451 register int i, x;
2452 k = *kanji;
2453 for (i = 0; i < sho_cnt; i++)
2454 {
2455 sho_list->kanji = k;
2456 getwscom (k);
2457 x = wnn_Strlen (k);
2458 k += x + 1;
2459
2460 sho_list->yomi = k;
2461 getwscom (k);
2462 x = wnn_Strlen (k);
2463 k += x + 1;
2464
2465 sho_list->fuzoku = k;
2466 getwscom (k);
2467 x = wnn_Strlen (k);
2468 k += x + 1;
2469 sho_list++;
2470 }
2471 *kanji = k;
2472 }
2473
2474
2475 static int
rcv_sho(ret)2476 rcv_sho (ret)
2477 struct wnn_ret_buf *ret;
2478 {
2479 register int sho_sum, kanji_sum, s_size, k_size;
2480 struct wnn_sho_bunsetsu *sho_list;
2481 w_char *kanji, *kp;
2482
2483 sho_sum = get4com ();
2484 if (sho_sum == -1)
2485 { /* error dayo */
2486 wnn_errorno = get4com ();
2487 return -1;
2488 }
2489 kanji_sum = get4com ();
2490
2491 s_size = sizeof (struct wnn_sho_bunsetsu) * sho_sum;
2492 k_size = sizeof (w_char) * kanji_sum;
2493
2494 re_alloc (ret, s_size + k_size);
2495
2496 sho_list = (struct wnn_sho_bunsetsu *) ((char *) ret->buf);
2497 kanji = (w_char *) ((char *) ret->buf + s_size);
2498
2499 rcv_sho_x (sho_list, sho_sum);
2500 kp = kanji;
2501 rcv_sho_kanji (sho_list, sho_sum, &kp);
2502 return sho_sum;
2503 }
2504
2505 /**
2506 kantan
2507 **/
2508 int
js_kantan_dai(env,yomi,hinsi,fzk,vec,vec1,rb)2509 js_kantan_dai (env, yomi, hinsi, fzk, vec, vec1, rb)
2510 struct wnn_env *env;
2511 w_char *yomi;
2512 int hinsi;
2513 w_char *fzk;
2514 int vec;
2515 int vec1;
2516 struct wnn_ret_buf *rb;
2517 {
2518 if (env == 0)
2519 return (-1);
2520 set_current_js (env->js_id);
2521 handler_of_jserver_dead (-1);
2522
2523 snd_env_head (env, JS_KANTAN_DAI);
2524 putwscom (yomi);
2525 put_fzk_vec (hinsi, fzk, vec, vec1);
2526 snd_flush ();
2527
2528 return rcv_dai (rb);
2529 }
2530
2531 int
js_kantan_sho(env,yomi,hinsi,fzk,vec,vec1,rb)2532 js_kantan_sho (env, yomi, hinsi, fzk, vec, vec1, rb)
2533 struct wnn_env *env;
2534 w_char *yomi;
2535 int hinsi;
2536 w_char *fzk;
2537 int vec;
2538 int vec1;
2539 struct wnn_ret_buf *rb;
2540 {
2541 int sbncnt;
2542 if (env == 0)
2543 return (-1);
2544 set_current_js (env->js_id);
2545 handler_of_jserver_dead (-1);
2546
2547 snd_env_head (env, JS_KANTAN_SHO);
2548 putwscom (yomi);
2549 put_fzk_vec (hinsi, fzk, vec, vec1);
2550 snd_flush ();
2551
2552 sbncnt = rcv_sho (rb);
2553 return sbncnt;
2554 }
2555
2556 /**
2557 kanzen
2558 **/
2559 int
js_kanzen_dai(env,yomi,hinsi,fzk,vec,vec1,rb)2560 js_kanzen_dai (env, yomi, hinsi, fzk, vec, vec1, rb)
2561 struct wnn_env *env;
2562 w_char *yomi;
2563 int hinsi;
2564 w_char *fzk;
2565 int vec;
2566 int vec1;
2567 struct wnn_ret_buf *rb;
2568 {
2569 if (env == 0)
2570 return (-1);
2571 set_current_js (env->js_id);
2572 handler_of_jserver_dead (-1);
2573 snd_env_head (env, JS_KANZEN_DAI);
2574 putwscom (yomi);
2575 put_fzk_vec (hinsi, fzk, vec, vec1);
2576 snd_flush ();
2577
2578 return rcv_dai (rb);
2579 }
2580
2581
2582 int
js_kanzen_sho(env,yomi,hinsi,fzk,vec,vec1,rb)2583 js_kanzen_sho (env, yomi, hinsi, fzk, vec, vec1, rb)
2584 struct wnn_env *env;
2585 w_char *yomi;
2586 int hinsi;
2587 w_char *fzk;
2588 int vec;
2589 int vec1;
2590 struct wnn_ret_buf *rb;
2591 {
2592 int sbncnt;
2593 if (env == 0)
2594 return (-1);
2595 set_current_js (env->js_id);
2596 handler_of_jserver_dead (-1);
2597 snd_env_head (env, JS_KANZEN_SHO);
2598 putwscom (yomi);
2599 put_fzk_vec (hinsi, fzk, vec, vec1);
2600 snd_flush ();
2601
2602 sbncnt = rcv_sho (rb);
2603 return sbncnt;
2604 }
2605
2606 /** js_version **/
2607 int
js_version(server,serv,libv)2608 js_version (server, serv, libv)
2609 int *serv, *libv;
2610 WNN_JSERVER_ID *server;
2611 {
2612 set_current_js (server);
2613 handler_of_jserver_dead (-1);
2614 snd_server_head (server, JS_VERSION);
2615 snd_flush ();
2616 *libv = JLIB_VERSION;
2617 return *serv = get4com ();
2618 }
2619
2620 static void
re_alloc(ret,size)2621 re_alloc (ret, size)
2622 register struct wnn_ret_buf *ret;
2623 int size;
2624 {
2625 if (ret->size < size)
2626 {
2627 if (ret->buf)
2628 free ((char *) ret->buf);
2629 ret->buf = malloc (size);
2630 ret->size = size;
2631 }
2632 }
2633
2634
2635 int
js_kill(server)2636 js_kill (server)
2637 WNN_JSERVER_ID *server;
2638 {
2639 int x;
2640 set_current_js (server);
2641 handler_of_jserver_dead (-1);
2642 snd_server_head (server, JS_KILL);
2643 snd_flush ();
2644 x = get4com ();
2645 return (x);
2646 }
2647
2648
2649 int
js_file_remove(server,n,pwd)2650 js_file_remove (server, n, pwd)
2651 WNN_JSERVER_ID *server;
2652 char *n, *pwd;
2653 {
2654 register int x;
2655 set_current_js (server);
2656 handler_of_jserver_dead (-1);
2657 snd_server_head (server, JS_FILE_REMOVE);
2658 putscom (n);
2659 putscom (pwd);
2660 snd_flush ();
2661 if ((x = get4com ()) == -1)
2662 {
2663 wnn_errorno = get4com ();
2664 return -1;
2665 }
2666 return (x);
2667 }
2668
2669 int
js_file_remove_client(server,n,pwd)2670 js_file_remove_client (server, n, pwd)
2671 WNN_JSERVER_ID *server;
2672 char *n, *pwd;
2673 {
2674 struct wnn_file_head fh;
2675 register FILE *fp;
2676 set_current_js (server);
2677 handler_of_jserver_dead (-1);
2678 if (js_file_loaded_local (server, n) != -1)
2679 {
2680 wnn_errorno = WNN_FILE_IN_USE;
2681 return (-1);
2682 }
2683 #ifdef WRITE_CHECK
2684 check_backup (n);
2685 #endif /* WRITE_CHECK */
2686 if ((fp = fopen (n, "r")) == NULL)
2687 {
2688 wnn_errorno = WNN_FILE_READ_ERROR;
2689 return (-1);
2690 }
2691 if (input_file_header (fp, &fh) == -1)
2692 {
2693 fclose (fp);
2694 wnn_errorno = WNN_NOT_A_FILE;
2695 return (-1);
2696 }
2697 fclose (fp);
2698 if (!check_pwd (pwd, fh.file_passwd))
2699 {
2700 wnn_errorno = WNN_INCORRECT_PASSWD;
2701 return (-1);
2702 }
2703 if (unlink (n) == -1)
2704 {
2705 wnn_errorno = WNN_UNLINK;
2706 return (-1);
2707 }
2708 return (0);
2709 }
2710
2711 /** js_dic_file_create_client **/
2712 int
js_dic_file_create_client(env,fn,type,com,passwd,hpasswd)2713 js_dic_file_create_client (env, fn, type, com, passwd, hpasswd)
2714 struct wnn_env *env;
2715 int type;
2716 char *fn;
2717 w_char *com;
2718 char *passwd, *hpasswd;
2719 {
2720 int x;
2721 if (type != WNN_REV_DICT && type != CWNN_REV_DICT && type != BWNN_REV_DICT && type != WNN_UD_DICT)
2722 {
2723 wnn_errorno = WNN_NOT_A_UD;
2724 return (-1);
2725 }
2726 x = create_null_dic (fn, com, passwd, hpasswd, type);
2727 if (x == -1)
2728 {
2729 wnn_errorno = WNN_FILE_CREATE_ERROR;
2730 return (-1);
2731 }
2732 return (0);
2733 }
2734
2735
2736 /** js_hindo_file_create_client **/
2737 int
js_hindo_file_create_client(env,fid,fn,com,hpasswd)2738 js_hindo_file_create_client (env, fid, fn, com, hpasswd)
2739 struct wnn_env *env;
2740 int fid;
2741 char *fn;
2742 w_char *com;
2743 char *hpasswd;
2744 {
2745 register int x;
2746 struct wnn_file_uniq funiq;
2747 int serial;
2748 register int i;
2749
2750 if (env == 0)
2751 return (-1);
2752 set_current_js (env->js_id);
2753 handler_of_jserver_dead (-1);
2754 snd_env_head (env, JS_HINDO_FILE_CREATE_CLIENT);
2755 put4com (fid);
2756 snd_flush ();
2757 x = get4com ();
2758 if (x == -1)
2759 {
2760 wnn_errorno = get4com ();
2761 return (-1);
2762 }
2763 serial = get4com ();
2764 funiq.time = get4com ();
2765 funiq.dev = get4com ();
2766 funiq.inode = get4com ();
2767 for (i = 0; i < WNN_HOSTLEN; i++)
2768 {
2769 funiq.createhost[i] = get1com ();
2770 }
2771 /* getscom(funiq.createhost); */
2772 if (create_hindo_file (&funiq, fn, com, hpasswd, serial) == -1)
2773 {
2774 wnn_errorno = WNN_FILE_CREATE_ERROR;
2775 return (-1);
2776 }
2777 return (0);
2778 }
2779
2780 int
js_file_comment_set(env,fid,comment)2781 js_file_comment_set (env, fid, comment)
2782 struct wnn_env *env;
2783 int fid;
2784 w_char *comment;
2785 {
2786 register int x;
2787 if (env == 0)
2788 return (-1);
2789 set_current_js (env->js_id);
2790 handler_of_jserver_dead (-1);
2791 snd_env_head (env, JS_FILE_COMMENT_SET);
2792 put4com (fid);
2793 putwscom (comment);
2794 snd_flush ();
2795 x = get4com ();
2796 if (x == -1)
2797 {
2798 wnn_errorno = get4com ();
2799 return (-1);
2800 }
2801 return (0);
2802 }
2803
2804
2805 /*
2806 * Hinsi Primitives
2807 */
2808
2809 int
js_hinsi_name(server,no,rb)2810 js_hinsi_name (server, no, rb)
2811 WNN_JSERVER_ID *server;
2812 int no;
2813 struct wnn_ret_buf *rb;
2814 {
2815 register int size;
2816
2817 set_current_js (server);
2818 handler_of_jserver_dead (-1);
2819 snd_server_head (server, JS_HINSI_NAME);
2820 put4com (no);
2821 snd_flush ();
2822 if ((size = get4com ()) == -1)
2823 {
2824 wnn_errorno = get4com ();
2825 return (-1);
2826 }
2827 re_alloc (rb, sizeof (w_char) * (size + 1));
2828 getwscom ((w_char *) rb->buf);
2829 return (0);
2830 }
2831
2832
2833 int
js_hinsi_number(server,name)2834 js_hinsi_number (server, name)
2835 WNN_JSERVER_ID *server;
2836 w_char *name;
2837 {
2838 register int no;
2839
2840 set_current_js (server);
2841 handler_of_jserver_dead (-1);
2842 snd_server_head (server, JS_HINSI_NUMBER);
2843 putwscom (name);
2844 snd_flush ();
2845 if ((no = get4com ()) == -1)
2846 {
2847 wnn_errorno = get4com ();
2848 return (-1);
2849 }
2850 return (no);
2851 }
2852
2853
2854 int
js_hinsi_list(env,dic_no,name,rb)2855 js_hinsi_list (env, dic_no, name, rb)
2856 struct wnn_env *env;
2857 int dic_no;
2858 w_char *name;
2859 struct wnn_ret_buf *rb;
2860 {
2861 int size;
2862 int count;
2863 register w_char *s;
2864 register w_char **r;
2865 register int k;
2866
2867 if (env == 0)
2868 return (-1);
2869 set_current_js (env->js_id);
2870 handler_of_jserver_dead (-1);
2871 snd_env_head (env, JS_HINSI_LIST);
2872 put4com (dic_no);
2873 putwscom (name);
2874 snd_flush ();
2875 if ((count = get4com ()) == -1)
2876 {
2877 wnn_errorno = get4com ();
2878 return (-1);
2879 }
2880 size = get4com ();
2881 re_alloc (rb, sizeof (w_char) * (size + 1) + count * sizeof (w_char *));
2882 r = (w_char **) rb->buf;
2883 s = (w_char *) ((w_char **) rb->buf + count);
2884 for (k = 0; k < count; k++)
2885 {
2886 *r++ = s;
2887 getwscom (s);
2888 s += wnn_Strlen (s) + 1;
2889 }
2890 return (count);
2891 }
2892
2893
2894 int
js_hinsi_dicts(env,no,rb)2895 js_hinsi_dicts (env, no, rb)
2896 struct wnn_env *env;
2897 int no;
2898 struct wnn_ret_buf *rb;
2899 {
2900 register int k, count;
2901 int *p;
2902
2903 if (env == 0)
2904 return (-1);
2905 set_current_js (env->js_id);
2906 handler_of_jserver_dead (-1);
2907 snd_env_head (env, JS_HINSI_DICTS);
2908 put4com (no);
2909 snd_flush ();
2910 if ((count = get4com ()) == -1)
2911 {
2912 wnn_errorno = get4com ();
2913 return (-1);
2914 }
2915 re_alloc (rb, sizeof (int) * (count + 1));
2916 p = (int *) rb->buf;
2917
2918 for (k = 0; k < count; k++)
2919 {
2920 *p++ = get4com ();
2921 }
2922 return (count);
2923 }
2924
2925
2926 char *wnn_dic_types[] = { "", "����", "��Ͽ", "�հ�", "����" };
2927
2928 char *cwnn_dic_types[] = { "", "�̶�", "��¼", "ƴ��", "����" };
2929 char *bwnn_dic_types[] = { "", "�̶�", "��¼", "����", "����" };
2930
2931 char *kwnn_dic_types[] = { "", "����", "���", "����", "����" };
2932 /* ͳ�� ���� ��� ��Ю */
2933
2934 /* New primitives 9/8 */
2935
2936 int
js_file_password_set(env,fid,which,old,new)2937 js_file_password_set (env, fid, which, old, new)
2938 struct wnn_env *env;
2939 int fid;
2940 int which; /* 1 for dic, 2 for hindo 3(0) for both */
2941 char *old, *new;
2942 {
2943 register int x;
2944 if (env == 0)
2945 return (-1);
2946 set_current_js (env->js_id);
2947 handler_of_jserver_dead (-1);
2948 snd_env_head (env, JS_FILE_PASSWORD_SET);
2949 put4com (fid);
2950 put4com (which);
2951 putscom (old);
2952 putscom (new);
2953 snd_flush ();
2954 x = get4com ();
2955 if (x == -1)
2956 {
2957 wnn_errorno = get4com ();
2958 return (-1);
2959 }
2960 return (0);
2961 }
2962
2963 int
js_hinsi_table_set(env,dic_no,hinsi_table)2964 js_hinsi_table_set (env, dic_no, hinsi_table)
2965 struct wnn_env *env;
2966 int dic_no;
2967 w_char *hinsi_table;
2968 {
2969 int x;
2970 if (env == 0)
2971 return (-1);
2972 set_current_js (env->js_id);
2973 handler_of_jserver_dead (-1);
2974 snd_env_head (env, JS_HINSI_TABLE_SET);
2975 put4com (dic_no);
2976 putwscom (hinsi_table);
2977 snd_flush ();
2978 x = get4com ();
2979 if (x == -1)
2980 {
2981 wnn_errorno = get4com ();
2982 return (-1);
2983 }
2984 return (0);
2985 }
2986
2987 #define SERVERDEFS_FILE "/serverdefs"
2988
2989 #define MACHINE_NAME 1
2990 #define UNIXDOMAIN_NAME 2
2991 #define SERVICE_NAME 3
2992 #define SERVICE_PORT_NUM 4
2993
2994 static char *
get_serv_defs(lang,cnt)2995 get_serv_defs (lang, cnt)
2996 char *lang;
2997 int cnt;
2998 {
2999 FILE *fp;
3000 static char s[7][EXPAND_PATH_LENGTH];
3001 char serv_defs[EXPAND_PATH_LENGTH];
3002 char data[1024];
3003 int num;
3004
3005 strcpy (serv_defs, LIBDIR);
3006 strcat (serv_defs, SERVERDEFS_FILE);
3007 if ((fp = fopen (serv_defs, "r")) == NULL)
3008 {
3009 return (NULL);
3010 }
3011 while (fgets (data, 1024, fp) != NULL)
3012 {
3013 num = sscanf (data, "%s %s %s %s %s %s %s", s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
3014 if ((num < 4) || s[0][0] == ';')
3015 {
3016 continue;
3017 }
3018 if (!strncmp (lang, s[0], strlen (s[0])))
3019 {
3020 fclose (fp);
3021 if (cnt == SERVICE_PORT_NUM && num < 5)
3022 return (NULL);
3023 if (strlen (s[cnt]) == strlen ("NULL") && !strcmp (s[cnt], "NULL"))
3024 {
3025 return (NULL);
3026 }
3027 else
3028 {
3029 return (s[cnt]);
3030 }
3031 }
3032 }
3033 fclose (fp);
3034 return (NULL);
3035 }
3036
3037 char *
_wnn_get_machine_of_serv_defs(char * lang)3038 _wnn_get_machine_of_serv_defs(char *lang)
3039 {
3040 return (get_serv_defs (lang, MACHINE_NAME));
3041 }
3042
3043 static char *
get_unixdomain_of_serv_defs(char * lang)3044 get_unixdomain_of_serv_defs(char *lang)
3045 {
3046 return (get_serv_defs (lang, UNIXDOMAIN_NAME));
3047 }
3048
3049 static char *
get_service_of_serv_defs(char * lang)3050 get_service_of_serv_defs(char *lang)
3051 {
3052 return (get_serv_defs (lang, SERVICE_NAME));
3053 }
3054
3055 static int
get_port_num_of_serv_defs(char * lang)3056 get_port_num_of_serv_defs(char *lang)
3057 {
3058 char *port_char;
3059
3060 if ((port_char = get_serv_defs (lang, SERVICE_PORT_NUM)) == NULL)
3061 {
3062 return (-1);
3063 }
3064 else
3065 {
3066 return (atoi (port_char));
3067 }
3068 }
3069