}
else
{
- // TODO lock the list, printf schedules!
// TODO implement RXPD_YIELD_EVERY
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RD, FALSE, NULL);
LLIST_FOREACH (&self->file->rules, n)
{
struct rxpd_rule* rule = (struct rxpd_rule*)n;
}
}
}
+ pth_rwlock_release (&self->file->lock);
}
}
{
RXPD_FILENAME_REQUIRED;
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
rxpd_connection_APPEND_PREPEND_helper (self);
llist_insertlist_prev (&self->file->rules, &self->tmp_list);
+
+ pth_rwlock_release (&self->file->lock);
}
void
{
RXPD_FILENAME_REQUIRED;
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
rxpd_connection_APPEND_PREPEND_helper (self);
llist_insertlist_next (&self->file->rules, &self->tmp_list);
+
+ pth_rwlock_release (&self->file->lock);
}
void
char* line;
while ((line = rxpd_buffer_readline (&self->in)))
{
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
LLIST_FOREACH (&self->file->rules, n)
{
struct rxpd_rule* rule = (struct rxpd_rule*)n;
}
rxpd_buffer_printf (&self->out, "#ERROR: line not found\n");
done:
- ;
+ pth_rwlock_release (&self->file->lock);
}
if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
rxpd_connection_do_REPLACE (struct rxpd_connection* self)
{
struct rxpd_rule* rule;
+
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
LLIST_FOREACH (&self->file->rules, n)
{
rule = (struct rxpd_rule*)n;
if (strcmp (rule->string, self->tmp_str) == 0)
goto found;
}
+ pth_rwlock_release (&self->file->lock);
return 0;
found:
llist_insertlist_next (&rule->node, &self->tmp_list);
rxpd_rule_delete (rule);
+ pth_rwlock_release (&self->file->lock);
+
free (self->tmp_str);
self->tmp_str = NULL;
return 1;
{
RXPD_FILENAME_REQUIRED;
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
char* line;
while ((line = rxpd_buffer_readline (&self->in)))
{
self->tmp_str = rxpd_strdup (line);
}
+ pth_rwlock_release (&self->file->lock);
+
if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
rxpd_buffer_printf (&self->out, "#ERROR:\n");
line = rxpd_buffer_readline (&self->in);
if (*line)
{
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
rxpd_file_rules_delete (self->file);
char* list = strrchr (line, '/');
// add recieving event
freeaddrinfo (addrs);
+
+
+ pth_rwlock_release (&self->file->lock);
+
}
}
rxpd_connection_cmd_DUMP (struct rxpd_connection* self)
{
RXPD_FILENAME_REQUIRED;
-
- if (llist_is_empty (&self->file->rules))
- rxpd_buffer_printf (&self->out, "#OK:\n");
- else
- {
- LLIST_FOREACH (&self->file->rules, n)
- {
- struct rxpd_rule* rule = (struct rxpd_rule*)n;
- if (rule->atime != (time_t)-1)
- rxpd_buffer_printf (&self->out, "%ld:%s\n", rule->atime, rule->string);
- else if (*rule->string != '#')
- rxpd_buffer_printf (&self->out, ":%s\n", rule->string);
- else
- rxpd_buffer_printf (&self->out, "%s\n", rule->string);
- }
- }
+ rxpd_file_dump (self->file, &self->out);
}
rxpd_connection_cmd_SHUTDOWN (struct rxpd_connection* self)
{
struct rxpd_base* base = self->socket->base;
+
LLIST_FOREACH (&base->sockets, n)
{
struct rxpd_socket* socket = (struct rxpd_socket*)n;
rxpd_socket_cancel (socket);
}
+
rxpd_buffer_printf (&self->out, "#OK:\n");
}
rxpd_log (base, LOG_INFO, "expire all entries in '%s' since %ld\n",
(const char*) self->file->node.key, since);
+ pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
LLIST_FOREACH (&self->file->rules, n)
{
struct rxpd_rule* rule = (struct rxpd_rule*)n;
rxpd_rule_delete (rule);
}
}
+
+ pth_rwlock_release (&self->file->lock);
}
else
rxpd_buffer_printf (&self->out, "#ERROR: no age given\n");
self = rxpd_malloc (sizeof (struct rxpd_file));
self->filename = filename;
self->base = base;
+ pth_rwlock_init (&self->lock);
+
const char* basename = strrchr (filename, '/');
if (basename)
++basename;
{
if (self)
{
+ pth_rwlock_acquire (&self->lock, PTH_RWLOCK_RW, FALSE, NULL);
LLIST_WHILE_HEAD (&self->rules, n)
{
struct rxpd_rule* node = (struct rxpd_rule*)n;
rxpd_rule_delete (node);
}
+ pth_rwlock_release (&self->lock);
}
return self;
}
// TODO error handling
if (f)
{
+ pth_rwlock_acquire (&self->lock, PTH_RWLOCK_RW, FALSE, NULL);
+
/* First purge old rules */
LLIST_WHILE_HEAD (&self->rules, n)
{
llist_insert_tail (&self->rules, &rule->node);
}
+ pth_rwlock_release (&self->lock);
fclose (f);
return 1;
}
// TODO error handling
if (f)
{
+ pth_rwlock_acquire (&self->lock, PTH_RWLOCK_RD, FALSE, NULL);
+
LLIST_FOREACH (&self->rules, n)
{
struct rxpd_rule* node = (struct rxpd_rule*)n;
fprintf (f, "%s\n", node->string);
}
+ pth_rwlock_release (&self->lock);
fclose (f);
rxpd_log (self->base, LOG_NOTICE, "saved '%s'\n", self->filename);
return 1;
}
}
+struct rxpd_file*
+rxpd_file_dump (struct rxpd_file* self, struct rxpd_buffer* out)
+{
+ if (self)
+ {
+ if (llist_is_empty (&self->rules))
+ rxpd_buffer_printf (out, "#OK:\n");
+ else
+ {
+ pth_rwlock_acquire (&self->lock, PTH_RWLOCK_RD, FALSE, NULL);
+
+ LLIST_FOREACH (&self->rules, n)
+ {
+ struct rxpd_rule* rule = (struct rxpd_rule*)n;
+ if (rule->atime != (time_t)-1)
+ rxpd_buffer_printf (out, "%ld:%s\n", rule->atime, rule->string);
+ else if (*rule->string != '#')
+ rxpd_buffer_printf (out, ":%s\n", rule->string);
+ else
+ rxpd_buffer_printf (out, "%s\n", rule->string);
+ }
+ pth_rwlock_release (&self->lock);
+ }
+ }
+
+ return self;
+}
+
int
rxpd_file_cmp (const void* A, const void* B)
{