// Open a DB.
bool open_db (KCDB *db, char *map_type, char *start_time) {
// Figure out what db to open.
char db_buffer[512];
snprintf(db_buffer, 256, "%s/%s/pg_agg_map_%s.%s", BASE_DB_DIR, start_time, map_type, DB_TYPE);
if (!kcdbopen(db, db_buffer, KCOWRITER)) {
#ifdef CF_NO_DB_IS_ERR
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.",
db_buffer, kcecodename(kcdbecode(db)))));
#endif
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.",
db_buffer, kcecodename(kcdbecode(db)))));
#endif
return false;
}
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Opened db -- %s.", db_buffer)));
#endif
return true;
}
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;
}
char * pwd_save(KCDB * db, const char * origin_url)
{
char * pk, * epk, * url;
char hash[41];
size_t vsiz;
if(!kcdbopen(db, db_file, KCOWRITER|KCOCREATE))
{
printf("Status: 500 INTERNAL ERROR\r\n\r\nkcdb open error: %s\n", kcecodename(kcdbecode(db)));
return NULL;
}
if(strstr(origin_url, "http://") == NULL && strstr(origin_url, "https://") == NULL)
{
url = malloc(strlen(origin_url) + 8);
strcpy(url, "http://");
strcat(url, origin_url);
}
else
{
url = malloc(strlen(origin_url) + 1);
strcpy(url, origin_url);
}
// calc url hash and check if exists
sha1(hash, url);
epk = kcdbget(db, hash, strlen(hash), &vsiz);
if(epk)
{
pk = malloc(strlen(epk) + 1);
strcpy(pk, epk);
kcfree(epk);
free(url);
kcdbclose(db);
return pk;
}
pk = pwd_get_pk(db);
if(pk == NULL)
{
free(url);
kcdbclose(db);
return NULL;
}
//TODO save pk => url && hash => pk
if(!kcdbset(db, pk, strlen(pk), url, strlen(url)))
{
free(pk); pk = NULL;
}
if(!kcdbset(db, hash, strlen(hash), pk, strlen(pk)))
{
free(pk); pk = NULL;
}
free(url);
kcdbclose(db);
return pk;
}
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;
}
/* print error message of database */
static void dberrprint(KCDB* db, int32_t line, const char* func) {
char* path;
const char* emsg;
int32_t ecode;
path = kcdbpath(db);
ecode = kcdbecode(db);
emsg = kcdbemsg(db);
oprintf("%s: %d: %s: %s: %d: %s: %s\n",
g_progname, line, func, path ? path : "-", ecode, kcecodename(ecode), emsg);
kcfree(path);
}
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;
}
inline void set_kv_path(Cloudflare__ZoneTimeBucket *msg, char *map_name, char *start_time_uid, KCDB* db) {
struct stat path_buf;
char dir_buf[KC_MAX_RID];
char *found;
msg->kv_map_file = (char *)palloc(KC_MAX_RID * sizeof(char));
snprintf(msg->kv_map_file, KC_MAX_RID, "%s/%s/%s/%s.%s",
CF_KV_MAP_BASE,
start_time_uid,
map_name,
msg->db_key,
DB_TYPE);
snprintf(dir_buf, KC_MAX_RID, "%s", CF_KV_MAP_BASE);
if (stat(dir_buf, &path_buf) != 0) {
mkdir (dir_buf, NEW_DIR_MASK);
}
chmod (dir_buf, NEW_DIR_MODE);
found = strtok (start_time_uid, "/");
while (found != NULL) {
strncat (dir_buf, "/", KC_MAX_RID);
strncat (dir_buf, found, KC_MAX_RID);
if (stat(dir_buf, &path_buf) != 0) {
mkdir (dir_buf, NEW_DIR_MODE);
}
chmod (dir_buf, NEW_DIR_MODE);
found = strtok (NULL, "/");
}
strncat (dir_buf, "/", KC_MAX_RID);
strncat (dir_buf, map_name, KC_MAX_RID);
if (stat(dir_buf, &path_buf) != 0) {
mkdir (dir_buf, NEW_DIR_MODE);
}
chmod (dir_buf, NEW_DIR_MODE);
if (!kcdbopen(db, msg->kv_map_file, KCOWRITER | KCOCREATE)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("KV open error for: %s %s\n", msg->kv_map_file, kcecodename(kcdbecode(db)))));
}
kcdbbegintran (db, 0);
kcdbclear (db);
chmod (msg->kv_map_file, FILE_MODE);
}
int merge_using_kv_map(Cloudflare__ZoneTimeBucket *msg_old, Cloudflare__ZoneTimeBucket *msg_new, KCDB* db) {
unsigned int i;
int num_new = 0;
if (msg_new->kv_map_file) {
// Open a db for the new map file.
KCCUR* cur;
KCDB* new_db;
new_db = kcdbnew();
/* open the database */
if (!kcdbopen(new_db, msg_new->kv_map_file, KCOWRITER)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("open error: %s", kcecodename(kcdbecode(new_db)))));
}
cur = kcdbcursor(new_db);
kccurjump(cur);
char *kv_kbuf;
size_t kv_ksiz;
while ((kv_kbuf = kccurgetkey(cur, &kv_ksiz, 1)) != NULL) {
int64_t value = kcdbincrint (new_db, kv_kbuf, kv_ksiz, 0);
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Saving: %s -- %ld", kv_kbuf, value)));
#endif
kcdbincrint (db, kv_kbuf, kv_ksiz, value);
num_new++;
kcfree(kv_kbuf);
}
kccurdel(cur);
kcdbclose(new_db);
} else {
for (i = 0; i < msg_new->n_map_entry; i++) {
kcdbincrint (db, msg_new->map_entry[i]->key, strlen(msg_new->map_entry[i]->key), msg_new->map_entry[i]->value);
num_new++;
}
}
return num_new;
}
char * pwd_load(KCDB * db, const char * key)
{
char * url, * value;
size_t vsiz;
if(!kcdbopen(db, db_file, KCOREADER))
{
printf("Status: 500 INTERNAL ERROR\r\n\r\nkcdb open error: %s\n", kcecodename(kcdbecode(db)));
return NULL;
}
value = kcdbget(db, key, strlen(key), &vsiz);
if(!value)
{
kcdbclose(db);
return NULL;
}
url = malloc(strlen(value) + 1);
strcpy(url, value);
kcfree(value);
kcdbclose(db);
return url;
}
Datum kc_delete(PG_FUNCTION_ARGS) {
char *map_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
char *start_time = text_to_cstring(PG_GETARG_TEXT_PP(1));
ArrayType *rids = PG_GETARG_ARRAYTYPE_P(2);
int i;
Datum *rid_datums;
bool *rid_nulls;
int rid_count;
char *next_rid;
KCDB *main_db;
char *vbuf;
size_t vsiz;
int64_t num_keys_to_run;
int64_t num_keys_deleted;
char **keys_to_use;
Cloudflare__ZoneTimeBucket *msg_new;
// Open our DB.
main_db = kcdbnew();
if (!open_db (main_db, map_name, start_time)) {
PG_RETURN_INT64(0);
}
kcdbbegintran (main_db, 0);
// Now run over the array.
deconstruct_array(rids, TEXTOID, -1, false, 'i',
&rid_datums, &rid_nulls, &rid_count);
if (ARR_HASNULL(rids)) {
ereport(ERROR,
(errcode(ERRCODE_ARRAY_ELEMENT_ERROR),
errmsg("cannot work with arrays containing NULLs")));
}
keys_to_use = (char **)palloc(KC_MAX_ENTRIES_PER_RID * sizeof(char));
num_keys_deleted = 0;
char prefixes_to_use[rid_count][KC_MAX_RID];
for (i = 0; i < rid_count; i++) {
next_rid = TextDatumGetCString(rid_datums[i]);
snprintf(prefixes_to_use[i], KC_MAX_RID, "%s%s", next_rid, CF_LABEL_SEP);
num_keys_to_run = kcdbmatchprefix (main_db, prefixes_to_use[i], keys_to_use, KC_MAX_ENTRIES_PER_RID);
if (num_keys_to_run != -1) {
num_keys_deleted += num_keys_to_run;
int next_key;
for (next_key=0; next_key < num_keys_to_run; next_key++) {
vbuf = kcdbget(main_db, keys_to_use[next_key], strlen(keys_to_use[next_key]), &vsiz);
if (vbuf) {
msg_new = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)vbuf);
if (msg_new == NULL) { // Something failed
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("error unpacking incoming message")));
} else {
if (msg_new->kv_map_file) {
unlink(msg_new->kv_map_file);
}
kcdbremove (main_db, keys_to_use[next_key], strlen(keys_to_use[next_key]));
}
cloudflare__zone_time_bucket__free_unpacked(msg_new, NULL);
kcfree(vbuf);
kcfree(keys_to_use[next_key]);
} else {
ereport(NOTICE,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("get error on %s -- %s", keys_to_use[next_key], kcecodename(kcdbecode(main_db)))));
}
}
} else {
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("prefix error on %s -- %s", prefixes_to_use[i], kcecodename(kcdbecode(main_db)))));
}
}
pfree(keys_to_use);
// Done!
kcdbendtran (main_db, 1);
if (!kcdbclose(main_db)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(main_db)))));
}
PG_RETURN_INT64(num_keys_deleted);
}
Datum kc_shrink(PG_FUNCTION_ARGS) {
char *map_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
char *start_time = text_to_cstring(PG_GETARG_TEXT_PP(1)); // Start time + uid!!!
char *new_rid = text_to_cstring(PG_GETARG_TEXT_PP(2));
ArrayType *old_rids = PG_GETARG_ARRAYTYPE_P(3);
char *classification = text_to_cstring(PG_GETARG_TEXT_PP(4));
char *doctype = text_to_cstring(PG_GETARG_TEXT_PP(5));
char *pop = text_to_cstring(PG_GETARG_TEXT_PP(6));
char *psource = text_to_cstring(PG_GETARG_TEXT_PP(7));
text *tout;
int i,j;
Datum *rid_datums;
bool *rid_nulls;
int rid_count;
char *next_rid;
KCDB *main_db;
char *vbuf;
size_t vsiz;
// Open our DB.
main_db = kcdbnew();
if (!open_db (main_db, map_name, start_time)) {
tout = cstring_to_text(new_rid);
PG_RETURN_TEXT_P(tout);
}
kcdbbegintran (main_db, 0);
// First fill in what we can from the input.
Cloudflare__ZoneTimeBucket msg = CLOUDFLARE__ZONE_TIME_BUCKET__INIT;
msg.map_name = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.doctype = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.classification = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.pop = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.psource = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.result_id = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.db_key = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.db_path = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
msg.map_entry = palloc(MAX_KEYS_BEFORE_KV_MAP * sizeof(Cloudflare__ZoneTimeBucket__Counter));
msg.n_map_entry = 0;
strncpy(msg.map_name, map_name, MAX_KC_ROW_ENTRY);
strncpy(msg.classification, classification, MAX_KC_ROW_ENTRY);
strncpy(msg.doctype, doctype, MAX_KC_ROW_ENTRY);
strncpy(msg.pop, pop, MAX_KC_ROW_ENTRY);
strncpy(msg.psource, psource, MAX_KC_ROW_ENTRY);
strncpy(msg.result_id, new_rid, KC_MAX_RID);
snprintf(msg.db_path, MAX_KC_ROW_ENTRY, "%s%s%s",
map_name, "/", start_time);
snprintf(msg.db_key, KC_MAX_RID, "%s%s%s%s%s%s%s%s%s%s%s",
new_rid, CF_LABEL_SEP,
classification, CF_LABEL_SEP,
doctype, CF_LABEL_SEP,
pop, CF_LABEL_SEP,
psource, CF_LABEL_SEP,
map_name);
// Now run over the array.
deconstruct_array(old_rids, TEXTOID, -1, false, 'i',
&rid_datums, &rid_nulls, &rid_count);
if (ARR_HASNULL(old_rids)) {
ereport(ERROR,
(errcode(ERRCODE_ARRAY_ELEMENT_ERROR),
errmsg("cannot work with arrays containing NULLs")));
}
int num_new_keys = 0;
int num_entries = 0;
char keys_to_use[rid_count][KC_MAX_RID];
Cloudflare__ZoneTimeBucket *msg_new[rid_count];
j=0;
for (i = 0; i < rid_count; i++) {
next_rid = TextDatumGetCString(rid_datums[i]);
snprintf(keys_to_use[i], KC_MAX_RID, "%s%s%s%s%s%s%s%s%s%s%s",
next_rid, CF_LABEL_SEP,
classification, CF_LABEL_SEP,
doctype, CF_LABEL_SEP,
pop, CF_LABEL_SEP,
psource, CF_LABEL_SEP,
map_name);
vbuf = kcdbget(main_db, keys_to_use[i], strlen(keys_to_use[i]), &vsiz);
if (vbuf) {
msg_new[j] = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)vbuf);
if (msg_new[j] == NULL) { // Something failed
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("error unpacking incoming message")));
} else {
if (msg_new[j]->kv_map_file) {
num_entries = MAX_KEYS_BEFORE_KV_MAP + 1;
} else {
num_entries += msg_new[j]->n_map_entry;
}
j++;
}
kcfree(vbuf);
} else {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("get error on %s -- %s", keys_to_use[i], kcecodename(kcdbecode(main_db)))));
#endif
}
}
// Now merge the buffers.
KCDB* msg_db = NULL;
if (num_entries > MAX_KEYS_BEFORE_KV_MAP) {
msg_db = kcdbnew();
set_kv_path(&msg, map_name, start_time, msg_db);
}
for (i = 0; i < j; i++) {
if (num_entries > MAX_KEYS_BEFORE_KV_MAP) {
num_new_keys += merge_using_kv_map(&msg, msg_new[i], msg_db);
} else {
num_new_keys += merge_messages_basic(&msg, msg_new[i]);
}
cloudflare__zone_time_bucket__free_unpacked(msg_new[i], NULL);
}
if (num_entries > MAX_KEYS_BEFORE_KV_MAP) {
// Close the db.
kcdbendtran (msg_db, 1);
kcdbclose(msg_db);
}
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("saving: num map entries: %zu -- writting with %d keys", msg.n_map_entry, num_new_keys)));
#endif
// Save the updated buffer.
if (num_new_keys > 0) {
unsigned int len;
void *buf;
len = cloudflare__zone_time_bucket__get_packed_size (&msg);
buf = palloc (len);
cloudflare__zone_time_bucket__pack (&msg, buf);
if(!kcdbset(main_db, msg.db_key, strlen(msg.db_key), buf, len)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("set error: %s\n", kcecodename(kcdbecode(main_db)))));
}
pfree (buf);
}
// Done!
kcdbendtran (main_db, 1);
if (!kcdbclose(main_db)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(main_db)))));
}
tout = cstring_to_text(new_rid);
PG_RETURN_TEXT_P(tout);
}
Datum kc_expand(PG_FUNCTION_ARGS) {
KC_ENTRY *search;
FuncCallContext *funcctx;
int call_cntr;
char *kbuf;
size_t ksiz, vsiz;
const char *cvbuf;
char *kv_kbuf = NULL;
size_t kv_ksiz;
int done;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL()) {
MemoryContext oldcontext;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/* switch to memory context appropriate for multiple function calls */
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
// Make sure that there are enough args.
if (PG_NARGS() < MIN_ARGS) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("Must run expand with at least %d args!", MIN_ARGS)));
}
/* Make the kcdb here. */
search = (KC_ENTRY *)palloc(sizeof(KC_ENTRY));
search->db = kcdbnew();
if (open_db (search->db, text_to_cstring(PG_GETARG_TEXT_PP(0)), text_to_cstring(PG_GETARG_TEXT_PP(1)))) {
// Set the key to jump into:
// Call with -- map_name, result_id, class, doctype, pop, psource
// Here, map_name describes a db to open.
// Otherwise, result_id:class:doctype:pop:psource
(search->jump_key) = (char *) palloc(MAX_JUMP_KEY_LEN * sizeof(char));
int index_point;
search->jump_key = text_to_cstring(PG_GETARG_TEXT_PP(2));
int size_left = MAX_JUMP_KEY_LEN;
for (index_point = START_VARIABLE_INDEX; index_point < END_VARIABLE_INDEX; index_point++) {
if (PG_NARGS() > index_point) {
char *next_idx = text_to_cstring(PG_GETARG_TEXT_PP(index_point));
if (next_idx != NULL) {
size_left = size_left - (2 + strlen(next_idx));
strncat (search->jump_key, CF_LABEL_SEP, size_left);
strncat (search->jump_key, next_idx, size_left);
}
}
}
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Setting jump buffer -- [%s]", search->jump_key)));
#endif
// Create a cursor, and set it to the base point looking for entries.
search->cur = kcdbcursor(search->db);
kccurjumpkey(search->cur, search->jump_key, MAX_JUMP_KEY_LEN);
} else {
search->db = NULL;
}
search->next_map = 0;
search->msg = NULL;
// Save the search struct for the subsequent calls.
funcctx->user_fctx = search;
MemoryContextSwitchTo(oldcontext);
}
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
search = (KC_ENTRY *) funcctx->user_fctx;
// If no current msg, try to get the next one.
done = 1;
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("beginning run")));
#endif
if (search->msg) {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Incrementing next from map %d -- %zu", search->next_map, search->msg->n_map_entry)));
#endif
// Case if we are using the external cursor running over kv map.
// Ready the next
if (search->msg->kv_map_file) {
if ((kv_kbuf = kccurgetkey(search->kv_cur, &kv_ksiz, 1)) == NULL) {
done = 1;
kccurdel(search->kv_cur);
kcdbendtran (search->kv_db, 1);
if (!kcdbclose(search->kv_db)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->kv_db)))));
}
// Also need to free this.
cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL);
search->msg = NULL;
} else {
done = 0;
}
} else {
if (search->next_map >= search->msg->n_map_entry) {
// Done with this msg -- move on to the next one.
cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL);
search->msg = NULL;
} else {
done = 0;
}
}
}
if (search->db && !search->msg) {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Getting new buf -- %s", search->jump_key)));
#endif
if ((kbuf = kccurget(search->cur, &ksiz, &cvbuf, &vsiz, 1)) != NULL) {
// Pull up the PB and expand it.
search->msg = cloudflare__zone_time_bucket__unpack(NULL, vsiz, (const uint8_t *)cvbuf);
if (search->msg == NULL) { // Something failed
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("error unpacking incoming message")));
done = 1;
} else {
// Does the buffer match the searched for string?
// @TODO -- bound this?
if (strstr(search->msg->db_key, search->jump_key)) {
done = 0;
search->next_map = 0;
// And load the kvkc if needed.
if (search->msg->kv_map_file) {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Switching to kvs %s", search->msg->kv_map_file)));
#endif
search->kv_db = kcdbnew();
if (!kcdbopen(search->kv_db, search->msg->kv_map_file, KCOWRITER)) {
#ifdef CF_NO_DB_IS_ERR
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.",
search->msg->kv_map_file, kcecodename(kcdbecode(search->kv_db)))));
#endif
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Error opening db: \"%s\", \"%s\". Make sure that the map_name is valid.",
search->msg->kv_map_file, kcecodename(kcdbecode(search->kv_db)))));
#endif
done = 1;
} else {
kcdbbegintran (search->kv_db, 0);
search->kv_cur = kcdbcursor(search->kv_db);
kccurjump(search->kv_cur);
if ((kv_kbuf = kccurgetkey(search->kv_cur, &kv_ksiz, 1)) == NULL) {
done = 1;
kccurdel(search->kv_cur);
kcdbendtran (search->kv_db, 1);
if (!kcdbclose(search->kv_db)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->kv_db)))));
}
} else {
done = 0;
}
}
}
} else {
done = 1;
}
}
kcfree(kbuf);
} else {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("no msg to find")));
#endif
done = 1;
}
}
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Done? %d -- next buf -- %d", done, search->next_map)));
#endif
// Take the next itteration over the cursor. If the next is NULL or else not matching the resultid passed in
// End. Otherwise, parse the value, populating the next row of the returning tuple.
if (!done) {
KC_ROW *out;
Datum result;
size_t size = sizeof(KC_ROW);
out = (KC_ROW *)palloc(size);
memset(out, '0', size);
SET_VARSIZE(out, size);
out->classification = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
out->doctype = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
out->pop = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
out->psource = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
out->key = (char *)palloc(MAX_KC_ROW_ENTRY * sizeof(char));
strncpy(out->classification, search->msg->classification, MAX_KC_ROW_ENTRY);
strncpy(out->doctype, search->msg->doctype, MAX_KC_ROW_ENTRY);
strncpy(out->pop, search->msg->pop, MAX_KC_ROW_ENTRY);
strncpy(out->psource, search->msg->psource, MAX_KC_ROW_ENTRY);
if (search->msg->kv_map_file) {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("getting val from -- [%s]", search->msg->kv_map_file)));
#endif
snprintf(out->key, MAX_KC_ROW_ENTRY, "%s", kv_kbuf);
out->value = kcdbincrint (search->kv_db, kv_kbuf, kv_ksiz, 0);
if (out->value == INT64_MIN) {
ereport(NOTICE,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("ERROR Getting val from key -- [%s], %s", kv_kbuf, kcecodename(kcdbecode(search->kv_db)))));
}
kcfree(kv_kbuf);
} else {
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Loading %s %ld", search->msg->map_entry[search->next_map]->key,
search->msg->map_entry[search->next_map]->value)));
#endif
snprintf(out->key, MAX_KC_ROW_ENTRY, "%s", search->msg->map_entry[search->next_map]->key);
out->value = search->msg->map_entry[search->next_map]->value;
}
result = PointerGetDatum(out);
/* clean up (this is not really necessary) */
pfree(out->classification);
pfree(out->doctype);
pfree(out->pop);
pfree(out->psource);
pfree(out->key);
pfree(out);
// Remember that we are going to the next step.
search->next_map++;
SRF_RETURN_NEXT(funcctx, result);
} else { /* do when there is no more left */
if (search->db) {
kccurdel(search->cur);
if (!kcdbclose(search->db)) {
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
errmsg("Error Closeing db: \"%s\"", kcecodename(kcdbecode(search->db)))));
}
if (search->msg != NULL) {
cloudflare__zone_time_bucket__free_unpacked(search->msg, NULL);
}
pfree(search->jump_key);
}
pfree(search);
#ifdef CF_DUBUG
ereport(NOTICE,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("Done with run")));
#endif
// Don't delete db, this leads to segfaults.
SRF_RETURN_DONE(funcctx);
}
}
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);
}
