d892541d8d6ac856b09ba3337672b6f923624962
[blerg.git] / common / stringbucket.c
1 /* Blerg is (C) 2011 The Dominion of Awesome, and is distributed under a
2  * BSD-style license.  Please see the COPYING file for details.
3  */
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <sys/mman.h>
7 #include <sys/file.h>
8 #include <fcntl.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <stringbucket.h>
13
14 #define STRINGBUCKET_STRINGSIZE 64
15
16 const char * strnchr(const char *s, int c, int n) {
17         const char *ptr = s;
18         while (n > 0) {
19                 if (*ptr == c)
20                         return ptr;
21                 ptr++;
22                 n--;
23         }
24         return NULL;
25 }
26
27 struct stringbucket * stringbucket_open(const char *filename) {
28         struct stat st;
29         struct stringbucket *obj = malloc(sizeof(struct stringbucket));
30
31         if (obj == NULL) {
32                 perror("stringbucket allocate");
33                 return NULL;
34         }
35
36         obj->fd = open(filename, O_RDWR | O_APPEND | O_CREAT, 0600);
37         flock(obj->fd, LOCK_SH);
38         fstat(obj->fd, &st);
39         flock(obj->fd, LOCK_UN);
40         obj->size = st.st_size;
41         obj->list = mmap(NULL, obj->size, PROT_READ | PROT_WRITE, MAP_SHARED, obj->fd, 0);
42         if (obj->list == NULL) {
43                 perror("stringbucket mmap");
44                 close(obj->fd);
45                 free(obj);
46                 return 0;
47         }
48
49         return obj;
50 }
51
52 void stringbucket_close(struct stringbucket *sb) {
53         munmap(sb->list, sb->size);
54         close(sb->fd);
55         free(sb);
56 }
57
58 int stringbucket_find(struct stringbucket *sb, const char *string) {
59         char * end = sb->list + sb->size;
60         int string_len = strlen(string);
61
62         char * ptr = sb->list;
63         while (ptr < end) {
64                 char * next = (char *) strnchr(ptr, '\n', end - ptr);
65                 if (next == NULL)
66                         next = end;
67                 int len = next - ptr;
68                 if (len > STRINGBUCKET_STRINGSIZE)
69                         len = STRINGBUCKET_STRINGSIZE;
70                 if (memcmp(ptr, string, (len < string_len ? string_len : len)) == 0) {
71                         return (ptr - sb->list);
72                 }
73                 ptr = next + 1;
74         }
75
76         return -1;
77 }
78
79 int stringbucket_add(struct stringbucket *sb, const char *string) {
80         if (stringbucket_find(sb, string) != -1) return 0;
81         flock(sb->fd, LOCK_EX);
82         write(sb->fd, string, strlen(string));
83         write(sb->fd, "\n", 1);
84         flock(sb->fd, LOCK_UN);
85         return 1;
86 }
87
88 int stringbucket_delete(struct stringbucket *sb, const char *string) {
89         int pos = stringbucket_find(sb, string);
90         if (pos == -1) return 0;
91
92         /* We doin' it DOS style! */
93         sb->list[pos] = 0;
94 }
95
96 void stringbucket_iterate(struct stringbucket *sb, void (*iter)(char *, void *), void *stuff) {
97         char string[STRINGBUCKET_STRINGSIZE + 1];
98         char * ptr = sb->list;
99         char * end = sb->list + sb->size;
100
101         while (ptr < end) {
102                 char * next = (char *) strnchr(ptr, '\n', end - ptr);
103                 if (next == NULL)
104                         next = end;
105                 if (ptr[0] == 0) {
106                         ptr = next + 1;
107                         continue;
108                 }
109                 int len = next - ptr;
110                 memcpy(string, ptr, len);
111                 string[len] = 0;
112                 iter(string, stuff);
113                 ptr = next + 1;
114         }
115 }