annotate Wnn/jlib/js.c @ 10:fc3022f61fc7

tiny clean up

/*
 *  $Id: js.c,v 1.16 2005/04/10 15:26:37 aonoto Exp $
 */

/*
 * FreeWnn is a network-extensible Kana-to-Kanji conversion system.
 * This file is part of FreeWnn.
 * 
 * Copyright Kyoto University Research Institute for Mathematical Sciences
 *                 1987, 1988, 1989, 1990, 1991, 1992
 * Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1999
 * Copyright ASTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992
 * Copyright FreeWnn Project 1999, 2000, 2001, 2002, 2003
 *
 * Maintainer:  FreeWnn Project   <[e-mail]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
        Nihongo Henkan Library
*/
/*
        entry functions

        js_open_lang    js_close
        js_change_current_jserver
        js_connect_lang js_disconnect
        js_isconnect

        js_param_get    js_param_set

        js_access       js_mkdir

        js_get_lang     js_set_lang


extern  Variables
        int     wnn_errorno;
*/

#if defined(HAVE_CONFIG_H)
#include <config.h>
#endif

#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#if STDC_HEADERS
#  include <stdlib.h>
#  include <string.h>
#else
#  if HAVE_MALLOC_H
#    include <malloc.h>
#  endif
#  if HAVE_STRINGS_H
#    include <strings.h>
#  endif
#endif /* STDC_HEADERS */
#if HAVE_FCNTL_H
#  include <fcntl.h>
#endif
#include <pwd.h>
#if HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>

#include "jd_sock.h"
#include "commonhd.h"
#include "demcom.h"
#include "wnn_config.h"

#include "wnnerror.h"
#include "jslib.h"
#include "jh.h"

#include "msg.h"

#define JS                      /* For include ../etc/bdic.c */
#include "../etc/bdic.c"
#include "../etc/pwd.c"

/* defined in wnn_os.h & should be modified in the future */
/* #define bzero(adr,n)    memset((adr),0,(n)) */

int wnn_errorno = 0;
struct msg_cat *wnn_msg_cat = NULL;

/*      j Lib.  */

static int current_sd;                          /** ¥½¥±¥Ã¥Èfd  **/
static WNN_JSERVER_ID *current_js = NULL;


/*      Packet Buffers          */
static unsigned char snd_buf[S_BUF_SIZ];        /** Á÷¿® **/
static int sbp = 0;                     /** Á÷¿®¥Ð¥Ã¥Õ¥¡¡¼¥Ý¥¤¥ó¥¿¡¼ **/
static int rbc = -1;                    /** ¼õ¿®¥Ð¥Ã¥Õ¥¡¡¼¥Ý¥¤¥ó¥¿¡¼ **/

#if defined(EAGAIN)
# if defined(EWOULDBLOCK)
# define ERRNO_CHECK(no)        ((no) == EAGAIN || (no) == EWOULDBLOCK)
# else /* defined(EWOULDBLOCK) */
# define ERRNO_CHECK(no)        ((no) == EAGAIN)
# endif /* defined(EWOULDBLOCK) */
#else /* defined(EAGAIN) */
# if defined(EWOULDBLOCK)
# define ERRNO_CHECK(no)        ((no) == EWOULDBLOCK)
# else /* defined(EWOULDBLOCK) */
# define ERRNO_CHECK(no)        (0)
# endif /* defined(EWOULDBLOCK) */
#endif /* defined(EAGAIN) */

static void connect_timeout ();
static int _get_server_name ();
static int writen ();
static char *get_unixdomain_of_serv_defs (), *get_service_of_serv_defs ();
static int get_port_num_of_serv_defs ();
#if DEBUG
void xerror ();
#endif

/*********      V4      *****************/
/***
        jserver_dead Macro
***/

static jmp_buf current_jserver_dead;

#define handler_of_jserver_dead(err_val) \
{ \
    if (current_js) { \
        if(current_js->js_dead){wnn_errorno=WNN_JSERVER_DEAD;return err_val;}\
        if(setjmp(current_jserver_dead)){ \
                wnn_errorno=WNN_JSERVER_DEAD; \
                return err_val; \
        } \
        wnn_errorno = 0; /* here initialize wnn_errorno; */    \
    } \
}

static void
set_current_js (server)
     register WNN_JSERVER_ID *server;
{
  current_js = server;
  current_sd = current_js->sd;
}

/**     ¥Ç¡¼¥â¥ó¤¬»à¤ó¤À»þ¤Î¤¿¤á¤Î¸å»ÏËö        **/
static void
daemon_dead ()
{
  current_js->js_dead = -1;
  wnn_errorno = WNN_JSERVER_DEAD;
  shutdown (current_sd, 2);
#ifdef HAVE_CLOSESOCKET
  closesocket (current_sd);
#else
  close (current_sd);
#endif
#if DEBUG
  fprintf (stderr, "jslib:JSERVER %s is Dead\n", current_js->js_name);
#endif
  if (current_js->js_dead_env_flg)
    {
      longjmp (current_js->js_dead_env, 666);
    }
  longjmp (current_jserver_dead, 666);
/* never reach */
}


/**
        ¥½¥±¥Ã¥È¤ò¥ª¡¼¥×¥ó¤·¤Æcurrent_sd¤Ë¥½¥±¥Ã¥Èfd¤òÊÖ¤¹
                        (cd¤È¤¤¤¦¤Î¤Ï¥³¥ß¥å¥Ë¥±¡¼¥·¥ç¥ó¥Ç¥Ð¥¤¥¹¤Î̾»Ä)
**/
static int
cd_open_un (lang)
     register char *lang;
{
#ifdef AF_UNIX
  int sd;
  struct sockaddr_un saddr;             /** ¥½¥±¥Ã¥È **/
  char *sock_name = NULL;
  saddr.sun_family = AF_UNIX;

  /* find socket name from table by lang */
  if (lang && *lang)
    {
      if ((sock_name = get_unixdomain_of_serv_defs (lang)) == NULL)
        {
          sock_name = sockname;
        }
    }
  else
    {
      sock_name = sockname;     /* Jserver */
    }
  strcpy (saddr.sun_path, sock_name);

  if ((sd = socket (AF_UNIX, SOCK_STREAM, 0)) == ERROR)
    {
#if DEBUG
      xerror ("jslib:Can't create unix domain socket.\n");
#endif
      return -1;
    }

#if !defined(SUN_LEN)
# define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
#endif
  if (connect (sd, (struct sockaddr *) &saddr, SUN_LEN (&saddr)) == ERROR)
    {

#if DEBUG
      xerror ("jslib:Can't connect unix domain socket.\n");
#endif
      close (sd);
      return -1;
    }
  return sd;
#else
  return -1;
#endif
}

static int
cd_open_in (server, lang, timeout)
     register char *server;
     register char *lang;
     register int timeout;
{
  int sd;
#ifdef INET6
  struct addrinfo hints, *res, *res0;
  int error;
  char sport[6];
#else
  struct sockaddr_in saddr_in;                  /** ¥½¥±¥Ã¥È **/
  register struct hostent *hp;
#endif
  struct servent *sp = NULL;
  int serverNO, port_num;
  int ret;
  char pserver[64];
  char sserver[64];
  char *serv_name = NULL;

  serverNO = _get_server_name (server, pserver);

  /* find service name from table by lang */
  if (lang && *lang)
    {
      if ((serv_name = get_service_of_serv_defs (lang)) == NULL)
        {
          strcpy (sserver, SERVERNAME);
        }
      else
        {
          strcpy (sserver, serv_name);
        }
    }
  else
    {
/*
        serv_name = SERVERNAME;
*/
      strcpy (sserver, SERVERNAME);
    }
/*
    if ((sp = getservbyname(serv_name,"tcp")) != NULL) {
*/
  if ((sp = getservbyname (sserver, "tcp")) != NULL)
    {
      serverNO += ntohs (sp->s_port);
    }
  else
    {
      if ((port_num = get_port_num_of_serv_defs (lang)) == -1)
        {
          serverNO += WNN_PORT_IN;
        }
      else
        {
          serverNO += port_num;
        }
    }
#ifdef INET6
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = PF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  sprintf(sport, "%d", serverNO);
  error = getaddrinfo(pserver, sport, &hints, &res0);
  if (error)
    {
#if DEBUG
      xerror (gai_strerror(error));
#endif
      return -1;
    }
  for (res = res0; res ; res = res->ai_next) {
    if (res->ai_family == AF_INET || res->ai_family == AF_INET6){
      if ((sd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) != ERROR){
#else
  if ((hp = gethostbyname (pserver)) == NULL)
    {
      return -1;
    }
  bzero ((char *) &saddr_in, sizeof (saddr_in));
  bcopy (hp->h_addr, (char *) &saddr_in.sin_addr, hp->h_length);
  saddr_in.sin_family = AF_INET;
  saddr_in.sin_port = htons (serverNO);
  if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == ERROR)
    {
#if DEBUG
      xerror ("jslib:Can't create inet socket.\n");
#endif
      return -1;
    }
#endif

  if (timeout != 0 && timeout > 0)
    {
      signal (SIGALRM, connect_timeout);
      alarm (timeout);
    }
#ifdef INET6
  ret = connect (sd, res->ai_addr, res->ai_addrlen);
#else
  ret = connect (sd, (struct sockaddr *) &saddr_in, sizeof (saddr_in));
#endif
  if (timeout != 0 && timeout > 0)
    {
      alarm (0);
      signal (SIGALRM, SIG_IGN);
    }
  if (ret == ERROR)
    {
#if DEBUG
#ifdef INET6
      if (res->ai_family == AF_INET)
	xerror ("jslib:Can't connect inet socket.\n");
      else if (res->ai_family == AF_INET6)
	xerror ("jslib:Can't connect inet6 socket.\n");
#else
      xerror ("jslib:Can't connect inet socket.\n");
#endif
#endif
#ifdef HAVE_CLOSESOCKET
      closesocket (sd);
#else
      close (sd);
#endif
#ifdef INET6
	  sd = ERROR;
	} else
	  break;
      } else {
#if DEBUG
      if (res->ai_family == AF_INET)
	xerror ("jslib:Can't create inet socket.\n");
      else if (res->ai_family == AF_INET6)
	xerror ("jslib:Can't create inet6 socket.\n");
#endif
      }
    }
  }
  freeaddrinfo(res0);
  if (sd == ERROR) {
#endif
      return -1;
    }
  return sd;
}

