Add some missing includes

[blerg.git] / database / tags.c

diff --git a/database/tags.c b/database/tags.c
index a28df02..3e3b14f 100644 (file)
--- a/database/tags.c
+++ b/database/tags.c
@@ -12,10 +12,10 @@
 #include <sys/mman.h>
 #include "tags.h"
 #include "util.h"
+#include "database.h"
 #include "config.h"
+#include "configuration.h"
 
-#define TAG_CHAR(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_')
-#define WHITESPACE(c) (c == ' ' || c == '\t' || c == '\n' || c == '\r')
 
 int tag_scan(const char *author, const char *data, int len, uint64_t record) {
        char *taglist[MAX_TAGS_PER_RECORD];
@@ -32,7 +32,7 @@ tag_scan_start:
                        }
                        int begin = i;
                        int start = ++i;
-                       while (i < len && TAG_CHAR(data[i]) && (i - start < MAX_TAG_LENGTH)) {
+                       while (i < len && VALID_CHAR(data[i]) && (i - start < MAX_TAG_LENGTH)) {
                                i++;
                        }
                        if (start - i == 0) continue;
@@ -59,11 +59,12 @@ tag_scan_start:
                tag_add(author, taglist[i], record);
                free(taglist[i]);
        }
+       return 1;
 }
 
 int tag_add(const char *author, const char *tag, uint64_t record) {
-       char filename[512];
-       struct tag t;
+       char filename[FILENAME_MAX];
+       struct blergref t;
 
        memset(t.author, 0, 32);
        strncpy(t.author, author, 32);
@@ -71,10 +72,10 @@ int tag_add(const char *author, const char *tag, uint64_t record) {
 
        switch(tag[0]) {
        case '#':
-               snprintf(filename, 512, "%s/%s", HASH_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.hash_tags_path, tag + 1);
                break;
        case '@':
-               snprintf(filename, 512, "%s/%s", REF_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.ref_tags_path, tag + 1);
                break;
        default:
                fprintf(stderr, "Invalid tag type: %s\n", tag);
@@ -87,8 +88,8 @@ int tag_add(const char *author, const char *tag, uint64_t record) {
                perror("Could not open tag file");
                return 0;
        }
-       int n = write(tag_fd, &t, sizeof(struct tag));
-       if (n < sizeof(struct tag)) {
+       int n = write(tag_fd, &t, sizeof(struct blergref));
+       if (n < sizeof(struct blergref)) {
                perror("Could not write new tag");
                return 0;
        }
@@ -98,22 +99,27 @@ int tag_add(const char *author, const char *tag, uint64_t record) {
        return 1;
 }
 
-struct tag * tag_list(const char *tag, uint64_t offset, int *count, int direction) {
-       char filename[512];
+struct blergref * tag_list(const char *tag, uint64_t offset, int *count, int direction) {
+       char filename[FILENAME_MAX];
        struct stat st;
-       struct tag *taglist;
-       struct tag *retlist;
+       struct blergref *taglist;
+       struct blergref *retlist;
        uint64_t n_tag_records;
 
-       if (!valid_name(tag + 1))
+       if (!valid_tag_name(tag + 1))
+               return NULL;
+
+       if (!(direction == 1 || direction == -1)) {
+               fprintf(stderr, "Invalid direction: %d\n", direction);
                return NULL;
+       }
        
        switch(tag[0]) {
        case '#':
-               snprintf(filename, 512, "%s/%s", HASH_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.hash_tags_path, tag + 1);
                break;
        case '@':
-               snprintf(filename, 512, "%s/%s", REF_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.ref_tags_path, tag + 1);
                break;
        default:
                fprintf(stderr, "Invalid tag type: %s\n", tag);
@@ -123,40 +129,37 @@ struct tag * tag_list(const char *tag, uint64_t offset, int *count, int directio
        int tag_fd = open(filename, O_RDONLY, 0600);
        if (tag_fd == -1) {
                perror("Could not open tag file");
-               *count = 0;
-               return NULL;
+               goto tag_list_open_failed;
        }
 
        fstat(tag_fd, &st);
        if (st.st_size == 0) {
-               close(tag_fd);
-               *count = 0;
-               return NULL;
+               goto tag_list_map_failed;
        }
-       n_tag_records = st.st_size / sizeof(struct tag);
-       if (*count > n_tag_records)
-               *count = n_tag_records;
+       n_tag_records = st.st_size / sizeof(struct blergref);
+       if (*count > n_tag_records - offset)
+               *count = n_tag_records - offset;
        if (offset > n_tag_records) {
                fprintf(stderr, "Cannot access tag record beyond end\n");
-               return NULL;
+               goto tag_list_map_failed;
        }
 
-       taglist = (struct tag *) mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, tag_fd, 0);
+       taglist = (struct blergref *) mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, tag_fd, 0);
        if (taglist == MAP_FAILED) {
                perror("Could not mmap tag file");
                goto tag_list_map_failed;
        }
-       retlist = (struct tag *) malloc(sizeof(struct tag) * *count);
+       retlist = (struct blergref *) malloc(sizeof(struct blergref) * *count);
        if (retlist == NULL) {
                perror("Could not allocate memory for tag list");
                goto tag_list_malloc_failed;
        }
        switch(direction) {
        case 1:
-               memcpy(retlist, taglist + offset, sizeof(struct tag) * *count);
+               memcpy(retlist, taglist + offset, sizeof(struct blergref) * *count);
                break;
        case -1:
-               memcpy(retlist, taglist + (n_tag_records - *count - offset), sizeof(struct tag) * *count);
+               memcpy(retlist, taglist + (n_tag_records - *count - offset), sizeof(struct blergref) * *count);
                break;
        }
 
@@ -169,13 +172,14 @@ tag_list_malloc_failed:
 tag_list_map_failed:
        close(tag_fd);
 tag_list_open_failed:
+       *count = 0;
        return NULL;
 }
 
 int tag_exists(const char *tag) {
-       char filename[512];
+       char filename[FILENAME_MAX];
 
-       if (!valid_name(tag + 1))
+       if (!valid_tag_name(tag + 1))
                return 0;
 
        if (!(tag[0] == '@' || tag[0] == '#')) {
@@ -185,10 +189,10 @@ int tag_exists(const char *tag) {
 
        switch(tag[0]) {
        case '#':
-               snprintf(filename, 512, "%s/%s", HASH_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.hash_tags_path, tag + 1);
                break;
        case '@':
-               snprintf(filename, 512, "%s/%s", REF_TAGS_PATH, tag + 1);
+               snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.ref_tags_path, tag + 1);
                break;
        default:
                fprintf(stderr, "Invalid tag type: %s\n", tag);