src/rxpd_connection_cmd.c

   1 /*
   2     rxpd_connection_cmd.c - regex policy daemon
   3
   4   Copyright (C)
   5     2007,               Christian Thaeter <ct@pipapo.org>
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License as
   9   published by the Free Software Foundation; either version 2 of the
  10   License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "rxpd.h"
  23
  24 #define RXPD_FILENAME_REQUIRED                                          \
  25   do {                                                                  \
  26     if (!self->file)                                                    \
  27       {                                                                 \
  28         rxpd_buffer_printf (&self->out, "#ERROR: missing filename\n");  \
  29         return;                                                         \
  30       }                                                                 \
  31   } while (0)
  32
  33 void
  34 rxpd_connection_cmd_CHECK (struct rxpd_connection* self)
  35 {
  36   RXPD_FILENAME_REQUIRED;
  37
  38   char* line;
  39   while ((line = rxpd_buffer_readline (&self->in)))
  40     {
  41       if (*line == '\0')
  42         {
  43           rxpd_buffer_printf (&self->out, "#OK:\n");
  44         }
  45       else
  46         {
  47           // TODO implement RXPD_YIELD_EVERY
  48           pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RD, FALSE, NULL);
  49           LLIST_FOREACH (&self->file->rules, n)
  50             {
  51               struct rxpd_rule* rule = (struct rxpd_rule*)n;
  52               if (rule->string[0] != '#')
  53                 {
  54                   if (regexec (&rule->rx, line, 0, NULL, 0) == 0)
  55                     {
  56                       if (rule->atime != (time_t) -1)
  57                         time (&rule->atime);
  58
  59                       rxpd_buffer_printf (&self->out, "%s\n", rule->string);
  60                       break;
  61                     }
  62                 }
  63             }
  64           pth_rwlock_release (&self->file->lock);
  65         }
  66     }
  67
  68   if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
  69     rxpd_buffer_printf (&self->out, "#ERROR:\n");
  70 }
  71
  72
  73
  74 static void
  75 rxpd_connection_APPEND_PREPEND_helper (struct rxpd_connection* self)
  76 {
  77   char* line;
  78
  79   while ((line = rxpd_buffer_readline (&self->in)))
  80     {
  81       if (*line && !RXPD_PREFIXCMP (line, "#EXIT:"))
  82         {
  83           struct rxpd_rule* rule;
  84           rule = rxpd_rule_new (line);
  85           llist_insert_tail (&self->tmp_list, &rule->node);
  86         }
  87       else
  88         break;  /* exit at empty line, error or whatever */
  89     }
  90
  91   if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
  92     rxpd_buffer_printf (&self->out, "#ERROR:\n");
  93   else
  94     rxpd_buffer_printf (&self->out, "#OK:\n");
  95 }
  96
  97 void
  98 rxpd_connection_cmd_APPEND (struct rxpd_connection* self)
  99 {
 100   RXPD_FILENAME_REQUIRED;
 101
 102   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 103
 104   rxpd_connection_APPEND_PREPEND_helper (self);
 105   llist_insertlist_prev (&self->file->rules, &self->tmp_list);
 106
 107   pth_rwlock_release (&self->file->lock);
 108 }
 109
 110 void
 111 rxpd_connection_cmd_PREPEND (struct rxpd_connection* self)
 112 {
 113   RXPD_FILENAME_REQUIRED;
 114
 115   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 116
 117   rxpd_connection_APPEND_PREPEND_helper (self);
 118   llist_insertlist_next (&self->file->rules, &self->tmp_list);
 119
 120   pth_rwlock_release (&self->file->lock);
 121 }
 122
 123 void
 124 rxpd_connection_cmd_REMOVE (struct rxpd_connection* self)
 125 {
 126   RXPD_FILENAME_REQUIRED;
 127
 128   char* line;
 129   while ((line = rxpd_buffer_readline (&self->in)))
 130     {
 131       if (*line && !RXPD_PREFIXCMP (line, "#EXIT:"))
 132         {
 133           pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 134           LLIST_FOREACH (&self->file->rules, n)
 135             {
 136               struct rxpd_rule* rule = (struct rxpd_rule*)n;
 137               if (strcmp (rule->string, line) == 0)
 138                 {
 139                   LList tmp = llist_prev (n);
 140                   rxpd_rule_delete (rule);
 141                   n = tmp;
 142                   rxpd_buffer_printf (&self->out, "#OK:\n");
 143                   goto done;
 144                 }
 145             }
 146           rxpd_buffer_printf (&self->out, "#ERROR: line not found\n");
 147         done:
 148           pth_rwlock_release (&self->file->lock);
 149         }
 150       else
 151         break;  /* exit at empty line, error or whatever */
 152     }
 153
 154   if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
 155     rxpd_buffer_printf (&self->out, "#ERROR:\n");
 156 }
 157
 158
 159
 160 static int
 161 rxpd_connection_do_REPLACE (struct rxpd_connection* self)
 162 {
 163   struct rxpd_rule* rule;
 164
 165   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 166
 167   LLIST_FOREACH (&self->file->rules, n)
 168     {
 169       rule = (struct rxpd_rule*)n;
 170       if (strcmp (rule->string, self->tmp_str) == 0)
 171         goto found;
 172     }
 173   pth_rwlock_release (&self->file->lock);
 174   return 0;
 175
 176  found:
 177   llist_insertlist_next (&rule->node, &self->tmp_list);
 178   rxpd_rule_delete (rule);
 179   pth_rwlock_release (&self->file->lock);
 180
 181   free (self->tmp_str);
 182   self->tmp_str = NULL;
 183   return 1;
 184 }
 185
 186 void
 187 rxpd_connection_cmd_REPLACE (struct rxpd_connection* self)
 188 {
 189   RXPD_FILENAME_REQUIRED;
 190
 191   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 192
 193   char* line;
 194   while ((line = rxpd_buffer_readline (&self->in)))
 195     {
 196       if (*line && !RXPD_PREFIXCMP (line, "#EXIT:"))
 197         {
 198           if (self->tmp_str)
 199             {
 200               struct rxpd_rule* rule;
 201               rule = rxpd_rule_new (line);
 202               if (rule)
 203                 llist_insert_tail (&self->tmp_list, &rule->node);
 204               else
 205                 rxpd_buffer_printf (&self->out, "#ERROR: illegal rule '%s'\n", line);
 206             }
 207           else
 208             self->tmp_str = rxpd_strdup (line);
 209         }
 210       else
 211         break;  /* exit at empty line, error or whatever */
 212     }
 213
 214   pth_rwlock_release (&self->file->lock);
 215
 216   if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
 217     rxpd_buffer_printf (&self->out, "#ERROR:\n");
 218
 219   if (rxpd_connection_do_REPLACE (self))
 220     rxpd_buffer_printf (&self->out, "#OK:\n");
 221   else
 222     rxpd_buffer_printf (&self->out, "#ERROR: no rule matching '%s'\n", self->tmp_str);
 223 }
 224
 225 void
 226 rxpd_connection_cmd_LOAD (struct rxpd_connection* self)
 227 {
 228   RXPD_FILENAME_REQUIRED;
 229
 230   if (rxpd_file_load (self->file))
 231     rxpd_buffer_printf (&self->out, "#OK:\n");
 232   else
 233     rxpd_buffer_printf (&self->out, "#ERROR: loading file '%s'\n", (const char*)self->file->node.key);
 234 }
 235
 236 void
 237 rxpd_connection_cmd_SAVE (struct rxpd_connection* self)
 238 {
 239   RXPD_FILENAME_REQUIRED;
 240
 241   if (rxpd_file_save (self->file))
 242     rxpd_buffer_printf (&self->out, "#OK:\n");
 243   else
 244     rxpd_buffer_printf (&self->out, "#ERROR: saving file '%s'\n", (const char*)self->file->node.key);
 245 }
 246
 247
 248 void
 249 rxpd_connection_cmd_DELETE (struct rxpd_connection* self)
 250 {
 251   RXPD_FILENAME_REQUIRED;
 252
 253   rxpd_file_delete (self->file);
 254   rxpd_buffer_printf (&self->out, "#OK:\n");
 255 }
 256
 257 void
 258 rxpd_connection_cmd_FETCH (struct rxpd_connection* self)
 259 {
 260   RXPD_FILENAME_REQUIRED;
 261
 262   struct rxpd_base* base = self->socket->base;
 263
 264   char* line;
 265   line = rxpd_buffer_readline (&self->in);
 266   if (*line)
 267     {
 268       /* parse line */
 269       char* list = strrchr (line, ':');
 270       if (!list)
 271         goto esyntax;
 272
 273       *list = '\0';
 274       ++ list;
 275
 276       char* port = strrchr (line, ':');
 277       if (!port)
 278         goto esyntax;
 279
 280       *port = '\0';
 281       ++ port;
 282
 283       struct addrinfo* addrs = NULL;
 284       int aierr;
 285
 286       /* resolve peer */
 287       aierr = getaddrinfo (line, port, NULL, &addrs);
 288       if (aierr)
 289         {
 290           rxpd_buffer_printf (&self->out, "#ERROR: resolving '%s': %s\n", line, gai_strerror (aierr));
 291           return;
 292         }
 293
 294       rxpd_log (base, LOG_INFO, "fetching list '%s' from '%s(%s)' at port '%s' to '%s'\n",
 295                 list,
 296                 line,
 297                 inet_ntoa (((struct sockaddr_in*)addrs->ai_addr)->sin_addr),
 298                 port,
 299                 self->file->node.key);
 300
 301       /* establish connection */
 302       int fd = socket (addrs->ai_family, addrs->ai_socktype, addrs->ai_protocol);
 303       if (fd == -1 || connect (fd, addrs->ai_addr, addrs->ai_addrlen))
 304         {
 305           freeaddrinfo (addrs);
 306           rxpd_buffer_printf (&self->out, "#ERROR: error connecting '%s': %s\n", line, strerror (errno));
 307           return;
 308         }
 309
 310       freeaddrinfo (addrs);
 311
 312       /* send DUMP command and fetch data */
 313       struct rxpd_buffer in;
 314       struct rxpd_buffer out;
 315       rxpd_buffer_init (&in, fd);
 316       rxpd_buffer_init (&out, fd);
 317
 318       rxpd_buffer_printf (&out, "DUMP:%s\n", list);
 319
 320       char* line;
 321       while ((line = rxpd_buffer_readline (&in)))
 322         {
 323           if (*line && !RXPD_PREFIXCMP (line, "#EXIT:"))
 324             {
 325               struct rxpd_rule* rule;
 326               rule = rxpd_rule_new (line);
 327               if (!rule)
 328                 rxpd_die ("rule creation failed on '%s'\n", line);
 329
 330               llist_insert_tail (&self->tmp_list, &rule->node);
 331             }
 332           else
 333             rxpd_log (base, LOG_INFO, "purge remote side error '%s'\n", line);
 334         }
 335       rxpd_log (base, LOG_DEBUG, "finished dump\n");
 336
 337       close (fd);
 338
 339       pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 340       rxpd_file_rules_delete (self->file);
 341       llist_insertlist_next (&self->file->rules, &self->tmp_list);
 342       pth_rwlock_release (&self->file->lock);
 343
 344       rxpd_buffer_printf (&self->out, "#OK:\n");
 345     }
 346   else
 347     {
 348     esyntax:
 349       rxpd_buffer_printf (&self->out, "#ERROR: syntax error\n");
 350     }
 351 }
 352
 353 void
 354 rxpd_connection_cmd_DUMP (struct rxpd_connection* self)
 355 {
 356   RXPD_FILENAME_REQUIRED;
 357   rxpd_file_dump (self->file, &self->out);
 358 }
 359
 360
 361 static psplay_delete_t
 362 walk_LIST (PSplay node, const enum psplay_order_e which, int level, void* data)
 363 {
 364   (void) level;
 365   struct rxpd_file* file = (struct rxpd_file*) node;
 366   struct rxpd_connection* conn = (struct rxpd_connection*) data;
 367
 368   if (which == PSPLAY_INORDER)
 369     rxpd_buffer_printf (&conn->out, "%s\n", file->node.key);
 370
 371   return PSPLAY_CONT;
 372 }
 373
 374
 375 void
 376 rxpd_connection_cmd_LIST (struct rxpd_connection* self)
 377 {
 378   struct rxpd_base* base = self->socket->base;
 379
 380   if (psplay_isempty_root (&base->files))
 381     rxpd_buffer_printf (&self->out, "#OK:\n");
 382   else
 383     psplay_walk (&base->files, NULL, walk_LIST, 0, self);
 384 }
 385
 386 void
 387 rxpd_connection_cmd_SHUTDOWN (struct rxpd_connection* self)
 388 {
 389   struct rxpd_base* base = self->socket->base;
 390
 391   LLIST_FOREACH (&base->sockets, n)
 392     {
 393       struct rxpd_socket* socket = (struct rxpd_socket*)n;
 394       rxpd_socket_cancel (socket);
 395     }
 396
 397   rxpd_buffer_printf (&self->out, "#OK:\n");
 398 }
 399
 400
 401 void
 402 rxpd_connection_cmd_VERSION (struct rxpd_connection* self)
 403 {
 404   rxpd_buffer_printf (&self->out, PACKAGE_STRING "\n#\n"
 405                       "# Copyright (C)\n"
 406                       "#   2007,               Christian Thaeter <ct@pipapo.org>\n#\n"
 407                       "# This is free software.  You may redistribute copies of it under the terms of\n"
 408                       "# the GNU General Public License <http://www.gnu.org/licenses/gpl.html>.\n"
 409                       "# There is NO WARRANTY, to the extent permitted by law.\n#\n"
 410                       "# http://www.pipapo.org/pipawiki/RegexPolicyDaemon\n");
 411 }
 412
 413 void
 414 rxpd_connection_cmd_HELP (struct rxpd_connection* self)
 415 {
 416   rxpd_buffer_printf (&self->out, "# Available commands:\n#\n");
 417 #define RXPD_CMD(cmd, help)     rxpd_buffer_printf (&self->out, "# %s %s.\n", #cmd, help);
 418   RXPD_COMMANDS
 419 #undef RXPD_CMD
 420     rxpd_buffer_printf (&self->out,
 421                         "#\n"
 422                         "# general syntax is: 'COMMAND:listname\\n..data..'\n"
 423                         "# see http://www.pipapo.org/pipawiki/RegexPolicyDaemon\n");
 424 }
 425
 426 void
 427 rxpd_connection_cmd_EXPIRE (struct rxpd_connection* self)
 428 {
 429   RXPD_FILENAME_REQUIRED;
 430
 431   struct rxpd_base* base = self->socket->base;
 432
 433   char* line = rxpd_buffer_readline (&self->in);
 434   if (*line)
 435     {
 436       // TODO strtol, error handling
 437       time_t since = time (NULL) - atoi (line);
 438       rxpd_log (base, LOG_INFO, "expire all entries in '%s' since %ld\n",
 439                 (const char*) self->file->node.key, since);
 440
 441       pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 442
 443       LLIST_FOREACH (&self->file->rules, n)
 444         {
 445           struct rxpd_rule* rule = (struct rxpd_rule*)n;
 446           if (rule->atime != -1 && rule->atime < since)
 447             {
 448               rxpd_log (base, LOG_DEBUG, "expiring %ld:%s\n", rule->atime, rule->string);
 449               rxpd_buffer_printf (&self->out, "#OK: expiring '%s'\n", rule->string);
 450               if (!rxpd_rule_comment (rule, "EXPIRED"))
 451                 rxpd_die ("couldn't comment rule out");
 452             }
 453         }
 454
 455       pth_rwlock_release (&self->file->lock);
 456     }
 457   else
 458     rxpd_buffer_printf (&self->out, "#ERROR: no age given\n");
 459 }
 460
 461 void
 462 rxpd_connection_cmd_UPDATE (struct rxpd_connection* self)
 463 {
 464   RXPD_FILENAME_REQUIRED;
 465
 466   struct rxpd_base* base = self->socket->base;
 467
 468   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 469
 470   char* line;
 471   while ((line = rxpd_buffer_readline (&self->in)))
 472     {
 473       /* for each line which is a listname */
 474       struct rxpd_file* source;
 475       source = (struct rxpd_file*) psplay_find (&base->files, line);
 476       if (source)
 477         {
 478           pth_rwlock_acquire (&source->lock, PTH_RWLOCK_RD, FALSE, NULL);
 479
 480           /* find first line which is in source and self->file, this is our start */
 481           LList source_itr = NULL;
 482           LList file_itr = NULL;
 483           LLIST_FOREACH (&source->rules, n)
 484             {
 485               struct rxpd_rule* rule_n = (struct rxpd_rule*)n;
 486               LLIST_FOREACH (&self->file->rules, m)
 487                 {
 488                   struct rxpd_rule* rule_m = (struct rxpd_rule*)m;
 489                   if (strcmp (rule_n->string, rule_m->string) == 0)
 490                     {
 491                       source_itr = &rule_n->node;
 492                       file_itr = &rule_m->node;
 493                       rxpd_log (base, LOG_DEBUG, "starting at '%s'\n", rule_n->string);
 494                       goto leave_loop;
 495                     }
 496                 }
 497             }
 498         leave_loop:
 499           if (!source_itr)
 500             {
 501               rxpd_log (base, LOG_DEBUG, "no common line found between '%s' and '%s'\n",
 502                         (const char*)self->file->node.key, line);
 503               pth_rwlock_release (&source->lock);
 504               break;
 505             }
 506
 507           /* Now we go for each rule in source which has a atime find the matching rule in self->file and update its atime */
 508           /* This algorihm assumes that lists stay ordered (insertions/deletions are supported, but not reordering) */
 509           /* advantage is that the algorithm has far less complexity */
 510           LLIST_FORRANGE (source_itr, &source->rules, n)
 511             {
 512               struct rxpd_rule* rule_n = (struct rxpd_rule*)n;
 513               if (rule_n->atime != (time_t)-1)
 514                 {
 515                   LLIST_FORRANGE (file_itr, &self->file->rules, m)
 516                     {
 517                       struct rxpd_rule* rule_m = (struct rxpd_rule*)m;
 518                       if (strcmp (rule_n->string, rule_m->string) == 0)
 519                         {
 520                           /* found the rule */
 521                           if (rule_m->atime != (time_t)-1 && rule_m->atime < rule_n->atime)
 522                             {
 523                               rxpd_log (base, LOG_DEBUG,
 524                                         "updating atime of rule '%s' from %ld to %ld\n",
 525                                         rule_m->string,
 526                                         rule_m->atime,
 527                                         rule_n->atime
 528                                         );
 529                               rule_m->atime = rule_n->atime;
 530                             }
 531
 532                           file_itr = llist_next (m);
 533                           break;
 534                         }
 535                     }
 536                 }
 537             }
 538
 539           pth_rwlock_release (&source->lock);
 540         }
 541       else
 542         rxpd_buffer_printf (&self->out, "#ERROR: unknown file '%s'\n", line);
 543     }
 544
 545   pth_rwlock_release (&self->file->lock);
 546
 547   rxpd_buffer_printf (&self->out, "#OK:\n");
 548 }
 549
 550
 551 void
 552 rxpd_connection_cmd_MERGE (struct rxpd_connection* self)
 553 {
 554   RXPD_FILENAME_REQUIRED;
 555
 556   struct rxpd_base* base = self->socket->base;
 557
 558   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 559
 560   char* line;
 561   while ((line = rxpd_buffer_readline (&self->in)))
 562     {
 563       /* for each line which is a listname */
 564       struct rxpd_file* source;
 565       source = (struct rxpd_file*) psplay_find (&base->files, line);
 566       if (source)
 567         {
 568           pth_rwlock_acquire (&source->lock, PTH_RWLOCK_RD, FALSE, NULL);
 569
 570           LList source_start = llist_head (&source->rules);
 571           LList file_start = llist_head (&self->file->rules);
 572           LList source_itr = NULL;
 573           LList file_itr = NULL;
 574
 575           /* find next line which is in source and self->file */
 576           while (source_itr != &source->rules)
 577             {
 578               LLIST_FORRANGE (source_start, &source->rules, n)
 579                 {
 580                   LLIST_FORRANGE (file_start, &self->file->rules, m)
 581                     {
 582                       struct rxpd_rule* rule_n = (struct rxpd_rule*)n;
 583                       struct rxpd_rule* rule_m = (struct rxpd_rule*)m;
 584                       if (strcmp (rule_n->string, rule_m->string) == 0)
 585                         {
 586                           source_itr = &rule_n->node;
 587                           file_itr = &rule_m->node;
 588                           goto leave_loop;
 589                         }
 590                     }
 591                 }
 592               /* not found, place the itr's at the end of their lists */
 593               source_itr = &source->rules;
 594               file_itr = &self->file->rules;
 595             leave_loop:
 596               /* copy all rules from source_start to source_itr before file_itr */
 597
 598               LLIST_FORRANGE (source_start, source_itr, n)
 599                 {
 600                   struct rxpd_rule* rule = rxpd_rule_copy ((struct rxpd_rule*)n);
 601                   if (!rule)
 602                     rxpd_die ("rule copy failed\n");
 603
 604                   llist_insert_prev (file_itr, &rule->node);
 605                 }
 606
 607               /*iterate for mismatch*/
 608               file_start = llist_next (file_itr);
 609               source_start = llist_next (source_itr);
 610             }
 611
 612           pth_rwlock_release (&source->lock);
 613         }
 614       else
 615         rxpd_buffer_printf (&self->out, "#ERROR: unknown file '%s'\n", line);
 616     }
 617
 618   pth_rwlock_release (&self->file->lock);
 619
 620   rxpd_buffer_printf (&self->out, "#OK:\n");
 621 }
 622
 623 void
 624 rxpd_connection_cmd_FILTER (struct rxpd_connection* self)
 625 {
 626   RXPD_FILENAME_REQUIRED;
 627
 628   /* Filter processes the target list by checking its rules against other lists */
 629   /* The outcome of this check is used to decide how to process with a rule */
 630   /* DELETE: delete rule from list */
 631   /* ACTIVATE: try to reactivate a rule which was commented out */
 632   /* any other: comment the rule out by using 'any other' as hint*/
 633
 634   struct rxpd_base* base = self->socket->base;
 635
 636   pth_rwlock_acquire (&self->file->lock, PTH_RWLOCK_RW, FALSE, NULL);
 637
 638   char* line;
 639   while ((line = rxpd_buffer_readline (&self->in)))
 640     {
 641       if (*line && !RXPD_PREFIXCMP (line, "#EXIT:"))
 642         {
 643
 644           /* for each line which is a listname */
 645           struct rxpd_file* source;
 646           source = (struct rxpd_file*) psplay_find (&base->files, line);
 647           if (source)
 648             {
 649               pth_rwlock_acquire (&source->lock, PTH_RWLOCK_RD, FALSE, NULL);
 650
 651               LLIST_FOREACH (&self->file->rules, n)
 652                 {
 653                   LLIST_FOREACH (&source->rules, m)
 654                     {
 655                       struct rxpd_rule* rule_n = (struct rxpd_rule*)n;
 656                       struct rxpd_rule* rule_m = (struct rxpd_rule*)m;
 657                       if (rule_m->string[0] != '#')
 658                         {
 659                           if (regexec (&rule_m->rx, rule_n->string, 0, NULL, 0) == 0)
 660                             {
 661                               if (rule_m->atime != (time_t) -1)
 662                                 time (&rule_m->atime);
 663
 664                               if (RXPD_PREFIXCMP (rule_m->string, "DELETE:"))
 665                                 {
 666                                   n = llist_prev (n);
 667                                   rxpd_log (base, LOG_DEBUG, "deleting rule '%s' from list '%s'\n",
 668                                             rule_n->string, (const char*) self->file->node.key);
 669                                   rxpd_rule_delete (rule_n);
 670                                 }
 671                               else if (RXPD_PREFIXCMP (rule_m->string, "ACTIVATE:"))
 672                                 {
 673                                   if (!rxpd_rule_activate (rule_n))
 674                                     rxpd_buffer_printf (&self->out, "#ERROR: cant activate rule '%s'\n", rule_n->string);
 675                                   else
 676                                     rxpd_log (base, LOG_DEBUG, "activated rule '%s' in list '%s'\n",
 677                                               rule_n->string, (const char*) self->file->node.key);
 678                                 }
 679                               else
 680                                 {
 681                                   char* c = strndupa (rule_m->string, strchr (rule_m->string, ':') - rule_m->string);
 682                                   rxpd_log (base, LOG_DEBUG, "commenting rule '%s' as '%s', in list '%s'\n",
 683                                             rule_n->string, c, (const char*) self->file->node.key);
 684
 685                                   rxpd_rule_comment (rule_n, c);
 686                                 }
 687                             }
 688                         }
 689                     }
 690                 }
 691               pth_rwlock_release (&source->lock);
 692             }
 693           else
 694             rxpd_buffer_printf (&self->out, "#ERROR: unknown file '%s'\n", line);
 695         }
 696       else
 697         break;  /* exit at empty line, error or whatever */
 698     }
 699
 700   pth_rwlock_release (&self->file->lock);
 701
 702   rxpd_buffer_printf (&self->out, "#OK:\n");
 703 }
 704
 705 /* Template
 706 void
 707 rxpd_connection_cmd_ (struct rxpd_connection* self)
 708 {
 709   RXPD_FILENAME_REQUIRED;
 710   //struct rxpd_base* base = self->socket->base;
 711   rxpd_buffer_printf (&self->out, "#ERROR: Unimplemented\n");
 712 }
 713 */