#include "main.h"

#include "filter.h"

#include "heap.h"

#include "log.h"

#include "reqs.h"

#include "conf.h"

#define FILTER_BUFFER_LEN (512)

static int err;

struct filter_list {

};

static struct filter_list *fl = NULL;

static int already_init = 0;

static filter_policy_t default_policy = FILTER_DEFAULT_ALLOW;

void filter_init (void)

{

FILE *fd;

struct filter_list *p;

char buf[FILTER_BUFFER_LEN];

char *s;

int cflags;

if (fl || already_init) {

return;

}

fd = fopen (config.filter, "r");

if (!fd) {

return;

}

p = NULL;

cflags = REG_NEWLINE | REG_NOSUB;

if (config.filter_extended)

cflags |= REG_EXTENDED;

if (!config.filter_casesensitive)

cflags |= REG_ICASE;

while (fgets (buf, FILTER_BUFFER_LEN, fd)) {

/*

s = buf;

while (*s) {

if (isspace ((unsigned char) *s))

break;

if (*s == '#') {

/*

if (s == buf || *(s - 1) != '\\')

break;

}

++s;

}

*s = '\0';

/* skip leading whitespace */

s = buf;

while (*s && isspace ((unsigned char) *s))

s++;

/* skip blank lines and comments */

if (*s == '\0')

continue;

if (!p) /* head of list */

fl = p =

(struct filter_list *)

safecalloc (1, sizeof (struct filter_list));

else { /* next entry */

p->next =

(struct filter_list *)

safecalloc (1, sizeof (struct filter_list));

p = p->next;

}

p->pat = safestrdup (s);

p->cpat = (regex_t *) safemalloc (sizeof (regex_t));

err = regcomp (p->cpat, p->pat, cflags);

if (err != 0) {

fprintf (stderr,

"Bad regex in %s: %s\n",

config.filter, p->pat);

exit (EX_DATAERR);

}

}

if (ferror (fd)) {

perror ("fgets");

exit (EX_DATAERR);

}

fclose (fd);

already_init = 1;

}

void filter_destroy (void)

{

struct filter_list *p, *q;

if (already_init) {

for (p = q = fl; p; p = q) {

regfree (p->cpat);

safefree (p->cpat);

safefree (p->pat);

q = p->next;

safefree (p);

}

fl = NULL;

already_init = 0;

}

}

void filter_reload (void)

{

if (config.filter) {

log_message (LOG_NOTICE, "Re-reading filter file.");

filter_destroy ();

filter_init ();

}

}

int filter_domain (const char *host)

{

struct filter_list *p;

int result;

if (!fl || !already_init)

goto COMMON_EXIT;

for (p = fl; p; p = p->next) {

result =

regexec (p->cpat, host, (size_t) 0, (regmatch_t *) 0, 0);

if (result == 0) {

if (default_policy == FILTER_DEFAULT_ALLOW)

return 1;

else

return 0;

}

}

COMMON_EXIT:

if (default_policy == FILTER_DEFAULT_ALLOW)

return 0;

else

return 1;

}

int filter_url (const char *url)

{

struct filter_list *p;

int result;

if (!fl || !already_init)

goto COMMON_EXIT;

for (p = fl; p; p = p->next) {

result =

regexec (p->cpat, url, (size_t) 0, (regmatch_t *) 0, 0);

if (result == 0) {

if (default_policy == FILTER_DEFAULT_ALLOW)

return 1;

else

return 0;

}

}

COMMON_EXIT:

if (default_policy == FILTER_DEFAULT_ALLOW)

return 0;

else

return 1;

}

void filter_set_default_policy (filter_policy_t policy)

{

default_policy = policy;

}