odb.cxx

Go to the documentation of this file.

/********************************************************************\
 
  Name:         ODB.C
  Created by:   Stefan Ritt
 
  Contents:     MIDAS online database functions
 
  $Id$
 
\********************************************************************/
 
#undef NDEBUG // midas required assert() to be always enabled
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
#include "midas.h"
#include "msystem.h"
#include "mxml.h"
#include "git-revision.h"
#include "mstrlcpy.h"
#include <assert.h>
#include <signal.h>
#include <math.h>
 
#include <deque>
 
#include "mjson.h"
 
#define CHECK_OPEN_RECORD 1
 
/*------------------------------------------------------------------*/
 
/********************************************************************\
*                                                                    *
*                 db_xxx  -  Database Functions                      *
*                                                                    *
\********************************************************************/
 
/* Globals */
 
#ifdef LOCAL_ROUTINES
static DATABASE *_database;
static INT _database_entries = 0;
#endif
 
static RECORD_LIST *_record_list;
static INT _record_list_entries = 0;
 
static WATCH_LIST *_watch_list;
static INT _watch_list_entries = 0;
 
INT db_save_xml_key(HNDLE hDB, HNDLE hKey, INT level, MXML_WRITER * writer);
 
/*------------------------------------------------------------------*/
 
#ifdef LOCAL_ROUTINES
 
typedef struct db_err_msg_struct db_err_msg;
 
static void db_msg(db_err_msg** msg, INT message_type, const char *filename, INT line, const char *routine, const char *format, ...) MATTRPRINTF(6,7);
static void db_print_msg(const db_err_msg* msg);
static void db_flush_msg(db_err_msg** msg);
 
static bool db_validate_key_offset(const DATABASE_HEADER * pheader, int offset);
static bool db_validate_data_offset(const DATABASE_HEADER * pheader, int offset);
 
static HNDLE db_pkey_to_hkey(const DATABASE_HEADER* pheader, const KEY* pkey);
 
static const KEY* db_get_pkey(  const DATABASE_HEADER* pheader, HNDLE hKey, int* pstatus, const char* caller, db_err_msg **msg);
static const KEY* db_get_parent(const DATABASE_HEADER* pheader, const KEY* pkey, int* pstatus, const char* caller, db_err_msg **msg);
 
static const KEYLIST* db_get_pkeylist(const DATABASE_HEADER* pheader, const KEY* pkey, const char* caller, db_err_msg **msg, bool kludge_repair = false);
 
static INT        db_find_key_locked(const DATABASE_HEADER *pheader, HNDLE hKey, const char *key_name, bool follow_links, HNDLE * subhKey, db_err_msg** msg);
static const KEY* db_find_pkey_locked(const DATABASE_HEADER *pheader, const KEY* pkey, const char *key_name, bool follow_links, int *pstatus, db_err_msg** msg);
 
static std::string db_get_path_locked(const DATABASE_HEADER* pheader, HNDLE hKey);
static std::string db_get_path_pkey(const DATABASE_HEADER* pheader, const KEY *pkey);
 
static int db_scan_tree_locked(const DATABASE_HEADER* pheader, const KEY* pkey, int level, int(*callback) (const DATABASE_HEADER*, const KEY*, int, void*, db_err_msg**), void *info, db_err_msg** msg);
 
static int db_set_mode_wlocked(DATABASE_HEADER*,KEY*,WORD mode,int recurse,db_err_msg**);
static const KEY* db_resolve_link_locked(const DATABASE_HEADER*, const KEY*,int *pstatus, db_err_msg**);
static int db_notify_clients_locked(const DATABASE* pdb, HNDLE hKeyMod, int index, BOOL bWalk, db_err_msg** msg);
static int db_create_key_wlocked(DATABASE_HEADER* pheader, KEY* parentKey, const char *key_name, DWORD type, KEY** pnewkey, db_err_msg** msg);
static int db_delete_key_locked(DATABASE* pdb, const KEY* pkey, int level, db_err_msg** msg);
static int db_set_value_wlocked(DATABASE* pdb, KEY* pkey_root, const char *key_name, const void *data, INT data_size, INT num_values, DWORD type, db_err_msg** msg);
static INT db_get_data_locked(DATABASE_HEADER* pheader, const KEY* pkey, int idx, void *data, INT * buf_size, DWORD type, db_err_msg** msg);
static INT db_set_data_wlocked(DATABASE_HEADER* pheader, KEY* pkey, const void *data, INT data_size, INT num_values, DWORD type, const char* caller, db_err_msg** msg);
static INT db_set_data_index_wlocked(DATABASE_HEADER* pheader, KEY* pkey, int idx, const void *data, INT data_size, DWORD type, const char* caller, db_err_msg** msg);
static INT db_check_set_data_locked(DATABASE_HEADER* pheader, const KEY* pkey, const void *data, INT data_size, INT num_values, DWORD type, const char* caller, db_err_msg** msg);
static INT db_check_set_data_index_locked(DATABASE_HEADER* pheader, const KEY* pkey, int idx, const void *data, INT data_size, DWORD type, const char* caller, db_err_msg** msg);
static int db_remove_open_record_wlocked(DATABASE* pdb, DATABASE_HEADER* pheader, HNDLE hKey);
 
static DATABASE* db_lock_database(HNDLE hDB, int *pstatus, const char* caller, bool check_attached = true);
static void db_unlock_database(DATABASE* pdb, const char* caller);
 
#endif // LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
 
/********************************************************************\
*                                                                    *
*            db_msg_xxx error message handling                       *
*                                                                    *
\********************************************************************/
 
#ifdef LOCAL_ROUTINES
 
struct db_err_msg_struct
{
   db_err_msg *next = NULL;
   int message_type = 0;
   std::string filename;
   int line = 0;
   std::string routine;
   std::string text;
};
 
static db_err_msg* _last_error_message = NULL; // for debuging core dumps
 
void db_print_msg(const db_err_msg* msg)
{
   while (msg != NULL) {
      printf("db_err_msg: %p, next %p, type %d, file \'%s:%d\', function \'%s\': %s\n", msg, msg->next, msg->message_type, msg->filename.c_str(), msg->line, msg->routine.c_str(), msg->text.c_str());
      msg = msg->next;
   }
}
 
void db_msg(db_err_msg** msgp, INT message_type, const char *filename, INT line, const char *routine, const char *format, ...)
{
   if (!msgp)
      return;
   
   va_list argptr;
   char message[1000];
 
   /* print argument list into message */
   va_start(argptr, format);
   vsnprintf(message, sizeof(message)-1, format, argptr);
   va_end(argptr);
   message[sizeof(message)-1] = 0; // ensure string is NUL-terminated
 
   if (strlen(message) >= sizeof(message) - 2) {
      const char* s = "!db_msg too long!";
      memcpy(message + strlen(message) - strlen(s), s, strlen(s));
   }
 
   db_err_msg* msg = new db_err_msg;
 
   msg->next = NULL;
   msg->message_type = message_type;
   msg->filename = filename;
   msg->line = line;
   msg->routine = routine;
   msg->text = message;
 
   _last_error_message = msg;
 
   //printf("new message:\n");
   //db_print_msg(msg);
 
   if (*msgp == NULL) {
      *msgp = msg;
      return;
   }
 
   // append new message to the end of the list
   db_err_msg *m = (*msgp);
   while (m->next != NULL) {
      m = m->next;
   }
   assert(m->next == NULL);
   m->next = msg;
 
   //printf("Message list with added new message:\n");
   //db_print_msg(*msgp);
   return;
}
 
void db_flush_msg(db_err_msg** msgp)
{
   db_err_msg *msg = *msgp;
   *msgp = NULL;
 
   if (/* DISABLES CODE */ (0)) {
      printf("db_flush_msg: %p\n", msg);
      db_print_msg(msg);
   }
 
   while (msg != NULL) {
      cm_msg(msg->message_type, msg->filename.c_str(), msg->line, msg->routine.c_str(), "%s", msg->text.c_str());
      db_err_msg* next = msg->next;
      msg->message_type = 0;
      msg->next = NULL;
      delete msg;
      msg = next;
   }
}
 
#endif // LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
 
#ifdef LOCAL_ROUTINES
 
/********************************************************************\
*                                                                    *
*            Shared Memory Allocation                                *
*                                                                    *
\********************************************************************/
 
/*------------------------------------------------------------------*/
static void *malloc_key(DATABASE_HEADER * pheader, INT size, const char* caller)
{
   // Notes:
   // we allocate objects:
   // KEY     aligned size 72
   // KEYLIST aligned size 16
   // they are not multiples of each other and we need to be
   // careful to avoid 8-byte allocation holes.
   // K.O.
 
   if (size == 0)
      return NULL;
 
   assert(size == sizeof(KEY) || size == sizeof(KEYLIST));
 
   /* quadword alignment for alpha CPU */
   size = ALIGN8(size);
 
   //printf("malloc_key(%d) from [%s]\n", size, caller);
 
   if (!db_validate_key_offset(pheader, pheader->first_free_key)) {
      return NULL;
   }
 
   if (pheader->first_free_key == 0) { // no free blocks!
      return NULL;
   }
 
   /* search for free block */
 
   bool have_good_block = false;
   int pass = 1;
   FREE_DESCRIP* pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key);
   FREE_DESCRIP* pprev = NULL;
 
   while (1) {
      //printf("pfree %p, size %3d, next_free %7d, pprev %p, want %3d, pass %d\n", pfree, pfree->size, pfree->next_free, pprev, size, pass);
 
      if (pfree->size >= size) { // found free block
         have_good_block = true;
         if (pass == 1) {
            // do not use a free block if remaining size is smaller than 16 (aligned size of KEYLIST)
            // because it will become dead space we cannot use for anything. K.O.
            int remaining = pfree->size - size;
            if ((remaining == 0) || (remaining >= (int)ALIGN8(sizeof(KEYLIST))))
               break;
         } else {
            // first pass could not find any free blocks we like,
            // second pass will use whatever fits. K.O.
            break;
         }
      }
 
      if (pfree->next_free == 0) { // last block
         //printf("pfree %p, size %3d, next_free %7d, pprev %p, want %3d, pass %d, out of free blocks, have_good_block %d\n", pfree, pfree->size, pfree->next_free, pprev, size, pass, have_good_block);
         if (pass == 1 && have_good_block) {
            // try again from scratch
            pass = 2;
            pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key);
            pprev = NULL;
            continue;
         }
         return NULL;
      }
 
      if (!db_validate_key_offset(pheader, pfree->next_free)) {
         return NULL;
      }
 
      pprev = pfree;
      pfree = (FREE_DESCRIP *) ((char *) pheader + pfree->next_free);
 
      if (pfree == pprev) {
         // we are in an infinite loop
         return NULL;
      }
   }
 
   //printf("found free block %p size %d, want %d\n", pfree, pfree->size, size);
 
   assert(pfree->size >= size);
 
   FREE_DESCRIP* pfound = pfree;
 
   /* if found block is first in list, correct pheader */
   if (pfree == (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key)) {
      if (size < pfree->size) {
         /* free block is only used partially */
         pheader->first_free_key += size;
         pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key);
 
         pfree->size = pfound->size - size;
         pfree->next_free = pfound->next_free;
      } else {
         /* free block is used totally */
         pheader->first_free_key = pfree->next_free;
      }
   } else {
      /* check if free block is used totally */
      if (pfound->size - size < (int) sizeof(FREE_DESCRIP)) {
         if (pfound->next_free == 0) {
            // we are about to kill the very last free block
            // let's not do it, free_key() cannot recover from this
            // and we lose most of the free space. K.O.
            //printf("found free block %p size %d, want %d, this will kill the last free block\n", pfree, pfree->size, size);
            return NULL;
         }
         /* skip block totally */
         pprev->next_free = pfound->next_free;
      } else {
         /* decrease free block */
         pfree = (FREE_DESCRIP *) ((char *) pfound + size);
 
         pfree->size = pfound->size - size;
         pfree->next_free = pfound->next_free;
 
         pprev->next_free = (POINTER_T) pfree - (POINTER_T) pheader;
      }
   }
 
   assert((void*)pfound != (void*)pheader);
 
   memset(pfound, 0, size);
 
   return pfound;
}
 
/*------------------------------------------------------------------*/
static void free_key(DATABASE_HEADER * pheader, void *address, INT size)
{
   FREE_DESCRIP *pfree, *pprev, *pnext;
 
   if (size == 0)
      return;
 
   assert(address != pheader);
 
   /* quadword alignment for alpha CPU */
   size = ALIGN8(size);
 
   pfree = (FREE_DESCRIP *) address;
   pprev = NULL;
 
   /* clear current block */
   memset(address, 0, size);
 
   /* if key comes before first free block, adjust pheader */
   if ((POINTER_T) address - (POINTER_T) pheader < pheader->first_free_key) {
      pfree->size = size;
      pfree->next_free = pheader->first_free_key;
      pheader->first_free_key = (POINTER_T) address - (POINTER_T) pheader;
   } else {
      /* find last free block before current block */
      pprev = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key);
 
      while (pprev->next_free < (POINTER_T) address - (POINTER_T) pheader) {
         if (pprev->next_free <= 0) {
            cm_msg(MERROR, "free_key", "database is corrupted: pprev=%p, pprev->next_free=%d", pprev, pprev->next_free);
            return;
         }
         pprev = (FREE_DESCRIP *) ((char *) pheader + pprev->next_free);
      }
 
      pfree->size = size;
      pfree->next_free = pprev->next_free;
 
      pprev->next_free = (POINTER_T) pfree - (POINTER_T) pheader;
   }
 
   /* try to melt adjacent free blocks after current block */
   pnext = (FREE_DESCRIP *) ((char *) pheader + pfree->next_free);
   if ((POINTER_T) pnext == (POINTER_T) pfree + pfree->size) {
      pfree->size += pnext->size;
      pfree->next_free = pnext->next_free;
 
      memset(pnext, 0, pnext->size);
   }
 
   /* try to melt adjacent free blocks before current block */
   if (pprev && pprev->next_free == (POINTER_T) pprev - (POINTER_T) pheader + pprev->size) {
      pprev->size += pfree->size;
      pprev->next_free = pfree->next_free;
 
      memset(pfree, 0, pfree->size);
   }
}
 
static int validate_free_data(DATABASE_HEADER * pheader, int free_data)
{
   if (free_data <= 0)
      return 0;
 
   if (free_data < (int)sizeof(DATABASE_HEADER)) {
      //printf("validate_free_data: failed: %d is inside the database header 0..%d\n", free_data, (int)sizeof(DATABASE_HEADER));
      return 0;
   }
 
   if (free_data < (int)sizeof(DATABASE_HEADER) + pheader->key_size) {
      //printf("validate_free_data: failed: %d is inside key space %d..%d\n", free_data, (int)sizeof(DATABASE_HEADER), (int)sizeof(DATABASE_HEADER) + pheader->key_size);
      return 0;
   }
 
   if (free_data > (int)sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size) {
      //printf("validate_free_data: failed: %d is beyound end of odb %d+%d+%d = %d\n", free_data, (int)sizeof(DATABASE_HEADER), pheader->key_size, pheader->data_size, (int)sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size);
      return 0;
   }
 
   return 1;
}
 
/*------------------------------------------------------------------*/
static void *malloc_data(DATABASE_HEADER * pheader, INT size)
{
   if (size == 0)
      return NULL;
 
   assert(size > 0);
 
   /* quadword alignment for alpha CPU */
   size = ALIGN8(size);
 
   /* smallest allocation size is 8 bytes to make sure we can always create a new FREE_DESCRIP in free_data() */
   assert(size >= (int)sizeof(FREE_DESCRIP));
 
   if (!validate_free_data(pheader, pheader->first_free_data)) {
      return NULL;
   }
 
   /* search for free block */
   FREE_DESCRIP *pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_data);
   FREE_DESCRIP *pprev = NULL;
   FREE_DESCRIP *pfound = NULL;
 
   while (1) {
      //printf("malloc_data: pprev %p,  pfree %p, next %d, size %d, want %d\n", pprev, pfree, pfree->next_free, pfree->size, size);
 
      if (pfree->size >= size) {
         // we will use this block
         pfound = pfree;
         break;
      }
 
      if (!pfree->next_free) {
         // no more free blocks
         return NULL;
      }
 
      if (!validate_free_data(pheader, pfree->next_free)) {
         // next_free is invalid
         //printf("malloc_data: pprev %p,  pfree %p, next %d, size %d, next is invalid\n", pprev, pfree, pfree->next_free, pfree->size);
         return NULL;
      }
      pprev = pfree;
      pfree = (FREE_DESCRIP *) ((char *) pheader + pfree->next_free);
 
      if (pfree == pprev) {
         // we are in an infinite loop
         return NULL;
      }
   }
 
   //printf("malloc_data: pprev %p, pfound %p, size %d, want %d\n", pprev, pfound, pfound->size, size);
 
   assert(pfound != NULL);
   assert(size <= pfound->size);
 
   /* if found block is first in list, correct pheader */
   if (!pprev) {
      if (size < pfree->size) {
         /* free block is only used partially */
         pheader->first_free_data += size;
         pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_data);
 
         pfree->size = pfound->size - size;
         pfree->next_free = pfound->next_free;
      } else {
         /* free block is used totally */
         pheader->first_free_data = pfree->next_free;
      }
   } else {
      /* check if free block is used totally */
      if (pfound->size - size < (int) sizeof(FREE_DESCRIP)) {
         /* delete this free block from the free blocks chain */
         pprev->next_free = pfound->next_free;
      } else {
         /* decrease free block */
         pfree = (FREE_DESCRIP *) ((char *) pfound + size);
 
         pfree->size = pfound->size - size;
         pfree->next_free = pfound->next_free;
 
         pprev->next_free = (POINTER_T) pfree - (POINTER_T) pheader;
      }
   }
 
   assert((void*)pfound != (void*)pheader);
 
   /* zero memeory */
   memset(pfound, 0, size);
 
   return pfound;
}
 
/*------------------------------------------------------------------*/
static int free_data(DATABASE_HEADER * pheader, void *address, INT size, const char* caller)
{
   if (size == 0)
      return DB_SUCCESS;
 
   assert(address != pheader);
 
   /* quadword alignment for alpha CPU */
   size = ALIGN8(size);
 
   /* smallest allocation size is 8 bytes to make sure we can always create a new FREE_DESCRIP in free_data() */
   assert(size >= (int)sizeof(FREE_DESCRIP));
 
   FREE_DESCRIP *pprev = NULL;
   FREE_DESCRIP *pfree = (FREE_DESCRIP *) address;
   int pfree_offset = (POINTER_T) address - (POINTER_T) pheader;
 
   /* clear current block */
   memset(address, 0, size);
 
   if (pheader->first_free_data == 0) {
      /* if free list is empty, create the first free block, adjust pheader */
      pfree->size = size;
      pfree->next_free = 0;
      pheader->first_free_data = pfree_offset;
      /* nothing else to do */
      return DB_SUCCESS;
   } else if ((POINTER_T) address - (POINTER_T) pheader < pheader->first_free_data) {
      /* if data comes before first free block, create new free block, adjust pheader */
      pfree->size = size;
      pfree->next_free = pheader->first_free_data;
      pheader->first_free_data = pfree_offset;
      /* maybe merge next free block into the new free block */
      //printf("free_data: created new first free block, maybe merge with old first free block\n");
   } else {
      /* find last free block before current block */
      pprev = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_data);
 
      while (pprev->next_free < pfree_offset) {
         if (pprev->next_free == 0) {
            /* add new free block at the end of the chain of free blocks */
            //printf("free_data: adding new free block at the very end\n");
            break;
         }
         if (!validate_free_data(pheader, pprev->next_free)) {
            cm_msg(MERROR, "free_data", "database is corrupted: pprev=%p, pprev->next_free=%d in free_data(%p,%p,%d) from %s", pprev, pprev->next_free, pheader, address, size, caller);
            return DB_CORRUPTED;
         }
 
         pprev = (FREE_DESCRIP *) ((char *) pheader + pprev->next_free);
      }
 
      pfree->size = size;
      pfree->next_free = pprev->next_free;
 
      pprev->next_free = pfree_offset;
   }
 
   /* try to melt adjacent free blocks after current block */
   FREE_DESCRIP *pnext = (FREE_DESCRIP *) ((char *) pheader + pfree->next_free);
   if ((POINTER_T) pnext == (POINTER_T) pfree + pfree->size) {
      //printf("free_data: merging first and second free block\n");
      pfree->size += pnext->size;
      pfree->next_free = pnext->next_free;
 
      memset(pnext, 0, pnext->size);
   }
 
   /* try to melt adjacent free blocks before current block */
   if (pprev && pprev->next_free == (POINTER_T) pprev - (POINTER_T) pheader + pprev->size) {
      //printf("free_data: merging pprev and pfree\n");
      pprev->size += pfree->size;
      pprev->next_free = pfree->next_free;
 
      memset(pfree, 0, pfree->size);
   }
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
static void *realloc_data(DATABASE_HEADER * pheader, void *address, INT old_size, INT new_size, const char* caller)
{
   void *tmp = NULL;
 
   if (old_size) {
      int status;
      tmp = malloc(old_size);
      if (tmp == NULL) {
         cm_msg(MERROR, "realloc_data", "cannot malloc(%d), called from %s", old_size, caller);
         return NULL;
      }
 
      memcpy(tmp, address, old_size);
 
      status = free_data(pheader, address, old_size, caller);
      if (status != DB_SUCCESS) {
         free(tmp);
         cm_msg(MERROR, "realloc_data", "cannot free_data(%p, %d), called from %s", address, old_size, caller);
         return NULL;
      }
   }
 
   void *pnew = malloc_data(pheader, new_size);
 
   if (!pnew) {
      if (tmp)
         free(tmp);
      cm_msg(MERROR, "realloc_data", "cannot malloc_data(%d), called from %s", new_size, caller);
      return NULL;
   }
 
   if (old_size) {
      memcpy(pnew, tmp, old_size < new_size ? old_size : new_size);
      free(tmp);
   }
 
   return pnew;
}
 
#endif // LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
char *strcomb(const char **list)
/* convert list of strings into single string to be used by db_paste() */
{
   INT i, j;
   static char *str = NULL;
 
   /* counter number of chars */
   for (i = 0, j = 0; list[i]; i++)
      j += strlen(list[i]) + 1;
   j += 1;
 
   if (str == NULL)
      str = (char *) malloc(j);
   else
      str = (char *) realloc(str, j);
 
   assert(str != NULL);
 
   str[0] = 0;
   for (i = 0; list[i]; i++) {
      strcat(str, list[i]);
      strcat(str, "\n");
   }
 
   return str;
}
 
/*------------------------------------------------------------------*/
 
std::string strcomb1(const char **list)
/* convert list of strings into single string to be used by db_paste() */
{
   std::string s;
 
   for (int i = 0; list[i]; i++) {
      s += list[i];
      s += "\n";
   }
 
   return s;
}
 
/*------------------------------------------------------------------*/
 
#ifdef LOCAL_ROUTINES
 
struct keylist_struct {
   int    type  = 0;
   HNDLE  hkey  = 0;
   size_t skey  = 0;
   HNDLE  hdata = 0;
   size_t sdata = 0;
   HNDLE  next_free = 0;
   HNDLE  hsort = 0; // value to sort on
};
 
bool operator<(const keylist_struct& a, const keylist_struct& b) {
   return a.hsort < b.hsort;
}
 
typedef std::vector<keylist_struct> keylist_vector;
 
static bool db_get_key_free_list_locked(const DATABASE_HEADER* pheader, keylist_vector* keyfreelist, db_err_msg **msg)
{
   /* validate the key free list */
 
   keyfreelist->clear();
 
   if (!db_validate_key_offset(pheader, pheader->first_free_key)) {
      db_msg(msg, MERROR, "db_get_key_free_list", "Error: database corruption, invalid pheader->first_free_key %d", pheader->first_free_key);
      return false;
   }
 
   const FREE_DESCRIP* pfree = (const FREE_DESCRIP *) ((const char *) pheader + pheader->first_free_key);
 
   for (int i=0; i<pheader->key_size; i++) { // avoid infinite loop
 
      keylist_struct ks;
      ks.hkey = (char*)pfree - (char*)pheader;
      ks.skey = pfree->size;
      ks.next_free = pfree->next_free;
      keyfreelist->push_back(ks);
 
      if (pfree->next_free == 0) { // end of free list
         return true;
      }
 
      if (!db_validate_key_offset(pheader, pfree->next_free)) {
         db_msg(msg, MERROR, "db_get_key_free_list", "Error: database corruption, invalid pfree->next_free %d", pfree->next_free);
         return false;
      }
 
      pfree = (const FREE_DESCRIP *) ((const char *) pheader + pfree->next_free);
   }
 
   db_msg(msg, MERROR, "db_get_key_free_list", "Error: database corruption, free list is too long: %zu", keyfreelist->size());
 
   return false;
}
 
static bool db_get_data_free_list_locked(const DATABASE_HEADER* pheader, keylist_vector* datafreelist, db_err_msg **msg)
{
   /* validate the data free list */
 
   datafreelist->clear();
 
   if (!db_validate_data_offset(pheader, pheader->first_free_data)) {
      db_msg(msg, MERROR, "db_get_data_free_list", "Error: database corruption, invalid pheader->first_free_data %d", pheader->first_free_data);
      return false;
   }
 
   const FREE_DESCRIP* pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_data);
 
   for (int i=0; i<pheader->data_size; i++) { // avoid infinite loop
 
      keylist_struct ks;
      ks.hdata = (char*)pfree - (char*)pheader;
      ks.sdata = pfree->size;
      ks.next_free = pfree->next_free;
      datafreelist->push_back(ks);
 
      if (pfree->next_free == 0) { // end of free list
         return true;
      }
 
      if (!db_validate_data_offset(pheader, pfree->next_free)) {
         db_msg(msg, MERROR, "db_get_key_free_list", "Error: database corruption, invalid pfree->next_free %d", pfree->next_free);
         return false;
      }
 
      pfree = (const FREE_DESCRIP *) ((const char *) pheader + pfree->next_free);
   }
 
   db_msg(msg, MERROR, "db_get_data_free_list", "Error: database corruption, free list is too long: %zu", datafreelist->size());
 
   return false;
}
 
static INT print_key_info_locked(const DATABASE_HEADER* pheader, const KEY* pkey, INT level, void *info, db_err_msg**msg)
{
   std::string* pbuf = (std::string*)info;
 
   HNDLE hKey = db_pkey_to_hkey(pheader, pkey);
 
   *pbuf += msprintf("%9d %9d %9d   ",
           (int) (hKey - sizeof(DATABASE_HEADER)),
           (int) (pkey->data - sizeof(DATABASE_HEADER)), (int) pkey->total_size);
 
   for (int i = 0; i < level; i++)
      *pbuf += "  ";
 
   *pbuf += pkey->name;
   *pbuf += "\n";
 
   return SUCCESS;
}
 
std::string db_show_mem(HNDLE hDB, BOOL verbose)
{
   std::string buf;
 
   bool flag;
   int status;
 
   DATABASE* pdb = db_lock_database(hDB, &status, "db_show_mem");
 
   if (!pdb)
      return "(Cannot lock ODB)";
 
   db_err_msg *msg = NULL;
 
   const DATABASE_HEADER *pheader = pdb->database_header;
 
   size_t odb_key_start = sizeof(DATABASE_HEADER);
   size_t odb_key_end   = sizeof(DATABASE_HEADER) + pheader->key_size;
 
   size_t odb_data_start = odb_key_end;
   size_t odb_data_end   = odb_data_start + pheader->data_size;
 
   buf += msprintf("Database header: %9d - %9zu, size %9zu bytes\n", 0, sizeof(DATABASE_HEADER), sizeof(DATABASE_HEADER));
   buf += msprintf("Key area:        %9zu - %9zu, size %9d bytes\n",  odb_key_start, odb_key_end, pheader->key_size);
   buf += msprintf("Data area:       %9zu - %9zu, size %9d bytes\n", odb_data_start, odb_data_end, pheader->data_size);
   buf += "\n";
   buf += "Key free list:\n";
   buf += "--------\n";
 
   keylist_vector keyfreelist;
 
   flag = db_get_key_free_list_locked(pheader, &keyfreelist, &msg);
 
   size_t total_size_key = 0;
 
   if (!flag) {
      buf += "ODB key free list is corrupted, see messages!\n\n";
   }
 
   for (size_t i=0; i<keyfreelist.size(); i++) {
      buf += msprintf("Free block %3zu at %9d, size %9zu, next %9d\n",
                      i,
                      keyfreelist[i].hkey,
                      keyfreelist[i].skey,
                      keyfreelist[i].next_free);
      total_size_key += keyfreelist[i].skey;
   }
 
   buf += "\n";
   buf += msprintf("Free Key area: %zu bytes out of %d bytes\n", total_size_key, pheader->key_size);
   buf += "\n";
   buf += "Data free list:\n";
   buf += "-----\n";
 
   keylist_vector datafreelist;
 
   flag = db_get_data_free_list_locked(pheader, &datafreelist, &msg);
 
   size_t total_size_data = 0;
   size_t biggest_size_data = 0;
 
   if (!flag) {
      buf += "ODB data free list is corrupted, see messages!\n\n";
   }
 
   for (size_t i=0; i<datafreelist.size(); i++) {
      buf += msprintf("Free block %3zu at %9d, size %9zu, next %9d\n",
                      i,
                      datafreelist[i].hdata,
                      datafreelist[i].sdata,
                      datafreelist[i].next_free);
      total_size_data += datafreelist[i].sdata;
      if (datafreelist[i].sdata > biggest_size_data)
         biggest_size_data = datafreelist[i].sdata;
   }
 
   buf += "\n";
   buf += msprintf("Free Data area: %zu bytes out of %d bytes\n", total_size_data, pheader->data_size);
   buf += "\n";
   buf += msprintf("Biggest Data area free block: %zu bytes\n", biggest_size_data);
   buf += "\n";
   buf += msprintf("Free: %zu (%1.1lf%%) keylist, %zu (%1.1lf%%) data\n",
           total_size_key,
           100 * (double) total_size_key / pheader->key_size,
           total_size_data, 100 * (double) total_size_data / pheader->data_size);
 
   if (verbose) {
      const KEY* proot = db_get_pkey(pheader, 0, 0, "db_show_mem", &msg);
 
      if (proot) {
         buf += "\n";
         buf += "\n";
         buf += "      Key      Data      Size\n";
         buf += "-----------------------------\n";
         db_scan_tree_locked(pheader, proot, 0, print_key_info_locked, &buf, &msg);
         buf += "-----------------------------\n";
         buf += "      Key      Data      Size\n";
      }
   }
 
   buf += "\n";
   buf += msprintf("Total ODB size: %d (0x%08X) Bytes, %lg MBytes\n",
           pheader->key_size + pheader->data_size, pheader->key_size + pheader->data_size,
           ((pheader->key_size + pheader->data_size) / 1E6));
 
   db_unlock_database(pdb, "db_show_mem");
 
   if (msg)
      db_flush_msg(&msg);
 
   return buf;
}
 
INT db_get_free_mem(HNDLE hDB, size_t *pkey_size, size_t *pdata_size, size_t *pdata_biggest)
{
   bool flag = true;
 
   *pkey_size = 0;
   *pdata_size = 0;
   *pdata_biggest = 0;
 
   int status = 0;
 
   DATABASE* pdb = db_lock_database(hDB, &status, "db_get_free_mem");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const DATABASE_HEADER* pheader = pdb->database_header;
   
   keylist_vector keyfreelist;
 
   flag &= db_get_key_free_list_locked(pheader, &keyfreelist, &msg);
 
   for (const auto e : keyfreelist) {
      *pkey_size += e.skey;
   }
 
   keylist_vector datafreelist;
 
   flag &= db_get_data_free_list_locked(pheader, &datafreelist, &msg);
 
   for (const auto e : datafreelist) {
      *pdata_size += e.sdata;
      if (e.sdata > *pdata_biggest)
         *pdata_biggest = e.sdata;
   }
 
   db_unlock_database(pdb, "db_get_free_mem");
 
   if (msg)
      db_flush_msg(&msg);
 
   if (!flag)
      return DB_CORRUPTED;
 
   return DB_SUCCESS;
}
 
#endif // LOCAL_ROUTINES
 
// Method to check if a given string is valid UTF-8.  Returns 1 if it is.
// This method was taken from stackoverflow user Christoph, specifically
// http://stackoverflow.com/questions/1031645/how-to-detect-utf-8-in-plain-c
static bool is_utf8(const char * string)
{
   if (!string)
      return false;
 
   return ss_is_valid_utf8(string);
}
 
#ifdef LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
static int db_validate_name(const char* name, int maybe_path, const char* caller_name, db_err_msg** msg)
{
   //printf("db_validate_name [%s] length %d, maybe_path %d from %s\n", name, (int)strlen(name), maybe_path, caller_name);
 
   if (name == NULL) {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name passed to %s: should not be NULL", caller_name);
      return DB_INVALID_NAME;
   }
 
   size_t len = strlen(name);
 
   if (len < 1) {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name passed to %s: should not be an empty string", caller_name);
      return DB_INVALID_NAME;
   }
 
   if (strchr(name, '[')) {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: should not contain \"[\"", name, caller_name);
      return DB_INVALID_NAME;
   }
   
   if (name[0] == ' ') {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: should not start with a space", name, caller_name);
      return DB_INVALID_NAME;
   }
 
   if (name[len-1] == ' ') {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: should not end with a space", name, caller_name);
      return DB_INVALID_NAME;
   }
 
   if (strchr(name, ']')) {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: should not contain \"[\"", name, caller_name);
      return DB_INVALID_NAME;
   }
   
   if (!is_utf8(name)) {
      db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: invalid unicode UTF-8 encoding", name, caller_name);
      return DB_INVALID_NAME;
   }
   
   if (!maybe_path) {
      if (strchr(name, '/')) {
         db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: should not contain \"/\"", name, caller_name);
         return DB_INVALID_NAME;
      }
 
      if (strlen(name) >= NAME_LENGTH) {
         db_msg(msg, MERROR, "db_validate_name", "Invalid name \"%s\" passed to %s: length %d should be less than %d bytes", name, caller_name, (int)strlen(name), NAME_LENGTH);
         return DB_INVALID_NAME;
      }
   }
 
   //if (strcmp(name, "test")==0)
   //return DB_INVALID_NAME;
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
static bool db_validate_key_offset(const DATABASE_HEADER * pheader, int offset)
/* check if key offset lies in valid range */
{
   if (offset != 0 && offset < (int) sizeof(DATABASE_HEADER))
      return false;
 
   if (offset > (int) sizeof(DATABASE_HEADER) + pheader->key_size)
      return false;
 
   return true;
}
 
static bool db_validate_data_offset(const DATABASE_HEADER * pheader, int offset)
/* check if data offset lies in valid range */
{
   if (offset != 0 && offset < (int) sizeof(DATABASE_HEADER))
      return false;
 
   if (offset > (int) sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size)
      return false;
 
   return true;
}
 
static bool db_validate_hkey(const DATABASE_HEADER * pheader, HNDLE hKey)
{
   if (hKey == 0) {
      cm_msg(MERROR, "db_validate_hkey", "Error: invalid zero hkey %d", hKey);
      return false;
   }
   if (!db_validate_key_offset(pheader, hKey)) {
      cm_msg(MERROR, "db_validate_hkey", "Error: invalid hkey %d", hKey);
      return false;
   }
   return true;
}
 
static const KEY* db_get_pkey(const DATABASE_HEADER* pheader, HNDLE hKey, int* pstatus, const char* caller, db_err_msg **msg)
{
   BOOL hKey_is_root_key = FALSE;
 
   if (!hKey) {
      hKey_is_root_key = TRUE;
      hKey = pheader->root_key;
   }
 
   /* check if hKey argument is correct */
   if (hKey == 0) {
      if (pstatus)
         *pstatus = DB_INVALID_HANDLE;
      return NULL;
   }
 
   /* check if hKey argument is correct */
   if (!db_validate_key_offset(pheader, hKey)) {
      if (pstatus)
         *pstatus = DB_INVALID_HANDLE;
      return NULL;
   }
 
   const KEY* pkey = (const KEY *) ((char *) pheader + hKey);
 
   if (pkey->type < 1 || pkey->type >= TID_LAST) {
      DWORD tid = pkey->type;
      if (hKey_is_root_key) {
         db_msg(msg, MERROR, caller, "db_get_pkey: root_key hkey %d invalid key type %d, database root directory is corrupted", hKey, tid);
         if (pstatus)
            *pstatus = DB_CORRUPTED;
         return NULL;
      } else {
         std::string path = db_get_path_pkey(pheader, pkey);
         db_msg(msg, MERROR, caller, "db_get_pkey: hkey %d path \"%s\" invalid key type %d", hKey, path.c_str(), tid);
      }
      if (pstatus)
         *pstatus = DB_NO_KEY;
      return NULL;
   }
 
   if (pkey->name[0] == 0) {
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, caller, "db_get_pkey: hkey %d path \"%s\" invalid name \"%s\" is empty", hKey, path.c_str(), pkey->name);
      if (pstatus)
         *pstatus = DB_NO_KEY;
      return NULL;
   }
 
   return pkey;
}
 
static const KEYLIST* db_get_pkeylist(const DATABASE_HEADER* pheader, const KEY* pkey, const char* caller, db_err_msg **msg, bool kludge_repair)
{
   if (pkey->type != TID_KEY) {
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, caller, "db_get_pkeylist: path \"%s\" unexpected call to db_get_pkeylist(), not a subdirectory, pkey->type %d", path.c_str(), pkey->type);
      return NULL;
   }
 
   if (!db_validate_data_offset(pheader, pkey->data)) {
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, caller, "Invalid pkey->data %d at path \"%s\"", pkey->data, path.c_str());
      return NULL;
   }
 
   const KEYLIST *pkeylist = (const KEYLIST *) ((char *) pheader + pkey->data);
 
   if (pkeylist->parent != db_pkey_to_hkey(pheader, pkey)) {
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, caller, "Invalid pkeylist->parent %d should be hkey %d at \"%s\"", pkeylist->parent, db_pkey_to_hkey(pheader, pkey), path.c_str());
      return NULL;
   }
 
   if (pkeylist->first_key == 0 && pkeylist->num_keys != 0) {
      if (!kludge_repair) {
         std::string path = db_get_path_pkey(pheader, pkey);
         db_msg(msg, MERROR, caller, "Invalid pkeylist->first_key %d should be non zero for num_keys %d at \"%s\"", pkeylist->first_key, pkeylist->num_keys, path.c_str());
         return NULL;
      }
 
      // FIXME: this repair should be done in db_validate_and_repair_key()
 
      // FIXME: this will crash if ODB is write-protected.
 
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, caller, "Repaired invalid num_keys %d when pkeylist->first_key is zero at \"%s\"", pkeylist->num_keys, path.c_str());
      ((KEYLIST*)pkeylist)->num_keys = 0;
   }
 
   return pkeylist;
}
 
static HNDLE db_pkey_to_hkey(const DATABASE_HEADER* pheader, const KEY* pkey)
{
   return (POINTER_T) pkey - (POINTER_T) pheader;
}
 
static const KEY* db_get_parent(const DATABASE_HEADER* pheader, const KEY* pkey, int* pstatus, const char* caller, db_err_msg **msg)
{
   if (pkey->parent_keylist == 0) {
      // they asked for the parent of "/", return "/"
      return db_get_pkey(pheader, pheader->root_key, pstatus, caller, msg);
   }
 
   if (!db_validate_data_offset(pheader, pkey->parent_keylist)) {
      db_msg(msg, MERROR, caller, "hkey %d path \"%s\" invalid pkey->parent %d", db_pkey_to_hkey(pheader, pkey), db_get_path_pkey(pheader, pkey).c_str(), pkey->parent_keylist);
      if (pstatus)
         *pstatus = DB_CORRUPTED;
      return NULL;
   }
 
   const KEYLIST *pkeylist = (const KEYLIST *) ((char *) pheader + pkey->parent_keylist);
 
   if (pkeylist->first_key == 0 && pkeylist->num_keys != 0) {
      db_msg(msg, MERROR, caller, "hkey %d path \"%s\" invalid parent pkeylist->first_key %d should be non zero for num_keys %d", db_pkey_to_hkey(pheader, pkey), db_get_path_pkey(pheader, pkey).c_str(), pkeylist->first_key, pkeylist->num_keys);
      if (pstatus)
         *pstatus = DB_CORRUPTED;
      return NULL;
   }
 
   return db_get_pkey(pheader, pkeylist->parent, pstatus, caller, msg);
}
 
static const KEY* db_enum_first_locked(const DATABASE_HEADER *pheader, const KEY* pkey, db_err_msg **msg)
{
   if (pkey->type != TID_KEY) {
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, "db_enum_first_locked", "path \"%s\" tid %d is not a directory", path.c_str(), pkey->type);
      return NULL;
   }
   
   const KEYLIST *pkeylist = db_get_pkeylist(pheader, pkey, "db_enum_first_locked", msg);
 
   if (!pkeylist) {
      // error
      return NULL;
   }
 
   if (pkeylist->num_keys == 0) {
      // empty directory
      return NULL;
   }
 
   if (pkeylist->first_key == 0) {
      // empty directory
      return NULL;
   }
 
   return db_get_pkey(pheader, pkeylist->first_key, NULL, "db_enum_first_locked", msg);
}
 
static const KEY* db_enum_next_locked(const DATABASE_HEADER *pheader, const KEY* pdir, const KEY* pkey, db_err_msg **msg)
{
   if (pkey->next_key == 0)
      return NULL;
   
   return db_get_pkey(pheader, pkey->next_key, NULL, "db_enum_next_locked", msg);
}
 
static const KEY* db_resolve_link_locked(const DATABASE_HEADER* pheader, const KEY* pkey, int* pstatus, db_err_msg** msg)
{
   if (pkey->type != TID_LINK)
      return pkey;
 
   if (!db_validate_data_offset(pheader, pkey->data)) {
      db_msg(msg, MERROR, "db_resolve_link_locked", "invalid data offset %d for symlink \"%s\"", pkey->data, db_get_path_pkey(pheader, pkey).c_str());
      if (pstatus)
         *pstatus = DB_CORRUPTED;
      return NULL;
   }
 
   if (*((char *) pheader + pkey->data) == '/') {
      return db_find_pkey_locked(pheader, NULL, (char*)pheader + pkey->data, true, pstatus, msg);
   } else {
      return db_find_pkey_locked(pheader, pkey, (char*)pheader + pkey->data, true, pstatus, msg);
   }
}
 
static void db_print_pkey(const DATABASE_HEADER * pheader, const KEY* pkey, int recurse = 0, const char *path = NULL, HNDLE parenthkeylist = 0)
{
   HNDLE hkey = db_pkey_to_hkey(pheader, pkey);
 
   std::string xpath;
   if (path == NULL) {
      xpath = db_get_path_pkey(pheader, pkey);
      path = xpath.c_str();
   }
 
   printf("path \"%s\", parenthkey %d, hkey %d, name \"%s\", type %d, parent %d, data %d, total_size %d", path, parenthkeylist, hkey, pkey->name, pkey->type, pkey->parent_keylist, pkey->data, pkey->total_size);
 
   if (pkey->type != TID_KEY) {
      printf("\n");
   } else {
      const KEYLIST *pkeylist = db_get_pkeylist(pheader, pkey, "db_validate_key", NULL);
 
      if (pkeylist) {
         printf(", pkeylist parent %d, num_keys %d, first_key %d", pkeylist->parent, pkeylist->num_keys, pkeylist->first_key);
         printf("\n");
      }
   }
}
 
static void db_print_hkey(const DATABASE_HEADER * pheader, HNDLE hkey, int recurse = 0, const char *path = NULL, HNDLE parenthkeylist = 0)
{
   const KEY *pkey = db_get_pkey(pheader, hkey, NULL, "db_print_key", NULL);
 
   if (!pkey) {
      return;
   }
 
   db_print_pkey(pheader, pkey, recurse, path, parenthkeylist);
}
 
static bool db_validate_and_repair_key_wlocked(DATABASE_HEADER * pheader, int recurse, const char *path, HNDLE parenthkeylist, HNDLE hkey, KEY * pkey, db_err_msg **msg, keylist_vector* keylist)
{
   int status;
   bool flag = true;
 
   if (recurse >= MAX_ODB_PATH) {
      db_msg(msg, MERROR, "db_validate_and_repair_key_wlocked", "Max ODB depth level %d exceeded at \"%s\"", MAX_ODB_PATH, path);
      return true;
   }
 
   //printf("path \"%s\", parenthkey %d, hkey %d, pkey->name \"%s\", type %d\n", path, parenthkeylist, hkey, pkey->name, pkey->type);
 
   //std::string xpath = db_get_path_locked(pheader, hkey);
   //if (xpath != path)
   //   printf("hkey %d, path \"%s\" vs \"%s\"\n", hkey, path, xpath.c_str());
 
   //db_print_key(pheader, 0, path, parenthkeylist, hkey);
 
   if (hkey==0 || !db_validate_key_offset(pheader, hkey)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid hkey", hkey, path);
      return false;
   }
 
   /* check key type */
   if (pkey->type <= 0 || pkey->type >= TID_LAST) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", name \"%s\", invalid key type %d", hkey, path, pkey->name, pkey->type);
      return false;
   }
 
   /* check key name */
   status = db_validate_name(pkey->name, FALSE, "db_validate_key", msg);
   if (status != DB_SUCCESS) {
      char newname[NAME_LENGTH];
      sprintf(newname, "%p", pkey);
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\": invalid name \"%s\" replaced with \"%s\"", hkey, path, pkey->name, newname);
      mstrlcpy(pkey->name, newname, sizeof(pkey->name));
      flag = false;
      //return false;
   }
 
   /* check parent */
   if (pkey->parent_keylist != parenthkeylist) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", name \"%s\", invalid parent_keylist %d should be %d", hkey, path, pkey->name, pkey->parent_keylist, parenthkeylist);
      return false;
   }
 
   if (!db_validate_data_offset(pheader, pkey->data)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid data offset 0x%08X is invalid", hkey, path, pkey->data - (int)sizeof(DATABASE_HEADER));
      return false;
   }
 
   /* check key sizes */
   if ((pkey->total_size < 0) || (pkey->total_size > pheader->data_size)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->total_size %d", hkey, path, pkey->total_size);
      return false;
   }
 
   if ((pkey->item_size < 0) || (pkey->item_size > pheader->data_size)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->item_size: %d", hkey, path, pkey->item_size);
      return false;
   }
 
   if ((pkey->num_values < 0) || (pkey->num_values > pheader->data_size)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->num_values: %d", hkey, path, pkey->num_values);
      return false;
   }
 
   /* check and correct key size */
   if (pkey->total_size != pkey->item_size * pkey->num_values) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", corrected pkey->total_size from %d to %d*%d=%d", hkey, path, pkey->total_size, pkey->item_size, pkey->num_values, pkey->item_size * pkey->num_values);
      pkey->total_size = pkey->item_size * pkey->num_values;
      flag = false;
   }
 
   /* check and correct key size */
   if (pkey->data == 0 && pkey->total_size != 0) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", pkey->data is zero, corrected pkey->num_values %d and pkey->total_size %d to be zero, should be zero", hkey, path, pkey->num_values, pkey->total_size);
      pkey->num_values = 0;
      pkey->total_size = 0;
      flag = false;
   }
 
   if (pkey->type == TID_STRING || pkey->type == TID_LINK) {
      const char* s = (char*)pheader + pkey->data;
      if (!is_utf8(s)) {
         db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\" is not a valid UTF-8 Unicode string", hkey, path);
         //flag = false;
      }
   }
 
   /* check link */
   if (pkey->type == TID_LINK) {
      bool good_link = true;
 
      if (good_link) {
         /* check for empty link */
         // minimum symlink length is 3 bytes:
         // one byte "/"
         // one byte odb entry name
         // one byte "\0"
         if (pkey->total_size <= 2) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_LINK is an empty link", hkey, path);
            flag = false;
            good_link = false;
            //return false;
         }
      }
 
      if (good_link) {
         /* check for too long link */
         if (pkey->total_size >= MAX_ODB_PATH) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_LINK length %d exceeds MAX_ODB_PATH %d", hkey, path, pkey->total_size, MAX_ODB_PATH);
            flag = false;
            good_link = false;
            //return false;
         }
      }
 
      if (good_link) {
         /* check for link loop */
 
         const char* link = (char*)pheader + pkey->data;
         size_t link_len = strlen(link);
         
         if (link_len <= 2) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_LINK is an empty link", hkey, path);
            flag = false;
            good_link = false;
            //return false;
         } else {
            size_t path_len = strlen(path);
            if (link_len == path_len) {
               // check for link to itself
               if (equal_ustring(link, path)) {
                  db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_LINK to \"%s\" is a link to itself", hkey, path, link);
                  flag = false;
                  good_link = false;
                  //return false;
               }
            } else if (link_len < path_len) {
               // check for link to the "path" subdirectory
               char tmp[MAX_ODB_PATH];
               memcpy(tmp, path, link_len);
               tmp[link_len] = 0;
               if (equal_ustring(link, tmp) && path[link_len] == DIR_SEPARATOR) {
                  db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_LINK to \"%s\" is a loop", hkey, path, link);
                  flag = false;
                  good_link = false;
                  //return false;
               }
            }
         }
      }
   }
 
   /* check access mode */
   if ((pkey->access_mode & ~(MODE_READ | MODE_WRITE | MODE_DELETE | MODE_EXCLUSIVE | MODE_ALLOC))) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->access_mode %d", hkey, path, pkey->access_mode);
      flag = false;
      //return false;
   }
 
   /* check if access time is in the future */
   if (pkey->last_written > 0 && ((DWORD)pkey->last_written > ss_time() + 3600)) {
      db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->last_written time %d", hkey, path, pkey->last_written);
      flag = false;
      //return false;
   }
 
   if (keylist) {
      if (pkey->type != TID_KEY) {
         keylist_struct kv;
         kv.type  = pkey->type;
         kv.hkey  = hkey;
         kv.skey  = sizeof(*pkey);
         kv.hdata = pkey->data;
         kv.sdata = pkey->total_size;
         keylist->push_back(kv);
      } else {
         keylist_struct kv1;
         kv1.type  = pkey->type;
         kv1.hkey  = hkey;
         kv1.skey  = sizeof(*pkey);
         kv1.hdata = 0;
         kv1.sdata = 0;
         keylist->push_back(kv1);
 
         keylist_struct kv2;
         kv2.type  = 0;
         kv2.hkey  = pkey->data;
         kv2.skey  = pkey->total_size;
         kv2.hdata = 0;
         kv2.sdata = 0;
         keylist->push_back(kv2);
      }
   }
 
   if (pkey->type == TID_KEY) {
      bool pkeylist_ok = true;
      // FIXME: notice the kludged repair of pkeylist! K.O.
      const KEYLIST *pkeylist = db_get_pkeylist(pheader, pkey, "db_validate_key", msg, true);
 
      if (!pkeylist) {
         db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", invalid pkey->data %d", hkey, path, pkey->data);
         flag = false;
      } else {
         if (pkeylist->parent != hkey) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_KEY invalid pkeylist->parent %d is not hkey %d", hkey, path, pkeylist->parent, hkey);
            flag = false;
            pkeylist_ok = false;
         }
 
         if (pkeylist->num_keys < 0 || pkeylist->num_keys > pheader->key_size) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_KEY invalid pkeylist->num_keys %d", hkey, path, pkeylist->num_keys);
            flag = false;
            pkeylist_ok = false;
         }
         
         if (pkeylist->num_keys == 0 && pkeylist->first_key == 0) {
            // empty key
         } else if (pkeylist->first_key == 0 || !db_validate_key_offset(pheader, pkeylist->first_key)) {
            db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_KEY invalid pkeylist->first_key %d", hkey, path, pkeylist->first_key);
            flag = false;
            pkeylist_ok = false;
         }
         
         if (pkeylist_ok) {
            //printf("hkey %d, path \"%s\", pkey->data %d, pkeylist parent %d, num_keys %d, first_key %d: ", hkey, path, pkey->data, pkeylist->parent, pkeylist->num_keys, pkeylist->first_key);
            
            HNDLE subhkey = pkeylist->first_key;
 
            int count = 0;
            while (subhkey != 0) {
               KEY* subpkey = (KEY*)db_get_pkey(pheader, subhkey, NULL, "db_validate_key", msg);
               if (!subpkey) {
                  db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", TID_KEY invalid subhkey %d", hkey, path, subhkey);
                  pkeylist_ok = false;
                  flag = false;
                  break;
               }
 
               std::string buf;
               buf += path;
               buf += "/";
               buf += subpkey->name;
               
               //printf("pkey %p, next %d, name [%s], path %s\n", subpkey, subpkey->next_key, subpkey->name, buf.c_str());
               
               if (recurse) {
                  flag &= db_validate_and_repair_key_wlocked(pheader, recurse + 1, buf.c_str(), pkey->data, subhkey, subpkey, msg, keylist);
               }
 
               count++;
               subhkey = subpkey->next_key;
            }
 
            if (count != pkeylist->num_keys) {
               db_msg(msg, MERROR, "db_validate_key", "hkey %d, path \"%s\", repaired TID_KEY mismatch of pkeylist->num_keys %d against key chain length %d", hkey, path, pkeylist->num_keys, count);
               ((KEYLIST*)pkeylist)->num_keys = count;
               flag = false;
               pkeylist_ok = false;
            }
         }
      }
   }
 
   return flag;
}
 
/*------------------------------------------------------------------*/
 
DATABASE_CLIENT* db_get_my_client_locked(DATABASE* pdb)
{
   assert(pdb);
   assert(pdb->database_header);
 
   DATABASE_HEADER *pheader = pdb->database_header;
 
   int idx = pdb->client_index;
 
   if (idx < 0 || idx >= pheader->max_client_index || idx >= MAX_CLIENTS) {
      cm_msg(MERROR, "db_get_my_client_locked", "My client index %d in ODB is invalid: out of range 0..%d. Maybe this client was removed by a timeout, see midas.log. Cannot continue, aborting...", idx, pheader->max_client_index-1);
      ss_semaphore_release(pdb->semaphore);
      abort();
   }
 
   DATABASE_CLIENT* pclient = &pheader->client[idx]; // safe to dereference on "idx"
 
   if (pclient->name[0] == 0) {
      cm_msg(MERROR, "db_get_my_client_locked", "My client index %d in ODB is invalid: client name is blank. Maybe this client was removed by a timeout, see midas.log. Cannot continue, aborting...", idx);
      ss_semaphore_release(pdb->semaphore);
      abort();
   }
 
   int pid = getpid();
 
   if (pclient->pid != pid) {
      cm_msg(MERROR, "db_get_my_client_locked", "My client index %d in ODB is invalid: pid mismatch, my pid is %d, but ODB has %d. Maybe this client was removed by a timeout, see midas.log. Cannot continue, aborting...", idx, pid, pclient->pid);
      ss_semaphore_release(pdb->semaphore);
      abort();
   }
 
   //printf("db_get_my_client_locked: idx %d, name [%s], pid %d\n", idx, pclient->name, pid);
 
   //if (strcmp(pclient->name, "mdump") == 0) {
   //   ss_semaphore_release(pdb->semaphore);
   //   for (int i=0; i<15; i++) {
   //      printf("sleep %d\n", i);
   //      ::sleep(1);
   //   }
   //   abort();
   //}
   
   return pclient;
}
 
/*------------------------------------------------------------------*/
static void db_validate_sizes()
{
   /* validate size of data structures (miscompiled, 32/64 bit mismatch, etc */
 
   if (0) {
#define S(x) printf("assert(sizeof(%-20s) == %6d);\n", #x, (int)sizeof(x))
      // basic data types
      S(char *);
      S(char);
      S(int);
      S(long int);
      S(float);
      S(double);
      S(BOOL);
      S(WORD);
      S(DWORD);
      S(INT);
      S(POINTER_T);
      S(midas_thread_t);
      // data buffers
      S(EVENT_REQUEST);
      S(BUFFER_CLIENT);
      S(BUFFER_HEADER);
      // history files
      S(HIST_RECORD);
      S(DEF_RECORD);
      S(INDEX_RECORD);
      S(TAG);
      // ODB shared memory structures
      S(KEY);
      S(KEYLIST);
      S(OPEN_RECORD);
      S(DATABASE_CLIENT);
      S(DATABASE_HEADER);
      // misc structures
      S(EVENT_HEADER);
      S(RUNINFO);
      S(EQUIPMENT_INFO);
      S(EQUIPMENT_STATS);
      S(BANK_HEADER);
      S(BANK);
      S(BANK32);
      S(ANA_OUTPUT_INFO);
      S(PROGRAM_INFO);
      S(ALARM_CLASS);
      S(ALARM);
      //S(CHN_SETTINGS);
      //S(CHN_STATISTICS);
#undef S
   }
 
#if 0
   EQUIPMENT_INFO eq;
   printf("EQUIPMENT_INFO offset of event_id: %d\n", (int)((char*)&eq.event_id - (char*)&eq));
   printf("EQUIPMENT_INFO offset of eq_type: %d\n", (int)((char*)&eq.eq_type - (char*)&eq));
   printf("EQUIPMENT_INFO offset of event_limit: %d\n", (int)((char*)&eq.event_limit - (char*)&eq));
   printf("EQUIPMENT_INFO offset of num_subevents: %d\n", (int)((char*)&eq.num_subevents - (char*)&eq));
   printf("EQUIPMENT_INFO offset of status: %d\n", (int)((char*)&eq.status - (char*)&eq));
   printf("EQUIPMENT_INFO offset of hidden: %d\n", (int)((char*)&eq.hidden - (char*)&eq));
#endif
 
   assert(sizeof(UINT8)  == 1);
   assert(sizeof(INT8)   == 1);
   assert(sizeof(UINT16) == 2);
   assert(sizeof(INT16)  == 2);
   assert(sizeof(UINT32) == 4);
   assert(sizeof(INT32)  == 4);
   assert(sizeof(UINT64) == 8);
   assert(sizeof(INT64)  == 8);
   
#ifdef OS_LINUX
   assert(sizeof(EVENT_REQUEST) == 16); // ODB v3
   assert(sizeof(BUFFER_CLIENT) == 256);
   assert(sizeof(BUFFER_HEADER) == 16444);
   assert(sizeof(HIST_RECORD) == 20);
   assert(sizeof(DEF_RECORD) == 40);
   assert(sizeof(INDEX_RECORD) == 12);
   assert(sizeof(TAG) == 40);
   assert(sizeof(KEY) == 68);
   assert(sizeof(KEYLIST) == 12);
   assert(sizeof(OPEN_RECORD) == 8);
   assert(sizeof(DATABASE_CLIENT) == 2112);
   assert(sizeof(DATABASE_HEADER) == 135232);
   assert(sizeof(EVENT_HEADER) == 16);
   //assert(sizeof(EQUIPMENT_INFO) == 696); has been moved to dynamic checking inside mhttpd.c
   assert(sizeof(EQUIPMENT_STATS) == 24);
   assert(sizeof(BANK_HEADER) == 8);
   assert(sizeof(BANK) == 8);
   assert(sizeof(BANK32) == 12);
   assert(sizeof(BANK32A) == 16);
   assert(sizeof(ANA_OUTPUT_INFO) == 792);
   assert(sizeof(PROGRAM_INFO) == 316);
   assert(sizeof(ALARM) == 460);
   assert(sizeof(ALARM_CLASS) == 352);
   //assert(sizeof(CHN_SETTINGS) == 648); // ODB v3
   //assert(sizeof(CHN_STATISTICS) == 56);        // ODB v3
#endif
}
 
typedef struct {
   DATABASE_HEADER * pheader;
   int max_keys;
   int num_keys;
   HNDLE* hkeys;
   int* counts;
   int* modes;
   int num_modified;
} UPDATE_OPEN_RECORDS;
 
static int db_update_open_record_wlocked(const DATABASE_HEADER* xpheader, const KEY* xpkey, int level, void* voidp, db_err_msg **msg)
{
   int found = 0;
   int count = 0;
   int status;
   int k;
   UPDATE_OPEN_RECORDS *uorp = (UPDATE_OPEN_RECORDS *)voidp;
 
   KEY* pkey = (KEY*)xpkey; // drop "const": we already have "allow_write"
 
   HNDLE hKey = db_pkey_to_hkey(uorp->pheader, pkey);
 
   for (k=0; k<uorp->num_keys; k++)
      if (uorp->hkeys[k] == hKey) {
         found = 1;
         count = uorp->counts[k];
         break;
      }
 
   if (pkey->notify_count == 0 && !found)
      return DB_SUCCESS; // no open record here
 
   std::string path = db_get_path_pkey(uorp->pheader, pkey);
   if (path == "") {
      db_msg(msg, MINFO, "db_update_open_record", "Invalid hKey %d", hKey);
      return DB_SUCCESS;
   }
 
   //if (!db_validate_hkey(uorp->pheader, hKey)) {
   //   cm_msg(MINFO, "db_update_open_record", "Invalid hKey %d", hKey);
   //   return DB_SUCCESS;
   //}
   //
   //KEY* pkey = (KEY *) ((char *) uorp->pheader + hKey);
 
   //printf("path [%s], type %d, notify_count %d\n", path, pkey->type, pkey->notify_count);
 
   // extra check: are we looking at the same key?
   //assert(xkey->notify_count == pkey->notify_count);
 
#if 0
   printf("%s, notify_count %d, found %d, our count %d\n", path, pkey->notify_count, found, count);
#endif
   
   if (pkey->notify_count==0 && found) {
      db_msg(msg, MINFO, "db_update_open_record", "Added missing open record flag to \"%s\"", path.c_str());
      pkey->notify_count = count;
      uorp->num_modified++;
      return DB_SUCCESS;
   }
 
   if (pkey->notify_count!=0 && !found) {
      db_msg(msg, MINFO, "db_update_open_record", "Removed open record flag from \"%s\"", path.c_str());
      pkey->notify_count = 0;
      uorp->num_modified++;
 
      if (pkey->access_mode | MODE_EXCLUSIVE) {
         status = db_set_mode_wlocked(uorp->pheader, pkey, (WORD) (pkey->access_mode & ~MODE_EXCLUSIVE), 1, msg);
         if (status != DB_SUCCESS) {
            db_msg(msg, MERROR, "db_update_open_record", "Cannot remove exclusive access mode from \"%s\", db_set_mode() status %d", path.c_str(), status);
            return DB_SUCCESS;
         }
         db_msg(msg, MINFO, "db_update_open_record", "Removed exclusive access mode from \"%s\"", path.c_str());
      }
      return DB_SUCCESS;
   }
 
   if (pkey->notify_count != uorp->counts[k]) {
      db_msg(msg, MINFO, "db_update_open_record", "Updated notify_count of \"%s\" from %d to %d", path.c_str(), pkey->notify_count, count);
      pkey->notify_count = count;
      uorp->num_modified++;
      return DB_SUCCESS;
   }
 
   return DB_SUCCESS;
}
 
static int db_validate_open_records_wlocked(DATABASE_HEADER* pheader, db_err_msg** msg)
{
   int status = DB_SUCCESS;
   UPDATE_OPEN_RECORDS uor;
   int i, j, k;
 
   uor.max_keys = MAX_CLIENTS*MAX_OPEN_RECORDS;
   uor.num_keys = 0;
   uor.hkeys = (HNDLE*)calloc(uor.max_keys, sizeof(HNDLE));
   uor.counts = (int*)calloc(uor.max_keys, sizeof(int));
   uor.modes = (int*)calloc(uor.max_keys, sizeof(int));
   uor.num_modified = 0;
 
   assert(uor.hkeys != NULL);
   assert(uor.counts != NULL);
   assert(uor.modes != NULL);
 
   uor.pheader = pheader;
 
   for (i = 0; i < pheader->max_client_index; i++) {
      DATABASE_CLIENT* pclient = &pheader->client[i];
      for (j = 0; j < pclient->max_index; j++)
         if (pclient->open_record[j].handle) {
            int found = 0;
            for (k=0; k<uor.num_keys; k++) {
               if (uor.hkeys[k] == pclient->open_record[j].handle) {
                  uor.counts[k]++;
                  found = 1;
                  break;
               }
            }
            if (!found) {
               uor.hkeys[uor.num_keys] = pclient->open_record[j].handle;
               uor.counts[uor.num_keys] = 1;
               uor.modes[uor.num_keys] = pclient->open_record[j].access_mode;
               uor.num_keys++;
            }
         }
   }
 
#if 0
   for (i=0; i<uor.num_keys; i++)
      printf("index %d, handle %d, count %d, access mode %d\n", i, uor.hkeys[i], uor.counts[i], uor.modes[i]);
#endif
 
   const KEY* proot = db_get_pkey(pheader, 0, &status, "db_validate_open_record", msg);
 
   if (proot) {
      db_scan_tree_locked(pheader, proot, 0, db_update_open_record_wlocked, &uor, msg);
   }
 
   if (uor.num_modified) {
      db_msg(msg, MINFO, "db_validate_open_records", "Corrected %d ODB entries", uor.num_modified);
   }
 
   free(uor.hkeys);
   free(uor.counts);
   free(uor.modes);
 
   return status;
}
 
/*------------------------------------------------------------------*/
 
static bool check_free_list_repair(db_err_msg **msg)
{
   bool enable_repair = false;
 
   if (enable_repair)
      return true;
 
   if (getenv("MIDAS_ODB_REPAIR_FREE_LIST")) {
      db_msg(msg, MINFO, "db_validate_db", "ODB free list repair is enabled by env.variable");
      return true;
   }
 
   db_msg(msg, MERROR, "db_validate_db", "ODB key free list repair is disabled. To enable repair, \"export MIDAS_ODB_REPAIR_FREE_LIST=1\" and try again");
   return false;
}
 
/*------------------------------------------------------------------*/
static bool db_validate_key_area_wlocked(DATABASE_HEADER * pheader, const keylist_vector& keylist, const keylist_vector& keyfreelist, db_err_msg **msg)
{
   bool debug = false;
   bool flag = true;
 
   if (debug) {
      for (size_t i=0; i<keylist.size(); i++) {
         size_t gap = 0;
         if (i>0)
            gap = keylist[i].hkey - (keylist[i-1].hkey + ALIGN8(keylist[i-1].skey));
         printf("keylist[%zu] type %2d, hkey %7d, key size %3zu, hdata %9d, data size %9zu, key gap %zu\n", i, keylist[i].type, keylist[i].hkey, keylist[i].skey, keylist[i].hdata, keylist[i].sdata, gap);
      }
   }
 
   size_t odb_key_start = sizeof(DATABASE_HEADER);
   size_t odb_key_end   = sizeof(DATABASE_HEADER) + pheader->key_size;
   
   std::vector<keylist_struct> keyfree;
   
   bool first = true;
   
   for (size_t i=1; i<keylist.size(); i++) {
 
      size_t hthis = keylist[i-1].hkey;
      size_t sthis = ALIGN8(keylist[i-1].skey);
      size_t hend  = hthis + sthis;
      
      if (first) {
         first = false;
         if (hthis == odb_key_start) {
            // first entry is at the start of odb data area
            // printf("FIRST!\n");
         } else {
            // insert a free block between start of odb key area and first used block
            keylist_struct ds;
            ds.hkey = odb_key_start;
            ds.skey = hthis - odb_key_start;
            keyfree.push_back(ds);
         }
      }
      
      size_t hnext = keylist[i].hkey;
      
      if (hnext == hend) {
         // no free space
         continue;
      }
      
      if (hnext > hend) {
         // a free block
         keylist_struct ds;
         ds.hkey = hend;
         ds.skey = hnext - hend;
         keyfree.push_back(ds);
         continue;
      }
      
      // data areas overlap
      
      size_t overlap = hend - hnext;
      
      std::string this_path = db_get_path_locked(pheader, keylist[i-1].hkey);
      std::string next_path = db_get_path_locked(pheader, keylist[i].hkey);
      
      //printf("this %zu, %zu+%zu is %zu next is %zu, overlap %zu\n", i, hthis, sthis, hend, hnext, overlap);
      
      db_msg(msg, MERROR, "db_validate_key_area", "Error: ODB key area is corrupted, \"%s\" (%zu+%zu) overlaps \"%s\" (%zu) by %zu bytes, cannot repair", this_path.c_str(), hthis, sthis, next_path.c_str(), hnext, overlap);
      flag = false;
   }
   
   if (1) {
      size_t ilast = keylist.size()-1;
      HNDLE last_used = keylist[ilast].hkey + ALIGN8(keylist[ilast].skey);
      keylist_struct ds;
      ds.hkey = last_used;
      ds.skey = odb_key_end - last_used;
      if (ds.skey != 0) {
         //printf("ADD LAST!\n");
         keyfree.push_back(ds);
      }
   }
   
   if (debug) {
      printf("\n");
      for (size_t i=0; i<keyfree.size(); i++) {
         printf("keyfree[%zu] hkey %9d, key size %9zu\n", i, keyfree[i].hkey, keyfree[i].skey);
      }
   
      printf("\n");
      for (size_t i=0; i<keyfreelist.size(); i++) {
         printf("keyfreelist[%zu] hkey %9d, key size %9zu\n", i, keyfreelist[i].hkey, keyfreelist[i].skey);
      }
   }
   
   bool needs_repair = false;
 
   size_t key_check_size = keyfree.size();
   
   if (keyfree.size() != keyfreelist.size()) {
      db_msg(msg, MERROR, "db_validate_key_area", "Error: ODB key free list is corrupted, key free list length %zu should be %zu", keyfreelist.size(), keyfree.size());
      flag = false;
      needs_repair = true;
      key_check_size = MIN(keyfree.size(), keyfreelist.size());
   }
      
   for (size_t i=0; i<key_check_size; i++) {
      if (keyfree[i].hkey != keyfreelist[i].hkey) {
         db_msg(msg, MERROR, "db_validate_key_area", "Error: ODB key free list is corrupted, entry %zu mismatch %d should be %d", i, keyfreelist[i].hkey, keyfree[i].hkey);
         flag = false;
         needs_repair = true;
         break;
      } else if (keyfree[i].skey != keyfreelist[i].skey) {
         db_msg(msg, MERROR, "db_validate_key_area", "Error: ODB key free list is corrupted, entry %zu size mismatch %zu should be %zu", i, keyfreelist[i].skey, keyfree[i].skey);
         flag = false;
         needs_repair = true;
         break;
      } else {
         // good
      }
   }
 
   if (needs_repair && check_free_list_repair(msg)) {
      db_msg(msg, MINFO, "db_validate_key_area", "Rewriting corrupted ODB key free list");
      
      for (size_t i=0; i<keyfree.size(); i++) {
         HNDLE  hh = keyfree[i].hkey;
         size_t ss = keyfree[i].skey;
         HNDLE  hnext = 0;
         if (i<keyfree.size()-1) {
            hnext = keyfree[i+1].hkey;
         }
         //printf("hh %d, ss %zu, hnext %d\n", hh, ss, hnext);
         FREE_DESCRIP* pfree = (FREE_DESCRIP *) ((char *) pheader + hh);
         pfree->size = ss;
         pfree->next_free = hnext;
      }
 
      // remember to update pheader->first_free_key !!!
 
      if (keyfree.size() > 0)
         pheader->first_free_key = keyfree[0].hkey;
      else
         pheader->first_free_key = 0;
   }
 
   return flag;
}
 
static bool db_validate_data_area_wlocked(DATABASE_HEADER * pheader, const keylist_vector& keylist, const keylist_vector& datafreelist, db_err_msg **msg)
{
   bool debug = false;
   bool flag = true;
 
   if (debug) {
      for (size_t i=0; i<keylist.size(); i++) {
         size_t gap = 0;
         if (i>0)
            gap = keylist[i].hdata - (keylist[i-1].hdata + ALIGN8(keylist[i-1].sdata));
         printf("keylist[%zu] type %2d, hkey %7d, key size %3zu, hdata %9d, data size %9zu, data gap %zu\n", i, keylist[i].type, keylist[i].hkey, keylist[i].skey, keylist[i].hdata, keylist[i].sdata, gap);
      }
   }
      
   size_t odb_data_start = sizeof(DATABASE_HEADER) + pheader->key_size;
   size_t odb_data_end   = sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size;
   
   std::vector<keylist_struct> datafree;
   
   bool first = true;
 
   HNDLE last_used = 0;
   
   for (size_t i=1; i<keylist.size(); i++) {
      
      if (keylist[i-1].hdata == 0)
         continue;
      
      if (keylist[i].hdata == 0)
         continue;
      
      size_t hthis = keylist[i-1].hdata;
      size_t sthis = ALIGN8(keylist[i-1].sdata);
      size_t hend  = hthis + sthis;
 
      last_used = keylist[i].hdata + ALIGN8(keylist[i].sdata);
      
      if (first) {
         first = false;
         if (hthis == odb_data_start) {
            // first entry is at the start of odb data area
            //printf("FIRST!\n");
         } else {
            // insert a free block between start of odb data area and first used block
            keylist_struct ds;
            ds.hdata = odb_data_start;
            ds.sdata = hthis - odb_data_start;
            datafree.push_back(ds);
         }
      }
      
      size_t hnext = keylist[i].hdata;
      
      if (hnext == hend) {
         // no free space
         continue;
      }
      
      if (hnext > hend) {
         // a free block
         keylist_struct ds;
         ds.hdata = hend;
         ds.sdata = hnext - hend;
         datafree.push_back(ds);
         continue;
      }
      
      // data areas overlap
      
      size_t overlap = hend - hnext;
      
      std::string this_path = db_get_path_locked(pheader, keylist[i-1].hkey);
      std::string next_path = db_get_path_locked(pheader, keylist[i].hkey);
      
      //printf("this %zu, %zu+%zu is %zu next is %zu, overlap %zu\n", i, hthis, sthis, hend, hnext, overlap);
      
      db_msg(msg, MERROR, "db_validate_data_area", "Error: ODB data area is corrupted, \"%s\" (%zu+%zu) overlaps \"%s\" (%zu) by %zu bytes", this_path.c_str(), hthis, sthis, next_path.c_str(), hnext, overlap);
      flag = false;
      
      if (check_free_list_repair(msg)) {
         db_msg(msg, MERROR, "db_validate_data_area", "Error: ODB data area is corrupted, clearing overlapping data of \"%s\"", this_path.c_str());
         KEY* pkey = (KEY*)db_get_pkey(pheader, keylist[i-1].hkey, NULL, "db_validate_data_area", msg);
         if (pkey) {
            pkey->num_values = 0;
            pkey->data = 0;
            pkey->total_size = 0;
            pkey->item_size = 0;
            pkey->last_written = 0;
         }
      }
   }
   
   if (1) {
      //size_t ilast = keylist.size()-1;
      //HNDLE last_used = keylist[ilast].hdata + ALIGN8(keylist[ilast].sdata);
 
      if (last_used == 0) { // empty ODB
         last_used = odb_data_start;
      }
 
      keylist_struct ds;
      ds.hdata = last_used;
      ds.sdata = odb_data_end - last_used;
      if (ds.sdata != 0) {
         datafree.push_back(ds);
      }
   }
   
   if (debug) {
      printf("\n");
      for (size_t i=0; i<datafree.size(); i++) {
         printf("datafree[%zu] hdata %9d, data size %9zu\n", i, datafree[i].hdata, datafree[i].sdata);
      }
      
      printf("\n");
      for (size_t i=0; i<datafreelist.size(); i++) {
         printf("datafreelist[%zu] hdata %9d, data size %9zu\n", i, datafreelist[i].hdata, datafreelist[i].sdata);
      }
   }
   
   bool needs_repair = false;
 
   size_t data_check_size = datafree.size();
   
   if (datafree.size() != datafreelist.size()) {
      db_msg(msg, MERROR, "db_validate_data_area", "Error: ODB data free list is corrupted, data free list length %zu should be %zu", datafreelist.size(), datafree.size());
      data_check_size = MIN(datafree.size(), datafreelist.size());
      flag = false;
      needs_repair = true;
   }
      
   for (size_t i=0; i<data_check_size; i++) {
      if (datafree[i].hdata != datafreelist[i].hdata) {
         db_msg(msg, MERROR, "db_validate_data_area", "Error: ODB data free list is corrupted, entry %zu mismatch %d should be %d", i, datafreelist[i].hdata, datafree[i].hdata);
         flag = false;
         needs_repair = true;
         break;
      } else if (datafree[i].sdata != datafreelist[i].sdata) {
         db_msg(msg, MERROR, "db_validate_data_area", "Error: ODB data free list is corrupted, entry %zu size mismatch %zu should be %zu", i, datafreelist[i].sdata, datafree[i].sdata);
         flag = false;
         needs_repair = true;
         break;
      } else {
         // good
      }
   }
 
   if (needs_repair && check_free_list_repair(msg)) {
      db_msg(msg, MINFO, "db_validate_data_area", "Rewriting corrupted ODB data free list");
      
      for (size_t i=0; i<datafree.size(); i++) {
         HNDLE  hh = datafree[i].hdata;
         size_t ss = datafree[i].sdata;
         HNDLE  hnext = 0;
         if (i<datafree.size()-1) {
            hnext = datafree[i+1].hdata;
         }
         //printf("hh %d, ss %zu, hnext %d\n", hh, ss, hnext);
         FREE_DESCRIP* pfree = (FREE_DESCRIP *) ((char *) pheader + hh);
         pfree->size = ss;
         pfree->next_free = hnext;
      }
 
      // remember to update pheader->first_free_data !!!
 
      if (datafree.size() > 0)
         pheader->first_free_data = datafree[0].hdata;
      else
         pheader->first_free_data = 0;
 
      //printf("first_free_data %d %d\n", pheader->first_free_data, datafree[0].hdata);
   }
 
   return flag;
}
 
static bool db_validate_and_repair_db_wlocked(DATABASE_HEADER * pheader, db_err_msg **msg)
{
   bool flag = true;
 
   /* validate size of data structures (miscompiled, 32/64 bit mismatch, etc */
 
   db_validate_sizes();
 
   /* validate the key free list */
 
   std::vector<keylist_struct> keyfreelist;
 
   flag &= db_get_key_free_list_locked(pheader, &keyfreelist, msg);
 
   int total_size_key = 0;
 
   for (const auto e : keyfreelist) {
      total_size_key += e.skey;
   }
 
   double key_ratio = ((double) (pheader->key_size - total_size_key)) / ((double) pheader->key_size);
 
   if (key_ratio > 0.9)
      db_msg(msg, MERROR, "db_validate_db", "Warning: database key area is %.0f%% full", key_ratio * 100.0);
 
   if (total_size_key > pheader->key_size) {
      db_msg(msg, MERROR, "db_validate_db", "Error: database corruption, total_size_key %d is bigger than pheader->key_size %d", total_size_key, pheader->key_size);
      flag = false;
   }
 
   /* validate the data free list */
 
   std::vector<keylist_struct> datafreelist;
 
   flag &= db_get_data_free_list_locked(pheader, &datafreelist, msg);
 
   int total_size_data = 0;
 
   for (const auto e : datafreelist) {
      total_size_data += e.sdata;
   }
 
   double ratio_data = ((double) (pheader->data_size - total_size_data)) / ((double) pheader->data_size);
   if (ratio_data > 0.9)
      db_msg(msg, MERROR, "db_validate_db", "Warning: database data area is %.0f%% full", ratio_data * 100.0);
 
   if (total_size_data > pheader->data_size) {
      db_msg(msg, MERROR, "db_validate_db", "Error: database corruption, total_size_data %d is bigger than pheader->data_size 0x%08X", total_size_data, pheader->data_size);
      flag = false;
   }
 
   /* validate the tree of keys, starting from the root key */
 
   if (!db_validate_key_offset(pheader, pheader->root_key)) {
      db_msg(msg, MERROR, "db_validate_db", "Error: database corruption, pheader->root_key 0x%08X is invalid", pheader->root_key - (int)sizeof(DATABASE_HEADER));
      return false;
   }
 
   keylist_vector keylist;
 
   flag &= db_validate_and_repair_key_wlocked(pheader, 1, "", 0, pheader->root_key, (KEY *) ((char *) pheader + pheader->root_key), msg, &keylist);
 
   if (!keylist.empty()) { // check key free list
      
      for (size_t i=0; i<keylist.size(); i++) {
         keylist[i].hsort = keylist[i].hkey; // sort by hkey
      }
 
      std::sort(keylist.begin(), keylist.end());
 
      flag &= db_validate_key_area_wlocked(pheader, keylist, keyfreelist, msg);
   }
 
   if (!keylist.empty()) { // check data free list
 
      for (size_t i=0; i<keylist.size(); i++) {
         keylist[i].hsort = keylist[i].hdata; // sort by hdata
      }
 
      std::sort(keylist.begin(), keylist.end());
 
      flag &= db_validate_data_area_wlocked(pheader, keylist, datafreelist, msg);
   }
 
   if (!flag) {
      db_msg(msg, MERROR, "db_validate_db", "Error: ODB corruption detected, see previous messages");
   }
 
   return flag;
}
 
#endif // LOCAL_ROUTINES
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_open_database(const char *xdatabase_name, INT database_size, HNDLE * hDB, const char *client_name)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_OPEN_DATABASE, xdatabase_name, database_size, hDB, client_name);
 
#ifdef LOCAL_ROUTINES
   {
   INT i, status;
   HNDLE handle;
   DATABASE_CLIENT *pclient;
   BOOL shm_created;
   DATABASE_HEADER *pheader;
   KEY *pkey;
   KEYLIST *pkeylist;
   FREE_DESCRIP *pfree;
   BOOL call_watchdog;
   DWORD timeout;
   char database_name[NAME_LENGTH];
 
   /* restrict name length */
   mstrlcpy(database_name, xdatabase_name, NAME_LENGTH);
 
   int odb_size_limit = 100*1000*1000;
   if (database_size < 0 || database_size > odb_size_limit) {
      cm_msg(MERROR, "db_open_database", "invalid database size: %d bytes. ODB size limit is %d bytes", database_size, odb_size_limit);
      return DB_INVALID_PARAM;
   }
 
   if (strlen(client_name) >= NAME_LENGTH) {
      cm_msg(MERROR, "db_open_database", "client name \'%s\' is longer than %d characters", client_name, NAME_LENGTH-1);
      return DB_INVALID_PARAM;
   }
 
   if (strchr(client_name, '/') != NULL) {
      cm_msg(MERROR, "db_open_database", "client name \'%s\' should not contain the slash \'/\' character", client_name);
      return DB_INVALID_PARAM;
   }
 
   /* allocate new space for the new database descriptor */
   if (_database_entries == 0) {
      _database = (DATABASE *) malloc(sizeof(DATABASE));
      assert(_database != NULL);
      memset(_database, 0, sizeof(DATABASE));
      if (_database == NULL) {
         *hDB = 0;
         return DB_NO_MEMORY;
      }
 
      _database_entries = 1;
      i = 0;
   } else {
      /* check if database already open */
      for (i = 0; i < _database_entries; i++)
         if (_database[i].attached && equal_ustring(_database[i].name, database_name)) {
            /* check if database belongs to this thread */
            *hDB = i + 1;
            return DB_SUCCESS;
         }
 
      /* check for a deleted entry */
      for (i = 0; i < _database_entries; i++)
         if (!_database[i].attached)
            break;
 
      /* if not found, create new one */
      if (i == _database_entries) {
         _database = (DATABASE *) realloc(_database, sizeof(DATABASE) * (_database_entries + 1));
         assert(_database != NULL);
 
         memset(&_database[_database_entries], 0, sizeof(DATABASE));
 
         _database_entries++;
         if (_database == NULL) {
            _database_entries--;
            *hDB = 0;
            return DB_NO_MEMORY;
         }
      }
   }
 
   handle = (HNDLE) i;
 
   _database[handle].hDB = handle + 1;
 
   /* open shared memory region */
   void* shm_adr = NULL;
   size_t shm_size = 0;
   HNDLE shm_handle;
   
   status = ss_shm_open(database_name, sizeof(DATABASE_HEADER) + 2 * ALIGN8(database_size / 2), &shm_adr, &shm_size, &shm_handle, TRUE);
 
   if (status == SS_NO_MEMORY || status == SS_FILE_ERROR) {
      *hDB = 0;
      return DB_INVALID_NAME;
   }
 
   _database[handle].shm_adr  = shm_adr;
   _database[handle].shm_size = shm_size;
   _database[handle].shm_handle = shm_handle;
 
   _database[handle].database_header = (DATABASE_HEADER *) shm_adr;
 
   /* shortcut to header */
   pheader = _database[handle].database_header;
 
   /* save name */
   strcpy(_database[handle].name, database_name);
 
   shm_created = (status == SS_CREATED);
 
   /* clear memeory for debugging */
   /* memset(pheader, 0, sizeof(DATABASE_HEADER) + 2*ALIGN8(database_size/2)); */
 
   if (shm_created && pheader->name[0] == 0) {
      /* setup header info if database was created */
      memset(pheader, 0, sizeof(DATABASE_HEADER) + 2 * ALIGN8(database_size / 2));
 
      strcpy(pheader->name, database_name);
      pheader->version = DATABASE_VERSION;
      pheader->key_size = ALIGN8(database_size / 2);
      pheader->data_size = ALIGN8(database_size / 2);
      pheader->root_key = sizeof(DATABASE_HEADER);
      pheader->first_free_key = sizeof(DATABASE_HEADER);
      pheader->first_free_data = sizeof(DATABASE_HEADER) + pheader->key_size;
 
      /* set up free list */
      pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_key);
      pfree->size = pheader->key_size;
      pfree->next_free = 0;
 
      pfree = (FREE_DESCRIP *) ((char *) pheader + pheader->first_free_data);
      pfree->size = pheader->data_size;
      pfree->next_free = 0;
 
      /* create root key */
      pkey = (KEY *) malloc_key(pheader, sizeof(KEY), "db_open_database_A");
      assert(pkey);
 
      /* set key properties */
      pkey->type = TID_KEY;
      pkey->num_values = 1;
      pkey->access_mode = MODE_READ | MODE_WRITE | MODE_DELETE;
      strcpy(pkey->name, "root");
      pkey->parent_keylist = 0;
 
      /* create keylist */
      pkeylist = (KEYLIST *) malloc_key(pheader, sizeof(KEYLIST), "db_open_database_B");
      assert(pkeylist);
 
      /* store keylist in data field */
      pkey->data = (POINTER_T) pkeylist - (POINTER_T) pheader;
      pkey->item_size = sizeof(KEYLIST);
      pkey->total_size = sizeof(KEYLIST);
 
      pkeylist->parent = (POINTER_T) pkey - (POINTER_T) pheader;
      pkeylist->num_keys = 0;
      pkeylist->first_key = 0;
   }
 
   /* check database version */
   if (pheader->version != DATABASE_VERSION) {
      cm_msg(MERROR, "db_open_database",
             "Different database format: Shared memory is %d, program is %d", pheader->version, DATABASE_VERSION);
      return DB_VERSION_MISMATCH;
   }
 
   /* check database size vs shared memory size */
   if (_database[handle].shm_size < (int)sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size) {
      cm_msg(MERROR, "db_open_database", "Invalid database, shared memory size %d is smaller than database size %d (header: %d, key area: %d, data area: %d). Delete this shared memory (odbedit -R), create a new odb (odbinit) and reload it from the last odb save file.", _database[handle].shm_size, (int)sizeof(DATABASE_HEADER) + pheader->key_size + pheader->data_size, (int)sizeof(DATABASE_HEADER), pheader->key_size, pheader->data_size);
      return DB_VERSION_MISMATCH;
   }
 
   /* check root key */
   if (!db_validate_key_offset(pheader, pheader->root_key)) {
      cm_msg(MERROR, "db_open_database", "Invalid, incompatible or corrupted database: root key offset %d is invalid", pheader->root_key);
      return DB_VERSION_MISMATCH;
   } else {
      pkey = (KEY*)((char*)pheader + pheader->root_key);
 
      if (pkey->type != TID_KEY) {
         cm_msg(MERROR, "db_open_database", "Invalid, incompatible or corrupted database: root key type %d is not TID_KEY", pkey->type);
         return DB_VERSION_MISMATCH;
      }
 
      if (strcmp(pkey->name, "root") != 0) {
         cm_msg(MERROR, "db_open_database", "Invalid, incompatible or corrupted database: root key name \"%s\" is not \"root\"", pkey->name);
         return DB_VERSION_MISMATCH;
      }
 
      // what if we are connecting to an incompatible ODB?
      // A call to db_validate_and_repair_key() maybe will
      // corrupt it here. But we have no choice,
      // if we skip it here and continue,
      // db_validate_and_repair_db() will call it later anyway... K.O.
 
      db_err_msg* msg = NULL;
      bool ok = db_validate_and_repair_key_wlocked(pheader, 0, "", 0, pheader->root_key, pkey, &msg, NULL);
      if (msg)
         db_flush_msg(&msg);
      if (!ok) {
         cm_msg(MERROR, "db_open_database", "Invalid, incompatible or corrupted database: root key is invalid");
         return DB_VERSION_MISMATCH;
      }
   }
 
   /* set default mutex and semaphore timeout */
   _database[handle].timeout = 10000;
 
   /* create mutexes for the database */
   status = ss_mutex_create(&_database[handle].mutex, TRUE);
   if (status != SS_SUCCESS && status != SS_CREATED) {
      *hDB = 0;
      return DB_NO_SEMAPHORE;
   }
 
   /* create semaphore for the database */
   status = ss_semaphore_create(database_name, &(_database[handle].semaphore));
   if (status != SS_SUCCESS && status != SS_CREATED) {
      *hDB = 0;
      return DB_NO_SEMAPHORE;
   }
   _database[handle].lock_cnt = 0;
 
   _database[handle].protect = FALSE;
   _database[handle].protect_read = FALSE;
   _database[handle].protect_write = FALSE;
 
   /* first lock database */
   status = db_lock_database(handle + 1);
   if (status != DB_SUCCESS)
      return status;
 
   /* we have the database locked, without write protection */
 
   /*
    Now we have a DATABASE_HEADER, so let's setup a CLIENT
    structure in that database. The information there can also
    be seen by other processes.
    */
 
   /*
    update the client count
    */
   int num_clients = 0;
   int max_client_index = 0;
   for (i = 0; i < MAX_CLIENTS; i++) {
      if (pheader->client[i].pid == 0)
         continue;
      num_clients++;
      max_client_index = i + 1;
   }
   pheader->num_clients = num_clients;
   pheader->max_client_index = max_client_index;
 
   /*fprintf(stderr,"num_clients: %d, max_client: %d\n",pheader->num_clients,pheader->max_client_index); */
 
   /* remove dead clients */
   for (i = 0; i < MAX_CLIENTS; i++) {
      if (pheader->client[i].pid == 0)
         continue;
      if (!ss_pid_exists(pheader->client[i].pid)) {
         char client_name_tmp[NAME_LENGTH];
         int client_pid;
 
         mstrlcpy(client_name_tmp, pheader->client[i].name, sizeof(client_name_tmp));
         client_pid = pheader->client[i].pid;
 
         // removed: /* decrement notify_count for open records and clear exclusive mode */
         // open records are corrected later, by db_validate_open_records()
 
         /* clear entry from client structure in database header */
         memset(&(pheader->client[i]), 0, sizeof(DATABASE_CLIENT));
 
         cm_msg(MERROR, "db_open_database", "Removed ODB client \'%s\', index %d because process pid %d does not exists", client_name_tmp, i, client_pid);
      }
   }
 
   /*
    Look for empty client slot
    */
   for (i = 0; i < MAX_CLIENTS; i++)
      if (pheader->client[i].pid == 0)
         break;
 
   if (i == MAX_CLIENTS) {
      db_unlock_database(handle + 1);
      *hDB = 0;
      cm_msg(MERROR, "db_open_database", "maximum number of clients exceeded");
      return DB_NO_SLOT;
   }
 
   /* store slot index in _database structure */
   _database[handle].client_index = i;
 
   /*
    Save the index of the last client of that database so that later only
    the clients 0..max_client_index-1 have to be searched through.
    */
   pheader->num_clients++;
   if (i + 1 > pheader->max_client_index)
      pheader->max_client_index = i + 1;
 
   /* setup database header and client structure */
   pclient = &pheader->client[i];
 
   memset(pclient, 0, sizeof(DATABASE_CLIENT));
   mstrlcpy(pclient->name, client_name, sizeof(pclient->name));
   pclient->pid = ss_getpid();
   pclient->num_open_records = 0;
 
   ss_suspend_get_odb_port(&pclient->port);
 
   pclient->last_activity = ss_millitime();
 
   cm_get_watchdog_params(&call_watchdog, &timeout);
   pclient->watchdog_timeout = timeout;
 
   /* check ODB for corruption */
   db_err_msg* msg = NULL;
   bool ok = db_validate_and_repair_db_wlocked(pheader, &msg);
   if (msg)
      db_flush_msg(&msg);
   if (!ok) {
      /* do not treat corrupted odb as a fatal error- allow the user
       to preceed at own risk- the database is already corrupted,
       so no further harm can possibly be made. */
      /*
       db_unlock_database(handle + 1);
       *hDB = 0;
       return DB_CORRUPTED;
       */
   }
 
   /* setup _database entry */
   _database[handle].database_data = _database[handle].database_header + 1;
   _database[handle].attached = TRUE;
   _database[handle].protect = FALSE;
   _database[handle].protect_read = FALSE;
   _database[handle].protect_write = FALSE;
 
   *hDB = (handle + 1);
 
   status = db_validate_open_records_wlocked(pheader, &msg);
   if (status != DB_SUCCESS) {
      db_unlock_database(handle + 1);
      if (msg)
         db_flush_msg(&msg);
      cm_msg(MERROR, "db_open_database", "Error: db_validate_open_records() status %d", status);
      return status;
   }
 
   db_unlock_database(handle + 1);
 
   if (msg)
      db_flush_msg(&msg);
 
   if (shm_created)
      return DB_CREATED;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_close_database(HNDLE hDB)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_CLOSE_DATABASE, hDB);
 
#ifdef LOCAL_ROUTINES
   else {
      INT destroy_flag, i, j;
      char xname[256];
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_close_database", "invalid database handle %d", hDB);
         return DB_INVALID_HANDLE;
      }
 
      /* flush database to disk */
      db_flush_database(hDB);
 
      /* first lock database */
      db_lock_database(hDB);
 
      DATABASE* pdb = &_database[hDB - 1];
 
      if (!pdb->attached) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_close_database", "database not attached");
         return DB_INVALID_HANDLE;
      }
 
      DATABASE_HEADER *pheader = pdb->database_header;
      DATABASE_CLIENT *pclient = db_get_my_client_locked(pdb);
 
      db_allow_write_locked(pdb, "db_close_database");
 
      /* close all open records */
      for (i = 0; i < pclient->max_index; i++)
         if (pclient->open_record[i].handle)
            db_remove_open_record_wlocked(pdb, pheader, pclient->open_record[i].handle);
 
      /* mark entry in _database as empty */
      pdb->attached = FALSE;
 
      /* clear entry from client structure in database header */
      memset(pclient, 0, sizeof(DATABASE_CLIENT));
 
      /* calculate new max_client_index entry */
      for (i = MAX_CLIENTS - 1; i >= 0; i--)
         if (pheader->client[i].pid != 0)
            break;
      pheader->max_client_index = i + 1;
 
      /* count new number of clients */
      for (i = MAX_CLIENTS - 1, j = 0; i >= 0; i--)
         if (pheader->client[i].pid != 0)
            j++;
      pheader->num_clients = j;
 
      destroy_flag = (pheader->num_clients == 0);
 
      /* flush shared memory to disk before it gets deleted */
      if (destroy_flag)
         ss_shm_flush(pheader->name, pdb->shm_adr, pdb->shm_size, pdb->shm_handle, true);
 
      mstrlcpy(xname, pheader->name, sizeof(xname));
 
      /* unmap shared memory, delete it if we are the last */
      ss_shm_close(xname, pdb->shm_adr, pdb->shm_size, pdb->shm_handle, destroy_flag);
 
      pheader = NULL; // after ss_shm_close(), pheader points nowhere
      pdb->database_header = NULL; // ditto
 
      /* unlock database */
      db_unlock_database(hDB);
 
      /* delete semaphore */
      ss_semaphore_delete(pdb->semaphore, destroy_flag);
 
      /* delete mutex */
      ss_mutex_delete(pdb->mutex);
 
      /* update _database_entries */
      if (hDB == _database_entries)
         _database_entries--;
 
      if (_database_entries > 0)
         _database = (DATABASE *) realloc(_database, sizeof(DATABASE) * (_database_entries));
      else {
         free(_database);
         _database = NULL;
      }
 
      /* if we are the last one, also delete other semaphores */
      if (destroy_flag) {
         //extern INT _semaphore_elog, _semaphore_alarm, _semaphore_history, _semaphore_msg;
         extern INT _semaphore_elog, _semaphore_alarm, _semaphore_history;
 
         if (_semaphore_elog)
            ss_semaphore_delete(_semaphore_elog, TRUE);
         if (_semaphore_alarm)
            ss_semaphore_delete(_semaphore_alarm, TRUE);
         if (_semaphore_history)
            ss_semaphore_delete(_semaphore_history, TRUE);
         //if (_semaphore_msg)
         //   ss_semaphore_delete(_semaphore_msg, TRUE);
      }
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_flush_database(HNDLE hDB)
/********************************************************************\
 
  Routine: db_flush_database
 
  Purpose: Flushes the shared memory of a database to its disk file.
 
  Input:
    HNDLE  hDB              Handle to the database, which is used as
                            an index to the _database array.
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    RPC_NET_ERROR           Network error
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_FLUSH_DATABASE, hDB);
 
#ifdef LOCAL_ROUTINES
   else {
      int status, size;
      uint32_t flush_period = 60;
      uint32_t last_flush = 0;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_flush_database", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      /* create keys if not present */
      size = sizeof(flush_period);
      db_get_value(hDB, 0, "/System/Flush/Flush period", &flush_period, &size, TID_UINT32, true);
      size = sizeof(last_flush);
      db_get_value(hDB, 0, "/System/Flush/Last flush", &last_flush, &size, TID_UINT32, true);
 
      HNDLE hkey;
      status = db_find_key(hDB, 0, "/System/Flush/Last flush", &hkey);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "db_flush_database", "Cannot obtain key /System/Flush/Last flush");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
      DATABASE *pdb = &_database[hDB - 1];
      DATABASE_HEADER *pheader = pdb->database_header;
 
      if (!_database[hDB - 1].attached) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_flush_database", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg *msg = nullptr;
 
      const KEY *pkey = db_get_pkey(pheader, hkey, &status, "db_flush_database", &msg);
 
      if (!pkey) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return CM_NO_CLIENT;
      }
 
      size = sizeof(last_flush);
      status = db_get_data_locked(pheader, pkey, 0, &last_flush, &size, TID_UINT32, &msg);
 
      /* only flush if period has expired */
      if (ss_time() > last_flush + flush_period) {
         db_allow_write_locked(pdb, "db_flush_database");
 
         /* update last flush time in ODB */
         last_flush = ss_time();
         db_set_value_wlocked(pdb, 0, "/System/Flush/Last flush", &last_flush, sizeof(last_flush), 1, TID_UINT32, &msg);
 
         /* flush shared memory to disk */
         ss_shm_flush(pheader->name, _database[hDB - 1].shm_adr, _database[hDB - 1].shm_size, _database[hDB - 1].shm_handle, false);
      }
 
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_close_all_databases(void)
/********************************************************************\
 
  Routine: db_close_all_databases
 
  Purpose: Close all open databases and open records
 
  Input:
    none
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   INT status;
 
   if (rpc_is_remote()) {
      status = rpc_call(RPC_DB_CLOSE_ALL_DATABASES);
      if (status != DB_SUCCESS)
         return status;
   }
 
   db_close_all_records();
   db_unwatch_all();
 
#ifdef LOCAL_ROUTINES
   {
      INT i;
 
      for (i = _database_entries; i > 0; i--)
         db_close_database(i);
   }
#endif                          /* LOCAL_ROUTINES */
   
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_set_client_name(HNDLE hDB, const char *client_name)
/********************************************************************\
 
  Routine: db_set_client_name
 
  Purpose: Set client name for a database. Used by cm_connect_experiment
           if a client name is duplicate and changed.
 
  Input:
    INT  hDB                Handle to database
    char *client_name       Name of this application
 
  Output:
 
  Function value:
    DB_SUCCESS              Successful completion
    RPC_NET_ERROR           Network error
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_CLIENT_NAME, hDB, client_name);
 
#ifdef LOCAL_ROUTINES
   {
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_client_name", "invalid database handle %d", hDB);
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
      
      DATABASE *pdb = &_database[hDB - 1];
      DATABASE_CLIENT *pclient = db_get_my_client_locked(pdb);
      mstrlcpy(pclient->name, client_name, sizeof(pclient->name));
 
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_lock_database(HNDLE hDB)
{
#ifdef LOCAL_ROUTINES
   int status = 0;
   DATABASE* pdb = db_lock_database(hDB, &status, "db_lock_database", false);
   if (!pdb)
      return status;
   return DB_SUCCESS;
#else
   return DB_SUCCESS;
#endif
}
 
#ifdef LOCAL_ROUTINES
 
DATABASE* db_lock_database(HNDLE hDB, int *pstatus, const char* caller, bool check_attached)
{
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, caller, "invalid database handle %d, aborting...", hDB);
      cm_msg_flush_buffer();
      abort();
      if (pstatus)
         *pstatus = DB_INVALID_HANDLE;
      return NULL;
   }
 
   DATABASE* pdb = &_database[hDB-1];
 
   if (check_attached && !pdb->attached) {
      cm_msg(MERROR, caller, "invalid database handle %d, aborting...", hDB);
      cm_msg_flush_buffer();
      abort();
      if (pstatus)
         *pstatus = DB_INVALID_HANDLE;
      return NULL;
   }
 
   if (hDB != pdb->hDB) {
      cm_msg(MERROR, "db_lock_database", "database handle mismatch %d vs %d, aborting...", hDB, pdb->hDB);
      cm_msg_flush_buffer();
      abort();
      if (pstatus)
         *pstatus = DB_INVALID_HANDLE;
      return NULL;
   }
 
   /* obtain access mutex in multi-thread applications */
   int status = ss_mutex_wait_for(pdb->mutex, pdb->timeout);
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "db_lock_database", "cannot lock ODB mutex, timeout %d ms, status %d, aborting...", pdb->timeout, status);
      cm_msg_flush_buffer();
      abort();
   }
 
   /* protect this function against recursive call from signal handlers */
   if (pdb->inside_lock_unlock) {
      fprintf(stderr, "db_lock_database: Detected recursive call to db_{lock,unlock}_database() while already inside db_{lock,unlock}_database(). Maybe this is a call from a signal handler. Cannot continue, aborting...\n");
      abort();
   }
 
   pdb->inside_lock_unlock = 1;
 
   //static int x = 0;
   //x++;
   //if (x > 5000) {
   //   printf("inside db_lock_database(), press Ctrl-C now!\n");
   //   sleep(5);
   //}
 
   // test recursive locking
   // static int out=0;
   // out++;
   // printf("HERE %d!\n", out);
   // if (out>10) abort();
   // db_lock_database(hDB);
   // printf("OUT %d!\n", out);
 
   if (pdb->lock_cnt == 0) {
      pdb->lock_cnt = 1;
      /* wait max. 5 minutes for semaphore (required if locking process is being debugged) */
      status = ss_semaphore_wait_for(pdb->semaphore, pdb->timeout);
      if (status == SS_TIMEOUT) {
         cm_msg(MERROR, "db_lock_database", "cannot lock ODB semaphore, timeout %d ms, aborting...", pdb->timeout);
         cm_msg_flush_buffer();
         //exit(1); // exit() calls ataxit() handlers, including midas disconnect experiment which will crash because ODB locking is hosed. cannot continue, must abort(). K.O. 13-OCT-2024.
         abort();
      }
      if (status != SS_SUCCESS) {
         cm_msg(MERROR, "db_lock_database", "cannot lock ODB semaphore, timeout %d ms, ss_semaphore_wait_for() status %d, aborting...", pdb->timeout, status);
         cm_msg_flush_buffer();
         abort();
      }
   } else {
      pdb->lock_cnt++; // we have already the lock (recursive call), so just increase counter
   }
 
#ifdef CHECK_LOCK_COUNT
   {
      std::string str = msprintf(str, "db_lock_database, lock_cnt=%d", pdb->lock_cnt);
      ss_stack_history_entry(str.c_str());
   }
#endif
 
   if (pdb->protect) {
      if (pdb->database_header == NULL) {
         int status;
         assert(!pdb->protect_read);
         assert(!pdb->protect_write);
         status = ss_shm_unprotect(pdb->shm_handle, &pdb->shm_adr, pdb->shm_size, TRUE, FALSE, "db_lock_database");
         if (status != SS_SUCCESS) {
            cm_msg(MERROR, "db_lock_database", "cannot lock ODB, ss_shm_unprotect(TRUE,FALSE) failed with status %d, aborting...", status);
            cm_msg_flush_buffer();
            ss_semaphore_release(pdb->semaphore);
            abort();
         }
         pdb->database_header = (DATABASE_HEADER *) pdb->shm_adr;
         pdb->protect_read = TRUE;
         pdb->protect_write = FALSE;
      }
   }
 
   pdb->inside_lock_unlock = 0;
   
   return pdb;
}
 
INT db_allow_write_locked(DATABASE* p, const char* caller_name)
{
   assert(p);
   if (p->protect && !p->protect_write) {
      int status;
      assert(p->lock_cnt > 0);
      assert(p->database_header != NULL);
      assert(p->protect_read);
      status = ss_shm_unprotect(p->shm_handle, &p->shm_adr, p->shm_size, TRUE, TRUE, caller_name);
      if (status != SS_SUCCESS) {
         cm_msg(MERROR, "db_allow_write_locked", "cannot write to ODB, ss_shm_unprotect(TRUE,TRUE) failed with status %d, aborting...", status);
         cm_msg_flush_buffer();
         ss_semaphore_release(p->semaphore);
         abort();
      }
      p->database_header = (DATABASE_HEADER *) p->shm_adr;
      p->protect_read = TRUE;
      p->protect_write = TRUE;
   }
   return DB_SUCCESS;
}
#endif                          /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_unlock_database(HNDLE hDB)
{
#ifdef LOCAL_ROUTINES
 
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_unlock_database", "invalid database handle %d", hDB);
      return DB_INVALID_HANDLE;
   }
 
   DATABASE* pdb = &_database[hDB - 1];
 
   db_unlock_database(pdb, "db_unlock_database");
 
   return DB_SUCCESS;
 
#else
   return DB_SUCCESS;
#endif
}
 
#ifdef LOCAL_ROUTINES
 
void db_unlock_database(DATABASE* pdb, const char* caller)
{
#ifdef CHECK_LOCK_COUNT
   {
      std::string str = msprintf("db_unlock_database, lock_cnt=%d", _database[hDB - 1].lock_cnt);
      ss_stack_history_entry(str.c_str());
   }
#endif
 
   /* protect this function against recursive call from signal handlers */
   if (pdb->inside_lock_unlock) {
      fprintf(stderr, "db_unlock_database: Detected recursive call to db_{lock,unlock}_database() while already inside db_{lock,unlock}_database(). Maybe this is a call from a signal handler. Cannot continue, aborting...\n");
      abort();
   }
 
   pdb->inside_lock_unlock = 1;
 
   //static int x = 0;
   //x++;
   //if (x > 5000) {
   //   printf("inside db_unlock_database(), press Ctrl-C now!\n");
   //   sleep(5);
   //}
 
   if (pdb->lock_cnt == 1) {
      ss_semaphore_release(pdb->semaphore);
 
      if (pdb->protect && pdb->database_header) {
         int status;
         assert(pdb->protect_read);
         assert(pdb->database_header);
         pdb->database_header = NULL;
         status = ss_shm_protect(pdb->shm_handle, pdb->shm_adr, pdb->shm_size);
         if (status != SS_SUCCESS) {
            cm_msg(MERROR, "db_unlock_database", "cannot unlock ODB, ss_shm_protect() failed with status %d, aborting...", status);
            cm_msg_flush_buffer();
            abort();
         }
         pdb->protect_read = FALSE;
         pdb->protect_write = FALSE;
      }
   }
 
   assert(pdb->lock_cnt > 0);
   pdb->lock_cnt--;
 
   pdb->inside_lock_unlock = 0;
 
   /* release mutex for multi-thread applications */
   ss_mutex_release(pdb->mutex);
}
 
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
#if 0
INT db_get_lock_cnt(HNDLE hDB)
{
#ifdef LOCAL_ROUTINES
 
   /* return zero if no ODB is open or we run remotely */
   if (_database_entries == 0)
      return 0;
 
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_get_lock_cnt", "invalid database handle %d, aborting...", hDB);
      fprintf(stderr, "db_get_lock_cnt: invalid database handle %d, aborting...\n", hDB);
      abort();
      return DB_INVALID_HANDLE;
   }
 
   return _database[hDB - 1].lock_cnt;
#else
   return 0;
#endif
}
#endif
 
INT db_set_lock_timeout(HNDLE hDB, int timeout_millisec)
{
#ifdef LOCAL_ROUTINES
 
   /* return zero if no ODB is open or we run remotely */
   if (_database_entries == 0)
      return 0;
 
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_set_lock_timeout", "invalid database handle %d", hDB);
      return 0;
   }
 
   if (timeout_millisec > 0) {
      _database[hDB - 1].timeout = timeout_millisec;
   }
 
   return _database[hDB - 1].timeout;
#else
   return 0;
#endif
}
 
#ifdef LOCAL_ROUTINES
 
INT db_update_last_activity(DWORD millitime)
{
   bool found = false;
   int pid = ss_getpid();
   for (int i = 0; i < _database_entries; i++) {
      if (_database[i].attached) {
         db_lock_database(i + 1);
         db_allow_write_locked(&_database[i], "db_update_last_activity");
         assert(_database[i].database_header);
         /* update the last_activity entry to show that we are alive */
         for (int j=0; j<_database[i].database_header->max_client_index; j++) {
            DATABASE_CLIENT* pdbclient = _database[i].database_header->client + j;
            //printf("client %d pid %d vs our pid %d\n", j, pdbclient->pid, pid);
            if (pdbclient->pid == pid) {
               pdbclient->last_activity = millitime;
               found = true;
            }
         }
         db_unlock_database(i + 1);
      }
   }
 
   if (!found) {
      cm_msg(MERROR, "db_update_last_activity", "Did not find this client in any database. Maybe this client was removed by a timeout, see midas.log. Cannot continue, aborting...");
      abort();
   }
   
   return DB_SUCCESS;
}
 
#endif // LOCAL_ROUTINES
 
#ifdef LOCAL_ROUTINES
static void db_delete_client_wlocked(DATABASE_HEADER* pheader, int jclient, db_err_msg** msg)
{
   DATABASE_CLIENT* pdbclient = &pheader->client[jclient];
 
   /* decrement notify_count for open records and clear exclusive mode */
   int k;
   for (k = 0; k < pdbclient->max_index; k++)
      if (pdbclient->open_record[k].handle) {
         KEY* pkey = (KEY *) ((char *) pheader + pdbclient->open_record[k].handle);
         if (pkey->notify_count > 0)
            pkey->notify_count--;
         
         if (pdbclient->open_record[k].access_mode & MODE_WRITE)
            db_set_mode_wlocked(pheader, pkey, (WORD) (pkey->access_mode & ~MODE_EXCLUSIVE), 2, msg);
      }
   
   /* clear entry from client structure in buffer header */
   memset(pdbclient, 0, sizeof(DATABASE_CLIENT));
   
   /* calculate new max_client_index entry */
   for (k = MAX_CLIENTS - 1; k >= 0; k--)
      if (pheader->client[k].pid != 0)
         break;
   pheader->max_client_index = k + 1;
   
   /* count new number of clients */
   int nc;
   for (k = MAX_CLIENTS - 1, nc = 0; k >= 0; k--)
      if (pheader->client[k].pid != 0)
         nc++;
   pheader->num_clients = nc;
}
#endif
 
#ifdef LOCAL_ROUTINES
static int db_delete_client_info_wlocked(DATABASE* pdb, int pid, db_err_msg** msg)
{
   if (!pid)
      pid = ss_getpid();
 
   int status = 0;
 
   std::string str = msprintf("System/Clients/%0d", pid);
 
   DATABASE_HEADER* pheader = pdb->database_header;
 
   KEY* pkey = (KEY*)db_find_pkey_locked(pheader, NULL, str.c_str(), true, &status, msg);
   if (!pkey) {
      return status;
   }
   
   status = db_set_mode_wlocked(pheader, pkey, MODE_READ | MODE_WRITE | MODE_DELETE, 2, msg);
   status = db_delete_key_locked(pdb, pkey, 0, msg);
   int32_t data = 0;
   db_set_value_wlocked(pdb, 0, "/System/Client Notify", &data, sizeof(data), 1, TID_INT32, msg);
 
   return status;
}
#endif
 
/********************************************************************/
int db_delete_client_info(HNDLE hDB, int pid)
{
#ifdef LOCAL_ROUTINES
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_delete_client_info", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   if (!_database[hDB - 1].attached) {
      cm_msg(MERROR, "db_delete_client_info", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   /* lock database */
   db_lock_database(hDB);
 
   DATABASE *pdb = &_database[hDB - 1];
 
   db_allow_write_locked(pdb, "db_delete_client_info");
 
   db_err_msg* msg = NULL;
 
   int status = db_delete_client_info_wlocked(pdb, pid, &msg);
   
   db_unlock_database(hDB);
 
   if (msg)
      db_flush_msg(&msg);
 
   return status;
#else
   return DB_SUCCESS;
#endif
}
 
void db_cleanup(const char *who, DWORD actual_time, BOOL wrong_interval)
{
#ifdef LOCAL_ROUTINES
   int i;
   /* check online databases */
   for (i = 0; i < _database_entries; i++) {
      DATABASE *pdb = &_database[i];
      if (!pdb->attached) // empty slot
         continue;
 
      db_lock_database(i + 1);
      db_allow_write_locked(pdb, "db_cleanup");
 
      DATABASE_HEADER* pheader = pdb->database_header;
      DATABASE_CLIENT* pclient = db_get_my_client_locked(pdb);
      
      /* update the last_activity entry to show that we are alive */
      pclient->last_activity = actual_time;
      
      /* don't check other clients if interval is stange */
      if (wrong_interval) {
         db_unlock_database(i + 1);
         continue;
      }
      
      db_err_msg *msg = NULL;
      
      /* now check other clients */
      int j;
      for (j = 0; j < pheader->max_client_index; j++) {
         DATABASE_CLIENT *pdbclient = &pheader->client[j];
         int client_pid = pdbclient->pid;
         if (client_pid == 0) // empty slot
            continue;
         
         if (!ss_pid_exists(client_pid)) {
            db_msg(&msg, MINFO, "db_cleanup", "Client \'%s\' on database \'%s\' pid %d does not exist and db_cleanup called by %s removed it", pdbclient->name, pheader->name, client_pid, who);
            
            db_delete_client_wlocked(pheader, j, &msg);
            db_delete_client_info_wlocked(pdb, client_pid, &msg);
            
            continue;
         }
         
         /* now make again the check with the buffer locked */
         actual_time = ss_millitime();
         if ((pdbclient->watchdog_timeout &&
              actual_time > pdbclient->last_activity &&
              actual_time - pdbclient->last_activity > pdbclient->watchdog_timeout)
             ) {
            db_msg(&msg, MINFO, "db_cleanup", "Client \'%s\' on database \'%s\' pid %d timed out and db_cleanup called by %s removed it (idle %1.1lfs,TO %1.0lfs)",
                   pdbclient->name, pheader->name, client_pid,
                   who,
                   (actual_time - pdbclient->last_activity) / 1000.0,
                   pdbclient->watchdog_timeout / 1000.0);
            
            db_delete_client_wlocked(pheader, j, &msg);
            db_delete_client_info_wlocked(pdb, client_pid, &msg);
         }
      }
      
      db_unlock_database(i + 1);
      if (msg)
         db_flush_msg(&msg);
   }
#endif
}
 
#ifdef LOCAL_ROUTINES
 
void db_cleanup2(const char* client_name, int ignore_timeout, DWORD actual_time,  const char *who)
{
   /* check online databases */
   int i;
   for (i = 0; i < _database_entries; i++) {
      if (_database[i].attached) {
         /* update the last_activity entry to show that we are alive */
         
         db_lock_database(i + 1);
 
         db_err_msg *msg = NULL;
 
         DATABASE* pdb = &_database[i];
 
         db_allow_write_locked(pdb, "db_cleanup2");
 
         DWORD now = ss_millitime();
 
         DATABASE_HEADER* pheader = pdb->database_header;
         DATABASE_CLIENT* pclient = db_get_my_client_locked(pdb);
         pclient->last_activity = now;
         
         /* now check other clients */
         int j;
         for (j = 0; j < pheader->max_client_index; j++) {
            DATABASE_CLIENT* pdbclient = &pheader->client[j];
            if (j == pdb->client_index) // do not check ourselves
               continue;
            if (!pdbclient->pid) // empty slot
               continue;
            if ((client_name == NULL || client_name[0] == 0
                 || strncmp(pdbclient->name, client_name, strlen(client_name)) == 0)) {
               int client_pid = pdbclient->pid;
 
               if (!ss_pid_exists(client_pid)) {
                  db_msg(&msg, MINFO, "db_cleanup2", "Client \'%s\' on database \'%s\' pid %d does not exist and db_cleanup2 called by %s removed it",
                         pdbclient->name, pheader->name,
                         client_pid,
                         who);
 
                  db_delete_client_wlocked(pheader, j, &msg);
                  db_delete_client_info_wlocked(pdb, client_pid, &msg);
 
                  /* go again though whole list */
                  j = 0;
                  continue;
               }
 
               DWORD interval;
               if (ignore_timeout)
                  interval = 2 * WATCHDOG_INTERVAL;
               else
                  interval = pdbclient->watchdog_timeout;
               
               /* If client process has no activity, clear its buffer entry. */
               
               if ((interval > 0 && now - pdbclient->last_activity > interval)) {
                  db_msg(&msg, MINFO, "db_cleanup2", "Client \'%s\' on database \'%s\' timed out and db_cleanup2 called by %s removed it (idle %1.1lfs,TO %1.0lfs)",
                         pdbclient->name, pheader->name,
                         who,
                         (now - pdbclient->last_activity) / 1000.0, interval / 1000.0);
 
                  db_delete_client_wlocked(pheader, j, &msg);
                  db_delete_client_info_wlocked(pdb, client_pid, &msg);
                  
                  /* go again though whole list */
                  j = 0;
                  continue;
               }
            }
         }
         
         db_unlock_database(i + 1);
         if (msg)
            db_flush_msg(&msg);
      }
   }
}
 
void db_set_watchdog_params(DWORD timeout)
{
   /* set watchdog flag of all open databases */
   for (int i = _database_entries; i > 0; i--) {
      
      db_lock_database(i);
 
      DATABASE* pdb = &_database[i - 1];
 
      if (!pdb->attached) {
         db_unlock_database(i);
         continue;
      }
      
      DATABASE_CLIENT *pclient = db_get_my_client_locked(pdb);
      
      db_allow_write_locked(pdb, "db_set_watchdog_params");
      
      /* clear entry from client structure in buffer header */
      pclient->watchdog_timeout = timeout;
      
      /* show activity */
      pclient->last_activity = ss_millitime();
      
      db_unlock_database(i);
   }
}
 
/********************************************************************/
INT db_get_watchdog_info(HNDLE hDB, const char *client_name, DWORD * timeout, DWORD * last)
{
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_get_watchdog_info", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   if (!_database[hDB - 1].attached) {
      cm_msg(MERROR, "db_get_watchdog_info", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   /* lock database */
   db_lock_database(hDB);
 
   DATABASE *pdb = &_database[hDB - 1];
   DATABASE_HEADER *pheader = pdb->database_header;
   
   /* find client */
   for (int i = 0; i < pheader->max_client_index; i++) {
      DATABASE_CLIENT *pclient = &pheader->client[i];
      if (pclient->pid && equal_ustring(pclient->name, client_name)) {
         *timeout = pclient->watchdog_timeout;
         *last = ss_millitime() - pclient->last_activity;
         db_unlock_database(hDB);
         return DB_SUCCESS;
      }
   }
   
   *timeout = *last = 0;
 
   db_unlock_database(hDB);
 
   return CM_NO_CLIENT;
}
 
/********************************************************************/
INT db_check_client(HNDLE hDB, HNDLE hKeyClient)
{
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_check_client", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   if (!_database[hDB - 1].attached) {
      cm_msg(MERROR, "db_check_client", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
 
   int status;
   
   db_lock_database(hDB);
 
   db_err_msg* msg = NULL;
 
   DATABASE *pdb = &_database[hDB - 1];
   DATABASE_HEADER *pheader = pdb->database_header;
   
   const KEY* pkey = db_get_pkey(pheader, hKeyClient, &status, "db_check_client", &msg);
 
   if (!pkey) {
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
      return CM_NO_CLIENT;
   }
   
   int client_pid = atoi(pkey->name);
 
   const KEY* pkey_name = db_find_pkey_locked(pheader, pkey, "Name", true, &status, &msg);
 
   if (!pkey_name) {
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
      return CM_NO_CLIENT;
   }
   
   char name[256];
   name[0] = 0;
   int size = sizeof(name);
   status = db_get_data_locked(pheader, pkey_name, 0, name, &size, TID_STRING, &msg);
   
   //fprintf(stderr, "db_check_client: hkey %d, status %d, pid %d, name \'%s\'\n", hKeyClient, status, client_pid, name);
   
   if (status != DB_SUCCESS) {
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
      return CM_NO_CLIENT;
   }
   
   bool dead = false;
   bool found = false;
   
   /* loop through clients */
   for (int i = 0; i < pheader->max_client_index; i++) {
      DATABASE_CLIENT *pclient = &pheader->client[i];
      if (pclient->pid == client_pid) {
         found = true;
         break;
      }
   }
   
   if (found) {
      /* check that the client is still running: PID still exists */
      if (!ss_pid_exists(client_pid)) {
         dead = true;
      }
   }
 
   status = DB_SUCCESS;
   
   if (!found || dead) {
      /* client not found : delete ODB stucture */
      
      db_allow_write_locked(pdb, "db_check_client");
      
      status = db_delete_client_info_wlocked(pdb, client_pid, &msg);
      
      if (status != DB_SUCCESS)
         db_msg(&msg, MERROR, "db_check_client", "Cannot delete client info for client \'%s\', pid %d, db_delete_client_info() status %d", name, client_pid, status);
      else if (!found)
         db_msg(&msg, MINFO, "db_check_client", "Deleted entry \'/System/Clients/%d\' for client \'%s\' because it is not connected to ODB", client_pid, name);
      else if (dead)
         db_msg(&msg, MINFO, "db_check_client", "Deleted entry \'/System/Clients/%d\' for client \'%s\' because process pid %d does not exists", client_pid, name, client_pid);
      
      status = CM_NO_CLIENT;
   }
 
   db_unlock_database(hDB);
   if (msg)
      db_flush_msg(&msg);
 
   return status;
}
 
#endif // LOCAL_ROUTINES
 
/********************************************************************/
INT db_protect_database(HNDLE hDB)
{
   if (rpc_is_remote())
      return DB_SUCCESS;
 
#ifdef LOCAL_ROUTINES
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_protect_database", "invalid database handle %d", hDB);
      return DB_INVALID_HANDLE;
   }
 
   _database[hDB - 1].protect = TRUE;
   ss_shm_protect(_database[hDB - 1].shm_handle, _database[hDB - 1].database_header, _database[hDB - 1].shm_size);
   _database[hDB - 1].database_header = NULL;
#endif                          /* LOCAL_ROUTINES */
   return DB_SUCCESS;
}
 
/*---- helper routines ---------------------------------------------*/
 
const char *extract_key(const char *key_list, char *key_name, int key_name_length)
{
   int i = 0;
 
   if (*key_list == '/')
      key_list++;
 
   while (*key_list && *key_list != '/' && ++i < key_name_length)
      *key_name++ = *key_list++;
   *key_name = 0;
 
   return key_list;
}
 
BOOL equal_ustring(const char *str1, const char *str2)
{
   if (str1 == NULL && str2 != NULL)
      return FALSE;
   if (str1 != NULL && str2 == NULL)
      return FALSE;
   if (str1 == NULL && str2 == NULL)
      return TRUE;
   if (strlen(str1) != strlen(str2))
      return FALSE;
 
   while (*str1)
      if (toupper(*str1++) != toupper(*str2++))
         return FALSE;
 
   if (*str2)
      return FALSE;
 
   return TRUE;
}
 
BOOL ends_with_ustring(const char *str, const char *suffix)
{
   int len_str = strlen(str);
   int len_suffix = strlen(suffix);
 
   // suffix is longer than the string
   if (len_suffix > len_str)
      return FALSE;
 
   return equal_ustring(str + len_str - len_suffix, suffix);
}
 
//utility function to match string against wildcard pattern
BOOL strmatch(char* pattern, char* str){
   switch(*pattern){
      case 0:
         if(*str == 0){
            //end of pattern
            return true;
         }else
            return false;
      case '*':
         {
            int i=0;
            // check for end of the string
            if(pattern[1] == 0) return true;
            // loop on all possible matches
            while(str[i] != 0) if(strmatch(pattern + 1, str+(i++))) return true;
            return false;
         }
      case '?':
         if(*str == 0){
            //end of string
            return false;
         } else {
            return strmatch(pattern+1, str+1);
         }
      default:
         if(*str == 0){
            //end of string
            return false;
         } else if(toupper(*str) == toupper(*pattern)){
            //recursion
            return strmatch(pattern+1, str+1);
         } else {
            return false;
         }
   }
}
 
//utility function to extract array indexes
void strarrayindex(char* odbpath, int* index1, int* index2){
   char* pc;
 
   *index1 = *index2 = 0;
   if (odbpath[strlen(odbpath) - 1] == ']') {
      if (strchr(odbpath, '[')) {
         if (*(strchr(odbpath, '[') + 1) == '*')
            *index1 = -1;
         else if (strchr((strchr(odbpath, '[') + 1), '.') ||
                  strchr((strchr(odbpath, '[') + 1), '-')) {
            *index1 = atoi(strchr(odbpath, '[') + 1);
            pc = strchr(odbpath, '[') + 1;
            while (*pc != '.' && *pc != '-')
               pc++;
            while (*pc == '.' || *pc == '-')
               pc++;
            *index2 = atoi(pc);
         } else
            *index1 = atoi(strchr(odbpath, '[') + 1);
      }
 
      //remove everything after bracket
      *strchr(odbpath, '[') = 0;
   }
}
 
/********************************************************************/
INT db_create_key(HNDLE hDB, HNDLE hKey, const char *key_name, DWORD type)
{
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_CREATE_KEY, hDB, hKey, key_name, type);
 
#ifdef LOCAL_ROUTINES
   {
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_create_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_create_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      /* lock database */
      db_lock_database(hDB);
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      db_err_msg *msg = NULL;
      
      KEY* pkey = (KEY*)db_get_pkey(pheader, hKey, &status, "db_create_key", &msg);
 
      if (!pkey) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return DB_INVALID_HANDLE;
      }
 
      db_allow_write_locked(pdb, "db_create_key");
 
      KEY* newpkey = NULL;
 
      status = db_create_key_wlocked(pheader, pkey, key_name, type, &newpkey, &msg);
 
      db_unlock_database(hDB);
 
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
 
int db_create_key_wlocked(DATABASE_HEADER* pheader, KEY* parentKey, const char *key_name, DWORD type, KEY** pnewkey, db_err_msg** msg)
{
   int status;
 
   if (pnewkey)
      *pnewkey = NULL;
 
   if (parentKey== NULL) {
      parentKey = (KEY*) db_get_pkey(pheader, pheader->root_key, &status, "db_create_key_wlocked", msg);
      if (!parentKey) {
         return status;
      }
   }
 
   //printf("db_create_key_wlocked: parent \"%s\", name \"%s\", type %d\n", db_get_path_pkey(pheader, parentKey).c_str(), key_name, type);
   
   status = db_validate_name(key_name, TRUE, "db_create_key_wlocked", msg);
   if (status != DB_SUCCESS) {
      return status;
   }
   
   /* check type */
   if (type <= 0 || type >= TID_LAST) {
      db_msg(msg, MERROR, "db_create_key", "invalid key type %d to create \'%s\' in \'%s\'", type, key_name, db_get_path_pkey(pheader, parentKey).c_str());
      return DB_INVALID_PARAM;
   }
 
   const KEY* pdir = parentKey;
   
   if (pdir->type != TID_KEY) {
      db_msg(msg, MERROR, "db_create_key", "cannot create \'%s\' in \'%s\' tid is %d, not a directory", key_name, db_get_path_pkey(pheader, pdir).c_str(), pdir->type);
      return DB_NO_KEY;
   }
 
   KEY* pcreated = NULL;
 
   const char* pkey_name = key_name;
   do {
      // key name is limited to NAME_LENGTH, but buffer has to be slightly longer
      // to prevent truncation before db_validate_name checks for correct length. K.O.
      char name[NAME_LENGTH+100];
      
      /* extract single key from key_name */
      pkey_name = extract_key(pkey_name, name, sizeof(name));
 
      status = db_validate_name(name, FALSE, "db_create_key", msg);
      if (status != DB_SUCCESS) {
         return status;
      }
      
      /* do not allow empty names, like '/dir/dir//dir/' */
      if (name[0] == 0) {
         return DB_INVALID_PARAM;
      }
      
      /* check if parent or current directory */
      if (strcmp(name, "..") == 0) {
         pdir = db_get_parent(pheader, pdir, &status, "db_create_key", msg);
         if (!pdir) {
            return status;
         }
         continue;
      }
      if (strcmp(name, ".") == 0)
         continue;
 
      KEY* pprev = NULL;
      const KEY* pitem = db_enum_first_locked(pheader, pdir, msg);
 
      while (pitem) {
         if (equal_ustring(name, pitem->name)) {
            break;
         }
         pprev = (KEY*)pitem;
         pitem = db_enum_next_locked(pheader, pdir, pitem, msg);
      }
      
      if (!pitem) {
         /* not found: create new key */
 
         /* check parent for write access */
         const KEY* pkeyparent = db_get_parent(pheader, pdir, &status, "db_create_key", msg);
         if (!pkeyparent) {
            return status;
         }
 
         if (!(pkeyparent->access_mode & MODE_WRITE) || (pkeyparent->access_mode & MODE_EXCLUSIVE)) {
            return DB_NO_ACCESS;
         }
         
         KEYLIST* pkeylist = (KEYLIST*)db_get_pkeylist(pheader, pdir, "db_create_key_wlocked", msg);
         
         if (!pkeylist) {
            return DB_CORRUPTED;
         }
         
         pkeylist->num_keys++;
         
         if (*pkey_name == '/' || type == TID_KEY) {
            /* create new key with keylist */
            KEY* pkey = (KEY *) malloc_key(pheader, sizeof(KEY), "db_create_key_subdir");
            
            if (pkey == NULL) {
               if (pkeylist->num_keys > 0)
                  pkeylist->num_keys--;
 
               db_msg(msg, MERROR, "db_create_key", "online database full while creating \'%s\' in \'%s\'", key_name, db_get_path_pkey(pheader, parentKey).c_str());
               return DB_FULL;
            }
 
            /* append key to key list */
            if (pprev)
               pprev->next_key = (POINTER_T) pkey - (POINTER_T) pheader;
            else
               pkeylist->first_key = (POINTER_T) pkey - (POINTER_T) pheader;
            
            /* set key properties */
            pkey->type = TID_KEY;
            pkey->num_values = 1;
            pkey->access_mode = MODE_READ | MODE_WRITE | MODE_DELETE;
            mstrlcpy(pkey->name, name, sizeof(pkey->name));
            pkey->parent_keylist = (POINTER_T) pkeylist - (POINTER_T) pheader;
            
            /* find space for new keylist */
            pkeylist = (KEYLIST *) malloc_key(pheader, sizeof(KEYLIST), "db_create_key_B");
            
            if (pkeylist == NULL) {
               db_msg(msg, MERROR, "db_create_key", "online database full while creating \'%s\' in \'%s'", key_name, db_get_path_pkey(pheader, parentKey).c_str());
               return DB_FULL;
            }
            
            /* store keylist in data field */
            pkey->data = (POINTER_T) pkeylist - (POINTER_T) pheader;
            pkey->item_size = sizeof(KEYLIST);
            pkey->total_size = sizeof(KEYLIST);
            
            pkeylist->parent = (POINTER_T) pkey - (POINTER_T) pheader;
            pkeylist->num_keys = 0;
            pkeylist->first_key = 0;
 
            pcreated = pkey;
            pdir = pkey; // descend into newly created subdirectory
         } else {
            /* create new key with data */
            KEY* pkey = (KEY *) malloc_key(pheader, sizeof(KEY), "db_create_key_data");
            
            if (pkey == NULL) {
               if (pkeylist->num_keys > 0)
                  pkeylist->num_keys--;
 
               db_msg(msg, MERROR, "db_create_key", "online database full while creating \'%s\' in \'%s\'", key_name, db_get_path_pkey(pheader, parentKey).c_str());
               return DB_FULL;
            }
            
            /* append key to key list */
            if (pprev)
               pprev->next_key = (POINTER_T) pkey - (POINTER_T) pheader;
            else
               pkeylist->first_key = (POINTER_T) pkey - (POINTER_T) pheader;
            
            pkey->type = type;
            pkey->num_values = 1;
            pkey->access_mode = MODE_READ | MODE_WRITE | MODE_DELETE;
            mstrlcpy(pkey->name, name, sizeof(pkey->name));
            pkey->parent_keylist = (POINTER_T) pkeylist - (POINTER_T) pheader;
            
            /* allocate data */
            pkey->item_size = rpc_tid_size(type);
            if (pkey->item_size > 0) {
               void* data = malloc_data(pheader, pkey->item_size);
               if (data == NULL) {
                  pkey->total_size = 0;
                  db_msg(msg, MERROR, "db_create_key", "online database full while creating \'%s\' in \'%s\'", key_name, db_get_path_pkey(pheader, parentKey).c_str());
                  return DB_FULL;
               }
               
               pkey->total_size = pkey->item_size;
               pkey->data = (POINTER_T)data - (POINTER_T)pheader;
            } else {
               /* first data is empty */
               pkey->item_size = 0;
               pkey->total_size = 0;
               pkey->data = 0;
            }
            pcreated = pkey;
         }
      } else {
         /* key found: descend */
         
         /* resolve links */
         if (pitem->type == TID_LINK && pkey_name[0]) {
            pdir = db_resolve_link_locked(pheader, pitem, &status, msg);
            if (!pdir) {
               return status;
            }
            continue;
         }
         
         if (!(*pkey_name == '/')) {
            if (pitem->type != type) {
               db_msg(msg, MERROR, "db_create_key", "object of type %d already exists at \"%s\" while creating \'%s\' of type %d in \'%s\'", pitem->type, db_get_path_pkey(pheader, pitem).c_str(), key_name, type, db_get_path_pkey(pheader, parentKey).c_str());
               return DB_TYPE_MISMATCH;
            }
            //db_print_pkey(pheader, pitem);
 
            if (pnewkey)
               *pnewkey = (KEY*)pitem;
 
            return DB_KEY_EXIST;
         }
         
         if (pitem->type != TID_KEY) {
            db_msg(msg, MERROR, "db_create_key", "path element \"%s\" in \"%s\" is not a subdirectory at \"%s\" while creating \'%s\' in \'%s\'", name, key_name, db_get_path_pkey(pheader, pitem).c_str(), key_name, db_get_path_pkey(pheader, parentKey).c_str());
            return DB_TYPE_MISMATCH;
         }
         
         pdir = pitem;
      }
   } while (*pkey_name == '/');
 
   assert(pcreated != NULL);
   
   if (pnewkey)
      *pnewkey = pcreated;
 
   return DB_SUCCESS;
}
 
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_create_link(HNDLE hDB, HNDLE hKey, const char *link_name, const char *destination)
{
   HNDLE hkey;
   int status;
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_CREATE_LINK, hDB, hKey, link_name, destination);
 
   if (destination == NULL) {
      cm_msg(MERROR, "db_create_link", "link destination name is NULL");
      return DB_INVALID_NAME;
   }
 
   if (destination[0] != '/') {
      cm_msg(MERROR, "db_create_link", "link destination name \'%s\' should start with \'/\', relative links are forbidden", destination);
      return DB_INVALID_NAME;
   }
 
   if (strlen(destination) < 1) {
      cm_msg(MERROR, "db_create_link", "link destination name \'%s\' is too short", destination);
      return DB_INVALID_NAME;
   }
 
   if ((destination[0] == '/') && (destination[1] == 0)) {
      cm_msg(MERROR, "db_create_link", "links to \"/\" are forbidden");
      return DB_INVALID_NAME;
   }
 
   /* check if destination exists */
   status = db_find_key(hDB, hKey, destination, &hkey);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "db_create_link", "Link destination \"%s\" does not exist", destination);
      return DB_NO_KEY;
   }
 
   //printf("db_create_link: [%s] hkey %d\n", destination, hkey);
 
   /* check if link already exists */
   status = db_find_link(hDB, hKey, link_name, &hkey);
   if (status != DB_SUCCESS) {
      // create new link
      status = db_set_value(hDB, hKey, link_name, destination, strlen(destination) + 1, 1, TID_LINK);
   } else {
      // check if key is TID_LINK
      KEY key;
      db_get_key(hDB, hkey, &key);
      if (key.type != TID_LINK) {
         cm_msg(MERROR, "db_create_link", "Existing key \"%s\" is not a link", link_name);
         return DB_KEY_EXIST;
      }
 
      // modify existing link
      status = db_set_link_data(hDB, hkey, destination, strlen(destination)+1, 1, TID_LINK);
   }
 
   return status;
}
 
/********************************************************************/
#ifdef LOCAL_ROUTINES
static int db_check_open_record(const DATABASE_HEADER* pheader, const KEY* pkey, db_err_msg** msg)
{
   int status = 0;
 
   while (1) {
#ifdef CHECK_OPEN_RECORD
      if (pkey->notify_count) {
         return DB_OPEN_RECORD;
      }
#endif
      if (pkey->parent_keylist == 0) // top level
         return DB_SUCCESS;
 
      const KEY* pparent = db_get_parent(pheader, pkey, &status, "db_delete_key_locked", msg);
 
      if (!pparent)
         return status;
 
      pkey = pparent;
   };
 
   return DB_SUCCESS;
}
 
static int db_delete_key_locked(DATABASE* pdb, const KEY *pkey, int level, db_err_msg** msg)
{
   INT status;
 
   DATABASE_HEADER* pheader = pdb->database_header;
   
   //printf("db_delete_key_locked: path \"%s\", level %d\n", db_get_path_pkey(pheader, pkey).c_str(), level);
   
   /* check if someone has opened key or parent */
   if (level == 0) {
      status = db_check_open_record(pheader, pkey, msg);
      if (status != DB_SUCCESS) {
         return status;
      }
   }
   
   bool deny_delete = false;
   
   if (pkey->type == TID_KEY) { // delete contents of subdirectory
 
      const KEY* pkey1 = db_enum_first_locked(pheader, pkey, msg);
      
      while (pkey1) {
         const KEY* pkeynext = db_enum_next_locked(pheader, pkey, pkey1, msg);
         
         status = db_delete_key_locked(pdb, pkey1, level + 1, msg);
         
         if (status == DB_NO_ACCESS)
            deny_delete = true;
            
         pkey1 = pkeynext;
      }
   }
 
   HNDLE hKey = db_pkey_to_hkey(pheader, pkey);
   
   /* return if key was already deleted by cyclic link */
 
   if (pkey->parent_keylist == 0) {
      return DB_SUCCESS;
   }
 
   /* do not delete the root */
 
   if (hKey == pheader->root_key) {
      return DB_SUCCESS;
   }
 
   /* check delete permission */
 
   if (!(pkey->access_mode & MODE_DELETE) || deny_delete) {
      return DB_NO_ACCESS;
   }
 
   /* check open record */
 
#ifdef CHECK_OPEN_RECORD
   if (pkey->notify_count) {
      return DB_OPEN_RECORD;
   }
#endif
 
   /* now delete key */
 
   /* make ODB writable */
 
   db_allow_write_locked(pdb, "db_delete_key_locked");
 
   /* delete key data */
 
   // FIXME: validate pkey->data and pkey->total_size.
 
   if (pkey->type == TID_KEY) {
      free_key(pheader, (char *) pheader + pkey->data, pkey->total_size);
   } else {
      free_data(pheader, (char *) pheader + pkey->data, pkey->total_size, "db_delete_key_locked");
   }
 
   /* unlink key from parent directory key list */
 
   const KEY *pkey_parent = db_get_parent(pheader, pkey, &status, "db_delete_key_locked", msg);
 
   const KEYLIST* pkeylist = db_get_pkeylist(pheader, pkey_parent, "db_delete_key_locked", msg);
 
   if (pkeylist->first_key == hKey) {
      /* key is first in list */
      ((KEYLIST*)pkeylist)->first_key = pkey->next_key;
   } else {
      const KEY* pkey1 = db_enum_first_locked(pheader, pkey_parent, msg);
      
      while (pkey1) {
         if (pkey1->next_key == hKey) {
            ((KEY*)pkey1)->next_key = pkey->next_key;
            break;
         }
         
         pkey1 = db_enum_next_locked(pheader, pkey_parent, pkey1, msg);
      }
   }
 
   ((KEYLIST*)pkeylist)->num_keys--;
   
   /* poison deleted key */
 
   KEY* wpkey = (KEY*)pkey;
 
   wpkey->type = 9999;
   wpkey->num_values = 0;
   wpkey->data = 0;
   wpkey->total_size = 0;
   wpkey->item_size = 0;
   wpkey->next_key = 0;
   wpkey->parent_keylist = 0;
   wpkey->access_mode = 0;
   wpkey->notify_count = 0;
   wpkey->last_written = 0;
 
   /* free key memory */
 
   free_key(pheader, wpkey, sizeof(KEY));
 
   return DB_SUCCESS;
}
 
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_delete_key(HNDLE hDB, HNDLE hKey, BOOL follow_links)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_DELETE_KEY, hDB, hKey, FALSE);
 
#ifdef LOCAL_ROUTINES
 
   int status = DB_SUCCESS;
   
   DATABASE* pdb = db_lock_database(hDB, &status, "db_delete_key");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const KEY* pkey = db_get_pkey(pdb->database_header, hKey, &status, "db_delete_key", &msg);
 
   if (pkey) {
      status = db_delete_key_locked(pdb, pkey, 0, &msg);
   }
   
   db_unlock_database(pdb, "db_delete_key");
   
   if (msg)
      db_flush_msg(&msg);
   
   return status;
#else
   return DB_SUCCESS;
#endif
}
 
INT db_delete_key(HNDLE hDB, HNDLE hKey)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_DELETE_KEY, hDB, hKey, FALSE);
 
#ifdef LOCAL_ROUTINES
 
   int status = DB_SUCCESS;
   
   DATABASE* pdb = db_lock_database(hDB, &status, "db_delete_key");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const KEY* pkey = db_get_pkey(pdb->database_header, hKey, &status, "db_delete_key", &msg);
 
   if (pkey) {
      status = db_delete_key_locked(pdb, pkey, 0, &msg);
   }
   
   db_unlock_database(pdb, "db_delete_key");
   
   if (msg)
      db_flush_msg(&msg);
   
   return status;
#else
   return DB_SUCCESS;
#endif
}
 
INT db_delete(HNDLE hDB, HNDLE hKeyRoot, const char* odb_path)
{
   if (rpc_is_remote()) {
      HNDLE hKey;
      int status = db_find_link(hDB, hKeyRoot, odb_path, &hKey);
      if (status != DB_SUCCESS)
         return status;
      return db_delete_key(hDB, hKey);
   }
 
#ifdef LOCAL_ROUTINES
 
   int status = DB_SUCCESS;
   
   DATABASE* pdb = db_lock_database(hDB, &status, "db_delete");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const KEY* pkeyroot = db_get_pkey(pdb->database_header, hKeyRoot, &status, "db_delete", &msg);
 
   if (pkeyroot) {
      const KEY* pkey = db_find_pkey_locked(pdb->database_header, pkeyroot, odb_path, false, &status, &msg);
 
      if (pkey) {
         status = db_delete_key_locked(pdb, pkey, 0, &msg);
      }
   }
   
   db_unlock_database(pdb, "db_delete");
   
   if (msg)
      db_flush_msg(&msg);
   
   return status;
#else
   return DB_SUCCESS;
#endif
}
 
#ifdef LOCAL_ROUTINES
static const KEY* db_find_pkey_locked(const DATABASE_HEADER *pheader, const KEY* pkey, const char *key_name, bool follow_links, int *pstatus, db_err_msg **msg)
{
   if (pkey == NULL) {
      pkey = db_get_pkey(pheader, pheader->root_key, pstatus, "db_find_key", msg);
      if (!pkey) {
         return NULL;
      }
   }
 
   if (pkey->type != TID_KEY) {
      DWORD tid = pkey->type;
      std::string path = db_get_path_pkey(pheader, pkey);
      db_msg(msg, MERROR, "db_find_key", "Path \"%s\" tid %d is not a directory, looking for \"%s\"", path.c_str(), tid, key_name);
      if (pstatus)
         *pstatus = DB_NO_KEY;
      return NULL;
   }
   
   if (key_name[0] == 0 || strcmp(key_name, "/") == 0) {
      if (!(pkey->access_mode & MODE_READ)) {
         if (pstatus)
            *pstatus = DB_NO_ACCESS;
         return NULL;
      }
      return pkey;
   }
 
   const KEYLIST *pkeylist = db_get_pkeylist(pheader, pkey, "db_find_key", msg);
   if (!pkeylist) {
      if (pstatus)
         *pstatus = DB_CORRUPTED;
      return NULL;
   }
 
   HNDLE hKey = db_pkey_to_hkey(pheader, pkey);
 
   HNDLE last_good_hkey = hKey;
 
   const char *pkey_name = key_name;
   do {
      assert(pkeylist!=NULL); // should never happen!
 
      char str[MAX_ODB_PATH];
         
      /* extract single subkey from key_name */
      pkey_name = extract_key(pkey_name, str, sizeof(str));
 
      /* strip trailing '[n]' */
      if (strchr(str, '[') && str[strlen(str) - 1] == ']')
         *strchr(str, '[') = 0;
 
      /* check if parent or current directory */
      if (strcmp(str, "..") == 0) {
         if (pkey->parent_keylist) {
            pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
            // FIXME: validate pkeylist->parent
            pkey = (KEY *) ((char *) pheader + pkeylist->parent);
         }
         continue;
      }
      if (strcmp(str, ".") == 0)
         continue;
 
      last_good_hkey = hKey;
 
      hKey = pkeylist->first_key;
 
      if (hKey == 0) {
         // empty subdirectory
         if (pstatus)
            *pstatus = DB_NO_KEY;
         return NULL;
      }
 
      int i;
      for (i = 0; i < pkeylist->num_keys; i++) {
         pkey = db_get_pkey(pheader, hKey, pstatus, "db_find_key", msg);
         
         if (!pkey) {
            std::string path = db_get_path_locked(pheader, last_good_hkey);
            db_msg(msg, MERROR, "db_find_key", "hkey %d path \"%s\" invalid subdirectory entry hkey %d, looking for \"%s\"", last_good_hkey, path.c_str(), hKey, key_name);
            return NULL;
         }
 
         if (!db_validate_key_offset(pheader, pkey->next_key)) {
            std::string path = db_get_path_locked(pheader, hKey);
            db_msg(msg, MERROR, "db_find_key", "hkey %d path \"%s\" invalid next_key %d, looking for \"%s\"", hKey, path.c_str(), pkey->next_key, key_name);
            if (pstatus)
               *pstatus = DB_CORRUPTED;
            return NULL;
         }
 
         if (equal_ustring(str, pkey->name))
            break;
 
         if (pkey->next_key == 0) {
            if (pstatus)
               *pstatus = DB_NO_KEY;
            return NULL;
         }
 
         hKey = pkey->next_key;
      }
 
      if (i == pkeylist->num_keys) {
         if (pstatus)
            *pstatus = DB_NO_KEY;
         return NULL;
      }
 
      /* resolve links */
      if (pkey->type == TID_LINK && follow_links) {
         /* copy destination, strip '/' */
         mstrlcpy(str, (char *) pheader + pkey->data, sizeof(str));
         if (str[strlen(str) - 1] == '/')
            str[strlen(str) - 1] = 0;
 
         /* if link is pointer to array index, return link instead of destination */
         if (str[strlen(str) - 1] == ']')
            break;
 
         /* append rest of key name if existing */
         if (pkey_name[0]) {
            mstrlcat(str, pkey_name, sizeof(str));
            return db_find_pkey_locked(pheader, NULL, str, follow_links, pstatus, msg);
         } else {
            /* if last key in chain is a link, return its destination */
            int status = 0;
            const KEY *plink = db_find_pkey_locked(pheader, NULL, str, follow_links, &status, msg);
            if (pstatus) {
               if (status == DB_NO_KEY)
                  *pstatus = DB_INVALID_LINK;
               else
                  *pstatus = status;
            }
            return plink;
         }
      }
 
      /* key found: check if last in chain */
      if (*pkey_name == '/') {
         if (pkey->type != TID_KEY) {
            if (pstatus)
               *pstatus = DB_NO_KEY;
            return NULL;
         }
      }
 
      if (pkey->type == TID_KEY) {
         /* descend one level */
         pkeylist = db_get_pkeylist(pheader, pkey, "db_find_key", msg);
         
         if (!pkeylist) {
            if (pstatus)
               *pstatus = DB_CORRUPTED;
            return NULL;
         }
      } else {
         pkeylist = NULL;
      }
 
   } while (*pkey_name == '/' && *(pkey_name + 1));
 
   return pkey;
}
 
static int db_find_key_locked(const DATABASE_HEADER *pheader, HNDLE hKey, const char *key_name, bool follow_links, HNDLE *subhKey, db_err_msg **msg)
{
   int status;
   const KEY* pkey = db_get_pkey(pheader, hKey, &status, "db_find_key", msg);
   if (!pkey) {
      if (subhKey)
         *subhKey = 0;
      return status;
   }
 
   const KEY* plink = db_find_pkey_locked(pheader, pkey, key_name, follow_links, &status, msg);
 
   if (!plink) {
      *subhKey = 0;
      return status;
   }
 
   *subhKey = db_pkey_to_hkey(pheader, plink);
 
   return DB_SUCCESS;
}
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_find_key(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE * subhKey)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_FIND_KEY, hDB, hKey, key_name, subhKey);
 
#ifdef LOCAL_ROUTINES
   {
      if (subhKey)
         *subhKey = 0;
 
      INT status = DB_SUCCESS;
 
      DATABASE* pdb = db_lock_database(hDB, &status, "db_find_key");
 
      if (!pdb)
         return status;
 
      db_err_msg *msg = NULL;
 
      status = db_find_key_locked(pdb->database_header, hKey, key_name, true, subhKey, &msg);
   
      db_unlock_database(pdb, "db_find_key");
 
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_find_link(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE * subhKey)
/********************************************************************\
 
  Routine: db_find_link
 
  Purpose: Find a key or link by name and return its handle
           (internal address). The only difference of this routine
           compared with db_find_key is that if the LAST key in
           the chain is a link, it is NOT evaluated. Links not being
           the last in the chain are evaluated.
 
  Input:
    HNDLE  bufer_handle     Handle to the database
    HNDLE  hKey       Key handle to start the search
    char   *key_name        Name of key in the form "/key/key/key"
 
  Output:
    INT    *handle          Key handle
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_KEY               Key doesn't exist
    DB_NO_ACCESS            No access to read key
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_FIND_LINK, hDB, hKey, key_name, subhKey);
 
#ifdef LOCAL_ROUTINES
   {
      if (subhKey)
         *subhKey = 0;
 
      INT status = DB_SUCCESS;
 
      DATABASE* pdb = db_lock_database(hDB, &status, "db_find_link");
 
      if (!pdb)
         return status;
 
      db_err_msg *msg = NULL;
 
      status = db_find_key_locked(pdb->database_header, hKey, key_name, false, subhKey, &msg);
   
      db_unlock_database(pdb, "db_find_link");
 
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_find_keys(HNDLE hDB, HNDLE hKeyRoot, const char* odbpath, std::vector<HNDLE> &hKeyVector)
/********************************************************************\
 
  Routine: db_find_keys
 
  Purpose: finds all ODB keys matching an odb path
           '*' and '?' wildcard expansion available
 
  Input:
    HNDLE               hDB              Handle to the database
    HNDLE               hKeyRoot         Key handle to start the search
    char                *odbpath         Pattern of keys in the form "/key/key/key", can include '*' and '?'
 
  Output:
    std::vector<HNDLE>  &hKeyVector      Key handle
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_KEY               No access to any key
    DB_NO_ACCESS            No access to a read key
 
\********************************************************************/
{
      HNDLE hKey;
      INT status;
      char *pattern = NULL;
      char *subkeypath = NULL;
      char *parentkeypath = NULL;
      char localpath[MAX_ODB_PATH];
 
      //make work on a local copy od odbpath to allow recursion
      mstrlcpy(localpath, odbpath, sizeof(localpath));
      parentkeypath = localpath;
 
      //printf("localpath [%s]\n", localpath);
 
      char *wildcard = strpbrk(localpath, "*?");
      if (wildcard) {
         //wildcard found
         subkeypath = strchr(wildcard, '/');
         if (subkeypath) {
            //truncate the string at slash
            *subkeypath = 0;
            subkeypath++;
         }
         parentkeypath = strrchr(localpath, '/');
         if (parentkeypath) {
            //truncate there too
            *parentkeypath = 0;
            pattern = parentkeypath+1;
            if((parentkeypath-1) == localpath){
               //path starts with '/', no parent path
               parentkeypath = NULL;
            } else {
               parentkeypath = localpath;
            }
         } else {
            //wildcard at top level, start with pattern
            pattern = localpath;
            parentkeypath = NULL;
         }
      }
 
      //printf("pattern [%s]\n", pattern);
      //printf("parentkeypath [%s]\n", parentkeypath);
      //printf("subkeypath [%s]\n", subkeypath);
 
      //if available search for parent key path
      if (parentkeypath) {
         status = db_find_key(hDB, hKeyRoot, parentkeypath, &hKey);
         if (status != DB_SUCCESS)
            return status;
      } else {
         hKey = hKeyRoot;
      }
 
      //printf("hKeyRoot %d, hKey %d\n", hKeyRoot, hKey);
 
      if (!pattern) {
         //no pattern: hKey matches!
         hKeyVector.push_back(hKey);
         return DB_SUCCESS;
      }
      
      // try match all subkeys
 
      for (int i=0 ; ; i++) {
         HNDLE hSubKey;
 
         db_enum_key(hDB, hKey, i, &hSubKey);
 
         if (!hSubKey)
            break; // end of list reached
 
         KEY key;
 
         status = db_get_key(hDB, hSubKey, &key);
 
         if (status != DB_SUCCESS)
            continue;
 
         bool match = strmatch(pattern, key.name);
 
         //printf("match pattern [%s] name [%s] yields %d\n", pattern, key.name, match);
         
         if (match) {
            if (!subkeypath) {
               //found
               hKeyVector.push_back(hSubKey);
            } else if (key.type == TID_KEY) {
               //recurse with hSubKey as root key and subkeypath as path
               db_find_keys(hDB, hSubKey, subkeypath, hKeyVector);
            }
         }
      }
 
      if (hKeyVector.empty())
         return DB_NO_KEY;
      
      return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_get_parent(HNDLE hDB, HNDLE hKey, HNDLE * parenthKey)
/********************************************************************\
 
  Routine: db_get_parent
 
  Purpose: return an handle to the parent key
 
  Input:
    HNDLE  bufer_handle     Handle to the database
    HNDLE  hKey       Key handle of the key
 
  Output:
    INT    *handle          Parent key handle
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_PARENT, hDB, hKey, parenthKey);
 
#ifdef LOCAL_ROUTINES
   {
 
      DATABASE_HEADER *pheader;
      const KEY *pkey;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_parent", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_parent", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_parent", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
      pkey = (const KEY *) ((char *) pheader + hKey);
 
      /* find parent key */
      const KEYLIST *pkeylist = (const KEYLIST *) ((char *) pheader + pkey->parent_keylist);
 
      if (!db_validate_hkey(pheader, pkeylist->parent)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (const KEY *) ((char *) pheader + pkeylist->parent);
 
      *parenthKey = (POINTER_T) pkey - (POINTER_T) pheader;
 
      db_unlock_database(hDB);
   }
#endif
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_scan_tree(HNDLE hDB, HNDLE hKey, INT level, INT(*callback) (HNDLE, HNDLE, KEY *, INT, void *), void *info)
/********************************************************************\
 
  Routine: db_scan_tree
 
  Purpose: Scan a subtree recursively and call 'callback' for each key
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKeyRoot         Key to start scan from, 0 for root
    INT    level            Recursion level
    void   *callback        Callback routine called with params:
                              hDB   Copy of hDB
                              hKey  Copy of hKey
                              key   Key associated with hKey
                              INT   Recursion level
                              info  Copy of *info
    void   *info            Optional data copied to callback routine
 
  Output:
    implicit via callback
 
  Function value:
    DB_SUCCESS              Successful completion
    <all error codes of db_get_key>
 
\********************************************************************/
{
   HNDLE hSubkey;
   KEY key;
   INT i, status;
 
   status = db_get_link(hDB, hKey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   status = callback(hDB, hKey, &key, level, info);
   if (status == 0)
      return status;
 
   if (key.type == TID_KEY) {
      for (i = 0;; i++) {
         db_enum_link(hDB, hKey, i, &hSubkey);
 
         if (!hSubkey)
            break;
 
         db_scan_tree(hDB, hSubkey, level + 1, callback, info);
      }
   }
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
 
int db_scan_tree_locked(const DATABASE_HEADER* pheader, const KEY* pkey, int level, int(*callback) (const DATABASE_HEADER* pheader, const KEY *, int, void *, db_err_msg** msg), void *info, db_err_msg** msg)
{
   assert(pkey != NULL);
 
   if (level >= MAX_ODB_PATH) {
      db_msg(msg, MERROR, "db_scan_tree_locked", "Max ODB depth level %d exceeded", MAX_ODB_PATH);
      return DB_TRUNCATED;
   }
 
   int status = callback(pheader, pkey, level, info, msg);
   if (status == 0)
      return status;
 
   if (pkey->type == TID_KEY) {
      const KEY* subkey = db_enum_first_locked(pheader, pkey, msg);
      while (subkey != NULL) {
         db_scan_tree_locked(pheader, subkey, level + 1, callback, info, msg);
         subkey = db_enum_next_locked(pheader, pkey, subkey, msg);
      }
   }
 
   return DB_SUCCESS;
}
 
#endif // LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
INT db_scan_tree_link(HNDLE hDB, HNDLE hKey, INT level, void (*callback) (HNDLE, HNDLE, KEY *, INT, void *), void *info)
/********************************************************************\
 
  Routine: db_scan_tree_link
 
  Purpose: Scan a subtree recursively and call 'callback' for each key.
           Similar to db_scan_tree but without following links.
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKeyRoot         Key to start scan from, 0 for root
    INT    level            Recursion level
    void   *callback        Callback routine called with params:
                              hDB   Copy of hDB
                              hKey  Copy of hKey
                              key   Key associated with hKey
                              INT   Recursion level
                              info  Copy of *info
    void   *info            Optional data copied to callback routine
 
  Output:
    implicit via callback
 
  Function value:
    DB_SUCCESS              Successful completion
    <all error codes of db_get_key>
 
\********************************************************************/
{
   HNDLE hSubkey;
   KEY key;
   INT i, status;
 
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   callback(hDB, hKey, &key, level, info);
 
   if (key.type == TID_KEY) {
      for (i = 0;; i++) {
         db_enum_link(hDB, hKey, i, &hSubkey);
 
         if (!hSubkey)
            break;
 
         db_scan_tree_link(hDB, hSubkey, level + 1, callback, info);
      }
   }
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
/*------------------------------------------------------------------*/
static std::string db_get_path_pkey(const DATABASE_HEADER* pheader, const KEY* pkey)
{
   std::string path = "";
   int level = 0;
   while (1) {
      //printf("db_get_path_pkey: hkey %d, pkey name \"%s\", type %d, parent %d, path \"%s\"\n", hKey, pkey->name, pkey->type, pkey->parent_keylist, path.c_str());
 
      /* check key type */
      if (pkey->type <= 0 || pkey->type >= TID_LAST) {
         std::string xpath = msprintf("(INVALID_KEY_TYPE_%d)", pkey->type);;
         if (path.length() > 0) {
            xpath += "/";
            xpath += path;
         }
         return xpath;
      }
 
      /* add key name in front of path */
      std::string str = path;
      path = "";
      if (pkey->name[0] == 0) {
         path += "(EMPTY_NAME)";
      } else {
         path += pkey->name;
      }
      if (str.length() > 0)
         path += "/";
      path += str;
 
      if (!pkey->parent_keylist) {
         return path;
      }
      
      if (!db_validate_data_offset(pheader, pkey->parent_keylist)) {
         return "(INVALID_PARENT_KEYLIST)/" + path;
      }
 
      /* find parent key */
      const KEYLIST* pkeylist = (const KEYLIST *) ((char *) pheader + pkey->parent_keylist);
 
      if (pkeylist->parent == pheader->root_key) {
         return "/" + path;
      }
 
      if (pkeylist->parent == 0) {
         return "(NULL_PARENT)/" + path;
      }
 
      if (!db_validate_key_offset(pheader, pkeylist->parent)) {
         return "(INVALID_PARENT)/" + path;
      }
 
      pkey = (const KEY *) ((char *) pheader + pkeylist->parent);
 
      level ++;
 
      if (level >= MAX_ODB_PATH) {
         return "(TRUNCATED)/" + path;
      }
   };
 
   /* NOT REACHED */
}
 
/*------------------------------------------------------------------*/
static std::string db_get_path_locked(const DATABASE_HEADER* pheader, HNDLE hKey)
{
   //printf("db_get_path_locked: hkey %d\n", hKey);
 
   if (!hKey)
      hKey = pheader->root_key;
 
   if (hKey == pheader->root_key) {
      return "/";
   }
 
   /* check if hKey argument is correct */
   if (hKey == 0) {
      return "(ZERO_HKEY)";
   }
 
   /* check if hKey argument is correct */
   if (!db_validate_key_offset(pheader, hKey)) {
      return "(INVALID_HKEY)";
   }
 
   const KEY* pkey = (const KEY *) ((char *) pheader + hKey);
 
   return db_get_path_pkey(pheader, pkey);
}
#endif /* LOCAL_ROUTINES */
 
/*------------------------------------------------------------------*/
INT db_get_path(HNDLE hDB, HNDLE hKey, char *path, INT buf_size)
/********************************************************************\
 
  Routine: db_get_path
 
  Purpose: Get full path of a key
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Key handle
    INT    buf_size         Maximum size of path buffer (including
                            trailing zero)
 
  Output:
    char   path[buf_size]   Path string
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_MEMORY            path buffer is to small to contain full
                            string
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_PATH, hDB, hKey, path, buf_size);
 
#ifdef LOCAL_ROUTINES
   {
      int status = 0;
 
      DATABASE* pdb = db_lock_database(hDB, &status, "db_get_path");
 
      if (!pdb)
         return status;
 
      std::string xpath = db_get_path_locked(pdb->database_header, hKey);
 
      db_unlock_database(pdb, "db_get_path");
 
      mstrlcpy(path, xpath.c_str(), buf_size);
 
      return DB_SUCCESS;
   }
#endif /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
std::string db_get_path(HNDLE hDB, HNDLE hKey)
/********************************************************************\
 
  Routine: db_get_path
 
  Purpose: Get full path of a key
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Key handle
 
  Function value:           Path string
 
\********************************************************************/
{
   if (rpc_is_remote()) {
      char path[MAX_ODB_PATH];
      int status = rpc_call(RPC_DB_GET_PATH, hDB, hKey, path, sizeof(path));
      if (status != DB_SUCCESS) {
         return msprintf("(RPC_DB_GET_PATH status %d)", status);
      }
      return path;
   }
 
#ifdef LOCAL_ROUTINES
   {
      int status = DB_SUCCESS;
 
      DATABASE* pdb = db_lock_database(hDB, &status, "db_get_path");
 
      if (!pdb)
         return "(CANNOT LOCK ODB)";
 
      std::string xpath = db_get_path_locked(pdb->database_header, hKey);
 
      db_unlock_database(pdb, "db_get_path");
 
      return xpath;
   }
#endif /* LOCAL_ROUTINES */
 
   return "(no LOCAL_ROUTINES)";
}
 
#ifdef LOCAL_ROUTINES
/*------------------------------------------------------------------*/
static int db_find_open_records(HNDLE hDB, HNDLE hKey, KEY * key, INT level, void *xresult)
{
   /* check if this key has notify count set */
   if (key->notify_count) {
 
      db_lock_database(hDB);
 
      DATABASE_HEADER *pheader = _database[hDB - 1].database_header;
 
      std::string path = db_get_path_locked(pheader, hKey);
 
      std::string line = msprintf("%s open %d times by", path.c_str(), key->notify_count);
 
      //printf("path [%s] key.name [%s]\n", path, key->name);
 
      int count = 0;
      for (int i = 0; i < pheader->max_client_index; i++) {
         DATABASE_CLIENT *pclient = &pheader->client[i];
         for (int j = 0; j < pclient->max_index; j++)
            if (pclient->open_record[j].handle == hKey) {
               count++;
               line += " \"";
               line += pclient->name;
               line += "\"";
               //sprintf(line + strlen(line), ", handle %d, mode %d ", pclient->open_record[j].handle, pclient->open_record[j].access_mode);
            }
      }
 
      if (count < 1) {
         line += " a deleted client";
      }
 
      line += "\n";
 
      std::string *result = (std::string*)xresult;
      *result += line;
 
      db_unlock_database(hDB);
   }
   return DB_SUCCESS;
}
 
static int db_fix_open_records(HNDLE hDB, HNDLE hKey, KEY * key, INT level, void *xresult)
{
   std::string *result = (std::string*)xresult;
   
   /* check if this key has notify count set */
   if (key->notify_count) {
      db_lock_database(hDB);
      DATABASE_HEADER *pheader = _database[hDB - 1].database_header;
      db_allow_write_locked(&_database[hDB - 1], "db_fix_open_records");
 
      int i;
      for (i = 0; i < pheader->max_client_index; i++) {
         DATABASE_CLIENT *pclient = &pheader->client[i];
         int j;
         for (j = 0; j < pclient->max_index; j++)
            if (pclient->open_record[j].handle == hKey)
               break;
         if (j < pclient->max_index)
            break;
      }
      if (i == pheader->max_client_index) {
         /* check if hKey argument is correct */
         if (!db_validate_hkey(pheader, hKey)) {
            db_unlock_database(hDB);
            return DB_SUCCESS;
         }
 
         /* reset notify count */
         KEY *pkey = (KEY *) ((char *) pheader + hKey);
         pkey->notify_count = 0;
 
         std::string path = db_get_path_locked(pheader, hKey);
         *result += path;
         *result += " fixed\n";
      }
 
      db_unlock_database(hDB);
   }
   return DB_SUCCESS;
}
#endif                          /* LOCAL_ROUTINES */
 
INT db_get_open_records(HNDLE hDB, HNDLE hKey, char *str, INT buf_size, BOOL fix)
/********************************************************************\
 
  Routine: db_get_open_records
 
  Purpose: Return a string with all open records
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Key to start search from, 0 for root
    INT    buf_size         Size of string
    INT    fix              If TRUE, fix records which are open
                            but have no client belonging to it.
 
  Output:
    char   *str             Result string. Individual records are
                            separated with new lines.
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   str[0] = 0;
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_OPEN_RECORDS, hDB, hKey, str, buf_size);
 
   std::string result;
 
#ifdef LOCAL_ROUTINES
 
   if (fix)
      db_scan_tree(hDB, hKey, 0, db_fix_open_records, &result); // FIXME: should use db_scan_tree_wlocked()
   else
      db_scan_tree(hDB, hKey, 0, db_find_open_records, &result); // FIXME: should use db_scan_tree_locked()
 
#endif
 
   mstrlcpy(str, result.c_str(), buf_size);
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
/********************************************************************/
INT db_set_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const void *data,
                 INT data_size, INT num_values, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_VALUE, hDB, hKeyRoot, key_name, data, data_size, num_values, type);
 
#ifdef LOCAL_ROUTINES
   {
      INT status;
 
      if (num_values == 0)
         return DB_INVALID_PARAM;
 
      db_lock_database(hDB);
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      db_allow_write_locked(pdb, "db_set_value");
 
      db_err_msg* msg = NULL;
 
      KEY* pkey_root = (KEY*)db_get_pkey(pheader, hKeyRoot, &status, "db_set_value", &msg);
 
      if (pkey_root) {
         status = db_set_value_wlocked(pdb, pkey_root, key_name, data, data_size, num_values, type, &msg);
      }
 
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
static int db_set_value_wlocked(DATABASE* pdb, KEY* pkey_root, const char *key_name, const void *data, INT data_size, INT num_values, DWORD type, db_err_msg** msg)
{
   INT status;
 
   if (num_values == 0)
      return DB_INVALID_PARAM;
 
   DATABASE_HEADER* pheader = pdb->database_header;
   
   KEY* pkey = (KEY*)db_find_pkey_locked(pheader, pkey_root, key_name, true, &status, msg);
 
   if (!pkey) {
      status = db_create_key_wlocked(pheader, pkey_root, key_name, type, &pkey, msg);
      if (status != DB_SUCCESS && status != DB_CREATED)
         return status;
   }
 
   if (data_size == 0) {
      db_msg(msg, MERROR, "db_set_value", "zero data size not allowed");
      return DB_TYPE_MISMATCH;
   }
   
   if (type != TID_STRING && type != TID_LINK && data_size != rpc_tid_size(type) * num_values) {
      db_msg(msg, MERROR, "db_set_value", "\"%s\" data_size %d does not match tid %d size %d times num_values %d", key_name, data_size, type, rpc_tid_size(type), num_values);
      return DB_TYPE_MISMATCH;
   }
 
   status = db_check_set_data_locked(pheader, pkey, data, data_size, num_values, type, "db_set_value", msg);
 
   if (status != DB_SUCCESS)
      return status;
 
   status = db_set_data_wlocked(pheader, pkey, data, data_size, num_values, type, "db_set_value", msg);
 
   if (status != DB_SUCCESS)
      return status;
   
   db_notify_clients_locked(pdb, db_pkey_to_hkey(pheader, pkey), -1, TRUE, msg);
   
   return DB_SUCCESS;
}
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_set_value_index(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const void *data,
                       INT data_size, INT idx, DWORD type, BOOL trunc)
{
   int status;
   HNDLE hkey;
 
   status = db_find_key(hDB, hKeyRoot, key_name, &hkey);
   if (!hkey) {
      status = db_create_key(hDB, hKeyRoot, key_name, type);
      status = db_find_key(hDB, hKeyRoot, key_name, &hkey);
      if (status != DB_SUCCESS)
         return status;
   } else
      if (trunc) {
         status = db_set_num_values(hDB, hkey, idx + 1);
         if (status != DB_SUCCESS)
            return status;
      }
 
   return db_set_data_index(hDB, hkey, data, data_size, idx, type);
}
 
/********************************************************************/
INT db_get_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, void *data, INT * buf_size, DWORD type, BOOL create)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_VALUE, hDB, hKeyRoot, key_name, data, buf_size, type, create);
 
#ifdef LOCAL_ROUTINES
   {
      INT status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_value", "invalid database handle %d", hDB);
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_value", "invalid database handle %d", hDB);
         return DB_INVALID_HANDLE;
      }
 
      /* check if key name contains index */
      char keyname[MAX_ODB_PATH];
      mstrlcpy(keyname, key_name, sizeof(keyname));
      int idx = -1;
      if (strchr(keyname, '[') && strchr(keyname, ']')) {
         char* p;
         for (p = strchr(keyname, '[') + 1; *p && *p != ']'; p++)
            if (!isdigit(*p))
               break;
 
         if (*p && *p == ']') {
            idx = atoi(strchr(keyname, '[') + 1);
            *strchr(keyname, '[') = 0;
         }
      }
 
      /* now lock database */
      db_lock_database(hDB);
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
      db_err_msg* msg = NULL;
 
      const KEY* pkey_root = db_get_pkey(pheader, hKeyRoot, &status, "db_get_value", &msg);
 
      if (!pkey_root) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      const KEY* pkey = db_find_pkey_locked(pheader, pkey_root, keyname, true, &status, &msg);
 
      if (!pkey) {
         if (create) {
            db_allow_write_locked(&_database[hDB-1], "db_get_value");
            /* set default value if key was created */
 
            /* get string size from data size */
            int size;
            if (type == TID_STRING || type == TID_LINK)
               size = *buf_size;
            else
               size = rpc_tid_size(type);
 
            status = db_set_value_wlocked(pdb, (KEY*)pkey_root, keyname, data, *buf_size, *buf_size / size, type, &msg);
            db_unlock_database(hDB);
            if (msg)
               db_flush_msg(&msg);
            return status;
         } else {
            db_unlock_database(hDB);
            if (msg)
               db_flush_msg(&msg);
            return DB_NO_KEY;
         }
      }
 
      status = db_get_data_locked(pheader, pkey, idx, data, buf_size, type, &msg);
 
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
static INT db_get_data_locked(DATABASE_HEADER* pheader, const KEY* pkey, int idx, void *data, INT * buf_size, DWORD type, db_err_msg** msg)
{
   /* check for correct type */
   if (pkey->type != (type)) {
      db_msg(msg, MERROR, "db_get_data_locked", "odb entry \"%s\" is of type %s, not %s", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(pkey->type), rpc_tid_name(type));
      return DB_TYPE_MISMATCH;
   }
 
   /* check for correct type */
   if (pkey->type == TID_KEY) {
      db_msg(msg, MERROR, "db_get_data_locked", "odb entry \"%s\" is of type %s, cannot contain data", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(pkey->type));
      return DB_TYPE_MISMATCH;
   }
 
   /* check for read access */
   if (!(pkey->access_mode & MODE_READ)) {
      db_msg(msg, MERROR, "db_get_data_locked", "odb entry \"%s\" has no read access", db_get_path_pkey(pheader, pkey).c_str());
      return DB_NO_ACCESS;
   }
 
   /* check if buffer is too small */
   if ((idx == -1 && pkey->num_values * pkey->item_size > *buf_size) || (idx != -1 && pkey->item_size > *buf_size)) {
      memcpy(data, (char *) pheader + pkey->data, *buf_size);
      db_msg(msg, MERROR, "db_get_data_locked", "odb entry \"%s\" data truncated, size is %d (%d*%d), buffer size is only %d", db_get_path_pkey(pheader, pkey).c_str(), pkey->num_values * pkey->item_size, pkey->num_values, pkey->item_size, *buf_size);
      return DB_TRUNCATED;
   }
 
   /* check if index in boundaries */
   if (idx != -1 && idx >= pkey->num_values) {
      cm_msg(MERROR, "db_get_data_locked", "odb entry \"%s\" index %d is out of valid range 0..%d", db_get_path_pkey(pheader, pkey).c_str(), idx, pkey->num_values-1);
      return DB_INVALID_PARAM;
   }
 
   /* copy key data */
   if (idx == -1) {
      memcpy(data, (char *) pheader + pkey->data, pkey->num_values * pkey->item_size);
      *buf_size = pkey->num_values * pkey->item_size;
   } else {
      memcpy(data, (char *) pheader + pkey->data + idx * pkey->item_size, pkey->item_size);
      *buf_size = pkey->item_size;
   }
 
   return DB_SUCCESS;
}
#endif                          /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_enum_key(HNDLE hDB, HNDLE hKey, INT idx, HNDLE * subkey_handle)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_ENUM_KEY, hDB, hKey, idx, subkey_handle);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      INT i;
      HNDLE parent;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_enum_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_enum_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      *subkey_handle = 0;
 
      /* first lock database */
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
      if (!hKey)
         hKey = pheader->root_key;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg *msg = NULL;
      int status;
 
      const KEY* pkey = db_get_pkey(pheader, hKey, &status, "db_enum_key", &msg);
 
      if (!pkey) {
         db_unlock_database(hDB);
         db_flush_msg(&msg);
         return DB_NO_MORE_SUBKEYS;
      }
 
      if (pkey->type != TID_KEY) {
         db_unlock_database(hDB);
         return DB_NO_MORE_SUBKEYS;
      }
 
      const KEYLIST* pkeylist = db_get_pkeylist(pheader, pkey, "db_enum_key", &msg);
 
      if (!pkeylist) {
         db_unlock_database(hDB);
         db_flush_msg(&msg);
         return DB_NO_MORE_SUBKEYS;
      }
 
      if (idx >= pkeylist->num_keys) {
         db_unlock_database(hDB);
         return DB_NO_MORE_SUBKEYS;
      }
 
      pkey = db_get_pkey(pheader, pkeylist->first_key, &status, "db_enum_key", &msg);
      
      if (!pkey) {
         std::string path = db_get_path_locked(pheader, hKey);
         HNDLE xfirst_key = pkeylist->first_key;
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         cm_msg(MERROR, "db_enum_key", "hkey %d path \"%s\" invalid first_key %d", hKey, path.c_str(), xfirst_key);
         return DB_NO_MORE_SUBKEYS;
      }
 
      for (i = 0; i < idx; i++) {
         if (pkey->next_key == 0) {
            std::string path = db_get_path_locked(pheader, hKey);
            db_unlock_database(hDB);
            cm_msg(MERROR, "db_enum_key", "hkey %d path \"%s\" unexpected end of key list at index %d", hKey, path.c_str(), i);
            return DB_NO_MORE_SUBKEYS;
         }
 
         pkey = db_get_pkey(pheader, pkey->next_key, &status, "db_enum_key", &msg);
 
         if (!pkey) {
            std::string path = db_get_path_locked(pheader, hKey);
            db_unlock_database(hDB);
            db_flush_msg(&msg);
            cm_msg(MERROR, "db_enum_key", "hkey %d path \"%s\" invalid key list at index %d, next_key %d", hKey, path.c_str(), i, pkey->next_key);
            return DB_NO_MORE_SUBKEYS;
         }
      }
 
      /* resolve links */
      if (pkey->type == TID_LINK) {
         const char* str = (char *) pheader + pkey->data;
 
         /* no not resolve if link to array index */
         if (strlen(str) > 0 && str[strlen(str) - 1] == ']') {
            *subkey_handle = (POINTER_T) pkey - (POINTER_T) pheader;
            db_unlock_database(hDB);
            return DB_SUCCESS;
         }
 
         if (*str == '/') {
            /* absolute path */
            db_unlock_database(hDB);
            return db_find_key(hDB, 0, str, subkey_handle);
         } else {
            /* relative path */
            if (pkey->parent_keylist) {
               pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
               parent = pkeylist->parent;
               db_unlock_database(hDB);
               return db_find_key(hDB, parent, str, subkey_handle);
            } else {
               db_unlock_database(hDB);
               return db_find_key(hDB, 0, str, subkey_handle);
            }
         }
      }
 
      *subkey_handle = (POINTER_T) pkey - (POINTER_T) pheader;
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
 
/*------------------------------------------------------------------*/
INT db_enum_link(HNDLE hDB, HNDLE hKey, INT idx, HNDLE * subkey_handle)
/********************************************************************\
 
  Routine: db_enum_link
 
  Purpose: Enumerate subkeys from a key, don't follow links
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key to enumerate, zero for the
                            root key
    INT   idx               Subkey index, sould be initially 0, then
                            incremented in each call until
                            *subhKey becomes zero and the function
                            returns DB_NO_MORE_SUBKEYS
 
  Output:
    HNDLE *subkey_handle    Handle of subkey which can be used in
                            db_get_key and db_get_data
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_MORE_SUBKEYS      Last subkey reached
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_ENUM_LINK, hDB, hKey, idx, subkey_handle);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEYLIST *pkeylist;
      KEY *pkey;
      INT i;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_enum_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_enum_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      *subkey_handle = 0;
 
      /* first lock database */
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
      if (!hKey)
         hKey = pheader->root_key;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      if (pkey->type != TID_KEY) {
         db_unlock_database(hDB);
         return DB_NO_MORE_SUBKEYS;
      }
      pkeylist = (KEYLIST *) ((char *) pheader + pkey->data);
 
      if (idx >= pkeylist->num_keys) {
         db_unlock_database(hDB);
         return DB_NO_MORE_SUBKEYS;
      }
 
      // FIXME: validate pkeylist->first_key
      pkey = (KEY *) ((char *) pheader + pkeylist->first_key);
      for (i = 0; i < idx; i++) {
         // FIXME: validate pkey->next_key
         pkey = (KEY *) ((char *) pheader + pkey->next_key);
      }
 
      *subkey_handle = (POINTER_T) pkey - (POINTER_T) pheader;
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_get_next_link(HNDLE hDB, HNDLE hKey, HNDLE * subkey_handle)
/********************************************************************\
 
  Routine: db_get_next_link
 
  Purpose: Get next key in ODB after hKey
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key to enumerate, zero for the
                            root key
 
  Output:
    HNDLE *subkey_handle    Handle of subkey which can be used in
                            db_get_key and db_get_data
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_MORE_SUBKEYS      Last subkey reached
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_NEXT_LINK, hDB, hKey, subkey_handle);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEYLIST *pkeylist;
      KEY *pkey;
      INT descent;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_enum_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_enum_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      *subkey_handle = 0;
 
      /* first lock database */
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
      if (!hKey)
         hKey = pheader->root_key;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      descent = TRUE;
      do {
         if (pkey->type != TID_KEY || !descent) {
            if (pkey->next_key) {
               /* key has next key, return it */
               // FIXME: validate pkey->next_key
               pkey = (KEY *) ((char *) pheader + pkey->next_key);
 
               if (pkey->type != TID_KEY) {
                  *subkey_handle = (POINTER_T) pkey - (POINTER_T) pheader;
                  db_unlock_database(hDB);
                  return DB_SUCCESS;
               }
 
               /* key has subkeys, so descent on the next iteration */
               descent = TRUE;
            } else {
               if (pkey->parent_keylist == 0) {
                  /* return if we are back to the root key */
                  db_unlock_database(hDB);
                  return DB_NO_MORE_SUBKEYS;
               }
 
               /* key is last in list, traverse up */
               pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
 
               // FIXME: validate pkeylist->parent
               pkey = (KEY *) ((char *) pheader + pkeylist->parent);
               descent = FALSE;
            }
         } else {
            if (descent) {
               /* find first subkey */
               pkeylist = (KEYLIST *) ((char *) pheader + pkey->data);
 
               if (pkeylist->num_keys == 0) {
                  /* if key has no subkeys, look for next key on this level */
                  descent = FALSE;
               } else {
                  /* get first subkey */
                  // FIXME: validate pkeylist->first_key
                  pkey = (KEY *) ((char *) pheader + pkeylist->first_key);
 
                  if (pkey->type != TID_KEY) {
                     *subkey_handle = (POINTER_T) pkey - (POINTER_T) pheader;
                     db_unlock_database(hDB);
                     return DB_SUCCESS;
                  }
               }
            }
         }
 
      } while (TRUE);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
 
static int db_enum_locked(const DATABASE_HEADER* pheader, const KEY* pkey, std::vector<HNDLE>* sub_handles, std::vector<KEY>* sub_keys, bool follow_links, db_err_msg** msg)
{
   if (sub_handles)
      sub_handles->clear();
 
   if (sub_keys)
      sub_keys->clear();
 
   if (pkey->type != TID_KEY) {
      return DB_NO_MORE_SUBKEYS;
   }
 
   const KEYLIST *pkeylist = db_get_pkeylist(pheader, pkey, "db_enum_locked", msg);
 
   if (!pkeylist)
      return DB_CORRUPTED;
 
   if (pkeylist->num_keys > 0) {
      HNDLE hsubkey = pkeylist->first_key;
      
      while (hsubkey) {
         int status = 0;
         const KEY* psubkey = db_get_pkey(pheader, hsubkey, &status, "db_enum_locked", msg);
         
         if (!psubkey)
            return status;
         
         if (psubkey->type == TID_LINK && follow_links) {
            const KEY *plink = db_resolve_link_locked(pheader, psubkey, &status, msg);
            
            if (plink) {
               HNDLE hlink = db_pkey_to_hkey(pheader, plink);
               if (sub_handles)
                  sub_handles->push_back(hlink);
               if (sub_keys)
                  sub_keys->push_back(*plink);
            } else {
               // link cannot be resolved
               
               if (sub_handles)
                  sub_handles->push_back(hsubkey);
               if (sub_keys)
                  sub_keys->push_back(*psubkey);
            }
         } else {
            if (sub_handles)
               sub_handles->push_back(hsubkey);
            if (sub_keys)
               sub_keys->push_back(*psubkey);
         }
         
         hsubkey = psubkey->next_key;
      }
   }
 
   return DB_SUCCESS;
}
 
#endif
 
/*------------------------------------------------------------------*/
INT EXPRT db_enum(HNDLE hDB, HNDLE hKeyRoot, std::vector<HNDLE>* sub_handles, std::vector<KEY>* sub_keys, bool follow_links)
/********************************************************************\
 
  Routine: db_enum
 
  Purpose: Enumerate subkeys from a key, follow or not follow links
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key to enumerate, zero for the root key
 
  Output:
    std::vector<HNDLE>* sub_handles Handles of subkeys
    std::vector<KEY>* sub_keys      Keys of subkeys
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
 
\********************************************************************/
{
   if (rpc_is_remote()) {
      if (sub_handles)
         sub_handles->clear();
 
      if (sub_keys)
         sub_keys->clear();
 
      for (int i=0 ; ; i++) {
         HNDLE hSubkey = 0;
 
         if (follow_links)
            db_enum_key(hDB, hKeyRoot, i, &hSubkey);
         else
            db_enum_link(hDB, hKeyRoot, i, &hSubkey);
 
         if (!hSubkey)
            break; // end of list reached
 
         KEY subkey;
 
         int status = db_get_key(hDB, hSubkey, &subkey);
 
         if (status == DB_SUCCESS) {
            if (sub_handles)
               sub_handles->push_back(hSubkey);
            if (sub_keys)
               sub_keys->push_back(subkey);
         }
      }
 
      return DB_SUCCESS;
   }
 
#ifdef LOCAL_ROUTINES
 
   if (sub_handles)
      sub_handles->clear();
 
   if (sub_keys)
      sub_keys->clear();
 
   int status = DB_SUCCESS;
   
   DATABASE* pdb = db_lock_database(hDB, &status, "db_enum");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const KEY* pkeyroot = db_get_pkey(pdb->database_header, hKeyRoot, &status, "db_enum", &msg);
 
   if (pkeyroot) {
      status = db_enum_locked(pdb->database_header, pkeyroot, sub_handles, sub_keys, follow_links, &msg);
   }
   
   db_unlock_database(pdb, "db_enum");
   
   if (msg)
      db_flush_msg(&msg);
   
   return status;
#endif
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT EXPRT db_enum(HNDLE hDB, HNDLE hKeyRoot, const char* odb_path, std::vector<HNDLE>* sub_handles, std::vector<KEY>* sub_keys, bool follow_links)
/********************************************************************\
 
  Routine: db_enum
 
  Purpose: Enumerate subkeys from a key, follow or not follow links
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKeyRoot          Handle of directory, zero for the root key
    char* odb_path          ODB path under hKeyRoot to enumerate
 
  Output:
    std::vector<HNDLE>* sub_handles Handles of subkeys
    std::vector<KEY>* sub_keys      Keys of subkeys
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
 
\********************************************************************/
{
   if (rpc_is_remote()) {
      if (sub_handles)
         sub_handles->clear();
 
      if (sub_keys)
         sub_keys->clear();
 
      int status = 0;
 
      if (follow_links)
         status = db_find_key(hDB, hKeyRoot, odb_path, &hKeyRoot);
      else
         status = db_find_link(hDB, hKeyRoot, odb_path, &hKeyRoot);
 
      if (!hKeyRoot)
         return status;
 
      for (int i=0 ; ; i++) {
         HNDLE hSubkey = 0;
 
         if (follow_links)
            db_enum_key(hDB, hKeyRoot, i, &hSubkey);
         else
            db_enum_link(hDB, hKeyRoot, i, &hSubkey);
 
         if (!hSubkey)
            break; // end of list reached
 
         KEY subkey;
 
         int status = db_get_key(hDB, hSubkey, &subkey);
 
         if (status == DB_SUCCESS) {
            if (sub_handles)
               sub_handles->push_back(hSubkey);
            if (sub_keys)
               sub_keys->push_back(subkey);
         }
      }
 
      return DB_SUCCESS;
   }
 
#ifdef LOCAL_ROUTINES
 
   if (sub_handles)
      sub_handles->clear();
 
   if (sub_keys)
      sub_keys->clear();
 
   int status = DB_SUCCESS;
   
   DATABASE* pdb = db_lock_database(hDB, &status, "db_enum");
 
   if (!pdb)
      return status;
 
   db_err_msg *msg = NULL;
 
   const KEY* pkeyroot = db_get_pkey(pdb->database_header, hKeyRoot, &status, "db_enum", &msg);
 
   if (pkeyroot) {
      const KEY* pkey = db_find_pkey_locked(pdb->database_header, pkeyroot, odb_path, follow_links, &status, &msg);
      if (pkey)
         status = db_enum_locked(pdb->database_header, pkey, sub_handles, sub_keys, follow_links, &msg);
   }
   
   db_unlock_database(pdb, "db_enum");
   
   if (msg)
      db_flush_msg(&msg);
   
   return status;
 
#endif
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
 
#ifdef LOCAL_ROUTINES
 
static INT db_get_key_locked(const DATABASE_HEADER* pheader, HNDLE hKey, KEY * key, db_err_msg** msg)
{
   if (!hKey)
      hKey = pheader->root_key;
 
   /* check if hKey argument is correct */
   if (!db_validate_hkey(pheader, hKey)) {
      return DB_INVALID_HANDLE;
   }
   
   const KEY* pkey = (const KEY *) ((char *) pheader + hKey);
   
   if (pkey->type < 1 || pkey->type >= TID_LAST) {
      int pkey_type = pkey->type;
      db_msg(msg, MERROR, "db_get_key", "hkey %d invalid key type %d", hKey, pkey_type);
      return DB_INVALID_HANDLE;
   }
   
   /* check for link to array index */
   if (pkey->type == TID_LINK) {
      char link_name[MAX_ODB_PATH];
      mstrlcpy(link_name, (char *) pheader + pkey->data, sizeof(link_name));
      if (strlen(link_name) > 0 && link_name[strlen(link_name) - 1] == ']') {
         if (strchr(link_name, '[') == NULL)
            return DB_INVALID_LINK;
 
         HNDLE hkeylink;
         if (db_find_key_locked(pheader, 0, link_name, true, &hkeylink, msg) != DB_SUCCESS)
            return DB_INVALID_LINK;
         int status = db_get_key_locked(pheader, hkeylink, key, msg);
         key->num_values = 1;        // fake number of values
         return status;
      }
   }
   
   memcpy(key, pkey, sizeof(KEY));
 
   return DB_SUCCESS;
}
#endif /* LOCAL_ROUTINES */
 
/********************************************************************/
INT db_get_key(HNDLE hDB, HNDLE hKey, KEY * key)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_KEY, hDB, hKey, key);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER) && hKey != 0) {
         cm_msg(MERROR, "db_get_key", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg *msg = NULL;
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      status = db_get_key_locked(pheader, hKey, key, &msg);
 
      db_unlock_database(hDB);
 
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_link(HNDLE hDB, HNDLE hKey, KEY * key)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_LINK, hDB, hKey, key);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_link", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER) && hKey != 0) {
         cm_msg(MERROR, "db_get_link", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg *msg = NULL;
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      int status = DB_SUCCESS;
 
      const KEY* pkey = db_get_pkey(pheader, hKey, &status, "db_get_link", &msg);
      if (pkey) {
         memcpy(key, pkey, sizeof(KEY));
      } else {
         memset(key, 0, sizeof(KEY));
         //abort();
      }
 
      db_unlock_database(hDB);
 
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_key_time(HNDLE hDB, HNDLE hKey, DWORD * delta)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_KEY_TIME, hDB, hKey, delta);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_key", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      *delta = ss_time() - pkey->last_written;
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_key_info(HNDLE hDB, HNDLE hKey, char *name, INT name_size, INT * type, INT * num_values, INT * item_size)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_KEY_INFO, hDB, hKey, name, name_size, type, num_values, item_size);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
      KEYLIST *pkeylist;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_key_info", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_key_info", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_key_info", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      if ((INT) strlen(pkey->name) + 1 > name_size) {
         /* truncate name */
         memcpy(name, pkey->name, name_size - 1);
         name[name_size] = 0;
      } else
         strcpy(name, pkey->name);
 
      /* convert "root" to "/" */
      if (strcmp(name, "root") == 0)
         strcpy(name, "/");
 
      *type = pkey->type;
      *num_values = pkey->num_values;
      *item_size = pkey->item_size;
 
      if (pkey->type == TID_KEY) {
         pkeylist = (KEYLIST *) ((char *) pheader + pkey->data);
         *num_values = pkeylist->num_keys;
      }
 
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
 
/*------------------------------------------------------------------*/
INT db_rename_key(HNDLE hDB, HNDLE hKey, const char *name)
/********************************************************************\
 
  Routine: db_get_key
 
  Purpose: Rename a key
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key
    char  *name             New key name
 
  Output:
    <none>
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_INVALID_NAME         Key name contains '/'
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_RENAME_KEY, hDB, hKey, name);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_rename_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_rename_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_rename_key", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg* msg = NULL;
      status = db_validate_name(name, FALSE, "db_rename_key", &msg);
      if (msg)
         db_flush_msg(&msg);
      if (status != DB_SUCCESS)
         return status;
 
      if (name == NULL) {
         cm_msg(MERROR, "db_rename_key", "key name is NULL");
         return DB_INVALID_NAME;
      }
 
      if (strlen(name) < 1) {
         cm_msg(MERROR, "db_rename_key", "key name is too short");
         return DB_INVALID_NAME;
      }
 
      if (strchr(name, '/')) {
         cm_msg(MERROR, "db_rename_key", "key name may not contain \"/\"");
         return DB_INVALID_NAME;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      if (!pkey->type) {
         int pkey_type = pkey->type;
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_rename_key", "hkey %d invalid key type %d", hKey, pkey_type);
         return DB_INVALID_HANDLE;
      }
 
      db_allow_write_locked(&_database[hDB - 1], "db_rename_key");
 
      mstrlcpy(pkey->name, name, NAME_LENGTH);
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_reorder_key(HNDLE hDB, HNDLE hKey, INT idx)
/********************************************************************\
 
  Routine: db_reorder_key
 
  Purpose: Reorder key so that key hKey apprears at position 'index'
           in keylist (or at bottom if index<0)
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key
    INT   idx               New positio of key in keylist
 
  Output:
    <none>
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_NO_ACCESS            Key is locked for write
    DB_OPEN_RECORD          Key, subkey or parent key is open
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_REORDER_KEY, hDB, hKey, idx);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey, *pnext_key, *pkey_tmp;
      KEYLIST *pkeylist;
      INT i;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_rename_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_rename_key", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_rename_key", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      if (!pkey->type) {
         int pkey_type = pkey->type;
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_reorder_key", "hkey %d invalid key type %d", hKey, pkey_type);
         return DB_INVALID_HANDLE;
      }
 
      if (!(pkey->access_mode & MODE_WRITE)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      /* check if someone has opened key or parent */
      do {
#ifdef CHECK_OPEN_RECORD
         if (pkey->notify_count) {
            db_unlock_database(hDB);
            return DB_OPEN_RECORD;
         }
#endif
         if (pkey->parent_keylist == 0)
            break;
 
         pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
         // FIXME: validate pkeylist->parent
         pkey = (KEY *) ((char *) pheader + pkeylist->parent);
      } while (TRUE);
      
      db_allow_write_locked(&_database[hDB - 1], "db_reorder_key");
      
      pkey = (KEY *) ((char *) pheader + hKey); // NB: hKey is already validated
      pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
 
      /* first remove key from list */
      pnext_key = (KEY *) (POINTER_T) pkey->next_key; // FIXME: what is this pointer cast?
 
      if ((KEY *) ((char *) pheader + pkeylist->first_key) == pkey) {
         /* key is first in list */
         pkeylist->first_key = (POINTER_T) pnext_key;
      } else {
         /* find predecessor */
         // FIXME: validate pkeylist->first_key
         pkey_tmp = (KEY *) ((char *) pheader + pkeylist->first_key);
         while ((KEY *) ((char *) pheader + pkey_tmp->next_key) != pkey) {
            // FIXME: validate pkey_tmp->next_key
            pkey_tmp = (KEY *) ((char *) pheader + pkey_tmp->next_key);
         }
         pkey_tmp->next_key = (POINTER_T) pnext_key;
      }
 
      /* add key to list at proper index */
      // FIXME: validate pkeylist->first_key
      pkey_tmp = (KEY *) ((char *) pheader + pkeylist->first_key);
      if (idx < 0 || idx >= pkeylist->num_keys - 1) {
         /* add at bottom */
 
         /* find last key */
         for (i = 0; i < pkeylist->num_keys - 2; i++) {
            // FIXME: validate pkey_tmp->next_key
            pkey_tmp = (KEY *) ((char *) pheader + pkey_tmp->next_key);
         }
 
         pkey_tmp->next_key = (POINTER_T) pkey - (POINTER_T) pheader;
         pkey->next_key = 0;
      } else {
         if (idx == 0) {
            /* add at top */
            pkey->next_key = pkeylist->first_key;
            pkeylist->first_key = (POINTER_T) pkey - (POINTER_T) pheader;
         } else {
            /* add at position index */
            for (i = 0; i < idx - 1; i++) {
               // FIXME: validate pkey_tmp->next_key
               pkey_tmp = (KEY *) ((char *) pheader + pkey_tmp->next_key);
            }
 
            pkey->next_key = pkey_tmp->next_key;
            pkey_tmp->next_key = (POINTER_T) pkey - (POINTER_T) pheader;
         }
      }
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
/********************************************************************/
INT db_get_data(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_DATA, hDB, hKey, data, buf_size, type);
 
#ifdef LOCAL_ROUTINES
   {
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_data", "Invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      DATABASE_HEADER* pheader = _database[hDB - 1].database_header;
      db_err_msg* msg = NULL;
 
      const KEY* pkey = db_get_pkey(pheader, hKey, &status, "db_get_data", &msg);
 
      if (!pkey) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      /* check for read access */
      if (!(pkey->access_mode & MODE_READ)) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return DB_NO_ACCESS;
      }
 
      /* follow links to array index */
      if (pkey->type == TID_LINK) {
         std::string link_name = (char *) pheader + pkey->data;
         if (link_name.length() > 0 && link_name.back() == ']') {
            size_t pos = link_name.rfind("[");
            if (pos == std::string::npos) {
               db_msg(&msg, MERROR, "db_get_data", "missing \"[\" in symlink to array element \"%s\" in \"%s\"", link_name.c_str(), db_get_path_pkey(pheader, pkey).c_str());
               db_unlock_database(hDB);
               if (msg)
                  db_flush_msg(&msg);
               return DB_INVALID_LINK;
            }
            int idx = atoi(link_name.c_str()+pos+1);
            link_name.resize(pos);
            //printf("link name [%s] idx %d\n", link_name.c_str(), idx);
 
            // relative symlinks did not work in the old db_get_data(), make sure they do not work now. K.O.
            if (link_name[0] != '/') {
               db_msg(&msg, MERROR, "db_get_data", "symlink \"%s\" should start with \"/\" in \"%s\"", link_name.c_str(), db_get_path_pkey(pheader, pkey).c_str());
               db_unlock_database(hDB);
               if (msg)
                  db_flush_msg(&msg);
               return DB_INVALID_LINK;
            }
 
            const KEY* pkey = db_find_pkey_locked(pheader, NULL, link_name.c_str(), true,  &status, &msg);
 
            if (!pkey) {
               db_unlock_database(hDB);
               if (msg)
                  db_flush_msg(&msg);
               return status;
            }
 
            //printf("db_get_data [%s] type [%s] idx %d\n", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(type), idx);
 
            status = db_get_data_locked(pheader, pkey, idx, data, buf_size, type, &msg);
            
            db_unlock_database(hDB);
            if (msg)
               db_flush_msg(&msg);
            return status;
         }
      }
 
      //printf("db_get_data [%s] type [%s]\n", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(type));
 
      status = db_get_data_locked(pheader, pkey, -1, data, buf_size, type, &msg);
 
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_link_data(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_LINK_DATA, hDB, hKey, data, buf_size, type);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_data", "Invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      /* check for read access */
      if (!(pkey->access_mode & MODE_READ)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      if (!pkey->type) {
         int pkey_type = pkey->type;
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "hkey %d invalid key type %d", hKey, pkey_type);
         return DB_INVALID_HANDLE;
      }
 
      if (pkey->type != type) {
         int pkey_type = pkey->type;
         char pkey_name[NAME_LENGTH];
         mstrlcpy(pkey_name, pkey->name, sizeof(pkey_name));
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "\"%s\" is of type %s, not %s", pkey_name, rpc_tid_name(pkey_type), rpc_tid_name(type));
         return DB_TYPE_MISMATCH;
      }
 
      /* keys cannot contain data */
      if (pkey->type == TID_KEY) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "Key cannot contain data");
         return DB_TYPE_MISMATCH;
      }
 
      /* check if key has data */
      if (pkey->data == 0) {
         memset(data, 0, *buf_size);
         *buf_size = 0;
         db_unlock_database(hDB);
         return DB_SUCCESS;
      }
 
      /* check if buffer is too small */
      if (pkey->num_values * pkey->item_size > *buf_size) {
         int pkey_size = pkey->num_values * pkey->item_size;
         memcpy(data, (char *) pheader + pkey->data, *buf_size);
         db_unlock_database(hDB);
         std::string path = db_get_path(hDB, hKey);
         cm_msg(MERROR, "db_get_data", "data for key \"%s\" truncated from %d to %d bytes", path.c_str(), pkey_size, *buf_size);
         return DB_TRUNCATED;
      }
 
      /* copy key data */
      memcpy(data, (char *) pheader + pkey->data, pkey->num_values * pkey->item_size);
      *buf_size = pkey->num_values * pkey->item_size;
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_get_data1(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, DWORD type, INT * num_values)
/********************************************************************\
 
  Routine: db_get_data1
 
  Purpose: Get key data from a handle, return number of values
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Handle of key
    INT    *buf_size        Size of data buffer
    DWORD  type             Type of data
 
  Output:
    void   *data            Key data
    INT    *buf_size        Size of key data
    INT    *num_values      Number of values
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_TRUNCATED            Return buffer is smaller than key data
    DB_TYPE_MISMATCH        Type mismatch
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_DATA1, hDB, hKey, data, buf_size, type, num_values);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_data", "Invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      /* check for read access */
      if (!(pkey->access_mode & MODE_READ)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      if (!pkey->type) {
         int pkey_type = pkey->type;
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "hkey %d invalid key type %d", hKey, pkey_type);
         return DB_INVALID_HANDLE;
      }
 
      if (pkey->type != type) {
         int pkey_type = pkey->type;
         char pkey_name[NAME_LENGTH];
         mstrlcpy(pkey_name, pkey->name, sizeof(pkey_name));
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "\"%s\" is of type %s, not %s", pkey_name, rpc_tid_name(pkey_type), rpc_tid_name(type));
         return DB_TYPE_MISMATCH;
      }
 
      /* keys cannot contain data */
      if (pkey->type == TID_KEY) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data", "Key cannot contain data");
         return DB_TYPE_MISMATCH;
      }
 
      /* check if key has data */
      if (pkey->data == 0) {
         memset(data, 0, *buf_size);
         *buf_size = 0;
         db_unlock_database(hDB);
         return DB_SUCCESS;
      }
 
      /* check if buffer is too small */
      if (pkey->num_values * pkey->item_size > *buf_size) {
         int pkey_size = pkey->num_values * pkey->item_size;
         memcpy(data, (char *) pheader + pkey->data, *buf_size);
         db_unlock_database(hDB);
         std::string path = db_get_path(hDB, hKey);
         cm_msg(MERROR, "db_get_data", "data for key \"%s\" truncated from %d to %d bytes", path.c_str(), pkey_size, *buf_size);
         return DB_TRUNCATED;
      }
 
      /* copy key data */
      memcpy(data, (char *) pheader + pkey->data, pkey->num_values * pkey->item_size);
      *buf_size = pkey->num_values * pkey->item_size;
      *num_values = pkey->num_values;
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_get_data_index(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, INT idx, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_GET_DATA_INDEX, hDB, hKey, data, buf_size, idx, type);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      KEY *pkey;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_get_data", "Invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_get_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_get_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      pheader = _database[hDB - 1].database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      pkey = (KEY *) ((char *) pheader + hKey);
 
      /* check for read access */
      if (!(pkey->access_mode & MODE_READ)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      if (!pkey->type) {
         int pkey_type = pkey->type;
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data_index", "hkey %d invalid key type %d", hKey, pkey_type);
         return DB_INVALID_HANDLE;
      }
 
      if (pkey->type != type) {
         int pkey_type = pkey->type;
         char pkey_name[NAME_LENGTH];
         mstrlcpy(pkey_name, pkey->name, sizeof(pkey_name));
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data_index", "\"%s\" is of type %s, not %s", pkey_name, rpc_tid_name(pkey_type), rpc_tid_name(type));
         return DB_TYPE_MISMATCH;
      }
 
      /* keys cannot contain data */
      if (pkey->type == TID_KEY) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_get_data_index", "Key cannot contain data");
         return DB_TYPE_MISMATCH;
      }
 
      /* check if key has data */
      if (pkey->data == 0) {
         memset(data, 0, *buf_size);
         *buf_size = 0;
         db_unlock_database(hDB);
         return DB_SUCCESS;
      }
 
      /* check if index in range */
      if (idx < 0 || idx >= pkey->num_values) {
         int pkey_num_values = pkey->num_values;
         memset(data, 0, *buf_size);
         db_unlock_database(hDB);
 
         std::string path = db_get_path(hDB, hKey);
         cm_msg(MERROR, "db_get_data_index", "index (%d) exceeds array length (%d) for key \"%s\"", idx, pkey_num_values, path.c_str());
         return DB_OUT_OF_RANGE;
      }
 
      /* check if buffer is too small */
      if (pkey->item_size > *buf_size) {
         int pkey_size = pkey->item_size;
         /* copy data */
         memcpy(data, (char *) pheader + pkey->data + idx * pkey->item_size, *buf_size);
         db_unlock_database(hDB);
         std::string path = db_get_path(hDB, hKey);
         cm_msg(MERROR, "db_get_data_index", "data for key \"%s\" truncated from %d to %d bytes", path.c_str(), pkey_size, *buf_size);
         return DB_TRUNCATED;
      }
 
      /* copy key data */
      memcpy(data, (char *) pheader + pkey->data + idx * pkey->item_size, pkey->item_size);
      *buf_size = pkey->item_size;
 
      db_unlock_database(hDB);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
/********************************************************************/
static INT db_set_data_wlocked(DATABASE_HEADER* pheader, KEY* pkey, const void *data, INT data_size, INT num_values, DWORD type, const char* caller, db_err_msg** msg)
{
   /* if no buf_size given (Java!), calculate it */
   if (data_size == 0)
      data_size = pkey->item_size * num_values;
 
   /* resize data size if necessary */
   if (pkey->total_size != data_size) {
      // FIXME: validate pkey->data!
      pkey->data = (POINTER_T) realloc_data(pheader, (char *) pheader + pkey->data, pkey->total_size, data_size, caller);
      
      if (pkey->data == 0) {
         pkey->total_size = 0;
         db_msg(msg, MERROR, caller, "Cannot reallocate \"%s\" with new size %d bytes, online database full", db_get_path_pkey(pheader, pkey).c_str(), data_size);
         return DB_FULL;
      }
      
      pkey->data -= (POINTER_T) pheader;
      pkey->total_size = data_size;
   }
   
   /* set number of values */
   pkey->num_values = num_values;
 
   if (type == TID_STRING || type == TID_LINK)
      pkey->item_size = data_size / num_values;
   else
      pkey->item_size = rpc_tid_size(type);
   
   if ((type == TID_STRING || type == TID_LINK) && pkey->num_values == 1) {
      /* copy string up to NUL termination */
      mstrlcpy((char *) pheader + pkey->data, (const char*)data, data_size);
   } else {
      /* copy data */
      memcpy((char *) pheader + pkey->data, data, data_size);
   }
   
   /* update time */
   pkey->last_written = ss_time();
 
   return DB_SUCCESS;
}
 
static INT db_set_data_index_wlocked(DATABASE_HEADER* pheader, KEY* pkey, int idx, const void *data, INT data_size, DWORD type, const char* caller, db_err_msg** msg)
{
   /* increase key size if necessary */
   if (idx >= pkey->num_values || pkey->item_size == 0) {
      // FIXME: validate pkey->data
      pkey->data = (POINTER_T) realloc_data(pheader, (char *) pheader + pkey->data, pkey->total_size, data_size * (idx + 1), caller);
      
      if (pkey->data == 0) {
         pkey->total_size = 0;
         pkey->num_values = 0;
         db_msg(msg, MERROR, caller, "Cannot reallocate \"%s\" with new num_values %d and new size %d bytes, online database full", db_get_path_pkey(pheader, pkey).c_str(), idx + 1, data_size * (idx + 1));
         return DB_FULL;
      }
      
      pkey->data -= (POINTER_T) pheader;
      if (!pkey->item_size)
         pkey->item_size = data_size;
      pkey->total_size = data_size * (idx + 1);
      pkey->num_values = idx + 1;
   }
 
#if 0
   /* cut strings which are too long */
   if ((type == TID_STRING || type == TID_LINK) && (int) strlen((char *) data) + 1 > pkey->item_size)
      *((char *) data + pkey->item_size - 1) = 0;
   
   /* copy data */
   memcpy((char *) pheader + pkey->data + idx * pkey->item_size, data, pkey->item_size);
#endif
 
   if ((type == TID_STRING || type == TID_LINK)) {
      /* cut strings which are too long */
      mstrlcpy((char *) pheader + pkey->data + idx * pkey->item_size, (char*)data, pkey->item_size);
   } else {
      /* copy data */
      memcpy((char *) pheader + pkey->data + idx * pkey->item_size, data, pkey->item_size);
   }
 
   /* update time */
   pkey->last_written = ss_time();
 
   return DB_SUCCESS;
}
 
static INT db_check_set_data_locked(DATABASE_HEADER* pheader, const KEY* pkey, const void *data, INT data_size, INT num_values, DWORD type, const char* caller, db_err_msg** msg)
{
   /* check for write access */
   if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
      return DB_NO_ACCESS;
   }
   
   if (pkey->type != type) {
      db_msg(msg, MERROR, caller, "\"%s\" is of type %s, not %s", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(pkey->type), rpc_tid_name(type));
      return DB_TYPE_MISMATCH;
   }
   
   /* keys cannot contain data */
   if (pkey->type == TID_KEY) {
      db_msg(msg, MERROR, caller, "\"%s\" of type TID_KEY cannot contain data", db_get_path_pkey(pheader, pkey).c_str());
      return DB_TYPE_MISMATCH;
   }
   
   if (type == TID_STRING || type == TID_LINK) {
      if (num_values > 1) {
         int item_size = pkey->item_size;
         if (data_size > 0 && num_values > 0)
            item_size = data_size/num_values;
         //printf("db_check_set_data for %s: utf8 check for odb \"%s\" string array size %d, item size %d\n", caller, db_get_path_pkey(pheader, pkey).c_str(), num_values, item_size);
         for (int i=0; i<num_values; i++) {
            const char* value = ((const char*)data) + i * item_size;
            //printf("db_check_set_data for %s: utf8 check for odb \"%s\" string array size %d item_size %d, index %d, value \"%s\"\n", caller, db_get_path_pkey(pheader, pkey).c_str(), num_values, item_size, i, value);
            if (!is_utf8(value)) {
               db_msg(msg, MERROR, caller, "\"%s\" index %d is not a valid UTF-8 Unicode string", db_get_path_pkey(pheader, pkey).c_str(), i);
               // just a warning for now. K.O.
               //return DB_TYPE_MISMATCH;
            }
         }
      } else {
         const char* value = (const char*)data;
         //printf("db_check_set_data for %s: utf8 check for odb \"%s\" value \"%s\" size %d\n", caller, db_get_path_pkey(pheader, pkey).c_str(), value, data_size);
         if (!is_utf8(value)) {
            db_msg(msg, MERROR, caller, "\"%s\" is not a valid UTF-8 Unicode string", db_get_path_pkey(pheader, pkey).c_str());
            // just a warning for now. K.O.
            //return DB_TYPE_MISMATCH;
         }
      }
   }
 
   return DB_SUCCESS;
}
 
static INT db_check_set_data_index_locked(DATABASE_HEADER* pheader, const KEY* pkey, int idx, const void *data, INT data_size, DWORD type, const char* caller, db_err_msg** msg)
{
   /* check for write access */
   if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
      return DB_NO_ACCESS;
   }
   
   if (pkey->type != type) {
      db_msg(msg, MERROR, caller, "\"%s\" is of type %s, not %s", db_get_path_pkey(pheader, pkey).c_str(), rpc_tid_name(pkey->type), rpc_tid_name(type));
      return DB_TYPE_MISMATCH;
   }
   
   /* keys cannot contain data */
   if (pkey->type == TID_KEY) {
      db_msg(msg, MERROR, "db_set_data_index", "\"%s\" of type TID_KEY cannot contain data", db_get_path_pkey(pheader, pkey).c_str());
      return DB_TYPE_MISMATCH;
   }
   
   /* check utf-8 encoding */
   if (pkey->type == TID_STRING || pkey->type == TID_LINK) {
      //printf("db_check_set_data_index for %s: utf8 check for odb \"%s\" value \"%s\"\n", caller, db_get_path_pkey(pheader, pkey).c_str(), data);
      const char* value = (const char*)data;
      if (!is_utf8(value)) {
         db_msg(msg, MERROR, "db_set_data_index", "\"%s\" index %d is not a valid UTF-8 Unicode string", db_get_path_pkey(pheader, pkey).c_str(), idx);
         // just a warning for now. K.O.
         //return DB_TYPE_MISMATCH;
      }
   }
 
   /* check for valid idx */
   if (idx < 0) {
      db_msg(msg, MERROR, caller, "\%s\" given invalid index %d",  db_get_path_pkey(pheader, pkey).c_str(), idx);
      return DB_INVALID_PARAM;
   }
   
   /* check for valid array element size: if new element size
      is different from existing size, ODB becomes corrupted */
   if (pkey->item_size != 0 && data_size != pkey->item_size) {
      db_msg(msg, MERROR, caller, "\"%s\" invalid element data size %d, expected %d", db_get_path_pkey(pheader, pkey).c_str(), data_size, pkey->item_size);
      return DB_TYPE_MISMATCH;
   }
 
   return DB_SUCCESS;
}
 
#endif // LOCAL_ROUTINES
 
/********************************************************************/
INT db_set_data(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_DATA, hDB, hKey, data, buf_size, num_values, type);
 
#ifdef LOCAL_ROUTINES
   {
      HNDLE hkeylink;
      int link_idx;
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      if (num_values == 0)
         return DB_INVALID_PARAM;
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
 
      /* check for write access */
      if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      /* check for link to array index */
      if (pkey->type == TID_LINK) {
         char link_name[256]; // FIXME: use std::string
         mstrlcpy(link_name, (char *) pheader + pkey->data, sizeof(link_name));
         if (strlen(link_name) > 0 && link_name[strlen(link_name) - 1] == ']') {
            db_unlock_database(hDB);
            if (strchr(link_name, '[') == NULL)
               return DB_INVALID_LINK;
            link_idx = atoi(strchr(link_name, '[') + 1);
            *strchr(link_name, '[') = 0;
            if (db_find_key(hDB, 0, link_name, &hkeylink) != DB_SUCCESS)
               return DB_INVALID_LINK;
            return db_set_data_index(hDB, hkeylink, data, buf_size, link_idx, type);
         }
      }
 
      status = db_check_set_data_locked(pheader, pkey, data, buf_size, num_values, type, "db_set_data", &msg);
 
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_allow_write_locked(pdb, "db_set_data");
 
      status = db_set_data_wlocked(pheader, pkey, data, buf_size, num_values, type, "db_set_data", &msg);
 
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_notify_clients_locked(pdb, hKey, -1, TRUE, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
INT db_set_data1(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
/*
 
 Same as db_set_data(), but do not notify hot-linked clients
 
 */
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_DATA1, hDB, hKey, data, buf_size, num_values, type);
   
#ifdef LOCAL_ROUTINES
   {
   DATABASE_HEADER *pheader;
   KEY *pkey;
   HNDLE hkeylink;
   int link_idx;
   char link_name[256];
   int status;
   
   if (hDB > _database_entries || hDB <= 0) {
      cm_msg(MERROR, "db_set_data1", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   if (!_database[hDB - 1].attached) {
      cm_msg(MERROR, "db_set_data1", "invalid database handle");
      return DB_INVALID_HANDLE;
   }
   
   if (hKey < (int) sizeof(DATABASE_HEADER)) {
      cm_msg(MERROR, "db_set_data1", "invalid key handle");
      return DB_INVALID_HANDLE;
   }
   
   if (num_values == 0)
      return DB_INVALID_PARAM;
   
   db_lock_database(hDB);
   db_err_msg* msg = NULL;
   
   pheader = _database[hDB - 1].database_header;
   
   /* check if hKey argument is correct */
   if (!db_validate_hkey(pheader, hKey)) {
      db_unlock_database(hDB);
      return DB_INVALID_HANDLE;
   }
   
   pkey = (KEY *) ((char *) pheader + hKey);
 
   /* check for write access */
   if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
      db_unlock_database(hDB);
      return DB_NO_ACCESS;
   }
   
   /* check for link to array index */
   if (pkey->type == TID_LINK) {
      mstrlcpy(link_name, (char *) pheader + pkey->data, sizeof(link_name));
      if (strlen(link_name) > 0 && link_name[strlen(link_name) - 1] == ']') {
         db_unlock_database(hDB);
         if (strchr(link_name, '[') == NULL)
            return DB_INVALID_LINK;
         link_idx = atoi(strchr(link_name, '[') + 1);
         *strchr(link_name, '[') = 0;
         if (db_find_key(hDB, 0, link_name, &hkeylink) != DB_SUCCESS)
            return DB_INVALID_LINK;
         return db_set_data_index1(hDB, hkeylink, data, buf_size, link_idx, type, FALSE);
      }
   }
 
   status = db_check_set_data_locked(pheader, pkey, data, buf_size, num_values, type, "db_set_data1", &msg);
 
   if (status != DB_SUCCESS) {
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
      return status;
   }
   
   db_allow_write_locked(&_database[hDB - 1], "db_set_data1");
 
   status = db_set_data_wlocked(pheader, pkey, data, buf_size, num_values, type, "db_set_data1", &msg);
   
   if (status != DB_SUCCESS) {
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
      return status;
   }
   
   db_unlock_database(hDB);
   if (msg)
      db_flush_msg(&msg);
   
   }
#endif                          /* LOCAL_ROUTINES */
   
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_set_link_data(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_LINK_DATA, hDB, hKey, data, buf_size, num_values, type);
 
#ifdef LOCAL_ROUTINES
   {
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_data", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_data", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      if (num_values == 0)
         return DB_INVALID_PARAM;
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
 
      int status = db_check_set_data_locked(pheader, pkey, data, buf_size, num_values, type, "db_set_link_data", &msg);
      
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_allow_write_locked(pdb, "db_set_link_data");
 
      status = db_set_data_wlocked(pheader, pkey, data, buf_size, num_values, type, "db_set_link_data", &msg);
      
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_notify_clients_locked(pdb, hKey, -1, TRUE, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_set_num_values(HNDLE hDB, HNDLE hKey, INT num_values)
/********************************************************************\
 
  Routine: db_set_num_values
 
  Purpose: Set number of values in a key. Extend with zeros or truncate.
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Handle of key
    INT    num_values       Number of data values
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_NUM_VALUES, hDB, hKey, num_values);
 
#ifdef LOCAL_ROUTINES
   {
      INT new_size;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_num_values", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_num_values", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_num_values", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      if (num_values <= 0) {
         cm_msg(MERROR, "db_set_num_values", "invalid num_values %d", num_values);
         return DB_INVALID_PARAM;
      }
 
      if (num_values == 0)
         return DB_INVALID_PARAM;
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
      
      /* check for write access */
      if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      /* keys cannot contain data */
      if (pkey->type == TID_KEY) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_set_num_values", "Key cannot contain data");
         return DB_TYPE_MISMATCH;
      }
 
      if (pkey->total_size != pkey->item_size * pkey->num_values) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_set_num_values", "Corrupted key");
         return DB_CORRUPTED;
      }
 
      if (pkey->item_size == 0) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "db_set_num_values", "Cannot resize array with item_size equal to zero");
         return DB_INVALID_PARAM;
      }
 
      db_allow_write_locked(pdb, "db_set_num_values");
 
      /* resize data size if necessary */
      if (pkey->num_values != num_values) {
         new_size = pkey->item_size * num_values;
 
         pkey->data = (POINTER_T) realloc_data(pheader, (char *) pheader + pkey->data, pkey->total_size, new_size, "db_set_num_values");
 
         if (pkey->data == 0) {
            pkey->total_size = 0;
            pkey->num_values = 0;
            db_msg(&msg, MERROR, "db_set_num_values", "Cannot resize \"%s\" with num_values %d and new size %d bytes, online database full", db_get_path_pkey(pheader, pkey).c_str(), num_values, new_size);
            db_unlock_database(hDB);
            if (msg)
               db_flush_msg(&msg);
            return DB_FULL;
         }
 
         pkey->data -= (POINTER_T) pheader;
         pkey->total_size = new_size;
         pkey->num_values = num_values;
      }
 
      /* update time */
      pkey->last_written = ss_time();
 
      db_notify_clients_locked(pdb, hKey, -1, TRUE, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_set_data_index(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_DATA_INDEX, hDB, hKey, data, data_size, idx, type);
 
#ifdef LOCAL_ROUTINES
   {
      int link_idx;
      HNDLE hkeylink;
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_data_index", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_data_index", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_data_index", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
 
      /* check for write access */
      if (!(pkey->access_mode & MODE_WRITE) || (pkey->access_mode & MODE_EXCLUSIVE)) {
         db_unlock_database(hDB);
         return DB_NO_ACCESS;
      }
 
      /* check for link to array index */
      if (pkey->type == TID_LINK) {
         char link_name[256]; // FIXME: use std::string
         mstrlcpy(link_name, (char *) pheader + pkey->data, sizeof(link_name));
         if (strlen(link_name) > 0 && link_name[strlen(link_name) - 1] == ']') {
            db_unlock_database(hDB);
            if (strchr(link_name, '[') == NULL)
               return DB_INVALID_LINK;
            link_idx = atoi(strchr(link_name, '[') + 1);
            *strchr(link_name, '[') = 0;
            if (db_find_key(hDB, 0, link_name, &hkeylink) != DB_SUCCESS)
               return DB_INVALID_LINK;
            return db_set_data_index(hDB, hkeylink, data, data_size, link_idx, type);
         }
      }
 
      status = db_check_set_data_index_locked(pheader, pkey, idx, data, data_size, type, "db_set_data_index", &msg);
 
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_allow_write_locked(&_database[hDB-1], "db_set_data_index");
 
      status = db_set_data_index_wlocked(pheader, pkey, idx, data, data_size, type, "db_set_data_index", &msg);
      
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_notify_clients_locked(pdb, hKey, idx, TRUE, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_set_link_data_index(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type)
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_LINK_DATA_INDEX, hDB, hKey, data, data_size, idx, type);
 
#ifdef LOCAL_ROUTINES
   {
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_link_data_index", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_link_data_index", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_link_data_index", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
 
      int status = db_check_set_data_index_locked(pheader, pkey, idx, data, data_size, type, "db_set_link_data_index", &msg);
      
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_allow_write_locked(pdb, "db_set_link_data_index");
 
      status = db_set_data_index_wlocked(pheader, pkey, idx, data, data_size, type, "db_set_link_data_index", &msg);
      
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_notify_clients_locked(pdb, hKey, idx, TRUE, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_set_data_index1(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type, BOOL bNotify)
/********************************************************************\
 
  Routine: db_set_data_index1
 
  Purpose: Set key data for a key which contains an array of values.
           Optionally notify clients which have key open.
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Handle of key to enumerate
    void   *data            Pointer to single value of data
    INT    data_size        Size of single data element
    INT    idx              Index of array to change [0..n-1]
    DWORD  type             Type of data
    BOOL   bNotify          If TRUE, notify clients
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
    DB_TYPE_MISMATCH        Key was created with different type
    DB_NO_ACCESS            No write access
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_DATA_INDEX1, hDB, hKey, data, data_size, idx, type, bNotify);
 
#ifdef LOCAL_ROUTINES
   {
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_data_index1", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_data_index1", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (hKey < (int) sizeof(DATABASE_HEADER)) {
         cm_msg(MERROR, "db_set_data_index1", "invalid key handle");
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
 
      DATABASE* pdb = &_database[hDB - 1];
      DATABASE_HEADER* pheader = pdb->database_header;
 
      /* check if hKey argument is correct */
      if (!db_validate_hkey(pheader, hKey)) {
         db_unlock_database(hDB);
         return DB_INVALID_HANDLE;
      }
 
      KEY* pkey = (KEY *) ((char *) pheader + hKey);
 
      int status = db_check_set_data_index_locked(pheader, pkey, idx, data, data_size, type, "db_set_data_index1", &msg);
 
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      db_allow_write_locked(pdb, "db_set_data_index1");
 
      status = db_set_data_index_wlocked(pheader, pkey, idx, data, data_size, type, "db_set_data_index1", &msg);
 
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      if (bNotify)
         db_notify_clients_locked(pdb, hKey, idx, TRUE, &msg);
      
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*----------------------------------------------------------------------------*/
 
INT db_merge_data(HNDLE hDB, HNDLE hKeyRoot, const char *name, void *data, INT data_size, INT num_values, INT type)
/********************************************************************\
 
  Routine: db_merge_data
 
  Purpose: Merge an array with an ODB array. If the ODB array doesn't
           exist, create it and fill it with the array. If it exists,
           load it in the array. Adjust ODB array size if necessary.
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKeyRoot         Key handle to start with, 0 for root
    cha    *name            Key name relative to hKeyRoot
    void   *data            Pointer to data array
    INT    data_size        Size of data array
    INT    num_values       Number of values in array
    DWORD  type             Type of data
 
  Output:
    none
 
  Function value:
    <same as db_set_data>
 
\********************************************************************/
{
   HNDLE hKey;
   INT status, old_size;
 
   if (num_values == 0)
      return DB_INVALID_PARAM;
 
   status = db_find_key(hDB, hKeyRoot, name, &hKey);
   if (status != DB_SUCCESS) {
      db_create_key(hDB, hKeyRoot, name, type);
      status = db_find_key(hDB, hKeyRoot, name, &hKey);
      if (status != DB_SUCCESS)
         return status;
      status = db_set_data(hDB, hKey, data, data_size, num_values, type);
   } else {
      old_size = data_size;
      db_get_data(hDB, hKey, data, &old_size, type);
      status = db_set_data(hDB, hKey, data, data_size, num_values, type);
   }
 
   return status;
}
 
#ifdef LOCAL_ROUTINES
 
/*------------------------------------------------------------------*/
static int db_set_mode_wlocked(DATABASE_HEADER *pheader, KEY *pkey, WORD mode, int recurse, db_err_msg** msg)
/********************************************************************\
 
  Routine: db_set_mode_wlocked()
 
  Purpose: Set access mode of key
 
  Input:
    pheader                 Database
    pkey                    Key
    DWORD  mode             Access mode, any or'ed combination of
                            MODE_READ, MODE_WRITE, MODE_EXCLUSIVE
                            and MODE_DELETE
    recurse                 Value of 0: do not recurse subtree,
                            value of 1: recurse subtree, becomes recurse level
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   /* resolve links */
   if (pkey->type == TID_LINK) {
      int status;
      pkey = (KEY*)db_resolve_link_locked(pheader, pkey, &status, msg);
      if (!pkey) {
         return status;
      }
   }
 
   if (pkey->type == TID_KEY && recurse) {
      // drop "const" from KEY* we are permitted to write to ODB!
      KEY* psubkey = (KEY*)db_enum_first_locked(pheader, pkey, msg);
      while (psubkey) {
         db_set_mode_wlocked(pheader, psubkey, mode, recurse+1, msg);
         psubkey = (KEY*)db_enum_next_locked(pheader, pkey, psubkey, msg);
      }
   }
 
   /* now set mode */
   pkey->access_mode = mode;
 
   return DB_SUCCESS;
}
 
#endif
 
/*------------------------------------------------------------------*/
INT db_set_mode(HNDLE hDB, HNDLE hKey, WORD mode, BOOL recurse)
/********************************************************************\
 
  Routine: db_set_mode
 
  Purpose: Set access mode of key
 
  Input:
    HNDLE  hDB              Handle to the database
    HNDLE  hKey             Key handle
    DWORD  mode             Access mode, any or'ed combination of
                            MODE_READ, MODE_WRITE, MODE_EXCLUSIVE
                            and MODE_DELETE
    BOOL   recurse          Value of 0 (FALSE): do not recurse subtree,
                            value of 1 (TRUE): recurse subtree,
                            value of 2: recurse subtree, assume database is locked by caller.
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_SET_MODE, hDB, hKey, mode, recurse);
 
#ifdef LOCAL_ROUTINES
   {
      DATABASE_HEADER *pheader;
      BOOL locked = FALSE;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_set_mode", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (!_database[hDB - 1].attached) {
         cm_msg(MERROR, "db_set_mode", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      if (recurse < 2) {
         db_lock_database(hDB);
         locked = TRUE;
      }
 
      pheader = _database[hDB - 1].database_header;
 
      db_err_msg* msg = NULL;
      int status = 0;
 
      KEY *pkey = (KEY*)db_get_pkey(pheader, hKey, &status, "db_set_mode", &msg);
 
      if (!pkey) {
         if (locked) {
            db_unlock_database(hDB);
            if (msg)
               db_flush_msg(&msg);
            return status;
         }
      }
 
      db_allow_write_locked(&_database[hDB-1], "db_set_mode");
 
      status = db_set_mode_wlocked(pheader, pkey, mode, recurse, &msg);
 
      if (locked) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
      }
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_load(HNDLE hDB, HNDLE hKeyRoot, const char *filename, BOOL bRemote)
{
   struct stat stat_buf;
   INT hfile, size, n, i, status;
   char *buffer;
 
   if (rpc_is_remote() && bRemote)
      return rpc_call(RPC_DB_LOAD, hDB, hKeyRoot, filename);
 
   /* open file */
   hfile = open(filename, O_RDONLY | O_TEXT, 0644);
   if (hfile == -1) {
      cm_msg(MERROR, "db_load", "file \"%s\" not found", filename);
      return DB_FILE_ERROR;
   }
 
   /* allocate buffer with file size */
   fstat(hfile, &stat_buf);
   size = stat_buf.st_size;
   buffer = (char *) malloc(size + 1);
 
   if (buffer == NULL) {
      cm_msg(MERROR, "db_load", "cannot allocate ODB load buffer");
      close(hfile);
      return DB_NO_MEMORY;
   }
 
   n = 0;
 
   do {
      i = read(hfile, buffer + n, size - n);
      if (i <= 0)
         break;
      n += i;
   } while (TRUE);
 
   buffer[n] = 0;
 
   if (strncmp(buffer, "<?xml version=\"1.0\"", 19) == 0) {
      status = db_paste_xml(hDB, hKeyRoot, buffer);
      if (status != DB_SUCCESS)
         printf("Error in file \"%s\"\n", filename);
   } else if( buffer[0] == '{'){
      if(strrchr(buffer, '}')){
         status = db_paste_json(hDB, hKeyRoot, buffer);
      } else {
         status = DB_FILE_ERROR;
      }
   } else
      status = db_paste(hDB, hKeyRoot, buffer);
 
   close(hfile);
   free(buffer);
 
   return status;
}
 
/********************************************************************/
INT db_copy(HNDLE hDB, HNDLE hKey, char *buffer, INT * buffer_size, const char *path)
{
   INT i, j, size, status;
   KEY key;
   HNDLE hSubkey;
   char *data;
 
   //printf("db_copy: %d %d %p %d [%s]\n", hDB, hKey, buffer, *buffer_size, path);
 
   std::string full_path = path;
 
   if (full_path.length() > MAX_ODB_PATH) {
      cm_msg(MERROR, "db_copy", "ODB path too long at \"%s\"", path);
      return DB_NO_MEMORY;
   }
 
   BOOL bWritten = FALSE;
 
   /* first enumerate this level */
   for (i = 0;; i++) {
      db_enum_link(hDB, hKey, i, &hSubkey);
 
      if (i == 0 && !hSubkey) {
         std::string line;
 
         /* If key has no subkeys, just write this key */
         status = db_get_link(hDB, hKey, &key);
         if (status != DB_SUCCESS)
            continue;
         size = key.total_size;
         data = (char *) malloc(size);
         if (data == NULL) {
            cm_msg(MERROR, "db_copy", "cannot allocate data buffer");
            return DB_NO_MEMORY;
         }
 
         if (key.type != TID_KEY) {
            status = db_get_link_data(hDB, hKey, data, &size, key.type);
            if (status != DB_SUCCESS)
               continue;
            if (key.num_values == 1) {
               line = msprintf("%s = %s : ", key.name, rpc_tid_name(key.type));
 
               if (key.type == TID_STRING && strchr(data, '\n') != NULL) {
                  /* multiline string */
                  line += "[====#$@$#====]\n";
 
                  /* copy line to buffer */
                  if ((INT) (line.length() + 1) > *buffer_size) {
                     free(data);
                     return DB_TRUNCATED;
                  }
 
                  strcpy(buffer, line.c_str());
                  buffer += line.length();
                  *buffer_size -= line.length();
 
                  /* copy multiple lines to buffer */
                  if (key.item_size > *buffer_size) {
                     free(data);
                     return DB_TRUNCATED;
                  }
 
                  strcpy(buffer, data);
                  buffer += strlen(data);
                  *buffer_size -= strlen(data);
 
                  line = "\n====#$@$#====\n";
               } else {
                  std::string str = db_sprintf(data, key.item_size, 0, key.type);
 
                  if (key.type == TID_STRING || key.type == TID_LINK)
                     line += msprintf("[%d] ", key.item_size);
 
                  line += str + "\n";
               }
            } else {
               line = msprintf("%s = %s[%d] :\n", key.name, rpc_tid_name(key.type), key.num_values);
 
               for (j = 0; j < key.num_values; j++) {
                  if (key.type == TID_STRING || key.type == TID_LINK)
                     line += msprintf("[%d] ", key.item_size);
                  else
                     line += msprintf("[%d] ", j);
 
                  std::string str = db_sprintf(data, key.item_size, j, key.type);
                  line += str + "\n";
 
                  /* copy line to buffer */
                  if ((INT) (line.length() + 1) > *buffer_size) {
                     free(data);
                     return DB_TRUNCATED;
                  }
 
                  strcpy(buffer, line.c_str());
                  buffer += line.length();
                  *buffer_size -= line.length();
                  line.clear();
               }
            }
         }
 
         /* copy line to buffer */
         if ((INT) (line.length() + 1) > *buffer_size) {
            free(data);
            return DB_TRUNCATED;
         }
 
         strcpy(buffer, line.c_str());
         buffer += line.length();
         *buffer_size -= line.length();
 
         free(data);
         data = NULL;
      }
 
      if (!hSubkey)
         break;
 
      status = db_get_link(hDB, hSubkey, &key);
      if (status != DB_SUCCESS)
         continue;
 
      if (strcmp(key.name, "arr2") == 0)
         printf("\narr2\n");
      size = key.total_size;
      data = (char *) malloc(size);
      if (data == NULL) {
         cm_msg(MERROR, "db_copy", "cannot allocate data buffer");
         return DB_NO_MEMORY;
      }
 
      if (key.type == TID_KEY) {
         char str[MAX_ODB_PATH];
 
         /* new line */
         if (bWritten) {
            if (*buffer_size < 2) {
               free(data);
               return DB_TRUNCATED;
            }
 
            strcpy(buffer, "\n");
            buffer += 1;
            *buffer_size -= 1;
         }
 
         strcpy(str, full_path.c_str());
         if (str[0] && str[strlen(str) - 1] != '/')
            strcat(str, "/");
         strcat(str, key.name);
 
         /* recurse */
         status = db_copy(hDB, hSubkey, buffer, buffer_size, str);
         if (status != DB_SUCCESS) {
            free(data);
            return status;
         }
 
         buffer += strlen(buffer);
         bWritten = FALSE;
      } else {
         std::string line;
 
         status = db_get_link_data(hDB, hSubkey, data, &size, key.type);
         if (status != DB_SUCCESS)
            continue;
 
         if (!bWritten) {
            if (path[0] == 0)
               line = "[.]\n";
            else
               line = msprintf("[%s]\n", path);
            bWritten = TRUE;
         }
 
         if (key.num_values == 1) {
            line += msprintf("%s = %s : ", key.name, rpc_tid_name(key.type));
 
            if (key.type == TID_STRING && strchr(data, '\n') != NULL) {
               /* multiline string */
               line += "[====#$@$#====]\n";
 
               /* ensure string limiter */
               data[size - 1] = 0;
 
               /* copy line to buffer */
               if ((INT) (line.length() + 1) > *buffer_size) {
                  free(data);
                  return DB_TRUNCATED;
               }
 
               strcpy(buffer, line.c_str());
               buffer += line.length();
               *buffer_size -= line.length();
 
               /* copy multiple lines to buffer */
               if (key.item_size > *buffer_size) {
                  free(data);
                  return DB_TRUNCATED;
               }
 
               strcpy(buffer, data);
               buffer += strlen(data);
               *buffer_size -= strlen(data);
 
               line = "\n====#$@$#====\n";
            } else {
               std::string str = db_sprintf(data, key.item_size, 0, key.type);
 
               if (key.type == TID_STRING || key.type == TID_LINK)
                  line += msprintf("[%d] ", key.item_size);
 
               line += str + "\n";
            }
         } else {
            line += msprintf("%s = %s[%d] :\n", key.name, rpc_tid_name(key.type), key.num_values);
 
            for (j = 0; j < key.num_values; j++) {
               if (key.type == TID_STRING || key.type == TID_LINK)
                  line += msprintf("[%d] ", key.item_size);
               else
                  line += msprintf("[%d] ", j);
 
               std::string str = db_sprintf(data, key.item_size, j, key.type);
               line += str + "\n";
 
               /* copy line to buffer */
               if ((INT) (line.length() + 1) > *buffer_size) {
                  free(data);
                  return DB_TRUNCATED;
               }
 
               strcpy(buffer, line.c_str());
               buffer += line.length();
               *buffer_size -= line.length();
               line.clear();
            }
         }
 
         /* copy line to buffer */
      if ((INT) (line.length() + 1) > *buffer_size) {
            free(data);
            return DB_TRUNCATED;
         }
 
         strcpy(buffer, line.c_str());
         buffer += line.length();
         *buffer_size -= line.length();
      }
 
      free(data);
      data = NULL;
   }
 
   if (bWritten) {
      if (*buffer_size < 2)
         return DB_TRUNCATED;
 
      strcpy(buffer, "\n");
      buffer += 1;
      *buffer_size -= 1;
   }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_paste(HNDLE hDB, HNDLE hKeyRoot, const char *buffer)
{
   char title[MAX_STRING_LENGTH];
   char *data;
   const char *pold;
   INT data_size, index;
   INT tid, i, j, n_data, string_length, status, size;
   HNDLE hKey;
   KEY root_key;
 
   title[0] = 0;
 
   if (hKeyRoot == 0)
      db_find_key(hDB, hKeyRoot, "", &hKeyRoot);
 
   db_get_key(hDB, hKeyRoot, &root_key);
 
   /* initial data size */
   data_size = 1000;
   data = (char *) malloc(data_size);
   if (data == NULL) {
      cm_msg(MERROR, "db_paste", "cannot allocate data buffer");
      return DB_NO_MEMORY;
   }
 
   do {
      char line[10*MAX_STRING_LENGTH];
 
      if (*buffer == 0)
         break;
 
      for (i = 0; *buffer != '\n' && *buffer && i < 10*MAX_STRING_LENGTH; i++)
         line[i] = *buffer++;
 
      if (i == 10*MAX_STRING_LENGTH) {
         line[10*MAX_STRING_LENGTH-1] = 0;
         cm_msg(MERROR, "db_paste", "line too long: %s...", line);
         free(data);
         return DB_TRUNCATED;
      }
 
      line[i] = 0;
      if (*buffer == '\n')
         buffer++;
 
      /* check if it is a section title */
      if (line[0] == '[') {
         /* extract title and append '/' */
         mstrlcpy(title, line + 1, sizeof(title));
         if (strchr(title, ']'))
            *strchr(title, ']') = 0;
         if (title[0] && title[strlen(title) - 1] != '/')
            mstrlcat(title, "/", sizeof(title));
      } else {
         /* valid data line if it includes '=' and no ';' */
         if (strchr(line, '=') && line[0] != ';') {
            char key_name[MAX_ODB_PATH];
            char test_str[MAX_ODB_PATH];
            char data_str[10*MAX_STRING_LENGTH];
 
            /* copy type info and data */
            char* pline = strrchr(line, '=') + 1;
            while (strstr(line, ": [") != NULL && strstr(line, ": [") < pline) {
               pline -= 2;
               while (*pline != '=' && pline > line)
                  pline--;
               pline++;
            }
            while (*pline == ' ')
               pline++;
            mstrlcpy(data_str, pline, sizeof(data_str));
 
            /* extract key name */
            *strrchr(line, '=') = 0;
            while (strstr(line, ": [") && strchr(line, '='))
               *strrchr(line, '=') = 0;
 
            pline = &line[strlen(line) - 1];
            while (*pline == ' ')
               *pline-- = 0;
 
            key_name[0] = 0;
            if (title[0] != '.')
               mstrlcpy(key_name, title, sizeof(key_name));
 
            mstrlcat(key_name, line, sizeof(key_name));
 
            /* evaluate type info */
            mstrlcpy(line, data_str, sizeof(line));
            if (strchr(line, ' '))
               *strchr(line, ' ') = 0;
 
            n_data = 1;
            if (strchr(line, '[')) {
               n_data = atol(strchr(line, '[') + 1);
               *strchr(line, '[') = 0;
            }
 
            for (tid = 0; tid < TID_LAST; tid++)
               if (strcmp(rpc_tid_name(tid), line) == 0)
                  break;
            if (tid == TID_LAST) {
               for (tid = 0; tid < TID_LAST; tid++)
                  if (strcmp(rpc_tid_name_old(tid), line) == 0)
                     break;
            }
 
            string_length = 0;
 
            if (tid == TID_LAST)
               cm_msg(MERROR, "db_paste", "found unknown data type \"%s\" in ODB file", line);
            else {
               /* skip type info */
               char* pc = data_str;
               while (*pc != ' ' && *pc)
                  pc++;
               while ((*pc == ' ' || *pc == ':') && *pc)
                  pc++;
 
               //mstrlcpy(data_str, pc, sizeof(data_str)); // MacOS 10.9 does not permit mstrlcpy() of overlapping strings
               assert(strlen(pc) < sizeof(data_str)); // "pc" points at a substring inside "data_str"
               memmove(data_str, pc, strlen(pc)+1);
 
               if (n_data > 1) {
                  data_str[0] = 0;
                  if (!*buffer)
                     break;
 
                  for (j = 0; *buffer != '\n' && *buffer; j++)
                     data_str[j] = *buffer++;
                  data_str[j] = 0;
                  if (*buffer == '\n')
                     buffer++;
               }
 
               for (i = 0; i < n_data; i++) {
                  /* strip trailing \n */
                  char* pc = &data_str[strlen(data_str) - 1];
                  while (*pc == '\n' || *pc == '\r')
                     *pc-- = 0;
 
                  if (tid == TID_STRING || tid == TID_LINK) {
                     if (!string_length) {
                        if (data_str[1] == '=')
                           string_length = -1;
                        else
                           string_length = atoi(data_str + 1);
                        if (string_length > MAX_STRING_LENGTH) {
                           string_length = MAX_STRING_LENGTH;
                           cm_msg(MERROR, "db_paste", "found string exceeding MAX_STRING_LENGTH, odb path \"%s\"", key_name);
                        }
                        if (string_length == 0) {
                           string_length = 32;
                           cm_msg(MERROR, "db_paste", "found string length of zero, set to 32, odb path \"%s\"", key_name);
                        }
                     }
 
                     if (string_length == -1) {
                        /* multi-line string */
                        if (strstr(buffer, "\n====#$@$#====\n") != NULL) {
                           string_length = (POINTER_T) strstr(buffer, "\n====#$@$#====\n") - (POINTER_T) buffer + 1;
 
                           if (string_length >= data_size) {
                              data_size += string_length + 100;
                              data = (char *) realloc(data, data_size);
                              if (data == NULL) {
                                 cm_msg(MERROR, "db_paste", "cannot allocate data buffer");
                                 return DB_NO_MEMORY;
                              }
                           }
 
                           memset(data, 0, data_size);
                           strncpy(data, buffer, string_length);
                           data[string_length - 1] = 0;
                           buffer = strstr(buffer, "\n====#$@$#====\n") + strlen("\n====#$@$#====\n");
                        } else
                           cm_msg(MERROR, "db_paste", "found multi-line string without termination sequence");
                     } else {
                        char* pc = data_str + 2;
                        while (*pc && *pc != ' ')
                           pc++;
 
                        // skip one space (needed for strings starting with spaces)
                        if (*pc)
                           pc++;
 
                        /* limit string size */
                        *(pc + string_length - 1) = 0;
 
                        /* increase data buffer if necessary */
                        if (string_length * (i + 1) >= data_size) {
                           data_size += 1000;
                           data = (char *) realloc(data, data_size);
                           if (data == NULL) {
                              cm_msg(MERROR, "db_paste", "cannot allocate data buffer");
                              return DB_NO_MEMORY;
                           }
                        }
 
                        mstrlcpy(data + string_length * i, pc, string_length);
                     }
                  } else {
                     char* pc = data_str;
 
                     if (n_data > 1 && data_str[0] == '[') {
                        index = atoi(data_str+1);
                        pc = strchr(data_str, ']') + 1;
                        while (*pc && *pc == ' ')
                           pc++;
                     } else
                        index = 0;
 
                     /* increase data buffer if necessary */
                     if (rpc_tid_size(tid) * (index + 1) >= data_size) {
                        data_size += 1000;
                        data = (char *) realloc(data, data_size);
                        if (data == NULL) {
                           cm_msg(MERROR, "db_paste", "cannot allocate data buffer");
                           return DB_NO_MEMORY;
                        }
                     }
 
                     db_sscanf(pc, data, &size, index, tid);
                  }
 
                  if (i < n_data - 1) {
                     data_str[0] = 0;
                     if (!*buffer)
                        break;
 
                     pold = buffer;
 
                     for (j = 0; *buffer != '\n' && *buffer; j++)
                        data_str[j] = *buffer++;
                     data_str[j] = 0;
                     if (*buffer == '\n')
                        buffer++;
 
                     /* test if valid data */
                     if (tid != TID_STRING && tid != TID_LINK) {
                        if (data_str[0] == 0 || (strchr(data_str, '=')
                                                 && strchr(data_str, ':')))
                           buffer = pold;
                     }
                  }
               }
 
               /* skip system client entries */
               mstrlcpy(test_str, key_name, sizeof(test_str));
               test_str[15] = 0;
 
               if (!equal_ustring(test_str, "/System/Clients")) {
                  if (root_key.type != TID_KEY) {
                     /* root key is destination key */
                     hKey = hKeyRoot;
                  } else {
                     /* create key and set value */
                     if (key_name[0] == '/') {
                        status = db_find_link(hDB, 0, key_name, &hKey);
                        if (status == DB_NO_KEY) {
                           db_create_key(hDB, 0, key_name, tid);
                           status = db_find_link(hDB, 0, key_name, &hKey);
                        }
                     } else {
                        status = db_find_link(hDB, hKeyRoot, key_name, &hKey);
                        if (status == DB_NO_KEY) {
                           db_create_key(hDB, hKeyRoot, key_name, tid);
                           status = db_find_link(hDB, hKeyRoot, key_name, &hKey);
                        }
                     }
                  }
 
                  /* set key data if created successfully */
                  if (hKey) {
                     if (tid == TID_STRING || tid == TID_LINK)
                        db_set_link_data(hDB, hKey, data, string_length * n_data, n_data, tid);
                     else
                        db_set_link_data(hDB, hKey, data, rpc_tid_size(tid) * n_data, n_data, tid);
                  }
               }
            }
         }
      }
   } while (TRUE);
 
   free(data);
   return DB_SUCCESS;
}
 
/********************************************************************/
/*
  Only internally used by db_paste_xml
*/
static int db_paste_node(HNDLE hDB, HNDLE hKeyRoot, PMXML_NODE node)
{
   int status;
 
   if (strcmp(mxml_get_name(node), "odb") == 0) {
      for (int i = 0; i < mxml_get_number_of_children(node); i++) {
         status = db_paste_node(hDB, hKeyRoot, mxml_subnode(node, i));
         if (status != DB_SUCCESS)
            return status;
      }
   } else if (strcmp(mxml_get_name(node), "dir") == 0) {
      const char* name = mxml_get_attribute(node, "name");
 
      if (name == NULL) {
         cm_msg(MERROR, "db_paste_node", "found key \"%s\" with no name in XML data", mxml_get_name(node));
         return DB_TYPE_MISMATCH;
      }
 
      HNDLE hKey;
      status = db_find_link(hDB, hKeyRoot, name, &hKey);
 
      if (status == DB_NO_KEY) {
         status = db_create_key(hDB, hKeyRoot, name, TID_KEY);
         if (status == DB_NO_ACCESS) {
            cm_msg(MINFO, "db_paste_node", "cannot load key \"%s\": write protected", name);
            return DB_SUCCESS;  /* key or tree is locked, just skip it */
         }
 
         if (status != DB_SUCCESS && status != DB_KEY_EXIST) {
            cm_msg(MERROR, "db_paste_node", "cannot create key \"%s\" in ODB, status = %d", name, status);
            return status;
         }
         status = db_find_link(hDB, hKeyRoot, name, &hKey);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "db_paste_node", "cannot find key \"%s\" in ODB", name);
            return status;
         }
      }
 
      std::string path = db_get_path(hDB, hKey);
      if (!equal_ustring(path.c_str(), "/System/Clients")) {
         for (int i = 0; i < mxml_get_number_of_children(node); i++) {
            status = db_paste_node(hDB, hKey, mxml_subnode(node, i));
            if (status != DB_SUCCESS)
               return status;
         }
      }
   } else if (strcmp(mxml_get_name(node), "key") == 0 || strcmp(mxml_get_name(node), "keyarray") == 0) {
 
      const char* name = mxml_get_attribute(node, "name");
 
      if (name == NULL) {
         cm_msg(MERROR, "db_paste_node", "found key \"%s\" with no name in XML data", mxml_get_name(node));
         return DB_TYPE_MISMATCH;
      }
 
      int num_values;
      if (strcmp(mxml_get_name(node), "keyarray") == 0)
         num_values = atoi(mxml_get_attribute(node, "num_values"));
      else
         num_values = 0;
 
      const char* type = mxml_get_attribute(node, "type");
 
      if (type == NULL) {
         cm_msg(MERROR, "db_paste_node", "found key \"%s\" with no type in XML data", mxml_get_name(node));
         return DB_TYPE_MISMATCH;
      }
 
      int tid = rpc_name_tid(type);
      if (tid == 0) {
         cm_msg(MERROR, "db_paste_node", "found unknown data type \"%s\" in XML data", type);
         return DB_TYPE_MISMATCH;
      }
 
      HNDLE hKey;
      status = db_find_link(hDB, hKeyRoot, name, &hKey);
      if (status == DB_NO_KEY) {
         status = db_create_key(hDB, hKeyRoot, name, tid);
         if (status == DB_NO_ACCESS) {
            cm_msg(MINFO, "db_paste_node", "cannot load key \"%s\": write protected", name);
            return DB_SUCCESS;  /* key or tree is locked, just skip it */
         }
 
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "db_paste_node", "cannot create key \"%s\" in ODB, status = %d", name, status);
            return status;
         }
         status = db_find_link(hDB, hKeyRoot, name, &hKey);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "db_paste_node", "cannot find key \"%s\" in ODB, status = %d", name, status);
            return status;
         }
      } else {
         KEY key;
         status = db_get_key(hDB, hKey, &key);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "db_paste_node", "cannot get key \"%s\" in ODB, status = %d", name, status);
            return status;
         }
 
         if (num_values > 0 && num_values != key.num_values && key.item_size > 0) {
            status = db_set_num_values(hDB, hKey, num_values);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "db_paste_node", "cannot resize key \"%s\" in ODB, status = %d", name, status);
               return status;
            }
         }
      }
 
      int size = 0;
      char *buf = NULL;
 
      if (tid == TID_STRING || tid == TID_LINK) {
         size = atoi(mxml_get_attribute(node, "size"));
         buf = (char *)malloc(size);
         assert(buf);
         buf[0] = 0;
      }
 
      if (num_values) {
         /* evaluate array */
         for (int i = 0; i < mxml_get_number_of_children(node); i++) {
            PMXML_NODE child = mxml_subnode(node, i);
            int idx;
            if (mxml_get_attribute(child, "index"))
               idx = atoi(mxml_get_attribute(child, "index"));
            else
               idx = i;
            if (tid == TID_STRING || tid == TID_LINK) {
               if (mxml_get_value(child) == NULL) {
                  status = db_set_data_index(hDB, hKey, "", size, i, tid);
                  if (status == DB_NO_ACCESS) {
                     cm_msg(MINFO, "db_paste_node", "cannot load string or link \"%s\": write protected", mxml_get_attribute(node, "name"));
                     return DB_SUCCESS;  /* key or tree is locked, just skip it */
                  } else if (status != DB_SUCCESS) {
                     cm_msg(MERROR, "db_paste_node", "cannot load string or link \"%s\": db_set_data_index() status %d", mxml_get_attribute(node, "name"), status);
                     return status;
                  }
               } else {
                  mstrlcpy(buf, mxml_get_value(child), size);
                  status = db_set_data_index(hDB, hKey, buf, size, idx, tid);
                  if (status == DB_NO_ACCESS) {
                     cm_msg(MINFO, "db_paste_node", "cannot load array element \"%s\": write protected", mxml_get_attribute(node, "name"));
                     return DB_SUCCESS;  /* key or tree is locked, just skip it */
                  } else if (status != DB_SUCCESS) {
                     cm_msg(MERROR, "db_paste_node", "cannot load array element \"%s\": db_set_data_index() status %d", mxml_get_attribute(node, "name"), status);
                     return status;
                  }
               }
            } else {
               char data[256];
               db_sscanf(mxml_get_value(child), data, &size, 0, tid);
               status = db_set_data_index(hDB, hKey, data, rpc_tid_size(tid), idx, tid);
               if (status == DB_NO_ACCESS) {
                  cm_msg(MINFO, "db_paste_node", "cannot load array element \"%s\": write protected", mxml_get_attribute(node, "name"));
                  return DB_SUCCESS;  /* key or tree is locked, just skip it */
               } else if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "db_paste_node", "cannot load array element \"%s\": db_set_data_index() status %d", mxml_get_attribute(node, "name"), status);
                  return status;
               }
            }
         }
 
      } else {                  /* single value */
         if (tid == TID_STRING || tid == TID_LINK) {
            size = atoi(mxml_get_attribute(node, "size"));
            if (mxml_get_value(node) == NULL) {
               status = db_set_data(hDB, hKey, "", size, 1, tid);
               if (status == DB_NO_ACCESS) {
                  cm_msg(MINFO, "db_paste_node", "cannot load string or link \"%s\": write protected", mxml_get_attribute(node, "name"));
                  return DB_SUCCESS;  /* key or tree is locked, just skip it */
               } else if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "db_paste_node", "cannot load string or link \"%s\": db_set_data() status %d", mxml_get_attribute(node, "name"), status);
                  return status;
               }
            } else {
               mstrlcpy(buf, mxml_get_value(node), size);
               status = db_set_data(hDB, hKey, buf, size, 1, tid);
               if (status == DB_NO_ACCESS) {
                  cm_msg(MINFO, "db_paste_node", "cannot load value \"%s\": write protected", mxml_get_attribute(node, "name"));
                  return DB_SUCCESS;  /* key or tree is locked, just skip it */
               } else if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "db_paste_node", "cannot load value \"%s\": db_set_data() status %d", mxml_get_attribute(node, "name"), status);
                  return status;
               }
            }
         } else {
            char data[256];
            db_sscanf(mxml_get_value(node), data, &size, 0, tid);
            status = db_set_data(hDB, hKey, data, rpc_tid_size(tid), 1, tid);
            if (status == DB_NO_ACCESS) {
               cm_msg(MINFO, "db_paste_node", "cannot load value \"%s\": write protected", mxml_get_attribute(node, "name"));
               return DB_SUCCESS;  /* key or tree is locked, just skip it */
            } else if (status != DB_SUCCESS) {
               cm_msg(MERROR, "db_paste_node", "cannot load value \"%s\": db_set_data() status %d", mxml_get_attribute(node, "name"), status);
               return status;
            }
         }
      }
 
      if (buf) {
         free(buf);
         buf = NULL;
      }
   }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_paste_xml(HNDLE hDB, HNDLE hKeyRoot, const char *buffer)
{
   char error[256];
   INT status;
   PMXML_NODE tree, node;
 
   if (hKeyRoot == 0)
      db_find_key(hDB, hKeyRoot, "", &hKeyRoot);
 
   /* parse XML buffer */
   tree = mxml_parse_buffer(buffer, error, sizeof(error), NULL);
   if (tree == NULL) {
      puts(error);
      return DB_TYPE_MISMATCH;
   }
 
   node = mxml_find_node(tree, "odb");
   if (node == NULL) {
      puts("Cannot find element \"odb\" in XML data");
      return DB_TYPE_MISMATCH;
   }
 
   status = db_paste_node(hDB, hKeyRoot, node);
 
   mxml_free_tree(tree);
 
   return status;
}
 
/********************************************************************/
INT db_copy_xml(HNDLE hDB, HNDLE hKey, char *buffer, int *buffer_size, bool header)
{
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_COPY_XML, hDB, hKey, buffer, buffer_size, header);
 
#ifdef LOCAL_ROUTINES
   {
      INT len;
      char *p;
      MXML_WRITER *writer;
 
      /* open file */
      writer = mxml_open_buffer();
      if (writer == NULL) {
         cm_msg(MERROR, "db_copy_xml", "Cannot allocate buffer");
         return DB_NO_MEMORY;
      }
 
      if (header) {
         std::string path = db_get_path(hDB, hKey);
 
         /* write XML header */
         mxml_start_element(writer, "odb");
         mxml_write_attribute(writer, "root", path.c_str());
         mxml_write_attribute(writer, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
         mxml_write_attribute(writer, "xsi:noNamespaceSchemaLocation", "http://midas.psi.ch/odb.xsd");
 
         db_save_xml_key(hDB, hKey, 0, writer);
         mxml_end_element(writer); // "odb"
      } else {
         KEY key;
         int status = db_get_key(hDB, hKey, &key);
         if (status != DB_SUCCESS)
            return status;
 
         db_save_xml_key(hDB, hKey, 1, writer);
      }
 
      p = mxml_close_buffer(writer);
      len = strlen(p) + 1;
      if (len > *buffer_size) {
         free(p);
         *buffer_size = 0;
         return DB_TRUNCATED;
      }
 
      mstrlcpy(buffer, p, len);
      free(p);
      *buffer_size = len;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
void name2c(char *str)
/********************************************************************\
 
  Routine: name2c
 
  Purpose: Convert key name to C name. Internal use only.
 
\********************************************************************/
{
   if (*str >= '0' && *str <= '9')
      *str = '_';
 
   while (*str) {
      if (!(*str >= 'a' && *str <= 'z') && !(*str >= 'A' && *str <= 'Z') && !(*str >= '0' && *str <= '9'))
         *str = '_';
      *str = (char) tolower(*str);
      str++;
   }
}
 
/*------------------------------------------------------------------*/
static void db_save_tree_struct(HNDLE hDB, HNDLE hKey, int hfile, INT level)
/********************************************************************\
 
  Routine: db_save_tree_struct
 
  Purpose: Save database tree as a C structure. Gets called by
           db_save_struct(). Internal use only.
 
\********************************************************************/
{
   INT i, idx;
   KEY key;
   HNDLE hSubkey;
   int wr;
 
   /* first enumerate this level */
   for (idx = 0;; idx++) {
      char name[MAX_ODB_PATH];
 
      db_enum_link(hDB, hKey, idx, &hSubkey);
      if (!hSubkey)
         break;
 
      /* first get the name of the link, than the type of the link target */
      db_get_key(hDB, hSubkey, &key);
      mstrlcpy(name, key.name, sizeof(name));
      db_enum_key(hDB, hKey, idx, &hSubkey);
 
      db_get_key(hDB, hSubkey, &key);
 
      if (key.type != TID_KEY) {
         char line[MAX_ODB_PATH];
         char str[MAX_ODB_PATH];
 
         for (i = 0; i <= level; i++) {
            wr = write(hfile, "  ", 2);
            assert(wr == 2);
         }
 
         switch (key.type) {
         case TID_INT8:
         case TID_CHAR:
            strcpy(line, "char");
            break;
         case TID_INT16:
            strcpy(line, "short");
            break;
         case TID_FLOAT:
            strcpy(line, "float");
            break;
         case TID_DOUBLE:
            strcpy(line, "double");
            break;
         case TID_BITFIELD:
            strcpy(line, "unsigned char");
            break;
         case TID_STRING:
            strcpy(line, "char");
            break;
         case TID_LINK:
            strcpy(line, "char");
            break;
         default:
            strcpy(line, rpc_tid_name(key.type));
            break;
         }
 
         mstrlcat(line, "                    ", sizeof(line));
         mstrlcpy(str, name, sizeof(str));
         name2c(str);
 
         if (key.num_values > 1)
            sprintf(str + strlen(str), "[%d]", key.num_values);
         if (key.type == TID_STRING || key.type == TID_LINK)
            sprintf(str + strlen(str), "[%d]", key.item_size);
 
         mstrlcpy(line + 10, str, sizeof(line) - 10);
         mstrlcat(line, ";\n", sizeof(line));
 
         wr = write(hfile, line, strlen(line));
         assert(wr > 0);
      } else {
         char line[10+MAX_ODB_PATH];
         char str[MAX_ODB_PATH];
 
         /* recurse subtree */
         for (i = 0; i <= level; i++) {
            wr = write(hfile, "  ", 2);
            assert(wr == 2);
         }
 
         sprintf(line, "struct {\n");
         wr = write(hfile, line, strlen(line));
         assert(wr > 0);
         db_save_tree_struct(hDB, hSubkey, hfile, level + 1);
 
         for (i = 0; i <= level; i++) {
            wr = write(hfile, "  ", 2);
            assert(wr == 2);
         }
 
         strcpy(str, name);
         name2c(str);
 
         sprintf(line, "} %s;\n", str);
         wr = write(hfile, line, strlen(line));
         assert(wr > 0);
      }
   }
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_save(HNDLE hDB, HNDLE hKey, const char *filename, BOOL bRemote)
{
   if (rpc_is_remote() && bRemote)
      return rpc_call(RPC_DB_SAVE, hDB, hKey, filename, bRemote);
 
#ifdef LOCAL_ROUTINES
   {
      INT hfile, size, buffer_size, n, status;
      char *buffer;
 
      /* open file */
      hfile = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_TEXT, 0644);
      if (hfile == -1) {
         cm_msg(MERROR, "db_save", "Cannot open file \"%s\"", filename);
         return DB_FILE_ERROR;
      }
 
      std::string path = db_get_path(hDB, hKey);
 
      buffer_size = 10000;
      do {
         buffer = (char *) malloc(buffer_size);
         if (buffer == NULL) {
            cm_msg(MERROR, "db_save", "cannot allocate ODB dump buffer");
            break;
         }
 
         size = buffer_size;
         status = db_copy(hDB, hKey, buffer, &size, path.c_str());
         if (status != DB_TRUNCATED) {
            n = write(hfile, buffer, buffer_size - size);
            free(buffer);
            buffer = NULL;
 
            if (n != buffer_size - size) {
               cm_msg(MERROR, "db_save", "cannot save .ODB file");
               close(hfile);
               return DB_FILE_ERROR;
            }
            break;
         }
 
         /* increase buffer size if truncated */
         free(buffer);
         buffer = NULL;
         buffer_size *= 2;
      } while (1);
 
      close(hfile);
 
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
void xml_encode(char *src, int size)
{
   int i;
   char *dst, *p;
 
   dst = (char *) malloc(size);
   if (dst == NULL)
      return;
 
   *dst = 0;
   for (i = 0; i < (int) strlen(src); i++) {
      switch (src[i]) {
      case '<':
         mstrlcat(dst, "&lt;", size);
         break;
      case '>':
         mstrlcat(dst, "&gt;", size);
         break;
      case '&':
         mstrlcat(dst, "&amp;", size);
         break;
      case '\"':
         mstrlcat(dst, "&quot;", size);
         break;
      case '\'':
         mstrlcat(dst, "&apos;", size);
         break;
      default:
         if ((int) strlen(dst) >= size) {
            free(dst);
            return;
         }
         p = dst + strlen(dst);
         *p = src[i];
         *(p + 1) = 0;
      }
   }
 
   mstrlcpy(src, dst, size);
}
 
/*------------------------------------------------------------------*/
 
INT db_save_xml_key(HNDLE hDB, HNDLE hKey, INT level, MXML_WRITER * writer)
{
   INT i, idx, size, status;
   char *data;
   HNDLE hSubkey;
   KEY key;
 
   if (level > MAX_ODB_PATH) {
      cm_msg(MERROR, "db_save_xml_key", "ODB path too long at \"%s\"", db_get_path(hDB, hKey).c_str());
      return DB_NO_MEMORY;
   }
 
   status = db_get_link(hDB, hKey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   if (key.type == TID_KEY) {
 
      /* save opening tag for subtree */
 
      if (level > 0) {
         mxml_start_element(writer, "dir");
         mxml_write_attribute(writer, "name", key.name);
         mxml_write_attribute(writer, "handle", std::to_string(hKey).c_str());
      }
 
      for (idx = 0;; idx++) {
         db_enum_link(hDB, hKey, idx, &hSubkey);
 
         if (!hSubkey)
            break;
 
         /* save subtree */
         status = db_save_xml_key(hDB, hSubkey, level + 1, writer);
         if (status != DB_SUCCESS)
            return status;
      }
 
      /* save closing tag for subtree */
      if (level > 0)
         mxml_end_element(writer);
 
   } else {
      /* save key value */
 
      if (key.num_values > 1)
         mxml_start_element(writer, "keyarray");
      else
         mxml_start_element(writer, "key");
      mxml_write_attribute(writer, "name", key.name);
      mxml_write_attribute(writer, "type", rpc_tid_name(key.type));
      mxml_write_attribute(writer, "handle", std::to_string(hKey).c_str());
 
      if (key.type == TID_STRING || key.type == TID_LINK) {
         char str[256];
         sprintf(str, "%d", key.item_size);
         mxml_write_attribute(writer, "size", str);
      }
 
      if (key.num_values > 1) {
         char str[256];
         sprintf(str, "%d", key.num_values);
         mxml_write_attribute(writer, "num_values", str);
      }
 
      size = key.total_size;
      data = (char *) malloc(size+1); // an extra byte to zero-terminate strings
      if (data == NULL) {
         cm_msg(MERROR, "db_save_xml_key", "cannot allocate data buffer");
         return DB_NO_MEMORY;
      }
 
      db_get_link_data(hDB, hKey, data, &size, key.type);
 
      if (key.num_values == 1) {
         if (key.type == TID_STRING) {
            data[size] = 0; // make sure strings are NUL-terminated
            mxml_write_value(writer, data);
         } else {
            std::string str = db_sprintf(data, key.item_size, 0, key.type);
            if (key.type == TID_STRING && strlen(data) >= MAX_STRING_LENGTH) {
               std::string path = db_get_path(hDB, hKey);
               cm_msg(MERROR, "db_save_xml_key", "Long odb string probably truncated, odb path \"%s\", string length %d truncated to %d", path.c_str(), (int)strlen(data), (int)str.length());
            }
            mxml_write_value(writer, str.c_str());
         }
         mxml_end_element(writer);
 
      } else {                  /* array of values */
 
         for (i = 0; i < key.num_values; i++) {
 
            mxml_start_element(writer, "value");
 
            {
               char str[256];
               sprintf(str, "%d", i);
               mxml_write_attribute(writer, "index", str);
            }
 
            if (key.type == TID_STRING) {
               char* p = data + i * key.item_size;
               p[key.item_size - 1] = 0; // make sure string is NUL-terminated
               //cm_msg(MINFO, "db_save_xml_key", "odb string array item_size %d, index %d length %d", key.item_size, i, (int)strlen(p));
               mxml_write_value(writer, p);
            } else {
               std::string str = db_sprintf(data, key.item_size, i, key.type);
               if ((key.type == TID_STRING) && (str.length() >= MAX_STRING_LENGTH-1)) {
                  std::string path = db_get_path(hDB, hKey);
                  cm_msg(MERROR, "db_save_xml_key", "Long odb string array probably truncated, odb path \"%s\"[%d]", path.c_str(), i);
               }
               mxml_write_value(writer, str.c_str());
            }
 
            mxml_end_element(writer);
         }
 
         mxml_end_element(writer);      /* keyarray */
      }
 
      free(data);
      data = NULL;
   }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_save_xml(HNDLE hDB, HNDLE hKey, const char *filename)
{
#ifdef LOCAL_ROUTINES
   {
      INT status;
      MXML_WRITER *writer;
 
      /* open file */
      writer = mxml_open_file(filename);
      if (writer == NULL) {
         cm_msg(MERROR, "db_save_xml", "Cannot open file \"%s\"", filename);
         return DB_FILE_ERROR;
      }
 
      std::string path = db_get_path(hDB, hKey);
 
      /* write XML header */
      mxml_start_element(writer, "odb");
      mxml_write_attribute(writer, "root", path.c_str());
      mxml_write_attribute(writer, "filename", filename);
      mxml_write_attribute(writer, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
      std::string xsd_path;
 
      if (getenv("MIDASSYS"))
         xsd_path = getenv("MIDASSYS");
      else
         xsd_path = ".";
 
      xsd_path += DIR_SEPARATOR_STR;
      xsd_path += "odb.xsd";
      mxml_write_attribute(writer, "xsi:noNamespaceSchemaLocation", xsd_path.c_str());
 
      status = db_save_xml_key(hDB, hKey, 0, writer);
 
      mxml_end_element(writer); // "odb"
      mxml_close_file(writer);
 
      return status;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
void json_write(char **buffer, int* buffer_size, int* buffer_end, int level, const char* s, int quoted)
{
   int len, remain, xlevel;
 
   len = strlen(s);
   remain = *buffer_size - *buffer_end;
   assert(remain >= 0);
 
   xlevel = 2*level;
 
   while (10 + xlevel + 3*len > remain) {
      // reallocate the buffer
      int new_buffer_size = 2*(*buffer_size);
      if (new_buffer_size < 4*1024)
         new_buffer_size = 4*1024;
      //printf("reallocate: len %d, size %d, remain %d, allocate %d\n", len, *buffer_size, remain, new_buffer_size);
      assert(new_buffer_size > *buffer_size);
      *buffer = (char *)realloc(*buffer, new_buffer_size);
      assert(*buffer);
      *buffer_size = new_buffer_size;
      remain = *buffer_size - *buffer_end;
      assert(remain >= 0);
   }
 
   if (xlevel) {
      int i;
      for (i=0; i<xlevel; i++)
         (*buffer)[(*buffer_end)++] = ' ';
   }
 
   if (!quoted) {
      memcpy(*buffer + *buffer_end, s, len);
      *buffer_end += len;
      (*buffer)[*buffer_end] = 0; // NUL-terminate the buffer
      return;
   }
 
   char *bufptr = *buffer;
   int bufend = *buffer_end;
   
   bufptr[bufend++] = '"';
 
   while (*s) {
      switch (*s) {
      case '\"':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = '\"';
         s++;
         break;
      case '\\':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = '\\';
         s++;
         break;
#if 0
      case '/':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = '/';
         s++;
         break;
#endif
      case '\b':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = 'b';
         s++;
         break;
      case '\f':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = 'f';
         s++;
         break;
      case '\n':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = 'n';
         s++;
         break;
      case '\r':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = 'r';
         s++;
         break;
      case '\t':
         bufptr[bufend++] = '\\';
         bufptr[bufend++] = 't';
         s++;
         break;
      default:
         bufptr[bufend++] = *s++;
      }
   }
 
   bufptr[bufend++] = '"';
   bufptr[bufend] = 0; // NUL-terminate the buffer
 
   *buffer_end = bufend;
 
   remain = *buffer_size - *buffer_end;
   assert(remain > 0);
}
 
static void json_ensure_decimal_dot(char *str)
{
   // sprintf "%.2e" can result in strings like "1,23e6" if
   // the user's locale has a comma for the decimal spearator.
   // However the JSON RFC requires a dot for the decimal.
   // This approach of "sprintf-then-replace" is much safer than 
   // changing the user's locale, and much faster than the C++
   // approach of using a stringstream that we "imbue" with a C locale.
   char* comma = strchr(str, ',');
 
   if (comma != nullptr) {
      *comma = '.';
   }
}
 
static void json_write_data(char **buffer, int* buffer_size, int* buffer_end, int level, const KEY* key, const char* p)
{
   char str[256];
   switch (key->type) {
   case TID_UINT8:
      sprintf(str, "%u", *(unsigned char*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_INT8:
      sprintf(str, "%d", *(char*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_CHAR:
      sprintf(str, "%c", *(char*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 1);
      break;
   case TID_UINT16:
      sprintf(str, "\"0x%04x\"", *(WORD*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_INT16:
      sprintf(str, "%d", *(short*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_UINT32:
      sprintf(str, "\"0x%08x\"", *(DWORD*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_INT32:
      sprintf(str, "%d", *(int*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_UINT64:
      // encode as hex string
      sprintf(str, "\"0x%016llx\"", *(UINT64*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_INT64:
      // encode as decimal string
      sprintf(str, "\"%lld\"", *(INT64*)p);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      break;
   case TID_BOOL:
      if (*(int*)p)
         json_write(buffer, buffer_size, buffer_end, 0, "true", 0);
      else
         json_write(buffer, buffer_size, buffer_end, 0, "false", 0);
      break;
   case TID_FLOAT: {
      float flt = (*(float*)p);
      if (isnan(flt))
         json_write(buffer, buffer_size, buffer_end, 0, "\"NaN\"", 0);
      else if (isinf(flt)) {
         if (flt > 0)
            json_write(buffer, buffer_size, buffer_end, 0, "\"Infinity\"", 0);
         else
            json_write(buffer, buffer_size, buffer_end, 0, "\"-Infinity\"", 0);
      } else if (flt == 0)
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
      else if (flt == (int)flt) {
         sprintf(str, "%.0f", flt);
         json_ensure_decimal_dot(str);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      } else {
         sprintf(str, "%.7e", flt);
         json_ensure_decimal_dot(str);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      }
      break;
   }
   case TID_DOUBLE: {
      double dbl = (*(double*)p);
      if (isnan(dbl))
         json_write(buffer, buffer_size, buffer_end, 0, "\"NaN\"", 0);
      else if (isinf(dbl)) {
         if (dbl > 0)
            json_write(buffer, buffer_size, buffer_end, 0, "\"Infinity\"", 0);
         else
            json_write(buffer, buffer_size, buffer_end, 0, "\"-Infinity\"", 0);
      } else if (dbl == 0)
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
      else if (dbl == (int)dbl) {
         sprintf(str, "%.0f", dbl);
         json_ensure_decimal_dot(str);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      } else {
         sprintf(str, "%.16e", dbl);
         json_ensure_decimal_dot(str);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
      }
      break;
   }
   case TID_BITFIELD:
      json_write(buffer, buffer_size, buffer_end, 0, "(TID_BITFIELD value)", 1);
      break;
   case TID_STRING:
      // data is already NUL terminated // p[key.item_size-1] = 0;  // make sure string is NUL terminated!
      json_write(buffer, buffer_size, buffer_end, 0, p, 1);
      break;
   case TID_ARRAY:
      json_write(buffer, buffer_size, buffer_end, 0, "(TID_ARRAY value)", 1);
      break;
   case TID_STRUCT:
      json_write(buffer, buffer_size, buffer_end, 0, "(TID_STRUCT value)", 1);
      break;
   case TID_KEY:
      json_write(buffer, buffer_size, buffer_end, 0, "{ }", 0);
      break;
   case TID_LINK:
      // data is already NUL terminated // p[key.item_size-1] = 0;  // make sure string is NUL terminated!
      json_write(buffer, buffer_size, buffer_end, 0, p, 1);
      break;
   default:
      json_write(buffer, buffer_size, buffer_end, 0, "(TID_UNKNOWN value)", 1);
   }
}
 
static void json_write_key(HNDLE hDB, HNDLE hKey, const KEY* key, const char* link_path, char **buffer, int* buffer_size, int* buffer_end)
{
   char str[256]; // not used to store anything long, only numeric values like: "item_size: 100"
 
   json_write(buffer, buffer_size, buffer_end, 0, "{ ", 0);
 
   sprintf(str, "\"type\" : %d", key->type);
   json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
   if (link_path) {
      json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
      json_write(buffer, buffer_size, buffer_end, 0, "link", 1);
      json_write(buffer, buffer_size, buffer_end, 0, ": ", 0);
      json_write(buffer, buffer_size, buffer_end, 0, link_path, 1);
   }
 
   if (key->num_values > 1) {
      json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
      sprintf(str, "\"num_values\" : %d", key->num_values);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
   }
 
   if (key->type == TID_STRING) {
      json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
      sprintf(str, "\"item_size\" : %d", key->item_size);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
   }
 
   if (key->notify_count > 0) {
      json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
      sprintf(str, "\"notify_count\" : %d", key->notify_count);
      json_write(buffer, buffer_size, buffer_end, 0, str, 0);
   }
 
   json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
   sprintf(str, "\"access_mode\" : %d", key->access_mode);
   json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
   json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
   sprintf(str, "\"last_written\" : %d", key->last_written);
   json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
   json_write(buffer, buffer_size, buffer_end, 0, " ", 0);
 
   json_write(buffer, buffer_size, buffer_end, 0, "}", 0);
}
 
static int db_save_json_key_obsolete(HNDLE hDB, HNDLE hKey, INT level, char **buffer, int* buffer_size, int* buffer_end, int save_keys, int follow_links, int recurse)
{
   INT i, size, status;
   char *data;
   KEY key;
   KEY link_key;
   char link_path[MAX_ODB_PATH];
   int omit_top_level_braces = 0;
 
   //printf("db_save_json_key: key %d, level %d, save_keys %d, follow_links %d, recurse %d\n", hKey, level, save_keys, follow_links, recurse);
 
   if (level < 0) {
      level = 0;
      omit_top_level_braces = 1;
   }
 
   status = db_get_link(hDB, hKey, &key);
 
   if (status != DB_SUCCESS)
      return status;
 
   link_key = key;
 
   if (key.type == TID_LINK) {
      size = sizeof(link_path);
      status = db_get_data(hDB, hKey, link_path, &size, TID_LINK);
 
      if (status != DB_SUCCESS)
         return status;
 
      if (follow_links) {
         status = db_find_key(hDB, 0, link_path, &hKey);
 
         if (status != DB_SUCCESS)
            return status;
 
         status = db_get_key(hDB, hKey, &key);
 
         if (status != DB_SUCCESS)
            return status;
      }
   }
 
   //printf("key [%s] link [%s], type %d, link %d\n", key.name, link_key.name, key.type, link_key.type);
 
   if (key.type == TID_KEY && (recurse || level<=0)) {
      int idx = 0;
      int do_close_curly_bracket = 0;
 
      if (level == 0 && !omit_top_level_braces) {
         json_write(buffer, buffer_size, buffer_end, 0, "{\n", 0);
         do_close_curly_bracket = 1;
      }
      else if (level > 0) {
         json_write(buffer, buffer_size, buffer_end, level, link_key.name, 1);
         json_write(buffer, buffer_size, buffer_end, 0, " : {\n", 0);
         do_close_curly_bracket = 1;
      }
 
      if (level > 100) {
         std::string path = db_get_path(hDB, hKey);
 
         json_write(buffer, buffer_size, buffer_end, 0, "/error", 1);
         json_write(buffer, buffer_size, buffer_end, 0, " : ", 0);
         json_write(buffer, buffer_size, buffer_end, 0, "max nesting level exceed", 1);
 
         cm_msg(MERROR, "db_save_json_key", "max nesting level exceeded at \"%s\", check for symlink loops in this subtree", path.c_str());
 
      } else {
         HNDLE hSubkey;
 
         for (;; idx++) {
            db_enum_link(hDB, hKey, idx, &hSubkey);
 
            if (!hSubkey)
               break;
 
            if (idx != 0) {
               json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
            }
 
            /* save subtree */
            status = db_save_json_key_obsolete(hDB, hSubkey, level + 1, buffer, buffer_size, buffer_end, save_keys, follow_links, recurse);
            if (status != DB_SUCCESS)
               return status;
         }
      }
 
      if (do_close_curly_bracket) {
         if (idx > 0)
            json_write(buffer, buffer_size, buffer_end, 0, "\n", 0);
         json_write(buffer, buffer_size, buffer_end, level, "}", 0);
      }
 
   } else {
 
      if (save_keys && level == 0) {
         json_write(buffer, buffer_size, buffer_end, 0, "{\n", 0);
      }
 
      /* save key value */
 
      if (save_keys == 1) {
         char str[NAME_LENGTH+15];
         sprintf(str, "%s/key", link_key.name);
 
         json_write(buffer, buffer_size, buffer_end, level, str, 1);
         json_write(buffer, buffer_size, buffer_end, 0, " : { ", 0);
 
         sprintf(str, "\"type\" : %d", key.type);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
         if (link_key.type == TID_LINK && follow_links) {
            json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
            json_write(buffer, buffer_size, buffer_end, 0, "link", 1);
            json_write(buffer, buffer_size, buffer_end, 0, ": ", 0);
            json_write(buffer, buffer_size, buffer_end, 0, link_path, 1);
         }
 
         if (key.num_values > 1) {
            json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
            sprintf(str, "\"num_values\" : %d", key.num_values);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
         }
 
         if (key.type == TID_STRING || key.type == TID_LINK) {
            json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
            sprintf(str, "\"item_size\" : %d", key.item_size);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
         }
 
         if (key.notify_count > 0) {
            json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
            sprintf(str, "\"notify_count\" : %d", key.notify_count);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
         }
 
         json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
         sprintf(str, "\"access_mode\" : %d", key.access_mode);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
         json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
         sprintf(str, "\"last_written\" : %d", key.last_written);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
         json_write(buffer, buffer_size, buffer_end, 0, " ", 0);
 
         json_write(buffer, buffer_size, buffer_end, 0, "}", 0);
 
         json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
      }
 
      if (save_keys == 2) {
         char str[NAME_LENGTH+15];
         sprintf(str, "%s/last_written", link_key.name);
 
         json_write(buffer, buffer_size, buffer_end, level, str, 1);
 
         sprintf(str, " : %d", key.last_written);
         json_write(buffer, buffer_size, buffer_end, 0, str, 0);
 
         json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
      }
 
      if (save_keys) {
         json_write(buffer, buffer_size, buffer_end, level, link_key.name, 1);
         json_write(buffer, buffer_size, buffer_end, 0, " : ", 0);
      }
 
      if (key.num_values > 1) {
         json_write(buffer, buffer_size, buffer_end, 0, "[ ", 0);
      }
 
      size = key.total_size;
      data = (char *) malloc(size);
      if (data == NULL) {
         cm_msg(MERROR, "db_save_json_key", "cannot allocate data buffer for %d bytes", size);
         return DB_NO_MEMORY;
      }
 
      if (key.type != TID_KEY) {
         if (follow_links)
            status = db_get_data(hDB, hKey, data, &size, key.type);
         else
            status = db_get_link_data(hDB, hKey, data, &size, key.type);
 
         if (status != DB_SUCCESS)
            return status;
      }
 
      for (i = 0; i < key.num_values; i++) {
         char str[256];
         char *p = data + key.item_size*i;
 
         if (i != 0)
            json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
 
         switch (key.type) {
         case TID_UINT8:
            sprintf(str, "%u", *(unsigned char*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_INT8:
            sprintf(str, "%d", *(char*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_CHAR:
            sprintf(str, "%c", *(char*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 1);
            break;
         case TID_UINT16:
            sprintf(str, "\"0x%04x\"", *(WORD*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_INT16:
            sprintf(str, "%d", *(short*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_UINT32:
            sprintf(str, "\"0x%08x\"", *(DWORD*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_INT32:
            sprintf(str, "%d", *(int*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_UINT64:
            sprintf(str, "\"0x%08llx\"", *(UINT64*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_INT64:
            sprintf(str, "%lld", *(INT64*)p);
            json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            break;
         case TID_BOOL:
            if (*(int*)p)
               json_write(buffer, buffer_size, buffer_end, 0, "true", 0);
            else
               json_write(buffer, buffer_size, buffer_end, 0, "false", 0);
            break;
         case TID_FLOAT: {
            float flt = (*(float*)p);
            if (isnan(flt))
               json_write(buffer, buffer_size, buffer_end, 0, "\"NaN\"", 0);
            else if (isinf(flt)) {
               if (flt > 0)
                  json_write(buffer, buffer_size, buffer_end, 0, "\"Infinity\"", 0);
               else
                  json_write(buffer, buffer_size, buffer_end, 0, "\"-Infinity\"", 0);
            } else if (flt == 0)
               json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
            else if (flt == (int)flt) {
               sprintf(str, "%.0f", flt);
               json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            } else {
               sprintf(str, "%.7e", flt);
               json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            }
            break;
         }
         case TID_DOUBLE: {
            double dbl = (*(double*)p);
            if (isnan(dbl))
               json_write(buffer, buffer_size, buffer_end, 0, "\"NaN\"", 0);
            else if (isinf(dbl)) {
               if (dbl > 0)
                  json_write(buffer, buffer_size, buffer_end, 0, "\"Infinity\"", 0);
               else
                  json_write(buffer, buffer_size, buffer_end, 0, "\"-Infinity\"", 0);
            } else if (dbl == 0)
               json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
            else if (dbl == (int)dbl) {
               sprintf(str, "%.0f", dbl);
               json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            } else {
               sprintf(str, "%.16e", dbl);
               json_write(buffer, buffer_size, buffer_end, 0, str, 0);
            }
            break;
         }
         case TID_BITFIELD:
            json_write(buffer, buffer_size, buffer_end, 0, "(TID_BITFIELD value)", 1);
            break;
         case TID_STRING:
            p[key.item_size-1] = 0;  // make sure string is NUL terminated!
            json_write(buffer, buffer_size, buffer_end, 0, p, 1);
            break;
         case TID_ARRAY:
            json_write(buffer, buffer_size, buffer_end, 0, "(TID_ARRAY value)", 1);
            break;
         case TID_STRUCT:
            json_write(buffer, buffer_size, buffer_end, 0, "(TID_STRUCT value)", 1);
            break;
         case TID_KEY:
            json_write(buffer, buffer_size, buffer_end, 0, "{ }", 0);
            break;
         case TID_LINK:
            p[key.item_size-1] = 0;  // make sure string is NUL terminated!
            json_write(buffer, buffer_size, buffer_end, 0, p, 1);
            break;
         default:
            json_write(buffer, buffer_size, buffer_end, 0, "(TID_UNKNOWN value)", 1);
         }
 
      }
 
      if (key.num_values > 1) {
         json_write(buffer, buffer_size, buffer_end, 0, " ]", 0);
      } else {
         json_write(buffer, buffer_size, buffer_end, 0, "", 0);
      }
 
      free(data);
      data = NULL;
 
      if (save_keys && level == 0) {
         json_write(buffer, buffer_size, buffer_end, 0, "\n}", 0);
      }
   }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_copy_json_array(HNDLE hDB, HNDLE hKey, char **buffer, int* buffer_size, int* buffer_end)
{
   int size, asize;
   int status;
   char* data;
   int i;
   KEY key;
 
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   assert(key.type != TID_KEY);
 
   if (key.num_values == 0) { // empty ODB entry cannot be handled by normal json_write_data()
 
      switch (key.type) {
      case TID_UINT8:
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      case TID_INT8:
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      case TID_CHAR:
         json_write(buffer, buffer_size, buffer_end, 0, " ", 1);
         break;
      case TID_UINT16:
         json_write(buffer, buffer_size, buffer_end, 0, "0x0000", 1);
         break;
      case TID_INT16:
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      case TID_UINT32:
         json_write(buffer, buffer_size, buffer_end, 0, "0x00000000", 1);
         break;
      case TID_INT32:
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      case TID_UINT64:
         json_write(buffer, buffer_size, buffer_end, 0, "0x0000000000000000", 1);
         break;
      case TID_INT64:
         json_write(buffer, buffer_size, buffer_end, 0, "0", 1);
         break;
      case TID_BOOL:
         json_write(buffer, buffer_size, buffer_end, 0, "false", 0);
         break;
      case TID_FLOAT: {
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      }
      case TID_DOUBLE: {
         json_write(buffer, buffer_size, buffer_end, 0, "0", 0);
         break;
      }
      case TID_BITFIELD:
         json_write(buffer, buffer_size, buffer_end, 0, "(TID_BITFIELD value)", 1);
         break;
      case TID_STRING:
         json_write(buffer, buffer_size, buffer_end, 0, "", 1);
         break;
      case TID_ARRAY:
         json_write(buffer, buffer_size, buffer_end, 0, "(TID_ARRAY value)", 1);
         break;
      case TID_STRUCT:
         json_write(buffer, buffer_size, buffer_end, 0, "(TID_STRUCT value)", 1);
         break;
      case TID_KEY:
         json_write(buffer, buffer_size, buffer_end, 0, "{ }", 0);
         break;
      case TID_LINK:
         json_write(buffer, buffer_size, buffer_end, 0, "", 1);
         break;
      default:
         json_write(buffer, buffer_size, buffer_end, 0, "(TID_UNKNOWN value)", 1);
      }
 
      return DB_SUCCESS;
   }
 
   if (key.num_values > 1) {
      json_write(buffer, buffer_size, buffer_end, 0, "[ ", 0);
   }
 
   size = key.total_size;
 
   asize = size;
   if (asize < 1024)
      asize = 1024;
   
   data = (char *) malloc(asize);
   if (data == NULL) {
      cm_msg(MERROR, "db_save_json_key_data", "cannot allocate data buffer for %d bytes", asize);
      return DB_NO_MEMORY;
   }
 
   data[0] = 0; // protect against TID_STRING that has key.total_size == 0.
 
   status = db_get_data(hDB, hKey, data, &size, key.type);
   if (status != DB_SUCCESS) {
      free(data);
      return status;
   }
 
   for (i = 0; i < key.num_values; i++) {
      char *p = data + key.item_size*i;
 
      if (i != 0)
         json_write(buffer, buffer_size, buffer_end, 0, ", ", 0);
      
      json_write_data(buffer, buffer_size, buffer_end, 0, &key, p);
   }
   
   if (key.num_values > 1) {
      json_write(buffer, buffer_size, buffer_end, 0, " ]", 0);
   }
   
   free(data);
   data = NULL;
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_copy_json_index(HNDLE hDB, HNDLE hKey, int index, char **buffer, int* buffer_size, int* buffer_end)
{
   int status;
   KEY key;
 
   status = db_get_key(hDB, hKey, &key);
 
   if (status != DB_SUCCESS)
      return status;
 
   int size = key.item_size;
   char* data = (char*)malloc(size + 1); // extra byte for string NUL termination
   assert(data != NULL);
 
   status = db_get_data_index(hDB, hKey, data, &size, index, key.type);
 
   if (status != DB_SUCCESS) {
      free(data);
      return status;
   }
 
   assert(size <= key.item_size);
   data[key.item_size] = 0; // make sure data is NUL terminated, in case of strings.
 
   json_write_data(buffer, buffer_size, buffer_end, 0, &key, data);
 
   free(data);
 
   return DB_SUCCESS;
}
 
static int json_write_bare_key(HNDLE hDB, HNDLE hLink, const KEY& link, char **buffer, int *buffer_size, int *buffer_end, int level, int flags, time_t timestamp, bool need_comma)
{
   int status;
   char link_buf[MAX_ODB_PATH]; // link_path points to link_buf
   char* link_path = NULL;
 
   HNDLE hLinkTarget = hLink;
 
   if (link.type == TID_LINK) {
      int size = sizeof(link_buf);
      status = db_get_link_data(hDB, hLink, link_buf, &size, TID_LINK);
      if (status != DB_SUCCESS)
         return status;
      
      //printf("link size %d, len %d, data [%s]\n", size, (int)strlen(link_buf), link_buf);
      
      if ((size > 0) && (strlen(link_buf) > 0)) {
         link_path = link_buf;
         
         // resolve the link, unless it is a link to an array element
         if ((flags & JSFLAG_FOLLOW_LINKS) && strchr(link_path, '[') == NULL) {
            status = db_find_key(hDB, 0, link_path, &hLinkTarget);
            if (status != DB_SUCCESS) {
               // dangling link to nowhere
                  hLinkTarget = hLink;
            }
         }
      }
   }
   
   KEY link_target;
   status = db_get_key(hDB, hLinkTarget, &link_target);
   if (status != DB_SUCCESS)
      return status;
   
   if (flags & JSFLAG_OMIT_OLD) {
      if (link_target.last_written) {
         if (link_target.last_written < timestamp) {
            // omit old data
            return DB_SUCCESS;
         }
      }
   }
   
   if (need_comma) {
      json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
   } else {
      json_write(buffer, buffer_size, buffer_end, 0, "\n", 0);
   }
   
   char link_name[MAX_ODB_PATH];
 
   mstrlcpy(link_name, link.name, sizeof(link_name));
   
   if (flags & JSFLAG_LOWERCASE) {
      for (int i=0; (i<(int)sizeof(link.name)) && link.name[i]; i++)
         link_name[i] = tolower(link.name[i]);
   }
   
   if ((flags & JSFLAG_LOWERCASE) && !(flags & JSFLAG_OMIT_NAMES)) {
      char buf[MAX_ODB_PATH];
      mstrlcpy(buf, link_name, sizeof(buf));
      mstrlcat(buf, "/name", sizeof(buf));
      json_write(buffer, buffer_size, buffer_end, level, buf, 1);
      json_write(buffer, buffer_size, buffer_end, 0, " : " , 0);
      json_write(buffer, buffer_size, buffer_end, 0, link.name, 1);
      json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
   }
   
   if (link.type != TID_KEY && (flags & JSFLAG_SAVE_KEYS)) {
      char buf[MAX_ODB_PATH];
      mstrlcpy(buf, link_name, sizeof(buf));
      mstrlcat(buf, "/key", sizeof(buf));
      json_write(buffer, buffer_size, buffer_end, level, buf, 1);
      json_write(buffer, buffer_size, buffer_end, 0, " : " , 0);
      json_write_key(hDB, hLink, &link_target, link_path, buffer, buffer_size, buffer_end);
      json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
   } else if ((link_target.type != TID_KEY) && !(flags & JSFLAG_OMIT_LAST_WRITTEN)) {
      char buf[MAX_ODB_PATH];
      mstrlcpy(buf, link_name, sizeof(buf));
      mstrlcat(buf, "/last_written", sizeof(buf));
      json_write(buffer, buffer_size, buffer_end, level, buf, 1);
      json_write(buffer, buffer_size, buffer_end, 0, " : " , 0);
      sprintf(buf, "%d", link_target.last_written);
      json_write(buffer, buffer_size, buffer_end, 0, buf, 0);
      json_write(buffer, buffer_size, buffer_end, 0, ",\n", 0);
   }
   
   json_write(buffer, buffer_size, buffer_end, level, link_name, 1);
   json_write(buffer, buffer_size, buffer_end, 0, " : " , 0);
   
   if (link_target.type == TID_KEY && !(flags & JSFLAG_RECURSE)) {
      json_write(buffer, buffer_size, buffer_end, 0, "{ }" , 0);
   } else {
      status = json_write_anything(hDB, hLinkTarget, buffer, buffer_size, buffer_end, level, 0, flags, timestamp);
      if (status != DB_SUCCESS)
         return status;
   }
 
   return DB_SUCCESS;
}
   
int json_write_bare_subdir(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end, int level, int flags, time_t timestamp)
{
   if (level > MAX_ODB_PATH) {
      cm_msg(MERROR, "json_write_bare_subdir", "Max ODB subdirectory nesting level exceeded %d at \"%s\"", level, db_get_path(hDB, hKey).c_str());
      return DB_TRUNCATED;
   }
 
   for (int i=0; ; i++) {
      int status;
 
      HNDLE hLink;
      status = db_enum_link(hDB, hKey, i, &hLink);
      if (status != DB_SUCCESS && !hLink)
         break;
 
      KEY link;
      status = db_get_link(hDB, hLink, &link);
      if (status != DB_SUCCESS)
         return status;
 
      bool need_comma = (i!=0);
 
      status = json_write_bare_key(hDB, hLink, link, buffer, buffer_size, buffer_end, level, flags, timestamp, need_comma);
      if (status != DB_SUCCESS)
         return status;
   }
 
   return DB_SUCCESS;
}
 
int EXPRT json_write_anything(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end, int level, int must_be_subdir, int flags, time_t timestamp)
{
   int status;
   KEY key;
 
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   if (key.type == TID_KEY) {
 
      json_write(buffer, buffer_size, buffer_end, 0, "{", 0);
 
      status = json_write_bare_subdir(hDB, hKey, buffer, buffer_size, buffer_end, level+1, flags, timestamp);
      if (status != DB_SUCCESS)
         return status;
 
      json_write(buffer, buffer_size, buffer_end, 0, "\n", 0);
      json_write(buffer, buffer_size, buffer_end, level, "}", 0);
 
   } else if (must_be_subdir) {
      json_write(buffer, buffer_size, buffer_end, 0, "{", 0);
      status = json_write_bare_key(hDB, hKey, key, buffer, buffer_size, buffer_end, level+1, flags, timestamp, false);
      if (status != DB_SUCCESS)
         return status;
      json_write(buffer, buffer_size, buffer_end, 0, "\n", 0);
      json_write(buffer, buffer_size, buffer_end, level, "}", 0);
   } else {
      status = db_copy_json_array(hDB, hKey, buffer, buffer_size, buffer_end);
 
      if (status != DB_SUCCESS)
         return status;
   }
 
   return DB_SUCCESS;
}
 
INT db_copy_json_ls(HNDLE hDB, HNDLE hKey, char **buffer, int* buffer_size, int* buffer_end)
{
   int status;
   bool unlock = false;
 
   if (!rpc_is_remote()) {
      status = db_lock_database(hDB);
      if (status != DB_SUCCESS) {
         return status;
      }
      unlock = true;
   }
 
   status = json_write_anything(hDB, hKey, buffer, buffer_size, buffer_end, JS_LEVEL_0, JS_MUST_BE_SUBDIR, JSFLAG_SAVE_KEYS|JSFLAG_FOLLOW_LINKS, 0);
 
   if (unlock) {
      db_unlock_database(hDB);
   }
 
   return status;
}
 
INT db_copy_json_values(HNDLE hDB, HNDLE hKey, char **buffer, int* buffer_size, int* buffer_end, int omit_names, int omit_last_written, time_t omit_old_timestamp, int preserve_case)
{
   int status;
   int flags = JSFLAG_FOLLOW_LINKS|JSFLAG_RECURSE;
   if (omit_names)
      flags |= JSFLAG_OMIT_NAMES;
   if (omit_last_written)
      flags |= JSFLAG_OMIT_LAST_WRITTEN;
   if (omit_old_timestamp)
      flags |= JSFLAG_OMIT_OLD;
   if (!preserve_case)
      flags |= JSFLAG_LOWERCASE;
 
   bool unlock = false;
 
   if (!rpc_is_remote()) {
      status = db_lock_database(hDB);
      if (status != DB_SUCCESS) {
         return status;
      }
      unlock = true;
   }
 
   status = json_write_anything(hDB, hKey, buffer, buffer_size, buffer_end, JS_LEVEL_0, 0, flags, omit_old_timestamp);
 
   if (unlock) {
      db_unlock_database(hDB);
   }
   
   return status;
}
 
INT db_copy_json_save(HNDLE hDB, HNDLE hKey, char **buffer, int* buffer_size, int* buffer_end)
{
   int status;
   bool unlock = false;
 
   if (!rpc_is_remote()) {
      status = db_lock_database(hDB);
      if (status != DB_SUCCESS) {
         return status;
      }
      unlock = true;
   }
 
   status = json_write_anything(hDB, hKey, buffer, buffer_size, buffer_end, JS_LEVEL_0, JS_MUST_BE_SUBDIR, JSFLAG_SAVE_KEYS|JSFLAG_RECURSE, 0);
 
   if (unlock) {
      db_unlock_database(hDB);
   }
   
   return status;
}
 
/********************************************************************/
INT db_copy_json_obsolete(HNDLE hDB, HNDLE hKey, char **buffer, int* buffer_size, int* buffer_end, int save_keys, int follow_links, int recurse)
{
   db_save_json_key_obsolete(hDB, hKey, 0, buffer, buffer_size, buffer_end, save_keys, follow_links, recurse);
   json_write(buffer, buffer_size, buffer_end, 0, "\n", 0);
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_save_json(HNDLE hDB, HNDLE hKey, const char *filename, int flags)
{
   INT status;
   
   /* open file */
   FILE *fp = fopen(filename, "w");
   if (fp == NULL) {
      cm_msg(MERROR, "db_save_json", "Cannot open file \"%s\", fopen() errno %d (%s)", filename, errno, strerror(errno));
      return DB_FILE_ERROR;
   }
   
   bool unlock = false;
   
   if (!rpc_is_remote()) {
      status = db_lock_database(hDB);
      if (status != DB_SUCCESS) {
         fclose(fp);
         return status;
      }
      unlock = true;
   }
   
   std::string path = db_get_path(hDB, hKey);
 
   bool emptySubdir = false;
   HNDLE hSubKey;
   status = db_enum_link(hDB, hKey, 0, &hSubKey);
   if (status == DB_NO_MORE_SUBKEYS)
      emptySubdir = true;
 
   char* buffer = NULL;
   int buffer_size = 0;
   int buffer_end = 0;
   
   json_write(&buffer, &buffer_size, &buffer_end, 0, "{\n", 0);
   
   json_write(&buffer, &buffer_size, &buffer_end, 1, "/MIDAS version", 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, " : ", 0);
   json_write(&buffer, &buffer_size, &buffer_end, 0, MIDAS_VERSION, 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, ",\n", 0);
   
   json_write(&buffer, &buffer_size, &buffer_end, 1, "/MIDAS git revision", 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, " : ", 0);
   json_write(&buffer, &buffer_size, &buffer_end, 0, GIT_REVISION, 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, ",\n", 0);
   
   json_write(&buffer, &buffer_size, &buffer_end, 1, "/filename", 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, " : ", 0);
   json_write(&buffer, &buffer_size, &buffer_end, 0, filename, 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, ",\n", 0);
   
   json_write(&buffer, &buffer_size, &buffer_end, 1, "/ODB path", 1);
   json_write(&buffer, &buffer_size, &buffer_end, 0, " : ", 0);
   json_write(&buffer, &buffer_size, &buffer_end, 0, path.c_str(), 1);
 
   if (emptySubdir)
      json_write(&buffer, &buffer_size, &buffer_end, 0, "", 0);
   else
      json_write(&buffer, &buffer_size, &buffer_end, 0, ",\n", 0);
 
   //status = db_save_json_key_obsolete(hDB, hKey, -1, &buffer, &buffer_size, &buffer_end, 1, 0, 1);
   status = json_write_bare_subdir(hDB, hKey, &buffer, &buffer_size, &buffer_end, JS_LEVEL_1, flags, 0);
   
   json_write(&buffer, &buffer_size, &buffer_end, 0, "\n}\n", 0);
 
   if (unlock) {
      db_unlock_database(hDB);
   }
   
   if (status == DB_SUCCESS) {
      if (buffer) {
         size_t wr = fwrite(buffer, 1, buffer_end, fp);
         if (wr != (size_t)buffer_end) {
            cm_msg(MERROR, "db_save_json", "Cannot write to file \"%s\", fwrite() errno %d (%s)", filename, errno, strerror(errno));
            free(buffer);
            fclose(fp);
            return DB_FILE_ERROR;
         }
      }
   }
   
   if (buffer)
      free(buffer);
   
   fclose(fp);
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_save_struct(HNDLE hDB, HNDLE hKey, const char *file_name, const char *struct_name, BOOL append)
{
   KEY key;
   char str[100], line[10+100];
   INT status, i, fh;
   int wr, size;
 
   /* open file */
   fh = open(file_name, O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC), 0644);
 
   if (fh == -1) {
      cm_msg(MERROR, "db_save_struct", "Cannot open file\"%s\"", file_name);
      return DB_FILE_ERROR;
   }
 
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "db_save_struct", "cannot find key");
      return DB_INVALID_HANDLE;
   }
 
   sprintf(line, "typedef struct {\n");
 
   size = strlen(line);
   wr = write(fh, line, size);
   if (wr != size) {
      cm_msg(MERROR, "db_save_struct", "file \"%s\" write error: write(%d) returned %d, errno %d (%s)", file_name, size, wr, errno, strerror(errno));
      close(fh);
      return DB_FILE_ERROR;
   }
 
   db_save_tree_struct(hDB, hKey, fh, 0);
 
   if (struct_name && struct_name[0])
      mstrlcpy(str, struct_name, sizeof(str));
   else
      mstrlcpy(str, key.name, sizeof(str));
 
   name2c(str);
   for (i = 0; i < (int) strlen(str); i++)
      str[i] = (char) toupper(str[i]);
 
   sprintf(line, "} %s;\n\n", str);
 
   size = strlen(line);
   wr = write(fh, line, size);
   if (wr != size) {
      cm_msg(MERROR, "db_save_struct", "file \"%s\" write error: write(%d) returned %d, errno %d (%s)", file_name, size, wr, errno, strerror(errno));
      close(fh);
      return DB_FILE_ERROR;
   }
 
   close(fh);
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_save_string(HNDLE hDB, HNDLE hKey, const char *file_name, const char *string_name, BOOL append)
/********************************************************************\
 
  Routine: db_save_string
 
  Purpose: Save a branch of a database as a string which can be used
           by db_create_record.
 
  Input:
    HNDLE hDB               Handle to the database
    HNDLE hKey              Handle of key to start, 0 for root
    int   fh                File handle to write to
    char  string_name       Name of string. If struct_name == NULL,
                            the name of the key is used.
 
  Output:
    none
 
  Function value:
    DB_SUCCESS              Successful completion
    DB_INVALID_HANDLE       Database handle is invalid
 
\********************************************************************/
{
   KEY key;
   char str[256], line[50+256];
   INT status, i, size, fh, buffer_size;
   char *buffer = NULL, *pc;
   int wr;
 
 
   /* open file */
   fh = open(file_name, O_WRONLY | O_CREAT | (append ? O_APPEND : O_TRUNC), 0644);
 
   if (fh == -1) {
      cm_msg(MERROR, "db_save_string", "Cannot open file\"%s\"", file_name);
      return DB_FILE_ERROR;
   }
 
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "db_save_string", "cannot find key");
      return DB_INVALID_HANDLE;
   }
 
   if (string_name && string_name[0])
      strcpy(str, string_name);
   else
      strcpy(str, key.name);
 
   name2c(str);
   for (i = 0; i < (int) strlen(str); i++)
      str[i] = (char) toupper(str[i]);
 
   sprintf(line, "#define %s(_name) const char *_name[] = {\\\n", str);
   size = strlen(line);
   wr = write(fh, line, size);
   if (wr != size) {
      cm_msg(MERROR, "db_save", "file \"%s\" write error: write(%d) returned %d, errno %d (%s)", file_name, size, wr, errno, strerror(errno));
      close(fh);
      if (buffer)
         free(buffer);
      return DB_FILE_ERROR;
   }
 
   buffer_size = 10000;
   do {
      buffer = (char *) malloc(buffer_size);
      if (buffer == NULL) {
         cm_msg(MERROR, "db_save", "cannot allocate ODB dump buffer");
         break;
      }
 
      size = buffer_size;
      status = db_copy(hDB, hKey, buffer, &size, "");
      if (status != DB_TRUNCATED)
         break;
 
      /* increase buffer size if truncated */
      free(buffer);
      buffer = NULL;
      buffer_size *= 2;
   } while (1);
 
 
   pc = buffer;
 
   do {
      i = 0;
      line[i++] = '"';
      while (*pc != '\n' && *pc != 0) {
         if (*pc == '\"' || *pc == '\'')
            line[i++] = '\\';
         line[i++] = *pc++;
      }
      strcpy(&line[i], "\",\\\n");
      if (i > 0) {
         size = strlen(line);
         wr = write(fh, line, size);
         if (wr != size) {
            cm_msg(MERROR, "db_save", "file \"%s\" write error: write(%d) returned %d, errno %d (%s)", file_name, size, wr, errno, strerror(errno));
            close(fh);
            if (buffer)
               free(buffer);
            return DB_FILE_ERROR;
         }
      }
 
      if (*pc == '\n')
         pc++;
 
   } while (*pc);
 
   sprintf(line, "NULL }\n\n");
   size = strlen(line);
   wr = write(fh, line, size);
   if (wr != size) {
      cm_msg(MERROR, "db_save", "file \"%s\" write error: write(%d) returned %d, errno %d (%s)", file_name, size, wr, errno, strerror(errno));
      close(fh);
      if (buffer)
         free(buffer);
      return DB_FILE_ERROR;
   }
 
   close(fh);
   free(buffer);
 
   return DB_SUCCESS;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
{
   if (data_size == 0)
      sprintf(string, "<NULL>");
   else
      switch (type) {
      case TID_UINT8:
         sprintf(string, "%d", *(((BYTE *) data) + idx));
         break;
      case TID_INT8:
         sprintf(string, "%d", *(((char *) data) + idx));
         break;
      case TID_CHAR:
         sprintf(string, "%c", *(((char *) data) + idx));
         break;
      case TID_UINT16:
         sprintf(string, "%u", *(((WORD *) data) + idx));
         break;
      case TID_INT16:
         sprintf(string, "%d", *(((short *) data) + idx));
         break;
      case TID_UINT32:
         sprintf(string, "%u", *(((DWORD *) data) + idx));
         break;
      case TID_INT32:
         sprintf(string, "%d", *(((INT *) data) + idx));
         break;
      case TID_UINT64:
         sprintf(string, "%llu", *(((UINT64 *) data) + idx));
         break;
      case TID_INT64:
         sprintf(string, "%lld", *(((INT64 *) data) + idx));
         break;
      case TID_BOOL:
         sprintf(string, "%c", *(((BOOL *) data) + idx) ? 'y' : 'n');
         break;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, "%.7g", *(((float *) data) + idx));
         break;
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, "%.16lg", *(((double *) data) + idx));
         break;
      case TID_BITFIELD:
         sprintf(string, "%u", *(((DWORD *) data) + idx));
         break;
      case TID_STRING:
      case TID_LINK:
         mstrlcpy(string, ((char *) data) + data_size * idx, MAX_STRING_LENGTH);
         break;
      default:
         sprintf(string, "<unknown>");
         break;
      }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_sprintff(char *string, const char *format, const void *data, INT data_size, INT idx, DWORD type)
{
   if (data_size == 0)
      sprintf(string, "<NULL>");
   else
      switch (type) {
      case TID_UINT8:
         sprintf(string, format, *(((BYTE *) data) + idx));
         break;
      case TID_INT8:
         sprintf(string, format, *(((char *) data) + idx));
         break;
      case TID_CHAR:
         sprintf(string, format, *(((char *) data) + idx));
         break;
      case TID_UINT16:
         sprintf(string, format, *(((WORD *) data) + idx));
         break;
      case TID_INT16:
         sprintf(string, format, *(((short *) data) + idx));
         break;
      case TID_UINT32:
         sprintf(string, format, *(((DWORD *) data) + idx));
         break;
      case TID_INT32:
         sprintf(string, format, *(((INT *) data) + idx));
         break;
      case TID_UINT64:
         sprintf(string, format, *(((UINT64 *) data) + idx));
         break;
      case TID_INT64:
         sprintf(string, format, *(((INT64 *) data) + idx));
         break;
      case TID_BOOL:
         sprintf(string, format, *(((BOOL *) data) + idx) ? 'y' : 'n');
         break;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, format, *(((float *) data) + idx));
         break;
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, format, *(((double *) data) + idx));
         break;
      case TID_BITFIELD:
         sprintf(string, format, *(((DWORD *) data) + idx));
         break;
      case TID_STRING:
      case TID_LINK:
         mstrlcpy(string, ((char *) data) + data_size * idx, MAX_STRING_LENGTH);
         break;
      default:
         sprintf(string, "<unknown>");
         break;
      }
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
INT db_sprintfh(char *string, const void *data, INT data_size, INT idx, DWORD type)
/********************************************************************\
 
  Routine: db_sprintfh
 
  Purpose: Convert a database value to a string according to its type
           in hex format
 
  Input:
    void  *data             Value data
    INT   idx               Index for array data
    INT   data_size         Size of single data element
    DWORD type              Valye type, one of TID_xxx
 
  Output:
    char  *string           ASCII string of data
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   if (data_size == 0)
      sprintf(string, "<NULL>");
   else
      switch (type) {
      case TID_UINT8:
         sprintf(string, "0x%X", *(((BYTE *) data) + idx));
         break;
      case TID_INT8:
         sprintf(string, "0x%X", *(((char *) data) + idx));
         break;
      case TID_CHAR:
         sprintf(string, "%c", *(((char *) data) + idx));
         break;
      case TID_UINT16:
         sprintf(string, "0x%X", *(((WORD *) data) + idx));
         break;
      case TID_INT16:
         sprintf(string, "0x%hX", *(((short *) data) + idx));
         break;
      case TID_UINT32:
         sprintf(string, "0x%X", *(((DWORD *) data) + idx));
         break;
      case TID_INT32:
         sprintf(string, "0x%X", *(((INT *) data) + idx));
         break;
      case TID_UINT64:
         sprintf(string, "0x%llX", *(((UINT64 *) data) + idx));
         break;
      case TID_INT64:
         sprintf(string, "0x%llX", *(((INT64 *) data) + idx));
         break;
      case TID_BOOL:
         sprintf(string, "%c", *(((BOOL *) data) + idx) ? 'y' : 'n');
         break;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, "%.7g", *(((float *) data) + idx));
         break;
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx)))
            sprintf(string, "NAN");
         else
            sprintf(string, "%.16lg", *(((double *) data) + idx));
         break;
      case TID_BITFIELD:
         sprintf(string, "0x%X", *(((DWORD *) data) + idx));
         break;
      case TID_STRING:
      case TID_LINK:
         sprintf(string, "%s", ((char *) data) + data_size * idx);
         break;
      default:
         sprintf(string, "<unknown>");
         break;
      }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
std::string db_sprintf(const void *data, INT data_size, INT idx, DWORD type)
{
   if (data_size == 0) {
      return "<NULL>";
   } else {
      char buf[256];
      switch (type) {
      case TID_UINT8:
         sprintf(buf, "%d", *(((BYTE *) data) + idx));
         return buf;
      case TID_INT8:
         sprintf(buf, "%d", *(((char *) data) + idx));
         return buf;
      case TID_CHAR:
         sprintf(buf, "%c", *(((char *) data) + idx));
         return buf;
      case TID_UINT16:
         sprintf(buf, "%u", *(((WORD *) data) + idx));
         return buf;
      case TID_INT16:
         sprintf(buf, "%d", *(((short *) data) + idx));
         return buf;
      case TID_UINT32:
         sprintf(buf, "%u", *(((DWORD *) data) + idx));
         return buf;
      case TID_INT32:
         sprintf(buf, "%d", *(((INT *) data) + idx));
         return buf;
      case TID_UINT64:
         sprintf(buf, "%llu", *(((UINT64 *) data) + idx));
         return buf;
      case TID_INT64:
         sprintf(buf, "%lld", *(((INT64 *) data) + idx));
         return buf;
      case TID_BOOL:
         sprintf(buf, "%c", *(((BOOL *) data) + idx) ? 'y' : 'n');
         return buf;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, "%.7g", *(((float *) data) + idx));
            return buf;
         }
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, "%.16lg", *(((double *) data) + idx));
            return buf;
         }
      case TID_BITFIELD:
         sprintf(buf, "%u", *(((DWORD *) data) + idx));
         return buf;
      case TID_STRING:
      case TID_LINK:
         return (((char *) data) + data_size * idx);
      default:
         return "<unknown>";
      }
   }
}
 
/********************************************************************/
std::string db_sprintff(const char *format, const void *data, INT data_size, INT idx, DWORD type)
{
   if (data_size == 0) {
      return "<NULL>";
   } else {
      char buf[256];
      switch (type) {
      case TID_UINT8:
         sprintf(buf, format, *(((BYTE *) data) + idx));
         return buf;
      case TID_INT8:
         sprintf(buf, format, *(((char *) data) + idx));
         return buf;
      case TID_CHAR:
         sprintf(buf, format, *(((char *) data) + idx));
         return buf;
      case TID_UINT16:
         sprintf(buf, format, *(((WORD *) data) + idx));
         return buf;
      case TID_INT16:
         sprintf(buf, format, *(((short *) data) + idx));
         return buf;
      case TID_UINT32:
         sprintf(buf, format, *(((DWORD *) data) + idx));
         return buf;
      case TID_INT32:
         sprintf(buf, format, *(((INT *) data) + idx));
         return buf;
      case TID_UINT64:
         sprintf(buf, format, *(((UINT64 *) data) + idx));
         return buf;
      case TID_INT64:
         sprintf(buf, format, *(((INT64 *) data) + idx));
         return buf;
      case TID_BOOL:
         sprintf(buf, format, *(((BOOL *) data) + idx) ? 'y' : 'n');
         return buf;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, format, *(((float *) data) + idx));
            return buf;
         }
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, format, *(((double *) data) + idx));
            return buf;
         }
      case TID_BITFIELD:
         sprintf(buf, format, *(((DWORD *) data) + idx));
         return buf;
      case TID_STRING:
      case TID_LINK:
         return (((char *) data) + data_size * idx);
      default:
         return "<unknown>";
      }
   }
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
std::string db_sprintfh(const void *data, INT data_size, INT idx, DWORD type)
/********************************************************************\
 
  Routine: db_sprintfh
 
  Purpose: Convert a database value to a string according to its type
           in hex format
 
  Input:
    void  *data             Value data
    INT   idx               Index for array data
    INT   data_size         Size of single data element
    DWORD type              Valye type, one of TID_xxx
 
  Output:
    char  *string           ASCII string of data
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   if (data_size == 0) {
      return "<NULL>";
   } else {
      char buf[256];
      switch (type) {
      case TID_UINT8:
         sprintf(buf, "0x%X", *(((BYTE *) data) + idx));
         return buf;
      case TID_INT8:
         sprintf(buf, "0x%X", *(((char *) data) + idx));
         return buf;
      case TID_CHAR:
         sprintf(buf, "%c", *(((char *) data) + idx));
         return buf;
      case TID_UINT16:
         sprintf(buf, "0x%X", *(((WORD *) data) + idx));
         return buf;
      case TID_INT16:
         sprintf(buf, "0x%hX", *(((short *) data) + idx));
         return buf;
      case TID_UINT32:
         sprintf(buf, "0x%X", *(((DWORD *) data) + idx));
         return buf;
      case TID_INT32:
         sprintf(buf, "0x%X", *(((INT *) data) + idx));
         return buf;
      case TID_UINT64:
         sprintf(buf, "0x%llX", *(((UINT64 *) data) + idx));
         return buf;
      case TID_INT64:
         sprintf(buf, "0x%llX", *(((INT64 *) data) + idx));
         return buf;
      case TID_BOOL:
         sprintf(buf, "%c", *(((BOOL *) data) + idx) ? 'y' : 'n');
         return buf;
      case TID_FLOAT:
         if (ss_isnan(*(((float *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, "%.7g", *(((float *) data) + idx));
            return buf;
         }
      case TID_DOUBLE:
         if (ss_isnan(*(((double *) data) + idx))) {
            return "NAN";
         } else {
            sprintf(buf, "%.16lg", *(((double *) data) + idx));
            return buf;
         }
      case TID_BITFIELD:
         sprintf(buf, "0x%X", *(((DWORD *) data) + idx));
         return buf;
      case TID_STRING:
      case TID_LINK:
         return (((char *) data) + data_size * idx);
      default:
         return "<unknown>";
      }
   }
}
 
/*------------------------------------------------------------------*/
INT db_sscanf(const char *data_str, void *data, INT * data_size, INT i, DWORD tid)
/********************************************************************\
 
  Routine: db_sscanf
 
  Purpose: Convert a string to a database value according to its type
 
  Input:
    char  *data_str         ASCII string of data
    INT   i                 Index for array data
    DWORD tid               Value type, one of TID_xxx
 
  Output:
    void  *data             Value data
    INT   *data_size        Size of single data element
 
  Function value:
    DB_SUCCESS              Successful completion
 
\********************************************************************/
{
   DWORD value = 0;
   BOOL hex = FALSE;
 
   if (data_str == NULL)
      return 0;
 
   *data_size = rpc_tid_size(tid);
   if (strncmp(data_str, "0x", 2) == 0) {
      hex = TRUE;
      sscanf(data_str + 2, "%x", &value);
   }
 
   switch (tid) {
   case TID_UINT8:
   case TID_INT8:
      if (hex)
         *((char *) data + i) = (char) value;
      else
         *((char *) data + i) = (char) atoi(data_str);
      break;
   case TID_CHAR:
      *((char *) data + i) = data_str[0];
      break;
   case TID_UINT16:
      if (hex)
         *((WORD *) data + i) = (WORD) value;
      else
         *((WORD *) data + i) = (WORD) atoi(data_str);
      break;
   case TID_INT16:
      if (hex)
         *((short int *) data + i) = (short int) value;
      else
         *((short int *) data + i) = (short int) atoi(data_str);
      break;
   case TID_UINT32:
      if (hex)
         value = strtoul(data_str, nullptr, 16);
      else
         value = strtoul(data_str, nullptr, 10);
 
      *((DWORD *) data + i) = value;
      break;
   case TID_INT32:
      if (hex)
         value = strtol(data_str, nullptr, 16);
      else
         value = strtol(data_str, nullptr, 10);
 
      *((INT *) data + i) = value;
      break;
   case TID_UINT64:
      if (hex)
         *((UINT64 *) data + i) = strtoull(data_str, nullptr, 16);
      else
         *((UINT64 *) data + i) = strtoull(data_str, nullptr, 10);
      break;
   case TID_INT64:
      if (hex)
         *((UINT64 *) data + i) = strtoll(data_str, nullptr, 16);
      else
         *((UINT64 *) data + i) = strtoll(data_str, nullptr, 10);
      break;
   case TID_BOOL:
      if (data_str[0] == 'y' || data_str[0] == 'Y' ||
          data_str[0] == 't' || data_str[0] == 'T' || atoi(data_str) > 0)
         *((BOOL *) data + i) = 1;
      else
         *((BOOL *) data + i) = 0;
      break;
   case TID_FLOAT:
      if (data_str[0] == 'n' || data_str[0] == 'N')
         *((float *) data + i) = (float) ss_nan();
      else
         *((float *) data + i) = (float) atof(data_str);
      break;
   case TID_DOUBLE:
      if (data_str[0] == 'n' || data_str[0] == 'N')
         *((double *) data + i) = ss_nan();
      else
         *((double *) data + i) = atof(data_str);
      break;
   case TID_BITFIELD:
      if (hex)
         value = strtoul(data_str, nullptr, 16);
      else
         value = strtoul(data_str, nullptr, 10);
 
      *((DWORD *) data + i) = value;
      break;
   case TID_STRING:
   case TID_LINK:
      strcpy((char *) data, data_str);
      *data_size = strlen(data_str) + 1;
      break;
   }
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
#ifdef LOCAL_ROUTINES
 
static void db_recurse_record_tree_locked(const DATABASE* pdb, const KEY* pkey, void **data, INT * total_size, INT base_align, INT * max_align, BOOL bSet, INT convert_flags, db_err_msg** msg)
/********************************************************************\
 
  Routine: db_recurse_record_tree_locked
 
  Purpose: Recurse a database tree and calculate its size or copy
           data. Internal use only.
 
\********************************************************************/
{
   const KEY *pold;
   INT size, align, corr, total_size_tmp;
 
   const DATABASE_HEADER* pheader = pdb->database_header;
 
   const KEYLIST *pkeylist = (const KEYLIST *) ((const char *) pheader + pkey->data);
   if (!pkeylist->first_key)
      return;
 
   // FIXME: validate pkeylist->first_key
   // FIXME: confusing reuse of pkey
   pkey = (const KEY *) ((char *) pheader + pkeylist->first_key);
 
   /* first browse through this level */
   do {
      pold = NULL;
      
      if (pkey->type == TID_LINK) {
         const KEY *plink = db_resolve_link_locked(pheader, pkey, NULL, msg);
         
         if (!plink)
            return;
 
         if (plink->type == TID_KEY) {
            db_recurse_record_tree_locked(pdb, plink, data, total_size, base_align, NULL, bSet, convert_flags, msg);
         } else {
            pold = pkey;
            pkey = plink;
         }
      }
      
      if (pkey->type != TID_KEY) {
         /* correct for alignment */
         align = 1;
 
         if (rpc_tid_size(pkey->type))
            align = rpc_tid_size(pkey->type) < base_align ? rpc_tid_size(pkey->type) : base_align;
 
         if (max_align && align > *max_align)
            *max_align = align;
 
         corr = VALIGN(*total_size, align) - *total_size;
         *total_size += corr;
         if (data)
            *data = (void *) ((char *) (*data) + corr);
 
         /* calculate data size */
         size = pkey->item_size * pkey->num_values;
 
         if (data) {
            if (bSet) {
               KEY* wpkey = (KEY*)pkey;
               /* copy data if there is write access */
               if (pkey->access_mode & MODE_WRITE) {
                  memcpy((char *) pheader + pkey->data, *data, pkey->item_size * pkey->num_values);
 
                  /* convert data */
                  if (convert_flags) {
                     if (pkey->num_values > 1)
                        rpc_convert_data((char *) pheader + pkey->data,
                                         pkey->type, RPC_FIXARRAY, pkey->item_size * pkey->num_values, convert_flags);
                     else
                        rpc_convert_single((char *) pheader + pkey->data, pkey->type, 0, convert_flags);
                  }
 
                  /* update time */
                  wpkey->last_written = ss_time();
 
                  /* notify clients which have key open */
                  db_notify_clients_locked(pdb, db_pkey_to_hkey(pheader, pkey), -1, TRUE, msg);
               }
            } else {
               /* copy key data if there is read access */
               if (pkey->access_mode & MODE_READ) {
                  memcpy(*data, (char *) pheader + pkey->data, pkey->item_size * pkey->num_values);
 
                  /* convert data */
                  if (convert_flags) {
                     if (pkey->num_values > 1)
                        rpc_convert_data(*data, pkey->type,
                                         RPC_FIXARRAY | RPC_OUTGOING,
                                         pkey->item_size * pkey->num_values, convert_flags);
                     else
                        rpc_convert_single(*data, pkey->type, RPC_OUTGOING, convert_flags);
                  }
               }
            }
 
            *data = (char *) (*data) + size;
         }
 
         *total_size += size;
      } else {
         /* align new substructure according to the maximum
            align value in this structure */
         align = 1;
 
         total_size_tmp = *total_size;
         db_recurse_record_tree_locked(pdb, pkey, NULL, &total_size_tmp, base_align, &align, bSet, convert_flags, msg);
 
         if (max_align && align > *max_align)
            *max_align = align;
 
         corr = VALIGN(*total_size, align) - *total_size;
         *total_size += corr;
         if (data)
            *data = (void *) ((char *) (*data) + corr);
 
         /* now recurse subtree */
         db_recurse_record_tree_locked(pdb, pkey, data, total_size, base_align, NULL, bSet, convert_flags, msg);
 
         corr = VALIGN(*total_size, align) - *total_size;
         *total_size += corr;
         if (data)
            *data = (void *) ((char *) (*data) + corr);
      }
         
      if (pold) {
         pkey = pold;
         pold = NULL;
      }
 
      if (!pkey->next_key)
         break;
 
      // FIXME: validate pkey->next_key
      pkey = (KEY *) ((char *) pheader + pkey->next_key);
   } while (TRUE);
}
 
static void db_recurse_record_tree_locked(const DATABASE* pdb, HNDLE hKey, void **data, INT * total_size, INT base_align, INT * max_align, BOOL bSet, INT convert_flags, db_err_msg** msg)
/********************************************************************\
 
  Routine: db_recurse_record_tree_locked
 
  Purpose: Recurse a database tree and calculate its size or copy
           data. Internal use only.
 
\********************************************************************/
{
   /* get first subkey of hKey */
 
   const KEY* pkey = db_get_pkey(pdb->database_header, hKey, NULL, "db_recurse_record_tree", msg);
 
   if (!pkey) {
      return;
   }
 
   db_recurse_record_tree_locked(pdb, pkey, data, total_size, base_align, max_align, bSet, convert_flags, msg);
}   
 
#endif                          /* LOCAL_ROUTINES */
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_get_record_size(HNDLE hDB, HNDLE hKey, INT align, INT * buf_size)
{
   if (rpc_is_remote()) {
      align = ss_get_struct_align();
      return rpc_call(RPC_DB_GET_RECORD_SIZE, hDB, hKey, align, buf_size);
   }
#ifdef LOCAL_ROUTINES
   {
      KEY key;
      INT status, max_align;
 
      if (!align)
         align = ss_get_struct_align();
 
      /* check if key has subkeys */
      status = db_get_key(hDB, hKey, &key);
      if (status != DB_SUCCESS)
         return status;
 
      if (key.type != TID_KEY) {
         /* just a single key */
         *buf_size = key.item_size * key.num_values;
         return DB_SUCCESS;
      }
 
      db_err_msg* msg = NULL;
      db_lock_database(hDB);
 
      DATABASE *pdb = &_database[hDB - 1];
 
      /* determine record size */
      *buf_size = max_align = 0;
      db_recurse_record_tree_locked(pdb, hKey, NULL, buf_size, align, &max_align, 0, 0, &msg);
 
      //int tmp = *buf_size;
      /* correct for byte padding */
      *buf_size = VALIGN(*buf_size, max_align);
 
      //if (tmp != *buf_size) {
      //   cm_msg(MERROR, "db_get_record_size", "ODB record \"%s\" has unexpected padding from %d to %d bytes", db_get_path(hDB, hKey).c_str(), tmp, *buf_size);
      //}
 
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_record(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, INT align)
{
   if (rpc_is_remote()) {
      align = ss_get_struct_align();
      return rpc_call(RPC_DB_GET_RECORD, hDB, hKey, data, buf_size, align);
   }
#ifdef LOCAL_ROUTINES
   {
      KEY key;
      INT convert_flags, status;
      INT total_size;
      void *pdata;
 
      if (data && buf_size) {
         memset(data, 0x00, *buf_size);
      }
 
      convert_flags = 0;
 
      if (!align)
         align = ss_get_struct_align();
      else {
         /* only convert data if called remotely, as indicated by align != 0 */
         if (rpc_is_mserver()) {
            convert_flags = rpc_get_convert_flags();
         }
      }
 
      /* check if key has subkeys */
      status = db_get_key(hDB, hKey, &key);
      if (status != DB_SUCCESS)
         return status;
 
      if (key.type != TID_KEY) {
         /* copy single key */
         if (key.item_size * key.num_values != *buf_size) {
            cm_msg(MERROR, "db_get_record", "struct size mismatch for \"%s\" (expected size: %d, size in ODB: %d * %d = %d)",
                   db_get_path(hDB, hKey).c_str(), *buf_size, key.num_values, key.item_size, key.item_size * key.num_values);
            return DB_STRUCT_SIZE_MISMATCH;
         }
 
         db_get_data(hDB, hKey, data, buf_size, key.type);
 
         if (convert_flags) {
            if (key.num_values > 1)
               rpc_convert_data(data, key.type, RPC_OUTGOING | RPC_FIXARRAY, key.item_size * key.num_values, convert_flags);
            else
               rpc_convert_single(data, key.type, RPC_OUTGOING, convert_flags);
         }
 
         return DB_SUCCESS;
      }
 
      /* check record size */
      db_get_record_size(hDB, hKey, align, &total_size);
      if (total_size != *buf_size) {
         cm_msg(MERROR, "db_get_record", "struct size mismatch for \"%s\" (expected size: %d, size in ODB: %d)", db_get_path(hDB, hKey).c_str(), *buf_size, total_size);
         return DB_STRUCT_SIZE_MISMATCH;
      }
 
      /* get subkey data */
      pdata = data;
      total_size = 0;
 
      db_err_msg* msg = NULL;
      db_lock_database(hDB);
      DATABASE *pdb = &_database[hDB - 1];
      db_recurse_record_tree_locked(pdb, hKey, &pdata, &total_size, align, NULL, FALSE, convert_flags, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
 
      //if (total_size != *buf_size) {
      //   cm_msg(MERROR, "db_get_record", "struct size mismatch for \"%s\", expected size: %d, read from ODB: %d bytes", db_get_path(hDB, hKey).c_str(), *buf_size, total_size);
      //   //return DB_STRUCT_SIZE_MISMATCH;
      //}
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_record1(HNDLE hDB, HNDLE hKey, void *data, INT * buf_size, INT align, const char *rec_str)
{
   int size = *buf_size;
   int odb_size = 0;
   int status;
   //char path[MAX_ODB_PATH];
 
   /* check record size first */
 
   status = db_get_record_size(hDB, hKey, align, &odb_size);
   if (status != DB_SUCCESS)
      return status;
 
   /* if size mismatch, call repair function */
 
   if (odb_size != size) {
      std::string path = db_get_path(hDB, hKey);
      cm_msg(MINFO, "db_get_record1", "Fixing ODB \"%s\" struct size mismatch (expected %d, odb size %d)", path.c_str(), size, odb_size);
      status = db_create_record(hDB, hKey, "", rec_str);
      if (status != DB_SUCCESS)
         return status;
   }
 
   /* run db_get_record(), if success, we are done */
 
   status = db_get_record(hDB, hKey, data, buf_size, align);
   if (status == DB_SUCCESS)
      return status;
 
   /* try repair with db_check_record() */
 
   status = db_check_record(hDB, hKey, "", rec_str, TRUE);
   if (status != DB_SUCCESS)
      return status;
 
   /* verify struct size again, because there can still be a mismatch if there
    * are extra odb entries at the end of the record as db_check_record()
    * seems to ignore all odb entries past the end of "rec_str". K.O.
    */
 
   status = db_get_record_size(hDB, hKey, align, &odb_size);
   if (status != DB_SUCCESS)
      return status;
 
   std::string path = db_get_path(hDB, hKey);
 
   if (odb_size != size) {
      cm_msg(MERROR, "db_get_record1", "after db_check_record() still struct size mismatch (expected %d, odb size %d) of \"%s\", calling db_create_record()", size, odb_size, path.c_str());
      status = db_create_record(hDB, hKey, "", rec_str);
      if (status != DB_SUCCESS)
         return status;
   }
 
   cm_msg(MERROR, "db_get_record1", "repaired struct size mismatch of \"%s\"", path.c_str());
 
   *buf_size = size;
   status = db_get_record(hDB, hKey, data, buf_size, align);
 
   return status;
}
 
static int db_parse_record(const char* rec_str, const char** out_rec_str, char* title, int title_size, char* key_name, int key_name_size, int* tid, int* n_data, int* string_length)
{
   title[0] = 0;
   key_name[0] = 0;
   *tid = 0;
   *n_data = 0;
   *string_length = 0;
   *out_rec_str = NULL;
 
   //
   // expected format of rec_str:
   //
   // title: "[.]",
   // numeric value: "example_int = INT : 3",
   // string value: "example_string = STRING : [20] /Runinfo/Run number",
   // array: "aaa = INT[10] : ...",
   // string array: "sarr = STRING[10] : [32] ",
   //
 
   //printf("parse_rec_str: [%s]\n", rec_str);
 
   while (*rec_str == '\n')
      rec_str++;
   
   /* check if it is a section title */
   if (rec_str[0] == '[') {
      rec_str++;
 
      title[0] = 0;
      
      /* extract title and append '/' */
      mstrlcpy(title, rec_str, title_size);
      char* p = strchr(title, ']');
      if (p)
         *p = 0;
 
      int len = strlen(title);
      if (len > 0) {
         if (title[len - 1] != '/')
            mstrlcat(title, "/", title_size);
      }
 
      // skip to the next end-of-line
      const char* pend = strchr(rec_str, '\n');
      if (pend)
         rec_str = pend;
      else
         rec_str = rec_str+strlen(rec_str);
 
      while (*rec_str == '\n')
         rec_str++;
 
      *out_rec_str = rec_str;
      return DB_SUCCESS;
   }
 
   if (rec_str[0] == ';') {
      // skip to the next end-of-line
      const char* pend = strchr(rec_str, '\n');
      if (pend)
         rec_str = pend;
      else
         rec_str = rec_str+strlen(rec_str);
 
      while (*rec_str == '\n')
         rec_str++;
 
      *out_rec_str = rec_str;
      return DB_SUCCESS;
   }
 
   const char* peq = strchr(rec_str, '=');
   if (!peq) {
      cm_msg(MERROR, "db_parse_record", "do not see \'=\'");
      return DB_INVALID_PARAM;
   }
 
   int key_name_len = peq - rec_str;
 
   // remove trailing equals sign and trailing spaces
   while (key_name_len > 1) {
      if (rec_str[key_name_len-1] == '=') {
         key_name_len--;
         continue;
      }
      if (rec_str[key_name_len-1] == ' ') {
         key_name_len--;
         continue;
      }
      break;
   }
 
   memcpy(key_name, rec_str, key_name_len);
   key_name[key_name_len] = 0;
 
   rec_str = peq + 1; // consume the "=" sign
 
   while (*rec_str == ' ') // consume spaces
      rec_str++;
 
   // extract type id
   char stid[256];
   int i;
   for (i=0; i<(int)sizeof(stid)-1; i++) {
      char s = *rec_str;
      if (s == 0)    break;
      if (s == ' ')  break;
      if (s == '\n') break;
      if (s == '[')  break;
      stid[i] = s;
      rec_str++;
   }
   stid[i] = 0;
 
   DWORD xtid = 0;
   for (xtid = 0; xtid < TID_LAST; xtid++) {
      if (strcmp(rpc_tid_name(xtid), stid) == 0) {
         *tid = xtid;
         break;
      }
   }
 
   //printf("tid [%s], tid %d\n", stid, *tid);
 
   if (xtid == TID_LAST) {
      cm_msg(MERROR, "db_parse_record", "do not see \':\'");
      return DB_INVALID_PARAM;
   }
      
   while (*rec_str == ' ') // consume spaces
      rec_str++;
 
   *n_data = 1;
 
   if (*rec_str == '[') {
      // decode array size
      rec_str++; // cosume the '['
      *n_data = atoi(rec_str);
      const char *pbr = strchr(rec_str, ']');
      if (!pbr) {
         cm_msg(MERROR, "db_parse_record", "do not see closing bracket \']\'");
         return DB_INVALID_PARAM;
      }
      rec_str = pbr + 1; // skip the closing bracket
   }
   
   while (*rec_str == ' ') // consume spaces
      rec_str++;
 
   const char* pcol = strchr(rec_str, ':');
   if (!pcol) {
      cm_msg(MERROR, "db_parse_record", "do not see \':\'");
      return DB_INVALID_PARAM;
   }
 
   rec_str = pcol + 1; // skip the ":"
 
   while (*rec_str == ' ') // consume spaces
      rec_str++;
 
   *string_length = 0;
   if (xtid == TID_LINK || xtid == TID_STRING) {
      // extract string length
      const char* pbr = strchr(rec_str, '[');
      if (pbr) {
         *string_length = atoi(pbr+1);
      }
   }
 
   // skip to the next end-of-line
   const char* pend = strchr(rec_str, '\n');
   if (pend)
      rec_str = pend;
   else
      rec_str = rec_str+strlen(rec_str);
   
   while (*rec_str == '\n')
      rec_str++;
   
   *out_rec_str = rec_str;
   return DB_SUCCESS;
}
 
static int db_get_record2_read_element(HNDLE hDB, HNDLE hKey, const char* key_name, int tid, int n_data, int string_length, char* buf_start, char** buf_ptr, int* buf_remain, BOOL correct)
{
   assert(tid > 0);
   assert(n_data > 0);
   int tsize = rpc_tid_size(tid);
   int offset = *buf_ptr - buf_start;
   int align = 0;
   if (tsize && (offset%tsize != 0)) {
      while (offset%tsize != 0) {
         align++;
         *(*buf_ptr) = 0xFF; // pad bytes for correct data alignement
         (*buf_ptr)++;
         (*buf_remain)--;
         offset++;
      }
   }
   printf("read element [%s] tid %d, n_data %d, string_length %d, tid_size %d, align %d, offset %d, buf_remain %d\n", key_name, tid, n_data, string_length, tsize, align, offset, *buf_remain);
   if (tsize > 0) {
      int xsize = tsize*n_data;
      if (xsize > *buf_remain) {
         cm_msg(MERROR, "db_get_record2", "buffer overrun at key \"%s\", size %d, buffer remaining %d", key_name, xsize, *buf_remain);
         return DB_INVALID_PARAM;
      }
      int ysize = xsize;
      int status = db_get_value(hDB, hKey, key_name, *buf_ptr, &ysize, tid, FALSE);
      //printf("status %d, xsize %d\n", status, xsize);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "db_get_record2", "cannot read \"%s\", db_get_value() status %d", key_name, status);
         memset(*buf_ptr, 0, xsize);
         *buf_ptr += xsize;
         *buf_remain -= xsize;
         return status;
      }
      *buf_ptr += xsize;
      *buf_remain -= xsize;
   } else if (tid == TID_STRING) {
      int xstatus = 0;
      int i;
      for (i=0; i<n_data; i++) {
         int xsize = string_length;
         if (xsize > *buf_remain) {
            cm_msg(MERROR, "db_get_record2", "string buffer overrun at key \"%s\" index %d, size %d, buffer remaining %d", key_name, i, xsize, *buf_remain);
            return DB_INVALID_PARAM;
         }
         std::string xkey_name = msprintf("%s[%d]", key_name, i);
         int status = db_get_value(hDB, hKey, xkey_name.c_str(), *buf_ptr, &xsize, tid, FALSE);
         //printf("status %d, string length %d, xsize %d, actual len %d\n", status, string_length, xsize, (int)strlen(*buf_ptr));
         if (status == DB_TRUNCATED) {
            // make sure string is NUL terminated
            (*buf_ptr)[string_length-1] = 0;
            cm_msg(MERROR, "db_get_record2", "string key \"%s\" index %d, string value was truncated", key_name, i);
         } else if (status != DB_SUCCESS) {
            cm_msg(MERROR, "db_get_record2", "cannot read string \"%s\"[%d], db_get_value() status %d", key_name, i, status);
            memset(*buf_ptr, 0, string_length);
            xstatus = status;
         }
         *buf_ptr += string_length;
         *buf_remain -= string_length;
      }
      if (xstatus != 0) {
         return xstatus;
      }
   } else {
      cm_msg(MERROR, "db_get_record2", "cannot read key \"%s\" of unsupported type %d", key_name, tid);
      return DB_INVALID_PARAM;
   }
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_get_record2(HNDLE hDB, HNDLE hKey, void *data, INT * xbuf_size, INT align, const char *rec_str, BOOL correct)
{
   int status = DB_SUCCESS;
 
   printf("db_get_record2!\n");
 
   assert(data != NULL);
   assert(xbuf_size != NULL);
   assert(*xbuf_size > 0);
   assert(correct == 0);
 
   int truncated = 0;
#if 1
   char* r1 = NULL;
   int rs = *xbuf_size;
   if (1) {
      r1 = (char*)malloc(rs);
      assert(r1 != NULL);
      memset(data, 0xFF, *xbuf_size);
      memset(r1, 0xFF, rs);
      //status = db_get_record1(hDB, hKey, r1, &rs, 0, rec_str);
      status = db_get_record(hDB, hKey, r1, &rs, 0);
      printf("db_get_record status %d\n", status);
   }
#endif
      
   char* buf_start = (char*)data;
   int buf_size = *xbuf_size;
 
   char* buf_ptr = buf_start;
   int buf_remain = buf_size;
 
   while (rec_str && *rec_str != 0) {
      char title[256];
      char key_name[MAX_ODB_PATH];
      int tid = 0;
      int n_data = 0;
      int string_length = 0;
      const char* rec_str_next = NULL;
      
      status = db_parse_record(rec_str, &rec_str_next, title, sizeof(title), key_name, sizeof(key_name), &tid, &n_data, &string_length);
 
      //printf("parse [%s], status %d, title [%s], key_name [%s], tid %d, n_data %d, string_length %d, next [%s]\n", rec_str, status, title, key_name, tid, n_data, string_length, rec_str_next);
 
      rec_str = rec_str_next;
 
      if (status != DB_SUCCESS) {
         return status;
      }
 
      if (key_name[0] == 0) {
         // skip title strings, comments, etc
         continue;
      }
      
      status = db_get_record2_read_element(hDB, hKey, key_name, tid, n_data, string_length, buf_start, &buf_ptr, &buf_remain, correct);
      if (status == DB_INVALID_PARAM) {
         cm_msg(MERROR, "db_get_record2", "error: cannot continue reading odb record because of previous fatal error, status %d", status);
         return DB_INVALID_PARAM;
      } if (status != DB_SUCCESS) {
         truncated = 1;
      }
 
      rec_str = rec_str_next;
   }
 
   if (r1) {
      int ok = -1;
      int i;
      for (i=0; i<rs; i++) {
         if (r1[i] != buf_start[i]) {
            ok = i;
            break;
         }
      }
      if (ok>=0 || buf_remain>0) {
         printf("db_get_record2: miscompare at %d out of %d, buf_remain %d\n", ok, rs, buf_remain);
      } else {
         printf("db_get_record2: check ok\n");
      }
   }
   
   if (buf_remain > 0) {
      // FIXME: we finished processing the data definition string, but unused space remains in the buffer
      return DB_TRUNCATED;
   }
 
   if (truncated)
      return DB_TRUNCATED;
   else
      return DB_SUCCESS;
}
 
/********************************************************************/
INT db_set_record(HNDLE hDB, HNDLE hKey, void *data, INT buf_size, INT align)
{
   if (rpc_is_remote()) {
      align = ss_get_struct_align();
      return rpc_call(RPC_DB_SET_RECORD, hDB, hKey, data, buf_size, align);
   }
#ifdef LOCAL_ROUTINES
   {
      KEY key;
      INT convert_flags;
      INT total_size;
      void *pdata;
 
      convert_flags = 0;
 
      if (!align)
         align = ss_get_struct_align();
      else {
         /* only convert data if called remotely, as indicated by align != 0 */
         if (rpc_is_mserver()) {
            convert_flags = rpc_get_convert_flags();
         }
      }
 
      /* check if key has subkeys */
      db_get_key(hDB, hKey, &key);
      if (key.type != TID_KEY) {
         /* copy single key */
         if (key.item_size * key.num_values != buf_size) {
            cm_msg(MERROR, "db_set_record", "struct size mismatch for \"%s\"", key.name);
            return DB_STRUCT_SIZE_MISMATCH;
         }
 
         if (convert_flags) {
            if (key.num_values > 1)
               rpc_convert_data(data, key.type, RPC_FIXARRAY, key.item_size * key.num_values, convert_flags);
            else
               rpc_convert_single(data, key.type, 0, convert_flags);
         }
 
         db_set_data(hDB, hKey, data, key.total_size, key.num_values, key.type);
         return DB_SUCCESS;
      }
 
      /* check record size */
      db_get_record_size(hDB, hKey, align, &total_size);
      if (total_size != buf_size) {
         cm_msg(MERROR, "db_set_record", "struct size mismatch for \"%s\"", key.name);
         return DB_STRUCT_SIZE_MISMATCH;
      }
 
      /* set subkey data */
      pdata = data;
      total_size = 0;
 
      db_lock_database(hDB);
      db_err_msg* msg = NULL;
      DATABASE *pdb = &_database[hDB - 1];
      db_allow_write_locked(pdb, "db_set_record");
      db_recurse_record_tree_locked(pdb, hKey, &pdata, &total_size, align, NULL, TRUE, convert_flags, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/*------------------------------------------------------------------*/
INT db_add_open_record(HNDLE hDB, HNDLE hKey, WORD access_mode)
/********************************************************************\
 
  Routine: db_add_open_record
 
  Purpose: Server part of db_open_record. Internal use only.
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_ADD_OPEN_RECORD, hDB, hKey, access_mode);
 
#ifdef LOCAL_ROUTINES
   {
      INT i;
      int status;
 
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_add_open_record", "invalid database handle");
         return DB_INVALID_HANDLE;
      }
 
      db_err_msg* msg = NULL;
 
      /* lock database */
      db_lock_database(hDB);
 
      DATABASE *pdb = &_database[hDB - 1];
      DATABASE_HEADER *pheader = pdb->database_header;
      DATABASE_CLIENT *pclient = db_get_my_client_locked(pdb);
 
      /* check if key is already open */
      for (i = 0; i < pclient->max_index; i++) {
         if (pclient->open_record[i].handle == hKey)
            break;
      }
 
      if (i < pclient->max_index) {
         db_unlock_database(hDB);
         return DB_SUCCESS;
      }
 
      /* not found, search free entry */
      for (i = 0; i < pclient->max_index; i++) {
         if (pclient->open_record[i].handle == 0)
            break;
      }
 
      /* check if maximum number reached */
      if (i == MAX_OPEN_RECORDS) {
         db_unlock_database(hDB);
         return DB_NO_MEMORY;
      }
 
      db_allow_write_locked(pdb, "db_add_open_record");
 
      KEY *pkey = (KEY*)db_get_pkey(pheader, hKey, &status, "db_add_open_record", &msg);
 
      if (!pkey) {
         db_unlock_database(hDB);
         if (msg)
            db_flush_msg(&msg);
         return status;
      }
 
      if (i == pclient->max_index)
         pclient->max_index++;
 
      pclient->open_record[i].handle = hKey;
      pclient->open_record[i].access_mode = access_mode;
 
      /* increment notify_count */
      pkey->notify_count++;
 
      pclient->num_open_records++;
 
      /* set exclusive bit if requested */
      if (access_mode & MODE_WRITE)
         db_set_mode(hDB, hKey, (WORD) (pkey->access_mode | MODE_EXCLUSIVE), 2);
 
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
#ifdef LOCAL_ROUTINES
 
static int db_remove_open_record_wlocked(DATABASE* pdb, DATABASE_HEADER* pheader, HNDLE hKey)
{
   int status = DB_SUCCESS;
 
   DATABASE_CLIENT *pclient = db_get_my_client_locked(pdb);
 
   /* search key */
   int idx;
   for (idx = 0; idx < pclient->max_index; idx++)
      if (pclient->open_record[idx].handle == hKey)
         break;
   
   if (idx == pclient->max_index) {
      return DB_INVALID_HANDLE;
   }
 
   KEY* pkey = (KEY*)db_get_pkey(pheader, hKey, &status, "db_remove_open_record_wlocked", NULL);
 
   if (!pkey)
      return status;
 
   /* decrement notify_count */
 
   if (pkey->notify_count > 0)
      pkey->notify_count--;
   
   pclient->num_open_records--;
   
   /* remove exclusive flag */
   if (pclient->open_record[idx].access_mode & MODE_WRITE)
      db_set_mode_wlocked(pheader, pkey, (WORD) (pkey->access_mode & ~MODE_EXCLUSIVE), 2, NULL);
   
   memset(&pclient->open_record[idx], 0, sizeof(OPEN_RECORD));
   
   /* calculate new max_index entry */
   int i;
   for (i = pclient->max_index - 1; i >= 0; i--)
      if (pclient->open_record[i].handle != 0)
         break;
   pclient->max_index = i + 1;
 
   return DB_SUCCESS;
}
#endif // LOCAL_ROUTINES
 
 
INT db_remove_open_record(HNDLE hDB, HNDLE hKey, BOOL lock)
/********************************************************************\
 
  Routine: db_remove_open_record
 
  Purpose: Gets called by db_close_record. Internal use only.
 
\********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_REMOVE_OPEN_RECORD, hDB, hKey, lock);
 
   int status = DB_SUCCESS;
   
#ifdef LOCAL_ROUTINES
   {
      if (hDB > _database_entries || hDB <= 0) {
         cm_msg(MERROR, "db_remove_open_record", "invalid database handle %d", hDB);
         return DB_INVALID_HANDLE;
      }
 
      db_lock_database(hDB);
 
      DATABASE *pdb = &_database[hDB - 1];
      DATABASE_HEADER *pheader = pdb->database_header;
 
      db_allow_write_locked(pdb, "db_remove_open_record");
 
      status = db_remove_open_record_wlocked(pdb, pheader, hKey);
 
      db_unlock_database(hDB);
   }
#endif                          /* LOCAL_ROUTINES */
 
   return status;
}
 
/*------------------------------------------------------------------*/
 
#ifdef LOCAL_ROUTINES
 
static INT db_notify_clients_locked(const DATABASE* pdb, HNDLE hKeyMod, int index, BOOL bWalk, db_err_msg** msg)
/********************************************************************\
 
  Routine: db_notify_clients
 
  Purpose: Gets called by db_set_xxx functions. Internal use only.
 
\********************************************************************/
{
   HNDLE hKey;
   KEYLIST *pkeylist;
   INT i, j;
   int status;
 
   const DATABASE_HEADER* pheader = pdb->database_header;
 
   hKey = hKeyMod;
 
   const KEY* pkey = db_get_pkey(pheader, hKey, &status, "db_notify_clients", msg);
   
   if (!pkey) {
      return status;
   }
   
   do {
 
      /* check which client has record open */
      if (pkey->notify_count)
         for (i = 0; i < pheader->max_client_index; i++) {
            const DATABASE_CLIENT* pclient = &pheader->client[i];
            for (j = 0; j < pclient->max_index; j++)
               if (pclient->open_record[j].handle == hKey) {
                  /* send notification to remote process */
                  std::string str = msprintf("O %d %d %d %d", pdb->hDB, hKey, hKeyMod, index);
                  ss_resume(pclient->port, str.c_str());
               }
         }
 
      if (pkey->parent_keylist == 0 || !bWalk)
         return DB_SUCCESS;
 
      // FIXME: validate pkey->parent_keylist
      pkeylist = (KEYLIST *) ((char *) pheader + pkey->parent_keylist);
      pkey = db_get_pkey(pheader, pkeylist->parent, &status, "db_notify_clients", msg);
      if (!pkey) {
         return status;
      }
      hKey = db_pkey_to_hkey(pheader, pkey);
   } while (TRUE);
 
}
 
#endif                          /* LOCAL_ROUTINES */
/*------------------------------------------------------------------*/
 
 
INT db_notify_clients(HNDLE hDB, HNDLE hKeyMod, int index, BOOL bWalk)
/********************************************************************\
 
  Routine: db_notify_clients
 
  Purpose: Gets called by db_set_xxx functions. Internal use only.
 \********************************************************************/
{
   if (rpc_is_remote()) {
      cm_msg(MERROR, "db_notify_clients", "db_notify_clients() does not work in remotely connected MIDAS clients");
      return DB_INVALID_HANDLE;
   }
   
#ifdef LOCAL_ROUTINES
   {
      db_err_msg* msg = NULL;
      int status = db_lock_database(hDB);
      if (status != DB_SUCCESS)
         return status;
      DATABASE* pdb = &_database[hDB - 1];
      db_notify_clients_locked(pdb, hKeyMod, index, bWalk, &msg);
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
   }
#endif
   return DB_SUCCESS;
}
 
INT db_notify_clients_array(HNDLE hDB, HNDLE hKeys[], INT size)
/********************************************************************\
 
 Routine: db_notify_clients_array
 
 Purpose: This function is typically called after a set of calls
          to db_set_data1 which omits hot-link notification to 
          programs. After several ODB values are modified in a set,
          this function has to be called to trigger the hot-links
          of the whole set.
 
 \********************************************************************/
{
   if (rpc_is_remote())
      return rpc_call(RPC_DB_NOTIFY_CLIENTS_ARRAY, hDB, hKeys, size);
   
#ifdef LOCAL_ROUTINES
   {
      int status = db_lock_database(hDB);
      if (status != DB_SUCCESS)
         return status;
      db_err_msg* msg = NULL;
      DATABASE* pdb = &_database[hDB - 1];
      int count = size/sizeof(INT);
      for (int i=0 ; i<count; i++) {
         db_notify_clients_locked(pdb, hKeys[i], -1, TRUE, &msg);
      }
      db_unlock_database(hDB);
      if (msg)
         db_flush_msg(&msg);
   }
#endif
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
static void merge_records(HNDLE hDB, HNDLE hKey, KEY * pkey, INT level, void *info)
{
   char full_name[MAX_ODB_PATH];
   INT status, size;
   HNDLE hKeyInit;
   KEY initkey, key;
 
   /* avoid compiler warnings */
   status = level;
 
   /* compose name of init key */
   std::string s = db_get_path(hDB, hKey);
   mstrlcpy(full_name, s.c_str(), sizeof(full_name));
   *strchr(full_name, 'O') = 'I';
 
   /* if key in init record found, copy original data to init data */
   status = db_find_key(hDB, 0, full_name, &hKeyInit);
   if (status == DB_SUCCESS) {
      status = db_get_key(hDB, hKeyInit, &initkey);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "merge_records", "merge_record error at \'%s\', db_get_key() status %d", full_name, status);
         return;
      }
      status = db_get_key(hDB, hKey, &key);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "merge_records", "merge_record error at \'%s\', second db_get_key() status %d", full_name, status);
         return;
      }
 
      if (initkey.type != TID_KEY && initkey.type == key.type) {
         char* allocbuffer = NULL;
         char  stackbuffer[10000];
         char* buffer = stackbuffer;
         size = sizeof(stackbuffer);
         while (1) {
            /* copy data from original key to new key */
            status = db_get_data(hDB, hKey, buffer, &size, initkey.type);
            if (status == DB_SUCCESS) {
               status = db_set_data(hDB, hKeyInit, buffer, initkey.total_size, initkey.num_values, initkey.type);
               if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "merge_records", "merge_record error at \'%s\', db_set_data() status %d", full_name, status);
                  return;
               }
               break;
            }
            if (status == DB_TRUNCATED) {
               size *= 2;
               allocbuffer = (char *)realloc(allocbuffer, size);
               assert(allocbuffer != NULL);
               buffer = allocbuffer;
               continue;
            }
            cm_msg(MERROR, "merge_records", "aborting on unexpected failure of db_get_data(%s), status %d", full_name, status);
            abort();
         }
         if (allocbuffer)
            free(allocbuffer);
      }
   } else if (status == DB_NO_KEY) {
      /* do nothing */
   } else if (status == DB_INVALID_LINK) {
      status = db_find_link(hDB, 0, full_name, &hKeyInit);
      if (status == DB_SUCCESS) {
         size = sizeof(full_name);
         status = db_get_data(hDB, hKeyInit, full_name, &size, TID_LINK);
      }
      cm_msg(MERROR, "merge_records", "Invalid link \"%s\"", full_name);
   } else {
      cm_msg(MERROR, "merge_records", "aborting on unexpected failure of db_find_key(%s), status %d", full_name, status);
      abort();
   }
}
 
static int _global_open_count; // FIXME: this is not thread-safe
 
static void check_open_keys(HNDLE hDB, HNDLE hKey, KEY * pkey, INT level, void *info)
{
   if (pkey->notify_count)
      _global_open_count++;
}
 
#endif                          /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT db_create_record(HNDLE hDB, HNDLE hKey, const char *orig_key_name, const char *init_str)
{
   char key_name[256], *buffer;
   INT status, size, buffer_size;
   HNDLE hKeyTmp, hKeyTmpO, hKeyOrig, hSubkey;
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_CREATE_RECORD, hDB, hKey, orig_key_name, init_str);
 
   /* make this function atomic */
   db_lock_database(hDB);
 
   /* strip trailing '/' */
   mstrlcpy(key_name, orig_key_name, sizeof(key_name));
   if (strlen(key_name) > 1 && key_name[strlen(key_name) - 1] == '/')
      key_name[strlen(key_name) - 1] = 0;
 
   /* merge temporay record and original record */
   status = db_find_key(hDB, hKey, key_name, &hKeyOrig);
   if (status == DB_SUCCESS) {
      assert(hKeyOrig != 0);
#ifdef CHECK_OPEN_RECORD
      /* check if key or subkey is opened */
      _global_open_count = 0; // FIXME: this is not thread safe
      db_scan_tree_link(hDB, hKeyOrig, 0, check_open_keys, NULL);
      if (_global_open_count) {
         db_unlock_database(hDB);
         return DB_OPEN_RECORD;
      }
#endif
      /* create temporary records */
      std::string str = "/System/Tmp/" + ss_tid_to_string(ss_gettid()) + "I";
      //printf("db_create_record str [%s]\n", str);
      db_delete(hDB, 0, str.c_str());
      db_create_key(hDB, 0, str.c_str(), TID_KEY);
      status = db_find_key(hDB, 0, str.c_str(), &hKeyTmp);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      str = "/System/Tmp/" + ss_tid_to_string(ss_gettid()) + "O";
      //printf("db_create_record str [%s]\n", str);
      db_delete(hDB, 0, str.c_str());
      db_create_key(hDB, 0, str.c_str(), TID_KEY);
      status = db_find_key(hDB, 0, str.c_str(), &hKeyTmpO);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      status = db_paste(hDB, hKeyTmp, init_str);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      buffer_size = 10000;
      buffer = (char *) malloc(buffer_size);
      assert(buffer != NULL);
 
      do {
         size = buffer_size;
         status = db_copy(hDB, hKeyOrig, buffer, &size, "");
         if (status == DB_TRUNCATED) {
            buffer_size += 10000;
            buffer = (char *) realloc(buffer, buffer_size);
            assert(buffer != NULL);
            continue;
         }
         if (status != DB_SUCCESS) {
            free(buffer);
            db_unlock_database(hDB);
            return status;
         }
 
      } while (status != DB_SUCCESS);
 
      status = db_paste(hDB, hKeyTmpO, buffer);
      if (status != DB_SUCCESS) {
         free(buffer);
         db_unlock_database(hDB);
         return status;
      }
 
      /* merge temporay record and original record */
      db_scan_tree_link(hDB, hKeyTmpO, 0, merge_records, NULL);
 
      /* delete original record */
      while (1) {
         db_enum_link(hDB, hKeyOrig, 0, &hSubkey);
         if (!hSubkey)
            break;
 
         status = db_delete_key(hDB, hSubkey);
         if (status != DB_SUCCESS) {
            free(buffer);
            db_unlock_database(hDB);
            return status;
         }
      }
 
      /* copy merged record to original record */
      do {
         size = buffer_size;
         status = db_copy(hDB, hKeyTmp, buffer, &size, "");
         if (status == DB_TRUNCATED) {
            buffer_size += 10000;
            buffer = (char *) realloc(buffer, buffer_size);
            continue;
         }
         if (status != DB_SUCCESS) {
            free(buffer);
            db_unlock_database(hDB);
            return status;
         }
 
      } while (status != DB_SUCCESS);
 
      status = db_paste(hDB, hKeyOrig, buffer);
      if (status != DB_SUCCESS) {
         free(buffer);
         db_unlock_database(hDB);
         return status;
      }
 
      /* delete temporary records */
      db_delete_key(hDB, hKeyTmp);
      db_delete_key(hDB, hKeyTmpO);
 
      free(buffer);
      buffer = NULL;
   } else if (status == DB_NO_KEY) {
      /* create fresh record */
      db_create_key(hDB, hKey, key_name, TID_KEY);
      status = db_find_key(hDB, hKey, key_name, &hKeyTmp);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      status = db_paste(hDB, hKeyTmp, init_str);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
   } else {
      cm_msg(MERROR, "db_create_record", "aborting on unexpected failure of db_find_key(%s), status %d", key_name, status);
      abort();
   }
 
   db_unlock_database(hDB);
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_check_record(HNDLE hDB, HNDLE hKey, const char *keyname, const char *rec_str, BOOL correct)
{
   char line[MAX_STRING_LENGTH];
   char title[MAX_STRING_LENGTH];
   char key_name[MAX_STRING_LENGTH];
   char info_str[MAX_STRING_LENGTH + 50];
   char *pc;
   const char *pold, *rec_str_orig;
   DWORD tid;
   INT i, j, n_data, string_length, status;
   HNDLE hKeyRoot, hKeyTest;
   KEY key;
   int bad_string_length;
 
   if (rpc_is_remote())
      return rpc_call(RPC_DB_CHECK_RECORD, hDB, hKey, keyname, rec_str, correct);
 
   /* check if record exists */
   status = db_find_key(hDB, hKey, keyname, &hKeyRoot);
 
   /* create record if not */
   if (status == DB_NO_KEY) {
      if (correct)
         return db_create_record(hDB, hKey, keyname, rec_str);
      return DB_NO_KEY;
   }
 
   assert(hKeyRoot);
 
   title[0] = 0;
   rec_str_orig = rec_str;
 
   db_get_key(hDB, hKeyRoot, &key);
   if (key.type == TID_KEY)
      /* get next subkey which is not of type TID_KEY */
      db_get_next_link(hDB, hKeyRoot, &hKeyTest);
   else
      /* test root key itself */
      hKeyTest = hKeyRoot;
 
   if (hKeyTest == 0 && *rec_str != 0) {
      if (correct)
         return db_create_record(hDB, hKey, keyname, rec_str_orig);
 
      return DB_STRUCT_MISMATCH;
   }
 
   do {
      if (*rec_str == 0)
         break;
 
      for (i = 0; *rec_str != '\n' && *rec_str && i < MAX_STRING_LENGTH; i++)
         line[i] = *rec_str++;
 
      if (i == MAX_STRING_LENGTH) {
         cm_msg(MERROR, "db_check_record", "line too long");
         return DB_TRUNCATED;
      }
 
      line[i] = 0;
      if (*rec_str == '\n')
         rec_str++;
 
      /* check if it is a section title */
      if (line[0] == '[') {
         /* extract title and append '/' */
         strcpy(title, line + 1);
         if (strchr(title, ']'))
            *strchr(title, ']') = 0;
         if (title[0] && title[strlen(title) - 1] != '/')
            strcat(title, "/");
      } else {
         /* valid data line if it includes '=' and no ';' */
         if (strchr(line, '=') && line[0] != ';') {
            /* copy type info and data */
            pc = strchr(line, '=') + 1;
            while (*pc == ' ')
               pc++;
            strcpy(info_str, pc);
 
            /* extract key name */
            *strchr(line, '=') = 0;
 
            pc = &line[strlen(line) - 1];
            while (*pc == ' ')
               *pc-- = 0;
 
            mstrlcpy(key_name, line, sizeof(key_name));
 
            /* evaluate type info */
            strcpy(line, info_str);
            if (strchr(line, ' '))
               *strchr(line, ' ') = 0;
 
            n_data = 1;
            if (strchr(line, '[')) {
               n_data = atol(strchr(line, '[') + 1);
               *strchr(line, '[') = 0;
            }
 
            for (tid = 0; tid < TID_LAST; tid++)
               if (strcmp(rpc_tid_name(tid), line) == 0)
                  break;
            if (tid == TID_LAST) {
               for (tid = 0; tid < TID_LAST; tid++)
                  if (strcmp(rpc_tid_name_old(tid), line) == 0)
                     break;
            }
 
            string_length = 0;
 
            if (tid == TID_LAST)
               cm_msg(MERROR, "db_check_record", "found unknown data type \"%s\" in ODB file", line);
            else {
               /* skip type info */
               pc = info_str;
               while (*pc != ' ' && *pc)
                  pc++;
               while ((*pc == ' ' || *pc == ':') && *pc)
                  pc++;
 
               if (n_data > 1) {
                  info_str[0] = 0;
                  if (!*rec_str)
                     break;
 
                  for (j = 0; *rec_str != '\n' && *rec_str; j++)
                     info_str[j] = *rec_str++;
                  info_str[j] = 0;
                  if (*rec_str == '\n')
                     rec_str++;
               }
 
               for (i = 0; i < n_data; i++) {
                  /* strip trailing \n */
                  pc = &info_str[strlen(info_str) - 1];
                  while (*pc == '\n' || *pc == '\r')
                     *pc-- = 0;
 
                  if (tid == TID_STRING || tid == TID_LINK) {
                     if (!string_length) {
                        if (info_str[1] == '=')
                           string_length = -1;
                        else {
                           pc = strchr(info_str, '[');
                           if (pc != NULL)
                              string_length = atoi(pc + 1);
                           else
                              string_length = -1;
                        }
                        if (string_length > MAX_STRING_LENGTH) {
                           string_length = MAX_STRING_LENGTH;
                           cm_msg(MERROR, "db_check_record", "found string exceeding MAX_STRING_LENGTH");
                        }
                     }
 
                     if (string_length == -1) {
                        /* multi-line string */
                        if (strstr(rec_str, "\n====#$@$#====\n") != NULL) {
                           string_length = (POINTER_T) strstr(rec_str, "\n====#$@$#====\n") - (POINTER_T) rec_str + 1;
 
                           rec_str = strstr(rec_str, "\n====#$@$#====\n") + strlen("\n====#$@$#====\n");
                        } else
                           cm_msg(MERROR, "db_check_record", "found multi-line string without termination sequence");
                     } else {
                        if (strchr(info_str, ']'))
                           pc = strchr(info_str, ']') + 1;
                        else
                           pc = info_str + 2;
                        while (*pc && *pc != ' ')
                           pc++;
                        while (*pc && *pc == ' ')
                           pc++;
 
                        /* limit string size */
                        *(pc + string_length - 1) = 0;
                     }
                  } else {
                     pc = info_str;
 
                     if (n_data > 1 && info_str[0] == '[') {
                        pc = strchr(info_str, ']') + 1;
                        while (*pc && *pc == ' ')
                           pc++;
                     }
                  }
 
                  if (i < n_data - 1) {
                     info_str[0] = 0;
                     if (!*rec_str)
                        break;
 
                     pold = rec_str;
 
                     for (j = 0; *rec_str != '\n' && *rec_str; j++)
                        info_str[j] = *rec_str++;
                     info_str[j] = 0;
                     if (*rec_str == '\n')
                        rec_str++;
 
                     /* test if valid data */
                     if (tid != TID_STRING && tid != TID_LINK) {
                        if (info_str[0] == 0 || (strchr(info_str, '=')
                                                 && strchr(info_str, ':')))
                           rec_str = pold;
                     }
                  }
               }
 
               /* if rec_str contains key, but not ODB, return mismatch */
               if (!hKeyTest) {
                  if (correct)
                     return db_create_record(hDB, hKey, keyname, rec_str_orig);
 
                  return DB_STRUCT_MISMATCH;
               }
 
               status = db_get_key(hDB, hKeyTest, &key);
               assert(status == DB_SUCCESS);
 
               bad_string_length = 0;
 
               if (key.type == TID_STRING) {
                  //printf("key name [%s], tid %d/%d, num_values %d/%d, string length %d/%d\n", key_name, key.type, tid, key.num_values, n_data, string_length, key.item_size);
                  if (string_length > 0 && string_length != key.item_size) {
                     bad_string_length = 1;
                  }
               }
 
               /* check rec_str vs. ODB key */
               if (!equal_ustring(key.name, key_name) || key.type != tid || key.num_values != n_data || bad_string_length) {
                  //printf("miscompare key name [%s], tid %d/%d, num_values %d/%d, string length %d/%d\n", key_name, key.type, tid, key.num_values, n_data, key.item_size, string_length);
                  if (correct)
                     return db_create_record(hDB, hKey, keyname, rec_str_orig);
 
                  return DB_STRUCT_MISMATCH;
               }
 
               /* get next key in ODB */
               db_get_next_link(hDB, hKeyTest, &hKeyTest);
            }
         }
      }
   } while (TRUE);
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_open_record(HNDLE hDB, HNDLE hKey, void *ptr, INT rec_size,
                   WORD access_mode, void (*dispatcher) (INT, INT, void *), void *info)
{
   INT idx, status, size;
   KEY key;
   void *data;
 
   /* allocate new space for the local record list */
   if (_record_list_entries == 0) {
      _record_list = (RECORD_LIST *) malloc(sizeof(RECORD_LIST));
      assert(_record_list != NULL);
      memset(_record_list, 0, sizeof(RECORD_LIST));
      if (_record_list == NULL) {
         cm_msg(MERROR, "db_open_record", "not enough memory");
         return DB_NO_MEMORY;
      }
 
      _record_list_entries = 1;
      idx = 0;
   } else {
      /* check for a deleted entry */
      for (idx = 0; idx < _record_list_entries; idx++)
         if (!_record_list[idx].handle)
            break;
 
      /* if not found, create new one */
      if (idx == _record_list_entries) {
         _record_list = (RECORD_LIST *) realloc(_record_list, sizeof(RECORD_LIST) * (_record_list_entries + 1));
         if (_record_list == NULL) {
            cm_msg(MERROR, "db_open_record", "not enough memory");
            return DB_NO_MEMORY;
         }
 
         memset(&_record_list[_record_list_entries], 0, sizeof(RECORD_LIST));
 
         _record_list_entries++;
      }
   }
 
   db_get_key(hDB, hKey, &key);
 
   /* check record size */
   status = db_get_record_size(hDB, hKey, 0, &size);
   if (status != DB_SUCCESS) {
      _record_list_entries--;
      cm_msg(MERROR, "db_open_record", "cannot get record size, db_get_record_size() status %d", status);
      return DB_NO_MEMORY;
   }
 
   if (size != rec_size && ptr != NULL) {
      _record_list_entries--;
      std::string path = db_get_path(hDB, hKey);
      cm_msg(MERROR, "db_open_record", "struct size mismatch for \"%s\" (expected size: %d, size in ODB: %d)", path.c_str(), rec_size, size);
      return DB_STRUCT_SIZE_MISMATCH;
   }
 
   /* check for read access */
   if (((key.access_mode & MODE_EXCLUSIVE) && (access_mode & MODE_WRITE))
       || (!(key.access_mode & MODE_WRITE) && (access_mode & MODE_WRITE))
       || (!(key.access_mode & MODE_READ) && (access_mode & MODE_READ))) {
      _record_list_entries--;
      return DB_NO_ACCESS;
   }
 
   if (access_mode & MODE_ALLOC) {
      data = malloc(size);
 
      if (data == NULL) {
         _record_list_entries--;
         cm_msg(MERROR, "db_open_record", "not enough memory, malloc(%d) returned NULL", size);
         return DB_NO_MEMORY;
      }
 
      memset(data, 0, size);
 
      *((void **) ptr) = data;
   } else {
      data = ptr;
   }
 
   /* copy record to local memory */
   if (access_mode & MODE_READ && data != NULL) {
      status = db_get_record(hDB, hKey, data, &size, 0);
      if (status != DB_SUCCESS) {
         _record_list_entries--;
         cm_msg(MERROR, "db_open_record", "cannot get record, db_get_record() status %d", status);
         return DB_NO_MEMORY;
      }
   }
 
   /* copy local record to ODB */
   if (access_mode & MODE_WRITE) {
      /* only write to ODB if not in MODE_ALLOC */
      if ((access_mode & MODE_ALLOC) == 0) {
         status = db_set_record(hDB, hKey, data, size, 0);
         if (status != DB_SUCCESS) {
            _record_list_entries--;
            cm_msg(MERROR, "db_open_record", "cannot set record, db_set_record() status %d", status);
            return DB_NO_MEMORY;
         }
      }
 
      /* init a local copy of the record */
      _record_list[idx].copy = malloc(size);
      if (_record_list[idx].copy == NULL) {
         cm_msg(MERROR, "db_open_record", "not enough memory");
         return DB_NO_MEMORY;
      }
 
      memcpy(_record_list[idx].copy, data, size);
   }
 
   /* initialize record list */
   _record_list[idx].handle = hKey;
   _record_list[idx].hDB = hDB;
   _record_list[idx].access_mode = access_mode;
   _record_list[idx].data = data;
   _record_list[idx].buf_size = size;
   _record_list[idx].dispatcher = dispatcher;
   _record_list[idx].info = info;
 
   /* add record entry in database structure */
   return db_add_open_record(hDB, hKey, (WORD) (access_mode & ~MODE_ALLOC));
}
 
/********************************************************************/
INT db_open_record1(HNDLE hDB, HNDLE hKey, void *ptr, INT rec_size,
                    WORD access_mode, void (*dispatcher) (INT, INT, void *), void *info,
                     const char *rec_str)
{
   if (rec_str) {
      int status;
      if (rec_size) {
         char* pbuf;
         int size = rec_size;
         pbuf = (char*)malloc(size);
         assert(pbuf != NULL);
         status = db_get_record1(hDB, hKey, pbuf, &size, 0, rec_str);
         free(pbuf);
         if (status != DB_SUCCESS)
            return status;
      }
 
      status = db_check_record(hDB, hKey, "", rec_str, TRUE);
      if (status != DB_SUCCESS)
         return status;
   }
 
   return db_open_record(hDB, hKey, ptr, rec_size, access_mode, dispatcher, info);
}
 
/********************************************************************/
INT db_close_record(HNDLE hDB, HNDLE hKey)
{
#ifdef LOCAL_ROUTINES
   {
      INT i;
 
      for (i = 0; i < _record_list_entries; i++)
         if (_record_list[i].handle == hKey && _record_list[i].hDB == hDB)
            break;
 
      if (i == _record_list_entries)
         return DB_INVALID_HANDLE;
 
      /* remove record entry from database structure */
      db_remove_open_record(hDB, hKey, TRUE);
 
      /* free local memory */
      if (_record_list[i].access_mode & MODE_ALLOC) {
         free(_record_list[i].data);
         _record_list[i].data = NULL;
      }
 
      if (_record_list[i].access_mode & MODE_WRITE) {
         free(_record_list[i].copy);
         _record_list[i].copy = NULL;
      }
 
      memset(&_record_list[i], 0, sizeof(RECORD_LIST));
   }
#endif                          /* LOCAL_ROUTINES */
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_close_all_records()
{
   INT i;
 
   for (i = 0; i < _record_list_entries; i++) {
      if (_record_list[i].handle) {
         if (_record_list[i].access_mode & MODE_WRITE) {
            free(_record_list[i].copy);
            _record_list[i].copy = NULL;
         }
 
         if (_record_list[i].access_mode & MODE_ALLOC) {
            free(_record_list[i].data);
            _record_list[i].data = NULL;
         }
 
         memset(&_record_list[i], 0, sizeof(RECORD_LIST));
      }
   }
 
   if (_record_list_entries > 0) {
      _record_list_entries = 0;
      free(_record_list);
      _record_list = NULL;
   }
 
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_update_record_local(INT hDB, INT hKeyRoot, INT hKey, int index)
{
   INT i, size, status;
 
   status = DB_INVALID_HANDLE;
 
   /* check all record entries for matching key */
   for (i = 0; i < _record_list_entries; i++)
      if (_record_list[i].handle == hKeyRoot) {
         status = DB_SUCCESS;
 
         /* get updated data if record not opened in write mode */
         if ((_record_list[i].access_mode & MODE_WRITE) == 0) {
            size = _record_list[i].buf_size;
            if (_record_list[i].data != NULL) {
               status = db_get_record(hDB, hKeyRoot, _record_list[i].data, &size, 0); // db_open_record() update
               //printf("db_open_record update status %d, size %d %d\n", status, _record_list[i].buf_size, size);
            }
            
            /* call dispatcher if requested */
            if (_record_list[i].dispatcher)
               _record_list[i].dispatcher(hDB, hKeyRoot, _record_list[i].info);
         }
      }
 
   /* check all watch entries for matching key */
   for (i = 0; i < _watch_list_entries; i++)
      if (_watch_list[i].handle == hKeyRoot) {
         status = DB_SUCCESS;
         
         /* call dispatcher if requested */
         if (_watch_list[i].dispatcher)
            _watch_list[i].dispatcher(hDB, hKey, index, _watch_list[i].info);
      }
 
   return status;
}
 
/********************************************************************/
INT db_update_record_mserver(INT hDB, INT hKeyRoot, INT hKey, int index, int client_socket)
{
   char buffer[32];
 
   int convert_flags = rpc_get_convert_flags();
   
   NET_COMMAND* nc = (NET_COMMAND *) buffer;
   
   nc->header.routine_id = MSG_ODB;
   nc->header.param_size = 4 * sizeof(INT);
   *((INT *) nc->param) = hDB;
   *((INT *) nc->param + 1) = hKeyRoot;
   *((INT *) nc->param + 2) = hKey;
   *((INT *) nc->param + 3) = index;
   
   if (convert_flags) {
      rpc_convert_single(&nc->header.routine_id, TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->header.param_size, TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->param[0], TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->param[4], TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->param[8], TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->param[12], TID_UINT32, RPC_OUTGOING, convert_flags);
   }
   
   /* send the update notification to the client */
   send_tcp(client_socket, buffer, sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT), 0);
   
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_send_changed_records()
{
   INT i;
 
   for (i = 0; i < _record_list_entries; i++)
      if (_record_list[i].access_mode & MODE_WRITE) {
         if (memcmp(_record_list[i].copy, _record_list[i].data, _record_list[i].buf_size) != 0) {
            if (rpc_is_remote()) {
               int align = ss_get_struct_align();
               rpc_call(RPC_DB_SET_RECORD|RPC_NO_REPLY, _record_list[i].hDB, _record_list[i].handle, _record_list[i].data, _record_list[i].buf_size, align);
            } else {
               db_set_record(_record_list[i].hDB, _record_list[i].handle, _record_list[i].data, _record_list[i].buf_size, 0);
            }
            memcpy(_record_list[i].copy, _record_list[i].data, _record_list[i].buf_size);
         }
      }
 
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
/********************************************************************/
INT db_watch(HNDLE hDB, HNDLE hKey, void (*dispatcher) (INT, INT, INT, void*), void* info)
{
   INT idx, status;
   KEY key;
   
   /* check for valid key */
   assert(hKey);
   
   /* allocate new space for the local record list */
   if (_watch_list_entries == 0) {
      _watch_list = (WATCH_LIST *) malloc(sizeof(WATCH_LIST));
      assert(_watch_list != NULL);
      memset(_watch_list, 0, sizeof(WATCH_LIST));
      if (_watch_list == NULL) {
         cm_msg(MERROR, "db_watch", "not enough memory");
         return DB_NO_MEMORY;
      }
      
      _watch_list_entries = 1;
      idx = 0;
   } else {
      /* check for a deleted entry */
      for (idx = 0; idx < _watch_list_entries; idx++)
         if (!_watch_list[idx].handle)
            break;
      
      /* if not found, create new one */
      if (idx == _watch_list_entries) {
         _watch_list = (WATCH_LIST *) realloc(_watch_list, sizeof(WATCH_LIST) * (_watch_list_entries + 1));
         if (_watch_list == NULL) {
            cm_msg(MERROR, "db_watch", "not enough memory");
            return DB_NO_MEMORY;
         }
         
         memset(&_watch_list[_watch_list_entries], 0, sizeof(WATCH_LIST));
         
         _watch_list_entries++;
      }
   }
   
   /* check key */
   status = db_get_key(hDB, hKey, &key);
   if (status != DB_SUCCESS) {
      _watch_list_entries--;
      std::string path = db_get_path(hDB, hKey);
      cm_msg(MERROR, "db_watch", "cannot get key \"%s\"", path.c_str());
      return DB_NO_MEMORY;
   }
   
   /* check for read access */
   if (!(key.access_mode & MODE_READ)) {
      _watch_list_entries--;
      std::string path = db_get_path(hDB, hKey);
      cm_msg(MERROR, "db_watch", "cannot get key \"%s\"", path.c_str());
      return DB_NO_ACCESS;
   }
   
   /* initialize record list */
   _watch_list[idx].handle = hKey;
   _watch_list[idx].hDB = hDB;
   _watch_list[idx].dispatcher = dispatcher;
   _watch_list[idx].info = info;
   
   /* add record entry in database structure */
   return db_add_open_record(hDB, hKey, MODE_WATCH);
}
 
 
/********************************************************************/
INT db_unwatch(HNDLE hDB, HNDLE hKey)
{
#ifdef LOCAL_ROUTINES
   {
   INT i;
   
   for (i = 0; i < _watch_list_entries; i++)
      if (_watch_list[i].handle == hKey && _watch_list[i].hDB == hDB)
         break;
   
   if (i == _watch_list_entries)
      return DB_INVALID_HANDLE;
   
   /* remove record entry from database structure */
   db_remove_open_record(hDB, hKey, TRUE);
   
   memset(&_watch_list[i], 0, sizeof(WATCH_LIST));
   }
#endif                          /* LOCAL_ROUTINES */
   
   return DB_SUCCESS;
}
 
/********************************************************************/
INT db_unwatch_all()
{
   for (int i = _watch_list_entries-1; i >= 0 ; i--) {
      if ((_watch_list[i].hDB == 0) && (_watch_list[i].handle == 0)) {
         // empty or deleted watch list entry
         continue;
      }
      db_unwatch(_watch_list[i].hDB, _watch_list[i].handle);
   }
   
   return DB_SUCCESS;
}
 
/*------------------------------------------------------------------*/
 
/* C++ wrapper for db_get_value */
 
INT EXPRT db_get_value_string(HNDLE hdb, HNDLE hKeyRoot, const char *key_name, int index, std::string* s, BOOL create, int create_string_length)
{
   int status;
   int hkey;
 
   //printf("db_get_value_string: key_name [%s], index %d, string [%s], create %d, create_string_length %d\n", key_name, index, s->c_str(), create, create_string_length);
 
   if (index > 0 && create) {
      cm_msg(MERROR, "db_get_value_string", "cannot resize odb string arrays, please use db_resize_string() instead");
      return DB_OUT_OF_RANGE;
   }
 
   status = db_find_key(hdb, hKeyRoot, key_name, &hkey);
   if (status == DB_SUCCESS) {
      KEY key;
      status = db_get_key(hdb, hkey, &key);
      if (status != DB_SUCCESS)
         return status;
      if (index < 0 || index >= key.num_values)
         return DB_OUT_OF_RANGE;
      int size = key.item_size;
      if (size == 0) {
         if (s)
            *s = "";
         //printf("db_get_value_string: return empty string, item_size %d\n", key.item_size);
         return DB_SUCCESS;
      }
      char* buf = (char*)malloc(size);
      assert(buf != NULL);
      status = db_get_data_index(hdb, hkey, buf, &size, index, TID_STRING);
      if (status != DB_SUCCESS) {
         free(buf);
         return status;
      }
      if (s)
         *s = buf;
      free(buf);
      //printf("db_get_value_string: return [%s], len %d, item_size %d, size %d\n", s->c_str(), s->length(), key.item_size, size);
      return DB_SUCCESS;
   } else if (!create) {
      // does not exist and not asked to create it
      return status;
   } else {
      //printf("db_get_value_string: creating [%s]\n", key_name);
      status = db_create_key(hdb, hKeyRoot, key_name, TID_STRING);
      if (status != DB_SUCCESS)
         return status;
      status = db_find_key(hdb, hKeyRoot, key_name, &hkey);
      if (status != DB_SUCCESS)
         return status;
      assert(s != NULL);
      if (create_string_length == 0) {
         int size = s->length() + 1; // 1 byte for final \0
         status = db_set_data_index(hdb, hkey, s->c_str(), size, index, TID_STRING);
      } else {
         char* buf = (char*)malloc(create_string_length);
         assert(buf);
         mstrlcpy(buf, s->c_str(), create_string_length);
         status = db_set_data_index(hdb, hkey, buf, create_string_length, index, TID_STRING);
         free(buf);
      }
      if (status != DB_SUCCESS)
         return status;
      //printf("db_get_value_string: created with value [%s]\n", s->c_str());
      return DB_SUCCESS;
   }
   // NOT REACHED
}
 
/* C++ wrapper for db_set_value */
 
INT EXPRT db_set_value_string(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const std::string* s)
{
   assert(s != NULL);
   int size = s->length() + 1; // 1 byte for final \0
   //printf("db_set_value_string: key_name [%s], string [%s], size %d\n", key_name, s->c_str(), size);
   return db_set_value(hDB, hKeyRoot, key_name, s->c_str(), size, 1, TID_STRING);
}
 
/********************************************************************/
INT EXPRT db_resize_string(HNDLE hdb, HNDLE hKeyRoot, const char *key_name, int num_values, int max_string_length)
{
   int status;
   int hkey;
 
   //printf("db_resize_string: key_name [%s], num_values %d, max_string_length %d\n", key_name, num_values, max_string_length);
 
   int old_num_values = 0;
   int old_item_size = 0;
   int old_size = 0;
   char* old_data = NULL;
 
   if (key_name) {
      status = db_find_key(hdb, hKeyRoot, key_name, &hkey);
   } else {
      hkey = hKeyRoot;
      status = DB_SUCCESS;
   }
   if (status == DB_SUCCESS) {
      KEY key;
      status = db_get_key(hdb, hkey, &key);
      if (status != DB_SUCCESS)
         return status;
      old_num_values = key.num_values;
      old_item_size = key.item_size;
      old_size = old_num_values * old_item_size;
      if (old_size > 0) {
         old_data = (char*)malloc(old_size);
         assert(old_data != NULL);
         int size = old_size;
         status = db_get_data(hdb, hkey, old_data, &size, TID_STRING);
         if (status != DB_SUCCESS) {
            free(old_data);
            return status;
         }
         assert(size == old_size);
      }
   } else {
      status = db_create_key(hdb, hKeyRoot, key_name, TID_STRING);
      if (status != DB_SUCCESS)
         return status;
      status = db_find_key(hdb, hKeyRoot, key_name, &hkey);
      if (status != DB_SUCCESS)
         return status;
   }
 
   //printf("old_num_values %d, old_item_size %d, old_size %d\n", old_num_values, old_item_size, old_size);
 
   int item_size = max_string_length;
 
   if (item_size < 1)
      item_size = old_item_size;
 
   if (num_values < 1)
      num_values = old_num_values;
 
   int new_size = num_values * item_size;
   char* new_data = (char*)malloc(new_size);
   assert(new_data);
 
   memset(new_data, 0, new_size);
 
   if (old_data) {
      int num = old_num_values;
      if (num > num_values)
         num = num_values;
 
      //printf("new num_values %d, item_size %d, new_size %d, old_size %d, to copy %d values\n", num_values, item_size, new_size, old_size, num);
 
      for (int i=0; i<num; i++) {
         const char* old_ptr = old_data + i*old_item_size;
         char* new_ptr = new_data + i*item_size;
         mstrlcpy(new_ptr, old_ptr, item_size);
      }
   }
 
   status = db_set_data(hdb, hkey, new_data, new_size, num_values, TID_STRING);
 
   if (old_data)
      free(old_data);
   if (new_data)
      free(new_data);
   
   return status;
}
 
MJsonNode* db_scl(HNDLE hDB)
{
#ifdef LOCAL_ROUTINES
   MJsonNode* scl = MJsonNode::MakeObject();
   MJsonNode* clients = MJsonNode::MakeArray();
 
   scl->AddToObject("now", MJsonNode::MakeNumber(ss_time_sec()));
   scl->AddToObject("clients", clients);
 
   /* lock database */
   db_lock_database(hDB);
 
   DATABASE *pdb = &_database[hDB - 1];
   DATABASE_HEADER *pheader = pdb->database_header;
 
   DWORD now = ss_millitime();
 
   /* list clients */
   for (int i = 0; i < pheader->max_client_index; i++) {
      DATABASE_CLIENT *pclient = &pheader->client[i];
      if (pclient->pid) {
         MJsonNode* c = MJsonNode::MakeObject();
         c->AddToObject("slot", MJsonNode::MakeNumber(i));
         c->AddToObject("pid", MJsonNode::MakeNumber(pclient->pid));
         c->AddToObject("name", MJsonNode::MakeString(pclient->name));
         std::string path = msprintf("/System/Clients/%d/Host", pclient->pid);
         const KEY* pkey = db_find_pkey_locked(pheader, NULL, path.c_str(), true, NULL, NULL);
         if (pkey) {
            int host_size = pkey->total_size;
            char* host = (char*)malloc(host_size);
            assert(host != NULL);
            db_get_data_locked(pheader, pkey, 0, host, &host_size, TID_STRING, NULL);
            c->AddToObject("host", MJsonNode::MakeString(host));
            free(host);
         }
         c->AddToObject("watchdog_timeout_millisec", MJsonNode::MakeNumber(pclient->watchdog_timeout));
         // "now" and "last_activity" is millisecond time wrapped around at 32 bits, must do unsigned 32-bit math here, not in javascript
         c->AddToObject("last_activity_millisec", MJsonNode::MakeNumber(now - pclient->last_activity));
         clients->AddToArray(c);
      }
   }
 
   db_unlock_database(hDB);
 
   return scl;
#else
   return MJsonNode::MakeNull();
#endif
}
 
MJsonNode* db_sor(HNDLE hDB, const char* root_path)
{
   //printf("db_sor(%s)\n", root_path);
   assert(root_path != NULL);
#ifdef LOCAL_ROUTINES
   size_t root_path_len = strlen(root_path);
   MJsonNode* sor = MJsonNode::MakeArray();
 
   /* lock database */
   db_lock_database(hDB);
 
   DATABASE *pdb = &_database[hDB - 1];
   DATABASE_HEADER *pheader = pdb->database_header;
 
   /* list clients */
   for (int i = 0; i < pheader->max_client_index; i++) {
      DATABASE_CLIENT *pclient = &pheader->client[i];
      if (pclient->pid) {
         for (int j = 0; j < pclient->max_index; j++) {
            std::string path = db_get_path_locked(pheader, pclient->open_record[j].handle);
            if (path.length() < root_path_len)
               continue;
            if (strncmp(root_path, path.c_str(), root_path_len) != 0)
               continue;
            MJsonNode* c = MJsonNode::MakeObject();
            c->AddToObject("name", MJsonNode::MakeString(pclient->name));
            //c->AddToObject("handle", MJsonNode::MakeNumber(pclient->open_record[j].handle));
            c->AddToObject("access_mode", MJsonNode::MakeNumber(pclient->open_record[j].access_mode));
            c->AddToObject("flags", MJsonNode::MakeNumber(pclient->open_record[j].flags));
            c->AddToObject("path", MJsonNode::MakeString(path.c_str()));
            sor->AddToArray(c);
         }
      }
   }
 
   db_unlock_database(hDB);
 
   return sor;
#else
   return MJsonNode::MakeNull();
#endif
}
 
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */