upstream/0.5.0/mastermod.c

/*************************************************************************************************
 * Implementation of mastermod
 *                                                      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"


/* private function prototypes */
static void log_close(void);
static void db_inform(const char *msg);
static int resdoc_compare(const void *ap, const void *bp);


/*************************************************************************************************
 * pseudo API
 *************************************************************************************************/


/* The handles of the log file. */
FILE *log_fp = NULL;


/* Level of logging. */
int log_level = LL_INFO;


/* Open the log file. */
int log_open(const char *rootdir, int level){
  char path[URIBUFSIZ];
  assert(rootdir);
  log_level = level;
  if(log_fp) return TRUE;
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, LOGFILE);
  if(!(log_fp = fopen(path, "ab"))) return FALSE;
  atexit(log_close);
  return TRUE;
}


/* Print formatted string into the log file. */
void log_print(int level, const char *format, ...){
  static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
  va_list ap;
  const char *lvstr;
  char *date;
  if(level < log_level) return;
  if(pthread_mutex_lock(&mymutex) != 0) return;
  va_start(ap, format);
  switch(level){
  case LL_DEBUG: lvstr = "DEBUG"; break;
  case LL_INFO: lvstr = "INFO"; break;
  case LL_WARN: lvstr = "WARN"; break;
  default: lvstr = "ERROR"; break;
  }
  date = cbdatestrwww(time(NULL), 0);
  printf("%s\t%s\t", date, lvstr);
  vprintf(format, ap);
  putchar('\n');
  fflush(stdout);
  if(log_fp){
    fprintf(log_fp, "%s\t%s\t", date, lvstr);
    vfprintf(log_fp, format, ap);
    fputc('\n', log_fp);
    fflush(log_fp);
  }
  free(date);
  va_end(ap);
  pthread_mutex_unlock(&mymutex);
}


/* Initialize the root directory. */
int master_init(const char *rootdir){
  DEPOT *depot;
  FILE *ofp;
  char path[URIBUFSIZ];
  int err;
  assert(rootdir);
  if(est_mkdir(rootdir) == -1 && errno != EEXIST) return FALSE;
  err = FALSE;
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, METAFILE);
  if((depot = dpopen(path, DP_OWRITER | DP_OCREAT | DP_OTRUNC, MINIBNUM))){
    if(!dpput(depot, MMKMAGIC, -1, MMKMAGVAL, -1, FALSE)) err = TRUE;
    if(!dpclose(depot)) err = TRUE;
  } else {
    err = TRUE;
  }
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, CONFFILE);
  if((ofp = fopen(path, "wb")) != NULL){
    fprintf(ofp, "# fully quarified hostname\n");
    fprintf(ofp, "hostname: localhost\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# port number of TCP\n");
    fprintf(ofp, "portnum: 1978\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# running mode (1:normal, 2:readonly)\n");
    fprintf(ofp, "runmode: 1\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# authorization mode (1:none, 2:admin, 3:all)\n");
    fprintf(ofp, "authmode: 2\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# maximum number of connections at the same time\n");
    fprintf(ofp, "maxconn: 30\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# timeout of a session, in seconds\n");
    fprintf(ofp, "sessiontimeout: 600\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# timeout of search, in seconds\n");
    fprintf(ofp, "searchtimeout: 8\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# maximum depth of meta search\n");
    fprintf(ofp, "searchdepth: 5\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# host name of the proxy\n");
    fprintf(ofp, "proxyhost:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# port number of the proxy\n");
    fprintf(ofp, "proxyport:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# logging level (1:debug, 2:information, 3:warning, 4:error, 5:none)\n");
    fprintf(ofp, "loglevel: 2\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# document root directory (full path of a directory to be public)\n");
    fprintf(ofp, "docroot:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# index file (name of directory index files)\n");
    fprintf(ofp, "indexfile:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# decimal IP addresses of trusted nodes (list separated by comma)\n");
    fprintf(ofp, "trustednodes:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# whether to deny all nodes except for trusted nodes (0:no, 1:yes)\n");
    fprintf(ofp, "denyuntrusted: 0\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# name of the attribute of special cache\n");
    fprintf(ofp, "specialcache:\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# whole width of the snippet of each shown document\n");
    fprintf(ofp, "snipwwidth: 480\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# width of strings picked up from the beginning of the text\n");
    fprintf(ofp, "sniphwidth: 96\n");
    fprintf(ofp, "\n");
    fprintf(ofp, "# width of strings picked up around each highlighted word\n");
    fprintf(ofp, "snipawidth: 96\n");
    if(fclose(ofp) == EOF) err = TRUE;
  } else {
    err = TRUE;
  }
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, PIDFILE);
  unlink(path);
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, STOPFILE);
  unlink(path);
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, USERFILE);
  if((ofp = fopen(path, "wb")) != NULL){
    if(fclose(ofp) == EOF) err = TRUE;
  } else {
    err = TRUE;
  }
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, LOGFILE);
  if((ofp = fopen(path, "wb")) != NULL){
    if(fclose(ofp) == EOF) err = TRUE;
  } else {
    err = TRUE;
  }
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, NODEDIR);
  est_rmdir_rec(path);
  if(est_mkdir(path) == -1) err = TRUE;
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, SESSDIR);
  est_rmdir_rec(path);
  if(est_mkdir(path) == -1) err = TRUE;
  return err ? FALSE : TRUE;
}


