2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
47 * Default entries, which always exist in the configuration
49 const char *c_default_entries[6] = {
58 static int configuration_entry_cmp(const void *, const void *);
59 static int configuration_entry_sort_cmp(const void *, const void *);
60 static int configuration_entry_cache_mp_sort_cmp(const void *, const void *);
61 static int configuration_entry_cache_mp_cmp(const void *, const void *);
62 static int configuration_entry_cache_mp_part_cmp(const void *, const void *);
63 static struct configuration_entry *create_configuration_entry(const char *,
64 struct timeval const *, struct timeval const *,
65 struct common_cache_entry_params const *,
66 struct common_cache_entry_params const *,
67 struct mp_cache_entry_params const *);
70 configuration_entry_sort_cmp(const void *e1, const void *e2)
72 return (strcmp((*((struct configuration_entry **)e1))->name,
73 (*((struct configuration_entry **)e2))->name
78 configuration_entry_cmp(const void *e1, const void *e2)
80 return (strcmp((const char *)e1,
81 (*((struct configuration_entry **)e2))->name
86 configuration_entry_cache_mp_sort_cmp(const void *e1, const void *e2)
88 return (strcmp((*((cache_entry *)e1))->params->entry_name,
89 (*((cache_entry *)e2))->params->entry_name
94 configuration_entry_cache_mp_cmp(const void *e1, const void *e2)
96 return (strcmp((const char *)e1,
97 (*((cache_entry *)e2))->params->entry_name
102 configuration_entry_cache_mp_part_cmp(const void *e1, const void *e2)
104 return (strncmp((const char *)e1,
105 (*((cache_entry *)e2))->params->entry_name,
106 strlen((const char *)e1)
110 static struct configuration_entry *
111 create_configuration_entry(const char *name,
112 struct timeval const *common_timeout,
113 struct timeval const *mp_timeout,
114 struct common_cache_entry_params const *positive_params,
115 struct common_cache_entry_params const *negative_params,
116 struct mp_cache_entry_params const *mp_params)
118 struct configuration_entry *retval;
122 TRACE_IN(create_configuration_entry);
123 assert(name != NULL);
124 assert(positive_params != NULL);
125 assert(negative_params != NULL);
126 assert(mp_params != NULL);
130 assert(retval != NULL);
132 res = pthread_mutex_init(&retval->positive_cache_lock, NULL);
135 LOG_ERR_2("create_configuration_entry",
136 "can't create positive cache lock");
137 TRACE_OUT(create_configuration_entry);
141 res = pthread_mutex_init(&retval->negative_cache_lock, NULL);
143 pthread_mutex_destroy(&retval->positive_cache_lock);
145 LOG_ERR_2("create_configuration_entry",
146 "can't create negative cache lock");
147 TRACE_OUT(create_configuration_entry);
151 res = pthread_mutex_init(&retval->mp_cache_lock, NULL);
153 pthread_mutex_destroy(&retval->positive_cache_lock);
154 pthread_mutex_destroy(&retval->negative_cache_lock);
156 LOG_ERR_2("create_configuration_entry",
157 "can't create negative cache lock");
158 TRACE_OUT(create_configuration_entry);
162 memcpy(&retval->positive_cache_params, positive_params,
163 sizeof(struct common_cache_entry_params));
164 memcpy(&retval->negative_cache_params, negative_params,
165 sizeof(struct common_cache_entry_params));
166 memcpy(&retval->mp_cache_params, mp_params,
167 sizeof(struct mp_cache_entry_params));
170 retval->name = calloc(1, size + 1);
171 assert(retval->name != NULL);
172 memcpy(retval->name, name, size);
174 memcpy(&retval->common_query_timeout, common_timeout,
175 sizeof(struct timeval));
176 memcpy(&retval->mp_query_timeout, mp_timeout,
177 sizeof(struct timeval));
179 asprintf(&retval->positive_cache_params.cep.entry_name, "%s+", name);
180 assert(retval->positive_cache_params.cep.entry_name != NULL);
182 asprintf(&retval->negative_cache_params.cep.entry_name, "%s-", name);
183 assert(retval->negative_cache_params.cep.entry_name != NULL);
185 asprintf(&retval->mp_cache_params.cep.entry_name, "%s*", name);
186 assert(retval->mp_cache_params.cep.entry_name != NULL);
188 TRACE_OUT(create_configuration_entry);
193 * Creates configuration entry and fills it with default values
195 struct configuration_entry *
196 create_def_configuration_entry(const char *name)
198 struct common_cache_entry_params positive_params, negative_params;
199 struct mp_cache_entry_params mp_params;
200 struct timeval default_common_timeout, default_mp_timeout;
202 struct configuration_entry *res = NULL;
204 TRACE_IN(create_def_configuration_entry);
205 memset(&positive_params, 0,
206 sizeof(struct common_cache_entry_params));
207 positive_params.cep.entry_type = CET_COMMON;
208 positive_params.cache_entries_size = DEFAULT_CACHE_HT_SIZE;
209 positive_params.max_elemsize = DEFAULT_POSITIVE_ELEMENTS_SIZE;
210 positive_params.satisf_elemsize = DEFAULT_POSITIVE_ELEMENTS_SIZE / 2;
211 positive_params.max_lifetime.tv_sec = DEFAULT_POSITIVE_LIFETIME;
212 positive_params.policy = CPT_LRU;
214 memcpy(&negative_params, &positive_params,
215 sizeof(struct common_cache_entry_params));
216 negative_params.max_elemsize = DEFAULT_NEGATIVE_ELEMENTS_SIZE;
217 negative_params.satisf_elemsize = DEFAULT_NEGATIVE_ELEMENTS_SIZE / 2;
218 negative_params.max_lifetime.tv_sec = DEFAULT_NEGATIVE_LIFETIME;
219 negative_params.policy = CPT_FIFO;
221 memset(&default_common_timeout, 0, sizeof(struct timeval));
222 default_common_timeout.tv_sec = DEFAULT_COMMON_ENTRY_TIMEOUT;
224 memset(&default_mp_timeout, 0, sizeof(struct timeval));
225 default_mp_timeout.tv_sec = DEFAULT_MP_ENTRY_TIMEOUT;
227 memset(&mp_params, 0,
228 sizeof(struct mp_cache_entry_params));
229 mp_params.cep.entry_type = CET_MULTIPART;
230 mp_params.max_elemsize = DEFAULT_MULTIPART_ELEMENTS_SIZE;
231 mp_params.max_sessions = DEFAULT_MULITPART_SESSIONS_SIZE;
232 mp_params.max_lifetime.tv_sec = DEFAULT_MULITPART_LIFETIME;
234 res = create_configuration_entry(name, &default_common_timeout,
235 &default_mp_timeout, &positive_params, &negative_params,
238 TRACE_OUT(create_def_configuration_entry);
243 destroy_configuration_entry(struct configuration_entry *entry)
245 TRACE_IN(destroy_configuration_entry);
246 assert(entry != NULL);
247 pthread_mutex_destroy(&entry->positive_cache_lock);
248 pthread_mutex_destroy(&entry->negative_cache_lock);
249 pthread_mutex_destroy(&entry->mp_cache_lock);
251 free(entry->positive_cache_params.cep.entry_name);
252 free(entry->negative_cache_params.cep.entry_name);
253 free(entry->mp_cache_params.cep.entry_name);
254 free(entry->mp_cache_entries);
256 TRACE_OUT(destroy_configuration_entry);
260 add_configuration_entry(struct configuration *config,
261 struct configuration_entry *entry)
263 TRACE_IN(add_configuration_entry);
264 assert(entry != NULL);
265 assert(entry->name != NULL);
266 if (configuration_find_entry(config, entry->name) != NULL) {
267 TRACE_OUT(add_configuration_entry);
271 if (config->entries_size == config->entries_capacity) {
272 struct configuration_entry **new_entries;
274 config->entries_capacity *= 2;
275 new_entries = calloc(1,
276 sizeof(*new_entries) *
277 config->entries_capacity);
278 assert(new_entries != NULL);
279 memcpy(new_entries, config->entries,
280 sizeof(struct configuration_entry *) *
281 config->entries_size);
283 free(config->entries);
284 config->entries = new_entries;
287 config->entries[config->entries_size++] = entry;
288 qsort(config->entries, config->entries_size,
289 sizeof(struct configuration_entry *),
290 configuration_entry_sort_cmp);
292 TRACE_OUT(add_configuration_entry);
297 configuration_get_entries_size(struct configuration *config)
299 TRACE_IN(configuration_get_entries_size);
300 assert(config != NULL);
301 TRACE_OUT(configuration_get_entries_size);
302 return (config->entries_size);
305 struct configuration_entry *
306 configuration_get_entry(struct configuration *config, size_t index)
308 TRACE_IN(configuration_get_entry);
309 assert(config != NULL);
310 assert(index < config->entries_size);
311 TRACE_OUT(configuration_get_entry);
312 return (config->entries[index]);
315 struct configuration_entry *
316 configuration_find_entry(struct configuration *config,
319 struct configuration_entry **retval;
321 TRACE_IN(configuration_find_entry);
323 retval = bsearch(name, config->entries, config->entries_size,
324 sizeof(struct configuration_entry *), configuration_entry_cmp);
325 TRACE_OUT(configuration_find_entry);
327 return ((retval != NULL) ? *retval : NULL);
331 * All multipart cache entries are stored in the configuration_entry in the
332 * sorted array (sorted by names). The 3 functions below manage this array.
336 configuration_entry_add_mp_cache_entry(struct configuration_entry *config_entry,
339 cache_entry *new_mp_entries, *old_mp_entries;
341 TRACE_IN(configuration_entry_add_mp_cache_entry);
342 ++config_entry->mp_cache_entries_size;
343 new_mp_entries = malloc(sizeof(*new_mp_entries) *
344 config_entry->mp_cache_entries_size);
345 assert(new_mp_entries != NULL);
346 new_mp_entries[0] = c_entry;
348 if (config_entry->mp_cache_entries_size - 1 > 0) {
349 memcpy(new_mp_entries + 1,
350 config_entry->mp_cache_entries,
351 (config_entry->mp_cache_entries_size - 1) *
352 sizeof(cache_entry));
355 old_mp_entries = config_entry->mp_cache_entries;
356 config_entry->mp_cache_entries = new_mp_entries;
357 free(old_mp_entries);
359 qsort(config_entry->mp_cache_entries,
360 config_entry->mp_cache_entries_size,
362 configuration_entry_cache_mp_sort_cmp);
364 TRACE_OUT(configuration_entry_add_mp_cache_entry);
369 configuration_entry_find_mp_cache_entry(
370 struct configuration_entry *config_entry, const char *mp_name)
374 TRACE_IN(configuration_entry_find_mp_cache_entry);
375 result = bsearch(mp_name, config_entry->mp_cache_entries,
376 config_entry->mp_cache_entries_size,
377 sizeof(cache_entry), configuration_entry_cache_mp_cmp);
379 if (result == NULL) {
380 TRACE_OUT(configuration_entry_find_mp_cache_entry);
383 TRACE_OUT(configuration_entry_find_mp_cache_entry);
389 * Searches for all multipart entries with names starting with mp_name.
390 * Needed for cache flushing.
393 configuration_entry_find_mp_cache_entries(
394 struct configuration_entry *config_entry, const char *mp_name,
395 cache_entry **start, cache_entry **finish)
399 TRACE_IN(configuration_entry_find_mp_cache_entries);
400 result = bsearch(mp_name, config_entry->mp_cache_entries,
401 config_entry->mp_cache_entries_size,
402 sizeof(cache_entry), configuration_entry_cache_mp_part_cmp);
404 if (result == NULL) {
405 TRACE_OUT(configuration_entry_find_mp_cache_entries);
410 *finish = result + 1;
412 while (*start != config_entry->mp_cache_entries) {
413 if (configuration_entry_cache_mp_part_cmp(mp_name, *start - 1) == 0)
419 while (*finish != config_entry->mp_cache_entries +
420 config_entry->mp_cache_entries_size) {
422 if (configuration_entry_cache_mp_part_cmp(
423 mp_name, *finish) == 0)
424 *finish = *finish + 1;
429 TRACE_OUT(configuration_entry_find_mp_cache_entries);
434 * Configuration entry uses rwlock to handle access to its fields.
437 configuration_lock_rdlock(struct configuration *config)
439 TRACE_IN(configuration_lock_rdlock);
440 pthread_rwlock_rdlock(&config->rwlock);
441 TRACE_OUT(configuration_lock_rdlock);
445 configuration_lock_wrlock(struct configuration *config)
447 TRACE_IN(configuration_lock_wrlock);
448 pthread_rwlock_wrlock(&config->rwlock);
449 TRACE_OUT(configuration_lock_wrlock);
453 configuration_unlock(struct configuration *config)
455 TRACE_IN(configuration_unlock);
456 pthread_rwlock_unlock(&config->rwlock);
457 TRACE_OUT(configuration_unlock);
461 * Configuration entry uses 3 mutexes to handle cache operations. They are
462 * acquired by configuration_lock_entry and configuration_unlock_entry
466 configuration_lock_entry(struct configuration_entry *entry,
467 enum config_entry_lock_type lock_type)
469 TRACE_IN(configuration_lock_entry);
470 assert(entry != NULL);
474 pthread_mutex_lock(&entry->positive_cache_lock);
477 pthread_mutex_lock(&entry->negative_cache_lock);
480 pthread_mutex_lock(&entry->mp_cache_lock);
483 /* should be unreachable */
486 TRACE_OUT(configuration_lock_entry);
490 configuration_unlock_entry(struct configuration_entry *entry,
491 enum config_entry_lock_type lock_type)
493 TRACE_IN(configuration_unlock_entry);
494 assert(entry != NULL);
498 pthread_mutex_unlock(&entry->positive_cache_lock);
501 pthread_mutex_unlock(&entry->negative_cache_lock);
504 pthread_mutex_unlock(&entry->mp_cache_lock);
507 /* should be unreachable */
510 TRACE_OUT(configuration_unlock_entry);
513 struct configuration *
514 init_configuration(void)
516 struct configuration *retval;
518 TRACE_IN(init_configuration);
519 retval = calloc(1, sizeof(*retval));
520 assert(retval != NULL);
522 retval->entries_capacity = INITIAL_ENTRIES_CAPACITY;
523 retval->entries = calloc(1,
524 sizeof(*retval->entries) *
525 retval->entries_capacity);
526 assert(retval->entries != NULL);
528 pthread_rwlock_init(&retval->rwlock, NULL);
530 TRACE_OUT(init_configuration);
535 fill_configuration_defaults(struct configuration *config)
539 TRACE_IN(fill_configuration_defaults);
540 assert(config != NULL);
542 if (config->socket_path != NULL)
543 free(config->socket_path);
545 len = strlen(DEFAULT_SOCKET_PATH);
546 config->socket_path = calloc(1, len + 1);
547 assert(config->socket_path != NULL);
548 memcpy(config->socket_path, DEFAULT_SOCKET_PATH, len);
550 len = strlen(DEFAULT_PIDFILE_PATH);
551 config->pidfile_path = calloc(1, len + 1);
552 assert(config->pidfile_path != NULL);
553 memcpy(config->pidfile_path, DEFAULT_PIDFILE_PATH, len);
555 config->socket_mode = S_IFSOCK | S_IRUSR | S_IWUSR |
556 S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
557 config->force_unlink = 1;
559 config->query_timeout = DEFAULT_QUERY_TIMEOUT;
560 config->threads_num = DEFAULT_THREADS_NUM;
562 for (i = 0; i < config->entries_size; ++i)
563 destroy_configuration_entry(config->entries[i]);
564 config->entries_size = 0;
566 TRACE_OUT(fill_configuration_defaults);
570 destroy_configuration(struct configuration *config)
574 TRACE_IN(destroy_configuration);
575 assert(config != NULL);
576 free(config->pidfile_path);
577 free(config->socket_path);
579 for (i = 0; i < config->entries_size; ++i)
580 destroy_configuration_entry(config->entries[i]);
581 free(config->entries);
583 pthread_rwlock_destroy(&config->rwlock);
585 TRACE_OUT(destroy_configuration);