upstream/0.5.0/estmaster.c

/*************************************************************************************************
 * The master of node servers
 *                                                      Copyright (C) 2004-2005 Mikio Hirabayashi
 * This file is part of Hyper Estraier.
 * Hyper Estraier 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.1 of the License or any later version.  Hyper Estraier 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 Hyper
 * Estraier; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA.
 *************************************************************************************************/


#include "mastermod.h"

#define SERVNAME       "estmaster"       /* name of the server */
#define IOBUFSIZ       8192              /* size of a buffer for I/O */
#define RECVMAX        1024 * 1024 * 32  /* max length of data to receive */
#define SPCACHEMNUM    131072            /* max number of the special cache */
#define IFLUSHSEC      60                /* idle time to start flushing */
#define IFLUSHNUM      5000              /* number of keys per flushing */
#define DEFMAXSRCH     10                /* default max number of retrieved documents */
#define SELFCREDIT     10000             /* credit of the node itself */
#define FCLOSECONNNUM  10                /* number of over connections for forced closing */
#define FCLOSEWAITMAX  10                /* wait time for forced closing */
#define FTERMWAITMAX   60                /* wait time for forced termination */

#define MASTERLOC      "/master"         /* location of the URL of the master */
#define NODEPREFIX     "/node/"          /* prefix of the URL of nodes */
#define MASTERUILOC    "/masterui"       /* prefix of user intarfaces */
#define DATTRNDURL     "#nodeurl"        /* name of the pseudo-attribute of the node URL */
#define DATTRNDLABEL   "#nodelabel"      /* name of the pseudo-attribute of the node label */

typedef struct {                         /* type of structure for a communication */
  int clsock;                            /* socket between client */
  char claddr[ADDRBUFSIZ];               /* address of the client */
  int clport;                            /* port number of the client */
} TARGCOMM;

enum {                                   /* enumeration for HTTP method */
  HM_HEAD,                               /* HEAD */
  HM_GET,                                /* GET */
  HM_POST,                               /* POST */
  HM_UNKNOWN                             /* unknown */
};

typedef struct {                         /* type of structure for a request */
  const char *claddr;                    /* address of the client */
  int clport;                            /* port number of the client */
  int method;                            /* method */
  char *target;                          /* target path */
  char *name;                            /* user name */
  char *passwd;                          /* password */
  time_t ims;                            /* if-modified-since header */
  char *ctype;                           /* content-type header */
  char *estvia;                          /* x-estraier-via header */
  char *host;                            /* host header */
  char *body;                            /* entity body */
  CBMAP *params;                         /* parameters */
} REQUEST;

typedef struct {                         /* type of structure for a local search */
  REQUEST *req;                          /* request object */
  int alive;                             /* whether to be alive */
  ESTCOND *cond;                         /* search condition */
  CBMAP *hints;                          /* hints about result */
  int max;                               /* max number of retrieved documents */
  NODE *node;                            /* self node object */
  RESMAP *resmap;                        /* documents in result */
  CBLIST *words;                         /* words in the search phrase */
  int hnum;                              /* number of hits */
} TARGLCSRCH;

typedef struct {                         /* type of structure for a remote search */
  REQUEST *req;                          /* request object */
  int alive;                             /* whether to be alive */
  const char *myurl;                     /* url of the local node */
  ESTCOND *cond;                         /* search condition */
  CBMAP *hints;                          /* hints about result */
  int max;                               /* max number of retrieved documents */
  NODE *node;                            /* self node object */
  RESMAP *resmap;                        /* documents in result */
  const char *url;                       /* URL of the link */
  int credit;                            /* credit of the link */
  char *label;                           /* label of the link */
  int depth;                             /* depth of meta search */
  int hnum;                              /* number of hits */
  int dnum;                              /* number of documents */
  int wnum;                              /* number of words */
  double size;                           /* size of the database */
} TARGRMSRCH;

enum {                                   /* enumeration for UI operations */
  UI_VIEWMASTER,                         /* view master operations */
  UI_SHUTDOWN,                           /* shutdown the master server */
  UI_VIEWUSERS,                          /* view user operations */
  UI_NEWUSER,                            /* create a user */
  UI_DELUSER,                            /* delete a user */
  UI_VIEWNODES,                          /* view node operations */
  UI_NEWNODE,                            /* create a node */
  UI_DELNODE,                            /* delete a node */
  UI_NONE                                /* none */
};


/* global variables */
const char *g_progname;                  /* program name */
int g_sigterm = FALSE;                   /* flag for termination signal */
int g_sigrestart = FALSE;                /* flag for restarting signal */
const char *g_rootdir = NULL;            /* path of the root directory */
const char *g_hostname = NULL;           /* fully qualified host name */
int g_portnum = 0;                       /* port number of TCP */
int g_runmode = 0;                       /* runnning mode */
int g_authmode = 0;                      /* authorization mode */
int g_maxconn = 0;                       /* maximum number of connections */
int g_sessiontimeout = 0;                /* timeout of a session, in seconds */
int g_searchtimeout = 0;                 /* timeout of search, in seconds */
int g_searchdepth = 0;                   /* depth of search */
const char *g_proxyhost = NULL;          /* host name of the proxy */
int g_proxyport = 0;                     /* port number of the proxy */
int g_loglevel = 0;                      /* logging level */
const char *g_docroot = NULL;            /* path of the document root directory */
const char *g_indexfile = NULL;          /* name of directory index files */
CBMAP *g_trustednodes = NULL;            /* addresses of trusted nodes */
int g_denyuntrusted = FALSE;             /* whether to deny untrusted nodes */
const char *g_specialcache = NULL;       /* name of the attribute of special cache */
int g_snipwwidth = 0;                    /* whole width of the snippet */
int g_sniphwidth = 0;                    /* width of beginning of the text */
int g_snipawidth = 0;                    /* width around each highlighted word */
int g_bgmode = FALSE;                    /* whether to be foreground mode */
int g_stmode = FALSE;                    /* whether to be single thread mode */
DEPOT *g_metadb = NULL;                  /* meta database */
UMGR *g_umgr = NULL;                     /* user manager */
NMGR *g_nmgr = NULL;                     /* node manager */
RWLOCK *g_runlock = NULL;                /* read-write lock for running threads */
RWLOCK *g_mgrlock = NULL;                /* read-write lock for handling managers */
const char *g_bordstr = NULL;            /* border string */
int g_svsock = -1;                       /* server socket */