/* Get the PID of the process locking the root directory. */
int lockerpid(const char *rootdir){
  char path[URIBUFSIZ], *vbuf;
  int pid;
  pid = -1;
  sprintf(path, "%s%c%s", rootdir, ESTPATHCHR, PIDFILE);
  if((vbuf = cbreadfile(path, NULL)) != NULL){
    pid = atoi(vbuf);
    free(vbuf);
  }
  return pid;
}


/* Check whether a name includes alpha numeric characters only. */
int check_alnum_name(const char *name){
  while(*name != '\0'){
    if(!(*name >= 'a' && *name <= 'z') && !(*name >= '0' && *name <= '9') &&
       *name != '-' && *name != '_'){
      return FALSE;
    }
    name++;
  }
  return TRUE;
}


/* Create a user manager object. */
UMGR *umgr_new(const char *rootdir){
  UMGR *umgr;
  assert(rootdir);
  log_print(LL_INFO, "starting the user manager");
  umgr = cbmalloc(sizeof(UMGR));
  umgr->rootdir = cbmemdup(rootdir, -1);
  umgr->users = cbmapopen();
  return umgr;
}


/* Destroy a user manager object. */
int umgr_delete(UMGR *umgr){
  USER *user;
  const char *kbuf, *vbuf;
  int err, ksiz;
  assert(umgr);
  log_print(LL_INFO, "finishing the user manager");
  err = FALSE;
  if(!umgr_sync(umgr)) err = TRUE;
  cbmapiterinit(umgr->users);
  while((kbuf = cbmapiternext(umgr->users, &ksiz)) != NULL){
    vbuf = cbmapget(umgr->users, kbuf, ksiz, NULL);
    user = (USER *)vbuf;
    pthread_mutex_destroy(&(user->mutex));
    if(user->sess) cbmapclose(user->sess);
    free(user->misc);
    free(user->fname);
    free(user->flags);
    free(user->passwd);
    free(user->name);
  }
  cbmapclose(umgr->users);
  free(umgr->rootdir);
  free(umgr);
  return err ? FALSE : TRUE;
}


/* Load all users from the user file. */
int umgr_load(UMGR *umgr){
  CBLIST *lines, *elems;
  const char *line;
  char path[URIBUFSIZ];
  int i, size;
  assert(umgr);
  log_print(LL_INFO, "loading the user list");
  sprintf(path, "%s%c%s", umgr->rootdir, ESTPATHCHR, USERFILE);
  if(!(lines = cbreadlines(path))){
    log_print(LL_ERROR, "loading the user list failed");
    return FALSE;
  }
  for(i = 0; i < cblistnum(lines); i++){
    line = cblistval(lines, i, &size);
    if(size < 1) continue;
    elems = cbsplit(line, size, "\t");
    if(cblistnum(elems) >= 5){
      umgr_put(umgr, cblistval(elems, 0, NULL), cblistval(elems, 1, NULL),
               cblistval(elems, 2, NULL), cblistval(elems, 3, NULL), cblistval(elems, 4, NULL));
    } else {
      log_print(LL_WARN, "invalid line: %d", i + 1);
    }
    cblistclose(elems);
  }
  cblistclose(lines);
  return TRUE;
}


