Clean up some #defines

[blerg.git] / database.c

diff --git a/database.c b/database.c
index ce03171..4b16d32 100644 (file)
--- a/database.c
+++ b/database.c
@@ -11,8 +11,6 @@
 #include "database.h"
 #include "config.h"
 
-#define RECORDS_PER_SEGMENT 65536
-
 uint64_t blerg_get_record_count(struct blerg *blerg) {
        uint64_t count;
        flock(blerg->meta_fd, LOCK_SH);
@@ -36,7 +34,7 @@ void blerg_segment_close(struct blerg *blerg) {
        if (blerg->data_fd != -1)
                close(blerg->data_fd);
        if (blerg->index != NULL)
-               munmap((void *)blerg->index, sizeof(RECORDS_PER_SEGMENT * sizeof(struct record)));
+               munmap((void *)blerg->index, RECORDS_PER_SEGMENT * sizeof(struct record));
        if (blerg->index_fd != -1)
                close(blerg->index_fd);
 }
@@ -101,13 +99,29 @@ int blerg_segment_switch(struct blerg *blerg, int new_segment) {
 open_failed_data_mmap:
        close(blerg->data_fd);
 open_failed_data_open:
-       munmap((void *)blerg->index, sizeof(65536 * sizeof(struct record)));
+       munmap((void *)blerg->index, sizeof(RECORDS_PER_SEGMENT * sizeof(struct record)));
 open_failed_index_mmap:
        close(blerg->index_fd);
 open_failed_index_open:
        return 0;
 }
 
+int blerg_exists(const char *name) {
+       int namelen = strlen(name);
+       char filename[512];
+
+       if (namelen > 32) {
+               perror("Name too long");
+               return 0;
+       }
+
+       snprintf(filename, 512, "%s/%s", DATA_PATH, name);
+       if (access(filename, F_OK) == -1)
+               return 0;
+       else
+               return 1;
+}
+
 struct blerg *blerg_open(const char *name) {
        int namelen = strlen(name);
        char filename[512];
@@ -123,6 +137,8 @@ struct blerg *blerg_open(const char *name) {
                perror("Cannot allocate memory for blerg");
                goto open_failed_blerg_malloc;
        }
+       blerg->name = malloc(namelen + 1);
+       memcpy(blerg->name, name, namelen + 1);
        blerg->meta_fd = blerg->index_fd = blerg->data_fd = -1;
        blerg->meta = NULL;
        blerg->index = NULL;
@@ -168,6 +184,7 @@ open_failed_segment_switch:
 open_failed_meta_mmap:
        close(blerg->meta_fd);
 open_failed_meta_open:
+       free(blerg->name);
        free(blerg);
 open_failed_blerg_malloc:
        return NULL;
@@ -178,12 +195,13 @@ int blerg_close(struct blerg *blerg) {
        munmap((void *)blerg->meta, sizeof(struct meta));
        close(blerg->meta_fd);
        free(blerg->base_path);
+       free(blerg->name);
        free(blerg);
        return 1;
 }
 
 int blerg_store(struct blerg *blerg, const char *data, int len) {
-       if (len > 65536) {
+       if (len > MAX_RECORD_SIZE) {
                printf("len > 64K\n");
                return -1;
        }
@@ -191,15 +209,15 @@ int blerg_store(struct blerg *blerg, const char *data, int len) {
        flock(blerg->index_fd, LOCK_EX);
        flock(blerg->data_fd, LOCK_EX);
 
-       uint64_t rec = blerg_increment_record_count(blerg);
-       if (rec == -1) {
+       uint64_t record = blerg_increment_record_count(blerg);
+       if (record == -1) {
                printf("Could not find free record\n");
                return -1;
        }
-       int segment = rec / RECORDS_PER_SEGMENT;
+       int segment = record / RECORDS_PER_SEGMENT;
        if (segment != blerg->current_segment)
                blerg_segment_switch(blerg, segment);
-       rec = rec % RECORDS_PER_SEGMENT;
+       int seg_rec = record % RECORDS_PER_SEGMENT;
 
        // Get the position for the new data
        FILE *datafile = fdopen(dup(blerg->data_fd), "a");
@@ -218,34 +236,36 @@ int blerg_store(struct blerg *blerg, const char *data, int len) {
                }
                bytes += n;
        } while (bytes < len);
-       blerg->index[rec].flags = 0x0001;
-       blerg->index[rec].offset = curpos;
-       blerg->index[rec].length = len;
+       blerg->index[seg_rec].flags = 0x0001;
+       blerg->index[seg_rec].offset = curpos;
+       blerg->index[seg_rec].length = len;
+
+       tag_scan(blerg->name, data, len, record);
 
        flock(blerg->data_fd, LOCK_UN);
        flock(blerg->index_fd, LOCK_UN);
 
-       return segment * RECORDS_PER_SEGMENT + rec;
+       return record;
 }
 
-int blerg_fetch(struct blerg *blerg, int rec, char **data, int *length) {
-       if (rec < 0) {
+int blerg_fetch(struct blerg *blerg, int record, char **data, int *length) {
+       if (record < 0) {
                printf("Invalid record\n");
                return 0;
        }
 
-       int segment = rec / RECORDS_PER_SEGMENT;
+       int segment = record / RECORDS_PER_SEGMENT;
        if (segment != blerg->current_segment)
                blerg_segment_switch(blerg, segment);
-       rec = rec % RECORDS_PER_SEGMENT;
+       int seg_rec = record % RECORDS_PER_SEGMENT;
 
-       if ((blerg->index[rec].flags & 0x1) == 0) {
+       if ((blerg->index[seg_rec].flags & 0x1) == 0) {
                printf("Invalid record\n");
                return 0;
        }
 
-       int rec_offset = blerg->index[rec].offset;
-       int rec_length = blerg->index[rec].length;
+       int rec_offset = blerg->index[seg_rec].offset;
+       int rec_length = blerg->index[seg_rec].length;
        if (rec_offset >= blerg->data_size) {
                // We're accessing an out-of-bounds record in our mmap.
                // Recheck size and remap.