4a0a46b06027120b21116428f389ac548b18216c
[people/ms/libloc.git] / src / stringpool.c
1 /*
2 libloc - A library to determine the location of someone on the Internet
3
4 Copyright (C) 2017 IPFire Development Team <info@ipfire.org>
5
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15 */
16
17 #include <errno.h>
18 #include <stddef.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <sys/mman.h>
23 #include <unistd.h>
24
25 #include <loc/libloc.h>
26 #include <loc/format.h>
27 #include "libloc-private.h"
28 #include "stringpool.h"
29
30 struct loc_stringpool {
31 struct loc_ctx* ctx;
32
33 int refcount;
34 char* data;
35 char* pos;
36
37 ssize_t max_length;
38 };
39
40 static int loc_stringpool_deallocate(struct loc_stringpool* pool) {
41 if (pool->data) {
42 int r = munmap(pool->data, pool->max_length);
43 if (r) {
44 ERROR(pool->ctx, "Could not unmap data at %p: %s\n",
45 pool->data, strerror(errno));
46
47 return r;
48 }
49 }
50
51 return 0;
52 }
53
54 static int loc_stringpool_allocate(struct loc_stringpool* pool, size_t length) {
55 // Drop old data
56 int r = loc_stringpool_deallocate(pool);
57 if (r)
58 return r;
59
60 pool->max_length = length;
61
62 // Align to page size
63 while (pool->max_length % sysconf(_SC_PAGE_SIZE) > 0)
64 pool->max_length++;
65
66 DEBUG(pool->ctx, "Allocating pool of %zu bytes\n", pool->max_length);
67
68 // Allocate some memory
69 pool->data = pool->pos = mmap(NULL, pool->max_length,
70 PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
71
72 if (pool->data == MAP_FAILED) {
73 DEBUG(pool->ctx, "%s\n", strerror(errno));
74 return -errno;
75 }
76
77 DEBUG(pool->ctx, "Allocated pool at %p\n", pool->data);
78
79 return 0;
80 }
81
82 LOC_EXPORT int loc_stringpool_new(struct loc_ctx* ctx, struct loc_stringpool** pool, size_t max_length) {
83 struct loc_stringpool* p = calloc(1, sizeof(*p));
84 if (!p)
85 return -ENOMEM;
86
87 p->ctx = loc_ref(ctx);
88 p->refcount = 1;
89
90 // Allocate the data section
91 if (max_length > 0) {
92 int r = loc_stringpool_allocate(p, max_length);
93 if (r) {
94 loc_stringpool_unref(p);
95 return r;
96 }
97 }
98
99 DEBUG(p->ctx, "String pool allocated at %p\n", p);
100 DEBUG(p->ctx, " Maximum size: %zu bytes\n", p->max_length);
101 *pool = p;
102
103 return 0;
104 }
105
106 LOC_EXPORT struct loc_stringpool* loc_stringpool_ref(struct loc_stringpool* pool) {
107 pool->refcount++;
108
109 return pool;
110 }
111
112 static void loc_stringpool_free(struct loc_stringpool* pool) {
113 DEBUG(pool->ctx, "Releasing string pool %p\n", pool);
114
115 loc_stringpool_deallocate(pool);
116 loc_unref(pool->ctx);
117 free(pool);
118 }
119
120 LOC_EXPORT struct loc_stringpool* loc_stringpool_unref(struct loc_stringpool* pool) {
121 if (--pool->refcount > 0)
122 return NULL;
123
124 loc_stringpool_free(pool);
125
126 return NULL;
127 }
128
129 static off_t loc_stringpool_get_offset(struct loc_stringpool* pool, const char* pos) {
130 if (pos < pool->data)
131 return -EFAULT;
132
133 if (pos > (pool->data + pool->max_length))
134 return -EFAULT;
135
136 return pos - pool->data;
137 }
138
139 static off_t loc_stringpool_get_next_offset(struct loc_stringpool* pool, off_t offset) {
140 const char* string = loc_stringpool_get(pool, offset);
141
142 return offset + strlen(string) + 1;
143 }
144
145 static size_t loc_stringpool_space_left(struct loc_stringpool* pool) {
146 return pool->max_length - loc_stringpool_get_size(pool);
147 }
148
149 LOC_EXPORT const char* loc_stringpool_get(struct loc_stringpool* pool, off_t offset) {
150 if (offset >= (ssize_t)pool->max_length)
151 return NULL;
152
153 const char* string = pool->data + offset;
154
155 // If the string is empty, we have reached the end
156 if (!*string)
157 return NULL;
158
159 return string;
160 }
161
162 LOC_EXPORT size_t loc_stringpool_get_size(struct loc_stringpool* pool) {
163 return loc_stringpool_get_offset(pool, pool->pos);
164 }
165
166 static off_t loc_stringpool_find(struct loc_stringpool* pool, const char* s) {
167 if (!s || !*s)
168 return -EINVAL;
169
170 off_t offset = 0;
171 while (offset < pool->max_length) {
172 const char* string = loc_stringpool_get(pool, offset);
173 if (!string)
174 break;
175
176 int r = strcmp(s, string);
177 if (r == 0)
178 return offset;
179
180 offset = loc_stringpool_get_next_offset(pool, offset);
181 }
182
183 return -ENOENT;
184 }
185
186 static off_t loc_stringpool_append(struct loc_stringpool* pool, const char* string) {
187 if (!string || !*string)
188 return -EINVAL;
189
190 DEBUG(pool->ctx, "Appending '%s' to string pool at %p\n", string, pool);
191
192 // Check if we have enough space left
193 size_t l = strlen(string) + 1;
194 if (l > loc_stringpool_space_left(pool)) {
195 DEBUG(pool->ctx, "Not enough space to append '%s'\n", string);
196 DEBUG(pool->ctx, " Need %zu bytes but only have %zu\n", l, loc_stringpool_space_left(pool));
197 return -ENOSPC;
198 }
199
200 off_t offset = loc_stringpool_get_offset(pool, pool->pos);
201
202 // Copy string byte by byte
203 while (*string && loc_stringpool_space_left(pool) > 1) {
204 *pool->pos++ = *string++;
205 }
206
207 // Terminate the string
208 *pool->pos++ = '\0';
209
210 return offset;
211 }
212
213 LOC_EXPORT off_t loc_stringpool_add(struct loc_stringpool* pool, const char* string) {
214 off_t offset = loc_stringpool_find(pool, string);
215 if (offset >= 0) {
216 DEBUG(pool->ctx, "Found '%s' at position %jd\n", string, offset);
217 return offset;
218 }
219
220 return loc_stringpool_append(pool, string);
221 }
222
223 LOC_EXPORT void loc_stringpool_dump(struct loc_stringpool* pool) {
224 off_t offset = 0;
225
226 while (offset < pool->max_length) {
227 const char* string = loc_stringpool_get(pool, offset);
228 if (!string)
229 break;
230
231 printf("%jd (%zu): %s\n", offset, strlen(string), string);
232
233 offset = loc_stringpool_get_next_offset(pool, offset);
234 }
235 }
236
237 LOC_EXPORT int loc_stringpool_read(struct loc_stringpool* pool, FILE* f, off_t offset, size_t length) {
238 DEBUG(pool->ctx, "Reading string pool from %zu (%zu bytes)\n", offset, length);
239
240 pool->data = pool->pos = mmap(NULL, length, PROT_READ,
241 MAP_PRIVATE, fileno(f), offset);
242 pool->max_length = length;
243
244 if (pool->data == MAP_FAILED)
245 return -errno;
246
247 return 0;
248 }
249
250 LOC_EXPORT size_t loc_stringpool_write(struct loc_stringpool* pool, FILE* f) {
251 size_t size = loc_stringpool_get_size(pool);
252
253 return fwrite(pool->data, sizeof(*pool->data), size, f);
254 }