dnsbl: src/context.cpp comparison

comparison src/context.cpp @ 214:82886d4dd71f stable-6-0-19

Fixes to compile on Fedora 9 and for const correctness.

author	Carl Byington <carl@five-ten-sg.com>
date	Tue, 10 Jun 2008 08:58:42 -0700
parents	4db1457cd11a
children	5c3e9bf45bb5

comparison

equal deleted inserted replaced

-:44ffef730bc4
+:82886d4dd71f
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 #include <unistd.h>
+#include <climits>
-char *token_autowhite;
-char *token_black;
+const char *token_autowhite;
-char *token_cctld;
+const char *token_black;
-char *token_content;
+const char *token_cctld;
-char *token_context;
+const char *token_content;
-char *token_dccbulk;
+const char *token_context;
-char *token_dccfrom;
+const char *token_dccbulk;
-char *token_dccgrey;
+const char *token_dccfrom;
-char *token_dccto;
+const char *token_dccgrey;
-char *token_default;
+const char *token_dccto;
-char *token_dnsbl;
+const char *token_default;
-char *token_dnsbll;
+const char *token_dnsbl;
-char *token_envfrom;
+const char *token_dnsbll;
-char *token_envto;
+const char *token_envfrom;
-char *token_filter;
+const char *token_envto;
-char *token_generic;
+const char *token_filter;
-char *token_host_limit;
+const char *token_generic;
-char *token_html_limit;
+const char *token_host_limit;
-char *token_html_tags;
+const char *token_html_limit;
-char *token_ignore;
+const char *token_html_tags;
-char *token_include;
+const char *token_ignore;
-char *token_inherit;
+const char *token_include;
-char *token_lbrace;
+const char *token_inherit;
-char *token_mailhost;
+const char *token_lbrace;
-char *token_many;
+const char *token_mailhost;
-char *token_no;
+const char *token_many;
-char *token_off;
+const char *token_no;
-char *token_ok;
+const char *token_off;
-char *token_ok2;
+const char *token_ok;
-char *token_on;
+const char *token_ok2;
-char *token_rate;
+const char *token_on;
-char *token_rbrace;
+const char *token_rate;
-char *token_require;
+const char *token_rbrace;
-char *token_semi;
+const char *token_require;
-char *token_soft;
+const char *token_semi;
-char *token_spamassassin;
+const char *token_soft;
-char *token_substitute;
+const char *token_spamassassin;
-char *token_tld;
+const char *token_substitute;
-char *token_unknown;
+const char *token_tld;
-char *token_uribl;
+const char *token_unknown;
-char *token_verify;
+const char *token_uribl;
-char *token_white;
+const char *token_verify;
-char *token_yes;
+const char *token_white;
+const char *token_yes;
-char *token_myhostname;
+const char *token_myhostname;
 #ifndef HOST_NAME_MAX
 #define HOST_NAME_MAX 255
 #endif
 char myhostname[HOST_NAME_MAX+1];
 }
 return 0;
 }