static void
connect_timeout ()
{
}

/* get server name and return serverNo */
static int
_get_server_name (server, pserver)
     char *server;
     char *pserver;
{
  register char *p;
#ifdef INET6
  int len;

  if (server[0] == '[') {
    p = strchr(server++, ']');
    if (p) {
      len = p-server<64-1?p-server:64-1;
      strncpy(pserver, server, len);
      pserver[len] = '\0';
    } else
      pserver[0] = '\0';
  } else {
#endif
  /* Workaround for pserver buffer overrun : Nov 11,1999 by T.Aono */
  /* assumes pserver[64]. variable length string is not supported. */
  strncpy(pserver, server, 64-1);
  pserver[64-1] = '\0';
  p = pserver;
#ifdef INET6
  }
#endif
  for (; *p && *p != ':'; p++);
  if (!*p)
    return (0);                 /* does not have a colon */
  *p = 0;
  return (atoi (++p));
}

/*      Packet SND/RCV subroutines      */
static void put4com ();

/**     ¥Ñ¥±¥Ã¥È¤Î¥Ø¥Ã¥À¡¼¤òÁ÷¤ë        **/
static void
snd_head (cmd)
     int cmd;   /** cmd=¥³¥Þ¥ó¥É **/
{
  sbp = 0;
  put4com (cmd);
  rbc = -1;
}

/**     ¥Ñ¥±¥Ã¥È¤Î¥Ø¥Ã¥À¡¼¤òÁ÷¤ë        **/
static int
snd_env_head (env, cmd)
     register struct wnn_env *env;
     int cmd;   /** cmd=¥³¥Þ¥ó¥É **/
{
  snd_head (cmd);
  put4com (env->env_id);
  return 0;
}

/**     ¥Ñ¥±¥Ã¥È¤Î¥Ø¥Ã¥À¡¼¤òÁ÷¤ë        **/
static int
snd_server_head (server, cmd)
     register WNN_JSERVER_ID *server;
     int cmd;   /** cmd=¥³¥Þ¥ó¥É **/
{
  snd_head (cmd);
  return 0;
}

/**     Á÷¿®¥Ð¥Ã¥Õ¥¡¤ò¥Õ¥é¥Ã¥·¥å¤¹¤ë    **/
static int
snd_flush ()
{
  if (sbp == 0)
    return (-1);
  writen (sbp);
  sbp = 0;
  return (0);
}

static int
writen (n)
     int n;
{
  int cc, x;
  for (cc = 0; cc < n;)
    {
      errno = 0;
#ifdef HAVE_SEND
      x = send (current_sd, &snd_buf[cc], n - cc, 0);
#else
      x = write (current_sd, &snd_buf[cc], n - cc);
#endif
      if (x < 0)
        {
          if (ERRNO_CHECK (errno) || errno == EINTR)
            {
              continue;
            }
          else
            {
              daemon_dead ();
              return -1;
            }
        }
      cc += x;
    }
#if DEBUG
  fprintf (stderr, "jslib:writen=%d\n", x);
/*      dmp(snd_buf,x); */
#endif
  return (0);
}

/**     ¥µ¡¼¥Ð¤Ø1¥Ð¥¤¥ÈÁ÷¤ë     **/
static void
put1com (c)
     int c;
{
  snd_buf[sbp++] = c;
  if (sbp >= S_BUF_SIZ)
    {
      writen (S_BUF_SIZ);
      sbp = 0;
    }
}

/**     ¥µ¡¼¥Ð¤Ø2¥Ð¥¤¥ÈÁ÷¤ë     **/
static void
put2com (c)
     int c;
{
  put1com (c >> (8 * 1));
  put1com (c);
}

/**     ¥µ¡¼¥Ð¤Ø4¥Ð¥¤¥ÈÁ÷¤ë     **/
static void
put4com (c)
     int c;
{
  put1com (c >> (8 * 3));
  put1com (c >> (8 * 2));
  put1com (c >> (8 * 1));
  put1com (c);
}

/**     ¥µ¡¼¥Ð¤Øʸ»úÎó¤òÁ÷¤ë    **/
static void
putwscom (p)
     register w_char *p;
{
  if (p == NULL)
    {
      put2com (0);
      return;
    }
  while (*p)
    put2com (*p++);
  put2com (0);
}

/**     ¥µ¡¼¥Ð¤Øʸ»úÎó¤òÁ÷¤ë    **/
static void
putscom (p)
     register char *p;
{
  if (p == NULL)
    {
      put1com (0);
      return;
    }
  while (*p)
    put1com (*p++);
  put1com (0);
}

/**     ¥µ¡¼¥Ð¤«¤é1¥Ð¥¤¥È¼õ¤±¤ë **/
static int
get1com ()
{
  static int rbp;
  static unsigned char rcv_buf[R_BUF_SIZ];      /** ¼õ¿® **/
  if (rbc <= 0)
    {
      while (1)
        {
          errno = 0;
#ifdef HAVE_RECV
          rbc = recv (current_sd, rcv_buf, R_BUF_SIZ, 0);
#else
          rbc = read (current_sd, rcv_buf, R_BUF_SIZ);
#endif
          if (rbc <= 0)
            {
              if (ERRNO_CHECK (errno))
                {
                  continue;
                }
              else if (rbc == 0)
                {
                  daemon_dead ();
                  return -1;
                }
              else
                {               /* cc == -1 */
                  if (errno != EINTR)
                    {
                      daemon_dead ();
                      return -1;
                    }
                  continue;
                }
            }
          rbp = 0;
#if DEBUG
          fprintf (stderr, "jslib:read:rbc=%d\n", rbc);
/*      dmp(rcv_buf,rbc); */
#endif
          break;
        }
    }
  rbc--;
  return rcv_buf[rbp++] & 0xFF;
}

/**     ¥µ¡¼¥Ð¤«¤é2¥Ð¥¤¥È¼õ¤±¤ë **/
static int
get2com ()
{
  register int h;
  h = get1com ();
  return (h << 8) | get1com ();
}

/**     ¥µ¡¼¥Ð¤«¤é4¥Ð¥¤¥È¼õ¤±¤ë **/
static int
get4com ()
{
  register int h1, h2, h3;
  h1 = get1com () << 24;
  h2 = get1com () << 16;
  h3 = get1com () << 8;
  return h1 | h2 | h3 | get1com ();
}

/**     ¥µ¡¼¥Ð¤Øʸ»úÎó¤òÁ÷¤ë    **/
static void
getscom (p)
     register char *p;
{
    while ((*p++ = get1com ()))
    ;
}

/**     ¥µ¡¼¥Ð¤Øʸ»úÎó¤òÁ÷¤ë    **/
static void
getwscom (p)
     w_char register *p;
{
    while ((*p++ = get2com ()))
    ;
}

#ifdef nodef
/* Moved from ../etc/string.c */
/**     **/
static int
Strlen (s)
     register w_char *s;
{
  register int n;

  for (n = 0; *s++ != 0; n++);
  return n;
}

