www.pipapo.org Git - rxpd/blob - rxpd.c

   1 /*
   2     rxpd.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 static struct rxpd_base global_base;
  25
  26 struct rxpd_base*
  27 rxpd_init (char* rulesdir)
  28 {
  29   if (global_base.rulesdir)
  30     return NULL;
  31
  32   global_base.rulesdir = strdup (rulesdir);
  33   if (!global_base.rulesdir) abort();
  34
  35   psplay_init_root (&global_base.files, rxpd_file_cmp, rxpd_file_delete);
  36
  37   llist_init (&global_base.sockets_pending);
  38   llist_init (&global_base.sockets_active);
  39   llist_init (&global_base.connections_pending);
  40   llist_init (&global_base.connections_active);
  41
  42   return &global_base;
  43 }
  44
  45 void
  46 rxpd_destroy (void)
  47 {
  48   if (global_base.rulesdir)
  49     {
  50       free (global_base.rulesdir);
  51       psplay_destroy_root (&global_base.files);
  52       LLIST_WHILE_HEAD (&global_base.sockets_pending, n)
  53         {
  54           struct rxpd_socket* socket = (struct rxpd_socket*)n;
  55           rxpd_socket_delete (socket);
  56         }
  57       LLIST_WHILE_HEAD (&global_base.sockets_active, n)
  58         {
  59           struct rxpd_socket* socket = (struct rxpd_socket*)n;
  60           rxpd_socket_delete (socket);
  61         }
  62       LLIST_WHILE_HEAD (&global_base.connections_pending, n)
  63         {
  64           struct rxpd_connection* connection = (struct rxpd_connection*)n;
  65           rxpd_connection_delete (connection);
  66         }
  67       LLIST_WHILE_HEAD (&global_base.connections_active, n)
  68         {
  69           struct rxpd_connection* connection = (struct rxpd_connection*)n;
  70           rxpd_connection_delete (connection);
  71         }
  72     }
  73 }
  74
  75
  76 //
  77 struct rxpd_rule*
  78 rxpd_rule_new (const char* buf)
  79 {
  80   struct rxpd_rule* self = malloc (sizeof (struct rxpd_rule));
  81   if (self)
  82     {
  83       llist_init (&self->node);
  84
  85       if (*buf != '#')
  86         {
  87           int err;
  88           char* rxstart = strchr (buf, ':') + 1;
  89
  90           err = regcomp (&self->rx, rxstart, REG_EXTENDED|REG_ICASE|REG_NOSUB);
  91
  92           if (!err)
  93             {
  94               self->string = strdup (buf);
  95               if (!self->string) abort();
  96             }
  97           else
  98             {
  99               regfree (&self->rx);
 100               char ebuf[256];
 101               size_t len = regerror (err, NULL, ebuf, 256);
 102               self->string = malloc(len + strlen(buf) + 14);
 103               if (!self->string) abort();
 104               strcpy (self->string, "#ERROR ");
 105               strcat (self->string, ebuf);
 106               strcat (self->string, " in '");
 107               strcat (self->string, buf);
 108               strcat (self->string, "'");
 109             }
 110         }
 111       else
 112         {
 113           self->string = strdup (buf);
 114           if (!self->string) abort();
 115         }
 116     }
 117   return self;
 118 }
 119
 120 void
 121 rxpd_rule_delete (struct rxpd_rule* rule)
 122 {
 123   if (rule)
 124     {
 125       llist_unlink (&rule->node);
 126       if (rule->string[0] != '#')
 127         regfree (&rule->rx);
 128       free (rule->string);
 129       free(rule);
 130     }
 131 }
 132
 133 //
 134
 135
 136 struct rxpd_file*
 137 rxpd_file_new (struct rxpd_base* base, const char* filename)
 138 {
 139   char buf[4096];
 140   struct rxpd_file* self = NULL;
 141
 142   // TODO better filenname validation / error handling
 143   if (!filename ||
 144       strchr (filename, '/') ||
 145       strlen (filename) + strlen (base->rulesdir) > 4097)
 146     return NULL;
 147
 148   strcpy (buf, base->rulesdir);
 149   strcat (buf, filename);
 150   filename = strdup (buf);
 151   if (filename)
 152     {
 153       self = malloc (sizeof (struct rxpd_file));
 154       if (self)
 155         {
 156           self->filename = filename;
 157           const char* basename = strrchr (filename, '/');
 158           if (basename)
 159             ++basename;
 160           else
 161             basename = filename;
 162           psplay_init (&self->node, basename);
 163           llist_init (&self->rules);
 164
 165           psplay_insert (&base->files, &self->node);
 166         }
 167     }
 168   return self;
 169 }
 170
 171 void
 172 rxpd_file_delete (PSplay f)
 173 {
 174   if (f)
 175     {
 176       struct rxpd_file* file = (struct rxpd_file*)f;
 177       LLIST_WHILE_HEAD (&file->rules, n)
 178         {
 179           struct rxpd_rule* node = (struct rxpd_rule*)n;
 180           rxpd_rule_delete (node);
 181         }
 182       free ((void*)file->filename);
 183       free (f);
 184     }
 185 }
 186
 187 int
 188 rxpd_file_load (struct rxpd_file* self)
 189 {
 190   FILE* f = fopen (self->filename, "r");
 191   // TODO error handling
 192   if (f)
 193     {
 194       // TODO test excess line length = error
 195       char buf[4096];
 196
 197       while (fgets (buf, 4096, f))
 198         {
 199           size_t last = strlen(buf);
 200           if (buf[last-1] == '\n')
 201             buf[last-1] = '\0';
 202
 203           struct rxpd_rule* rule;
 204           rule = rxpd_rule_new (buf);
 205           if (!rule)
 206             abort();
 207
 208           printf("%s\n", rule->string);
 209
 210           llist_insert_tail (&self->rules, &rule->node);
 211         }
 212
 213       fclose (f);
 214       return 1;
 215     }
 216   else
 217     return 0;
 218 }
 219
 220 int
 221 rxpd_file_cmp (const void* A, const void* B)
 222 {
 223   return strcmp (A, B);
 224 }
 225
 226
 227 //
 228
 229 struct rxpd_socket*
 230 rxpd_socket_new_tcp4 (struct rxpd_base* base, const char* addr, unsigned short port)
 231 {
 232   struct rxpd_socket* self = malloc (sizeof (struct rxpd_socket));
 233   if (!self)
 234     abort();
 235
 236   self->base = base;
 237
 238   llist_init (&self->node);
 239
 240   self->fd = socket (PF_INET, SOCK_STREAM, 0);
 241   if (self->fd == -1)
 242     abort ();
 243
 244   struct sockaddr_in listen_addr;
 245   memset (&listen_addr, 0, sizeof (listen_addr));
 246
 247   listen_addr.sin_family = AF_INET;
 248   if (addr)
 249     {
 250       if (inet_aton (addr, &listen_addr.sin_addr) == 0)
 251         abort();
 252     }
 253   else
 254     listen_addr.sin_addr.s_addr = INADDR_ANY;
 255
 256   listen_addr.sin_port = htons(port);
 257
 258   if (bind (self->fd, (struct sockaddr*)&listen_addr, sizeof (listen_addr)) == -1)
 259     abort();
 260
 261   static int yes = 1;
 262   if (setsockopt (self->fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
 263     abort ();
 264
 265   if (listen (self->fd, 20) == -1)
 266     abort ();
 267
 268   event_set (&self->ev, self->fd, EV_READ, rxpd_socket_accept, self);
 269   llist_insert_tail (&base->sockets_pending, &self->node);
 270   return self;
 271 }
 272
 273
 274 void
 275 rxpd_socket_delete (struct rxpd_socket* self)
 276 {
 277   if (self)
 278     {
 279       event_del (&self->ev);
 280       llist_unlink (&self->node);
 281       close (self->fd);
 282     }
 283   free (self);
 284 }
 285
 286 struct rxpd_socket*
 287 rxpd_socket_schedule (struct rxpd_socket* self)
 288 {
 289   if (self)
 290     {
 291       llist_insert_head (&self->base->sockets_active, &self->node);
 292       event_add (&self->ev, NULL);
 293     }
 294   return self;
 295 }
 296
 297 struct rxpd_socket*
 298 rxpd_socket_suspend (struct rxpd_socket* self)
 299 {
 300   if (self)
 301     {
 302       event_del (&self->ev);
 303       llist_insert_tail (&self->base->sockets_pending, &self->node);
 304     }
 305   return self;
 306 }
 307
 308 void
 309 rxpd_socket_accept (int fd, short event, void* ptr)
 310 {
 311   printf ("incoming connection\n");
 312
 313   struct rxpd_socket* self = ptr;
 314
 315   struct rxpd_connection* conn =
 316     rxpd_connection_new (self->base, fd);
 317
 318   rxpd_connection_schedule (conn);
 319   rxpd_socket_schedule (self);
 320 }
 321
 322 ///
 323
 324 struct rxpd_buffer*
 325 rxpd_buffer_init (struct rxpd_buffer* self, struct rxpd_connection* conn)
 326 {
 327   self->conn = conn;
 328   self->state = RXPD_OK;
 329   self->eol = self->eob = self->buffer;
 330   self->buffer [4095] = '\0';
 331   return self;
 332 }
 333
 334
 335 char*
 336 rxpd_buffer_readline (struct rxpd_buffer* self, int again)
 337 {
 338   int fd = self->conn->fd;
 339
 340   if (self->eol < self->eob)
 341     {
 342       //there was a line pending, shift buffer left
 343       memmove (self->buffer, self->eol+1, self->eob - self->eol - 1);
 344       self->eob = (char*)(self->eob - (self->eol - self->buffer + 1));
 345       self->eol = self->buffer;
 346       // TODO handle \r's
 347     }
 348
 349
 350   if (!again && self->state == RXPD_OK)   // we only read when again is 0, first iteration
 351     {
 352       ssize_t r = 0;
 353       do
 354         {
 355           r = read(fd, self->eob, 4095 - (self->eob - self->buffer));
 356         }
 357       while (r == -1 && errno == EINTR);
 358
 359       if (r != -1)
 360         {
 361
 362           if (r == 0)
 363             {
 364               shutdown (fd, SHUT_RD);
 365               self->state = RXPD_EOF;
 366             }
 367
 368           self->eob += r;
 369         }
 370       else
 371         self->state = RXPD_ERROR;
 372     }
 373
 374   // find next newline, terminate string there
 375   for (char* i = self->buffer; i < self->eob; ++i)
 376     {
 377       if (*i == '\n')
 378         {
 379           *i = '\0';
 380           self->eol = i;
 381           break;
 382         }
 383     }
 384
 385   // TODO handle buffer overfulls
 386
 387   return (self->eob == self->buffer) ? NULL : self->buffer;
 388 }
 389
 390 /*
 391 void
 392 rxpd_buffer_write(int fd, short event, void* ptr)
 393 {
 394   struct rxpd_buffer* self = (struct rxpd_buffer*) ptr;
 395
 396   ssize_t n = write(int fd, const void *buf, size_t count);
 397
 398 }
 399 */
 400
 401 int
 402 rxpd_buffer_printf (struct rxpd_buffer* self, const char* fmt, ...)
 403 {
 404   // for now we do a blocking write, needs to be fixed some day
 405   // add string to buffer
 406   va_list ap;
 407   va_start(ap, fmt);
 408   //int sz = self->buffer+4096 - self->eob;
 409   int n = vsnprintf (self->buffer, 4096, fmt, ap);
 410   va_end(ap);
 411
 412   write (self->conn->fd, self->buffer, n);
 413
 414   if (n>4095)
 415     return 0;
 416
 417   return 1;
 418 }
 419
 420
 421
 422
 423 ///
 424
 425 struct rxpd_connection*
 426 rxpd_connection_new (struct rxpd_base* base, int fd)
 427 {
 428   struct rxpd_connection* self = malloc (sizeof (struct rxpd_connection));
 429   if (!self)
 430     abort();
 431
 432   llist_init (&self->node);
 433
 434   socklen_t addr_sz = sizeof (self->peer_addr);
 435   self->fd = accept (fd, (struct sockaddr*)&self->peer_addr, &addr_sz);
 436   if (self->fd == -1)
 437     abort ();
 438
 439   static int yes = 1;
 440   if (setsockopt (self->fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
 441     abort ();
 442
 443   self->base = base;
 444   self->file = NULL;
 445
 446   rxpd_buffer_init (&self->in, self);
 447   rxpd_buffer_init (&self->out, self);
 448
 449   event_set (&self->ev, self->fd, EV_READ, rxpd_connection_parse_cmd, self);
 450
 451   llist_insert_tail (&base->connections_pending, &self->node);
 452
 453   return self;
 454 }
 455
 456 void
 457 rxpd_connection_delete (struct rxpd_connection* self)
 458 {
 459   if (self)
 460     {
 461       event_del (&self->ev);
 462       llist_unlink (&self->node);
 463       close (self->fd);
 464     }
 465   free (self);
 466 }
 467
 468 struct rxpd_connection*
 469 rxpd_connection_schedule (struct rxpd_connection* self)
 470 {
 471   if (self)
 472     {
 473       llist_insert_tail (&self->base->connections_active, &self->node);
 474       event_add (&self->ev, NULL);
 475     }
 476   return self;
 477 }
 478
 479 struct rxpd_connection*
 480 rxpd_connection_suspend (struct rxpd_connection* self)
 481 {
 482   if (self)
 483     {
 484       event_del (&self->ev);
 485       llist_insert_tail (&self->base->connections_pending, &self->node);
 486     }
 487   return self;
 488 }
 489
 490 void
 491 rxpd_connection_parse_cmd (int fd, short event, void* ptr)
 492 {
 493   printf ("parse cmd\n");
 494   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 495
 496   char* line;
 497   line = rxpd_buffer_readline (&self->in, 0);
 498
 499   if (!line)
 500     {
 501       rxpd_buffer_printf (&self->out, "#ERROR: no data\n");
 502       close (fd);
 503       return;
 504     }
 505
 506   static const struct cmd_table
 507   {
 508     enum rxpd_cmd_e nr;
 509     const char* cmd;
 510     size_t sz;
 511   } cmds[] =
 512     {
 513 #define RXPD_CMD(cmd) {RXPD_CMD_##cmd, #cmd":", sizeof (#cmd)},
 514       RXPD_COMMANDS
 515 #undef RXPD_CMD
 516       {0, NULL, 0}
 517     };
 518
 519   const struct cmd_table* i;
 520   for (i = cmds; i->cmd; ++i)
 521     if (strncmp (line, i->cmd, i->sz) == 0)
 522       break;
 523   if (!i->cmd)
 524     {
 525       rxpd_buffer_printf (&self->out, "#ERROR: no command\n");
 526       rxpd_connection_delete (self);
 527       return;
 528     }
 529   // TODO policy check here
 530
 531   if (line[i->sz])
 532     {
 533       // rulename provided
 534       self->file = (struct rxpd_file*) psplay_find (&self->base->files, &line[i->sz]);
 535       if (!self->file)
 536         {
 537           self->file = rxpd_file_new (self->base, &line[i->sz]);
 538           if (!self->file)
 539             {
 540               rxpd_buffer_printf (&self->out, "#ERROR: illegal rule\n");
 541               rxpd_connection_delete (self);
 542               return;
 543             }
 544         }
 545     }
 546
 547   // dispatch
 548   switch (i->nr)
 549     {
 550 #define RXPD_CMD(cmd)                                                           \
 551 case RXPD_CMD_##cmd:                                                            \
 552   event_set (&self->ev, self->fd, EV_READ, rxpd_connection_cmd_##cmd, self);    \
 553   break;
 554       RXPD_COMMANDS
 555 #undef RXPD_CMD
 556     }
 557   rxpd_connection_schedule (self);
 558 }
 559
 560
 561
 562 void
 563 rxpd_connection_cmd_CHECK (int fd, short event, void* ptr)
 564 {
 565   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 566
 567   int again = -1;
 568   char* line;
 569   while (line = rxpd_buffer_readline (&self->in, ++again))
 570     {
 571
 572       if (*line == '\0')
 573         {
 574           rxpd_buffer_printf (&self->out, "#OK:\n");
 575           break;
 576         }
 577       else
 578         {
 579           LLIST_FOREACH (&self->file->rules, n)
 580             {
 581               struct rxpd_rule* rule = (struct rxpd_rule*)n;
 582               if (rule->string[0] != '#')
 583                 {
 584                   if (regexec (&rule->rx, line, 0, NULL, 0) == 0)
 585                     {
 586                       rxpd_buffer_printf (&self->out, "%s\n", rule->string);
 587                       break;
 588                     }
 589                 }
 590             }
 591         }
 592     }
 593
 594   if (rxpd_buffer_state (&self->in) == RXPD_OK)
 595     rxpd_connection_schedule (self);
 596   else
 597     {
 598       if (rxpd_buffer_state (&self->in) == RXPD_ERROR)
 599         rxpd_buffer_printf (&self->out, "#ERROR:\n");
 600       close (fd);
 601     }
 602 }
 603
 604 void
 605 rxpd_connection_cmd_APPEND (int fd, short event, void* ptr)
 606 {
 607   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 608   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 609 }
 610
 611 void
 612 rxpd_connection_cmd_PREPEND (int fd, short event, void* ptr)
 613 {
 614   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 615   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 616 }
 617
 618 void
 619 rxpd_connection_cmd_REMOVE (int fd, short event, void* ptr)
 620 {
 621   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 622   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 623 }
 624
 625 void
 626 rxpd_connection_cmd_REPLACE (int fd, short event, void* ptr)
 627 {
 628   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 629   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 630 }
 631
 632 void
 633 rxpd_connection_cmd_LOAD (int fd, short event, void* ptr)
 634 {
 635   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 636   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 637 }
 638
 639 void
 640 rxpd_connection_cmd_SAVE (int fd, short event, void* ptr)
 641 {
 642   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 643   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 644 }
 645
 646 void
 647 rxpd_connection_cmd_DUMP (int fd, short event, void* ptr)
 648 {
 649   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 650   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 651 }
 652
 653 void
 654 rxpd_connection_cmd_LIST (int fd, short event, void* ptr)
 655 {
 656   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 657   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 658 }
 659
 660 void
 661 rxpd_connection_cmd_SHUTDOWN (int fd, short event, void* ptr)
 662 {
 663   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
 664   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
 665 }
 666