X-Git-Url: http://git.bytex64.net/?a=blobdiff_plain;f=database%2Ftags.c;h=ba7c376031d246a65473e7b9729c5b882a40f472;hb=3e3138025852408ef03f3213972e042e12841bed;hp=5b3b3ce9ab8ed5c5c3ece9f7b3ac6ed462705c48;hpb=efabc7da2c7dff11ab6835d23655a023f1cbc296;p=blerg.git

diff --git a/database/tags.c b/database/tags.c
index 5b3b3ce..ba7c376 100644
--- a/database/tags.c
+++ b/database/tags.c
@@ -14,6 +14,7 @@
 #include "util.h"
 #include "database.h"
 #include "config.h"
+#include "configuration.h"
 
 
 int tag_scan(const char *author, const char *data, int len, uint64_t record) {
@@ -58,11 +59,13 @@ 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;
+	const char *tagval = tag + 1;
 
 	memset(t.author, 0, 32);
 	strncpy(t.author, author, 32);
@@ -70,10 +73,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, tagval);
 		break;
 	case '@':
-		snprintf(filename, 512, "%s/%s", REF_TAGS_PATH, tag + 1);
+		snprintf(filename, FILENAME_MAX, "%s/%s", blergconf.ref_tags_path, tagval);
 		break;
 	default:
 		fprintf(stderr, "Invalid tag type: %s\n", tag);
@@ -86,33 +89,47 @@ 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;
 	}
 	flock(tag_fd, LOCK_UN);
 	close(tag_fd);
 
+	/* Set a flag for mentioned users */
+	if (tag[0] == '@' && blerg_exists(tagval)) {
+		struct blerg *b = blerg_open(tagval);
+		if (b != NULL) {
+			blerg_set_status(b, BLERGSTATUS_MENTIONED, 1);
+			blerg_close(b);
+		}
+	}
+
 	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_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);
@@ -122,42 +139,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) {
-		*count = 0;
 		goto tag_list_map_failed;
 	}
-	n_tag_records = st.st_size / sizeof(struct tag);
+	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");
-		*count = 0;
 		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");
-		*count = 0;
 		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");
-		*count = 0;
 		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;
 	}
 
@@ -170,11 +182,12 @@ 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_tag_name(tag + 1))
 		return 0;
@@ -186,10 +199,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);