Convert rbl to use array_t.
Signed-off-by: Florent Bruneau <florent.bruneau@polytechnique.org>
#include "common.h"
#include "mem.h"
#include "common.h"
#include "mem.h"
#define PRIV_ARRAY(Type) \
struct { \
#define PRIV_ARRAY(Type) \
struct { \
array_wipe(array); \
} while (0)
array_wipe(array); \
} while (0)
+#define array_lock(array) \
+ !(mlock((array).data, (array).len * sizeof(*(array).data)) != 0)
+#define array_unlock(array) \
+ (void)munlock((array).data, (array).len * sizeof(*(array).data))
+
* Copyright © 2008 Florent Bruneau
*/
* Copyright © 2008 Florent Bruneau
*/
#include "array.h"
#include "str.h"
#include "trie.h"
#include "array.h"
#include "str.h"
#include "trie.h"
if (trie->locked) {
return;
}
if (trie->locked) {
return;
}
- if (mlock(trie->entries.data, sizeof(trie_entry_t) * trie->entries.len) != 0) {
+ if (!array_lock(trie->entries)) {
UNIXERR("mlock");
return;
}
UNIXERR("mlock");
return;
}
- if (mlock(trie->c.data, trie->c.len) != 0) {
+ if (!array_lock(trie->c)) {
- munlock(trie->entries.data, sizeof(trie_entry_t) * trie->entries.len);
+ array_unlock(trie->entries);
return;
}
trie->locked = true;
return;
}
trie->locked = true;
if (!trie->locked) {
return;
}
if (!trie->locked) {
return;
}
- munlock(trie->entries.data, sizeof(trie_entry_t) * trie->entries.len);
- munlock(trie->c.data, trie->c.len);
+ array_unlock(trie->entries);
+ array_unlock(trie->entries);
#include "rbl.h"
#include "str.h"
#include "file.h"
#include "rbl.h"
#include "str.h"
#include "file.h"
#define IPv4_BITS 5
#define IPv4_PREFIX(ip) ((uint32_t)(ip) >> IPv4_BITS)
#define IPv4_BITS 5
#define IPv4_PREFIX(ip) ((uint32_t)(ip) >> IPv4_BITS)
- uint32_t len, size;
- uint32_t *ips;
- bool locked;
+ A(uint32_t) ips;
+ bool locked;
};
static int get_o(const char *s, const char **out)
};
static int get_o(const char *s, const char **out)
if (parse_ipv4(p, &p, &ip) < 0) {
p = (char *)memchr(p, '\n', end - p) + 1;
} else {
if (parse_ipv4(p, &p, &ip) < 0) {
p = (char *)memchr(p, '\n', end - p) + 1;
} else {
- if (db->len >= db->size) {
- db->size += 64 * 1024;
- p_realloc(&db->ips, db->size);
- }
- db->ips[db->len++] = ip;
+ array_add(db->ips, ip);
}
}
file_map_close(&map);
/* Lookup may perform serveral I/O, so avoid swap.
*/
}
}
file_map_close(&map);
/* Lookup may perform serveral I/O, so avoid swap.
*/
- db->locked = lock && mlock(db->ips, db->len * sizeof(*(db->ips))) == 0;
+ array_adjust(db->ips);
+ db->locked = lock && array_lock(db->ips);
if (lock && !db->locked) {
UNIXERR("mlock");
}
if (lock && !db->locked) {
UNIXERR("mlock");
}
# define QSORT_TYPE uint32_t
# define QSORT_TYPE uint32_t
-# define QSORT_BASE db->ips
-# define QSORT_NELT db->len
+# define QSORT_BASE db->ips.data
+# define QSORT_NELT db->ips.len
# define QSORT_LT(a,b) *a < *b
# include "qsort.c"
}
# define QSORT_LT(a,b) *a < *b
# include "qsort.c"
}
- syslog(LOG_INFO, "rbl %s loaded, %d IPs", file, db->len);
+ syslog(LOG_INFO, "rbl %s loaded, %d IPs", file, db->ips.len);
{
if (*db) {
if ((*db)->locked) {
{
if (*db) {
if ((*db)->locked) {
- (void)munlock((*db)->ips, (*db)->len * sizeof(*(*db)->ips));
+ array_unlock((*db)->ips);
+ array_wipe((*db)->ips);
p_delete(&(*db));
}
}
uint32_t rbldb_stats(rbldb_t *rbl)
{
p_delete(&(*db));
}
}
uint32_t rbldb_stats(rbldb_t *rbl)
{
}
bool rbldb_ipv4_lookup(rbldb_t *db, uint32_t ip)
{
}
bool rbldb_ipv4_lookup(rbldb_t *db, uint32_t ip)
{
- int l = 0, r = db->len;
+ int l = 0, r = db->ips.len;
while (l < r) {
int i = (r + l) / 2;
while (l < r) {
int i = (r + l) / 2;
+ if (array_elt(db->ips, i) == ip)
+ if (ip < array_elt(db->ips, i)) {
r = i;
} else {
l = i + 1;
r = i;
} else {
l = i + 1;