/* Synchronize all users into the user file. */
int umgr_sync(UMGR *umgr){
  FILE *ofp;
  USER *user;
  const char *kbuf, *vbuf;
  char path[URIBUFSIZ];
  int err, ksiz;
  assert(umgr);
  log_print(LL_INFO, "saving the user list");
  sprintf(path, "%s%c%s", umgr->rootdir, ESTPATHCHR, USERFILE);
  if(!(ofp = fopen(path, "wb"))){
    log_print(LL_ERROR, "synchronizing the user list failed");
    return FALSE;
  }
  err = FALSE;
  cbmapiterinit(umgr->users);
  while((kbuf = cbmapiternext(umgr->users, &ksiz)) != NULL){
    vbuf = cbmapget(umgr->users, kbuf, ksiz, NULL);
    user = (USER *)vbuf;
    fprintf(ofp, "%s\t%s\t%s\t%s\t%s\n",
            user->name, user->passwd, user->flags, user->fname, user->misc);
  }
  if(fclose(ofp) == EOF){
    log_print(LL_ERROR, "saving the user list failed");
    err = TRUE;
  }
  return err ? FALSE : TRUE;
}


/* Add a user to a user manager object. */
int umgr_put(UMGR *umgr, const char *name, const char *passwd, const char *flags,
             const char *fname, const char *misc){
  USER user;
  assert(umgr && name && passwd && flags && fname && misc);
  log_print(LL_DEBUG, "umgr_put: %s:%s:%s:%s:%s", name, passwd, flags, fname, misc);
  if(name[0] == '\0' || cbmapget(umgr->users, name, -1, NULL)){
    log_print(LL_WARN, "duplicated or empty user name: %s", name);
    return FALSE;
  }
  if(!check_alnum_name(name)){
    log_print(LL_WARN, "invalid user name: %s", name);
    return FALSE;
  }
  user.name = cbmemdup(name, -1);
  user.passwd = cbmemdup(passwd, -1);
  user.flags = cbmemdup(flags, -1);
  user.fname = cbmemdup(fname, -1);
  user.misc = cbmemdup(misc, -1);
  user.atime = 0;
  user.sess = NULL;
  pthread_mutex_init(&(user.mutex), NULL);
  cbmapput(umgr->users, name, -1, (char *)&user, sizeof(USER), FALSE);
  return TRUE;
}


/* Remove a user from a user manager object. */
int umgr_out(UMGR *umgr, const char *name){
  USER *user;
  const char *vbuf;
  assert(umgr && name);
  log_print(LL_DEBUG, "umgr_out: %s", name);
  if(!(vbuf = cbmapget(umgr->users, name, -1, NULL))) return FALSE;
  user = (USER *)vbuf;
  pthread_mutex_destroy(&(user->mutex));
  if(user->sess) cbmapclose(user->sess);
  free(user->misc);
  free(user->fname);
  free(user->flags);
  free(user->passwd);
  free(user->name);
  cbmapout(umgr->users, name, -1);
  return TRUE;
}


/* Get a list of names of users in a user manager object. */
CBLIST *umgr_names(UMGR *umgr){
  CBLIST *names;
  assert(umgr);
  names = cbmapkeys(umgr->users);
  cblistsort(names);
  return names;
}


/* Get a user object in a user manager object. */
USER *umgr_get(UMGR *umgr, const char *name){
  const char *vbuf;
  assert(umgr && name);
  if(!(vbuf = cbmapget(umgr->users, name, -1, NULL))) return NULL;
  return (USER *)vbuf;
}


/* Make the session of a user object. */
void user_make_sess(USER *user){
  assert(user);
  if(pthread_mutex_lock(&(user->mutex)) != 0) return;
  if(user->sess) cbmapclose(user->sess);
  user->sess = cbmapopenex(MINIBNUM);
  pthread_mutex_unlock(&(user->mutex));
}


