28#ifndef DOXYGEN_SHOULD_SKIP_THIS
33#include "git-revision.h"
41#define CHECK_OPEN_RECORD 1
115 while (msg !=
NULL) {
116 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());
139 msg->filename = filename;
141 msg->routine = routine;
173 printf(
"db_flush_msg: %p\n", msg);
177 while (msg !=
NULL) {
223 while (
pfree->size < size &&
pfree->next_free) {
235 if (
pfree->size < size)
269 assert((
void*)
pfound != (
void*)pheader);
284 assert(address != pheader);
305 if (
pprev->next_free <= 0) {
306 cm_msg(
MERROR,
"free_key",
"database is corrupted: pprev=%p, pprev->next_free=%d",
pprev,
pprev->next_free);
385 if (
pfree->size >= size) {
391 if (!
pfree->next_free) {
439 assert((
void*)
pfound != (
void*)pheader);
453 assert(address != pheader);
471 pfree->next_free = 0;
487 if (
pprev->next_free == 0) {
493 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);
605 for (
int i = 0;
list[
i];
i++) {
687 sprintf(
str,
"Database header size is 0x%04X, all following values are offset by this!\n", (
int)
sizeof(
DATABASE_HEADER));
699 add_to_buf(&
buf,
"ODB is corrupted: pheader->first_free_key is invalid\n");
713 sprintf(
str,
"Free block at 0x%08X, size 0x%08X, next 0x%08X\n",
732 add_to_buf(&
buf,
"ODB is corrupted: pheader->first_free_data is invalid\n");
746 sprintf(
str,
"Free block at 0x%08X, size 0x%08X, next 0x%08X\n",
760 sprintf(
str,
"\nFree: %1d (%1.1lf%%) keylist, %1d (%1.1lf%%) data\n",
773 sprintf(
str,
"\nTotal ODB size: %d (0x%08X) Bytes, %lg MiB\n",
803 *key_size +=
pfree->size;
811 *data_size +=
pfree->size;
847 db_msg(msg,
MERROR,
"db_validate_name",
"Invalid name passed to %s: should not be an empty string",
caller_name);
856 if (
name[0] ==
' ') {
861 if (
name[len-1] ==
' ') {
960 db_msg(msg,
MERROR,
caller,
"db_get_pkey: root_key hkey %d invalid key type %d, database root directory is corrupted",
hKey, tid);
966 db_msg(msg,
MERROR,
caller,
"db_get_pkey: hkey %d path \"%s\" invalid key type %d",
hKey, path.c_str(), tid);
973 if (
pkey->name[0] == 0) {
988 db_msg(msg,
MERROR,
caller,
"db_get_pkeylist: hkey %d path \"%s\" unexpected call to db_get_pkeylist(), not a subdirectory, pkey->type %d",
hKey, path.c_str(),
pkey->type);
1020 db_msg(msg,
MERROR,
caller,
"hkey %d path \"%s\" repaired invalid num_keys %d when pkeylist->first_key is zero",
hKey, path.c_str(),
pkeylist->num_keys);
1034 if (
pkey->parent_keylist == 0) {
1064 db_msg(msg,
MERROR,
"db_enum_first_locked",
"hkey %d path \"%s\" tid %d is not a directory",
hKey, path.c_str(),
pkey->type);
1090 if (
pkey->next_key == 0)
1103 if (*((
char *) pheader +
pkey->data) ==
'/') {
1161 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid hkey",
hkey, path);
1167 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", name \"%s\", invalid key type %d",
hkey, path,
pkey->name,
pkey->type);
1176 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\": invalid name \"%s\" replaced with \"%s\"",
hkey, path,
pkey->name,
newname);
1184 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);
1195 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->total_size %d",
hkey, path,
pkey->total_size);
1200 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->item_size: %d",
hkey, path,
pkey->item_size);
1205 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->num_values: %d",
hkey, path,
pkey->num_values);
1210 if (
pkey->total_size !=
pkey->item_size *
pkey->num_values) {
1211 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);
1217 if (
pkey->data == 0 &&
pkey->total_size != 0) {
1218 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);
1219 pkey->num_values = 0;
1220 pkey->total_size = 0;
1225 const char* s = (
char*)pheader +
pkey->data;
1227 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", string value is not valid UTF-8",
hkey, path);
1238 if (
pkey->total_size <= 2) {
1239 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_LINK is an empty link",
hkey, path);
1256 const char*
link = (
char*)pheader +
pkey->data;
1262 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_LINK to \"%s\" is a link to itself",
hkey, path,
link);
1272 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_LINK to \"%s\" is a loop",
hkey, path,
link);
1281 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->access_mode %d",
hkey, path,
pkey->access_mode);
1288 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->last_written time %d",
hkey, path,
pkey->last_written);
1299 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", invalid pkey->data %d",
hkey, path,
pkey->data);
1303 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);
1309 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_KEY invalid pkeylist->num_keys %d",
hkey, path,
pkeylist->num_keys);
1317 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_KEY invalid pkeylist->first_key %d",
hkey, path,
pkeylist->first_key);
1331 db_msg(msg,
MERROR,
"db_validate_key",
"hkey %d, path \"%s\", TID_KEY invalid subhkey %d",
hkey, path,
subhkey);
1353 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);
1370 assert(
pdb->database_header);
1374 int idx =
pdb->client_index;
1377 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);
1385 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);
1393 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);
1418#define S(x) printf("assert(sizeof(%-20s) == %6d);\n", #x, (int)sizeof(x))
1466 printf(
"EQUIPMENT_INFO offset of event_id: %d\n", (
int)((
char*)&
eq.event_id - (
char*)&
eq));
1467 printf(
"EQUIPMENT_INFO offset of eq_type: %d\n", (
int)((
char*)&
eq.eq_type - (
char*)&
eq));
1468 printf(
"EQUIPMENT_INFO offset of event_limit: %d\n", (
int)((
char*)&
eq.event_limit - (
char*)&
eq));
1469 printf(
"EQUIPMENT_INFO offset of num_subevents: %d\n", (
int)((
char*)&
eq.num_subevents - (
char*)&
eq));
1470 printf(
"EQUIPMENT_INFO offset of status: %d\n", (
int)((
char*)&
eq.status - (
char*)&
eq));
1471 printf(
"EQUIPMENT_INFO offset of hidden: %d\n", (
int)((
char*)&
eq.hidden - (
char*)&
eq));
1474 assert(
sizeof(
UINT8) == 1);
1475 assert(
sizeof(
INT8) == 1);
1476 assert(
sizeof(
UINT16) == 2);
1477 assert(
sizeof(
INT16) == 2);
1478 assert(
sizeof(
UINT32) == 4);
1479 assert(
sizeof(
INT32) == 4);
1480 assert(
sizeof(
UINT64) == 8);
1481 assert(
sizeof(
INT64) == 8);
1490 assert(
sizeof(
TAG) == 40);
1491 assert(
sizeof(
KEY) == 68);
1492 assert(
sizeof(
KEYLIST) == 12);
1500 assert(
sizeof(
BANK) == 8);
1501 assert(
sizeof(
BANK32) == 12);
1504 assert(
sizeof(
ALARM) == 460);
1533 for (
k=0;
k<
uorp->num_keys;
k++)
1562 printf(
"%s, notify_count %d, found %d, our count %d\n", path,
pkey->notify_count,
found,
count);
1566 db_msg(msg,
MINFO,
"db_update_open_record",
"Added missing open record flag to \"%s\"", path.c_str());
1568 uorp->num_modified++;
1573 db_msg(msg,
MINFO,
"db_update_open_record",
"Removed open record flag from \"%s\"", path.c_str());
1574 pkey->notify_count = 0;
1575 uorp->num_modified++;
1580 db_msg(msg,
MERROR,
"db_update_open_record",
"Cannot remove exclusive access mode from \"%s\", db_set_mode() status %d", path.c_str(),
status);
1583 db_msg(msg,
MINFO,
"db_update_open_record",
"Removed exclusive access mode from \"%s\"", path.c_str());
1588 if (
pkey->notify_count !=
uorp->counts[
k]) {
1589 db_msg(msg,
MINFO,
"db_update_open_record",
"Updated notify_count of \"%s\" from %d to %d", path.c_str(),
pkey->notify_count,
count);
1591 uorp->num_modified++;
1609 uor.num_modified = 0;
1615 uor.pheader = pheader;
1620 if (
pclient->open_record[
j].handle) {
1622 for (
k=0;
k<
uor.num_keys;
k++) {
1631 uor.counts[
uor.num_keys] = 1;
1639 for (
i=0;
i<
uor.num_keys;
i++)
1640 printf(
"index %d, handle %d, count %d, access mode %d\n",
i,
uor.hkeys[
i],
uor.counts[
i],
uor.modes[
i]);
1649 if (
uor.num_modified) {
1650 db_msg(msg,
MINFO,
"db_validate_open_records",
"Corrected %d ODB entries",
uor.num_modified);
1694 db_msg(msg,
MERROR,
"db_validate_db",
"Warning: database corruption, key area next_free 0x%08X is same as current free %p, truncating the free list",
pfree->next_free,
pfree - (
int)
sizeof(
DATABASE_HEADER));
1695 pfree->next_free = 0;
1706 db_msg(msg,
MERROR,
"db_validate_db",
"Warning: database key area is %.0f%% full",
ratio * 100.0);
1727 db_msg(msg,
MERROR,
"db_validate_db",
"Warning: database corruption, invalid data area next_free 0x%08X",
pfree->next_free - (
int)
sizeof(
DATABASE_HEADER));
1737 db_msg(msg,
MERROR,
"db_validate_db",
"Warning: database corruption, data area next_free 0x%08X is same as current free %p, truncating the free list",
pfree->next_free,
pfree - (
int)
sizeof(
DATABASE_HEADER));
1738 pfree->next_free = 0;
1749 db_msg(msg,
MERROR,
"db_validate_db",
"Warning: database data area is %.0f%% full",
ratio * 100.0);
1767 db_msg(msg,
MERROR,
"db_validate_db",
"Error: ODB corruption detected, see previous messages");
1794#ifdef LOCAL_ROUTINES
1818 cm_msg(
MERROR,
"db_open_database",
"client name \'%s\' is longer than %d characters", client_name,
NAME_LENGTH-1);
1823 cm_msg(
MERROR,
"db_open_database",
"client name \'%s\' should not contain the slash \'/\' character", client_name);
1872 void* shm_adr =
NULL;
1873 size_t shm_size = 0;
1915 pfree->next_free = 0;
1919 pfree->next_free = 0;
1927 pkey->num_values = 1;
1929 strcpy(
pkey->name,
"root");
1930 pkey->parent_keylist = 0;
1955 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);
1961 cm_msg(
MERROR,
"db_open_database",
"Invalid, incompatible or corrupted database: root key offset %d is invalid", pheader->
root_key);
1967 cm_msg(
MERROR,
"db_open_database",
"Invalid, incompatible or corrupted database: root key type %d is not TID_KEY",
pkey->type);
1972 cm_msg(
MERROR,
"db_open_database",
"Invalid, incompatible or corrupted database: root key name \"%s\" is not \"root\"",
pkey->name);
1987 cm_msg(
MERROR,
"db_open_database",
"Invalid, incompatible or corrupted database: root key is invalid");
2030 int num_clients = 0;
2031 int max_client_index = 0;
2036 max_client_index =
i + 1;
2074 cm_msg(
MERROR,
"db_open_database",
"maximum number of clients exceeded");
2095 pclient->num_open_records = 0;
2102 pclient->watchdog_timeout = timeout;
2127 *
hDB = (handle + 1);
2134 cm_msg(
MERROR,
"db_open_database",
"Error: db_validate_open_records() status %d",
status);
2162#ifdef LOCAL_ROUTINES
2168 cm_msg(
MERROR,
"db_close_database",
"invalid database handle %d",
hDB);
2180 if (!
pdb->attached) {
2182 cm_msg(
MERROR,
"db_close_database",
"database not attached");
2193 if (
pclient->open_record[
i].handle)
2270#ifndef DOXYGEN_SHOULD_SKIP_THIS
2297#ifdef LOCAL_ROUTINES
2304 cm_msg(
MERROR,
"db_flush_database",
"invalid database handle");
2317 cm_msg(
MERROR,
"db_flush_database",
"Cannot obtain key /System/Flush/Last flush");
2327 cm_msg(
MERROR,
"db_flush_database",
"invalid database handle");
2394#ifdef LOCAL_ROUTINES
2430#ifdef LOCAL_ROUTINES
2433 cm_msg(
MERROR,
"db_set_client_name",
"invalid database handle %d",
hDB);
2462#ifdef LOCAL_ROUTINES
2466 cm_msg(
MERROR,
"db_lock_database",
"invalid database handle %d, aborting...",
hDB);
2480 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");
2506 cm_msg(
MERROR,
"db_lock_database",
"cannot lock ODB semaphore, timeout %d ms, aborting...",
_database[
hDB - 1].timeout);
2511 cm_msg(
MERROR,
"db_lock_database",
"cannot lock ODB semaphore, timeout %d ms, ss_semaphore_wait_for() status %d, aborting...",
_database[
hDB - 1].timeout,
status);
2518#ifdef CHECK_LOCK_COUNT
2534 cm_msg(
MERROR,
"db_lock_database",
"cannot lock ODB, ss_shm_unprotect(TRUE,FALSE) failed with status %d, aborting...",
status);
2552#ifdef LOCAL_ROUTINES
2563 cm_msg(
MERROR,
"db_allow_write_locked",
"cannot write to ODB, ss_shm_unprotect(TRUE,TRUE) failed with status %d, aborting...",
status);
2584#ifdef LOCAL_ROUTINES
2587 cm_msg(
MERROR,
"db_unlock_database",
"invalid database handle %d",
hDB);
2590#ifdef CHECK_LOCK_COUNT
2601 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");
2624 cm_msg(
MERROR,
"db_unlock_database",
"cannot unlock ODB, ss_shm_protect() failed with status %d, aborting...",
status);
2649#ifdef LOCAL_ROUTINES
2656 cm_msg(
MERROR,
"db_get_lock_cnt",
"invalid database handle %d, aborting...",
hDB);
2657 fprintf(
stderr,
"db_get_lock_cnt: invalid database handle %d, aborting...\n",
hDB);
2671#ifdef LOCAL_ROUTINES
2678 cm_msg(
MERROR,
"db_set_lock_timeout",
"invalid database handle %d",
hDB);
2692#ifdef LOCAL_ROUTINES
2720 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...");
2729#ifdef LOCAL_ROUTINES
2739 if (
pkey->notify_count > 0)
2764#ifdef LOCAL_ROUTINES
2798#ifdef LOCAL_ROUTINES
2800 cm_msg(
MERROR,
"db_delete_client_info",
"invalid database handle");
2805 cm_msg(
MERROR,
"db_delete_client_info",
"invalid database handle");
2834#ifdef LOCAL_ROUTINES
2868 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);
2882 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)",
2900#ifdef LOCAL_ROUTINES
2928 if (
j ==
pdb->client_index)
2932 if ((client_name ==
NULL || client_name[0] == 0
2937 db_msg(&msg,
MINFO,
"db_cleanup2",
"Client \'%s\' on database \'%s\' pid %d does not exist and db_cleanup2 called by %s removed it",
2959 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)",
2990 if (!
pdb->attached) {
3000 pclient->watchdog_timeout = timeout;
3022 cm_msg(
MERROR,
"db_get_watchdog_info",
"invalid database handle");
3027 cm_msg(
MERROR,
"db_get_watchdog_info",
"invalid database handle");
3048 *timeout = *
last = 0;
3067 cm_msg(
MERROR,
"db_check_client",
"invalid database handle");
3072 cm_msg(
MERROR,
"db_check_client",
"invalid database handle");
3107 int size =
sizeof(
name);
3148 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);
3150 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);
3177#ifdef LOCAL_ROUTINES
3179 cm_msg(
MERROR,
"db_protect_database",
"invalid database handle %d",
hDB);
3252 if(pattern[1] == 0)
return true;
3290 while (*
pc !=
'.' && *
pc !=
'-')
3292 while (*
pc ==
'.' || *
pc ==
'-')
3319#ifdef LOCAL_ROUTINES
3324 cm_msg(
MERROR,
"db_create_key",
"invalid database handle");
3329 cm_msg(
MERROR,
"db_create_key",
"invalid database handle");
3367#ifdef LOCAL_ROUTINES
3485 pkey->num_values = 1;
3528 pkey->num_values = 1;
3535 if (
pkey->item_size > 0) {
3538 pkey->total_size = 0;
3543 pkey->total_size =
pkey->item_size;
3547 pkey->item_size = 0;
3548 pkey->total_size = 0;
3567 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_locked(pheader,
pitem).
c_str(), key_name,
type,
db_get_path_locked(pheader,
parentKey).
c_str());
3579 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_locked(pheader,
pitem).
c_str(), key_name,
db_get_path_locked(pheader,
parentKey).
c_str());
3615 cm_msg(
MERROR,
"db_create_link",
"link destination name is NULL");
3620 cm_msg(
MERROR,
"db_create_link",
"link destination name \'%s\' should start with \'/\', relative links are forbidden",
destination);
3630 cm_msg(
MERROR,
"db_create_link",
"links to \"/\" are forbidden");
3676#ifdef LOCAL_ROUTINES
3687 cm_msg(
MERROR,
"db_delete_key1",
"invalid database handle");
3692 cm_msg(
MERROR,
"db_delete_key1",
"invalid database handle");
3697 cm_msg(
MERROR,
"db_delete_key1",
"invalid key handle");
3721#ifdef CHECK_OPEN_RECORD
3722 if (
pkey->notify_count) {
3728 if (
pkey->parent_keylist == 0)
3767 cm_msg(
MERROR,
"db_delete_key1",
"try to delete cyclic link");
3780 if (
pkey->parent_keylist == 0) {
3793#ifdef CHECK_OPEN_RECORD
3794 if (
pkey->notify_count) {
3806 free_data(pheader, (
char *) pheader +
pkey->data,
pkey->total_size,
"db_delete_key1");
3869#ifdef LOCAL_ROUTINES
3884 db_msg(msg,
MERROR,
"db_find_key",
"hkey %d path \"%s\" tid %d is not a directory, looking for \"%s\"",
hKey, path.c_str(), tid, key_name);
3890 if (key_name[0] == 0 ||
strcmp(key_name,
"/") == 0) {
3923 if (
pkey->parent_keylist) {
3950 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);
3956 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);
3965 if (
pkey->next_key == 0) {
4089#ifdef LOCAL_ROUTINES
4097 cm_msg(
MERROR,
"db_find_key",
"invalid database handle");
4102 cm_msg(
MERROR,
"db_find_key",
"invalid database handle");
4127#ifndef DOXYGEN_SHOULD_SKIP_THIS
4156#ifdef LOCAL_ROUTINES
4167 cm_msg(
MERROR,
"db_find_key",
"invalid database handle");
4172 cm_msg(
MERROR,
"db_find_key",
"invalid database handle");
4194 if (key_name[0] == 0 ||
strcmp(key_name,
"/") == 0) {
4214 if (
pkey->parent_keylist) {
4233 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
4244 strcpy(
str, (
char *) pheader +
pkey->data);
4309#ifdef LOCAL_ROUTINES
4320 cm_msg(
MERROR,
"db_find_link",
"Invalid database handle");
4325 cm_msg(
MERROR,
"db_find_link",
"invalid database handle");
4350 if (key_name[0] == 0 ||
strcmp(key_name,
"/") == 0) {
4372 if (
pkey->parent_keylist) {
4398 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
4410 strcpy(
str, (
char *) pheader +
pkey->data);
4470#ifdef LOCAL_ROUTINES
4481 cm_msg(
MERROR,
"db_find_link",
"Invalid database handle");
4486 cm_msg(
MERROR,
"db_find_link",
"invalid database handle");
4507 if (key_name[0] == 0 ||
strcmp(key_name,
"/") == 0) {
4526 if (
pkey->parent_keylist) {
4542 cm_msg(
MERROR,
"db_find_link1",
"Warning: database corruption, key \"%s\", next_key 0x%08X is invalid", key_name,
pkey->next_key - (
int)
sizeof(
DATABASE_HEADER));
4550 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
4561 strcpy(
str, (
char *) pheader +
pkey->data);
4618 char *pattern =
NULL;
4667 for (
int i=0 ; ;
i++)
4726#ifdef LOCAL_ROUTINES
4733 cm_msg(
MERROR,
"db_get_parent",
"invalid database handle");
4738 cm_msg(
MERROR,
"db_get_parent",
"invalid database handle");
4826#ifdef LOCAL_ROUTINES
4904#ifdef LOCAL_ROUTINES
4908 std::string path =
"";
4915 sprintf(buf,
"(INVALID_KEY_TYPE_%d)",
pkey->type);
4918 if (path.length() > 0) {
4926 std::string
str = path;
4928 if (
pkey->name[0] == 0) {
4929 path +=
"(EMPTY_NAME)";
4933 if (
str.length() > 0)
4937 if (!
pkey->parent_keylist) {
4942 return "(INVALID_PARENT_KEYLIST)/" + path;
4953 return "(NULL_PARENT)/" + path;
4957 return "(INVALID_PARENT)/" + path;
4980 return "(ZERO_HKEY)";
4985 return "(INVALID_HKEY)";
5022#ifdef LOCAL_ROUTINES
5027 cm_msg(
MERROR,
"db_get_path",
"invalid database handle");
5032 cm_msg(
MERROR,
"db_get_path",
"invalid database handle");
5078#ifdef LOCAL_ROUTINES
5083 cm_msg(
MERROR,
"db_get_path",
"invalid database handle");
5084 return "(DB_INVALID_HANDLE)";
5088 cm_msg(
MERROR,
"db_get_path",
"invalid database handle");
5089 return "(DB_INVALID_HANDLE)";
5104 return "(no LOCAL_ROUTINES)";
5107#ifdef LOCAL_ROUTINES
5138 line +=
" a deleted client";
5143 std::string *result = (std::string*)
xresult;
5153 std::string *result = (std::string*)
xresult;
5184 *result +=
" fixed\n";
5223#ifdef LOCAL_ROUTINES
5272#ifdef LOCAL_ROUTINES
5276 if (num_values == 0)
5304#ifdef LOCAL_ROUTINES
5309 if (num_values == 0)
5320 if (data_size == 0) {
5321 db_msg(msg,
MERROR,
"db_set_value",
"zero data size not allowed");
5326 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);
5425#ifdef LOCAL_ROUTINES
5449 if (*p && *p ==
']') {
5510#ifdef LOCAL_ROUTINES
5532 if ((
idx == -1 &&
pkey->num_values *
pkey->item_size > *buf_size) || (
idx != -1 &&
pkey->item_size > *buf_size)) {
5534 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_locked(pheader,
pkey).
c_str(),
pkey->num_values *
pkey->item_size,
pkey->num_values,
pkey->item_size, *buf_size);
5547 *buf_size =
pkey->num_values *
pkey->item_size;
5550 *buf_size =
pkey->item_size;
5596#ifdef LOCAL_ROUTINES
5604 cm_msg(
MERROR,
"db_enum_key",
"invalid database handle");
5609 cm_msg(
MERROR,
"db_enum_key",
"invalid database handle");
5669 for (
i = 0;
i <
idx;
i++) {
5670 if (
pkey->next_key == 0) {
5673 cm_msg(
MERROR,
"db_enum_key",
"hkey %d path \"%s\" unexpected end of key list at index %d",
hKey, path.c_str(),
i);
5683 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);
5690 strcpy(
str, (
char *) pheader +
pkey->data);
5705 if (
pkey->parent_keylist) {
5726#ifndef DOXYGEN_SHOULD_SKIP_THIS
5760#ifdef LOCAL_ROUTINES
5768 cm_msg(
MERROR,
"db_enum_link",
"invalid database handle");
5773 cm_msg(
MERROR,
"db_enum_link",
"invalid database handle");
5807 for (
i = 0;
i <
idx;
i++) {
5809 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
5847#ifdef LOCAL_ROUTINES
5855 cm_msg(
MERROR,
"db_enum_link",
"invalid database handle");
5860 cm_msg(
MERROR,
"db_enum_link",
"invalid database handle");
5884 if (
pkey->next_key) {
5887 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
5898 if (
pkey->parent_keylist == 0) {
5945#ifdef LOCAL_ROUTINES
6029#ifdef LOCAL_ROUTINES
6035 cm_msg(
MERROR,
"db_get_key",
"invalid database handle");
6040 cm_msg(
MERROR,
"db_get_key",
"invalid database handle");
6082#ifdef LOCAL_ROUTINES
6087 cm_msg(
MERROR,
"db_get_link",
"invalid database handle");
6092 cm_msg(
MERROR,
"db_get_link",
"invalid database handle");
6142#ifdef LOCAL_ROUTINES
6148 cm_msg(
MERROR,
"db_get_key",
"invalid database handle");
6153 cm_msg(
MERROR,
"db_get_key",
"invalid database handle");
6201#ifdef LOCAL_ROUTINES
6208 cm_msg(
MERROR,
"db_get_key_info",
"invalid database handle");
6213 cm_msg(
MERROR,
"db_get_key_info",
"invalid database handle");
6218 cm_msg(
MERROR,
"db_get_key_info",
"invalid key handle");
6246 *num_values =
pkey->num_values;
6247 *item_size =
pkey->item_size;
6262#ifndef DOXYGEN_SHOULD_SKIP_THIS
6291#ifdef LOCAL_ROUTINES
6298 cm_msg(
MERROR,
"db_rename_key",
"invalid database handle");
6303 cm_msg(
MERROR,
"db_rename_key",
"invalid database handle");
6325 cm_msg(
MERROR,
"db_rename_key",
"key name is too short");
6330 cm_msg(
MERROR,
"db_rename_key",
"key name may not contain \"/\"");
6393#ifdef LOCAL_ROUTINES
6401 cm_msg(
MERROR,
"db_rename_key",
"invalid database handle");
6406 cm_msg(
MERROR,
"db_rename_key",
"invalid database handle");
6441#ifdef CHECK_OPEN_RECORD
6442 if (
pkey->notify_count) {
6447 if (
pkey->parent_keylist == 0)
6498 for (
i = 0;
i <
idx - 1;
i++) {
6549#ifdef LOCAL_ROUTINES
6554 cm_msg(
MERROR,
"db_get_data",
"Invalid database handle");
6559 cm_msg(
MERROR,
"db_get_data",
"invalid database handle");
6595 if (pos == std::string::npos) {
6666#ifdef LOCAL_ROUTINES
6672 cm_msg(
MERROR,
"db_get_data",
"Invalid database handle");
6677 cm_msg(
MERROR,
"db_get_data",
"invalid database handle");
6723 cm_msg(
MERROR,
"db_get_data",
"Key cannot contain data");
6728 if (
pkey->data == 0) {
6736 if (
pkey->num_values *
pkey->item_size > *buf_size) {
6741 cm_msg(
MERROR,
"db_get_data",
"data for key \"%s\" truncated from %d to %d bytes", path.c_str(),
pkey_size, *buf_size);
6747 *buf_size =
pkey->num_values *
pkey->item_size;
6758#ifndef DOXYGEN_SHOULD_SKIP_THIS
6790#ifdef LOCAL_ROUTINES
6796 cm_msg(
MERROR,
"db_get_data",
"Invalid database handle");
6801 cm_msg(
MERROR,
"db_get_data",
"invalid database handle");
6847 cm_msg(
MERROR,
"db_get_data",
"Key cannot contain data");
6852 if (
pkey->data == 0) {
6860 if (
pkey->num_values *
pkey->item_size > *buf_size) {
6865 cm_msg(
MERROR,
"db_get_data",
"data for key \"%s\" truncated from %d to %d bytes", path.c_str(),
pkey_size, *buf_size);
6871 *buf_size =
pkey->num_values *
pkey->item_size;
6872 *num_values =
pkey->num_values;
6903#ifdef LOCAL_ROUTINES
6909 cm_msg(
MERROR,
"db_get_data",
"Invalid database handle");
6914 cm_msg(
MERROR,
"db_get_data",
"invalid database handle");
6960 cm_msg(
MERROR,
"db_get_data_index",
"Key cannot contain data");
6965 if (
pkey->data == 0) {
6984 if (
pkey->item_size > *buf_size) {
6990 cm_msg(
MERROR,
"db_get_data_index",
"data for key \"%s\" truncated from %d to %d bytes", path.c_str(),
pkey_size, *buf_size);
6996 *buf_size =
pkey->item_size;
7006#ifdef LOCAL_ROUTINES
7023 data_size =
pkey->item_size * num_values;
7026 if (
pkey->total_size != data_size) {
7030 if (
pkey->data == 0) {
7031 pkey->total_size = 0;
7037 pkey->total_size = data_size;
7041 pkey->num_values = num_values;
7044 pkey->item_size = data_size / num_values;
7065 if (
idx >=
pkey->num_values ||
pkey->item_size == 0) {
7069 if (
pkey->data == 0) {
7070 pkey->total_size = 0;
7071 pkey->num_values = 0;
7077 if (!
pkey->item_size)
7078 pkey->item_size = data_size;
7079 pkey->total_size = data_size * (
idx + 1);
7086 *((
char *)
data +
pkey->item_size - 1) = 0;
7125 if (num_values > 1) {
7126 int item_size =
pkey->item_size;
7127 if (data_size > 0 && num_values > 0)
7128 item_size = data_size/num_values;
7130 for (
int i=0;
i<num_values;
i++) {
7131 const char*
value = ((
const char*)
data) +
i * item_size;
7190 if (
pkey->item_size != 0 && data_size !=
pkey->item_size) {
7225#ifdef LOCAL_ROUTINES
7235 cm_msg(
MERROR,
"db_set_data",
"invalid database handle");
7240 cm_msg(
MERROR,
"db_set_data",
"invalid database handle");
7249 if (num_values == 0)
7328#ifdef LOCAL_ROUTINES
7338 cm_msg(
MERROR,
"db_set_data1",
"invalid database handle");
7343 cm_msg(
MERROR,
"db_set_data1",
"invalid database handle");
7352 if (num_values == 0)
7435#ifdef LOCAL_ROUTINES
7442 cm_msg(
MERROR,
"db_set_data",
"invalid database handle");
7447 cm_msg(
MERROR,
"db_set_data",
"invalid database handle");
7456 if (num_values == 0)
7504#ifndef DOXYGEN_SHOULD_SKIP_THIS
7531#ifdef LOCAL_ROUTINES
7538 cm_msg(
MERROR,
"db_set_num_values",
"invalid database handle");
7543 cm_msg(
MERROR,
"db_set_num_values",
"invalid database handle");
7548 cm_msg(
MERROR,
"db_set_num_values",
"invalid key handle");
7552 if (num_values <= 0) {
7553 cm_msg(
MERROR,
"db_set_num_values",
"invalid num_values %d", num_values);
7557 if (num_values == 0)
7582 cm_msg(
MERROR,
"db_set_num_values",
"Key cannot contain data");
7586 if (
pkey->total_size !=
pkey->item_size *
pkey->num_values) {
7592 if (
pkey->item_size == 0) {
7594 cm_msg(
MERROR,
"db_set_num_values",
"Cannot resize array with item_size equal to zero");
7601 if (
pkey->num_values != num_values) {
7606 if (
pkey->data == 0) {
7607 pkey->total_size = 0;
7608 pkey->num_values = 0;
7618 pkey->num_values = num_values;
7658#ifdef LOCAL_ROUTINES
7668 cm_msg(
MERROR,
"db_set_data_index",
"invalid database handle");
7673 cm_msg(
MERROR,
"db_set_data_index",
"invalid database handle");
7678 cm_msg(
MERROR,
"db_set_data_index",
"invalid key handle");
7764#ifdef LOCAL_ROUTINES
7771 cm_msg(
MERROR,
"db_set_link_data_index",
"invalid database handle");
7776 cm_msg(
MERROR,
"db_set_link_data_index",
"invalid database handle");
7781 cm_msg(
MERROR,
"db_set_link_data_index",
"invalid key handle");
7830#ifndef DOXYGEN_SHOULD_SKIP_THIS
7864#ifdef LOCAL_ROUTINES
7871 cm_msg(
MERROR,
"db_set_data_index1",
"invalid database handle");
7876 cm_msg(
MERROR,
"db_set_data_index1",
"invalid database handle");
7881 cm_msg(
MERROR,
"db_set_data_index1",
"invalid key handle");
7962 if (num_values == 0)
7981#ifdef LOCAL_ROUTINES
8061#ifdef LOCAL_ROUTINES
8067 cm_msg(
MERROR,
"db_set_mode",
"invalid database handle");
8072 cm_msg(
MERROR,
"db_set_mode",
"invalid database handle");
8143 cm_msg(
MERROR,
"db_load",
"file \"%s\" not found", filename);
8150 buffer = (
char *)
malloc(size + 1);
8152 if (buffer ==
NULL) {
8153 cm_msg(
MERROR,
"db_load",
"cannot allocate ODB load buffer");
8169 if (
strncmp(buffer,
"<?xml version=\"1.0\"", 19) == 0) {
8172 printf(
"Error in file \"%s\"\n", filename);
8173 }
else if( buffer[0] ==
'{'){
8248 cm_msg(
MERROR,
"db_copy",
"cannot allocate data buffer");
8265 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8270 strcpy(buffer, line);
8272 *buffer_size -=
strlen(line);
8280 strcpy(buffer,
data);
8284 strcpy(line,
"\n====#$@$#====\n");
8306 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8311 strcpy(buffer, line);
8313 *buffer_size -=
strlen(line);
8320 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8325 strcpy(buffer, line);
8327 *buffer_size -=
strlen(line);
8345 cm_msg(
MERROR,
"db_copy",
"cannot allocate data buffer");
8356 if (*buffer_size < 2) {
8361 strcpy(buffer,
"\n");
8378 buffer +=
strlen(buffer);
8389 sprintf(line,
"[%s]\n", path);
8404 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8409 strcpy(buffer, line);
8411 *buffer_size -=
strlen(line);
8419 strcpy(buffer,
data);
8423 strcpy(line,
"\n====#$@$#====\n");
8445 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8450 strcpy(buffer, line);
8452 *buffer_size -=
strlen(line);
8458 if ((
INT) (
strlen(line) + 1) > *buffer_size) {
8463 strcpy(buffer, line);
8465 *buffer_size -=
strlen(line);
8473 if (*buffer_size < 2)
8476 strcpy(buffer,
"\n");
8513 cm_msg(
MERROR,
"db_paste",
"cannot allocate data buffer");
8524 line[
i] = *buffer++;
8528 cm_msg(
MERROR,
"db_paste",
"line too long: %s...", line);
8534 if (*buffer ==
'\n')
8538 if (line[0] ==
'[') {
8540 mstrlcpy(title, line + 1,
sizeof(title));
8543 if (title[0] && title[
strlen(title) - 1] !=
'/')
8544 mstrlcat(title,
"/",
sizeof(title));
8547 if (
strchr(line,
'=') && line[0] !=
';') {
8560 while (*
pline ==
' ')
8570 while (*
pline ==
' ')
8574 if (title[0] !=
'.')
8575 mstrlcpy(key_name, title,
sizeof(key_name));
8577 mstrlcat(key_name, line,
sizeof(key_name));
8590 for (tid = 0; tid <
TID_LAST; tid++)
8594 for (tid = 0; tid <
TID_LAST; tid++)
8602 cm_msg(
MERROR,
"db_paste",
"found unknown data type \"%s\" in ODB file", line);
8606 while (*
pc !=
' ' && *
pc)
8608 while ((*
pc ==
' ' || *
pc ==
':') && *
pc)
8620 for (
j = 0; *buffer !=
'\n' && *buffer;
j++)
8623 if (*buffer ==
'\n')
8627 for (
i = 0;
i < n_data;
i++) {
8630 while (*
pc ==
'\n' || *
pc ==
'\r')
8641 cm_msg(
MERROR,
"db_paste",
"found string exceeding MAX_STRING_LENGTH, odb path \"%s\"", key_name);
8645 cm_msg(
MERROR,
"db_paste",
"found string length of zero, set to 32, odb path \"%s\"", key_name);
8651 if (
strstr(buffer,
"\n====#$@$#====\n") !=
NULL) {
8658 cm_msg(
MERROR,
"db_paste",
"cannot allocate data buffer");
8666 buffer =
strstr(buffer,
"\n====#$@$#====\n") +
strlen(
"\n====#$@$#====\n");
8668 cm_msg(
MERROR,
"db_paste",
"found multi-line string without termination sequence");
8671 while (*
pc && *
pc !=
' ')
8686 cm_msg(
MERROR,
"db_paste",
"cannot allocate data buffer");
8696 if (n_data > 1 &&
data_str[0] ==
'[') {
8699 while (*
pc && *
pc ==
' ')
8709 cm_msg(
MERROR,
"db_paste",
"cannot allocate data buffer");
8717 if (
i < n_data - 1) {
8724 for (
j = 0; *buffer !=
'\n' && *buffer;
j++)
8727 if (*buffer ==
'\n')
8749 if (key_name[0] ==
'/') {
8809 cm_msg(
MINFO,
"db_paste_node",
"cannot load key \"%s\": write protected",
name);
8856 cm_msg(
MERROR,
"db_paste_node",
"found unknown data type \"%s\" in XML data",
type);
8865 cm_msg(
MINFO,
"db_paste_node",
"cannot load key \"%s\": write protected",
name);
8900 buf = (
char *)
malloc(size);
9021 puts(
"Cannot find element \"odb\" in XML data");
9048#ifdef LOCAL_ROUTINES
9056 if (writer ==
NULL) {
9057 cm_msg(
MERROR,
"db_copy_xml",
"Cannot allocate buffer");
9083 if (len > *buffer_size) {
9099#ifndef DOXYGEN_SHOULD_SKIP_THIS
9111 if (*
str >=
'0' && *
str <=
'9')
9115 if (!(*
str >=
'a' && *
str <=
'z') && !(*
str >=
'A' && *
str <=
'Z') && !(*
str >=
'0' && *
str <=
'9'))
9165 strcpy(line,
"char");
9168 strcpy(line,
"short");
9171 strcpy(line,
"float");
9174 strcpy(line,
"double");
9177 strcpy(line,
"unsigned char");
9180 strcpy(line,
"char");
9183 strcpy(line,
"char");
9200 mstrlcat(line,
";\n",
sizeof(line));
9255#ifdef LOCAL_ROUTINES
9263 cm_msg(
MERROR,
"db_save",
"Cannot open file \"%s\"", filename);
9269 buffer_size = 10000;
9271 buffer = (
char *)
malloc(buffer_size);
9272 if (buffer ==
NULL) {
9273 cm_msg(
MERROR,
"db_save",
"cannot allocate ODB dump buffer");
9284 if (
n != buffer_size - size) {
9313 dst = (
char *)
malloc(size);
9336 if ((
int)
strlen(dst) >= size) {
9414 cm_msg(
MERROR,
"db_save_xml_key",
"cannot allocate data buffer");
9428 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());
9455 cm_msg(
MERROR,
"db_save_xml_key",
"Long odb string array probably truncated, odb path \"%s\"[%d]", path.c_str(),
i);
9487#ifdef LOCAL_ROUTINES
9494 if (writer ==
NULL) {
9495 cm_msg(
MERROR,
"db_save_xml",
"Cannot open file \"%s\"", filename);
9559 (*buffer)[(*buffer_end)++] =
' ';
9642 if (
comma !=
nullptr) {
9696 float flt = (*(
float*)p);
9704 }
else if (
flt == 0)
9706 else if (
flt == (
int)
flt) {
9718 double dbl = (*(
double*)p);
9726 }
else if (
dbl == 0)
9728 else if (
dbl == (
int)
dbl) {
9869 else if (
level > 0) {
9882 cm_msg(
MERROR,
"db_save_json_key",
"max nesting level exceeded at \"%s\", check for symlink loops in this subtree", path.c_str());
9997 cm_msg(
MERROR,
"db_save_json_key",
"cannot allocate data buffer for %d bytes", size);
10062 float flt = (*(
float*)p);
10070 }
else if (
flt == 0)
10072 else if (
flt == (
int)
flt) {
10082 double dbl = (*(
double*)p);
10090 }
else if (
dbl == 0)
10092 else if (
dbl == (
int)
dbl) {
10181 cm_msg(
MERROR,
"db_save_json_key_data",
"cannot allocate data buffer for %d bytes",
asize);
10317 mstrlcat(buf,
"/name",
sizeof(buf));
10327 mstrlcat(buf,
"/key",
sizeof(buf));
10335 mstrlcat(buf,
"/last_written",
sizeof(buf));
10362 cm_msg(
MERROR,
"json_write_bare_subdir",
"Max ODB subdirectory nesting level exceeded %d",
level);
10366 for (
int i=0; ;
i++) {
10429 bool unlock =
false;
10461 bool unlock =
false;
10483 bool unlock =
false;
10537 FILE *
fp =
fopen(filename,
"w");
10543 bool unlock =
false;
10562 char* buffer =
NULL;
10563 int buffer_size = 0;
10635 char str[100], line[10+100];
10653 sprintf(line,
"typedef struct {\n");
10690#ifndef DOXYGEN_SHOULD_SKIP_THIS
10718 char str[256], line[50+256];
10720 char *buffer =
NULL, *
pc;
10747 sprintf(line,
"#define %s(_name) const char *_name[] = {\\\n",
str);
10758 buffer_size = 10000;
10760 buffer = (
char *)
malloc(buffer_size);
10761 if (buffer ==
NULL) {
10762 cm_msg(
MERROR,
"db_save",
"cannot allocate ODB dump buffer");
10766 size = buffer_size;
10783 while (*
pc !=
'\n' && *
pc != 0) {
10784 if (*
pc ==
'\"' || *
pc ==
'\'')
10788 strcpy(&line[
i],
"\",\\\n");
10851 if (data_size == 0)
10905 sprintf(
string,
"<unknown>");
10927 if (data_size == 0)
10981 sprintf(
string,
"<unknown>");
11011 if (data_size == 0)
11065 sprintf(
string,
"<unknown>");
11095 if (data_size == 0) {
11149 return (((
char *)
data) + data_size *
idx);
11151 return "<unknown>";
11171 if (data_size == 0) {
11225 return (((
char *)
data) + data_size *
idx);
11227 return "<unknown>";
11233#ifndef DOXYGEN_SHOULD_SKIP_THIS
11258 if (data_size == 0) {
11312 return (((
char *)
data) + data_size *
idx);
11314 return "<unknown>";
11443#ifdef LOCAL_ROUTINES
11492 corr =
VALIGN(*total_size, align) - *total_size;
11493 *total_size +=
corr;
11495 *
data = (
void *) ((
char *) (*data) +
corr);
11498 size =
pkey->item_size *
pkey->num_values;
11508 if (convert_flags) {
11509 if (
pkey->num_values > 1)
11528 if (convert_flags) {
11529 if (
pkey->num_values > 1)
11532 pkey->item_size *
pkey->num_values, convert_flags);
11542 *total_size += size;
11554 corr =
VALIGN(*total_size, align) - *total_size;
11555 *total_size +=
corr;
11557 *
data = (
void *) ((
char *) (*data) +
corr);
11562 corr =
VALIGN(*total_size, align) - *total_size;
11563 *total_size +=
corr;
11565 *
data = (
void *) ((
char *) (*data) +
corr);
11573 if (!
pkey->next_key)
11577 pkey = (
KEY *) ((
char *) pheader +
pkey->next_key);
11627#ifdef LOCAL_ROUTINES
11721#ifdef LOCAL_ROUTINES
11728 if (
data && buf_size) {
11751 cm_msg(
MERROR,
"db_get_record",
"struct size mismatch for \"%s\" (expected size: %d, size in ODB: %d * %d = %d)",
11758 if (convert_flags) {
11770 if (total_size != *buf_size) {
11814 int size = *buf_size;
11829 cm_msg(
MINFO,
"db_get_record1",
"Fixing ODB \"%s\" struct size mismatch (expected %d, odb size %d)", path.c_str(), size,
odb_size);
11859 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());
11865 cm_msg(
MERROR,
"db_get_record1",
"repaired struct size mismatch of \"%s\"", path.c_str());
11905 char* p =
strchr(title,
']');
11909 int len =
strlen(title);
11911 if (title[len - 1] !=
'/')
11946 cm_msg(
MERROR,
"db_parse_record",
"do not see \'=\'");
11979 if (s ==
' ')
break;
11980 if (s ==
'\n')
break;
11981 if (s ==
'[')
break;
11998 cm_msg(
MERROR,
"db_parse_record",
"do not see \':\'");
12013 cm_msg(
MERROR,
"db_parse_record",
"do not see closing bracket \']\'");
12024 cm_msg(
MERROR,
"db_parse_record",
"do not see \':\'");
12059 assert(n_data > 0);
12066 *(*buf_ptr) = 0xFF;
12072 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);
12083 cm_msg(
MERROR,
"db_get_record2",
"cannot read \"%s\", db_get_value() status %d", key_name,
status);
12094 for (
i=0;
i<n_data;
i++) {
12097 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);
12107 cm_msg(
MERROR,
"db_get_record2",
"string key \"%s\" index %d, string value was truncated", key_name,
i);
12109 cm_msg(
MERROR,
"db_get_record2",
"cannot read string \"%s\"[%d], db_get_value() status %d", key_name,
i,
status);
12120 cm_msg(
MERROR,
"db_get_record2",
"cannot read key \"%s\" of unsupported type %d", key_name, tid);
12180 printf(
"db_get_record2!\n");
12226 if (key_name[0] == 0) {
12233 cm_msg(
MERROR,
"db_get_record2",
"error: cannot continue reading odb record because of previous fatal error, status %d",
status);
12245 for (
i=0;
i<
rs;
i++) {
12254 printf(
"db_get_record2: check ok\n");
12305#ifdef LOCAL_ROUTINES
12332 if (convert_flags) {
12345 if (total_size != buf_size) {
12368#ifndef DOXYGEN_SHOULD_SKIP_THIS
12383#ifdef LOCAL_ROUTINES
12389 cm_msg(
MERROR,
"db_add_open_record",
"invalid database handle");
12415 if (
pclient->open_record[
i].handle == 0)
12440 pclient->open_record[
i].access_mode = access_mode;
12443 pkey->notify_count++;
12458#ifdef LOCAL_ROUTINES
12483 if (
pkey->notify_count > 0)
12496 for (
i =
pclient->max_index - 1;
i >= 0;
i--)
12497 if (
pclient->open_record[
i].handle != 0)
12520#ifdef LOCAL_ROUTINES
12523 cm_msg(
MERROR,
"db_remove_open_record",
"invalid database handle %d",
hDB);
12545#ifdef LOCAL_ROUTINES
12573 if (
pkey->notify_count)
12584 if (
pkey->parent_keylist == 0 || !
bWalk)
12611 cm_msg(
MERROR,
"db_notify_clients",
"db_notify_clients() does not work in remotely connected MIDAS clients");
12615#ifdef LOCAL_ROUTINES
12647#ifdef LOCAL_ROUTINES
12744 if (
pkey->notify_count)
12810 char str[256], key_name[256], *buffer;
12822 if (
strlen(key_name) > 1 && key_name[
strlen(key_name) - 1] ==
'/')
12823 key_name[
strlen(key_name) - 1] = 0;
12829#ifdef CHECK_OPEN_RECORD
12869 buffer_size = 10000;
12870 buffer = (
char *)
malloc(buffer_size);
12872 size = buffer_size;
12875 buffer_size += 10000;
12876 buffer = (
char *)
realloc(buffer, buffer_size);
12877 assert(buffer !=
NULL);
12913 size = buffer_size;
12916 buffer_size += 10000;
12917 buffer = (
char *)
realloc(buffer, buffer_size);
12956 cm_msg(
MERROR,
"db_create_record",
"aborting on unexpected failure of db_find_key(%s), status %d", key_name,
status);
13045 if (line[0] ==
'[') {
13047 strcpy(title, line + 1);
13049 *
strchr(title,
']') = 0;
13050 if (title[0] && title[
strlen(title) - 1] !=
'/')
13054 if (
strchr(line,
'=') && line[0] !=
';') {
13068 mstrlcpy(key_name, line,
sizeof(key_name));
13076 if (
strchr(line,
'[')) {
13081 for (tid = 0; tid <
TID_LAST; tid++)
13085 for (tid = 0; tid <
TID_LAST; tid++)
13093 cm_msg(
MERROR,
"db_check_record",
"found unknown data type \"%s\" in ODB file", line);
13097 while (*
pc !=
' ' && *
pc)
13099 while ((*
pc ==
' ' || *
pc ==
':') && *
pc)
13114 for (
i = 0;
i < n_data;
i++) {
13117 while (*
pc ==
'\n' || *
pc ==
'\r')
13133 cm_msg(
MERROR,
"db_check_record",
"found string exceeding MAX_STRING_LENGTH");
13144 cm_msg(
MERROR,
"db_check_record",
"found multi-line string without termination sequence");
13150 while (*
pc && *
pc !=
' ')
13152 while (*
pc && *
pc ==
' ')
13161 if (n_data > 1 &&
info_str[0] ==
'[') {
13163 while (*
pc && *
pc ==
' ')
13168 if (
i < n_data - 1) {
13301 WORD access_mode,
void (*dispatcher) (
INT,
INT,
void *),
void *
info)
13313 cm_msg(
MERROR,
"db_open_record",
"not enough memory");
13329 cm_msg(
MERROR,
"db_open_record",
"not enough memory");
13345 cm_msg(
MERROR,
"db_open_record",
"cannot get record size, db_get_record_size() status %d",
status);
13352 cm_msg(
MERROR,
"db_open_record",
"struct size mismatch for \"%s\" (expected size: %d, size in ODB: %d)", path.c_str(),
rec_size, size);
13369 cm_msg(
MERROR,
"db_open_record",
"not enough memory, malloc(%d) returned NULL", size);
13375 *((
void **) ptr) =
data;
13385 cm_msg(
MERROR,
"db_open_record",
"cannot get record, db_get_record() status %d",
status);
13397 cm_msg(
MERROR,
"db_open_record",
"cannot set record, db_set_record() status %d",
status);
13405 cm_msg(
MERROR,
"db_open_record",
"not enough memory");
13452 WORD access_mode,
void (*dispatcher) (
INT,
INT,
void *),
void *
info,
13485#ifdef LOCAL_ROUTINES
13624 if (convert_flags) {
13868 cm_msg(
MERROR,
"db_watch",
"cannot get key \"%s\"", path.c_str());
13876 cm_msg(
MERROR,
"db_watch",
"cannot get key \"%s\"", path.c_str());
13900#ifdef LOCAL_ROUTINES
13953 cm_msg(
MERROR,
"db_get_value_string",
"cannot resize odb string arrays, please use db_resize_string() instead");
13972 char* buf = (
char*)
malloc(size);
13973 assert(buf !=
NULL);
13997 int size = s->length() + 1;
14019 int size = s->length() + 1;
14089 if (num_values < 1)
14092 int new_size = num_values * item_size;
14100 if (
num > num_values)
14105 for (
int i=0;
i<
num;
i++) {
14124#ifdef LOCAL_ROUTINES
14125 MJsonNode*
scl = MJsonNode::MakeObject();
14126 MJsonNode* clients = MJsonNode::MakeArray();
14129 scl->AddToObject(
"clients", clients);
14143 MJsonNode*
c = MJsonNode::MakeObject();
14144 c->AddToObject(
"slot", MJsonNode::MakeNumber(
i));
14145 c->AddToObject(
"pid", MJsonNode::MakeNumber(
pclient->pid));
14146 c->AddToObject(
"name", MJsonNode::MakeString(
pclient->name));
14147 std::string path =
msprintf(
"/System/Clients/%d/Host",
pclient->pid);
14152 assert(host !=
NULL);
14154 c->AddToObject(
"host", MJsonNode::MakeString(host));
14157 c->AddToObject(
"watchdog_timeout_millisec", MJsonNode::MakeNumber(
pclient->watchdog_timeout));
14159 c->AddToObject(
"last_activity_millisec", MJsonNode::MakeNumber(
now -
pclient->last_activity));
14160 clients->AddToArray(
c);
14168 return MJsonNode::MakeNull();
14176#ifdef LOCAL_ROUTINES
14178 MJsonNode*
sor = MJsonNode::MakeArray();
14190 for (
int j = 0;
j <
pclient->max_index;
j++) {
14196 MJsonNode*
c = MJsonNode::MakeObject();
14197 c->AddToObject(
"name", MJsonNode::MakeString(
pclient->name));
14199 c->AddToObject(
"access_mode", MJsonNode::MakeNumber(
pclient->open_record[
j].access_mode));
14200 c->AddToObject(
"flags", MJsonNode::MakeNumber(
pclient->open_record[
j].flags));
14201 c->AddToObject(
"path", MJsonNode::MakeString(path.c_str()));
14202 sor->AddToArray(
c);
14211 return MJsonNode::MakeNull();
INT cm_get_watchdog_params(BOOL *call_watchdog, DWORD *timeout)
#define DB_STRUCT_MISMATCH
#define DB_INVALID_HANDLE
#define DB_STRUCT_SIZE_MISMATCH
#define DB_NO_MORE_SUBKEYS
#define DB_VERSION_MISMATCH
#define VALIGN(adr, align)
#define MAX_STRING_LENGTH
INT ss_get_struct_align()
INT ss_suspend_get_odb_port(INT *port)
bool ss_is_valid_utf8(const char *string)
INT ss_mutex_release(MUTEX_T *mutex)
INT ss_shm_flush(const char *name, const void *adr, size_t size, HNDLE handle, bool wait_for_thread)
INT ss_semaphore_create(const char *name, HNDLE *semaphore_handle)
INT ss_mutex_delete(MUTEX_T *mutex)
INT ss_mutex_create(MUTEX_T **mutex, BOOL recursive)
INT ss_shm_open(const char *name, INT size, void **adr, size_t *shm_size, HNDLE *handle, BOOL get_size)
INT ss_semaphore_release(HNDLE semaphore_handle)
void ss_stack_history_entry(char *tag)
std::string ss_tid_to_string(midas_thread_t thread_id)
INT ss_resume(INT port, const char *message)
midas_thread_t ss_gettid(void)
INT ss_semaphore_delete(HNDLE semaphore_handle, INT destroy_flag)
INT ss_semaphore_wait_for(HNDLE semaphore_handle, DWORD timeout_millisec)
INT ss_shm_unprotect(HNDLE handle, void **adr, size_t shm_size, BOOL read, BOOL write, const char *caller_name)
INT ss_shm_close(const char *name, void *adr, size_t shm_size, HNDLE handle, INT destroy_flag)
INT send_tcp(int sock, char *buffer, DWORD buffer_size, INT flags)
BOOL ss_pid_exists(int pid)
INT ss_shm_protect(HNDLE handle, void *adr, size_t shm_size)
INT ss_mutex_wait_for(MUTEX_T *mutex, INT timeout)
INT cm_msg_flush_buffer()
INT cm_msg(INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
BOOL equal_ustring(const char *str1, const char *str2)
static void free_key(DATABASE_HEADER *pheader, void *address, INT size)
INT db_find_key1(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE *subhKey)
INT db_sprintfh(char *string, const void *data, INT data_size, INT idx, DWORD type)
INT db_flush_database(HNDLE hDB)
static void json_write_key(HNDLE hDB, HNDLE hKey, const KEY *key, const char *link_path, char **buffer, int *buffer_size, int *buffer_end)
INT db_remove_open_record(HNDLE hDB, HNDLE hKey, BOOL lock)
static void check_open_keys(HNDLE hDB, HNDLE hKey, KEY *pkey, INT level, void *info)
INT db_get_data_index(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, INT idx, DWORD type)
INT db_delete_key(HNDLE hDB, HNDLE hKey, BOOL follow_links)
INT db_send_changed_records()
INT db_find_link(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE *subhKey)
INT db_check_client(HNDLE hDB, HNDLE hKeyClient)
static void * malloc_key(DATABASE_HEADER *pheader, INT size, const char *caller)
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)
INT db_get_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, void *data, INT *buf_size, DWORD type, BOOL create)
static int db_delete_client_info_wlocked(HNDLE hDB, DATABASE_HEADER *pheader, int pid, db_err_msg **msg)
INT db_reorder_key(HNDLE hDB, HNDLE hKey, INT idx)
static const KEY * db_get_parent(const DATABASE_HEADER *pheader, const KEY *pkey, int *pstatus, const char *caller, db_err_msg **msg)
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)
INT db_save_json(HNDLE hDB, HNDLE hKey, const char *filename, int flags)
static INT _record_list_entries
INT db_open_record(HNDLE hDB, HNDLE hKey, void *ptr, INT rec_size, WORD access_mode, void(*dispatcher)(INT, INT, void *), void *info)
INT db_open_database(const char *xdatabase_name, INT database_size, HNDLE *hDB, const char *client_name)
static int db_paste_node(HNDLE hDB, HNDLE hKeyRoot, PMXML_NODE node)
INT db_get_open_records(HNDLE hDB, HNDLE hKey, char *str, INT buf_size, BOOL fix)
INT db_paste_xml(HNDLE hDB, HNDLE hKeyRoot, const char *buffer)
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)
void db_cleanup(const char *who, DWORD actual_time, BOOL wrong_interval)
INT db_show_mem(HNDLE hDB, char **result, BOOL verbose)
static const KEY * db_resolve_link_locked(const DATABASE_HEADER *, const KEY *, int *pstatus, db_err_msg **)
INT db_lock_database(HNDLE hDB)
static bool db_validate_hkey(const DATABASE_HEADER *pheader, HNDLE hKey)
std::string strcomb1(const char **list)
INT db_delete_key1(HNDLE hDB, HNDLE hKey, INT level, BOOL follow_links)
static void * malloc_data(DATABASE_HEADER *pheader, INT size)
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 db_save_xml(HNDLE hDB, HNDLE hKey, const char *filename)
INT db_set_link_data(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
static INT db_find_key_locked(const DATABASE_HEADER *pheader, HNDLE hKey, const char *key_name, HNDLE *subhKey, db_err_msg **msg)
INT db_get_path(HNDLE hDB, HNDLE hKey, char *path, INT buf_size)
int json_write_bare_subdir(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end, int level, int flags, time_t timestamp)
INT db_get_record1(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, INT align, const char *rec_str)
static int db_create_key_wlocked(DATABASE_HEADER *pheader, KEY *parentKey, const char *key_name, DWORD type, KEY **pnewkey, db_err_msg **msg)
INT db_copy(HNDLE hDB, HNDLE hKey, char *buffer, INT *buffer_size, const char *path)
INT db_set_link_data_index(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type)
BOOL strmatch(char *pattern, char *str)
INT db_get_record_size(HNDLE hDB, HNDLE hKey, INT align, INT *buf_size)
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_get_data_locked(DATABASE_HEADER *pheader, const KEY *pkey, int idx, void *data, INT *buf_size, DWORD type, db_err_msg **msg)
INT db_get_data(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, DWORD type)
INT db_create_key(HNDLE hDB, HNDLE hKey, const char *key_name, DWORD type)
INT db_check_record(HNDLE hDB, HNDLE hKey, const char *keyname, const char *rec_str, BOOL correct)
static int validate_free_data(DATABASE_HEADER *pheader, int free_data)
INT db_copy_json_save(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end)
INT db_copy_xml(HNDLE hDB, HNDLE hKey, char *buffer, int *buffer_size, bool header)
INT db_unlock_database(HNDLE hDB)
MJsonNode * db_scl(HNDLE hDB)
static RECORD_LIST * _record_list
INT db_save_struct(HNDLE hDB, HNDLE hKey, const char *file_name, const char *struct_name, BOOL append)
INT db_get_record(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, INT align)
static void * realloc_data(DATABASE_HEADER *pheader, void *address, INT old_size, INT new_size, const char *caller)
void xml_encode(char *src, int size)
INT db_unwatch(HNDLE hDB, HNDLE hKey)
INT db_set_mode(HNDLE hDB, HNDLE hKey, WORD mode, BOOL recurse)
INT db_get_next_link(HNDLE hDB, HNDLE hKey, HNDLE *subkey_handle)
INT db_scan_tree_link(HNDLE hDB, HNDLE hKey, INT level, void(*callback)(HNDLE, HNDLE, KEY *, INT, void *), void *info)
INT db_save(HNDLE hDB, HNDLE hKey, const char *filename, BOOL bRemote)
static bool db_validate_and_repair_db_wlocked(DATABASE_HEADER *pheader, db_err_msg **msg)
INT db_allow_write_locked(DATABASE *p, const char *caller_name)
INT db_scan_tree(HNDLE hDB, HNDLE hKey, INT level, INT(*callback)(HNDLE, HNDLE, KEY *, INT, void *), void *info)
INT db_get_key(HNDLE hDB, HNDLE hKey, KEY *key)
static INT db_get_key_locked(const DATABASE_HEADER *pheader, HNDLE hKey, KEY *key, db_err_msg **msg)
static int _global_open_count
INT db_get_link(HNDLE hDB, HNDLE hKey, KEY *key)
static INT _database_entries
static const KEYLIST * db_get_pkeylist(const DATABASE_HEADER *pheader, HNDLE hKey, const KEY *pkey, const char *caller, db_err_msg **msg, bool kludge_repair=false)
static bool db_validate_data_offset(const DATABASE_HEADER *pheader, int offset)
static int db_remove_open_record_wlocked(DATABASE *pdb, DATABASE_HEADER *pheader, HNDLE hKey)
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)
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)
INT db_load(HNDLE hDB, HNDLE hKeyRoot, const char *filename, BOOL bRemote)
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 db_sprintff(char *string, const char *format, const void *data, INT data_size, INT idx, DWORD type)
static void db_delete_client_wlocked(DATABASE_HEADER *pheader, int jclient, db_err_msg **msg)
static void add_to_buf(struct print_key_info_buf *buf, const char *s)
INT db_get_watchdog_info(HNDLE hDB, const char *client_name, DWORD *timeout, DWORD *last)
INT db_set_data_index(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type)
static HNDLE db_pkey_to_hkey(const DATABASE_HEADER *pheader, const KEY *pkey)
static bool db_validate_key_offset(const DATABASE_HEADER *pheader, int offset)
static int free_data(DATABASE_HEADER *pheader, void *address, INT size, const char *caller)
static void db_save_tree_struct(HNDLE hDB, HNDLE hKey, int hfile, INT level)
INT db_find_keys(HNDLE hDB, HNDLE hKeyRoot, char *odbpath, std::vector< HNDLE > &hKeyVector)
INT db_save_string(HNDLE hDB, HNDLE hKey, const char *file_name, const char *string_name, BOOL append)
static int db_update_open_record_wlocked(const DATABASE_HEADER *xpheader, const KEY *xpkey, int level, void *voidp, db_err_msg **msg)
INT db_copy_json_index(HNDLE hDB, HNDLE hKey, int index, char **buffer, int *buffer_size, int *buffer_end)
INT db_close_all_records()
static const KEY * db_enum_next_locked(const DATABASE_HEADER *pheader, const KEY *pdir, const KEY *pkey, db_err_msg **msg)
INT db_paste(HNDLE hDB, HNDLE hKeyRoot, const char *buffer)
INT db_save_xml_key(HNDLE hDB, HNDLE hKey, INT level, MXML_WRITER *writer)
static void static void db_print_msg(const db_err_msg *msg)
INT db_watch(HNDLE hDB, HNDLE hKey, void(*dispatcher)(INT, INT, INT, void *), void *info)
static std::string db_get_path_locked(const DATABASE_HEADER *pheader, HNDLE hKey)
INT db_get_key_info(HNDLE hDB, HNDLE hKey, char *name, INT name_size, INT *type, INT *num_values, INT *item_size)
INT db_close_all_databases(void)
INT db_set_data(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
INT db_enum_link(HNDLE hDB, HNDLE hKey, INT idx, HNDLE *subkey_handle)
static const KEY * db_get_pkey(const DATABASE_HEADER *pheader, HNDLE hKey, int *pstatus, const char *caller, db_err_msg **msg)
INT db_copy_json_ls(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end)
char * strcomb(const char **list)
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)
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)
static WATCH_LIST * _watch_list
static int db_fix_open_records(HNDLE hDB, HNDLE hKey, KEY *key, INT level, void *xresult)
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
INT db_update_last_activity(DWORD millitime)
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)
void strarrayindex(char *odbpath, int *index1, int *index2)
INT db_set_data1(HNDLE hDB, HNDLE hKey, const void *data, INT buf_size, INT num_values, DWORD type)
DATABASE_CLIENT * db_get_my_client_locked(DATABASE *pdb)
static int db_set_mode_wlocked(DATABASE_HEADER *, KEY *, WORD mode, int recurse, db_err_msg **)
INT db_get_data1(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, DWORD type, INT *num_values)
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)
static int db_set_value_wlocked(DATABASE_HEADER *pheader, HNDLE hDB, KEY *pkey_root, const char *key_name, const void *data, INT data_size, INT num_values, DWORD type, db_err_msg **msg)
INT db_set_value(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const void *data, INT data_size, INT num_values, DWORD type)
static int db_find_open_records(HNDLE hDB, HNDLE hKey, KEY *key, INT level, void *xresult)
static int db_notify_clients_locked(const DATABASE_HEADER *pheader, HNDLE hDB, HNDLE hKeyMod, int index, BOOL bWalk, db_err_msg **msg)
static void json_write_data(char **buffer, int *buffer_size, int *buffer_end, int level, const KEY *key, const char *p)
static INT _watch_list_entries
static const KEY * db_find_pkey_locked(const DATABASE_HEADER *pheader, const KEY *pkey, const char *key_name, int *pstatus, db_err_msg **msg)
INT db_find_key(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE *subhKey)
static const KEY * db_enum_first_locked(const DATABASE_HEADER *pheader, const KEY *pkey, db_err_msg **msg)
INT db_update_record_local(INT hDB, INT hKeyRoot, INT hKey, int index)
INT db_find_link1(HNDLE hDB, HNDLE hKey, const char *key_name, HNDLE *subhKey)
static void db_recurse_record_tree_locked(HNDLE hDB, const DATABASE_HEADER *pheader, const KEY *pkey, void **data, INT *total_size, INT base_align, INT *max_align, BOOL bSet, INT convert_flags, db_err_msg **msg)
INT db_copy_json_array(HNDLE hDB, HNDLE hKey, char **buffer, int *buffer_size, int *buffer_end)
MJsonNode * db_sor(HNDLE hDB, const char *root_path)
INT db_get_link_data(HNDLE hDB, HNDLE hKey, void *data, INT *buf_size, DWORD type)
void db_set_watchdog_params(DWORD timeout)
static void db_validate_sizes()
INT db_update_record_mserver(INT hDB, INT hKeyRoot, INT hKey, int index, int client_socket)
INT db_rename_key(HNDLE hDB, HNDLE hKey, const char *name)
BOOL ends_with_ustring(const char *str, const char *suffix)
void db_cleanup2(const char *client_name, int ignore_timeout, DWORD actual_time, const char *who)
void json_write(char **buffer, int *buffer_size, int *buffer_end, int level, const char *s, int quoted)
INT EXPRT db_paste_json(HNDLE hDB, HNDLE hKeyRoot, const char *buffer)
static bool is_utf8(const char *string)
INT db_get_key_time(HNDLE hDB, HNDLE hKey, DWORD *delta)
int db_delete_client_info(HNDLE hDB, int pid)
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)
static void db_flush_msg(db_err_msg **msg)
static int db_validate_name(const char *name, int maybe_path, const char *caller_name, db_err_msg **msg)
INT db_set_client_name(HNDLE hDB, const char *client_name)
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 db_notify_clients_array(HNDLE hDB, HNDLE hKeys[], INT size)
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)
INT db_merge_data(HNDLE hDB, HNDLE hKeyRoot, const char *name, void *data, INT data_size, INT num_values, INT type)
INT db_notify_clients(HNDLE hDB, HNDLE hKeyMod, int index, BOOL bWalk)
INT db_set_record(HNDLE hDB, HNDLE hKey, void *data, INT buf_size, INT align)
INT db_set_data_index1(HNDLE hDB, HNDLE hKey, const void *data, INT data_size, INT idx, DWORD type, BOOL bNotify)
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)
INT db_enum_key(HNDLE hDB, HNDLE hKey, INT idx, HNDLE *subkey_handle)
INT EXPRT db_resize_string(HNDLE hdb, HNDLE hKeyRoot, const char *key_name, int num_values, int max_string_length)
INT db_close_record(HNDLE hDB, HNDLE hKey)
static int db_validate_open_records_wlocked(DATABASE_HEADER *pheader, db_err_msg **msg)
INT db_create_record(HNDLE hDB, HNDLE hKey, const char *orig_key_name, const char *init_str)
INT db_sscanf(const char *data_str, void *data, INT *data_size, INT i, DWORD tid)
static db_err_msg * _last_error_message
static void db_msg(db_err_msg **msg, INT message_type, const char *filename, INT line, const char *routine, const char *format,...) MATTRPRINTF(6
INT db_add_open_record(HNDLE hDB, HNDLE hKey, WORD access_mode)
INT EXPRT db_set_value_string(HNDLE hDB, HNDLE hKeyRoot, const char *key_name, const std::string *s)
INT db_set_lock_timeout(HNDLE hDB, int timeout_millisec)
INT db_set_num_values(HNDLE hDB, HNDLE hKey, INT num_values)
INT db_get_record2(HNDLE hDB, HNDLE hKey, void *data, INT *xbuf_size, INT align, const char *rec_str, BOOL correct)
INT db_create_link(HNDLE hDB, HNDLE hKey, const char *link_name, const char *destination)
static void merge_records(HNDLE hDB, HNDLE hKey, KEY *pkey, INT level, void *info)
INT db_close_database(HNDLE hDB)
INT db_protect_database(HNDLE hDB)
static INT print_key_info(HNDLE hDB, HNDLE hKey, KEY *pkey, INT level, void *info)
struct db_err_msg_struct db_err_msg
const char * extract_key(const char *key_list, char *key_name, int key_name_length)
INT db_get_free_mem(HNDLE hDB, INT *key_size, INT *data_size)
static DATABASE * _database
static void json_ensure_decimal_dot(char *str)
#define RPC_DB_ADD_OPEN_RECORD
#define RPC_DB_SET_DATA_INDEX
void rpc_convert_data(void *data, INT tid, INT flags, INT total_size, INT convert_flags)
#define RPC_DB_CLOSE_DATABASE
#define RPC_DB_CREATE_RECORD
#define RPC_DB_CREATE_LINK
#define RPC_DB_NOTIFY_CLIENTS_ARRAY
#define RPC_DB_DELETE_KEY
#define RPC_DB_SET_NUM_VALUES
const char * rpc_tid_name_old(INT id)
#define RPC_DB_SET_CLIENT_NAME
#define RPC_DB_REMOVE_OPEN_RECORD
#define RPC_DB_CLOSE_ALL_DATABASES
#define RPC_DB_SET_LINK_DATA_INDEX
#define RPC_DB_RENAME_KEY
#define RPC_DB_GET_NEXT_LINK
INT rpc_call(DWORD routine_id,...)
const char * rpc_tid_name(INT id)
#define RPC_DB_SET_LINK_DATA
#define RPC_DB_GET_LINK_DATA
#define RPC_DB_SET_DATA_INDEX1
#define RPC_DB_GET_PARENT
#define RPC_DB_REORDER_KEY
#define RPC_DB_OPEN_DATABASE
#define RPC_DB_CHECK_RECORD
#define RPC_DB_GET_DATA_INDEX
int rpc_name_tid(const char *name)
#define RPC_DB_GET_KEY_INFO
bool rpc_is_mserver(void)
#define RPC_DB_FLUSH_DATABASE
#define RPC_DB_GET_KEY_TIME
#define RPC_DB_SET_RECORD
#define RPC_DB_GET_RECORD_SIZE
#define RPC_DB_GET_OPEN_RECORDS
INT rpc_get_convert_flags(void)
void rpc_convert_single(void *data, INT tid, INT flags, INT convert_flags)
#define RPC_DB_CREATE_KEY
#define RPC_DB_GET_RECORD
std::string msprintf(const char *format,...)
#define DIR_SEPARATOR_STR
#define JSFLAG_FOLLOW_LINKS
#define MATTRPRINTF(a, b)
#define JSFLAG_OMIT_LAST_WRITTEN
unsigned long long UINT64
#define JSFLAG_OMIT_NAMES
#define WATCHDOG_INTERVAL
#define JS_MUST_BE_SUBDIR
#define message(type, str)
#define write(n, a, f, d)
struct callback_addr callback
TH1X EXPRT * h1_book(const char *name, const char *title, int bins, double min, double max)
OPEN_RECORD open_record[MAX_OPEN_RECORDS]
DATABASE_CLIENT client[MAX_CLIENTS]
DATABASE_HEADER * database_header
NET_COMMAND_HEADER header
void(* dispatcher)(INT, INT, void *)
DATABASE_HEADER * pheader
void(* dispatcher)(INT, INT, INT, void *info)
static double comma(double a, double b)
static te_expr * list(state *s)