-int SMTP::cmd(char *c) {
+int SMTP::cmd(const char *c) {
 if (c) {
 init();
 append(c);
 }
 append("\r\n");
 efrom[0] = '\0';
 return rc;
 }
-int SMTP::from(char *f) {
+int SMTP::from(const char *f) {
 // the mail from address was originally passed in from sendmail enclosed in
 // <>. to_lower_string() removed the <> and converted the rest to lowercase,
 // except in the case of an empty return path, which was left as the two
 // character string <>.
 if (strncmp(efrom, f, maxlen)) {
 }
 return 250; // pretend it worked
 }
-int SMTP::rcpt(char *t) {
+int SMTP::rcpt(const char *t) {
 init();
 append("RCPT TO:<");
 append(t);
 append(">");
 return cmd(NULL);
 close(fd);
 }
 #ifdef VERIFY_DEBUG
-void SMTP::log(char *m, int v) {
+void SMTP::log(const char *m, int v) {
 char buf[maxlen];
 snprintf(buf, maxlen, m, v);
 my_syslog(buf);
 }
-void SMTP::log(char *m, char *v) {
+void SMTP::log(const char *m, const char *v) {
 char buf[maxlen];
 snprintf(buf, maxlen, m, v);
 my_syslog(buf);
 }
 #endif
 ////////////////////////////////////////////////
 // smtp verifier so backup mx machines can see the valid users
 //
-VERIFY::VERIFY(char *h) {
+VERIFY::VERIFY(const char *h) {
 host     = h;
 last_err = 0;
 pthread_mutex_init(&mutex, 0);
 }
 pthread_mutex_unlock(&mutex);
 }
 }
-bool VERIFY::ok(char *from, char *to) {
+bool VERIFY::ok(const char *from, const char *to) {
 if (host == token_myhostname) return true;
 SMTP *conn = get_connection();
 if (!conn) return true;    // cannot verify right now, we have socket errors
 int rc;
 rc = conn->from(from);
 ////////////////////////////////////////////////
 // setup a new smtp verify host
 //
-VERIFYP add_verify_host(char *host);
+VERIFYP add_verify_host(const char *host);
-VERIFYP add_verify_host(char *host) {
+VERIFYP add_verify_host(const char *host) {
 VERIFYP rc = NULL;
 pthread_mutex_lock(&verifier_mutex);
 verify_map::iterator i = verifiers.find(host);
 if (i == verifiers.end()) {
 rc = new VERIFY(host);
 ////////////////////////////////////////////////
 // automatic whitelister
 //
-WHITELISTER::WHITELISTER(char *f, int d) {
+WHITELISTER::WHITELISTER(const char *f, int d) {
 fn       = f;
 days     = d;
 pthread_mutex_init(&mutex, 0);
 need     = false;
 loaded   = time(NULL);
 // purge old entries
 for (autowhite_sent::iterator i=rcpts.begin(); i!=rcpts.end();) {
 time_t when = (*i).second;
 if (when < limit) {
-char *who = (*i).first;
+const char *who = (*i).first;
-free(who);
+free((void*)who);
 rcpts.erase(i++);
 need = true;
 }
 else i++;
 }
 // dump the file
 ofstream ofs;
 ofs.open(fn);
 if (!ofs.fail()) {
 for (autowhite_sent::iterator i=rcpts.begin(); i!=rcpts.end(); i++) {
-char *who = (*i).first;
+const char *who = (*i).first;
 int  when = (*i).second;
 if (!strchr(who, ' ')) {
 ofs << who << " " << when << endl;
 }
 }
 }
 pthread_mutex_unlock(&mutex);
 }
-void WHITELISTER::sent(char *to) {
+void WHITELISTER::sent(const char *to) {
 // we take ownership of the string
 pthread_mutex_lock(&mutex);
 need = true;
 autowhite_sent::iterator i = rcpts.find(to);
 if (i == rcpts.end()) {
 rcpts[to] = time(NULL);
 }
 else {
 (*i).second = time(NULL);
-free(to);
+free((void*)to);
 }
 pthread_mutex_unlock(&mutex);
 }
-bool WHITELISTER::is_white(char *from) {
+bool WHITELISTER::is_white(const char *from) {
 pthread_mutex_lock(&mutex);
 autowhite_sent::iterator i = rcpts.find(from);
 bool rc = (i != rcpts.end());
 pthread_mutex_unlock(&mutex);
 return rc;
 ////////////////////////////////////////////////
 // setup a new auto whitelister file
 //
-WHITELISTERP add_whitelister_file(char *fn, int days);
+WHITELISTERP add_whitelister_file(const char *fn, int days);
-WHITELISTERP add_whitelister_file(char *fn, int days) {
+WHITELISTERP add_whitelister_file(const char *fn, int days) {
 WHITELISTERP rc = NULL;
 pthread_mutex_lock(&whitelister_mutex);
 whitelister_map::iterator i = whitelisters.find(fn);
 if (i == whitelisters.end()) {
 rc = new WHITELISTER(fn, days);
 }
 return NULL;
 }
-DELAYWHITE::DELAYWHITE(char *loto_, WHITELISTERP w_, CONTEXTP con_) {
+DELAYWHITE::DELAYWHITE(const char *loto_, WHITELISTERP w_, CONTEXTP con_) {
 loto = loto_;
 w    = w_;
 con  = con_;
 }
-DNSBL::DNSBL(char *n, char *s, char *m) {
+DNSBL::DNSBL(const char *n, const char *s, const char *m) {
 name    = n;
 suffix  = s;
 message = m;
 }
 default_context = con;
 }
 }
-void CONFIG::add_to(char *to, CONTEXTP con) {
+void CONFIG::add_to(const char *to, CONTEXTP con) {
 context_map::iterator i = env_to.find(to);
 if (i != env_to.end()) {
 CONTEXTP  c = (*i).second;
 if ((c != con) && (c != con->get_parent())) {
 if (debug_syslog) {
 char oldname[maxlen];
 char newname[maxlen];
-char *oldn = c->get_full_name(oldname, maxlen);
+const char *oldn = c->get_full_name(oldname, maxlen);
-char *newn = con->get_full_name(newname, maxlen);
+const char *newn = con->get_full_name(newname, maxlen);
 char buf[maxlen*3];
 snprintf(buf, maxlen*3, "both %s and %s claim envelope to %s, the second one wins", oldn, newn, to);
 my_syslog(buf);
 }
 }
 }
 env_to[to] = con;
 }
-CONTEXTP CONFIG::find_context(char *to) {
+CONTEXTP CONFIG::find_context(const char *to) {
 context_map::iterator i = env_to.find(to);
 if (i != env_to.end()) return (*i).second;      // found user@domain key
-char *x = strchr(to, '@');
+const char *x = strchr(to, '@');
 if (x) {
 x++;
 i = env_to.find(x);
 if (i != env_to.end()) return (*i).second;  // found domain key
-char y = *x;
+size_t len = x - to;
-*x = '\0';
+char user[len+1];
-i = env_to.find(to);
+memcpy(user, to, len);
-*x = y;
+user[len] = '\0';
+i = env_to.find(user);
 if (i != env_to.end()) return (*i).second;  // found user@ key
 }
 return default_context;
 }
 CONTEXTP p = c->get_parent();
 if (!p && (c != default_context)) c->dump(false, spamass);
 }
 char buf[maxlen];
 for (context_map::iterator i=env_to.begin(); i!=env_to.end(); i++) {
-char     *to = (*i).first;
+const char *to = (*i).first;
-CONTEXTP con = (*i).second;
+CONTEXTP   con = (*i).second;
 printf("// envelope to %s \t-> context %s \n", to, con->get_full_name(buf,maxlen));
 }
 if (spamass && (spamc == spamc_empty)) {
 printf("// *** warning - spamassassin filtering requested, but spamc not found by autoconf.\n");
 }
 }
-CONTEXT::CONTEXT(CONTEXTP parent_, char *name_) {
+CONTEXT::CONTEXT(CONTEXTP parent_, const char *name_) {
 parent              = parent_;
 name                = name_;
 verify_host         = NULL;
 verifier            = NULL;
 generic_regx        = NULL;
 if (!parent) return false;
 return parent->is_parent(p);
 }
-char *CONTEXT::get_full_name(char *buffer, int size) {
+const char *CONTEXT::get_full_name(char *buffer, int size) {
 if (!parent) return name;
 char buf[maxlen];
 snprintf(buffer, size, "%s.%s", parent->get_full_name(buf, maxlen), name);
 return buffer;
 }
-bool CONTEXT::set_generic(char *regx, char *msg)
+bool CONTEXT::set_generic(const char *regx, const char *msg)
 {
 int rc = 0;
 if (generic_regx) regfree(&generic_pattern);
 generic_regx    = regx;
 generic_message = msg;
 }
 return rc;  // true iff bad pattern
 }
-char *CONTEXT::generic_match(char *client)
+const char *CONTEXT::generic_match(const char *client)
 {
 if (!client) return NULL;   // allow missing _ macro, which will disable generic checking
 if (parent && !generic_regx) return parent->generic_match(client);
 if (!generic_regx)           return NULL;
 if (0 == regexec(&generic_pattern, client, 0, NULL, 0)) {
 }
 return NULL;
 }
-bool CONTEXT::cover_env_to(char *to) {
+bool CONTEXT::cover_env_to(const char *to) {
-char buffer[maxlen];
+const char *x = strchr(to, '@');
-char *x = strchr(to, '@');
 if (x) x++;
 else   x = to;
 if (*x == '\0') return true;                // always allow covering addresses with no domain name, eg abuse@
 if (!parent && env_to.empty()) return true; // empty env_to at global level covers everything
 string_set::iterator i = env_to.find(x);
 }
 return false;
 }
-VERIFYP CONTEXT::find_verify(char *to) {
+VERIFYP CONTEXT::find_verify(const char *to) {
 if (verifier && (verify_host != token_myhostname) && cover_env_to(to))
 return verifier;
 else if (parent)
 return parent->find_verify(to);
 else
 return NULL;
 }
-WHITELISTERP CONTEXT::find_autowhite(char *from, char *to) {
+WHITELISTERP CONTEXT::find_autowhite(const char *from, const char *to) {
 if (whitelister && cover_env_to(to) && !cover_env_to(from))
 return whitelister;
 else if (parent)
 return parent->find_autowhite(from, to);
 else
 return NULL;
 }
-int CONTEXT::find_rate(char *user) {
+int CONTEXT::find_rate(const char *user) {
 if (rcpt_per_hour.empty()) return default_rcpt_rate;
 rcpt_rates::iterator i = rcpt_per_hour.find(user);
 return (i == rcpt_per_hour.end()) ? default_rcpt_rate : (*i).second;
 }
-char *CONTEXT::find_from(char *from, bool update_white) {
+const char *CONTEXT::find_from(const char *from, bool update_white) {
 WHITELISTERP w = whitelister;
 CONTEXTP     p = parent;
 while (!w && p) {
 w = p->whitelister;
 p = p->parent;
 }
 w->sent(strdup(from));
 }
 return token_white;
 }
-char *rc = env_from_default;
+const char *rc = env_from_default;
 string_map::iterator i = env_from.find(from);
 if (i != env_from.end()) rc = (*i).second;  // found user@domain key
 else {
 char *x = strchr(from, '@');
 if (x) {
 if ((rc == token_inherit) && parent) return parent->find_from(from);
 return (rc == token_inherit) ? token_unknown : rc;
 }
-CONTEXTP CONTEXT::find_context(char *from) {
+CONTEXTP CONTEXT::find_context(const char *from) {
 context_map::iterator i = env_from_context.find(from);
 if (i != env_from_context.end()) return (*i).second;        // found user@domain key
 char *x = strchr(from, '@');
 if (x) {
 x++;
 }
 return this;
 }
-CONTEXTP CONTEXT::find_from_context_name(char *name) {
+CONTEXTP CONTEXT::find_from_context_name(const char *name) {
 context_map::iterator i = children.find(name);
 if (i != children.end()) return (*i).second;
 return NULL;
 }
-DNSBLP CONTEXT::find_dnsbl(char *name) {
+DNSBLP CONTEXT::find_dnsbl(const char *name) {
 dnsblp_map::iterator i = dnsbl_names.find(name);
 if (i != dnsbl_names.end()) return (*i).second;
 if (parent) return parent->find_dnsbl(name);
 return NULL;
 }
-char* CONTEXT::get_content_suffix() {
+const char* CONTEXT::get_content_suffix() {
 if (!content_suffix && parent) return parent->get_content_suffix();
 return content_suffix;
 }
-char* CONTEXT::get_uribl_suffix() {
+const char* CONTEXT::get_uribl_suffix() {
 if (!uribl_suffix && parent) return parent->get_uribl_suffix();
 return uribl_suffix;
 }
-char* CONTEXT::get_content_message() {
+const char* CONTEXT::get_content_message() {
 if (!content_message && parent) return parent->get_content_message();
 return content_message;
 }
-char* CONTEXT::get_uribl_message() {
+const char* CONTEXT::get_uribl_message() {
 if (!uribl_message && parent) return parent->get_uribl_message();
 return uribl_message;
 }
 char indent[maxlen];
 int i = min(maxlen-1, level*4);
 memset(indent, ' ', i);
 indent[i] = '\0';
 char buf[maxlen];
-char *fullname = get_full_name(buf,maxlen);
+const char *fullname = get_full_name(buf,maxlen);
 printf("%s context %s { \t// %s\n", indent, name, fullname);
 for (dnsblp_map::iterator i=dnsbl_names.begin(); i!=dnsbl_names.end(); i++) {
-char *n = (*i).first;
+const char *n = (*i).first;
 DNSBL &d = *(*i).second;
 printf("%s     dnsbl %s %s \"%s\"; \n", indent, n, d.suffix, d.message);
 }
 dnsblp_list dl = get_dnsbl_list();
 }
 printf("; \n");
 }
 if (content_filtering) {
-printf("%s     content on { \n", indent, env_from_default);
+printf("%s     content on { \n", indent);
 if (content_suffix) {
 printf("%s         filter %s \"%s\"; \n", indent, content_suffix, content_message);
 }
 if (uribl_suffix) {
 printf("%s         uribl %s \"%s\"; \n", indent, uribl_suffix, uribl_message);
 else                                    printf("%s         dcc_bulk_threshold %d; \n", indent, dcc_bulk_threshold);
 printf("%s     }; \n", indent);
 spamass |= (spamassassin_limit != 0);
 }
 else {
-printf("%s     content off {}; \n", indent, env_from_default);
+printf("%s     content off {}; \n", indent);
 }
 printf("%s     env_to { \t// %s\n", indent, fullname);
 for (string_set::iterator i=env_to.begin(); i!=env_to.end(); i++) {
 printf("%s         %s; \n", indent, *i);
 printf("%s     env_from %s { \t// %s\n", indent, env_from_default, fullname);
 if (!env_from.empty()) {
 printf("%s     // white/black/unknown \n", indent);
 for (string_map::iterator i=env_from.begin(); i!=env_from.end(); i++) {
-char *f = (*i).first;
+const char *f = (*i).first;
-char *t = (*i).second;
+const char *t = (*i).second;
 printf("%s         %s \t%s; \n", indent, f, t);
 }
 }
 if (!env_from_context.empty()) {
 printf("%s     // child contexts \n", indent);
 for (context_map::iterator j=env_from_context.begin(); j!=env_from_context.end(); j++) {
-char    *f = (*j).first;
+const char    *f = (*j).first;
 CONTEXTP t = (*j).second;
 printf("%s         %s \t%s; \n", indent, f, t->name);
 }
 }
 printf("%s     }; \n", indent);
 if (isdefault) {
 printf("%s     rate_limit %d { \n", indent, default_rcpt_rate);
 for (rcpt_rates::iterator j=rcpt_per_hour.begin(); j!=rcpt_per_hour.end(); j++) {
-char    *u = (*j).first;
+const char *u = (*j).first;
-int      l = (*j).second;
+int         l = (*j).second;
 printf("%s         \"%s\" \t%d; \n", indent, u, l);
 }
 printf("%s     }; \n", indent);
 }
 ////////////////////////////////////////////////
 // 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);
+free((void*)*i);
 }
 s.clear();
 }
 ////////////////////////////////////////////////
 // helper to register a string in a string set
 //
-char* register_string(string_set &s, char *name) {
+const char* register_string(string_set &s, const 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) {
+const char* register_string(const char *name) {
 return register_string(all_strings, name);
 }
 ////////////////////////////////////////////////
 }
 ////////////////////////////////////////////////
 //
-bool tsa(TOKEN &tok, char *token);
+bool tsa(TOKEN &tok, const char *token);
-bool tsa(TOKEN &tok, char *token) {
+bool tsa(TOKEN &tok, const char *token) {
-char *have = tok.next();
+const char *have = tok.next();
 if (have == token) return true;
 tok.token_error(token, have);
 return false;
 }
 ////////////////////////////////////////////////
 //
 bool parse_dnsbl(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_dnsbl(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *name = tok.next();
+const char *name = tok.next();
-char *suf = tok.next();
+const char *suf  = tok.next();
-char *msg = tok.next();
+const char *msg  = tok.next();
 if (!tsa(tok, token_semi)) return false;
 DNSBLP dnsnew = new DNSBL(name, suf, msg);
 DNSBLP dnsold = me.find_dnsbl(name);
 if (dnsold && (*dnsold == *dnsnew)) {
 // duplicate redefinition, ignore it
 ////////////////////////////////////////////////
 //
 bool parse_dnsbll(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_dnsbll(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_semi) break;
 DNSBLP dns = me.find_dnsbl(have);
 if (dns) {
 me.add_dnsbl(dns);
 ////////////////////////////////////////////////
 //
 bool parse_content(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_content(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *setting = tok.next();
+const char *setting = tok.next();
 if (setting == token_on) {
 me.set_content_filtering(true);
 }
 else if (setting == token_off) {
 me.set_content_filtering(false);
 tok.token_error("on/off", setting);
 return false;
 }
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_filter) {
-char *suffix = tok.next();
+const char *suffix = tok.next();
-char *messag = tok.next();
+const char *messag = tok.next();
 me.set_content_suffix(suffix);
 me.set_content_message(messag);
 if (!tsa(tok, token_semi)) return false;
 }
 else if (have == token_uribl) {
-char *suffix = tok.next();
+const char *suffix = tok.next();
-char *messag = tok.next();
+const char *messag = tok.next();
 me.set_uribl_suffix(suffix);
 me.set_uribl_message(messag);
 if (!tsa(tok, token_semi)) return false;
 }
 else if (have == token_ignore) {
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
 if (!have) break;
-char *have = tok.next();
+const char *have = tok.next();
 if (have == token_rbrace) break;  // done
 me.add_ignore(have);
 }
 if (!tsa(tok, token_semi)) return false;
 }
 else if (have == token_tld) {
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;  // done
 me.add_tld(have);
 }
 if (!tsa(tok, token_semi)) return false;
 }
 else if (have == token_cctld) {
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;  // done
 me.add_cctld(have);
 }
 if (!tsa(tok, token_semi)) return false;
 }
 else if (have == token_html_tags) {
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) {
 break;  // done
 }
 else {
 //
 bool parse_envto(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_envto(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;
 if (have == token_semi) {
 // optional separators
 }
 else if (have == token_dccto) {
-char *flavor = tok.next();
+const char *flavor = tok.next();
 if (!tsa(tok, token_lbrace)) return false;
 bool keeping = false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;
 if (have == flavor) {
 keeping = true;
 continue;
 ////////////////////////////////////////////////
 //
 bool parse_verify(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_verify(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *host = tok.next();
+const char *host = tok.next();
 if (!tsa(tok, token_semi)) return false;
 me.set_verify(host);
 me.set_verifier(add_verify_host(host));
 return true;
 }
 ////////////////////////////////////////////////
 //
 bool parse_generic(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_generic(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *regx = tok.next();
+const char *regx = tok.next();
-char *msg  = tok.next();
+const char *msg  = tok.next();
 if (!tsa(tok, token_semi)) return false;
 if (me.set_generic(regx, msg)) {
 tok.token_error("invalid regular expression %s", regx, regx);
 return false;
 }
 ////////////////////////////////////////////////
 //
 bool parse_autowhite(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_autowhite(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
 int days = tok.nextint();
-char *fn = tok.next();
+const char *fn = tok.next();
 if (!tsa(tok, token_semi)) return false;
 me.set_autowhite(fn);
 me.set_whitelister(add_whitelister_file(fn, days));
 return true;
 }
 ////////////////////////////////////////////////
 //
 bool parse_envfrom(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_envfrom(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *st = tok.next();
+const char *st = tok.next();
 if ((st == token_black) || (st == token_white) || (st == token_unknown) || (st == token_inherit)) {
 me.set_from_default(st);
 }
 else {
 tok.push(st);
 }
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;
 if (have == token_semi) {
 // optional separators
 }
 else if (have == token_dccfrom) {
 if (!tsa(tok, token_lbrace)) return false;
 bool keeping = false;
 bool many = false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;
 if (have == token_ok) {
 keeping = true;
 many    = false;
 tok.skipeol();
 }
 }
 else {
 // may be a valid email address or domain name
-char *st = tok.next();
+const char *st = tok.next();
 if ((st == token_white) || (st == token_black) || (st == token_unknown) || (st == token_inherit)) {
 me.add_from(have, st);
 }
 else {
 CONTEXTP con = me.find_from_context_name(st);
 ////////////////////////////////////////////////
 //
 bool parse_rate(TOKEN &tok, CONFIG &dc, CONTEXT &me);
 bool parse_rate(TOKEN &tok, CONFIG &dc, CONTEXT &me) {
-char *def = tok.next();
+const char *def = tok.next();
 tok.push(def);
 if (def != token_lbrace) me.set_default_rate(tok.nextint());
 if (!tsa(tok, token_lbrace)) return false;
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;
 if (have == token_semi) {
 // optional separators
 }
 ////////////////////////////////////////////////
 //
 bool parse_context(TOKEN &tok, CONFIG &dc, CONTEXTP parent);
 bool parse_context(TOKEN &tok, CONFIG &dc, CONTEXTP parent) {
-char *name = tok.next();
+const char *name = tok.next();
 if (!tsa(tok, token_lbrace)) return false;
 CONTEXTP con = new CONTEXT(parent, name);
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_rbrace) break;  // done
 if (have == token_dnsbl) {
 if (!parse_dnsbl(tok, dc, *con)) return false;
 }
 ////////////////////////////////////////////////
 // parse a config file
 //
-bool load_conf(CONFIG &dc, char *fn) {
+bool load_conf(CONFIG &dc, const char *fn) {
 int count = 0;
 TOKEN tok(fn, &dc.config_files);
 while (true) {
-char *have = tok.next();
+const char *have = tok.next();
 if (!have) break;
 if (have == token_context) {
 if (!parse_context(tok, dc, NULL)) {
 tok.token_error("load_conf() failed to parse context");
 return false;

Mercurial > dnsbl

comparison src/context.cpp @ 214:82886d4dd71f stable-6-0-19