# HG changeset patch # User carl # Date 1142015408 28800 # Node ID 616666e2f34c6df507c4dba452f7c8b289bff920 initial version diff -r 000000000000 -r 616666e2f34c html/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/html/Makefile.am Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,3 @@ +htmldir = ${datadir}/doc/@PACKAGE@-@VERSION@ +html_DATA = $(wildcard *.html) $(wildcard *.pdf) +EXTRA_DIST = $(html_DATA) diff -r 000000000000 -r 616666e2f34c info/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/info/Makefile.am Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,2 @@ +info_INFOS = dnsbl.texi +EXTRA_DIST = $(info_INFOS) diff -r 000000000000 -r 616666e2f34c man/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/man/Makefile.am Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,2 @@ +man_MANS = dnsbl.1 dnsbl.conf.5 +EXTRA_DIST = $(man_MANS) diff -r 000000000000 -r 616666e2f34c src/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/Makefile.am Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,13 @@ +sbin_PROGRAMS = sm-archive +sm-archive_SOURCES = sm-archive.cpp sm-archive.h context.cpp context.h tokenizer.cpp tokenizer.h includes.h +EXTRA_DIST = test.cpp + +# set the include path found by configure +INCLUDES= $(all_includes) + +# the library search path. +sm-archive_LDFLAGS = $(all_libraries) /usr/lib/libresolv.a -lmilter -pthread + +# default compile flags +sm-archive_CXXFLAGS = -pthread + diff -r 000000000000 -r 616666e2f34c src/context.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/context.cpp Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,202 @@ +/* + +Copyright (c) 2004 Carl Byington - 510 Software Group, released under +the GPL version 2 or any later version at your choice available at +http://www.fsf.org/licenses/gpl.txt + +*/ + +#include "includes.h" + +// needed for socket io +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static char* context_version="$Id$"; + +char *token_envfrom; +char *token_lbrace; +char *token_rbrace; +char *token_rcptto; +char *token_semi; + +string_set all_strings; // owns all the strings, only modified by the config loader thread +const int maxlen = 1000; // used for snprintf buffers + +CONFIG::CONFIG() { + reference_count = 0; + generation = 0; + load_time = 0; +} + + +CONFIG::~CONFIG() { +} + + +char *CONFIG::find(char *needle, &string_map haystack) { + string_map::iterator i = haystack.find(needle); + if (i != haystack.end()) return (*i).second; // found user@domain.tld key + char *x = strchr(needle, '@'); + if (x) { + x++; + i = haystack.find(x); + if (i != haystack.end()) return (*i).second; // found domain.tld key + char y = *x; + *x = '\0'; + i = haystack.find(needle); + *x = y; + if (i != haystack.end()) return (*i).second; // found user@ key + } + return NULL; +} + + +void CONFIG::dump() { + printf("rcpt_to {\n"); + for (string_map::iterator i=rcpt_to.begin(); i!=rcpt_to.end(); i++) { + char *to = (*i).first; + char *target = (*i).second; + printf(" %s \t %s\n", to, target); + } + printf("};\n"); + printf("env_from {\n"); + for (string_map::iterator i=env_from.begin(); i!=env_from.end(); i++) { + char *from = (*i).first; + char *target = (*i).second; + printf(" %s \t %s\n", from, target); + } + printf("};\n"); +} + + +//////////////////////////////////////////////// +// helper to discard the strings held by a string_set +// +void discard(string_set &s) { + for (string_set::iterator i=s.begin(); i!=s.end(); i++) { + free(*i); + } + s.clear(); +} + + +//////////////////////////////////////////////// +// helper to register a string in a string set +// +char* register_string(string_set &s, char *name) { + string_set::iterator i = s.find(name); + if (i != s.end()) return *i; + char *x = strdup(name); + s.insert(x); + return x; +} + + +//////////////////////////////////////////////// +// register a global string +// +char* register_string(char *name) { + return register_string(all_strings, name); +} + + +//////////////////////////////////////////////// +// +bool tsa(TOKEN &tok, char *token); +bool tsa(TOKEN &tok, char *token) { + char *have = tok.next(); + if (have == token) return true; + tok.token_error(token, have); + return false; +} + + +//////////////////////////////////////////////// +// +bool parse_rcpt_to(TOKEN &tok, CONFIG &dc); +bool parse_rcpt_to(TOKEN &tok, CONFIG &dc) { + if (!tsa(tok, token_lbrace)) return false; + while (true) { + char *have = tok.next(); + if (!have) break; + if (have == token_rbrace) break; + if (have == token_semi) { + // optional separators + } + else { + char *target = tok.next(); + dc.add_to(have, target); + } + } + return tsa(tok, token_semi); +} + + +//////////////////////////////////////////////// +// +bool parse_env_from(TOKEN &tok, CONFIG &dc); +bool parse_env_from(TOKEN &tok, CONFIG &dc) { + if (!tsa(tok, token_lbrace)) return false; + while (true) { + char *have = tok.next(); + if (!have) break; + if (have == token_rbrace) break; + if (have == token_semi) { + // optional separators + } + else { + char *target = tok.next(); + dc.add_from(have, target); + } + } + return tsa(tok, token_semi); +} + + +//////////////////////////////////////////////// +// parse a config file +// +bool load_conf(CONFIG &dc, char *fn) { + TOKEN tok(fn, &dc.config_files); + while (true) { + char *have = tok.next(); + if (!have) break; + if (have == token_envfrom) { + if (!parse_env_from(tok, dc)) { + tok.token_error("load_conf() failed to parse env_from"); + return false; + } + } + else if (have == token_rcptto) { + if (!parse_rcpt_to(tok, dc)) { + tok.token_error("load_conf() failed to parse rcpt_to"); + return false; + } + } + else { + tok.token_error(token_context, have); + return false; + } + } + return true; +} + + +//////////////////////////////////////////////// +// init the tokens +// +void token_init() { + token_envfrom = register_string("env_from"); + token_lbrace = register_string("{"); + token_rbrace = register_string("}"); + token_rcptto = register_string("rcpt_to"); + token_semi = register_string(";"); +} diff -r 000000000000 -r 616666e2f34c src/context.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/context.h Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,44 @@ +#ifndef context_include +#define context_include + +#include "tokenizer.h" +#include + + +typedef map string_map; + +struct CONFIG { + // the only mutable stuff once it has been loaded from the config file + int reference_count; // protected by the global config_mutex + // all the rest is constant after loading from the config file + int generation; + time_t load_time; + string_map env_from; // map senders to archive mailboxes + string_map rcpt_to; // map recipients to archive mailboxes + + CONFIG(); + ~CONFIG(); + void add_from(char *from, char *target) {env_from[from] = target; }; + void add_to(char *to, char *target) {rcpt_to[to] = target; }; + char * find_from(char *from) {return find(from, env_from);}; + char * find_to(char *to) {return find(to, env_to); }; + char * find(char *needle, &string_map haystack); + void dump(); +}; + +extern char *token_envfrom; +extern char *token_lbrace; +extern char *token_rbrace; +extern char *token_rcptto; +extern char *token_semi; + +extern string_set all_strings; // owns all the strings, only modified by the config loader thread + +void discard(string_set &s); +char* register_string(string_set &s, char *name); +char* register_string(char *name); +CONFIG *parse_config(char *fn); +bool load_conf(CONFIG &dc, char *fn); +void token_init(); + +#endif diff -r 000000000000 -r 616666e2f34c src/includes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/includes.h Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,8 @@ +#define VERIFY_DEBUG 1 +#define RESOLVER_DEBUG 1 +#undef VERIFY_DEBUG +#undef RESOLVER_DEBUG + +#include "tokenizer.h" +#include "context.h" +#include "dnsbl.h" diff -r 000000000000 -r 616666e2f34c src/sm-archive.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/sm-archive.cpp Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,509 @@ +/* + +Copyright (c) 2004, 2005 Carl Byington - 510 Software Group, released +under the GPL version 2 or any later version at your choice available at +http://www.fsf.org/licenses/gpl.txt + +Based on a sample milter Copyright (c) 2000-2003 Sendmail, Inc. and its +suppliers. Inspired by the DCC by Rhyolite Software + +-p port The port through which the MTA will connect to this milter. +-t sec The timeout value. +-c Check the config, and print a copy to stdout. Don't start the + milter or do anything with the socket. +-d increase debug level + +*/ + + +// from sendmail sample +#include +#include +#include +#include +#include + +// needed for socket io +#include +#include +#include +#include +#include +#include +#include +#include + +// needed for thread +#include + +// needed for std c++ collections +#include +#include +#include + +// for the dns resolver +#include +#include +#include + +// misc stuff needed here +#include +#include +#include +#include /* header for waitpid() and various macros */ +#include /* header for signal functions */ + +#include "includes.h" + +static char* dnsbl_version="$Id$"; + + +extern "C" { + #include "libmilter/mfapi.h" + sfsistat mlfi_connect(SMFICTX *ctx, char *hostname, _SOCK_ADDR *hostaddr); + sfsistat mlfi_envfrom(SMFICTX *ctx, char **argv); + sfsistat mlfi_envrcpt(SMFICTX *ctx, char **argv); + sfsistat mlfi_eom(SMFICTX *ctx); + sfsistat mlfi_abort(SMFICTX *ctx); + sfsistat mlfi_close(SMFICTX *ctx); + void sig_chld(int signo); +} + +int debug_syslog = 0; +bool syslog_opened = false; +bool use_syslog = true; // false to printf +bool loader_run = true; // used to stop the config loader thread +CONFIG *config = NULL; // protected by the config_mutex +int generation = 0; // protected by the config_mutex +const int maxlen = 1000; // used for snprintf buffers + +pthread_mutex_t config_mutex; +pthread_mutex_t syslog_mutex; + + +mlfiPriv::mlfiPriv() { + pthread_mutex_lock(&config_mutex); + pc = config; + pc->reference_count++; + pthread_mutex_unlock(&config_mutex); + mailaddr = NULL; + queueid = NULL; + processed_from = false; +} + +mlfiPriv::~mlfiPriv() { + pthread_mutex_lock(&config_mutex); + pc->reference_count--; + pthread_mutex_unlock(&config_mutex); + reset(true); +} + +void mlfiPriv::reset(bool final) { + processed_from = false; + if (mailaddr) free(mailaddr); + if (queueid) free(queueid); + if (!final) { + mailaddr = NULL; + queueid = NULL; + } +} + +#define MLFIPRIV ((struct mlfiPriv *) smfi_getpriv(ctx)) + + +//////////////////////////////////////////////// +// syslog a message +// +void my_syslog(mlfiPriv *priv, char *text) { + char buf[maxlen]; + if (priv) { + snprintf(buf, sizeof(buf), "%s: %s", priv->queueid, text); + text = buf; + } + if (use_syslog) { + pthread_mutex_lock(&syslog_mutex); + if (!syslog_opened) { + openlog("dnsbl", LOG_PID, LOG_MAIL); + syslog_opened = true; + } + syslog(LOG_NOTICE, "%s", text); + pthread_mutex_unlock(&syslog_mutex); + } + else { + printf("%s \n", text); + } +} + +void my_syslog(char *text) { + my_syslog(NULL, text); +} + + +//////////////////////////////////////////////// +// this email address is passed in from sendmail, and will +// always be enclosed in <>. It may have mixed case, just +// as the mail client sent it. We dup the string and convert +// the duplicate to lower case. +// +char *to_lower_string(char *email); +char *to_lower_string(char *email) { + int n = strlen(email)-2; + if (n < 1) return strdup(email); + char *key = strdup(email+1); + key[n] = '\0'; + for (int i=0; i 1) { + char msg[maxlen]; + snprintf(msg, sizeof(msg), "from <%s> to <%s>", priv.mailaddr, rcptaddr); + my_syslog(&priv, msg); + } + char *target = dc.find_to(rcptaddr); + if (target) smfi_addrcpt(ctx, target); + free(rcptaddr); + if (!processed_from) { + target = dc.find_from(priv.mailaddr); + if (target) smfi_addrcpt(ctx, target); + processed_from = true; + } + return SMFIS_CONTINUE; +} + +sfsistat mlfi_eom(SMFICTX *ctx) +{ + // reset for a new message on the same connection + mlfi_abort(ctx); + return SMFIS_CONTINUE; +} + +sfsistat mlfi_abort(SMFICTX *ctx) +{ + mlfiPriv &priv = *MLFIPRIV; + if (!priv) return SMFIS_CONTINUE; + priv.reset(); + return SMFIS_CONTINUE; +} + +sfsistat mlfi_close(SMFICTX *ctx) +{ + mlfiPriv *priv = MLFIPRIV; + if (!priv) return SMFIS_CONTINUE; + delete priv; + smfi_setpriv(ctx, NULL); + return SMFIS_CONTINUE; +} + +struct smfiDesc smfilter = +{ + "SM-ARCHIVE", // filter name + SMFI_VERSION, // version code -- do not change + SMFIF_ADDRCPT, // flags + mlfi_connect, // connection info filter + NULL, // SMTP HELO command filter + mlfi_envfrom, // envelope sender filter + mlfi_envrcpt, // envelope recipient filter + NULL, // header filter + NULL, // end of header + NULL, // body block filter + mlfi_eom, // end of message + mlfi_abort, // message aborted + mlfi_close, // connection cleanup +}; + + +//////////////////////////////////////////////// +// reload the config +// +CONFIG* new_conf(); +CONFIG* new_conf() { + CONFIG *newc = new CONFIG; + pthread_mutex_lock(&config_mutex); + newc->generation = generation++; + pthread_mutex_unlock(&config_mutex); + if (debug_syslog) { + char buf[maxlen]; + snprintf(buf, sizeof(buf), "loading configuration generation %d", newc->generation); + my_syslog(buf); + } + if (load_conf(*newc, "dnsbl.conf")) { + newc->load_time = time(NULL); + return newc; + } + delete newc; + return NULL; +} + + +//////////////////////////////////////////////// +// thread to watch the old config files for changes +// and reload when needed. we also cleanup old +// configs whose reference count has gone to zero. +// +void* config_loader(void *arg); +void* config_loader(void *arg) { + typedef set configp_set; + configp_set old_configs; + while (loader_run) { + sleep(180); // look for modifications every 3 minutes + if (!loader_run) break; + CONFIG &dc = *config; + time_t then = dc.load_time; + struct stat st; + bool reload = false; + for (string_set::iterator i=dc.config_files.begin(); i!=dc.config_files.end(); i++) { + char *fn = *i; + if (stat(fn, &st)) reload = true; // file disappeared + else if (st.st_mtime > then) reload = true; // file modified + if (reload) break; + } + if (reload) { + CONFIG *newc = new_conf(); + if (newc) { + // replace the global config pointer + pthread_mutex_lock(&config_mutex); + CONFIG *old = config; + config = newc; + pthread_mutex_unlock(&config_mutex); + if (old) old_configs.insert(old); + } + else { + // failed to load new config + my_syslog("failed to load new configuration"); + system("echo 'failed to load new dnsbl configuration from /etc/dnsbl' | mail -s 'error in /etc/dnsbl configuration' root"); + // update the load time on the current config to prevent complaining every 3 minutes + dc.load_time = time(NULL); + } + } + // now look for old configs with zero ref counts + for (configp_set::iterator i=old_configs.begin(); i!=old_configs.end(); ) { + CONFIG *old = *i; + if (!old->reference_count) { + if (debug_syslog) { + char buf[maxlen]; + snprintf(buf, sizeof(buf), "freeing memory for old configuration generation %d", old->generation); + my_syslog(buf); + } + delete old; // destructor does all the work + old_configs.erase(i++); + } + else i++; + } + } + return NULL; +} + + +void usage(char *prog); +void usage(char *prog) +{ + fprintf(stderr, "Usage: %s [-d [level]] [-c] -p sm-sock-addr [-t timeout]\n", prog); + fprintf(stderr, "where sm-sock-addr is for the connection to sendmail\n"); + fprintf(stderr, " and should be one of\n"); + fprintf(stderr, " inet:port@ip-address\n"); + fprintf(stderr, " local:local-domain-socket-file-name\n"); + fprintf(stderr, "-c will load and dump the config to stdout\n"); + fprintf(stderr, "-d will set the syslog message level, currently 0 to 3\n"); +} + + + +void setup_socket(char *sock); +void setup_socket(char *sock) { + unlink(sock); + // sockaddr_un addr; + // memset(&addr, '\0', sizeof addr); + // addr.sun_family = AF_UNIX; + // strncpy(addr.sun_path, sock, sizeof(addr.sun_path)-1); + // int s = socket(AF_UNIX, SOCK_STREAM, 0); + // bind(s, (sockaddr*)&addr, sizeof(addr)); + // close(s); +} + + +/* + * The signal handler function -- only gets called when a SIGCHLD + * is received, ie when a child terminates + */ +void sig_chld(int signo) +{ + int status; + /* Wait for any child without blocking */ + while (waitpid(-1, &status, WNOHANG) > 0) { + // ignore child exit status, we only do this to cleanup zombies + } +} + + +int main(int argc, char**argv) +{ + token_init(); + bool check = false; + bool setconn = false; + int c; + const char *args = "p:t:d:ch"; + extern char *optarg; + + // Process command line options + while ((c = getopt(argc, argv, args)) != -1) { + switch (c) { + case 'p': + if (optarg == NULL || *optarg == '\0') { + fprintf(stderr, "Illegal sendmail socket: %s\n", optarg); + exit(EX_USAGE); + } + if (smfi_setconn(optarg) == MI_FAILURE) { + fprintf(stderr, "smfi_setconn failed\n"); + exit(EX_SOFTWARE); + } + if (strncasecmp(optarg, "unix:", 5) == 0) setup_socket(optarg + 5); + else if (strncasecmp(optarg, "local:", 6) == 0) setup_socket(optarg + 6); + setconn = true; + break; + + case 't': + if (optarg == NULL || *optarg == '\0') { + fprintf(stderr, "Illegal timeout: %s\n", optarg); + exit(EX_USAGE); + } + if (smfi_settimeout(atoi(optarg)) == MI_FAILURE) { + fprintf(stderr, "smfi_settimeout failed\n"); + exit(EX_SOFTWARE); + } + break; + + case 'c': + check = true; + break; + + case 'd': + if (optarg == NULL || *optarg == '\0') debug_syslog = 1; + else debug_syslog = atoi(optarg); + break; + + case 'h': + default: + usage(argv[0]); + exit(EX_USAGE); + } + } + + if (check) { + use_syslog = false; + debug_syslog = 10; + CONFIG *conf = new_conf(); + if (conf) { + conf->dump(); + delete conf; + return 0; + } + else { + return 1; // config failed to load + } + } + + if (!setconn) { + fprintf(stderr, "%s: Missing required -p argument\n", argv[0]); + usage(argv[0]); + exit(EX_USAGE); + } + + if (smfi_register(smfilter) == MI_FAILURE) { + fprintf(stderr, "smfi_register failed\n"); + exit(EX_UNAVAILABLE); + } + + // switch to background mode + if (daemon(1,0) < 0) { + fprintf(stderr, "daemon() call failed\n"); + exit(EX_UNAVAILABLE); + } + + // write the pid + const char *pidpath = "/var/run/dnsbl.pid"; + unlink(pidpath); + FILE *f = fopen(pidpath, "w"); + if (f) { +#ifdef linux + // from a comment in the DCC source code: + // Linux threads are broken. Signals given the + // original process are delivered to only the + // thread that happens to have that PID. The + // sendmail libmilter thread that needs to hear + // SIGINT and other signals does not, and that breaks + // scripts that need to stop milters. + // However, signaling the process group works. + fprintf(f, "-%d\n", (u_int)getpgrp()); +#else + fprintf(f, "%d\n", (u_int)getpid()); +#endif + fclose(f); + } + + // initialize the thread sync objects + pthread_mutex_init(&config_mutex, 0); + pthread_mutex_init(&syslog_mutex, 0); + + // drop root privs + struct passwd *pw = getpwnam("sm-archive"); + if (pw) { + if (setgid(pw->pw_gid) == -1) { + my_syslog("failed to switch to group dnsbl"); + } + if (setuid(pw->pw_uid) == -1) { + my_syslog("failed to switch to user dnsbl"); + } + } + + // load the initial config + config = new_conf(); + if (!config) { + my_syslog("failed to load initial configuration, quitting"); + exit(1); + } + + // only create threads after the fork() in daemon + pthread_t tid; + if (pthread_create(&tid, 0, config_loader, 0)) + my_syslog("failed to create config loader thread"); + if (pthread_detach(tid)) + my_syslog("failed to detach config loader thread"); + + time_t starting = time(NULL); + int rc = smfi_main(); + if ((rc != MI_SUCCESS) && (time(NULL) > starting+5*60)) { + my_syslog("trying to restart after smfi_main()"); + loader_run = false; // eventually the config loader thread will terminate + execvp(argv[0], argv); + } + exit((rc == MI_SUCCESS) ? 0 : EX_UNAVAILABLE); +} + diff -r 000000000000 -r 616666e2f34c src/sm-archive.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/sm-archive.h Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,27 @@ +#ifndef dnsbl_include +#define dnsbl_include + +#include "context.h" + +extern int debug_syslog; + +//////////////////////////////////////////////// +// mail filter private data, held for us by sendmail +// +struct mlfiPriv +{ + // connection specific data + CONFIG *pc; // global filtering configuration + // message specific data + char *mailaddr; // envelope from value + char *queueid; // sendmail queue id + bool processed_from; // looked at env_from address + mlfiPriv(); + ~mlfiPriv(); + void reset(bool final = false); // for a new message +}; + +void my_syslog(mlfiPriv *priv, char *text); +void my_syslog(char *text); + +#endif diff -r 000000000000 -r 616666e2f34c src/test.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/test.cpp Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,124 @@ +/* + +Copyright (c) 2004 Carl Byington - 510 Software Group, released under +the GPL version 2 or any later version at your choice available at +http://www.fsf.org/licenses/gpl.txt + +*/ + +#include +#include +#include +#include + +static char* test_version="$Id$"; + +using namespace std; + +struct ltstr { + bool operator()(char* s1, char* s2) const { + return strcmp(s1, s2) < 0; + } +}; + +typedef set string_set; + +static string_set all_strings; // owns all the strings, only modified by the config loader thread + +struct stats { + bool stop; + bool running; + int counter; + int errors; + stats(); +}; +stats::stats() { + stop = false; + running = false; + counter = 0; + errors = 0; +} + +//////////////////////////////////////////////// +// helper to discard the strings held by a string_set +// +static void discard(string_set &s); +static void discard(string_set &s) { + for (string_set::iterator i=s.begin(); i!=s.end(); i++) { + free(*i); + } + s.clear(); +} + +//////////////////////////////////////////////// +// helper to register a string in a string set +// +static char* register_string(string_set &s, char *name); +static char* register_string(string_set &s, char *name) { + string_set::iterator i = s.find(name); + if (i != s.end()) return *i; + char *x = strdup(name); + s.insert(x); + return x; +} + + +//////////////////////////////////////////////// +// thread tester +// +static void* tester(void *arg); +static void* tester(void *arg) { + stats &st = *((stats *)arg); + st.running = true; + while (!st.stop) { + const int LIMIT = 1000; + string_set *mine = new string_set; + string_set &me = *mine; + for (int i=0; i + { s_ignore, s_term, s_string2, s_ignore, s_ignore, }, // 0x0a + { s_single, s_term, s_string, s_single, s_eol, }, // 0x0b + { s_single, s_term, s_string, s_single, s_eol, }, // 0x0c + { s_ignore, s_term, s_string2, s_ignore, s_eol, }, // 0x0d + { s_single, s_term, s_string, s_single, s_eol, }, // 0x0e + { s_single, s_term, s_string, s_single, s_eol, }, // 0x0f + { s_single, s_term, s_string, s_single, s_eol, }, // 0x10 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x11 xon char + { s_single, s_term, s_string, s_single, s_eol, }, // 0x12 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x13 xoff char + { s_single, s_term, s_string, s_single, s_eol, }, // 0x14 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x15 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x16 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x17 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x18 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x19 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1a + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1b + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1c + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1d + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1e + { s_single, s_term, s_string, s_single, s_eol, }, // 0x1f + { s_ignore, s_term, s_string, s_ignore, s_eol, }, // 0x20 space + { s_single, s_term, s_string, s_single, s_eol, }, // 0x21 ! + { s_string1, s_term, s_string2, s_string1, s_eol, }, // 0x22 " + { s_eol, s_term, s_string, s_eol, s_eol, }, // 0x23 # + { s_single, s_term, s_string, s_single, s_eol, }, // 0x24 $ + { s_single, s_term, s_string, s_single, s_eol, }, // 0x25 % + { s_single, s_term, s_string, s_single, s_eol, }, // 0x26 & + { s_single, s_term, s_string, s_single, s_eol, }, // 0x27 ' + { s_single, s_term, s_string, s_single, s_eol, }, // 0x28 ( + { s_single, s_term, s_string, s_single, s_eol, }, // 0x29 ) + { s_single, s_term, s_string, s_single, s_eol, }, // 0x2A * + { s_single, s_token, s_string, s_single, s_eol, }, // 0x2B + + { s_single, s_term, s_string, s_single, s_eol, }, // 0x2C , + { s_single, s_token, s_string, s_single, s_eol, }, // 0x2D - + { s_single, s_token, s_string, s_single, s_eol, }, // 0x2E . + { s_slash, s_token, s_string, s_slash, s_eol, }, // 0x2F / + { s_token, s_token, s_string, s_token, s_eol, }, // 0x30 0 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x31 1 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x32 2 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x33 3 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x34 4 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x35 5 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x36 6 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x37 7 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x38 8 + { s_token, s_token, s_string, s_token, s_eol, }, // 0x39 9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x3A : + { s_single, s_term, s_string, s_single, s_eol, }, // 0x3B ; + { s_single, s_term, s_string, s_single, s_eol, }, // 0x3C < + { s_single, s_token, s_string, s_single, s_eol, }, // 0x3D = + { s_single, s_term, s_string, s_single, s_eol, }, // 0x3E > + { s_single, s_term, s_string, s_single, s_eol, }, // 0x3F ? + { s_single, s_token, s_string, s_single, s_eol, }, // 0x40 @ + { s_token, s_token, s_string, s_token, s_eol, }, // 0x41 A + { s_token, s_token, s_string, s_token, s_eol, }, // 0x42 B + { s_token, s_token, s_string, s_token, s_eol, }, // 0x43 C + { s_token, s_token, s_string, s_token, s_eol, }, // 0x44 D + { s_token, s_token, s_string, s_token, s_eol, }, // 0x45 E + { s_token, s_token, s_string, s_token, s_eol, }, // 0x46 F + { s_token, s_token, s_string, s_token, s_eol, }, // 0x47 G + { s_token, s_token, s_string, s_token, s_eol, }, // 0x48 H + { s_token, s_token, s_string, s_token, s_eol, }, // 0x49 I + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4A J + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4B K + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4C L + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4D M + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4E N + { s_token, s_token, s_string, s_token, s_eol, }, // 0x4F O + { s_token, s_token, s_string, s_token, s_eol, }, // 0x50 P + { s_token, s_token, s_string, s_token, s_eol, }, // 0x51 Q + { s_token, s_token, s_string, s_token, s_eol, }, // 0x52 R + { s_token, s_token, s_string, s_token, s_eol, }, // 0x53 S + { s_token, s_token, s_string, s_token, s_eol, }, // 0x54 T + { s_token, s_token, s_string, s_token, s_eol, }, // 0x55 U + { s_token, s_token, s_string, s_token, s_eol, }, // 0x56 V + { s_token, s_token, s_string, s_token, s_eol, }, // 0x57 W + { s_token, s_token, s_string, s_token, s_eol, }, // 0x58 X + { s_token, s_token, s_string, s_token, s_eol, }, // 0x59 Y + { s_token, s_token, s_string, s_token, s_eol, }, // 0x5A Z + { s_single, s_term, s_string, s_single, s_eol, }, // 0x5B [ + { s_single, s_term, s_string, s_single, s_eol, }, // 0x5C backslash + { s_single, s_term, s_string, s_single, s_eol, }, // 0x5D ] + { s_single, s_term, s_string, s_single, s_eol, }, // 0x5E ^ + { s_single, s_token, s_string, s_single, s_eol, }, // 0x5F _ + { s_single, s_term, s_string, s_single, s_eol, }, // 0x60 ` + { s_token, s_token, s_string, s_token, s_eol, }, // 0x61 a + { s_token, s_token, s_string, s_token, s_eol, }, // 0x62 b + { s_token, s_token, s_string, s_token, s_eol, }, // 0x63 c + { s_token, s_token, s_string, s_token, s_eol, }, // 0x64 d + { s_token, s_token, s_string, s_token, s_eol, }, // 0x65 e + { s_token, s_token, s_string, s_token, s_eol, }, // 0x66 f + { s_token, s_token, s_string, s_token, s_eol, }, // 0x67 g + { s_token, s_token, s_string, s_token, s_eol, }, // 0x68 h + { s_token, s_token, s_string, s_token, s_eol, }, // 0x69 i + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6A j + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6B k + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6C l + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6D m + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6E n + { s_token, s_token, s_string, s_token, s_eol, }, // 0x6F o + { s_token, s_token, s_string, s_token, s_eol, }, // 0x70 p + { s_token, s_token, s_string, s_token, s_eol, }, // 0x71 q + { s_token, s_token, s_string, s_token, s_eol, }, // 0x72 r + { s_token, s_token, s_string, s_token, s_eol, }, // 0x73 s + { s_token, s_token, s_string, s_token, s_eol, }, // 0x74 t + { s_token, s_token, s_string, s_token, s_eol, }, // 0x75 u + { s_token, s_token, s_string, s_token, s_eol, }, // 0x76 v + { s_token, s_token, s_string, s_token, s_eol, }, // 0x77 w + { s_token, s_token, s_string, s_token, s_eol, }, // 0x78 x + { s_token, s_token, s_string, s_token, s_eol, }, // 0x79 y + { s_token, s_token, s_string, s_token, s_eol, }, // 0x7A z + { s_single, s_term, s_string, s_single, s_eol, }, // 0x7B { + { s_single, s_term, s_string, s_single, s_eol, }, // 0x7C | + { s_single, s_term, s_string, s_single, s_eol, }, // 0x7D } + { s_single, s_term, s_string, s_single, s_eol, }, // 0x7E ~ + { s_single, s_term, s_string, s_single, s_eol, }, // 0x7f + { s_single, s_term, s_string, s_single, s_eol, }, // 0x80 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x81 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x82 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x83 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x84 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x85 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x86 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x87 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x88 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x89 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8a + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8b + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8c + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8d + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8e + { s_single, s_term, s_string, s_single, s_eol, }, // 0x8f + { s_single, s_term, s_string, s_single, s_eol, }, // 0x90 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x91 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x92 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x93 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x94 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x95 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x96 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x97 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x98 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x99 + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9a + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9b + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9c + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9d + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9e + { s_single, s_term, s_string, s_single, s_eol, }, // 0x9f + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xa9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xaa + { s_single, s_term, s_string, s_single, s_eol, }, // 0xab + { s_single, s_term, s_string, s_single, s_eol, }, // 0xac + { s_single, s_term, s_string, s_single, s_eol, }, // 0xad + { s_single, s_term, s_string, s_single, s_eol, }, // 0xae + { s_single, s_term, s_string, s_single, s_eol, }, // 0xaf + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xb9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xba + { s_single, s_term, s_string, s_single, s_eol, }, // 0xbb + { s_single, s_term, s_string, s_single, s_eol, }, // 0xbc + { s_single, s_term, s_string, s_single, s_eol, }, // 0xbd + { s_single, s_term, s_string, s_single, s_eol, }, // 0xbe + { s_single, s_term, s_string, s_single, s_eol, }, // 0xbf + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xc9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xca + { s_single, s_term, s_string, s_single, s_eol, }, // 0xcb + { s_single, s_term, s_string, s_single, s_eol, }, // 0xcc + { s_single, s_term, s_string, s_single, s_eol, }, // 0xcd + { s_single, s_term, s_string, s_single, s_eol, }, // 0xce + { s_single, s_term, s_string, s_single, s_eol, }, // 0xcf + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xd9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xda + { s_single, s_term, s_string, s_single, s_eol, }, // 0xdb + { s_single, s_term, s_string, s_single, s_eol, }, // 0xdc + { s_single, s_term, s_string, s_single, s_eol, }, // 0xdd + { s_single, s_term, s_string, s_single, s_eol, }, // 0xde + { s_single, s_term, s_string, s_single, s_eol, }, // 0xdf + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xe9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xea + { s_single, s_term, s_string, s_single, s_eol, }, // 0xeb + { s_single, s_term, s_string, s_single, s_eol, }, // 0xec + { s_single, s_term, s_string, s_single, s_eol, }, // 0xed + { s_single, s_term, s_string, s_single, s_eol, }, // 0xee + { s_single, s_term, s_string, s_single, s_eol, }, // 0xef + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf0 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf1 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf2 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf3 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf4 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf5 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf6 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf7 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf8 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xf9 + { s_single, s_term, s_string, s_single, s_eol, }, // 0xfa + { s_single, s_term, s_string, s_single, s_eol, }, // 0xfb + { s_single, s_term, s_string, s_single, s_eol, }, // 0xfc + { s_single, s_term, s_string, s_single, s_eol, }, // 0xfd + { s_single, s_term, s_string, s_single, s_eol, }, // 0xfe + { s_single, s_term, s_string, s_single, s_eol, }, // 0xff +}; + + +TOKEN::TOKEN(char *fn, string_set *includes) { + pushed = false; + include_files = includes; + include(fn); +} + + +TOKEN::~TOKEN() { + while (!streams.empty()) pop(); +} + + +void TOKEN::pop() { + ifstream *is = streams.front(); + char *fn = filenames.front(); + streams.pop_front(); + filenames.pop_front(); + filenamess.erase(fn); + linenumbers.pop_front(); + is->close(); + delete is; +} + + +void TOKEN::push_char(u_char c) { + pushed = true; + pushed_char = c; +} + + +bool TOKEN::next_char(u_char &uc) { + if (pushed) { + uc = (u_char)tolower((char)pushed_char); + pushed = false; + return true; + } + while (!streams.empty() && streams.front()->eof()) { + pop(); + } + if (streams.empty()) return false; + ifstream *is = streams.front(); + uc = (u_char)is->get(); + if (is->eof()) return next_char(uc); + if (uc == (u_char)'\n') { + int &line = linenumbers.front(); + line++; + } + uc = (u_char)tolower((char)uc); + return true; +} + + +bool TOKEN::include(char *fn) { + string_set::iterator i = filenamess.find(fn); + if (i != filenamess.end()) { + token_error("redundant or recursive include file detected"); + return false; + } + ifstream *is = new ifstream; + is->open(fn); + if (is->fail()) { + char buf[maxlen]; + snprintf(buf, sizeof(buf), "include file %s not found", fn); + token_error(buf); + return false; + } + string_set &inc = *include_files; + inc.insert(fn); + streams.push_front(is); + filenames.push_front(fn); + filenamess.insert(fn); + linenumbers.push_front(1); + return true; +} + + +char *TOKEN::next() { + if (!pending_tokens.empty()) { + char *t = pending_tokens.front(); + pending_tokens.pop_front(); + return t; + } + if (streams.empty()) return NULL; + const int PENDING_LIMIT = 1000; + static u_char buffer[PENDING_LIMIT]; + int count = 0; + state st = s_init; + while (true) { + if (count == (PENDING_LIMIT-1)) { + token_error("token too long"); + break; + } + if (st >= end_state) { + token_error("finite state machine error"); + break; + } + u_char c; + if (!next_char(c)) break; + st = parse_table[c][st]; + switch (st) { + case s_string: + case s_token: { + buffer[count++] = c; + } break; + + case s_term: { + push_char(c); + st = s_init; + } break; + + case s_string1: { + st = s_string; + } break; + + case s_string2: { + st = s_init; + } break; + + case s_single: { + buffer[count++] = c; + st = s_init; + } break; + + case s_ignore: + case s_eol: { + } break; + + + case s_slash: { + buffer[count++] = c; + if (next_char(c)) { + if (c == (u_char)'/') { + // start of ignore to eol on // + count--; + st = s_eol; + } + else { + // not a // token, just return this single / + push_char(c); + st = s_init; + } + } + else { + // cannot get another char + st = s_init; + } + } break; + + default: { + token_error(); + token_error("unknown state %d %s \n", st, " "); + } break; + } + if (st == s_init) break; + } + + buffer[count] = '\0'; + if (count == 0) return NULL; + char *t = register_string((char*)buffer); + if (t == token_include) { + char *f = next(); // should be file name + char *s = next(); // should be semicolon + if (s == token_semi) { + include(f); + return next(); + } + else { + push(s); + push(f); + return t; + } + } + return t; +} + + +int TOKEN::nextint() { + char *t = next(); + char *e; + long i = strtol(t, &e, 10); + if (*e != '\0') { + token_error("integer", t); + return 0; + } + return (int)i; +} + + +void TOKEN::skipeol() { + while (true) { + u_char c; + if (!next_char(c)) break; + if (c == (u_char)'\n') break; + } +} + + +void TOKEN::token_error(const char *err) { + token_error(); + char buf[maxlen]; + snprintf(buf, sizeof(buf), "%s \n", err); + my_syslog(buf); +} + + +void TOKEN::token_error(const char *fmt, int d, const char *s) { + char buf[maxlen]; + snprintf(buf, sizeof(buf), fmt, d, s); + my_syslog(buf); +} + + +void TOKEN::token_error(const char *fmt, const char *t, const char *h) { + if (!h) h = "null"; + char buf[maxlen]; + snprintf(buf, sizeof(buf), fmt, t, h); + my_syslog(buf); +} + + +void TOKEN::token_error(const char *want, const char *have) { + token_error(); + token_error("expecting %s, found %s \n", want, have); +} + + +void TOKEN::token_error() { + token_error("syntax error at line %d in file %s -- ", cur_line(), cur_fn()); + line_list::iterator j = linenumbers.begin(); + string_list::iterator i = filenames.begin(); + for (; i!=filenames.end(); i++,j++) { + if (i != filenames.begin()) { + char *fn = (*i); + int li = (*j); + token_error("\n included from line %d in file %s -- ", li, fn); + } + } +} + diff -r 000000000000 -r 616666e2f34c src/tokenizer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/tokenizer.h Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,55 @@ +#ifndef tokenizer_include +#define tokenizer_include + +#include +#include +#include +#include +#include + + +using namespace std; + +struct ltstr { + bool operator()(char* s1, char* s2) const { + return strcmp(s1, s2) < 0; + } +}; + +typedef list stream_list; +typedef list string_list; +typedef set string_set; +typedef list line_list; + +class TOKEN { + stream_list streams; + string_list filenames; + string_set filenamess; + line_list linenumbers; + string_list pending_tokens; + string_set *include_files; + bool pushed; + u_char pushed_char; + + void pop(); + bool next_char(u_char &c); + void push_char(u_char c); + +public: + TOKEN(char *fn, string_set *includes); + ~TOKEN(); + bool include(char *fn); + char *next(); // return next token + int nextint(); + void skipeol(); // skip to eol + void push(char *token) {pending_tokens.push_front(token);}; + char *cur_fn() {return filenames.front();}; + int cur_line() {return linenumbers.front();}; + void token_error(const char *err); + void token_error(const char *fmt, int d, const char *s); + void token_error(const char *fmt, const char *t, const char *h); + void token_error(const char *want, const char *have); + void token_error(); +}; + +#endif diff -r 000000000000 -r 616666e2f34c xml/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xml/Makefile.am Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,10 @@ +all: dnsbl + cat header.xml dnsbl >dnsbl.xml + cat header.sgml dnsbl >dnsbl.sgml + rm -f ../html/*html + rm -f ../html/*pdf + xmlto -o ../man man dnsbl.xml + xmlto -o ../html xhtml dnsbl.xml + xmlto -o ../html pdf dnsbl.xml + docbook2texi -o ../info dnsbl.sgml + rm -f dnsbl.xml dnsbl.sgml diff -r 000000000000 -r 616666e2f34c xml/header.sgml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xml/header.sgml Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,1 @@ + diff -r 000000000000 -r 616666e2f34c xml/header.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xml/header.xml Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,4 @@ + + + diff -r 000000000000 -r 616666e2f34c xml/sm-archive.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xml/sm-archive.in Fri Mar 10 10:30:08 2006 -0800 @@ -0,0 +1,235 @@ + + @PACKAGE@ Sendmail milter - Version @VERSION@ + + Packages + The various source and binary packages are available at http://www.five-ten-sg.com/@PACKAGE@/packages/ + The most recent documentation is available at http://www.five-ten-sg.com/@PACKAGE@/ + + + + + + + 2006-03-10 + + + + @PACKAGE@ + 1 + @PACKAGE@ @VERSION@ + + + + @PACKAGE@ + a sendmail milter to add recipients to messages + + + + Synopsis + + @PACKAGE@ + + + + + + + + + Options + + + -c + + Load the configuration file, print a cannonical form + of the configuration on stdout, and exit. + + + + -d n + + Set the debug level to n. + + + + -p sendmail-socket + + Set the socket used for the milter connection to sendmail. This is either + "inet:port@ip-address" or "local:local-domain-socket-file-name". + + + + -t timeout + + Set the timeout in seconds used for communication with sendmail. + + + + + + + Usage + @PACKAGE@ -c + @PACKAGE@ -d 10 -p local:dnsbl.sock + + + + Installation + + This is now a standard GNU autoconf/automake installation, so the normal + "./configure; make; su; make install" works. "make chkconfig" will + setup the init.d runlevel scripts. Alternatively, you can use the + source or binary RPMs at http://www.five-ten-sg.com/@PACKAGE@/packages. + + + Note that this has ONLY been tested on Linux, specifically RedHat Linux. + You will need at a minimum a C++ compiler with a + minimally thread safe STL implementation. The distribution includes a + test.cpp program. If it fails this milter won't work. If it passes, + this milter might work. + + + Modify your sendmail.mc by adding + the following line in your sendmail.mc and rebuild the .cf file + + INPUT_MAIL_FILTER(`sm-archive', `S=local:/var/run/sm-archive/sm-archive.sock, F=T, T=C:30s;S:5m;R:5m;E:5m') + + Modify the default + @PACKAGE@.conf 5 + configuration. + + + + + Configuration + + The configuration file is documented in + @PACKAGE@.conf 5 + . Any change to the config file, or any file included + from that config file, will cause it to be reloaded within three + minutes. + + + + + Introduction + + Consider the problem of archiving all the mail sent to or from particular + email addresses or domains. This milter allows you to configure archive + mailboxes for each address or domain. It will add the address of the archive + mailbox to messages that pass thru this milter. + + + The DNSBL milter reads a text configuration file (sm-archive.conf) on + startup, and whenever the config file (or any of the referenced include + files) is changed. The entire configuration file is case insensitive. + If the configuration cannot be loaded due to a syntax error, the milter + will log the error and quit. If the configuration cannot be reloaded + after being modified, the milter will log the error and send an email to + root from sm-archive@$hostname. You probably want to added sm-archive@$hostname + to your /etc/mail/virtusertable since otherwise sendmail will reject + that message. + + + + + TODO + + Placeholder for future ideas. + + + + + Copyright + + Copyright (C) 2006 by 510 Software Group <carl@five-ten-sg.com> + + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + + You should have received a copy of the GNU General Public License along + with this program; see the file COPYING. If not, please write to the + Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + + + + + CVS Version + + $Id$ + + + + + + + + 2006-03-10 + + + + @PACKAGE@.conf + 5 + @PACKAGE@ @VERSION@ + + + + @PACKAGE@.conf + configuration file for @PACKAGE@ sendmail milter + + + + Synopsis + + @PACKAGE@.conf + + + + + Description + The @PACKAGE@.conf configuration file is + specified by this partial bnf description. + + + + + + Sample + + + + + CVS Version + + $Id$ + + + + +