/* Clear the session of a user object. */
void user_clear_sess(USER *user){
  assert(user);
  if(pthread_mutex_lock(&(user->mutex)) != 0) return;
  if(user->sess) cbmapclose(user->sess);
  user->sess = NULL;
  pthread_mutex_unlock(&(user->mutex));
}


/* Set a session variable of a user object. */
void user_set_sess_val(USER *user, const char *name, const char *value){
  assert(user && name);
  if(pthread_mutex_lock(&(user->mutex)) != 0) return;
  if(user->sess){
    if(value){
      cbmapput(user->sess, name, -1, value, -1, TRUE);
    } else {
      cbmapout(user->sess, name, -1);
    }
  }
  pthread_mutex_unlock(&(user->mutex));
}


/* Get the value of a session variable of a user object. */
char *user_sess_val(USER *user, const char *name){
  const char *value;
  char *rv;
  assert(user && name);
  if(pthread_mutex_lock(&(user->mutex)) != 0) return NULL;
  value = user->sess ? cbmapget(user->sess, name, -1, NULL) : NULL;
  rv = value ? cbmemdup(value, -1) : NULL;
  pthread_mutex_unlock(&(user->mutex));
  return rv;
}


/* Create a node manager object. */
NMGR *nmgr_new(const char *rootdir){
  NMGR *nmgr;
  assert(rootdir);
  log_print(LL_INFO, "starting the node manager");
  nmgr = cbmalloc(sizeof(NMGR));
  nmgr->rootdir = cbmemdup(rootdir, -1);
  nmgr->nodes = cbmapopen();
  return nmgr;
}


/* Destroy a user manager object. */
int nmgr_delete(NMGR *nmgr){
  NODE *node;
  const char *kbuf, *vbuf;
  int err, ksiz, ecode;
  assert(nmgr);
  log_print(LL_INFO, "finishing the node manager");
  err = FALSE;
  if(!nmgr_sync(nmgr, FALSE)) err = TRUE;
  cbmapiterinit(nmgr->nodes);
  while((kbuf = cbmapiternext(nmgr->nodes, &ksiz)) != NULL){
    vbuf = cbmapget(nmgr->nodes, kbuf, ksiz, NULL);
    node = (NODE *)vbuf;
    pthread_mutex_destroy(&(node->mutex));
    cbmapclose(node->links);
    cbmapclose(node->users);
    cbmapclose(node->admins);
    free(node->label);
    free(node->name);
    est_mtdb_close(node->db, &ecode);
  }
  cbmapclose(nmgr->nodes);
  free(nmgr->rootdir);
  free(nmgr);
  return err ? FALSE : TRUE;
}


/* Load all nodes from the node directory. */
int nmgr_load(NMGR *nmgr, int wmode){
  CBLIST *list;
  const char *file;
  char path[URIBUFSIZ];
  int i, err;
  assert(nmgr);
  sprintf(path, "%s%c%s", nmgr->rootdir, ESTPATHCHR, NODEDIR);
  if(!(list = cbdirlist(path))){
    log_print(LL_ERROR, "loading the node directory failed");
    return FALSE;
  }
  err = FALSE;
  for(i = 0; i < cblistnum(list); i++){
    file = cblistval(list, i, NULL);
    if(!strcmp(file, ESTCDIRSTR) || !strcmp(file, ESTPDIRSTR)) continue;
    if(!nmgr_put(nmgr, file, wmode)) err = TRUE;
  }
  cblistclose(list);
  return err ? FALSE : TRUE;
}


