keep files by basename in lookup tree, store full pathname in rxpd_file
[rxpd] / 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 (inet_aton (addr?addr:"0.0.0.0", &listen_addr.sin_addr) == 0)
249     abort();
250   listen_addr.sin_port = htons(port);
251
252   if (bind (self->fd, (struct sockaddr*)&listen_addr, sizeof (listen_addr)) == -1)
253     abort();
254
255   static int yes = 1;
256   if (setsockopt (self->fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
257     abort ();
258
259   if (listen (self->fd, 20) == -1)
260     abort ();
261
262   event_set (&self->ev, self->fd, EV_READ, rxpd_socket_accept, self);
263   llist_insert_tail (&base->sockets_pending, &self->node);
264   return self;
265 }
266
267
268 void
269 rxpd_socket_delete (struct rxpd_socket* self)
270 {
271   if (self)
272     {
273       event_del (&self->ev);
274       llist_unlink (&self->node);
275       close (self->fd);
276     }
277   free (self);
278 }
279
280 struct rxpd_socket*
281 rxpd_socket_schedule (struct rxpd_socket* self)
282 {
283   if (self)
284     {
285       llist_insert_head (&self->base->sockets_active, &self->node);
286       event_add (&self->ev, NULL);
287     }
288   return self;
289 }
290
291 struct rxpd_socket*
292 rxpd_socket_suspend (struct rxpd_socket* self)
293 {
294   if (self)
295     {
296       event_del (&self->ev);
297       llist_insert_tail (&self->base->sockets_pending, &self->node);
298     }
299   return self;
300 }
301
302 void
303 rxpd_socket_accept (int fd, short event, void* ptr)
304 {
305   printf ("incoming connection\n");
306
307   struct rxpd_socket* self = ptr;
308
309   struct rxpd_connection* conn =
310     rxpd_connection_new (self->base, fd);
311
312   rxpd_connection_schedule (conn);
313   rxpd_socket_schedule (self);
314 }
315
316 ///
317
318 struct rxpd_buffer*
319 rxpd_buffer_init (struct rxpd_buffer* self, struct rxpd_connection* conn)
320 {
321   self->conn = conn;
322   self->state = RXPD_OK;
323   self->eol = self->eob = self->buffer;
324   self->buffer [4095] = '\0';
325   return self;
326 }
327
328
329 char*
330 rxpd_buffer_readline (struct rxpd_buffer* self, int again)
331 {
332   int fd = self->conn->fd;
333
334   if (self->eol != self->buffer)
335     {
336       //there was a line pending, discard it now
337       memmove (self->buffer, self->eol+1, self->eob - self->eol - 1);
338       self->eob = (char*)(self->eob - (self->eol - self->buffer + 1));
339       self->eol = self->buffer;
340       // TODO handle \r's
341     }
342
343   if (!again && self->state == RXPD_OK)   // we only read when again is 0, first iteration
344     {
345       ssize_t r = 0;
346       do
347         {
348           r = read(fd, self->eob, 4096 - (self->eob - self->buffer));
349         }
350       while (r == -1 && errno == EINTR);
351
352       if (r == -1)
353         self->state = RXPD_ERROR;
354
355       if (r == 0)
356         {
357           shutdown (fd, SHUT_RD);
358           self->state = RXPD_EOF;
359         }
360
361       self->eob += r;
362     }
363
364   // find next newline, terminate string there
365   for (char* i = self->buffer; i < self->eob; ++i)
366     {
367       if (*i == '\n')
368         {
369           *i = '\0';
370           self->eol = i;
371           break;
372         }
373     }
374
375   // TODO handle buffer overfulls
376
377   return self->eol == self->buffer ? NULL : self->buffer;
378 }
379
380 /*
381 void
382 rxpd_buffer_write(int fd, short event, void* ptr)
383 {
384   struct rxpd_buffer* self = (struct rxpd_buffer*) ptr;
385
386   ssize_t n = write(int fd, const void *buf, size_t count);
387
388 }
389 */
390
391 int
392 rxpd_buffer_printf (struct rxpd_buffer* self, const char* fmt, ...)
393 {
394   // for now we do a blocking write, needs to be fixed some day
395   // add string to buffer
396   va_list ap;
397   va_start(ap, fmt);
398   //int sz = self->buffer+4096 - self->eob;
399   int n = vsnprintf (self->buffer, 4096, fmt, ap);
400   va_end(ap);
401
402   write (self->conn->fd, self->buffer, n);
403
404   if (n>4095)
405     return 0;
406
407   return 1;
408 }
409
410
411
412
413 ///
414
415 struct rxpd_connection*
416 rxpd_connection_new (struct rxpd_base* base, int fd)
417 {
418   struct rxpd_connection* self = malloc (sizeof (struct rxpd_connection));
419   if (!self)
420     abort();
421
422   llist_init (&self->node);
423
424   socklen_t addr_sz = sizeof (self->peer_addr); 
425   self->fd = accept (fd, (struct sockaddr*)&self->peer_addr, &addr_sz);
426   if (self->fd == -1)
427     abort ();
428
429   static int yes = 1;
430   if (setsockopt (self->fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
431     abort ();
432
433   self->base = base;
434   self->file = NULL;
435
436   rxpd_buffer_init (&self->in, self);
437   rxpd_buffer_init (&self->out, self);
438   
439   event_set (&self->ev, self->fd, EV_READ, rxpd_connection_parse_cmd, self);
440
441   llist_insert_tail (&base->connections_pending, &self->node);
442
443   return self;
444 }
445
446 void
447 rxpd_connection_delete (struct rxpd_connection* self)
448 {
449   if (self)
450     {
451       event_del (&self->ev);
452       llist_unlink (&self->node);
453       close (self->fd);
454     }
455   free (self);
456 }
457
458 struct rxpd_connection*
459 rxpd_connection_schedule (struct rxpd_connection* self)
460 {
461   if (self)
462     {
463       llist_insert_tail (&self->base->connections_active, &self->node);
464       event_add (&self->ev, NULL);
465     }
466   return self;
467 }
468
469 struct rxpd_connection*
470 rxpd_connection_suspend (struct rxpd_connection* self)
471 {
472   if (self)
473     {
474       event_del (&self->ev);
475       llist_insert_tail (&self->base->connections_pending, &self->node);
476     }
477   return self;
478 }
479
480 void
481 rxpd_connection_parse_cmd (int fd, short event, void* ptr)
482 {
483   printf ("parse cmd\n");
484   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
485
486   char* line;
487   while (!(line = rxpd_buffer_readline (&self->in, 0)) && (rxpd_buffer_state (&self->in) == RXPD_OK));
488
489   if (!line)
490     {
491       rxpd_buffer_printf (&self->out, "#ERROR: no data\n");
492       close (fd);
493       return;
494     }
495
496   static const struct cmd_table
497   {
498     enum rxpd_cmd_e nr;
499     const char* cmd;
500     size_t sz;
501   } cmds[] =
502     {
503 #define RXPD_CMD(cmd) {RXPD_CMD_##cmd, #cmd":", sizeof (#cmd)},
504       RXPD_COMMANDS
505 #undef RXPD_CMD
506       {0, NULL, 0}
507     };
508
509   const struct cmd_table* i;
510   for (i = cmds; i->cmd; ++i)
511     if (strncmp (line, i->cmd, i->sz) == 0)
512       break;
513   if (!i->cmd)
514     {
515       rxpd_buffer_printf (&self->out, "#ERROR: no command\n");
516       rxpd_connection_delete (self);
517       return;
518     }
519   // TODO policy check here
520
521   if (line[i->sz])
522     {
523       // rulename provided
524       self->file = (struct rxpd_file*) psplay_find (&self->base->files, &line[i->sz]);
525       if (!self->file)
526         {
527           self->file = rxpd_file_new (self->base, &line[i->sz]);
528           if (!self->file)
529             {
530               rxpd_buffer_printf (&self->out, "#ERROR: illegal rule\n");
531               rxpd_connection_delete (self);
532               return;
533             }
534         }
535     }
536
537   // dispatch
538   switch (i->nr)
539     {
540 #define RXPD_CMD(cmd)                                                           \
541 case RXPD_CMD_##cmd:                                                            \
542   event_set (&self->ev, self->fd, EV_READ, rxpd_connection_cmd_##cmd, self);    \
543   break;
544       RXPD_COMMANDS
545 #undef RXPD_CMD
546     }
547   rxpd_connection_schedule (self);
548 }
549
550 void
551 rxpd_connection_cmd_CHECK (int fd, short event, void* ptr)
552 {
553   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
554   LLIST_FOREACH (&self->file.rules, node)
555   
556
557     //rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
558
559
560   rxpd_connection_schedule (self);
561 }
562
563 void
564 rxpd_connection_cmd_APPEND (int fd, short event, void* ptr)
565 {
566   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
567   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
568 }
569
570 void
571 rxpd_connection_cmd_PREPEND (int fd, short event, void* ptr)
572 {
573   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
574   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
575 }
576
577 void
578 rxpd_connection_cmd_REMOVE (int fd, short event, void* ptr)
579 {
580   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
581   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
582 }
583
584 void
585 rxpd_connection_cmd_REPLACE (int fd, short event, void* ptr)
586 {
587   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
588   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
589 }
590
591 void
592 rxpd_connection_cmd_LOAD (int fd, short event, void* ptr)
593 {
594   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
595   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
596 }
597
598 void
599 rxpd_connection_cmd_SAVE (int fd, short event, void* ptr)
600 {
601   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
602   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
603 }
604
605 void
606 rxpd_connection_cmd_DUMP (int fd, short event, void* ptr)
607 {
608   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
609   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
610 }
611
612 void
613 rxpd_connection_cmd_LIST (int fd, short event, void* ptr)
614 {
615   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
616   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
617 }
618
619 void
620 rxpd_connection_cmd_SHUTDOWN (int fd, short event, void* ptr)
621 {
622   struct rxpd_connection* self = (struct rxpd_connection*) ptr;
623   rxpd_buffer_printf (&self->out, "#ERROR: unimplemented command %s\n", &__func__[20]);
624 }
625