/* function prototypes */
int main(int argc, char **argv);
static void setsignals(void);
static void sigtermhandler(int num);
static void usage(void);
static int runinit(int argc, char **argv);
static int runstart(int argc, char **argv);
static int runstop(int argc, char **argv);
static int rununittest(int argc, char **argv);
static int runcrypt(int argc, char **argv);
static void die(const char *format, ...);
static void startup(void);
static const char *skiplabel(const char *str);
static void cleanup(void);
static int procinit(const char *rootdir, int ex);
static int procstart(const char *rootdir);
static int procstop(const char *rootdir);
static int procunittest(const char *rootdir);
static int proccrypt(const char *key, const char *hash);
static void dispatch(void);
static void *flushnode(void *targ);
static void *communicate(void *targ);
static void setparams(CBMAP *params, const char *src);
static void addservinfo(CBDATUM *datum);
static void senderror(int clsock, REQUEST *req, int code, const char *message);
static int isbanned(USER *user);
static int ismasteradmin(REQUEST *req, USER *user);
static int isnodeadmin(NODE *node, REQUEST *req, USER *user);
static int isnodeuser(NODE *node, REQUEST *req, USER *user);
static void sendautherror(int clsock, REQUEST *req, const char *realm);
static void sendmasterdata(int clsock, REQUEST *req, USER *user);
static void sendnodedata(int clsock, REQUEST *req, USER *user, const char *path);
static void setdocorigin(ESTDOC *doc, NODE *node);
static void mergehints(CBMAP *total, CBMAP *local);
static int islooproute(const char *url, REQUEST *req);
static void *searchlocal(void *targ);
static void *searchremote(void *targ);
static void catdocdata(CBDATUM *datum, RESDOC *resdoc, CBLIST *words);
static void sendnodecmdinform(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdsearch(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdgetdoc(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdgetdocattr(int clsock, REQUEST *req, NODE *node);
static void sendnodecmduritoid(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdputdoc(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdoutdoc(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdsetuser(int clsock, REQUEST *req, NODE *node);
static void sendnodecmdsetlink(int clsock, REQUEST *req, NODE *node);
static void senduidata(int clsock, REQUEST *req, USER *user);
static void sendfiledata(int clsock, REQUEST *req);
static char *makelocalpath(const char *target);


/* main routine */
int main(int argc, char **argv){
  const char *tmp;
  int rv;
  if((tmp = getenv("ESTDBGFD")) != NULL) dpdbgfd = atoi(tmp);
  cbstdiobin();
  g_progname = argv[0];
  g_sigterm = FALSE;
  if(argc < 2) usage();
  rv = 0;
  if(!strcmp(argv[1], "init")){
    rv = runinit(argc, argv);
  } else if(!strcmp(argv[1], "start")){
    rv = runstart(argc, argv);
  } else if(!strcmp(argv[1], "stop")){
    rv = runstop(argc, argv);
  } else if(!strcmp(argv[1], "unittest")){
    rv = rununittest(argc, argv);
  } else if(!strcmp(argv[1], "crypt")){
    rv = runcrypt(argc, argv);
  } else {
    usage();
  }
  return rv;
}


/* set signal handlers */
static void setsignals(void){
  signal(1, sigtermhandler);
  signal(2, sigtermhandler);
  signal(3, sigtermhandler);
  signal(13, SIG_IGN);
  signal(15, sigtermhandler);
  g_sigterm = FALSE;
  g_sigrestart = FALSE;
}


/* handler of termination signal */
static void sigtermhandler(int num){
  g_sigterm = TRUE;
  if(num == 1) g_sigrestart = TRUE;
}


/* print the usage and exit */
static void usage(void){
  fprintf(stderr, "%s: the master of node servers\n", g_progname);
  fprintf(stderr, "\n");
  fprintf(stderr, "usage:\n");
  fprintf(stderr, "  %s init [-ex] rootdir\n", g_progname);
  fprintf(stderr, "  %s start [-bg] [-st] rootdir\n", g_progname);
  fprintf(stderr, "  %s stop rootdir\n", g_progname);
  fprintf(stderr, "  %s unittest rootdir\n", g_progname);
  fprintf(stderr, "  %s crypt key [hash]\n", g_progname);
  fprintf(stderr, "\n");
  exit(1);
}


/* parse arguments of the init command */
static int runinit(int argc, char **argv){
  char *rootdir;
  int i, ex, rv;
  rootdir = NULL;
  ex = FALSE;
  for(i = 2; i < argc; i++){
    if(!rootdir && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-ex")){
        ex = TRUE;
      } else {
        usage();
      }
    } else if(!rootdir){
      rootdir = argv[i];
    } else {
      usage();
    }
  }
  if(!rootdir) usage();
  rv = procinit(rootdir, ex);
  return rv;
}


/* parse arguments of the start command */
static int runstart(int argc, char **argv){
  char *rootdir;
  int i, rv;
  rootdir = NULL;
  for(i = 2; i < argc; i++){
    if(!rootdir && argv[i][0] == '-'){
      if(!strcmp(argv[i], "-bg")){
        g_bgmode = TRUE;
      } else if(!strcmp(argv[i], "-st")){
        g_stmode = TRUE;
      } else {
        usage();
      }
    } else if(!rootdir){
      rootdir = argv[i];
    } else {
      usage();
    }
  }
  if(!rootdir) usage();
  rv = procstart(rootdir);
  return rv;
}


/* parse arguments of the stop command */
static int runstop(int argc, char **argv){
  char *rootdir;
  int i, rv;
  rootdir = NULL;
  for(i = 2; i < argc; i++){
    if(!rootdir && argv[i][0] == '-'){
      usage();
    } else if(!rootdir){
      rootdir = argv[i];
    } else {
      usage();
    }
  }
  if(!rootdir) usage();
  rv = procstop(rootdir);
  return rv;
}


/* parse arguments of the unittest command */
static int rununittest(int argc, char **argv){
  char *rootdir;
  int i, rv;
  rootdir = NULL;
  for(i = 2; i < argc; i++){
    if(!rootdir && argv[i][0] == '-'){
      usage();
    } else if(!rootdir){
      rootdir = argv[i];
    } else {
      usage();
    }
  }
  if(!rootdir) usage();
  rv = procunittest(rootdir);
  return rv;
}


/* parse arguments of the crypt command */
static int runcrypt(int argc, char **argv){
  char *key, *hash;
  int i, rv;
  key = NULL;
  hash = NULL;
  for(i = 2; i < argc; i++){
    if(!key && argv[i][0] == '-'){
      usage();
    } else if(!key){
      key = argv[i];
    } else if(!hash){
      hash = argv[i];
    } else {
      usage();
    }
  }
  if(!key) usage();
  rv = proccrypt(key, hash);
  return rv;
}


/* print formatted error string and exit */
static void die(const char *format, ...){
  va_list ap;
  va_start(ap, format);
  fprintf(stderr, "%s: ", g_progname);
  vfprintf(stderr, format, ap);
  fputc('\n', stderr);
  fflush(stderr);
  va_end(ap);
  exit(1);
}


/* initialize the global variables */
static void startup(void){
  NODE *node;
  CBLIST *lines, *elems;
  struct stat sbuf;
  const char *rp, *name;
  char path[URIBUFSIZ], numbuf[NUMBUFSIZ];
  int i, j, pid, omode;
  if(stat(g_rootdir, &sbuf) == -1)
    die("the server root directory (%s) could not open", g_rootdir);
  sprintf(path, "%s%c%s", g_rootdir, ESTPATHCHR, CONFFILE);
  if(!(lines = cbreadlines(path))) die("the configuration file (%s) could not open", path);
  cbglobalgc(lines, (void (*)(void *))cblistclose);
  g_trustednodes = cbmapopenex(MINIBNUM);
  cbglobalgc(g_trustednodes, (void (*)(void *))cbmapclose);
  for(i = 0; i < cblistnum(lines); i++){
    rp = cblistval(lines, i, NULL);
    if(cbstrfwimatch(rp, "hostname:")){
      g_hostname = skiplabel(rp);
    } else if(cbstrfwimatch(rp, "portnum:")){
      g_portnum = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "runmode:")){
      g_runmode = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "authmode:")){
      g_authmode = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "maxconn:")){
      g_maxconn = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "sessiontimeout:")){
      g_sessiontimeout = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "searchtimeout:")){
      g_searchtimeout = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "searchdepth:")){
      g_searchdepth = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "proxyhost:")){
      g_proxyhost = skiplabel(rp);
    } else if(cbstrfwimatch(rp, "proxyport:")){
      g_proxyport = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "loglevel:")){
      g_loglevel = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "docroot:")){
      g_docroot = skiplabel(rp);
    } else if(cbstrfwimatch(rp, "indexfile:")){
      g_indexfile = skiplabel(rp);
    } else if(cbstrfwimatch(rp, "trustednodes:")){
      elems = cbsplit(skiplabel(rp), -1, " ,");
      for(j = 0; j < cblistnum(elems); j++){
        rp = cblistval(elems, j, NULL);
        if(rp != '\0') cbmapput(g_trustednodes, rp, -1, "", 0, TRUE);
      }
      cblistclose(elems);
    } else if(cbstrfwimatch(rp, "denyuntrusted:")){
      g_denyuntrusted = atoi(skiplabel(rp)) > 0;
    } else if(cbstrfwimatch(rp, "specialcache:")){
      g_specialcache = skiplabel(rp);
    } else if(cbstrfwimatch(rp, "snipwwidth:")){
      g_snipwwidth = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "sniphwidth:")){
      g_sniphwidth = atoi(skiplabel(rp));
    } else if(cbstrfwimatch(rp, "snipawidth:")){
      g_snipawidth = atoi(skiplabel(rp));
    }
  }
  if(!g_hostname) die("hostname is undefined");
  if(g_portnum < 1) die("portnum is undefined");
  if(g_runmode < RM_NORMAL || g_runmode > RM_RDONLY) die("runmode is undefined");
  if(g_authmode < AM_NONE || g_authmode > AM_ALL) die("authmode is undefined");
  if(g_maxconn < 1) die("maxconn is undefined");
  if(g_sessiontimeout < 1) die("sessiontimeout is undefined");
  if(g_searchtimeout < 1) die("searchtimeout is undefined");
  if(g_searchdepth < 1) die("searchdepth is undefined");
  if(!g_proxyhost) die("proxyhost is undefined");
  if(g_proxyhost[0] != '\0' && g_proxyport < 1) die("proxyport is undefined");
  if(g_loglevel < LL_DEBUG || g_loglevel > LL_NONE) die("loglevel is undefined");
  if(!g_docroot) die("docroot is undefined");
  if(!g_indexfile) die("indexfile is undefined");
  if(!g_specialcache) die("indexfile is undefined");
  if(g_snipwwidth < 0) die("snipwwidth is invalid");
  if(g_sniphwidth < 0) die("sniphwidth is invalid");
  if(g_snipawidth < 0) die("snipawidth is invalid");
  if((pid = lockerpid(g_rootdir)) > 0)
    die("other process (pid:%d) has opened the database", pid);
  if(g_bgmode && !be_daemon(g_rootdir)) die("the process could not be a daemon");
  sprintf(path, "%s%c%s", g_rootdir, ESTPATHCHR, METAFILE);
  omode = (g_runmode == RM_RDONLY ? DP_OREADER : DP_OWRITER) | DP_OLCKNB;
  if(!(g_metadb = dpopen(path, omode, MINIBNUM))){
    if(dpecode == DP_ELOCK){
      die("other process (pid:%d) has opened the database", lockerpid(g_rootdir));
    } else {
      die("the meta database file (%s) could not open", path);
    }
  }
  pid = (int)getpid();
  sprintf(path, "%s%c%s", g_rootdir, ESTPATHCHR, PIDFILE);
  sprintf(numbuf, "%d\n", pid);
  cbwritefile(path, numbuf, -1);
  if(!log_open(g_rootdir, g_loglevel)){
    unlink(path);
    dpclose(g_metadb);
    die("starting logging failed");
  }
  log_print(LL_INFO, "starting the master process (pid:%d)", pid);
  g_umgr = umgr_new(g_rootdir);
  g_nmgr = nmgr_new(g_rootdir);
  if(!umgr_load(g_umgr) || !nmgr_load(g_nmgr, g_runmode != RM_RDONLY)){
    unlink(path);
    nmgr_delete(g_nmgr);
    umgr_delete(g_umgr);
    dpclose(g_metadb);
    log_print(LL_ERROR, "loading users and nodes failed");
    die("loading users and nodes failed");
  }
  g_runlock = rwlock_new();
  g_mgrlock = rwlock_new();
  if(!est_init_net_env() || (g_svsock = est_get_server_sock(NULL, g_portnum)) == -1){
    unlink(path);
    rwlock_delete(g_mgrlock);
    rwlock_delete(g_runlock);
    nmgr_delete(g_nmgr);
    umgr_delete(g_umgr);
    dpclose(g_metadb);
    log_print(LL_ERROR, "initializing network failed");
    die("initializing network failed");
  }
  if(g_docroot[0] != '\0'){
    if(stat(g_docroot, &sbuf) == 0){
      log_print(LL_INFO, "letting the directory (%s) be public", g_docroot);
    } else {
      log_print(LL_WARN, "missing the directory (%s)", g_docroot);
    }
  }
  g_bordstr = est_border_str();
  if(g_specialcache[0] != '\0'){
    elems = nmgr_names(g_nmgr);
    for(i = 0; i < cblistnum(elems); i++){
      if(!(name = cblistval(elems, i, NULL)) || !(node = nmgr_get(g_nmgr, name))) continue;
      est_mtdb_set_special_cache(node->db, g_specialcache, SPCACHEMNUM);
    }
    cblistclose(elems);
  }
}


/* skip the label of a line */
static const char *skiplabel(const char *str){
  if(!(str = strchr(str, ':'))) return "";
  str++;
  while(*str != '\0' && (*str == ' ' || *str == '\t')){
    str++;
  }
  return str;
}


/* clean up resources */
static void cleanup(void){
  char path[URIBUFSIZ];
  if(g_svsock != -1) est_sock_down(g_svsock);
  rwlock_delete(g_mgrlock);
  rwlock_delete(g_runlock);
  nmgr_delete(g_nmgr);
  umgr_delete(g_umgr);
  sprintf(path, "%s%c%s", g_rootdir, ESTPATHCHR, STOPFILE);
  unlink(path);
  sprintf(path, "%s%c%s", g_rootdir, ESTPATHCHR, PIDFILE);
  unlink(path);
  dpclose(g_metadb);
  log_print(LL_INFO, "the master process finished");
}


/* perform the init command */
static int procinit(const char *rootdir, int ex){
  UMGR *umgr;
  NMGR *nmgr;
  NODE *node;
  ESTDOC *doc;
  char *tmp;
  int err;
  setsignals();
  if(!master_init(rootdir)){
    log_print(LL_ERROR, "initializing the root directory failed");
    return 1;
  }
  log_open(rootdir, LL_INFO);
  log_print(LL_INFO, "the root directory created");
  umgr = umgr_new(rootdir);
  tmp = est_make_crypt("admin");
  umgr_put(umgr, "admin", tmp, "s", "Carolus Magnus", "Administrator");
  free(tmp);
  if(ex){
    tmp = est_make_crypt("john");
    umgr_put(umgr, "john", tmp, "", "John Doe", "Normal User");
    free(tmp);
    tmp = est_make_crypt("dick");
    umgr_put(umgr, "dick", tmp, "", "Richard Roe", "Normal User");
    free(tmp);
    tmp = est_make_crypt("lupin");
    umgr_put(umgr, "lupin", tmp, "b", "Arsene Lupin", "Banned User");
    free(tmp);
  }
  err = FALSE;
  if(!umgr_delete(umgr)) err = TRUE;
  nmgr = nmgr_new(rootdir);
  if(ex){
    nmgr_put(nmgr, "sample1", TRUE);
    if((node = nmgr_get(nmgr, "sample1")) != NULL){
      free(node->label);
      node->label = cbmemdup("Sample Node One", -1);
      cbmapput(node->admins, "john", -1, "", 0, TRUE);
      cbmapput(node->users, "john", -1, "", 0, TRUE);
      cbmapput(node->users, "dick", -1, "", 0, TRUE);
      cbmapput(node->users, "lupin", -1, "", 0, TRUE);
      node_set_link(node, "http://localhost:1978/node/sample2",
                    "Sample-Node-Two", 4000);
      doc = est_doc_new();
      est_doc_add_attr(doc, ESTDATTRURI, "http://localhost/foo.html");
      est_doc_add_text(doc, "You may my glories and my state dispose,");
      est_doc_add_text(doc, "But not my griefs; still am I king of those.");
      est_doc_add_text(doc, "(Give it up, Yo!  Give it up, Yo!)");
      est_mtdb_put_doc(node->db, doc, 0);
      est_doc_delete(doc);
      doc = est_doc_new();
      est_doc_add_attr(doc, ESTDATTRURI, "http://localhost/bar.html");
      est_doc_add_text(doc, "The faster I go, the behinder I get.");
      est_doc_add_text(doc, "(Give it up, Yo!  Give it up, Yo!)");
      est_mtdb_put_doc(node->db, doc, 0);
      est_doc_delete(doc);
    } else {
      err = TRUE;
    }
    nmgr_put(nmgr, "sample2", TRUE);
    if((node = nmgr_get(nmgr, "sample2")) != NULL){
      free(node->label);
      node->label = cbmemdup("Sample Node Two", -1);
      cbmapput(node->users, "john", -1, "", 0, TRUE);
      node_set_link(node, "http://localhost:1978/node/sample1",
                    "Sample-Node-One", 8000);
      doc = est_doc_new();
      est_doc_add_attr(doc, ESTDATTRURI, "http://localhost/foo.html");
      est_doc_add_text(doc, "He that is giddy thinks the world turns round.");
      est_doc_add_text(doc, "(Give it up, Yo!  Give it up, Yo!)");
      est_mtdb_put_doc(node->db, doc, 0);
      est_doc_delete(doc);
    } else {
      err = TRUE;
    }
  }
  if(!nmgr_delete(nmgr)) err = TRUE;
  return err ? 1 : 0;
}


/* perform the start command */
static int procstart(const char *rootdir){
  char *path;
  path = est_realpath(rootdir);
  cbglobalgc(path, free);
  g_rootdir = path;
  do {
    setsignals();
    startup();
    dispatch();
    cleanup();
  } while(g_sigrestart);
  return 0;
}


/* perform the stop command */
static int procstop(const char *rootdir){
  struct stat sbuf;
  char path[URIBUFSIZ], *buf;
  int pid;
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, PIDFILE);
  if(!(buf = cbreadfile(path, NULL))) die("not running");
  pid = atoi(buf);
  free(buf);
  if(pid < 1) die("not running");
  if(est_kill(pid, 15)){
    do {
      est_usleep(1000 * 500);
      if(!est_kill(pid, 13) && errno == ESRCH) break;
    } while(TRUE);
  } else {
    sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, STOPFILE);
    if(!cbwritefile(path, "OH, MY GOODNESS!\n", -1)) die("killing failed");
    do {
      est_usleep(1000 * 500);
      if(stat(path, &sbuf) == -1 && errno == ENOENT) break;
    } while(TRUE);
  }
  return 0;
}