/* Synchronize all nodes into the node directory. */
int nmgr_sync(NMGR *nmgr, int phis){
  NODE *node;
  CBDATUM *datum;
  const char *kbuf, *vbuf;
  int err, ksiz, vsiz;
  assert(nmgr);
  log_print(LL_INFO, "synchronizing the node manager");
  err = FALSE;
  cbmapiterinit(nmgr->nodes);
  while((kbuf = cbmapiternext(nmgr->nodes, &ksiz)) != NULL){
    vbuf = cbmapget(nmgr->nodes, kbuf, ksiz, NULL);
    node = (NODE *)vbuf;
    est_mtdb_add_meta(node->db, NMKNAME, node->name);
    est_mtdb_add_meta(node->db, NMKLABEL, node->label);
    datum = cbdatumopen("", 0);
    cbmapiterinit(node->admins);
    while((kbuf = cbmapiternext(node->admins, &ksiz)) != NULL){
      cbdatumcat(datum, kbuf, ksiz);
      cbdatumcat(datum, "\n", 1);
    }
    est_mtdb_add_meta(node->db, NMKADMINS, cbdatumptr(datum));
    cbdatumclose(datum);
    datum = cbdatumopen("", 0);
    cbmapiterinit(node->users);
    while((kbuf = cbmapiternext(node->users, &ksiz)) != NULL){
      cbdatumcat(datum, kbuf, ksiz);
      cbdatumcat(datum, "\n", 1);
    }
    est_mtdb_add_meta(node->db, NMKUSERS, cbdatumptr(datum));
    cbdatumclose(datum);
    datum = cbdatumopen("", 0);
    cbmapiterinit(node->links);
    while((kbuf = cbmapiternext(node->links, &ksiz)) != NULL){
      vbuf = cbmapget(node->links, kbuf, ksiz, &vsiz);
      cbdatumcat(datum, kbuf, ksiz);
      cbdatumcat(datum, "\t", 1);
      cbdatumcat(datum, vbuf, vsiz);
      cbdatumcat(datum, "\n", 1);
    }
    est_mtdb_add_meta(node->db, NMKLINKS, cbdatumptr(datum));
    cbdatumclose(datum);
    if(phis && !est_mtdb_sync(node->db)){
      log_print(LL_ERROR, "DB-ERROR: %s", est_err_msg(est_mtdb_error(node->db)));
      err = TRUE;
    }
  }
  return err ? FALSE : TRUE;
}


/* Add a node to a node manager object. */
int nmgr_put(NMGR *nmgr, const char *name, int wmode){
  NODE node;
  ESTMTDB *db;
  CBLIST *list;
  const char *cbuf, *pv;
  char pbuf[URIBUFSIZ], *vbuf;
  int i, ecode, csiz;
  assert(nmgr && name);
  log_print(LL_DEBUG, "nmgr_put: %s", name);
  if(name[0] == '\0' || cbmapget(nmgr->nodes, name, -1, NULL)){
    log_print(LL_WARN, "duplicated or empty node name: %s", name);
    return FALSE;
  }
  if(strlen(name) >= NODENAMEMAX || !check_alnum_name(name)){
    log_print(LL_WARN, "invalid node name: %s", name);
    return FALSE;
  }
  log_print(LL_INFO, "opening the node (%s): %s", wmode ? "WRITER" : "READER", name);
  sprintf(pbuf, "%s%c%s%c%s", nmgr->rootdir, ESTPATHCHR, NODEDIR, ESTPATHCHR, name);
  if(!(db = est_mtdb_open(pbuf, wmode ? ESTDBWRITER | ESTDBCREAT : ESTDBREADER, &ecode))){
    log_print(LL_ERROR, "DB-ERROR: %s", est_err_msg(ecode));
    return FALSE;
  }
  est_mtdb_set_informer(db, db_inform);
  node.db = db;
  est_mtdb_add_meta(db, NMKNAME, name);
  node.name = cbmemdup(name, -1);
  vbuf = est_mtdb_meta(db, NMKLABEL);
  node.label = vbuf ? vbuf : cbmemdup(name, -1);
  if((vbuf = est_mtdb_meta(db, NMKADMINS)) != NULL){
    list = cbsplit(vbuf, -1, "\n");
    node.admins = cbmapopenex(cblistnum(list) + MINIBNUM);
    for(i = 0; i < cblistnum(list); i++){
      cbuf = cblistval(list, i, &csiz);
      if(csiz < 1) continue;
      cbmapput(node.admins, cbuf, csiz, "", 0, FALSE);
    }
    cblistclose(list);
    free(vbuf);
  } else {
    node.admins = cbmapopenex(MINIBNUM);
  }
  if((vbuf = est_mtdb_meta(db, NMKUSERS)) != NULL){
    list = cbsplit(vbuf, -1, "\n");
    node.users = cbmapopenex(cblistnum(list) + MINIBNUM);
    for(i = 0; i < cblistnum(list); i++){
      cbuf = cblistval(list, i, &csiz);
      if(csiz < 1) continue;
      cbmapput(node.users, cbuf, csiz, "", 0, FALSE);
    }
    cblistclose(list);
    free(vbuf);
  } else {
    node.users = cbmapopenex(MINIBNUM);
  }
  if((vbuf = est_mtdb_meta(db, NMKLINKS)) != NULL){
    list = cbsplit(vbuf, -1, "\n");
    node.links = cbmapopenex(cblistnum(list) + MINIBNUM);
    for(i = 0; i < cblistnum(list); i++){
      cbuf = cblistval(list, i, NULL);
      if(!(pv = strchr(cbuf, '\t'))) continue;
      cbmapput(node.links, cbuf, pv - cbuf, pv + 1, -1, FALSE);
    }
    cblistclose(list);
    free(vbuf);
  } else {
    node.links = cbmapopenex(MINIBNUM);
  }
  pthread_mutex_init(&(node.mutex), NULL);
  cbmapput(nmgr->nodes, name, -1, (char *)&node, sizeof(NODE), FALSE);
  return TRUE;
}


