int main() {
attacks_init();
master_pgn_db = kcdbnew();
puts("opening master-pgn.kct ...");
if (!kcdbopen(master_pgn_db, "master-pgn.kct", KCOREADER)) {
printf("master-pgn.kct open error: %s\n", kcecodename(kcdbecode(master_pgn_db)));
return 1;
}
master_db = kcdbnew();
puts("opening master.kch ...");
if (!kcdbopen(master_db, "master.kch", KCOREADER)) {
printf("master.kch open error: %s\n", kcecodename(kcdbecode(master_db)));
return 1;
}
puts("opened all databases.");
int ret = serve(5555);
if (!kcdbclose(master_pgn_db)) {
printf("master-pgn.kct close error: %s\n", kcecodename(kcdbecode(master_pgn_db)));
}
if (!kcdbclose(master_db)) {
printf("master.kch close error: %s\n", kcecodename(kcdbecode(master_db)));
}
kcdbdel(master_pgn_db);
return ret;
}
/* main routine */
int
main (int argc, char **argv)
{
KCDB *db;
char *vbuf;
size_t vsiz;
int retour = 1;
db = kcdbnew ();
if (argc != 3)
{
fprintf (stderr, "Usage getVal DB_FILE KEY\n");
return 100;
}
/* open the database */
if (!kcdbopen (db, argv[1], KCOWRITER | KCOCREATE))
{
fprintf (stderr, "open error: %s\n", kcecodename (kcdbecode (db)));
return 100;
}
vbuf = kcdbget (db, argv[2], strlen (argv[2]), &vsiz);
if (vbuf)
{
printf ("%s\n", vbuf);
kcfree (vbuf);
retour = 0;
}
/* delete the database object */
kcdbdel (db);
return retour;
}
/* main routine */
int
main (int argc, char **argv)
{
KCDB *db;
char *vbuf;
size_t vsiz;
/* Variable for time mesure */
clock_t start, finish;
int duration;
start = clock ();
db = kcdbnew ();
/* open the database */
if (!kcdbopen (db, argv[1], KCOWRITER | KCOCREATE))
{
fprintf (stderr, "open error: %s\n", kcecodename (kcdbecode (db)));
return 100;
}
vbuf = kcdbget (db, argv[2], strlen (argv[2]), &vsiz);
if (vbuf)
{
printf ("%s\n", vbuf);
kcfree (vbuf);
}
/* delete the database object */
kcdbdel (db);
finish = clock ();
duration = (finish - start);
printf ("\nduration : %iclock (%i clock/s) \n", duration, CLOCKS_PER_SEC);
return 0;
}
/* We set a trap using atexit(3) to flush and close the cache database
* if it's open, in order to prevent cache corruption in the case of
* calls to exit() in the case of memory allocation errors and the like.
*/
void pyt_at_exit(void)
{
if(Config.cachedb != NULL) {
kcdbclose(Config.cachedb);
kcdbdel(Config.cachedb);
}
return;
}
int main(int argc, char **argv)
{
/* from config.h */
struct pyt_private_data *d = &Config;
/* open the databases */
d->filesdb = kcdbnew();
if(!kcdbopen(d->filesdb, "-", KCOREADER | KCOWRITER | KCOCREATE))
LERROR(EXIT_FAILURE, 0, "Could not create in-memory cache database: %s",
kcecodename(kcdbecode(d->filesdb)));
d->cachedb = kcdbnew();
d->cachefile = pyt_fs_kcdbpath(d->cachefile, PYT_DB_TUNING_DATA);
if(!kcdbopen(d->cachedb, d->cachefile, KCOREADER | KCOWRITER | KCOCREATE)) {
LERROR(0, 0, "Could not open or create cache database @ %s: %s",
d->cachefile, kcecodename(kcdbecode(d->cachedb)));
free(d->cachefile);
kcdbclose(d->filesdb);
kcdbdel(d->filesdb);
free(d->cachefile);
return EXIT_FAILURE;
}
/* register exit trap to prevent cache corruption */
if(atexit(pyt_at_exit) != 0)
LERROR(0, 0, "Failed to register pyt_at_exit() as a trap on exit(). "
"If you terminate the program forcefully, cache corruption might occur!");
/* initialize the file database with the control files */
if(pyt_fs_init_filesdb(d) != 0) {
LERROR(0, 0, "pyt_fs_init_filesdb() failed");
goto main_close_databases;
}
/* close databases */
main_close_databases:
kcdbclose(d->filesdb);
kcdbdel(d->filesdb);
kcdbclose(d->cachedb);
kcdbdel(d->cachedb);
d->cachedb = NULL; // for pyt_at_exit
free(d->cachefile);
return EXIT_SUCCESS;
}
struct db *db_open(const char *path_db, int flags, duc_errno *e)
{
struct db *db;
int compress = 0;
uint32_t mode = KCOREADER;
if(flags & DUC_OPEN_RW) mode |= KCOWRITER | KCOCREATE;
if(flags & DUC_OPEN_COMPRESS) compress = 1;
db = duc_malloc(sizeof *db);
db->kdb = kcdbnew();
db->kdb = kcdbnew();
if(!db->kdb) {
*e = DUC_E_DB_BACKEND;
goto err1;
}
char fname[DUC_PATH_MAX];
snprintf(fname, sizeof(fname), "%s.kct#opts=c", path_db);
int r = kcdbopen(db->kdb, fname, mode);
if(r == 0) {
perror(kcecodename(kcdbecode(db->kdb)));
*e = tcdb_to_errno(db->kdb);
goto err2;
}
size_t vall;
char *version = db_get(db, "duc_db_version", 14, &vall);
if(version) {
if(strcmp(version, DUC_DB_VERSION) != 0) {
*e = DUC_E_DB_VERSION_MISMATCH;
goto err3;
}
free(version);
} else {
db_put(db, "duc_db_version", 14, DUC_DB_VERSION, strlen(DUC_DB_VERSION));
}
return db;
err3:
kcdbclose(db->kdb);
err2:
kcdbdel(db->kdb);
err1:
free(db);
return NULL;
}
extern CAMLprim
value kc_open(value path, value options)
{
CAMLparam2(path, options);
KCDB* db = kcdbnew();
if (! kcdbopen(db, String_val(path), decode_flags(options, OPEN_FLAGS))) {
const char *error = kcdbemsg(db);
kcdbdel(db);
RAISE(error);
}
value caml_db = alloc_small(1, Abstract_tag);
KCDB_val(caml_db) = db;
CAMLreturn(caml_db);
}
extern CAMLprim
value kc_close(value caml_db)
{
CAMLparam1(caml_db);
KCDB* db = KCDB_val(caml_db);
if (db) {
if (! kcdbclose(db)) {
const char *error = kcdbemsg(db);
RAISE(error);
}
kcdbdel(db);
KCDB_val(caml_db) = NULL;
}
CAMLreturn(Val_unit);
}
int main()
{
const char * host = "pwd.tw";
const char * db_file = "/home/rek/pwd.kch";
char * uri;
char * server_name;
char * server;
KCDB * db;
char * v;
db = kcdbnew();
while(FCGI_Accept() >= 0)
{
uri = getenv("REQUEST_URI");
server_name = getenv("SERVER_NAME");
if(server_name == NULL)
{
printf("Status: 404 Not Found\r\n\r\n");
continue;
}
if(strcmp(server_name, host) == 0)
{
if(uri == NULL || strcmp(uri, "/") == 0)
{
printf("X-LIGHTTPD-send-file: /var/www/index.html\r\n\r\n");
}
else
{
v = pwd_save(db, &uri[1]);
if(v)
{
printf("Content-Type: text/html\r\n"
"Content-Length: %d\r\n\r\n"
"http://%s.pwd.tw\r\n", strlen(v) + 16, v);
}
else
{
printf("Status: 500 SERVER ERROR\r\n\r\nkc error: %s\r\n", kcecodename(kcdbecode(db)));
}
}
}
else
{
server = malloc(strlen(server_name) + 1);
strcpy(server, server_name);
server[strlen(server) - strlen(host) - 1] = '\0';
v = pwd_load(db, server);
free(server);server = NULL;
if(v)
{
printf("Status: 301 Moved Permanently\r\n"
"Location: %s\r\n"
"Content-Length: %d\r\n\r\n"
"%s\n", v, strlen(v) + 1, v);
}
else
{
printf("Status: 404 Not Found\r\n"
"Content-Type: text/plain\r\n\r\n"
"The shorten %s cannot be found\r\n"
"Debug Info: %s",
server_name,
kcecodename(kcdbecode(db))
);
}
}
if(v)
{
free(v);
v = NULL;
}
}
kcdbdel(db);
}
/* perform order command */
static int32_t procorder(const char* path, int64_t rnum, int32_t rnd, int32_t etc,
int32_t tran, int32_t oflags) {
KCDB* db;
KCCUR* cur, *paracur;
int32_t err;
char kbuf[RECBUFSIZ], *vbuf, wbuf[RECBUFSIZ], *corepath, *copypath, *snappath;
size_t ksiz, vsiz, psiz;
int32_t wsiz;
int64_t i, cnt;
double stime, etime;
VISARG visarg;
oprintf("<In-order Test>\n path=%s rnum=%ld rnd=%d etc=%d tran=%d oflags=%d\n\n",
path, (long)rnum, rnd, etc, tran, oflags);
err = FALSE;
db = kcdbnew();
oprintf("opening the database:\n");
stime = kctime();
if (!kcdbopen(db, path, KCOWRITER | KCOCREATE | KCOTRUNCATE | oflags)) {
dberrprint(db, __LINE__, "kcdbopen");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
oprintf("setting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbset(db, kbuf, ksiz, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbset");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("adding records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbadd(db, kbuf, ksiz, kbuf, ksiz) && kcdbecode(db) != KCEDUPREC) {
dberrprint(db, __LINE__, "kcdbadd");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("appending records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbappend(db, kbuf, ksiz, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbadd");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
oprintf("getting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
vbuf = kcdbget(db, kbuf, ksiz, &vsiz);
if (vbuf) {
if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbget");
err = TRUE;
}
kcfree(vbuf);
} else if (!rnd || kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbget");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("getting records with a buffer:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
wsiz = kcdbgetbuf(db, kbuf, ksiz, wbuf, sizeof(wbuf));
if (wsiz >= 0) {
if (wsiz < (int32_t)ksiz || memcmp(wbuf, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbgetbuf");
err = TRUE;
}
} else if (!rnd || kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbgetbuf");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("traversing the database by the inner iterator:\n");
stime = kctime();
cnt = kcdbcount(db);
visarg.rnum = rnum;
visarg.rnd = rnd;
visarg.cnt = 0;
memset(visarg.rbuf, '+', sizeof(visarg.rbuf));
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
if (!kcdbiterate(db, visitfull, &visarg, TRUE)) {
dberrprint(db, __LINE__, "kcdbiterate");
err = TRUE;
}
if (rnd) oprintf(" (end)\n");
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (visarg.cnt != cnt) {
dberrprint(db, __LINE__, "kcdbiterate");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("traversing the database by the outer cursor:\n");
stime = kctime();
cnt = kcdbcount(db);
visarg.rnum = rnum;
visarg.rnd = rnd;
visarg.cnt = 0;
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
cur = kcdbcursor(db);
if (!kccurjump(cur) && kccurecode(cur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurjump");
err = TRUE;
}
paracur = kcdbcursor(db);
while (!err && kccuraccept(cur, &visitfull, &visarg, TRUE, !rnd)) {
if (rnd) {
ksiz = sprintf(kbuf, "%08ld", (long)myrand(rnum));
switch (myrand(3)) {
case 0: {
if (!kcdbremove(db, kbuf, ksiz) && kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbremove");
err = TRUE;
}
break;
}
case 1: {
if (!kccurjumpkey(paracur, kbuf, ksiz) && kccurecode(paracur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurjump");
err = TRUE;
}
break;
}
default: {
if (!kccurstep(cur) && kccurecode(cur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurstep");
err = TRUE;
}
break;
}
}
}
}
oprintf(" (end)\n");
kccurdel(paracur);
kccurdel(cur);
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (!rnd && visarg.cnt != cnt) {
dberrprint(db, __LINE__, "kccuraccept");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("synchronizing the database:\n");
stime = kctime();
if (!kcdbsync(db, FALSE, NULL, NULL)) {
dberrprint(db, __LINE__, "kcdbsync");
err = TRUE;
}
if (!kcdboccupy(db, FALSE, NULL, NULL)) {
dberrprint(db, __LINE__, "kcdboccupy");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
corepath = kcdbpath(db);
psiz = strlen(corepath);
if (strstr(corepath, ".kch") || strstr(corepath, ".kct")) {
copypath = kcmalloc(psiz + 256);
sprintf(copypath, "%s.tmp", corepath);
snappath = kcmalloc(psiz + 256);
sprintf(snappath, "%s.kcss", corepath);
} else {
copypath = kcmalloc(256);
sprintf(copypath, "kclangctest.tmp");
snappath = kcmalloc(256);
sprintf(snappath, "kclangctest.kcss");
}
oprintf("copying the database file:\n");
stime = kctime();
if (!kcdbcopy(db, copypath)) {
dberrprint(db, __LINE__, "kcdbcopy");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
remove(copypath);
oprintf("dumping records into snapshot:\n");
stime = kctime();
if (!kcdbdumpsnap(db, snappath)) {
dberrprint(db, __LINE__, "kcdbdumpsnap");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
oprintf("loading records into snapshot:\n");
stime = kctime();
cnt = kcdbcount(db);
if (rnd && myrand(2) == 0 && !kcdbclear(db)) {
dberrprint(db, __LINE__, "kcdbclear");
err = TRUE;
}
if (!kcdbloadsnap(db, snappath) || kcdbcount(db) != cnt) {
dberrprint(db, __LINE__, "kcdbloadsnap");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
remove(snappath);
kcfree(copypath);
kcfree(snappath);
kcfree(corepath);
}
oprintf("removing records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbremove(db, kbuf, ksiz) &&
((!rnd && !etc) || kcdbecode(db) != KCENOREC)) {
dberrprint(db, __LINE__, "kcdbremove");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, TRUE);
oprintf("time: %.3f\n", etime - stime);
oprintf("closing the database:\n");
stime = kctime();
if (!kcdbclose(db)) {
dberrprint(db, __LINE__, "kcdbclose");
err = TRUE;
}
etime = kctime();
oprintf("time: %.3f\n", etime - stime);
kcdbdel(db);
oprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
void db_close(struct db *db)
{
kcdbclose(db->kdb);
kcdbdel(db->kdb);
free(db);
}