/* perform the unittest command */
static int procunittest(const char *rootdir){
  UMGR *umgr;
  USER *user;
  NMGR *nmgr;
  NODE *node;
  RWLOCK *rwlock;
  RESMAP *resmap;
  RESDOC **resdocs;
  ESTNODERES *nres;
  ESTRESDOC *rdoc;
  ESTDOC *doc;
  CBLIST *list;
  CBMAP *attrs;
  const char *name, *path;
  char *str;
  int i, err, rnum;
  setsignals();
  if(procinit(rootdir, TRUE) != 0) return 1;
  log_open(rootdir, LL_DEBUG);
  err = FALSE;
  umgr = umgr_new(rootdir);
  umgr_load(umgr);
  umgr_put(umgr, "mikio", "x", "", "Mikio Hirabayashi", "Test");
  umgr_put(umgr, "mikio", "x", "", "Mikio Hirabayashi", "Test");
  list = umgr_names(umgr);
  for(i = 0; i < cblistnum(list); i++){
    name = cblistval(list, i, NULL);
    if(!(user = umgr_get(umgr, name))){
      err = TRUE;
      continue;
    }
    if(i % 2 == 0) user_make_sess(user);
    if(i % 3 == 0){
      user_set_sess_val(user, "oda", "nobunaga");
      user_set_sess_val(user, "hashiba", "hideyoshi");
      user_set_sess_val(user, "ieyasu", "tokugawa");
      user_set_sess_val(user, "oda", NULL);
      free(user_sess_val(user, "oda"));
      free(user_sess_val(user, "hashiba"));
      user_clear_sess(user);
      free(user_sess_val(user, "ieyasu"));
    }
  }
  cblistclose(list);
  umgr_out(umgr, "mikio");
  umgr_out(umgr, "hoge");
  if(!umgr_delete(umgr)) err = TRUE;
  nmgr = nmgr_new(rootdir);
  nmgr_load(nmgr, TRUE);
  nmgr_put(nmgr, "eagle", TRUE);
  nmgr_put(nmgr, "shark", TRUE);
  nmgr_put(nmgr, "panther", TRUE);
  nmgr_put(nmgr, "i n v a l i d", TRUE);
  list = nmgr_names(nmgr);
  for(i = 0; i < cblistnum(list); i++){
    path = cblistval(list, i, NULL);
    if(!(node = nmgr_get(nmgr, path))){
      err = TRUE;
      continue;
    }
    doc = est_doc_new();
    est_doc_add_attr(doc, ESTDATTRURI, "file:///home/mikio/sample1.html");
    est_doc_add_text(doc, "Happy Hacking!");
    if(!est_mtdb_put_doc(node->db, doc, 0)) err = TRUE;
    est_doc_delete(doc);
    doc = est_doc_new();
    est_doc_add_attr(doc, ESTDATTRURI, "file:///home/mikio/sample2.txt");
    est_doc_add_text(doc, "The savior becomes the victim.");
    if(!est_mtdb_put_doc(node->db, doc, 0)) err = TRUE;
    est_doc_delete(doc);
    node_set_link(node, "http://hoge.com/node/hoge1", "a", 100);
    node_set_link(node, "http://hoge.com/node/hoge2", "b", 200);
    node_set_link(node, "http://hoge.com/node/hoge2", "c", 300);
  }
  cblistclose(list);
  nmgr_out(nmgr, "eagle");
  nmgr_out(nmgr, "hoge");
  nmgr_delete(nmgr);
  rwlock = rwlock_new();
  if(!rwlock_lock(rwlock, TRUE)) err = TRUE;
  if(!rwlock_unlock(rwlock)) err = TRUE;
  if(!rwlock_lock(rwlock, FALSE)) err = TRUE;
  if(!rwlock_unlock(rwlock)) err = TRUE;
  rwlock_delete(rwlock);
  resmap = resmap_new();
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/one.html");
  est_doc_add_text(doc, "This is a pen.");
  resmap_put(resmap, 100, doc, NULL, NULL);
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/two.html");
  est_doc_add_text(doc, "Love is stranger.");
  resmap_put(resmap, 200, doc, NULL, NULL);
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/001.html");
  resmap_put(resmap, 1, doc, NULL, cbmemdup("one", -1));
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/006.html");
  resmap_put(resmap, 6, doc, NULL, cbmemdup("six", -1));
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/003.html");
  resmap_put(resmap, 3, doc, NULL, cbmemdup("three", -1));
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/004.html");
  resmap_put(resmap, 4, doc, NULL, cbmemdup("four", -1));
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/002.html");
  resmap_put(resmap, 2, doc, NULL, cbmemdup("two", -1));
  doc = est_doc_new();
  est_doc_add_attr(doc, ESTDATTRURI, "http://tako.ika/005.html");
  resmap_put(resmap, 1, doc, NULL, cbmemdup("five", -1));
  resdocs = resmap_list(resmap, &rnum);
  for(i = 0; i < rnum; i++){
    log_print(LL_DEBUG, "result: uri=%s score=%d body=%s",
              est_doc_attr(resdocs[i]->doc, ESTDATTRURI), resdocs[i]->score,
              resdocs[i]->body ? resdocs[i]->body : "(null)");
  }
  free(resdocs);
  resmap_delete(resmap);
  nres = est_noderes_new();
  for(i = 0; i < 128; i++){
    attrs = cbmapopenex(MINIBNUM);
    str = cbsprintf("http://big/bigger/biggest/%d", i + 1);
    if(i % 10 != 0) cbmapput(attrs, ESTDATTRURI, -1, str, -1, FALSE);
    free(str);
    str = cbsprintf("This is %d\n", i + 1);
    est_noderes_add_doc(nres, attrs, str);
  }
  for(i = 0; i < 100 && est_noderes_shift(nres, &attrs, &str); i++){
    free(str);
    cbmapclose(attrs);
  }
  for(i = 0; i < est_noderes_doc_num(nres); i++){
    rdoc = est_noderes_get_doc(nres, i);
    log_print(LL_DEBUG, "%s", est_resdoc_uri(rdoc));
  }
  for(i = 0; i < 2048; i++){
    attrs = cbmapopenex(MINIBNUM);
    str = cbsprintf("http://big/bigger/biggest/%d", i + 1);
    if(i % 10 != 0) cbmapput(attrs, ESTDATTRURI, -1, str, -1, FALSE);
    free(str);
    str = cbsprintf("This is %d\n", i + 1);
    est_noderes_add_doc(nres, attrs, str);
  }
  est_noderes_delete(nres);
  return err ? 1 : 0;
}


/* perform the crypt command */
static int proccrypt(const char *key, const char *hash){
  char *tmp;
  if(hash){
    if(!est_match_crypt(key, hash)){
      fprintf(stderr, "%s and %s do not match", key, hash);
      return 1;
    }
  } else {
    tmp = est_make_crypt(key);
    printf("%s\n", tmp);
    free(tmp);
  }
  return 0;
}


/* listen the socket and dispatch processes */
static void dispatch(void){
  pthread_t th;
  fd_set rfds;
  struct timeval tv;
  struct stat sbuf;
  char *stfile, claddr[ADDRBUFSIZ];
  int clsock, clport, isec, cnum;
  time_t start;
  TARGCOMM *targ;
  log_print(LL_INFO, "waiting for requests");
  stfile = cbsprintf("%s%c%s", g_rootdir, ESTPATHCHR, STOPFILE);
  isec = 0;
  start = -1;
  while(TRUE){
    FD_ZERO(&rfds);
    FD_SET(g_svsock, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 1000 * 1000;
    errno = 0;
    if(select(g_svsock + 1, &rfds, NULL, NULL, &tv) > 0 && FD_ISSET(g_svsock, &rfds)){
      clsock = est_accept_conn(g_svsock, claddr, &clport);
      switch(clsock){
      case -1:
        log_print(LL_ERROR, "accepting connection failed");
        break;
      case 0:
        log_print(LL_WARN, "accepting connection interrupted by a signal");
        break;
      default:
        if(rwlock_rnum(g_runlock) > g_maxconn + FCLOSECONNNUM){
          log_print(LL_WARN, "doing forced shutdown due to jam-up");
          est_sock_down(clsock);
        } else {
          targ = cbmalloc(sizeof(TARGCOMM));
          targ->clsock = clsock;
          sprintf(targ->claddr, "%s", claddr);
          targ->clport = clport;
          if(g_stmode){
            communicate(targ);
          } else {
            if(pthread_create(&th, NULL, communicate, targ) == 0){
              if(pthread_detach(th) != 0) log_print(LL_ERROR, "detachting thread failed");
            } else {
              log_print(LL_WARN, "creating thread failed");
              est_sock_down(clsock);
              free(targ);
            }
          }
        }
        break;
      }

      isec = 0;
    } else {
      if(errno != EINTR) isec++;
      if(stat(stfile, &sbuf) == 0){
        log_print(LL_INFO, "the stop file detected");
        g_sigterm = TRUE;
      }
    }
    if(g_sigterm){
      if(rwlock_rnum(g_runlock) < 1){
        break;
      } else if(start == -1){
        start = time(NULL);
      } else if(time(NULL) - start > 1){
        break;
      }
    }
    if(++isec >= IFLUSHSEC){
      if(g_stmode){
        flushnode(NULL);
      } else {
        if(pthread_create(&th, NULL, flushnode, NULL) == 0){
          if(pthread_detach(th) != 0) log_print(LL_ERROR, "detachting thread failed");
        } else {
          log_print(LL_WARN, "creating thread failed");
        }
      }
    }
  }
  free(stfile);
  log_print(LL_INFO, "shutting down");
  start = time(NULL);
  while((cnum = rwlock_rnum(g_runlock)) > 0){
    log_print(LL_INFO, "waiting for children: %d", cnum);
    est_usleep(1000 * 1000);
    if(time(NULL) - start > FCLOSEWAITMAX && g_svsock != -1){
      est_sock_down(g_svsock);
      g_svsock = -1;
      log_print(LL_WARN, "doing forced shutdown of the server socket");
    }
    if(time(NULL) - start > FTERMWAITMAX){
      log_print(LL_WARN, "doing forced termination of the server process");
      break;
    }
  }
  est_usleep(1000 * 100);
}


/* flush one of nodes */
static void *flushnode(void *targ){
  static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
  static int cnt = 0;
  CBLIST *list;
  NODE *node;
  if(pthread_mutex_trylock(&mymutex) != 0) return NULL;
  if(!rwlock_lock(g_runlock, FALSE)){
    log_print(LL_ERROR, "locking failed");
    pthread_mutex_unlock(&mymutex);
    return NULL;
  }
  if(!rwlock_lock(g_mgrlock, FALSE)){
    rwlock_unlock(g_runlock);
    pthread_mutex_unlock(&mymutex);
    log_print(LL_ERROR, "locking failed");
    return NULL;
  }
  list = nmgr_names(g_nmgr);
  if(cblistnum(list) > 0){
    if((node = nmgr_get(g_nmgr, cblistval(list, cnt++ % cblistnum(list), NULL))) != NULL){
      if(!est_mtdb_flush(node->db, est_mtdb_cache_num(node->db) > 0 ? IFLUSHNUM : -1))
        log_print(LL_ERROR, "flushing failed");
    }
  }
  cblistclose(list);
  if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
  if(!rwlock_unlock(g_runlock)) log_print(LL_ERROR, "unlocking failed");
  if(pthread_mutex_unlock(&mymutex) != 0) log_print(LL_ERROR, "unlocking failed");
  return NULL;
}


/* communicate with a client */
static void *communicate(void *targ){
  TARGCOMM *myarg;
  REQUEST req;
  USER *user;
  const char *cstr;
  char ibuf[IOBUFSIZ], *tmp, *bp, *ep;
  int clsock, len, clen;
  myarg = (TARGCOMM *)targ;
  clsock = myarg->clsock;
  if(!rwlock_lock(g_runlock, FALSE)){
    est_sock_down(myarg->clsock);
    free(myarg);
    log_print(LL_ERROR, "locking failed");
    return NULL;
  }
  est_sock_recv_line(clsock, ibuf, IOBUFSIZ - 1);
  log_print(LL_INFO, "[%s:%d]: %s", myarg->claddr, myarg->clport, ibuf);
  if(cbstrfwmatch(ibuf, "HEAD ")){
    req.method = HM_HEAD;
  } else if(cbstrfwmatch(ibuf, "GET ")){
    req.method = HM_GET;
  } else if(cbstrfwmatch(ibuf, "POST ")){
    req.method = HM_POST;
  } else {
    req.method = HM_UNKNOWN;
  }
  req.claddr = myarg->claddr;
  req.clport = myarg->clport;
  req.target = NULL;
  req.name = NULL;
  req.passwd = NULL;
  req.ims = -1;
  req.ctype = NULL;
  req.estvia = NULL;
  req.host = NULL;
  req.body = NULL;
  req.params = cbmapopenex(MINIBNUM);
  if((bp = strchr(ibuf, ' ')) != NULL){
    while(*bp == ' '){
      bp++;
    }
    while(bp[0] == '/' && bp[1] == '/'){
      bp++;
    }
    if((ep = strchr(bp, ' ')) != NULL){
      req.target = cbmemdup(bp, ep - bp);
    } else {
      req.target = cbmemdup(bp, -1);
    }
    if((bp = strchr(req.target, '?')) != NULL){
      *(bp++) = '\0';
      setparams(req.params, bp);
    }
  }
  if(!req.target) req.target = cbmemdup("/", 1);
  clen = -1;
  do {
    len = est_sock_recv_line(clsock, ibuf, IOBUFSIZ - 1);
    if(len > 0) log_print(LL_DEBUG, "[%s:%d]: + %s", myarg->claddr, myarg->clport, ibuf);
    if(cbstrfwimatch(ibuf, "Content-Length:")){
      clen = atoi(skiplabel(ibuf));
    } else if(cbstrfwimatch(ibuf, "Content-Type:")){
      req.ctype = cbmemdup(skiplabel(ibuf), -1);
    } else if(cbstrfwimatch(ibuf, "X-Estraier-Via:")){
      if(req.estvia){
        tmp = cbsprintf("%s, %s", req.estvia, skiplabel(ibuf));
        free(req.estvia);
        req.estvia = tmp;
      } else {
        req.estvia = cbmemdup(skiplabel(ibuf), -1);
      }
    } else if(cbstrfwimatch(ibuf, "Host:")){
      req.host = cbmemdup(skiplabel(ibuf), -1);
    } else if(cbstrfwimatch(ibuf, "Authorization:")){
      cstr = skiplabel(ibuf);
      if(cbstrfwimatch(cstr, "basic") && (cstr = strchr(cstr, ' ')) != NULL){
        while(*cstr == ' '){
          cstr++;
        }
        bp = cbbasedecode(cstr, NULL);
        if((ep = strchr(bp, ':')) != NULL) *(ep++) = '\0';
        req.name = cbmemdup(bp, -1);
        req.passwd = cbmemdup(ep ? ep : "", -1);
        free(bp);
      }
    } else if(cbstrfwimatch(ibuf, "If-Modified-Since")){
      req.ims = cbstrmktime(skiplabel(ibuf));
    }
  } while(len > 0);
  if(clen > RECVMAX) clen = RECVMAX;
  if(req.method == HM_POST && clen > 0){
    req.body = est_sock_recv_all(clsock, clen);
    if(req.ctype && cbstrfwimatch(req.ctype, ESTFORMTYPE)) setparams(req.params, req.body);
    est_sock_recv_void(clsock);
  }
  user = NULL;
  if(rwlock_lock(g_mgrlock, FALSE)){
    if(req.name) user = umgr_get(g_umgr, req.name);
    if(user && !est_match_crypt(req.passwd, user->passwd)) user = NULL;
    if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
  } else {
    log_print(LL_ERROR, "locking failed");
  }
  if(g_sigterm){
    senderror(clsock, &req, 503, "Service Unavailable (shutting down)");
  } else if(rwlock_rnum(g_runlock) > g_maxconn){
    senderror(clsock, &req, 503, "Service Unavailable (too busy)");
  } else if(req.method == HM_UNKNOWN){
    senderror(clsock, &req, 501, "Not Implemented");
  } else if(req.method == HM_POST && clen < 0){
    senderror(clsock, &req, 411, "Length Required");
  } else if(req.method == HM_POST && clen >= RECVMAX){
    senderror(clsock, &req, 413, "Request Entity Too Large");
  } else if(req.target[0] != '/' || strstr(req.target, "/../")){
    senderror(clsock, &req, 400, "Bad Request");
  } else if(g_denyuntrusted && !cbmapget(g_trustednodes, req.claddr, -1, NULL)){
    senderror(clsock, &req, 403, "Forbidden");
  } else if(!strcmp(req.target, MASTERLOC)){
    sendmasterdata(clsock, &req, user);
  } else if(cbstrfwmatch(req.target, NODEPREFIX)){
    sendnodedata(clsock, &req, user, req.target + strlen(NODEPREFIX));
  } else if(!strcmp(req.target, MASTERUILOC)){
    senduidata(clsock, &req, user);
  } else {
    sendfiledata(clsock, &req);
  }
  cbmapclose(req.params);
  free(req.body);
  free(req.host);
  free(req.estvia);
  free(req.ctype);
  free(req.name);
  free(req.passwd);
  free(req.target);
  est_sock_down(myarg->clsock);
  free(myarg);
  if(!rwlock_unlock(g_runlock)) log_print(LL_ERROR, "unlocking failed");
  return NULL;
}


/* set parameters into a map object */
static void setparams(CBMAP *params, const char *src){
  CBLIST *pairs;
  char *key, *val, *dkey, *dval;
  int i;
  pairs = cbsplit(src, -1, "&");
  for(i = 0; i < cblistnum(pairs); i++){
    key = cbmemdup(cblistval(pairs, i, NULL), -1);
    if((val = strchr(key, '=')) != NULL){
      *(val++) = '\0';
      dkey = cburldecode(key, NULL);
      dval = cburldecode(val, NULL);
      cbmapput(params, dkey, -1, dval, -1, FALSE);
      free(dval);
      free(dkey);
    }
    free(key);
  }
  cblistclose(pairs);
}


/* add the server information to a datum object */
static void addservinfo(CBDATUM *datum){
  char *tmp;
  tmp = cbdatestrhttp(time(NULL), 0);
  est_datum_printf(datum, "Date: %s\r\n", tmp);
  free(tmp);
  est_datum_printf(datum, "Server: %s/%s\r\n", SERVNAME, est_version);
  est_datum_printf(datum, "Cache-Control: no-cache, must-revalidate, no-transform\r\n");
  est_datum_printf(datum, "Pragma: no-cache\r\n");
  est_datum_printf(datum, "Connection: close\r\n");
}


/* send error message */
static void senderror(int clsock, REQUEST *req, int code, const char *message){
  CBDATUM *datum;
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 %d %s\r\n", code, message);
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
  est_datum_printf(datum, "\r\n");
  if(req->method != HM_HEAD && code != 304) est_datum_printf(datum, "%s\n", message);
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_WARN, "[%s:%d]: %d %s", req->claddr, req->clport, code, message);
}