/* Remove a node from a node manager object. */
int nmgr_out(NMGR *nmgr, const char *name){
  NODE *node;
  const char *vbuf;
  char pbuf[URIBUFSIZ];
  int err, ecode;
  assert(nmgr && name);
  log_print(LL_DEBUG, "nmgr_out: %s", name);
  if(!(vbuf = cbmapget(nmgr->nodes, name, -1, NULL))) return FALSE;
  err = FALSE;
  node = (NODE *)vbuf;
  pthread_mutex_destroy(&(node->mutex));
  cbmapclose(node->links);
  cbmapclose(node->users);
  cbmapclose(node->admins);
  free(node->label);
  free(node->name);
  if(!(est_mtdb_close(node->db, &ecode))){
    log_print(LL_ERROR, "DB-ERROR: %s", est_err_msg(ecode));
    err = TRUE;
  }
  sprintf(pbuf, "%s%c%s%c%s", nmgr->rootdir, ESTPATHCHR, NODEDIR, ESTPATHCHR, name);
  if(!est_rmdir_rec(pbuf)){
    log_print(LL_ERROR, "could not remove a directory");
    err = TRUE;
  }
  cbmapout(nmgr->nodes, name, -1);
  return TRUE;
}


/* Get a list of names of nodes in a noder manager object. */
CBLIST *nmgr_names(NMGR *nmgr){
  CBLIST *names;
  assert(nmgr);
  names = cbmapkeys(nmgr->nodes); 
  cblistsort(names);
  return names;
}


/* Get a node object in a node manager object. */
NODE *nmgr_get(NMGR *nmgr, const char *name){
  const char *vbuf;
  assert(nmgr && name);
  if(!(vbuf = cbmapget(nmgr->nodes, name, -1, NULL))) return NULL;
  return (NODE *)vbuf;
}


/* Set a link object of a node. */
void node_set_link(NODE *node, const char *url, const char *label, int credit){
  char *vbuf;
  assert(node && url);
  if(!label || credit < 0){
    cbmapout(node->links, url, -1);
    return;
  }
  vbuf = cbsprintf("%s\t%d", label, credit);
  cbmapput(node->links, url, -1, vbuf, -1, TRUE);
  free(vbuf);
}


/* Create a read-write lock object. */
RWLOCK *rwlock_new(void){
  RWLOCK *rwlock;
  rwlock = cbmalloc(sizeof(RWLOCK));
  rwlock->readers = 0;
  rwlock->writers = 0;
  pthread_mutex_init(&(rwlock->mutex), NULL);
  pthread_cond_init(&(rwlock->cond), NULL);
  return rwlock;
}