/**     **/
static w_char *
Strcpy (s1, s2)
     register w_char *s1;
     register w_char *s2;
{
  register w_char *d;

  for (d = s1; (*d++ = *s2++) != 0;);
  return s1;
}
#endif


/*      Debug Subroutines       */
#if DEBUG
void
xerror (s)
     char *s;
{
  fprintf (stderr, "%s\n", s);
}

void
dmp (p, c)
     char *p;
{
  int i, j;
  for (i = 0;; i += 16)
    {
      for (j = 0; j < 16; j++)
        {
          if (c <= 0)
            {
              fprintf (stderr, "\n");
              return;
            }
          fprintf (stderr, "%02x ", p[i + j] & 0xFF);
          c--;
        }
      fprintf (stderr, "\n");
    }
}

#endif

/*      get login name form /etc/passwd file    */
static char *
getlogname ()
{
  struct passwd *getpwuid ();
  return getpwuid (getuid ())->pw_name;
}




/*
 *              Lib. Functions
 *              raw lib.
 */

/***
        js
        ¡¦global
***/

/**       jserver ¤ÈÀܳ¤¹¤ë¡£jserver_id ¤òÊÖ¤¹¡£       **/
WNN_JSERVER_ID *
js_open_lang (server, lang, timeout)
     register char *server, *lang;
     register int timeout;
{
  char *new_js;
  char host[WNN_HOSTLEN], user[WNN_ENVNAME_LEN];
  int x;

  if (wnn_msg_cat == NULL)
    {
      char nlspath[MAXPATHLEN];
      strcpy (nlspath, LIBDIR);
      strcat (nlspath, "/%L/%N");
      wnn_msg_cat = msg_open ("libwnn.msg", nlspath, lang);
      if (wnn_msg_cat == NULL)
        {
          fprintf (stderr, "libwnn: Cannot open message file for libwnn.a\n");
        }
    }
  sbp = 0;                      /* init sndBufPointer */
  if (!(new_js = (char *) malloc (sizeof (WNN_JSERVER_ID))))
    {
      wnn_errorno = WNN_ALLOC_FAIL;
      return NULL;
    }
  current_js = (WNN_JSERVER_ID *) new_js;
  if (server == NULL)
    {
      current_js->js_name[0] = '\0';
    }
  else
    {
      strncpy (current_js->js_name, server, sizeof (current_js->js_name) - 1);
      current_js->js_name[sizeof (current_js->js_name) - 1] = '\0';
    }
  current_js->js_dead = 0;
  current_js->js_dead_env_flg = 0;
/*
 if(user == NULL || 0==strcmp(user,""))
*/
  strncpy (user, getlogname (), WNN_ENVNAME_LEN);
  user[WNN_ENVNAME_LEN - 1] = '\0';     /* truncate by WNN_ENVNAME_LEN */
  if (server == NULL || 0 == strcmp (server, "") || 0 == strcmp (server, "unix"))
    {
      strcpy (host, "unix");
      if ((current_sd = cd_open_un (lang)) == -1)
        {
          wnn_errorno = WNN_SOCK_OPEN_FAIL;
          free ((char *) current_js);
          current_js = NULL;
          return NULL;
        }
    }
  else
    {
      gethostname (host, WNN_HOSTLEN);
      host[WNN_HOSTLEN - 1] = '\0';     /* truncate by WNN_HOSTLEN */
      if ((current_sd = cd_open_in (server, lang, timeout)) == -1)
        {
          wnn_errorno = WNN_SOCK_OPEN_FAIL;
          free ((char *) current_js);
          current_js = NULL;
          return NULL;
        }
    }
  current_js->sd = current_sd;
  handler_of_jserver_dead (NULL);
  snd_head (JS_OPEN);
  put4com (JLIB_VERSION);       /* H.T. */
  putscom (host);
  putscom (user);
  snd_flush ();
  if (get4com () == -1)
    {
      x = wnn_errorno = get4com ();
      js_close (current_js);    /* H.T. */
      current_js = NULL;
      wnn_errorno = x;
      return NULL;
    }
  return current_js;
}


/**     ¥½¥±¥Ã¥È¤ò¥¯¥í¡¼¥º¤¹¤ë  **/
/**       jserver ¤È¤ÎÀܳ¤ò close ¤¹¤ë¡£       **/
int
js_close (server)
     WNN_JSERVER_ID *server;
{
  register int x;
  WNN_JSERVER_ID tmp_js_id;
  if (server == 0)
    return (-1);
  tmp_js_id = *server;
  free ((char *) server);
  current_js = &tmp_js_id;
  current_sd = current_js->sd;
/*      handler of jserver dead */
  handler_of_jserver_dead (-1);
  snd_head (JS_CLOSE);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
#ifdef HAVE_CLOSESOCKET
  closesocket (current_sd);
#else
  close (current_sd);
#endif
  return x;
}


/*
        jserver ¤È¤Î´Ö¤Ë connection ¤òÄ¥¤ê¡¢Æ±»þ¤Ë jserver ¤ÎÆâÉô¤Ë´Ä
        ¶­¤òºî¤ë¡£env_name ¤Ë´û¤Ë¸ºß¤¹¤ë´Ä¶­¤ò»ØÄꤷ¤¿»þ¤Ë¤Ï¤½¤Î´Ä¶­¤ò
        ÊÖ¤·¡¢NULL ¤ò»ØÄꤷ¤¿»þ¤Ë¤Ï¿·¤·¤¤´Ä¶­¤òºî¤Ã¤ÆÊÖ¤¹¡£
*/

struct wnn_env *
js_connect_lang (server, env_name, lang)
     register char *env_name;
     WNN_JSERVER_ID *server;
     char *lang;
{
  register int e_id;
  register struct wnn_env *env;
  void js_set_lang ();

  set_current_js (server);
  if (!(env = (struct wnn_env *) malloc (sizeof (struct wnn_env))))
    {
      wnn_errorno = WNN_ALLOC_FAIL;
      return NULL;
    }
  handler_of_jserver_dead (NULL);
  snd_head (JS_CONNECT);
  putscom (env_name);
  snd_flush ();
  e_id = get4com ();
  if (e_id == -1)
    {
      wnn_errorno = get4com ();
      free (env);
      return NULL;
    }
  env->env_id = e_id;
  env->js_id = server;
  strcpy (env->lang, lang);     /* set language name */
  return env;
}

#ifdef  nodef
/* set language value to env */
void
js_set_lang (env, lang)
     struct wnn_env *env;
     register char *lang;
{
  register char *p;
  extern char *getenv ();

  /* if not specified language , use $LANG */
  if (lang == 0 || *lang == 0)
    lang = getenv ("LANG");
  if (lang == 0 || *lang == 0)
    lang = WNN_DEFAULT_LANG;
  for (p = env->lang; *lang != '.' && *lang != '@' && *lang != 0; lang++, p++)
    *p = *lang;
  *p = 0;
}
#endif

/* get language value from env */
char *
js_get_lang (env)
     struct wnn_env *env;
{
  return (env->lang);
}

int
js_env_exist (server, env_name)
     register char *env_name;
     register WNN_JSERVER_ID *server;
{
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_head (JS_ENV_EXIST);
  putscom (env_name);
  snd_flush ();
  return (get4com ());
}

int
js_env_sticky (env)
     register struct wnn_env *env;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_ENV_STICKY);
  snd_flush ();
  return (get4com ());
}

int
js_env_un_sticky (env)
     register struct wnn_env *env;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_ENV_UN_STICKY);
  snd_flush ();
  return (get4com ());
}

/**
          env ¤Ç¼¨¤µ¤ì¤ë´Ä¶­¤ò̵¤¯¤¹¡£
**/
int
js_disconnect (env)
     register struct wnn_env *env;
{
  register int x;
  struct wnn_env tmp_env;
  if (env == 0)
    return (-1);
  tmp_env = *env;
  /* ËÜÍè¤Ï¡¢free ¤·¤Ê¤­¤ã¤¢¤«¤ó¤Î¤À¤±¤É¡¢¥ê¥½¡¼¥¹´ÉÍý¤¬½ÐÍè¤Ê¤¤¤·¡¢
     ¤Þ¤¢¡¢8¥Ð¥¤¥È¤À¤«¤é¡¢¥´¥ß¤¬»Ä¤ë¤±¤É¤¤¤¤¤À¤í¤¦¡£
     free((char *)env);
   */
  set_current_js (env->js_id);
  handler_of_jserver_dead (0);
  snd_env_head (&tmp_env, JS_DISCONNECT);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
    }
  return x;
}

/**     ¥µ¡¼¥Ð¤È¥³¥Í¥¯¥È¤·¤Æ¤¤¤ë¤«      **/
int
js_isconnect (env)
     register struct wnn_env *env;
{
  if (env && env->js_id)
    return (env->js_id->js_dead);
  return (-1);
}