/* send authenticate error message */
static void sendautherror(int clsock, REQUEST *req, const char *realm){
  CBDATUM *datum;
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 401 Unauthorized\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
  est_datum_printf(datum, "WWW-Authenticate: Basic realm=\"%s\"\r\n", realm);
  est_datum_printf(datum, "\r\n");
  if(req->method != HM_HEAD) est_datum_printf(datum, "Unauthorized\n");
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_WARN, "[%s:%d]: 401 Unauthorized", req->claddr, req->clport);
}


/* check whether a user is banned */
static int isbanned(USER *user){
  if(user && strchr(user->flags, 'b')) return TRUE;
  return FALSE;
}


/* check whether a user is an administrator of the master */
static int ismasteradmin(REQUEST *req, USER *user){
  if(isbanned(user)) return FALSE;
  if(cbmapget(g_trustednodes, req->claddr, -1, NULL)) return TRUE;
  if(user && strchr(user->flags, 's')) return TRUE;
  return FALSE;
}


/* check whether a user is an administrator of a node */
static int isnodeadmin(NODE *node, REQUEST *req, USER *user){
  if(isbanned(user)) return FALSE;
  if(ismasteradmin(req, user)) return TRUE;
  if(g_authmode == AM_NONE) return TRUE;
  if(user && cbmapget(node->admins, user->name, -1, NULL)) return TRUE;
  return FALSE;
}


/* check whether a user is a user of a node */
static int isnodeuser(NODE *node, REQUEST *req, USER *user){
  if(isbanned(user)) return FALSE;
  if(isnodeadmin(node, req, user)) return TRUE;
  if(g_authmode == AM_NONE || g_authmode == AM_ADMIN) return TRUE;
  if(user && cbmapget(node->users, user->name, -1, NULL)) return TRUE;
  return FALSE;
}


/* send the master data */
static void sendmasterdata(int clsock, REQUEST *req, USER *user){
  CBDATUM *datum;
  CBLIST *list;
  USER *tuser;
  NODE *tnode;
  const char *act, *name, *passwd, *flags, *fname, *misc, *label;
  char *tmp;
  int i;
  if(!rwlock_lock(g_mgrlock, TRUE)){
    log_print(LL_ERROR, "locking failed");
    senderror(clsock, req, 500, "Internal Server Error (locking failed)");
    return;
  }
  if(!ismasteradmin(req, user)){
    sendautherror(clsock, req, "Super User");
    if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
    return;
  }
  if(!(act = cbmapget(req->params, "action", -1, NULL))) act = "";
  if(!(name = cbmapget(req->params, "name", -1, NULL))) name = "";
  if(!(passwd = cbmapget(req->params, "passwd", -1, NULL))) passwd = "";
  if(!(flags = cbmapget(req->params, "flags", -1, NULL))) flags = "";
  if(!(fname = cbmapget(req->params, "fname", -1, NULL))) fname = "";
  if(!(misc = cbmapget(req->params, "misc", -1, NULL))) misc = "";
  if(!(label = cbmapget(req->params, "label", -1, NULL))) label = "";
  if(!strcmp(act, "shutdown")){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 202 Accepted\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    est_datum_printf(datum, "Accepted\n");
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    g_sigterm = TRUE;
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 202 (accepted - shutdown)", req->claddr, req->clport);
  } else if(!strcmp(act, "userlist")){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    list = umgr_names(g_umgr);
    for(i = 0; i < cblistnum(list); i++){
      if(!(name = cblistval(list, i, NULL)) || !(tuser = umgr_get(g_umgr, name))) continue;
      est_datum_printf(datum, "%s\t%s\t%s\t%s\t%s\n",
                       tuser->name, tuser->passwd, tuser->flags, tuser->fname, tuser->misc);
    }
    cblistclose(list);
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - userlist)", req->claddr, req->clport);
  } else if(!strcmp(act, "useradd") && name[0] != '\0' && passwd[0] != '\0'){
    tmp = est_make_crypt(passwd);
    if(g_runmode != RM_RDONLY && umgr_put(g_umgr, name, tmp, flags, fname, misc)){
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
      est_datum_printf(datum, "\r\n");
      est_datum_printf(datum, "OK\n");
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      cbdatumclose(datum);
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - useradd)", req->claddr, req->clport);
    } else {
      senderror(clsock, req, 400, "Bad Request (maybe, the user already exists)");
    }
    free(tmp);
  } else if(!strcmp(act, "userdel") && name[0] != '\0'){
    if(g_runmode != RM_RDONLY && umgr_out(g_umgr, name)){
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
      est_datum_printf(datum, "\r\n");
      est_datum_printf(datum, "OK\n");
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      cbdatumclose(datum);
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - userdel)", req->claddr, req->clport);
    } else {
      senderror(clsock, req, 400, "Bad Request (maybe, the user does not exist)");
    }
  } else if(!strcmp(act, "nodelist")){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    list = nmgr_names(g_nmgr);
    for(i = 0; i < cblistnum(list); i++){
      if(!(name = cblistval(list, i, NULL)) || !(tnode = nmgr_get(g_nmgr, name))) continue;
      est_datum_printf(datum, "%s\t%s\t%d\t%d\t%.0f\n", tnode->name, tnode->label,
                       est_mtdb_doc_num(tnode->db), est_mtdb_word_num(tnode->db),
                       est_mtdb_size(tnode->db));
    }
    cblistclose(list);
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - nodelist)", req->claddr, req->clport);
  } else if(!strcmp(act, "nodeadd") && name[0] != '\0' && label[0] != '\0'){
    if(g_runmode != RM_RDONLY && nmgr_put(g_nmgr, name, TRUE)){
      if((tnode = nmgr_get(g_nmgr, name)) != NULL){
        free(tnode->label);
        tnode->label = cbmemdup(label, -1);
      }
      nmgr_sync(g_nmgr, FALSE);
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
      est_datum_printf(datum, "\r\n");
      est_datum_printf(datum, "OK\n");
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      cbdatumclose(datum);
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - nodeadd)", req->claddr, req->clport);
    } else {
      senderror(clsock, req, 400, "Bad Request (maybe, the node already exists)");
    }
  } else if(!strcmp(act, "nodedel") && name[0] != '\0'){
    if(g_runmode != RM_RDONLY && nmgr_out(g_nmgr, name)){
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
      est_datum_printf(datum, "\r\n");
      est_datum_printf(datum, "OK\n");
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      cbdatumclose(datum);
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - nodedel)", req->claddr, req->clport);
    } else {
      senderror(clsock, req, 400, "Bad Request (maybe, the node does not exist)");
    }
  } else {
    senderror(clsock, req, 400, "Bad Request (the action is invalid or lack of parameters)");
  }
  if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
}