/* Destroy a read-write lock object. */
void rwlock_delete(RWLOCK *rwlock){
  assert(rwlock);
  pthread_cond_destroy(&(rwlock->cond));
  pthread_mutex_destroy(&(rwlock->mutex));
  free(rwlock);
}


/* Lock a read-write lock object. */
int rwlock_lock(RWLOCK *rwlock, int wmode){
  assert(rwlock);
  if(pthread_mutex_lock(&(rwlock->mutex)) != 0) return FALSE;
  if(wmode){
    while(rwlock->writers > 0 || rwlock->readers > 0){
      pthread_cond_wait(&(rwlock->cond), &(rwlock->mutex));
    }
    rwlock->writers++;
  } else {
    while(rwlock->writers > 0){
      pthread_cond_wait(&(rwlock->cond), &(rwlock->mutex));
    }
    rwlock->readers++;
  }
  pthread_mutex_unlock(&(rwlock->mutex));
  return TRUE;
}


/* Unlock a read-write lock object. */
int rwlock_unlock(RWLOCK *rwlock){
  assert(rwlock);
  if(pthread_mutex_lock(&(rwlock->mutex)) != 0) return FALSE;
  if(rwlock->writers > 0){
    rwlock->writers--;
    pthread_cond_broadcast(&(rwlock->cond));
    pthread_mutex_unlock(&(rwlock->mutex));
  } else {
    rwlock->readers--;
    if(rwlock->readers < 1) pthread_cond_signal(&(rwlock->cond));
    pthread_mutex_unlock(&(rwlock->mutex));
  }
  return TRUE;
}


/* Get the number of readers locking a read-write lock object. */
int rwlock_rnum(RWLOCK *rwlock){
  assert(rwlock);
  return rwlock->readers;
}


/* Create a result map object. */
RESMAP *resmap_new(void){
  RESMAP *resmap;
  resmap = cbmalloc(sizeof(RESMAP));
  resmap->uris = cbmapopen();
  pthread_mutex_init(&(resmap->mutex), NULL);
  return resmap;
}


/* Destroy a result map object. */
void resmap_delete(RESMAP *resmap){
  RESDOC *resdoc;
  const char *kbuf, *vbuf;
  int ksiz;
  assert(resmap);
  cbmapiterinit(resmap->uris);
  while((kbuf = cbmapiternext(resmap->uris, &ksiz)) != NULL){
    vbuf = cbmapget(resmap->uris, kbuf, ksiz, NULL);
    resdoc = (RESDOC *)vbuf;
    if(resdoc->doc) est_doc_delete(resdoc->doc);
    if(resdoc->attrs) cbmapclose(resdoc->attrs);
    if(resdoc->body) free(resdoc->body);
  }
  pthread_mutex_destroy(&(resmap->mutex));
  cbmapclose(resmap->uris);
  free(resmap);
}


/* Add a result document data to a result map object. */
void resmap_put(RESMAP *resmap, int score, ESTDOC *doc, CBMAP *attrs, char *body){
  RESDOC resdoc;
  const char *uri, *vbuf;
  assert(resmap);
  uri = NULL;
  if(doc) uri = est_doc_attr(doc, ESTDATTRURI);
  if(attrs) uri = cbmapget(attrs, ESTDATTRURI, -1, NULL);
  if(!uri || pthread_mutex_lock(&(resmap->mutex)) != 0){
    if(doc) est_doc_delete(doc);
    if(attrs) cbmapclose(attrs);
    if(body) free(body);
    return;
  }
  if((vbuf = cbmapget(resmap->uris, uri, -1, NULL)) != NULL){
    if(((RESDOC *)vbuf)->score >= score){
      if(doc) est_doc_delete(doc);
      if(attrs) cbmapclose(attrs);
      if(body) free(body);
    } else {
      if(((RESDOC *)vbuf)->doc) est_doc_delete(((RESDOC *)vbuf)->doc);
      if(((RESDOC *)vbuf)->attrs) cbmapclose(((RESDOC *)vbuf)->attrs);
      if(((RESDOC *)vbuf)->body) free(((RESDOC *)vbuf)->body);
      resdoc.score = score;
      resdoc.doc = doc;
      resdoc.attrs = attrs;
      resdoc.body = body;
      cbmapput(resmap->uris, uri, -1, (char *)&resdoc, sizeof(RESDOC), TRUE);
    }
  } else {
    resdoc.score = score;
    resdoc.doc = doc;
    resdoc.attrs = attrs;
    resdoc.body = body;
    cbmapput(resmap->uris, uri, -1, (char *)&resdoc, sizeof(RESDOC), FALSE);
  }
  pthread_mutex_unlock(&(resmap->mutex));
}