/**
          env ¤Î ´Ä¶­ ¤È¤ÎÄÌ¿®¥Ð¥Ã¥Õ¥¡¤ò flush ¤¹¤ë¡£
**/
void
js_flush (env)
     struct wnn_env *env;
{
}



/*      Parameter set/get       */
/**     ÊÑ´¹ parameter ¤òÀßÄꤹ¤ë¡£     **/
/**     js_param_set            **/
int
js_param_set (env, para)
     struct wnn_env *env;
     register struct wnn_param *para;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_PARAM_SET);
  put4com (para->n);            /* £Î(Âç)ʸÀá²òÀϤΣΠ*/
  put4com (para->nsho);         /* ÂçʸÀáÃæ¤Î¾®Ê¸Àá¤ÎºÇÂç¿ô */
  put4com (para->p1);           /* ´´¸ì¤ÎÉÑÅ٤Υѥé¥á¡¼¥¿ */
  put4com (para->p2);           /* ¾®Ê¸ÀáĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  put4com (para->p3);           /* ´´¸ìĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  put4com (para->p4);           /* º£»È¤Ã¤¿¤è¥Ó¥Ã¥È¤Î¥Ñ¥é¥á¡¼¥¿ */
  put4com (para->p5);           /* ¼­½ñ¤Î¥Ñ¥é¥á¡¼¥¿ */
  put4com (para->p6);           /* ¾®Ê¸Àá¤Îɾ²ÁÃͤΥѥé¥á¡¼¥¿ */
  put4com (para->p7);           /* ÂçʸÀáĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  put4com (para->p8);           /* ¾®Ê¸Àá¿ô¤Î¥Ñ¥é¥á¡¼¥¿ */

  put4com (para->p9);           /* µ¿»÷ÉÊ»ì ¿ô»ú¤ÎÉÑÅÙ */
  put4com (para->p10);          /* µ¿»÷ÉÊ»ì ¥«¥Ê¤ÎÉÑÅÙ *//* CWNN ±Ñ¿ô¤ÎÉÑÅÙ */
  put4com (para->p11);          /* µ¿»÷ÉÊ»ì ±Ñ¿ô¤ÎÉÑÅÙ *//* CWNN µ­¹æ¤ÎÉÑÅÙ */
  put4com (para->p12);          /* µ¿»÷ÉÊ»ì µ­¹æ¤ÎÉÑÅÙ *//* CWNN ³«³ç¸Ì¤ÎÉÑÅÙ */
  put4com (para->p13);          /* µ¿»÷ÉÊ»ì Êijç¸Ì¤ÎÉÑÅÙ *//* CWNN Êijç¸Ì¤ÎÉÑÅÙ */
  put4com (para->p14);          /* µ¿»÷ÉÊ»ì ÉÕ°¸ì¤ÎÉÑÅÙ *//* BWNN No of koho */
  put4com (para->p15);          /* µ¿»÷ÉÊ»ì ³«³ç¸Ì¤ÎÉÑÅÙ *//* CWNN Not used */

  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }
  return 0;
}

/**     js_param_get            **/
/**     env ¤Ç¼¨¤µ¤ì¤ë´Ä¶­¤ÎÊÑ´¹ parameter ¤ò¼è¤ê½Ð¤¹¡£ **/
int
js_param_get (env, para)
     struct wnn_env *env;
     register struct wnn_param *para;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_PARAM_GET);
  snd_flush ();
  if (get4com () == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }
  para->n = get4com ();         /* £Î(Âç)ʸÀá²òÀϤΣΠ*/
  para->nsho = get4com ();      /* ÂçʸÀáÃæ¤Î¾®Ê¸Àá¤ÎºÇÂç¿ô */
  para->p1 = get4com ();        /* ´´¸ì¤ÎÉÑÅ٤Υѥé¥á¡¼¥¿ */
  para->p2 = get4com ();        /* ¾®Ê¸ÀáĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p3 = get4com ();        /* ´´¸ìĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p4 = get4com ();        /* º£»È¤Ã¤¿¤è¥Ó¥Ã¥È¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p5 = get4com ();        /* ¼­½ñ¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p6 = get4com ();        /* ¾®Ê¸Àá¤Îɾ²ÁÃͤΥѥé¥á¡¼¥¿ */
  para->p7 = get4com ();        /* ÂçʸÀáĹ¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p8 = get4com ();        /* ¾®Ê¸Àá¿ô¤Î¥Ñ¥é¥á¡¼¥¿ */
  para->p9 = get4com ();        /* µ¿»÷ÉÊ»ì ¿ô»ú¤ÎÉÑÅÙ */
  para->p10 = get4com ();       /* µ¿»÷ÉÊ»ì ¥«¥Ê¤ÎÉÑÅÙ */
  para->p11 = get4com ();       /* µ¿»÷ÉÊ»ì ±Ñ¿ô¤ÎÉÑÅÙ */
  para->p12 = get4com ();       /* µ¿»÷ÉÊ»ì µ­¹æ¤ÎÉÑÅÙ */
  para->p13 = get4com ();       /* µ¿»÷ÉÊ»ì Êijç¸Ì¤ÎÉÑÅÙ */
  para->p14 = get4com ();       /* µ¿»÷ÉÊ»ì ÉÕ°¸ì¤ÎÉÑÅÙ */
  para->p15 = get4com ();       /* µ¿»÷ÉÊ»ì ³«³ç¸Ì¤ÎÉÑÅÙ */

  return 0;
}

/*
        global File Operation
*/
/**     js_mkdir        **/
int
js_mkdir (env, path)
     struct wnn_env *env;
     char *path;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_MKDIR);
  putscom (path);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_access       **/
int
js_access (env, path, amode)
     struct wnn_env *env;
     char *path;
     int amode;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_ACCESS);
  put4com (amode);
  putscom (path);
  snd_flush ();
  x = get4com ();
  return x;
}

/**     js_file_list_all        **/
static int rcv_file_list ();

int
js_file_list_all (server, ret)
     WNN_JSERVER_ID *server;
     struct wnn_ret_buf *ret;
{
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_FILE_LIST_ALL);
  snd_flush ();
  return rcv_file_list (ret);
}


/**     js_file_list    **/
int
js_file_list (env, ret)
     struct wnn_env *env;
     struct wnn_ret_buf *ret;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_LIST);
  snd_flush ();
  return rcv_file_list (ret);
}

static void re_alloc ();

static int
rcv_file_list (ret)
     struct wnn_ret_buf *ret;
{
  register int i, count;
  WNN_FILE_INFO_STRUCT *files;
  count = get4com ();
  re_alloc (ret, sizeof (WNN_FILE_INFO_STRUCT) * count);
  files = (WNN_FILE_INFO_STRUCT *) ret->buf;
  for (i = 0; i < count; i++)
    {
      files->fid = get4com ();
      files->localf = get4com ();
      files->ref_count = get4com ();
      files->type = get4com ();
      getscom (files->name);
      files++;
    }
  return count;
}

/**     js_file_stat    **/
int
js_file_stat (env, path, s)
     struct wnn_env *env;
     char *path;
     WNN_FILE_STAT *s;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_STAT);
  putscom (path);
  snd_flush ();
  x = get4com ();
  s->type = x;
  return x;
}


/**     js_file_info    **/
int
js_file_info (env, fid, file)
     struct wnn_env *env;
     int fid;
     register WNN_FILE_INFO_STRUCT *file;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_INFO);
  put4com (fid);
  snd_flush ();
  file->fid = fid;
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  getscom (file->name);
  file->localf = get4com ();
  file->ref_count = get4com ();
  file->type = get4com ();
  return 0;
}

/**     js_file_loaded  **/
int
js_file_loaded (server, path)
     WNN_JSERVER_ID *server;
     char *path;
{
  register int x;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_FILE_LOADED);
  putscom (path);
  snd_flush ();
  x = get4com ();
  return x;
}

/**     js_file_loaded_local    **/
static int check_local_file ();
static int file_loaded_local ();

int
js_file_loaded_local (server, path)
     WNN_JSERVER_ID *server;
     char *path;
{
  int x;
  set_current_js (server);
  handler_of_jserver_dead (-1);

  if (check_local_file (path) == -1)
    return (-1);
  snd_server_head (server, JS_FILE_LOADED_LOCAL);
  x = file_loaded_local (path);
  if (x == -1)
    {
      return -1;
    }
  return x;
}