/* send a node data */
static void sendnodedata(int clsock, REQUEST *req, USER *user, const char *path){
  CBDATUM *datum;
  CBLIST *list;
  NODE *node;
  const char *cmd;
  char *pbuf, *pv;
  int i;
  pbuf = cbmemdup(path, -1);
  if((pv = strchr(path, '/')) != NULL){
    *pv = '\0';
    cmd = pv + 1;
  } else {
    cmd = "";
  }
  if(!rwlock_lock(g_mgrlock, cmd[0] == '_')){
    log_print(LL_ERROR, "locking failed");
    senderror(clsock, req, 500, "Internal Server Error (locking failed)");
    free(pbuf);
    return;
  }
  if(!(node = nmgr_get(g_nmgr, path))){
    if(!strcmp(req->target, NODEPREFIX)){
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
      est_datum_printf(datum, "\r\n");
      if(req->method != HM_HEAD){
        list = nmgr_names(g_nmgr);
        for(i = 0; i < cblistnum(list); i++){
          est_datum_printf(datum, "%s\n", cblistval(list, i, NULL));
        }
        cblistclose(list);
      }
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      cbdatumclose(datum);
    } else {
      senderror(clsock, req, 404, "Not Found (the node does not exist)");
    }
  } else if(!strcmp(cmd, "inform")){
    if(isnodeuser(node, req, user)){
      sendnodecmdinform(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "search")){
    if(isnodeuser(node, req, user)){
      sendnodecmdsearch(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "get_doc")){
    if(isnodeuser(node, req, user)){
      sendnodecmdgetdoc(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "get_doc_attr")){
    if(isnodeuser(node, req, user)){
      sendnodecmdgetdocattr(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "uri_to_id")){
    if(isnodeuser(node, req, user)){
      sendnodecmduritoid(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "put_doc")){
    if(isnodeadmin(node, req, user)){
      sendnodecmdputdoc(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "out_doc")){
    if(isnodeadmin(node, req, user)){
      sendnodecmdoutdoc(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "_set_user")){
    if(isnodeadmin(node, req, user)){
      sendnodecmdsetuser(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else if(!strcmp(cmd, "_set_link")){
    if(isnodeadmin(node, req, user)){
      sendnodecmdsetlink(clsock, req, node);
    } else {
      sendautherror(clsock, req, node->name);
    }
  } else {
    senderror(clsock, req, 400, "Bad Request (the command is invalid)");
  }
  free(pbuf);
  if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
}


/* set the pseudo-attribute of the original node to a document */
static void setdocorigin(ESTDOC *doc, NODE *node){
  char pbuf[URIBUFSIZ];
  sprintf(pbuf, "http://%s:%d%s%s", g_hostname, g_portnum, NODEPREFIX, node->name);
  est_doc_add_attr(doc, DATTRNDURL, pbuf);
  est_doc_add_attr(doc, DATTRNDLABEL, node->label);
}


/* merge local hints to total hints */
static void mergehints(CBMAP *total, CBMAP *local){
  static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
  const char *kbuf, *vbuf;
  char numbuf[NUMBUFSIZ];
  int ksiz, num, vsiz;
  if(pthread_mutex_lock(&mymutex) != 0) return;
  cbmapiterinit(local);
  while((kbuf = cbmapiternext(local, &ksiz)) != NULL){
    num = atoi(cbmapget(local, kbuf, ksiz, NULL));
    if((vbuf = cbmapget(total, kbuf, ksiz, NULL)) != NULL){
      num += atoi(vbuf);
    }
    vsiz = sprintf(numbuf, "%d", num);
    cbmapput(total, kbuf, ksiz,  numbuf, vsiz, TRUE);
  }
  pthread_mutex_unlock(&mymutex);
}


/* check whether the request is looping */
static int islooproute(const char *url, REQUEST *req){
  CBLIST *list;
  const char *rp;
  int i;
  assert(url && req);
  if(!req->estvia) return FALSE;
  list = cbsplit(req->estvia, -1, ",");
  for(i = 0; i < cblistnum(list); i++){
    rp = cblistval(list, i, NULL);
    while(*rp == ' ' || *rp == '\t'){
      rp++;
    }
    if(!strcmp(url, rp)){
      cblistclose(list);
      return TRUE;
    }
  }
  cblistclose(list);
  return FALSE;
}


/* search a local index */
static void *searchlocal(void *targ){
  REQUEST *req;
  ESTCOND *cond;
  ESTDOC *doc;
  NODE *node;
  RESMAP *resmap;
  CBMAP *hints, *myhints;
  CBLIST *words;
  const char *kbuf;
  int i, max, *res, rnum, cnt, ksiz;
  req = ((TARGLCSRCH *)targ)->req;
  cond = ((TARGLCSRCH *)targ)->cond;
  node = ((TARGLCSRCH *)targ)->node;
  hints = ((TARGLCSRCH *)targ)->hints;
  max = ((TARGLCSRCH *)targ)->max;
  resmap = ((TARGLCSRCH *)targ)->resmap;
  words = ((TARGLCSRCH *)targ)->words;
  log_print(LL_DEBUG, "[%s:%d]: local search: %s",
            req->claddr, req->clport, est_mtdb_name(node->db));
  myhints = cbmapopenex(MINIBNUM);
  res = est_mtdb_search(node->db, cond, &rnum, myhints);
  mergehints(hints, myhints);
  cnt = 0;
  for(i = 0; i < rnum && cnt < max; i++){
    if(!(doc = est_mtdb_get_doc(node->db, res[i], 0))) continue;
    setdocorigin(doc, node);
    resmap_put(resmap, SELFCREDIT * (max - cnt), doc, NULL, NULL);
    cnt++;
  }
  free(res);
  ((TARGLCSRCH *)targ)->hnum = atoi(cbmapget(myhints, "", 0, NULL));
  cbmapiterinit(myhints);
  while((kbuf = cbmapiternext(myhints, &ksiz)) != NULL){
    if(ksiz > 0) cblistpush(words, kbuf, ksiz);
  }
  cbmapclose(myhints);
  return NULL;
}


/* search a remote index */
static void *searchremote(void *targ){
  REQUEST *req;
  ESTCOND *cond;
  NODE *node;
  RESMAP *resmap;
  ESTNODE *tnode;
  ESTNODERES *nres;
  CBMAP *hints, *attrs, *myhints, *whints;
  CBLIST *list;
  const char *myurl, *url, *label, *vbuf, *pv;
  char numbuf[NUMBUFSIZ], *snippet;
  int i, max, credit, depth, len, cnt;
  req = ((TARGRMSRCH *)targ)->req;
  myurl = ((TARGRMSRCH *)targ)->myurl;
  cond = ((TARGRMSRCH *)targ)->cond;
  node = ((TARGRMSRCH *)targ)->node;
  hints = ((TARGRMSRCH *)targ)->hints;
  max = ((TARGRMSRCH *)targ)->max;
  resmap = ((TARGRMSRCH *)targ)->resmap;
  url = ((TARGRMSRCH *)targ)->url;
  label = ((TARGRMSRCH *)targ)->label;
  credit = ((TARGRMSRCH *)targ)->credit;
  depth = ((TARGRMSRCH *)targ)->depth;
  if(!strcmp(myurl, url) || islooproute(url, req)){
    log_print(LL_DEBUG, "[%s:%d]: omitting request loop (link): %s",
              req->claddr, req->clport, url);
    return NULL;
  }
  log_print(LL_DEBUG, "[%s:%d]: remote search: %s", req->claddr, req->clport, url);
  tnode = est_node_new(url);
  if(g_proxyhost[0] != '\0') est_node_set_proxy(tnode, g_proxyhost, g_proxyport);
  est_node_set_timeout(tnode, g_searchtimeout);
  if(req->estvia) est_node_add_header(tnode, ESTHTHVIA, req->estvia);
  est_node_add_header(tnode, ESTHTHVIA, myurl);
  if((nres = est_node_search(tnode, cond, depth - 1)) != NULL){
    cnt = 0;
    while(est_noderes_shift(nres, &attrs, &snippet)){
      resmap_put(resmap, credit * (max - cnt), NULL, attrs, snippet);
      cnt++;
    }
    whints = cbmapopenex(MINIBNUM);
    myhints = est_noderes_hints(nres);
    if((vbuf = cbmapget(myhints, "HIT", -1, NULL)) != NULL){
      cbmapput(whints, "", 0, vbuf, -1, FALSE);
      ((TARGRMSRCH *)targ)->hnum = atoi(vbuf);
    } else {
      cbmapput(whints, "", 0, "0", -1, FALSE);
    }
    if((vbuf = cbmapget(myhints, "DOCNUM", -1, NULL)) != NULL)
      ((TARGRMSRCH *)targ)->dnum = atoi(vbuf);
    if((vbuf = cbmapget(myhints, "WORDNUM", -1, NULL)) != NULL)
      ((TARGRMSRCH *)targ)->wnum = atoi(vbuf);
    if((vbuf = cbmapget(myhints, "LINK#0", -1, NULL)) != NULL){
      list = cbsplit(vbuf, -1, "\t");
      if(cblistnum(list) == 7)
        ((TARGRMSRCH *)targ)->size = strtod(cblistval(list, 5, NULL), NULL);
      cblistclose(list);
    }
    for(i = 0; i < cbmaprnum(myhints); i++){
      len = sprintf(numbuf, "HINT#%d", i + 1);
      if((vbuf = cbmapget(myhints, numbuf, len, NULL)) != NULL &&
         (pv = strchr(vbuf, '\t')) != NULL && pv > vbuf){
        cbmapput(whints, vbuf, pv - vbuf, pv + 1, -1, FALSE);
      } else {
        break;
      }
    }
    mergehints(hints, whints);
    cbmapclose(whints);
    est_noderes_delete(nres);
  } else {
    log_print(LL_WARN, "[%s:%d]: connection failed: %s", req->claddr, req->clport, url);
  }
  est_node_delete(tnode);
  return NULL;
}


/* concatenate a document data to an output buffer */
static void catdocdata(CBDATUM *datum, RESDOC *resdoc, CBLIST *words){
  CBLIST *list;
  const char *vbuf;
  char *snippet;
  int i;
  if(resdoc->doc){
    list = est_doc_attr_names(resdoc->doc);
    for(i = 0; i < cblistnum(list); i++){
      vbuf = cblistval(list, i, NULL);
      est_datum_printf(datum, "%s=%s\n", vbuf, est_doc_attr(resdoc->doc, vbuf));
    }
    cblistclose(list);
  } else if(resdoc->attrs){
    list = cbmapkeys(resdoc->attrs);
    cblistsort(list);
    for(i = 0; i < cblistnum(list); i++){
      vbuf = cblistval(list, i, NULL);
      est_datum_printf(datum, "%s=%s\n", vbuf, cbmapget(resdoc->attrs, vbuf, -1, NULL));
    }
    cblistclose(list);
  }
  est_datum_printf(datum, "\n");
  if(resdoc->body){
    cbdatumcat(datum, resdoc->body, -1);
  } else if(resdoc->doc){
    if(g_snipwwidth > 0){
      snippet = est_doc_make_snippet(resdoc->doc, words,
                                     g_snipwwidth, g_sniphwidth, g_snipawidth);
      cbdatumcat(datum, snippet, -1);
      free(snippet);
    }
  }
}


/* send the result of search command */
static void sendnodecmdinform(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *kbuf;
  int ksiz;
  if(pthread_mutex_lock(&(node->mutex)) != 0){
    log_print(LL_ERROR, "locking failed");
    senderror(clsock, req, 500, "Internal Server Error (locking failed)");
    return;
  }
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: %s; charset=UTF-8\r\n", ESTINFORMTYPE);
  est_datum_printf(datum, "\r\n");
  est_datum_printf(datum, "%s\t%s\t%d\t%d\t%.0f\n", node->name, node->label,
                   est_mtdb_doc_num(node->db), est_mtdb_word_num(node->db),
                   est_mtdb_size(node->db));
  est_datum_printf(datum, "\n");
  cbmapiterinit(node->admins);
  while((kbuf = cbmapiternext(node->admins, NULL)) != NULL){
    if(kbuf[0] != '\0') est_datum_printf(datum, "%s\n", kbuf);
  }
  est_datum_printf(datum, "\n");
  cbmapiterinit(node->users);
  while((kbuf = cbmapiternext(node->users, NULL)) != NULL){
    if(kbuf[0] != '\0') est_datum_printf(datum, "%s\n", kbuf);
  }
  est_datum_printf(datum, "\n");
  cbmapiterinit(node->links);
  while((kbuf = cbmapiternext(node->links, &ksiz)) != NULL){
    if(kbuf[0] != '\0')
      est_datum_printf(datum, "%s\t%s\n", kbuf, cbmapget(node->links, kbuf, ksiz, NULL));
  }
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_DEBUG, "[%s:%d]: 200 (ok - inform)", req->claddr, req->clport);
  if(pthread_mutex_unlock(&(node->mutex)) != 0) log_print(LL_ERROR, "unlocking failed");
}


/* send the result of search command */
static void sendnodecmdsearch(int clsock, REQUEST *req, NODE *node){
  pthread_t lth, *rths;
  TARGLCSRCH ltarg;
  TARGRMSRCH *rtargs;
  RESMAP *resmap;
  RESDOC **resdocs;
  ESTCOND *cond;
  CBMAP *hints;
  CBDATUM *datum;
  const char *tmp, *url, *label, *kbuf;
  char *myurl;
  int i, num, max, depth, dnum, wnum, ksiz, rnum;
  double curtime;
  myurl = cbsprintf("http://%s:%d/node/%s", g_hostname, g_portnum, node->name);
  if(islooproute(myurl, req)){
    log_print(LL_DEBUG, "[%s:%d]: omitting request loop (self): %s",
              req->claddr, req->clport, myurl);
    free(myurl);
    senderror(clsock, req, 400, "Bad Request (the request loops)");
    return;
  }
  if(pthread_mutex_lock(&(node->mutex)) != 0){
    log_print(LL_ERROR, "locking failed");
    senderror(clsock, req, 500, "Internal Server Error (locking failed)");
    return;
  }
  cond = est_cond_new();
  max = DEFMAXSRCH;
  depth = 0;
  if((tmp = cbmapget(req->params, "phrase", -1, NULL)) != NULL) est_cond_set_phrase(cond, tmp);
  if((tmp = cbmapget(req->params, "attr", -1, NULL)) != NULL) est_cond_set_phrase(cond, tmp);
  if((tmp = cbmapget(req->params, "attr1", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr2", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr3", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr4", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr5", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr6", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr7", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr8", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "attr9", -1, NULL)) != NULL) est_cond_add_attr(cond, tmp);
  if((tmp = cbmapget(req->params, "order", -1, NULL)) != NULL) est_cond_set_order(cond, tmp);
  if((tmp = cbmapget(req->params, "max", -1, NULL)) && (num = atoi(tmp)) >= 0) max = num;
  est_cond_set_max(cond, max * 1.3 + 1);
  if((tmp = cbmapget(req->params, "options", -1, NULL)) && (num = atoi(tmp)) > 0)
    est_cond_set_options(cond, num);
  if((tmp = cbmapget(req->params, "depth", -1, NULL)) && (num = atoi(tmp)) > 0) depth = num;
  if(depth >= g_searchdepth) depth = g_searchdepth;
  resmap = resmap_new();
  hints = cbmapopenex(MINIBNUM);
  curtime = est_gettimeofday();
  ltarg.req = req;
  ltarg.alive = TRUE;
  ltarg.cond = cond;
  ltarg.hints = hints;
  ltarg.max = max;
  ltarg.node = node;
  ltarg.resmap = resmap;
  ltarg.words = cblistopen();
  ltarg.hnum = 0;
  if(g_stmode){
    searchlocal(&ltarg);
    ltarg.alive = FALSE;
  } else if(pthread_create(&lth, NULL, searchlocal, &ltarg) != 0){
    log_print(LL_WARN, "creating thread failed");
    ltarg.alive = FALSE;
  }
  rths = cbmalloc(cbmaprnum(node->links) * sizeof(pthread_t) + 1);
  rtargs = cbmalloc(cbmaprnum(node->links) * sizeof(TARGRMSRCH) + 1);
  cbmapiterinit(node->links);
  for(i = 0; (url = cbmapiternext(node->links, NULL)) != NULL; i++){
    rtargs[i].req = req;
    rtargs[i].alive = TRUE;
    rtargs[i].myurl = myurl;
    rtargs[i].cond = cond;
    rtargs[i].hints = hints;
    rtargs[i].max = max;
    rtargs[i].node = node;
    rtargs[i].resmap = resmap;
    rtargs[i].url = url;
    label = cbmapget(node->links, url, -1, NULL);
    if((tmp = strchr(label, '\t')) != NULL){
      rtargs[i].label = cbmemdup(label, tmp - label);
      rtargs[i].credit = atoi(tmp + 1);
    } else {
      rtargs[i].label = cbmemdup(label, -1);
      rtargs[i].credit = 0;
    }
    rtargs[i].depth = depth;
    rtargs[i].hnum = 0;
    rtargs[i].dnum = 0;
    rtargs[i].wnum = 0;
    rtargs[i].size = 0.0;
    if(depth < 1){
      rtargs[i].alive = FALSE;
      rtargs[i].hnum = -1;
      rtargs[i].dnum = -1;
      rtargs[i].wnum = -1;
      rtargs[i].size = -1.0;
    } else if(g_stmode){
      searchremote(&rtargs[i]);
      rtargs[i].alive = FALSE;
    } else if(pthread_create(rths + i, NULL, searchremote, rtargs + i) != 0){
      log_print(LL_WARN, "creating thread failed");
      rtargs[i].alive = FALSE;
    }
  }
  if(pthread_mutex_unlock(&(node->mutex)) != 0) log_print(LL_ERROR, "unlocking failed");
  dnum = 0;
  wnum = 0;
  if(ltarg.alive){
    if(pthread_join(lth, NULL) == 0){
      dnum = est_mtdb_doc_num(node->db);
      wnum = est_mtdb_word_num(node->db);
    } else {
      log_print(LL_ERROR, "joining thread failed");
    }
  }
  for(i = 0; i < cbmaprnum(node->links); i++){
    if(rtargs[i].alive){
      if(pthread_join(rths[i], NULL) == 0){
        dnum += rtargs[i].dnum;
        wnum += rtargs[i].wnum;
      } else {
        log_print(LL_ERROR, "joining thread failed");
      }
    }
  }
  curtime = est_gettimeofday() - curtime;
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: %s; charset=UTF-8\r\n", ESTRESULTTYPE);
  est_datum_printf(datum, "\r\n");
  est_datum_printf(datum, "%s\n", g_bordstr);
  est_datum_printf(datum, "VERSION\t%s\n", _EST_PROTVER);
  est_datum_printf(datum, "NODE\thttp://%s:%d%s%s\n",
                   g_hostname, g_portnum, NODEPREFIX, node->name);
  tmp = cbmapget(hints, "", 0, NULL);
  est_datum_printf(datum, "HIT\t%s\n", tmp ? tmp : "0");
  cbmapiterinit(hints);
  num = 1;
  while((kbuf = cbmapiternext(hints, &ksiz)) != NULL){
    if(ksiz < 1) continue;
    est_datum_printf(datum, "HINT#%d\t%s\t%s\n", num, kbuf, cbmapget(hints, kbuf, ksiz, NULL));
    num++;
  }
  est_datum_printf(datum, "DOCNUM\t%d\n", dnum);
  est_datum_printf(datum, "WORDNUM\t%d\n", wnum);
  if(curtime > 0.0) est_datum_printf(datum, "TIME\t%.3f\n", curtime / 1000.0);
  est_datum_printf(datum, "LINK#0\thttp://%s:%d%s%s\t",
                   g_hostname, g_portnum, NODEPREFIX, node->name);
  est_datum_printf(datum, "%s\t%d\t%d\t%d\t%.0f\t%d\n",
                   node->label, SELFCREDIT, est_mtdb_doc_num(node->db),
                   est_mtdb_word_num(node->db), est_mtdb_size(node->db), ltarg.hnum);
  for(i = 0; i < cbmaprnum(node->links); i++){
    est_datum_printf(datum, "LINK#%d\t%s\t%s\t%d\t%d\t%d\t%.0f\t%d\n",
                     i + 1, rtargs[i].url, rtargs[i].label, rtargs[i].credit,
                     rtargs[i].dnum, rtargs[i].wnum, rtargs[i].size, rtargs[i].hnum);
  }
  est_datum_printf(datum, "VIEW\tSNIPPET\n");
  est_datum_printf(datum, "\n");
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumsetsize(datum, 0);
  resdocs = resmap_list(resmap, &rnum);
  for(i = 0; i < rnum && i < max; i++){
    est_datum_printf(datum, "%s\n", g_bordstr);
    catdocdata(datum, resdocs[i], ltarg.words);
  }
  free(resdocs);
  est_datum_printf(datum, "%s:END\n", g_bordstr);
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_DEBUG, "[%s:%d]: 200 (ok - search)", req->claddr, req->clport);
  cblistclose(ltarg.words);
  for(i = 0; i < cbmaprnum(node->links); i++){
    free(rtargs[i].label);
  }
  free(rtargs);
  free(rths);
  cbmapclose(hints);
  resmap_delete(resmap);
  est_cond_delete(cond);
  free(myurl);
}


/* send the result of get_doc command */
static void sendnodecmdgetdoc(int clsock, REQUEST *req, NODE *node){
  ESTDOC *doc;
  CBDATUM *datum;
  const char *tmp, *uri;
  char *draft;
  int id;
  id = (tmp = cbmapget(req->params, "id", -1, NULL)) ? atoi(tmp) : 0;
  if(!(uri = cbmapget(req->params, "uri", -1, NULL))) uri = "";
  if(id < 1 && uri[0] == '\0'){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  if(id < 1) id = est_mtdb_uri_to_id(node->db, uri);
  if(id > 0 && (doc = est_mtdb_get_doc(node->db, id, 0)) != NULL){
    setdocorigin(doc, node);
    draft = est_doc_dump_draft(doc);
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: %s; charset=UTF-8\r\n", ESTDRAFTTYPE);
    est_datum_printf(datum, "\r\n");
    cbdatumcat(datum, draft, -1);
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - get_doc)", req->claddr, req->clport);
    free(draft);
    est_doc_delete(doc);
  } else {
    log_print(LL_WARN, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
    senderror(clsock, req, 400, "Bad Request (maybe, the document does not exists)");
  }
}


/* send the result of get_doc_attr command */
static void sendnodecmdgetdocattr(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *tmp, *uri, *attr;
  char *value;
  int id;
  id = (tmp = cbmapget(req->params, "id", -1, NULL)) ? atoi(tmp) : 0;
  if(!(uri = cbmapget(req->params, "uri", -1, NULL))) uri = "";
  if(!(attr = cbmapget(req->params, "attr", -1, NULL))) attr = "";
  if((id < 1 && uri[0] == '\0') || attr[0] == '\0'){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  if(id < 1) id = est_mtdb_uri_to_id(node->db, uri);
  if(id > 0 && (value = est_mtdb_get_doc_attr(node->db, id, attr)) != NULL){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    est_datum_printf(datum, "%s\n", value);
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - get_doc_attr)", req->claddr, req->clport);
    free(value);
  } else {
    log_print(LL_WARN, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
    senderror(clsock, req, 400,
              "Bad Request (maybe, the document or the attribute does not exists)");
  }
}


/* send the result of uri_to_id command */
static void sendnodecmduritoid(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *uri;
  int id;
  uri = cbmapget(req->params, "uri", -1, NULL);
  if(!uri){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  if((id = est_mtdb_uri_to_id(node->db, uri)) > 0){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    est_datum_printf(datum, "%d\n", id);
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - uri_to_id)", req->claddr, req->clport);
  } else {
    log_print(LL_WARN, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
    senderror(clsock, req, 400, "Bad Request (maybe, the URI does not registered)");
  }
}


/* send the result of pub_doc command */
static void sendnodecmdputdoc(int clsock, REQUEST *req, NODE *node){
  ESTDOC *doc;
  CBDATUM *datum;
  const char *draft;
  if(req->ctype && cbstrfwimatch(req->ctype, ESTDRAFTTYPE)){
    draft = req->body;
  } else {
    draft = cbmapget(req->params, "draft", -1, NULL);
  }
  if(!draft){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  doc = est_doc_new_from_draft(draft);
  if(est_mtdb_put_doc(node->db, doc, ESTPDCLEAN)){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    est_datum_printf(datum, "OK\n");
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - put_doc)", req->claddr, req->clport);
  } else {
    log_print(LL_ERROR, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
    if(!est_doc_attr(doc, ESTDATTRURI)){
      senderror(clsock, req, 400, "Bad Request (maybe, the document has not the URI)");
    } else {
      senderror(clsock, req, 400, "Bad Request (maybe, the database has a fatal error)");
    }
  }
  est_doc_delete(doc);
}


/* send the result of out_doc command */
static void sendnodecmdoutdoc(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *tmp, *uri;
  int id;
  id = (tmp = cbmapget(req->params, "id", -1, NULL)) ? atoi(tmp) : 0;
  if(!(uri = cbmapget(req->params, "uri", -1, NULL))) uri = "";
  if(id < 1 && uri[0] == '\0'){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  if(id < 1) id = est_mtdb_uri_to_id(node->db, uri);
  if(id > 0 && est_mtdb_out_doc(node->db, id, ESTODCLEAN)){
    datum = cbdatumopen("", 0);
    est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
    addservinfo(datum);
    est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
    est_datum_printf(datum, "\r\n");
    est_datum_printf(datum, "OK\n");
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    log_print(LL_DEBUG, "[%s:%d]: 200 (ok - out_doc)", req->claddr, req->clport);
  } else {
    log_print(LL_WARN, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
    senderror(clsock, req, 400, "Bad Request (maybe, the document does not exist)");
  }
}


/* send the result of _set_user command */
static void sendnodecmdsetuser(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *name, *tmp;
  int mode;
  name = cbmapget(req->params, "name", -1, NULL);
  mode = (tmp = cbmapget(req->params, "mode", -1, NULL)) && tmp[0] != '\0' ? atoi(tmp) : -1;
  if(!name || name[0] == '\0' || mode < 0 || mode > 2){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  switch(mode){
  case 1:
    cbmapput(node->admins, name, -1, "", 0, FALSE);
    break;
  case 2:
    cbmapput(node->users, name, -1, "", 0, FALSE);
    break;
  default:
    cbmapout(node->admins, name, -1);
    cbmapout(node->users, name, -1);
    break;
  }
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
  est_datum_printf(datum, "\r\n");
  est_datum_printf(datum, "OK\n");
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_DEBUG, "[%s:%d]: 200 (ok - _set_user)", req->claddr, req->clport);
}


/* send the result of _set_link command */
static void sendnodecmdsetlink(int clsock, REQUEST *req, NODE *node){
  CBDATUM *datum;
  const char *url, *label, *tmp;
  int credit;
  url = cbmapget(req->params, "url", -1, NULL);
  label = cbmapget(req->params, "label", -1, NULL);
  credit = (tmp = cbmapget(req->params, "credit", -1, NULL)) ? atoi(tmp) : -1;
  if(!url || url[0] == '\0'){
    senderror(clsock, req, 400, "Bad Request (the parameters lack)");
    return;
  }
  node_set_link(node, url, label, credit);
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: text/plain; charset=UTF-8\r\n");
  est_datum_printf(datum, "\r\n");
  est_datum_printf(datum, "OK\n");
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_DEBUG, "[%s:%d]: 200 (ok - _set_link)", req->claddr, req->clport);
}


/* send user interface data */
static void senduidata(int clsock, REQUEST *req, USER *user){
  CBDATUM *datum;
  CBLIST *list;
  USER *tuser;
  NODE *tnode;
  const char *tmp, *name, *passwd, *flags, *fname, *misc, *label;
  char *pbuf;
  int i, action, sure, vm, vu, vn;
  action = UI_NONE;
  if((tmp = cbmapget(req->params, "action", -1, NULL)) != NULL) action = atoi(tmp);
  sure = FALSE;
  if((tmp = cbmapget(req->params, "sure", -1, NULL)) != NULL) sure = atoi(tmp) > 0;
  if(!(name = cbmapget(req->params, "name", -1, NULL))) name = "";
  if(!(passwd = cbmapget(req->params, "passwd", -1, NULL))) passwd = "";
  if(!(flags = cbmapget(req->params, "flags", -1, NULL))) flags = "";
  if(!(fname = cbmapget(req->params, "fname", -1, NULL))) fname = "";
  if(!(misc = cbmapget(req->params, "misc", -1, NULL))) misc = "";
  if(!(label = cbmapget(req->params, "label", -1, NULL))) label = "";
  if(!rwlock_lock(g_mgrlock, TRUE)){
    log_print(LL_ERROR, "locking failed");
    senderror(clsock, req, 500, "Internal Server Error (locking failed)");
    return;
  }
  if(!ismasteradmin(req, user)){
    sendautherror(clsock, req, "Super User");
    if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
    return;
  }
  datum = cbdatumopen("", 0);
  est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
  addservinfo(datum);
  est_datum_printf(datum, "Content-Type: text/html; charset=UTF-8\r\n");
  est_datum_printf(datum, "\r\n");
  est_datum_printf(datum, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
  est_datum_printf(datum, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\""
                   " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
  est_datum_printf(datum, "<html xmlns=\"http://www.w3.org/1999/xhtml\""
                   " xml:lang=\"en\" lang=\"en\">\n");
  est_datum_printf(datum, "<head>\n");
  est_datum_printf(datum, "<meta http-equiv=\"Content-Language\" content=\"en\" />\n");
  est_datum_printf(datum, "<meta http-equiv=\"Content-Type\""
                   " content=\"text/html; charset=UTF-8\" />\n");
  est_datum_printf(datum, "<meta http-equiv=\"Content-Style-Type\" content=\"text/css\" />\n");
  est_datum_printf(datum, "<link rel=\"contents\" href=\"%@\" />\n", MASTERUILOC);
  est_datum_printf(datum, "<title>Administration Interface of Hyper Estraier</title>\n");
  est_datum_printf(datum, "<style type=\"text/css\">"
                   "html { margin: 0em 0em; padding 0em 0em; background: #eeeeee none; }\n");
  est_datum_printf(datum, "body { margin: 2em 2em; padding 0em 0em;");
  est_datum_printf(datum, " background: #eeeeee none; color: #111111;");
  est_datum_printf(datum, " font-style: normal; font-weight: normal; }\n");
  est_datum_printf(datum, "a { color: #0022aa; text-decoration: none; }\n");
  est_datum_printf(datum, "a:hover,a:focus { color: #0033ee; text-decoration: underline; }\n");
  est_datum_printf(datum, "a.head { color: #111111; text-decoration: none; }\n");
  est_datum_printf(datum, "table { padding: 1pt 2pt 1pt 2pt; border: none;"
                   " margin: 1.5em 1.5em; border-collapse: collapse; }\n");
  est_datum_printf(datum, "th { padding: 1pt 4pt 1pt 4pt; border-style: none;"
                   " text-align: left; vertical-align: bottom; }\n");
  est_datum_printf(datum, "th.mini { font-size: smaller; }\n");
  est_datum_printf(datum, "td { padding: 1pt 4pt 1pt 4pt; border: 1pt solid #333333;"
                   " text-align: left; vertical-align: top; }\n");
  est_datum_printf(datum, "td.mini { font-size: smaller; }\n");
  est_datum_printf(datum, "div.form { margin: 1.0em 1.5em; }\n");
  est_datum_printf(datum, "div.logo { text-align: right; font-size: smaller; }\n");
  est_datum_printf(datum, "</style>\n");
  est_datum_printf(datum, "</head>\n");
  est_datum_printf(datum, "<body>\n");
  est_datum_printf(datum, "<h1>Administration Interface of Hyper Estraier</h1>\n");
  est_datum_printf(datum, "<ul>\n");
  vm = FALSE;
  vu = FALSE;
  vn = FALSE;
  switch(action){
  case UI_VIEWMASTER:
  case UI_SHUTDOWN:
    vm = TRUE;
    break;
  case UI_VIEWUSERS:
  case UI_NEWUSER:
  case UI_DELUSER:
    vu = TRUE;
    break;
  case UI_VIEWNODES:
  case UI_NEWNODE:
  case UI_DELNODE:
    vn = TRUE;
    break;
  default:
    break;
  }
  if(vm){
    est_datum_printf(datum, "<li><strong>Manage Master</strong></li>\n");
  } else {
    est_datum_printf(datum, "<li><a href=\"%@?action=%d\">Manage Master</a></li>\n",
                     MASTERUILOC, UI_VIEWMASTER);
  }
  if(vu){
    est_datum_printf(datum, "<li><strong>Manage Users</strong></li>\n");
  } else {
    est_datum_printf(datum, "<li><a href=\"%@?action=%d\">Manage Users</a></li>\n",
                     MASTERUILOC, UI_VIEWUSERS);
  }
  if(vn){
    est_datum_printf(datum, "<li><strong>Manage Nodes</strong></li>\n");
  } else {
    est_datum_printf(datum, "<li><a href=\"%@?action=%d\">Manage Nodes</a></li>\n",
                     MASTERUILOC, UI_VIEWNODES);
  }
  est_datum_printf(datum, "</ul>\n");
  est_datum_printf(datum, "<hr />\n");
  switch(action){
  case UI_SHUTDOWN:
    if(sure){
      g_sigterm = TRUE;
      est_datum_printf(datum, "<p>Good Bye!</p>\n");
    } else {
      est_datum_printf(datum, "<form method=\"post\" action=\"%@\">\n", MASTERUILOC);
      est_datum_printf(datum, "<div class=\"form\">\n");
      est_datum_printf(datum, "confirmation to shutdown the master server:\n");
      est_datum_printf(datum, "<input type=\"submit\" value=\"shutdown\" />\n");
      est_datum_printf(datum, "<input type=\"hidden\" name=\"action\" value=\"%d\" />\n",
                       UI_SHUTDOWN);
      est_datum_printf(datum, "<input type=\"hidden\" name=\"sure\" value=\"1\" />\n");
      est_datum_printf(datum, "</div>\n");
      est_datum_printf(datum, "</form>\n");
    }
    est_datum_printf(datum, "<hr />\n");
    break;
  case UI_NEWUSER:
    pbuf = est_make_crypt(passwd);
    if(name[0] == '\0' || passwd[0] == '\0'){
      est_datum_printf(datum, "<p>The name and the password sould not be empty.</p>\n");
    } else if((tuser = umgr_get(g_umgr, name)) != NULL){
      est_datum_printf(datum, "<p>The name should not be duplicated.</p>\n");
    } else if(!check_alnum_name(name)){
      est_datum_printf(datum, "<p>The name can include alphanumeric characters only.</p>\n");
    } else if(umgr_put(g_umgr, name, pbuf, flags, fname, misc)){
      est_datum_printf(datum, "<p><strong>%@</strong> was created successfully.</p>\n", name);
    } else {
      est_datum_printf(datum, "<p>Some errors were occurred.</p>\n");
    }
    free(pbuf);
    est_datum_printf(datum, "<hr />\n");
    break;
  case UI_DELUSER:
    if(sure){
      if(umgr_out(g_umgr, name)){
        est_datum_printf(datum, "<p><strong>%@</strong> was deleted successfully.</p>\n", name);
      } else {
        est_datum_printf(datum, "<p>Some errors were occurred.</p>\n");
      }
    } else {
      est_datum_printf(datum, "<form method=\"post\" action=\"%@\">\n", MASTERUILOC);
      est_datum_printf(datum, "<div class=\"form\">\n");
      est_datum_printf(datum, "confirmation to delete <strong>%@</strong>:\n", name);
      est_datum_printf(datum, "<input type=\"submit\" value=\"delete\" />\n");
      est_datum_printf(datum, "<input type=\"hidden\" name=\"action\" value=\"%d\" />\n",
                       UI_DELUSER);
      est_datum_printf(datum, "<input type=\"hidden\" name=\"name\" value=\"%@\" />\n", name);
      est_datum_printf(datum, "<input type=\"hidden\" name=\"sure\" value=\"1\" />\n");
      est_datum_printf(datum, "</div>\n");
      est_datum_printf(datum, "</form>\n");
    }
    est_datum_printf(datum, "<hr />\n");
    break;
  case UI_NEWNODE:
    if(name[0] == '\0' || label[0] == '\0'){
      est_datum_printf(datum, "<p>The name and the label sould not be empty.</p>\n");
    } else if((tnode = nmgr_get(g_nmgr, name)) != NULL){
      est_datum_printf(datum, "<p>The name should not be duplicated.</p>\n");
    } else if(!check_alnum_name(name)){
      est_datum_printf(datum, "<p>The name can include alphanumeric characters only.</p>\n");
    } else if(nmgr_put(g_nmgr, name, TRUE)){
      if((tnode = nmgr_get(g_nmgr, name)) != NULL){
        free(tnode->label);
        tnode->label = cbmemdup(label, -1);
      }
      nmgr_sync(g_nmgr, FALSE);
      est_datum_printf(datum, "<p><strong>%@</strong> was created successfully.</p>\n", name);
    } else {
      est_datum_printf(datum, "<p>Some errors were occurred.</p>\n");
    }
    est_datum_printf(datum, "<hr />\n");
    break;
  case UI_DELNODE:
    if(sure){
      if(nmgr_out(g_nmgr, name)){
        est_datum_printf(datum, "<p><strong>%@</strong> was deleted successfully.</p>\n", name);
      } else {
        est_datum_printf(datum, "<p>Some errors were occurred.</p>\n");
      }
    } else {
      est_datum_printf(datum, "<form method=\"post\" action=\"%@\">\n", MASTERUILOC);
      est_datum_printf(datum, "<div class=\"form\">\n");
      est_datum_printf(datum, "confirmation to delete <strong>%@</strong>:\n", name);
      est_datum_printf(datum, "<input type=\"submit\" value=\"delete\" />\n");
      est_datum_printf(datum, "<input type=\"hidden\" name=\"action\" value=\"%d\" />\n",
                       UI_DELNODE);
      est_datum_printf(datum, "<input type=\"hidden\" name=\"name\" value=\"%@\" />\n", name);
      est_datum_printf(datum, "<input type=\"hidden\" name=\"sure\" value=\"1\" />\n");
      est_datum_printf(datum, "</div>\n");
      est_datum_printf(datum, "</form>\n");
    }
    est_datum_printf(datum, "<hr />\n");
    break;
  default:
    break;
  }
  if(vm){
    est_datum_printf(datum, "<ul>\n");
    est_datum_printf(datum, "<li>");
    est_datum_printf(datum, "<a href=\"%@?action=%d\">SHUTDOWN</a>", MASTERUILOC, UI_SHUTDOWN);
    est_datum_printf(datum, "</li>\n");
    est_datum_printf(datum, "</ul>\n");
    est_datum_printf(datum, "<hr />\n");
  }
  if(vu){
    list = umgr_names(g_umgr);
    est_datum_printf(datum, "<table summary=\"nodes\">\n");
    est_datum_printf(datum, "<tr>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"name\">name</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"passwd\">password</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"flags\">flags</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"fname\">full name</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"misc\">misc</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"actions\">actions</th>\n");
    est_datum_printf(datum, "</tr>\n");
    for(i = 0; i < cblistnum(list); i++){
      if(!(tmp = cblistval(list, i, NULL)) || !(tuser = umgr_get(g_umgr, tmp))) continue;
      pbuf = cbmemdup(tuser->passwd, -1);
      if(strlen(pbuf) > 8) sprintf(pbuf + 4, "...");
      est_datum_printf(datum, "<tr>\n");
      est_datum_printf(datum, "<td>%@</td>\n", tuser->name);
      est_datum_printf(datum, "<td>%@</td>\n", pbuf);
      est_datum_printf(datum, "<td>%@</td>\n", tuser->flags);
      est_datum_printf(datum, "<td>%@</td>\n", tuser->fname);
      est_datum_printf(datum, "<td>%@</td>\n", tuser->misc);
      est_datum_printf(datum, "<td>");
      est_datum_printf(datum, "<a href=\"%@?action=%d&amp;name=%?\">DELE</a>",
                       MASTERUILOC, UI_DELUSER, tuser->name);
      est_datum_printf(datum, "</td>\n");
      est_datum_printf(datum, "</tr>\n");
      free(pbuf);
    }
    est_datum_printf(datum, "</table>\n");
    cblistclose(list);
    est_datum_printf(datum, "<form method=\"post\" action=\"%@\">\n", MASTERUILOC);
    est_datum_printf(datum, "<div class=\"form\">\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"name\" value=\"\" size=\"12\" />\n");
    est_datum_printf(datum, "<input type=\"password\" name=\"passwd\" value=\"\""
                     " size=\"12\" />\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"flags\" value=\"\" size=\"4\" />\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"fname\" value=\"\" size=\"12\" />\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"misc\" value=\"\" size=\"12\" />\n");
    est_datum_printf(datum, "<input type=\"submit\" value=\"create\" />\n");
    est_datum_printf(datum, "<input type=\"hidden\" name=\"action\" value=\"%d\" />\n",
                     UI_NEWUSER);
    est_datum_printf(datum, "</div>\n");
    est_datum_printf(datum, "</form>\n");
    est_datum_printf(datum, "<hr />\n");
  }
  if(vn){
    list = nmgr_names(g_nmgr);
    est_datum_printf(datum, "<table summary=\"nodes\">\n");
    est_datum_printf(datum, "<tr>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"name\">name</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"label\">label</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"docnum\">#docs</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"wordnum\">#words</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"size\">size</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"adminnum\">#a</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"usernum\">#u</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"linknum\">#l</th>\n");
    est_datum_printf(datum, "<th class=\"mini\" abbr=\"actions\">actions</th>\n");
    est_datum_printf(datum, "</tr>\n");
    for(i = 0; i < cblistnum(list); i++){
      if(!(tmp = cblistval(list, i, NULL)) || !(tnode = nmgr_get(g_nmgr, tmp))) continue;
      est_datum_printf(datum, "<tr>\n");
      est_datum_printf(datum, "<td>%@</td>\n", tnode->name);
      est_datum_printf(datum, "<td>%@</td>\n", tnode->label);
      est_datum_printf(datum, "<td>%d</td>\n", est_mtdb_doc_num(tnode->db));
      est_datum_printf(datum, "<td>%d</td>\n", est_mtdb_word_num(tnode->db));
      est_datum_printf(datum, "<td>%.1f</td>\n", est_mtdb_size(tnode->db) / 1024.0 / 1024.0);
      est_datum_printf(datum, "<td>%d</td>\n", cbmaprnum(tnode->admins));
      est_datum_printf(datum, "<td>%d</td>\n", cbmaprnum(tnode->users));
      est_datum_printf(datum, "<td>%d</td>\n", cbmaprnum(tnode->links));
      est_datum_printf(datum, "<td>");
      est_datum_printf(datum, "<a href=\"%@?action=%d&amp;name=%?\">DELE</a>",
                       MASTERUILOC, UI_DELNODE, tnode->name);
      est_datum_printf(datum, "</td>\n");
      est_datum_printf(datum, "</tr>\n");
    }
    est_datum_printf(datum, "</table>\n");
    cblistclose(list);
    est_datum_printf(datum, "<form method=\"post\" action=\"%@\">\n", MASTERUILOC);
    est_datum_printf(datum, "<div class=\"form\">\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"name\" value=\"\" size=\"12\" />\n");
    est_datum_printf(datum, "<input type=\"text\" name=\"label\" value=\"\" size=\"24\" />\n");
    est_datum_printf(datum, "<input type=\"submit\" value=\"create\" />\n");
    est_datum_printf(datum, "<input type=\"hidden\" name=\"action\" value=\"%d\" />\n",
                     UI_NEWNODE);
    est_datum_printf(datum, "</div>\n");
    est_datum_printf(datum, "</form>\n");
    est_datum_printf(datum, "<hr />\n");
  }
  est_datum_printf(datum, "<div class=\"logo\">Powered by Hyper Estraier %@.</div>\n",
                   est_version);
  est_datum_printf(datum, "</body>\n");
  est_datum_printf(datum, "</html>\n");
  est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
  cbdatumclose(datum);
  log_print(LL_DEBUG, "[%s:%d]: 200 (ok - ui:%d)", req->claddr, req->clport, action);
  if(!rwlock_unlock(g_mgrlock)) log_print(LL_ERROR, "unlocking failed");
}


/* send a file data */
static void sendfiledata(int clsock, REQUEST *req){
  struct stat sbuf;
  CBLIST *list;
  CBDATUM *datum;
  const char *elem;
  char *path, *index, pbuf[URIBUFSIZ], ibuf[IOBUFSIZ], *ext, *tmp;
  int i, fd, len, fdir;
  time_t ims;
  double size;
  if(g_docroot[0] == '\0'){
    senderror(clsock, req, 403, "Forbidden");
    return;
  }
  path = makelocalpath(req->target);
  if(g_indexfile[0] != '\0'){
    index = cbsprintf("%s%c%s", path, ESTPATHCHR, g_indexfile);
    if(stat(index, &sbuf) == 0 && cbstrbwmatch(req->target, "/")){
      free(path);
      path = index;
      index = NULL;
    }
    free(index);
  }
  if((list = cbdirlist(path)) != NULL){
    datum = cbdatumopen("", 0);
    if(cbstrbwmatch(req->target, "/")){
      cblistsort(list);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      est_datum_printf(datum, "Content-Type: text/html\r\n");
      est_datum_printf(datum, "\r\n");
      if(req->method != HM_HEAD){
        est_datum_printf(datum, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        est_datum_printf(datum, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\""
                         " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
        est_datum_printf(datum, "<html xmlns=\"http://www.w3.org/1999/xhtml\""
                         " xml:lang=\"en\" lang=\"en\">\n");
        est_datum_printf(datum, "<head>\n");
        est_datum_printf(datum, "<meta http-equiv=\"Content-Type\" content=\"text/html\" />\n");
        est_datum_printf(datum, "<meta http-equiv=\"Content-Style-Type\""
                         " content=\"text/css\" />\n");
        est_datum_printf(datum, "<title>%@</title>\n", req->target);
        est_datum_printf(datum, "<style type=\"text/css\">"
                         "html { margin: 0em 0em; padding 0em 0em;"
                         " background: #eeeeee none; }\n");
        est_datum_printf(datum, "body { margin: 2em 2em; padding 0em 0em;");
        est_datum_printf(datum, " background: #eeeeee none; color: #111111;");
        est_datum_printf(datum, " font-style: normal; font-weight: normal; }\n");
        est_datum_printf(datum, "a { color: #0022aa; text-decoration: none; }\n");
        est_datum_printf(datum, "a:hover,a:focus { color: #0033ee;"
                         " text-decoration: underline; }\n");
        est_datum_printf(datum, "a.head { color: #111111; text-decoration: none; }\n");
        est_datum_printf(datum, "</style>\n");
        est_datum_printf(datum, "</head>\n");
        est_datum_printf(datum, "<body>\n");
        est_datum_printf(datum, "<h1>Index of %@</h1>\n", req->target);
        est_datum_printf(datum, "<hr />\n");
        est_datum_printf(datum, "<ul>\n");
        if(strcmp(req->target, "/"))
          est_datum_printf(datum, "<li><a href=\"../\">../</a></li>\n");
        for(i = 0; i < cblistnum(list); i++){
          elem = cblistval(list, i, NULL);
          if(!strcmp(elem, ESTCDIRSTR) || !strcmp(elem, ESTPDIRSTR)) continue;
          sprintf(pbuf, "%s%c%s", path, ESTPATHCHR, elem);
          if(!cbfilestat(pbuf, &fdir, NULL, NULL)) continue;
          est_datum_printf(datum, "<li><a href=\"%?%s\">%@%s</a></li>\n",
                           elem, fdir ? "/" : "", elem, fdir ? "/" : "");
        }
        est_datum_printf(datum, "</ul>\n");
        est_datum_printf(datum, "<hr />\n");
        est_datum_printf(datum, "<address>%@/%@ at %@:%d</address>\n",
                         SERVNAME, est_version, g_hostname, g_portnum);
        est_datum_printf(datum, "</body>\n");
        est_datum_printf(datum, "</html>\n");
      }
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - directory)", req->claddr, req->clport);
    } else {
      cblistsort(list);
      est_datum_printf(datum, "HTTP/1.0 301 Moved Parmanently\r\n");
      addservinfo(datum);
      if(req->host){
        est_datum_printf(datum, "Location: http://%s%s/\r\n", req->host, req->target);
      } else {
        est_datum_printf(datum, "Location: http://%s:%d%s/\r\n",
                         g_hostname, g_portnum, req->target);
      }
      est_datum_printf(datum, "Content-Type: text/plain\r\n");
      est_datum_printf(datum, "\r\n");
      if(req->method != HM_HEAD) est_datum_printf(datum, "Go to %s/\n", req->target);
      log_print(LL_DEBUG, "[%s:%d]: 301 (moved parmanently)", req->claddr, req->clport);
    }
    est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
    cbdatumclose(datum);
    cblistclose(list);
  } else if((fd = open(path, O_RDONLY, 0)) != -1){
    if(fstat(fd, &sbuf) == 0){
      ims = sbuf.st_mtime;
      size = sbuf.st_size;
    } else {
      ims = -1;
      size = -1.0;
    }
    if(req->ims > 0 && ims <= req->ims){
      senderror(clsock, req, 304, "Not Modified");
    } else {
      datum = cbdatumopen("", 0);
      est_datum_printf(datum, "HTTP/1.0 200 OK\r\n");
      addservinfo(datum);
      if(ims > 0){
        tmp = cbdatestrhttp(ims, 0);
        est_datum_printf(datum, "Last-Modified: %s\r\n", tmp);
        free(tmp);
      }
      if(size >= 0.0) est_datum_printf(datum, "Content-Length: %.0f\r\n", size);
      ext = strrchr(path, ESTPATHCHR);
      ext = strrchr(ext ? ext : path, '.');
      est_datum_printf(datum, "Content-Type: %s\r\n", est_ext_type(ext ? ext : ""));
      est_datum_printf(datum, "\r\n");
      est_sock_send_all(clsock, cbdatumptr(datum), cbdatumsize(datum));
      if(req->method != HM_HEAD){
        while((len = read(fd, ibuf, IOBUFSIZ)) > 0 && !g_sigterm){
          send(clsock, ibuf, len, 0);
        }
      }
      cbdatumclose(datum);
      log_print(LL_DEBUG, "[%s:%d]: 200 (ok - file)", req->claddr, req->clport);
    }
    close(fd);
  } else {
    senderror(clsock, req, 404, "Not Found");
  }
  free(path);
}


/* make the local path of a target */
static char *makelocalpath(const char *target){
  CBLIST *list;
  CBDATUM *datum;
  const char *elem;
  char *tmp;
  int i;
  datum = cbdatumopen(g_docroot, -1);
  list = cbsplit(target, -1, "/");
  for(i = 0; i < cblistnum(list); i++){
    elem = cblistval(list, i, NULL);
    if(elem[0] == '\0') continue;
    tmp = cburldecode(elem, NULL);
    est_datum_printf(datum, "%c%s", ESTPATHCHR, tmp);
    free(tmp);
  }
  cblistclose(list);
  return cbdatumtomalloc(datum, NULL);
}


/* END OF FILE */