/* Get a list object of result objects in a result map objects. */
RESDOC **resmap_list(RESMAP *resmap, int *nump){
  RESDOC **resdocs;
  const char *kbuf, *vbuf;
  int i, ksiz;
  assert(resmap && nump);
  if(pthread_mutex_lock(&(resmap->mutex)) != 0){
    *nump = 0;
    return cbmalloc(1);
  }
  *nump = cbmaprnum(resmap->uris);
  resdocs = cbmalloc(*nump * sizeof(RESDOC) + 1);
  cbmapiterinit(resmap->uris);
  for(i = 0; i < *nump; i++){
    kbuf = cbmapiternext(resmap->uris, &ksiz);
    vbuf = cbmapget(resmap->uris, kbuf, ksiz, NULL);
    resdocs[i] = (RESDOC *)vbuf;
  }
  qsort(resdocs, *nump, sizeof(RESDOC *), resdoc_compare);
  pthread_mutex_unlock(&(resmap->mutex));
  return resdocs;
}


/* Be a daemon process. */
int be_daemon(const char *curdir){
#if defined(_SYS_MSVC_) || defined(_SYS_MINGW_)
  PROCESS_INFORMATION pi;
  STARTUPINFO si;
  assert(curdir);
  FreeConsole();
  if(getenv("ESTDAEMON")){
    Sleep(1000);
    if(chdir(curdir) == -1) return FALSE;
  } else {
    putenv("ESTDAEMON=1");
    memset(&si, 0, sizeof(STARTUPINFO));
    si.cb = sizeof(si);
    if(!CreateProcess(NULL, GetCommandLine(), NULL, NULL, FALSE,
                      BELOW_NORMAL_PRIORITY_CLASS | CREATE_NEW_PROCESS_GROUP |
                      CREATE_NO_WINDOW | DETACHED_PROCESS, NULL, NULL, &si, &pi))
      return FALSE;
    CloseHandle(pi.hProcess);
    exit(0);
  }
  return TRUE;
#else
  int fd;
  assert(curdir);
  switch(fork()){
  case -1:
    return FALSE;
  case 0:
    break;
  default:
    exit(1);
  }
  if(setsid() == -1) return FALSE;
  switch(fork()){
  case -1:
    return FALSE;
  case 0:
    break;
  default:
    exit(1);
  }
  umask(0);
  if(chdir(curdir) == -1) return FALSE;
  close(0);
  close(1);
  close(2);
  if((fd = open(NULLDEV, O_RDWR, 0)) != -1){
    dup2(fd, 0);
    dup2(fd, 1);
    dup2(fd, 2);
    if(fd > 2) close(fd);
  }
  nice(5);
  return TRUE;
#endif
}


/*************************************************************************************************
 * private objects
 *************************************************************************************************/


/* Close the log file. */
static void log_close(void){
  if(log_fp) fclose(log_fp);
}


/* Output the log message of a DB event.
   `msg' specifies the log message of a DB event. */
static void db_inform(const char *msg){
  assert(msg);
  log_print(LL_INFO, "DB-EVENT: %s", msg);
}


/* Compare two result document objects by score.
   `ap' specifies the pointer to one object.
   `ap' specifies the pointer to the other object.
   The return value is negative if one is small, positive if one is big, 0 if both are equal. */
static int resdoc_compare(const void *ap, const void *bp){
  assert(ap && bp);
  return (*(RESDOC **)bp)->score - (*(RESDOC **)ap)->score;
}


/* END OF FILE */