static int
check_local_file (path)
     char *path;
{
  register FILE *f;
  register int x;
  struct wnn_file_head fh;

#ifdef WRITE_CHECK
  check_backup (path);
#endif /* WRITE_CHECK */
  f = fopen (path, "r");
  if (f == NULL)
    {
      wnn_errorno = WNN_OPENF_ERR;
      return -1;
    }
  x = input_file_header (f, &fh);
  if (x == -1)
    {
      fclose (f);
      wnn_errorno = WNN_NOT_A_FILE;
      return -1;
    }
  if (check_inode (f, &fh) == -1)
    {
      change_file_uniq (&fh, path);
#ifdef WRITE_CHECK
      fclose (f);
      f = fopen (path, "r");
      if (f == NULL)
        {
          wnn_errorno = WNN_OPENF_ERR;
          return (-1);
        }
#endif /* WRITE_CHECK */
      if (check_inode (f, &fh) == -1)
        {
          fclose (f);
          wnn_errorno = WNN_INODE_CHECK_ERROR;
          return (-1);
        }
    }
  fclose (f);
  return 0;
}


static int
file_loaded_local (path)
     char *path;
{
  register int x, i;
  FILE *f;
  struct wnn_file_head fh;

#ifdef WRITE_CHECK
  check_backup (path);
#endif /* WRITE_CHECK */
  f = fopen (path, "r");
  if (f == NULL)
    {
      wnn_errorno = WNN_OPENF_ERR;
      return -1;
    }
  x = input_file_header (f, &fh);
  if (x == -1)
    {
      fclose (f);
      wnn_errorno = WNN_NOT_A_FILE;
      return -1;
    }
  put4com (fh.file_uniq.time);
  put4com (fh.file_uniq.dev);
  put4com (fh.file_uniq.inode);
  for (i = 0; i < WNN_HOSTLEN; i++)
    {
      put1com (fh.file_uniq.createhost[i]);
    }

  snd_flush ();
  x = get4com ();
  fclose (f);
  return x;
}


/**     js_hindo_file_create    **/
int
js_hindo_file_create (env, fid, fn, comment, hpasswd)
     struct wnn_env *env;
     int fid;
     char *fn;
     w_char *comment;
     char *hpasswd;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINDO_FILE_CREATE);
  put4com (fid);
  putscom (fn);
  putwscom (comment);
  putscom (hpasswd);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_dic_file_create      **/
int
js_dic_file_create (env, fn, type, comment, passwd, hpasswd)
     struct wnn_env *env;
     char *fn;
     w_char *comment;
     char *passwd, *hpasswd;
     int type;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_FILE_CREATE);
  putscom (fn);
  putwscom (comment);
  putscom (passwd);
  putscom (hpasswd);
  put4com (type);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}


/**     js_file_discard **/
int
js_file_discard (env, fid)
     struct wnn_env *env;
     int fid;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_DISCARD);
  put4com (fid);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_file_read    **/
int
js_file_read (env, fn)
     struct wnn_env *env;
     char *fn;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_READ);
  putscom (fn);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_file_write   **/
int
js_file_write (env, fid, fn)
     struct wnn_env *env;
     int fid;
     char *fn;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_WRITE);
  put4com (fid);
  putscom (fn);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_file_receive **/
static int xget1com ();
static void xput1com ();

int
js_file_receive (env, fid, fn)
     struct wnn_env *env;
     int fid;
     char *fn;
{
  register int mode, x;
  char file_name[1024];
  char buf[1024];
  FILE *f;
  int n;
  struct wnn_file_head fh;
  int i;
#ifdef WRITE_CHECK
  char *tmp, *backup = NULL, tmp_x;
  int tmp_err = 0;
#endif /* WRITE_CHECK */

  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_RECEIVE);
  put4com (fid);
  snd_flush ();
   /**/ getscom (file_name);
  if (fn == NULL || strcmp (fn, "") == 0)
    {
      gethostname (buf, 1024);
      n = strlen (buf);
      buf[n] = C_LOCAL;
      buf[n + 1] = 0;
      if (strncmp (buf, file_name, n + 1) == 0)
        {
          fn = file_name + n + 1;
        }
    }
#ifdef WRITE_CHECK
  check_backup (fn);
#endif /* WRITE_CHECK */
  if ((f = fopen (fn, "r")) == NULL)
    {                           /* New File */
      fh.file_uniq.time = fh.file_uniq.dev = fh.file_uniq.inode = 0;
    }
  else
    {                           /* Old File Exists */
      if (input_file_header (f, &fh) == -1)
        {
          wnn_errorno = WNN_NOT_A_FILE;
          fclose (f);
          put4com (-1);
          snd_flush ();
          sleep (1);            /* enssure handshake */
          return (-1);
        }
      fclose (f);
    }
  put4com (0);                  /* Ack */
  put4com (fh.file_uniq.time);
  put4com (fh.file_uniq.dev);
  put4com (fh.file_uniq.inode);
  for (i = 0; i < WNN_HOSTLEN; i++)
    {
      put1com (fh.file_uniq.createhost[i]);
    }

  snd_flush ();

  if ((mode = get4com ()) == -1)
    {                           /* check stat */
      wnn_errorno = get4com ();
      return -1;
    }
  else if (mode == 0)
    {
      return 0;                 /* need not saving */
    }
  else if (mode == 1 || mode == 3)
    {                           /* mode == 3 means the file is a new one. */
#ifdef WRITE_CHECK
      backup = make_backup_file (fn);
      if ((tmp = make_tmp_file (fn, 0, &f)) == NULL)
        {
          delete_tmp_file (backup);
#else /* WRITE_CHECK */
      if ((f = fopen (fn, "w+")) == NULL)
        {
#endif /* WRITE_CHECK */
          wnn_errorno = WNN_FILE_WRITE_ERROR;
          put4com (-1);
          snd_flush ();
          sleep (1);            /* enssure handshake */
          return (-1);
        }
    }
  else if (mode == 2)
    {
#ifdef WRITE_CHECK
      backup = make_backup_file (fn);
      if ((tmp = make_tmp_file (fn, 1, &f)) == NULL)
        {
          delete_tmp_file (backup);
#else /* WRITE_CHECK */
      if ((f = fopen (fn, "r+")) == NULL)
        {                       /* New File */
#endif /* WRITE_CHECK */
          wnn_errorno = WNN_FILE_WRITE_ERROR;
          put4com (-1);
          snd_flush ();
          sleep (1);            /* enssure handshake */
          return (-1);
        }
    }
  put4com (0);
  snd_flush ();                 /* ACK */
  for (;;)
    {
      if ((x = xget1com ()) == -1)
        break;                  /* EOF */
#ifdef WRITE_CHECK
      tmp_x = (char) x;
      if (fwrite (&tmp_x, sizeof (char), 1, f) == -1)
        tmp_err = 1;
#else /* WRITE_CHECK */
      fputc (x, f);
#endif /* WRITE_CHECK */
    }
  fclose (f);
#ifdef WRITE_CHECK
  if (tmp_err == 0)
    {
      move_tmp_to_org (tmp, fn, 1);
    }
  else
    {
      delete_tmp_file (tmp);
    }
  delete_tmp_file (backup);
#endif /* WRITE_CHECK */

  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
#ifdef WRITE_CHECK
  if (tmp_err)
    {
      wnn_errorno = WNN_FILE_WRITE_ERROR;
      return (-1);
    }
#endif /* WRITE_CHECK */

  return x;
}

static int
xget1com ()
{
  register int x;
  if ((x = get1com ()) != 0xFF)
    return x;
  if (get1com () == 0xFF)
    return -1;                  /* EOF */
  return 0xFF;
}

/**     js_file_send    **/
int
js_file_send (env, fn)
     struct wnn_env *env;
     char *fn;
{
  register int x;
  FILE *f;
  int n;
  char buf[1024], *b;
  register int cc, i;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);

  if (check_local_file (fn) == -1)
    return (-1);

  snd_env_head (env, JS_FILE_SEND);
  x = file_loaded_local (fn);
  if (x != -1)
    {                           /* file is already loaded */
      if (get4com () == -1)
        {
          wnn_errorno = get4com ();
          return (-1);
        }
      return x;
    }

  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }

  gethostname (buf, 1024);
  n = strlen (buf);
  buf[n] = C_LOCAL;
  strcpy (buf + n + 1, fn);
  putscom (buf);

#ifdef WRITE_CHECK
  check_backup (fn);
#endif /* WRITE_CHECK */
  if ((f = fopen (fn, "r")) == NULL)
    {
      xput1com (-1);            /* EOF */
      return -1;
    }

  /* send contents of file */
  for (;;)
    {
      cc = fread (buf, 1, 1024, f);
      if (cc <= 0)
        break;                  /* EOF */
      for (b = buf, i = 0; i < cc; i++)
        {
          xput1com ((int) *b++ & 0xff);
        }
    }
  fclose (f);
  xput1com (-1);                /* EOF */
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

static void
xput1com (d)
     int d;
{
  if (d == -1)
    {
      put1com (0xFF);
      put1com (0xFF);
      return;                   /* EOF */
    }
  put1com (d);
  if (d == 0xFF)
    {
      put1com (0x00);
    }
}


/***    Dic. Operation for Env.  ***/

/**     js_dic_add      **/
int
js_dic_add (env, fid, hfid, rev, jnice, rw, hrw, pw1, pw2)
     struct wnn_env *env;
     int fid, hfid, rev, jnice, rw, hrw;
     char *pw1, *pw2;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_ADD);
  put4com (fid);
  put4com (hfid);
  put4com (jnice);
  put4com (rw);
  put4com (hrw);
  putscom (pw1);
  putscom (pw2);
  put4com (rev);                /* rev is to add it as reverse dict */
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_dic_delete   **/
int
js_dic_delete (env, dicno)
     struct wnn_env *env;
     int dicno;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_DELETE);
  put4com (dicno);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_dic_use      **/
int
js_dic_use (env, dic_no, flag)
     struct wnn_env *env;
     int dic_no, flag;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_USE);
  put4com (dic_no);
  put4com (flag);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_fuzokugo_set **/
int
js_fuzokugo_set (env, fid)
     struct wnn_env *env;
     int fid;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FUZOKUGO_SET);
  put4com (fid);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_fuzokugo_get **/
int
js_fuzokugo_get (env)
     struct wnn_env *env;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FUZOKUGO_GET);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_dic_list_all **/
static int rcv_dic_list ();
static void get_dic_info ();

int
js_dic_list_all (server, ret)
     WNN_JSERVER_ID *server;
     struct wnn_ret_buf *ret;
{
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_DIC_LIST_ALL);
  snd_flush ();
  return rcv_dic_list (ret);
}


/**     js_dic_list     **/
int
js_dic_list (env, ret)
     struct wnn_env *env;
     struct wnn_ret_buf *ret;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_LIST);
  snd_flush ();
  return rcv_dic_list (ret);
}

static int
rcv_dic_list (ret)
     struct wnn_ret_buf *ret;
{
  register int i, count;
  register WNN_DIC_INFO *dic;
  count = get4com ();
  re_alloc (ret, sizeof (WNN_DIC_INFO) * (count + 1));

  dic = (WNN_DIC_INFO *) ret->buf;
  for (i = 0; i < count; i++)
    {
      get_dic_info (dic);
      dic++;
    }
  dic->dic_no = -1;
  return count;
}

static void
get_dic_info (dic)
     register WNN_DIC_INFO *dic;
{
  dic->dic_no = get4com ();     /* dic_No */
  dic->body = get4com ();       /* body fid */
  dic->hindo = get4com ();      /* hindo fid */
  dic->rw = get4com ();         /* r/w */
  dic->hindo_rw = get4com ();   /* hindo r/w */
  dic->enablef = get4com ();    /* enable/disable */
  dic->nice = get4com ();       /* nice */
  dic->rev = get4com ();
/* added H.T */
  getwscom (dic->comment);
  getscom (dic->fname);
  getscom (dic->hfname);
  getscom (dic->passwd);
  getscom (dic->hpasswd);
  dic->type = get4com ();
  dic->gosuu = get4com ();
  dic->localf = get4com ();
  dic->hlocalf = get4com ();
}

/***    Dic. Operation by dic_No.       ***/

/**     js_word_add             **/
int
js_word_add (env, dic_no, yomi, kanji, comment, hinshi, init_hindo)
     struct wnn_env *env;
     int dic_no;
     w_char *yomi, *kanji, *comment;
     int hinshi, init_hindo;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_ADD);
  put4com (dic_no);
  putwscom (yomi);
  putwscom (kanji);
  putwscom (comment);
  put4com (hinshi);
  put4com (init_hindo);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}

/**     js_word_delete          **/
int
js_word_delete (env, dic_no, entry)
     struct wnn_env *env;
     int dic_no;
     int entry;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_DELETE);
  put4com (dic_no);
  put4com (entry);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    wnn_errorno = get4com ();
  return x;
}


/**     js_word_search          **/
static int rcv_word_data ();

int
js_word_search (env, dic_no, yomi, ret)
     struct wnn_env *env;
     int dic_no;
     w_char *yomi;
     struct wnn_ret_buf *ret;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_SEARCH);
  put4com (dic_no);
  putwscom (yomi);
  snd_flush ();

  return (rcv_word_data (ret, yomi));
}

/**     js_word_search_by_env   **/
int
js_word_search_by_env (env, yomi, ret)
     struct wnn_env *env;
     w_char *yomi;
     struct wnn_ret_buf *ret;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_SEARCH_BY_ENV);
  putwscom (yomi);
  snd_flush ();

  return (rcv_word_data (ret, yomi));
}

/**     js_word_info            **/
int
js_word_info (env, dic_no, entry, ret)
     struct wnn_env *env;
     int dic_no, entry;
     struct wnn_ret_buf *ret;
{
  register int x;
  w_char yomi[LENGTHYOMI];

  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_INFO);
  put4com (dic_no);
  put4com (entry);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  getwscom (yomi);
  rcv_word_data (ret, yomi);
  return (0);
}

int
js_word_comment_set (env, dic_no, entry, comment)
     struct wnn_env *env;
     int dic_no, entry;
     w_char *comment;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_WORD_COMMENT_SET);
  put4com (dic_no);
  put4com (entry);
  putwscom (comment);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  return (0);
}

/**     rcv for word_search             **/
static int
rcv_word_data (ret, yomi)
     struct wnn_ret_buf *ret;
     w_char *yomi;              /* Yomi is not sent from server
                                 *  (at least for the time being).
                                 */
{
  register int x, j_c, k_c;
  w_char *k;
  register struct wnn_jdata *jd;
  register int cnt;

  j_c = get4com ();
  k_c = get4com ();
  re_alloc (ret, sizeof (struct wnn_jdata) * (j_c + 1) + sizeof (w_char) * (k_c + j_c * 3 + j_c * wnn_Strlen (yomi)));
  jd = (struct wnn_jdata *) ret->buf;
  for (cnt = 0;; cnt++)
    {
      jd->dic_no = x = get4com ();
      if (x == -1)
        break;
      jd->serial = get4com ();
      jd->hinshi = get4com ();
      jd->hindo = get4com ();
      jd->ima = get4com ();
      jd->int_hindo = get4com ();
      jd->int_ima = get4com ();
      jd++;
    }
  jd++;
  k = (w_char *) jd;
  jd = (struct wnn_jdata *) ret->buf;
  for (;;)
    {
      if (jd->dic_no == -1)
        break;

      jd->yomi = k;             /* Copy Yomi */
      wnn_Strcpy (k, yomi);
      k += wnn_Strlen (k) + 1;

      jd->kanji = k;            /* Get Kanji */
      getwscom (k);
      k += wnn_Strlen (k) + 1;

      jd->com = k;              /* Get Comment */
      getwscom (k);
      k += wnn_Strlen (k) + 1;
      jd++;
    }
  return cnt;
}


/**     js_dic_info     **/
int
js_dic_info (env, dic_no, ret)
     struct wnn_env *env;
     int dic_no;
     register WNN_DIC_INFO *ret;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_DIC_INFO);
  put4com (dic_no);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      return get4com ();
    }
  get_dic_info (ret);
  return dic_no;
}


/**     js_who          **/
int
js_who (server, ret)
     WNN_JSERVER_ID *server;
     struct wnn_ret_buf *ret;
{
  register int i, j, c;
  WNN_JWHO *w;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_WHO);
  snd_flush ();

  c = get4com ();
  if (c == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }

  re_alloc (ret, sizeof (WNN_JWHO) * c);
  w = (WNN_JWHO *) ret->buf;
  for (i = 0; i < c; i++)
    {
      w->sd = get4com ();
      getscom (w->user_name);
      getscom (w->host_name);
      for (j = 0; j < WNN_MAX_ENV_OF_A_CLIENT; j++)
        {
          (w->env)[j] = get4com ();
        }
      w++;
    }
  return (c);
}

/**     jserver Ãæ¤ÎÁ´¤Æ¤Î´Ä¶­¤Ë´Ø¤¹¤ë¾ðÊó¤òÆÀ¤ë¡£
        (¥¦¥éµ»)
**/
int
js_env_list (server, ret)
     WNN_JSERVER_ID *server;
     struct wnn_ret_buf *ret;
{
  register int i, j, c;
  WNN_ENV_INFO *w;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_ENV_LIST);
  snd_flush ();

  c = get4com ();
  if (c == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }

  re_alloc (ret, sizeof (WNN_ENV_INFO) * c);
  w = (WNN_ENV_INFO *) ret->buf;
  for (i = 0; i < c; i++)
    {
      w->env_id = get4com ();
      getscom (w->env_name);
      w->ref_count = get4com ();
      w->fzk_fid = get4com ();
      w->jishomax = get4com ();
      for (j = 0; j < WNN_MAX_JISHO_OF_AN_ENV; j++)
        {
          (w->jisho)[j] = get4com ();
        }
      for (j = 0; j < WNN_MAX_FILE_OF_AN_ENV; j++)
        {
          (w->file)[j] = get4com ();
        }
      w++;
    }
  return (c);
}

/****

****/
int
js_hindo_set (env, dic, entry, ima, hindo)
     struct wnn_env *env;
     int dic, entry, ima, hindo;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINDO_SET);

  put4com (dic);
  put4com (entry);
  put4com (ima);
  put4com (hindo);
  snd_flush ();
  if ((x = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }
  return x;
}


/****
        Henkan
****/

static void
put_fzk_vec (hinsi, fzk, vec, vec1)
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
{
  put4com (hinsi);
  putwscom (fzk);
  put4com (vec);
  put4com (vec1);
}

/**
        kanren
**/
static int rcv_dai ();
static void rcv_sho_x ();
static void rcv_sho_kanji ();

int
js_kanren (env, yomi, hinsi, fzk, vec, vec1, vec2, rb)
     struct wnn_env *env;
     w_char *yomi;
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
     int vec2;
     struct wnn_ret_buf *rb;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);

  snd_env_head (env, JS_KANREN);
  putwscom (yomi);
  put_fzk_vec (hinsi, fzk, vec, vec1);
  put4com (vec2);
  snd_flush ();
  return rcv_dai (rb);
}

/*      rcv dai         */
static int
rcv_dai (ret)
     struct wnn_ret_buf *ret;
{
  int dai_cnt, sho_sum, kanji_sum, d_size, s_size, k_size, x;
  register int i;
  struct wnn_dai_bunsetsu *dai_list;
  register struct wnn_dai_bunsetsu *dp;
  struct wnn_sho_bunsetsu *sho_list;
  register struct wnn_sho_bunsetsu *sp;
  w_char *kanji, *kp;

  dai_cnt = get4com ();
  if (dai_cnt == -1)
    {                           /* error dayo */
      wnn_errorno = get4com ();
      return -1;
    }
  sho_sum = get4com ();
  kanji_sum = get4com ();

  d_size = sizeof (struct wnn_dai_bunsetsu) * dai_cnt;
  s_size = sizeof (struct wnn_sho_bunsetsu) * sho_sum;
  k_size = sizeof (w_char) * kanji_sum;

/* re_alloc(ret, d_size+s_size+k_size); Seems This cause Bug?? H.T.*/
  re_alloc (ret, d_size + s_size + k_size);

  dai_list = (struct wnn_dai_bunsetsu *) ret->buf;
  sho_list = (struct wnn_sho_bunsetsu *) ((char *) ret->buf + d_size);
  kanji = (w_char *) ((char *) ret->buf + d_size + s_size);

  for (dp = dai_list, i = 0; i < dai_cnt; i++)
    {
      dp->end = get4com ();
      dp->start = get4com ();
      dp->sbncnt = get4com ();
      dp->hyoka = get4com ();
      dp++;
    }

  for (dp = dai_list, sp = sho_list, i = 0; i < dai_cnt; i++)
    {
      dp->sbn = sp;
      x = dp->sbncnt;
      rcv_sho_x (sp, x);
      sp += x;
      dp++;
    }

  for (dp = dai_list, kp = kanji, i = 0; i < dai_cnt; i++)
    {
      rcv_sho_kanji (dp->sbn, dp->sbncnt, &kp);
      dp++;
    }
  return dai_cnt;
}

/*      rcv sho routines        */
static void
rcv_sho_x (sho_list, sho_cnt)
     register struct wnn_sho_bunsetsu *sho_list;
     int sho_cnt;
{
  register int i;
  for (i = 0; i < sho_cnt; i++)
    {
      sho_list->end = get4com ();
      sho_list->start = get4com ();
      sho_list->jiriend = get4com ();
      sho_list->dic_no = get4com ();
      sho_list->entry = get4com ();
      sho_list->hindo = get4com ();
      sho_list->ima = get4com ();
      sho_list->hinsi = get4com ();
      sho_list->status = get4com ();
      sho_list->status_bkwd = get4com ();
      sho_list->kangovect = get4com ();
      sho_list->hyoka = get4com ();
      sho_list++;
    }
}

static void
rcv_sho_kanji (sho_list, sho_cnt, kanji)
     struct wnn_sho_bunsetsu *sho_list;
     int sho_cnt;
     w_char **kanji;
{
  register w_char *k;
  register int i, x;
  k = *kanji;
  for (i = 0; i < sho_cnt; i++)
    {
      sho_list->kanji = k;
      getwscom (k);
      x = wnn_Strlen (k);
      k += x + 1;

      sho_list->yomi = k;
      getwscom (k);
      x = wnn_Strlen (k);
      k += x + 1;

      sho_list->fuzoku = k;
      getwscom (k);
      x = wnn_Strlen (k);
      k += x + 1;
      sho_list++;
    }
  *kanji = k;
}


static int
rcv_sho (ret)
     struct wnn_ret_buf *ret;
{
  register int sho_sum, kanji_sum, s_size, k_size;
  struct wnn_sho_bunsetsu *sho_list;
  w_char *kanji, *kp;

  sho_sum = get4com ();
  if (sho_sum == -1)
    {                           /* error dayo */
      wnn_errorno = get4com ();
      return -1;
    }
  kanji_sum = get4com ();

  s_size = sizeof (struct wnn_sho_bunsetsu) * sho_sum;
  k_size = sizeof (w_char) * kanji_sum;

  re_alloc (ret, s_size + k_size);

  sho_list = (struct wnn_sho_bunsetsu *) ((char *) ret->buf);
  kanji = (w_char *) ((char *) ret->buf + s_size);

  rcv_sho_x (sho_list, sho_sum);
  kp = kanji;
  rcv_sho_kanji (sho_list, sho_sum, &kp);
  return sho_sum;
}

/**
        kantan
**/
int
js_kantan_dai (env, yomi, hinsi, fzk, vec, vec1, rb)
     struct wnn_env *env;
     w_char *yomi;
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
     struct wnn_ret_buf *rb;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);

  snd_env_head (env, JS_KANTAN_DAI);
  putwscom (yomi);
  put_fzk_vec (hinsi, fzk, vec, vec1);
  snd_flush ();

  return rcv_dai (rb);
}

int
js_kantan_sho (env, yomi, hinsi, fzk, vec, vec1, rb)
     struct wnn_env *env;
     w_char *yomi;
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
     struct wnn_ret_buf *rb;
{
  int sbncnt;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);

  snd_env_head (env, JS_KANTAN_SHO);
  putwscom (yomi);
  put_fzk_vec (hinsi, fzk, vec, vec1);
  snd_flush ();

  sbncnt = rcv_sho (rb);
  return sbncnt;
}

/**
        kanzen
**/
int
js_kanzen_dai (env, yomi, hinsi, fzk, vec, vec1, rb)
     struct wnn_env *env;
     w_char *yomi;
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
     struct wnn_ret_buf *rb;
{
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_KANZEN_DAI);
  putwscom (yomi);
  put_fzk_vec (hinsi, fzk, vec, vec1);
  snd_flush ();

  return rcv_dai (rb);
}


int
js_kanzen_sho (env, yomi, hinsi, fzk, vec, vec1, rb)
     struct wnn_env *env;
     w_char *yomi;
     int hinsi;
     w_char *fzk;
     int vec;
     int vec1;
     struct wnn_ret_buf *rb;
{
  int sbncnt;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_KANZEN_SHO);
  putwscom (yomi);
  put_fzk_vec (hinsi, fzk, vec, vec1);
  snd_flush ();

  sbncnt = rcv_sho (rb);
  return sbncnt;
}

/**     js_version              **/
int
js_version (server, serv, libv)
     int *serv, *libv;
     WNN_JSERVER_ID *server;
{
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_VERSION);
  snd_flush ();
  *libv = JLIB_VERSION;
  return *serv = get4com ();
}

static void
re_alloc (ret, size)
     register struct wnn_ret_buf *ret;
     int size;
{
  if (ret->size < size)
    {
      if (ret->buf)
        free ((char *) ret->buf);
      ret->buf = malloc (size);
      ret->size = size;
    }
}


int
js_kill (server)
     WNN_JSERVER_ID *server;
{
  int x;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_KILL);
  snd_flush ();
  x = get4com ();
  return (x);
}


int
js_file_remove (server, n, pwd)
     WNN_JSERVER_ID *server;
     char *n, *pwd;
{
  register int x;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_FILE_REMOVE);
  putscom (n);
  putscom (pwd);
  snd_flush ();
  if ((x = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return -1;
    }
  return (x);
}

int
js_file_remove_client (server, n, pwd)
     WNN_JSERVER_ID *server;
     char *n, *pwd;
{
  struct wnn_file_head fh;
  register FILE *fp;
  set_current_js (server);
  handler_of_jserver_dead (-1);
  if (js_file_loaded_local (server, n) != -1)
    {
      wnn_errorno = WNN_FILE_IN_USE;
      return (-1);
    }
#ifdef WRITE_CHECK
  check_backup (n);
#endif /* WRITE_CHECK */
  if ((fp = fopen (n, "r")) == NULL)
    {
      wnn_errorno = WNN_FILE_READ_ERROR;
      return (-1);
    }
  if (input_file_header (fp, &fh) == -1)
    {
      fclose (fp);
      wnn_errorno = WNN_NOT_A_FILE;
      return (-1);
    }
  fclose (fp);
  if (!check_pwd (pwd, fh.file_passwd))
    {
      wnn_errorno = WNN_INCORRECT_PASSWD;
      return (-1);
    }
  if (unlink (n) == -1)
    {
      wnn_errorno = WNN_UNLINK;
      return (-1);
    }
  return (0);
}

/**     js_dic_file_create_client       **/
int
js_dic_file_create_client (env, fn, type, com, passwd, hpasswd)
     struct wnn_env *env;
     int type;
     char *fn;
     w_char *com;
     char *passwd, *hpasswd;
{
  int x;
  if (type != WNN_REV_DICT && type != CWNN_REV_DICT && type != BWNN_REV_DICT && type != WNN_UD_DICT)
    {
      wnn_errorno = WNN_NOT_A_UD;
      return (-1);
    }
  x = create_null_dic (fn, com, passwd, hpasswd, type);
  if (x == -1)
    {
      wnn_errorno = WNN_FILE_CREATE_ERROR;
      return (-1);
    }
  return (0);
}


/**     js_hindo_file_create_client     **/
int
js_hindo_file_create_client (env, fid, fn, com, hpasswd)
     struct wnn_env *env;
     int fid;
     char *fn;
     w_char *com;
     char *hpasswd;
{
  register int x;
  struct wnn_file_uniq funiq;
  int serial;
  register int i;

  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINDO_FILE_CREATE_CLIENT);
  put4com (fid);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  serial = get4com ();
  funiq.time = get4com ();
  funiq.dev = get4com ();
  funiq.inode = get4com ();
  for (i = 0; i < WNN_HOSTLEN; i++)
    {
      funiq.createhost[i] = get1com ();
    }
/*    getscom(funiq.createhost); */
  if (create_hindo_file (&funiq, fn, com, hpasswd, serial) == -1)
    {
      wnn_errorno = WNN_FILE_CREATE_ERROR;
      return (-1);
    }
  return (0);
}

int
js_file_comment_set (env, fid, comment)
     struct wnn_env *env;
     int fid;
     w_char *comment;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_COMMENT_SET);
  put4com (fid);
  putwscom (comment);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  return (0);
}


/* 
 * Hinsi Primitives
 */

int
js_hinsi_name (server, no, rb)
     WNN_JSERVER_ID *server;
     int no;
     struct wnn_ret_buf *rb;
{
  register int size;

  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_HINSI_NAME);
  put4com (no);
  snd_flush ();
  if ((size = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  re_alloc (rb, sizeof (w_char) * (size + 1));
  getwscom ((w_char *) rb->buf);
  return (0);
}


int
js_hinsi_number (server, name)
     WNN_JSERVER_ID *server;
     w_char *name;
{
  register int no;

  set_current_js (server);
  handler_of_jserver_dead (-1);
  snd_server_head (server, JS_HINSI_NUMBER);
  putwscom (name);
  snd_flush ();
  if ((no = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  return (no);
}


int
js_hinsi_list (env, dic_no, name, rb)
     struct wnn_env *env;
     int dic_no;
     w_char *name;
     struct wnn_ret_buf *rb;
{
  int size;
  int count;
  register w_char *s;
  register w_char **r;
  register int k;

  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINSI_LIST);
  put4com (dic_no);
  putwscom (name);
  snd_flush ();
  if ((count = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  size = get4com ();
  re_alloc (rb, sizeof (w_char) * (size + 1) + count * sizeof (w_char *));
  r = (w_char **) rb->buf;
  s = (w_char *) ((w_char **) rb->buf + count);
  for (k = 0; k < count; k++)
    {
      *r++ = s;
      getwscom (s);
      s += wnn_Strlen (s) + 1;
    }
  return (count);
}


int
js_hinsi_dicts (env, no, rb)
     struct wnn_env *env;
     int no;
     struct wnn_ret_buf *rb;
{
  register int k, count;
  int *p;

  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINSI_DICTS);
  put4com (no);
  snd_flush ();
  if ((count = get4com ()) == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  re_alloc (rb, sizeof (int) * (count + 1));
  p = (int *) rb->buf;

  for (k = 0; k < count; k++)
    {
      *p++ = get4com ();
    }
  return (count);
}


char *wnn_dic_types[] = { "", "¸ÇÄê", "ÅÐÏ¿", "µÕ°ú", "Àµµ¬" };

char *cwnn_dic_types[] = { "", "¹Ì¶¨", "µÇ¼", "Æ´Òô", "Õý¹æ" };
char *bwnn_dic_types[] = { "", "¹Ì¶¨", "µÇ¼", "±ÊÐÍ", "Õý¹æ" };

char *kwnn_dic_types[] = { "", "°íÁ¤", "µî·Ï", "¿ª¿ë", "Á¤±Ô" };
                        /*    ͳïÒ   ÔôÖâ   æ½ìÚ   ïáЮ */

/* New primitives  9/8 */

int
js_file_password_set (env, fid, which, old, new)
     struct wnn_env *env;
     int fid;
     int which;                 /* 1 for dic, 2 for hindo 3(0) for both */
     char *old, *new;
{
  register int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_FILE_PASSWORD_SET);
  put4com (fid);
  put4com (which);
  putscom (old);
  putscom (new);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  return (0);
}

int
js_hinsi_table_set (env, dic_no, hinsi_table)
     struct wnn_env *env;
     int dic_no;
     w_char *hinsi_table;
{
  int x;
  if (env == 0)
    return (-1);
  set_current_js (env->js_id);
  handler_of_jserver_dead (-1);
  snd_env_head (env, JS_HINSI_TABLE_SET);
  put4com (dic_no);
  putwscom (hinsi_table);
  snd_flush ();
  x = get4com ();
  if (x == -1)
    {
      wnn_errorno = get4com ();
      return (-1);
    }
  return (0);
}

#define SERVERDEFS_FILE         "/serverdefs"

#define MACHINE_NAME            1
#define UNIXDOMAIN_NAME         2
#define SERVICE_NAME            3
#define SERVICE_PORT_NUM        4

static char *
get_serv_defs (lang, cnt)
     char *lang;
     int cnt;
{
  FILE *fp;
  static char s[7][EXPAND_PATH_LENGTH];
  char serv_defs[EXPAND_PATH_LENGTH];
  char data[1024];
  int num;

  strcpy (serv_defs, LIBDIR);
  strcat (serv_defs, SERVERDEFS_FILE);
  if ((fp = fopen (serv_defs, "r")) == NULL)
    {
      return (NULL);
    }
  while (fgets (data, 1024, fp) != NULL)
    {
      num = sscanf (data, "%s %s %s %s %s %s %s", s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
      if ((num < 4) || s[0][0] == ';')
        {
          continue;
        }
      if (!strncmp (lang, s[0], strlen (s[0])))
        {
          fclose (fp);
          if (cnt == SERVICE_PORT_NUM && num < 5)
            return (NULL);
          if (strlen (s[cnt]) == strlen ("NULL") && !strcmp (s[cnt], "NULL"))
            {
              return (NULL);
            }
          else
            {
              return (s[cnt]);
            }
        }
    }
  fclose (fp);
  return (NULL);
}

char *
_wnn_get_machine_of_serv_defs (lang)
     char *lang;
{
  return (get_serv_defs (lang, MACHINE_NAME));
}

static char *
get_unixdomain_of_serv_defs (lang)
     char *lang;
{
  return (get_serv_defs (lang, UNIXDOMAIN_NAME));
}

static char *
get_service_of_serv_defs (lang)
     char *lang;
{
  return (get_serv_defs (lang, SERVICE_NAME));
}

static int
get_port_num_of_serv_defs (lang)
     char *lang;
{
  char *port_char;

  if ((port_char = get_serv_defs (lang, SERVICE_PORT_NUM)) == NULL)
    {
      return (-1);
    }
  else
    {
      return (atoi (port_char));
    }
}