/* This routine inserts the cookie into table_cookie. We log arrival of
* the message (done=0). */
void sub_sql_tagmsg(struct subdbinfo *info,
unsigned long msgnum, /* number of this message */
const char *hashout, /* previously calculated hash */
unsigned long bodysize,
unsigned long chunk)
{
const char *ret;
char strnum[FMT_ULONG];
if (chunk >= 53L) chunk = 0L; /* sanity */
/* INSERT INTO table_cookie (msgnum,tai,cookie,bodysize,chunk) VALUES (...) */
/* (we may have tried message before, but failed to complete, so */
/* ER_DUP_ENTRY is ok) */
stralloc_copys(&query,"INSERT INTO ");
stralloc_cats(&query,info->base_table);
stralloc_cats(&query,"_cookie (msgnum,tai,cookie,bodysize,chunk) VALUES ");
stralloc_cats(&query,sql_tagmsg_values_defn);
stralloc_copyb(¶ms[0],strnum,fmt_ulong(strnum,msgnum));
stralloc_copyb(¶ms[1],hashout,COOKIE);
stralloc_copyb(¶ms[2],strnum,fmt_ulong(strnum,bodysize));
stralloc_copyb(¶ms[3],strnum,fmt_ulong(strnum,chunk));
sql_exec(info,&query,4,params); /* ignore dups */
if (! (ret = logmsg(msgnum,0L,0L,1)))
return; /* log done=1*/
if (*ret) strerr_die2x(111,FATAL,ret);
}
int httpdate(stralloc *sa,struct tai *t)
{
struct caltime ct;
int i;
caltime_utc(&ct,t,&i,(int *) 0);
if (i < 0) i = 0;
if (i > 6) i = 6;
if (!stralloc_copys(sa,weekday[i])) return 0;
if (!stralloc_catuint0(sa,ct.date.day,2)) return 0;
i = ct.date.month - 1;
if (i < 0) i = 0;
if (i > 11) i = 11;
if (!stralloc_cats(sa,month[i])) return 0;
if (!stralloc_catuint0(sa,ct.date.year,0)) return 0;
if (!stralloc_cats(sa," ")) return 0;
if (!stralloc_catuint0(sa,ct.hour,2)) return 0;
if (!stralloc_cats(sa,":")) return 0;
if (!stralloc_catuint0(sa,ct.minute,2)) return 0;
if (!stralloc_cats(sa,":")) return 0;
if (!stralloc_catuint0(sa,ct.second,2)) return 0;
if (!stralloc_cats(sa," GMT")) return 0;
return 1;
}
/* Outputs all addresses in the table through subwrite. subwrite must be
* a function returning >=0 on success, -1 on error, and taking
* arguments (char* string, unsigned int length). It will be called once
* per address and should take care of newline or whatever needed for
* the output form. */
unsigned long sub_sql_putsubs(struct subdbinfo *info,
const char *table,
unsigned long hash_lo,
unsigned long hash_hi,
int subwrite()) /* write function. */
{
void *result;
unsigned long no = 0L;
char strnum[FMT_ULONG];
stralloc_copyb(¶ms[0],strnum,fmt_ulong(strnum,hash_lo));
stralloc_copyb(¶ms[1],strnum,fmt_ulong(strnum,hash_hi));
make_name(info,table?"_":0,table,0);
/* main query */
stralloc_copys(&query,"SELECT address FROM ");
stralloc_cat(&query,&name);
stralloc_cats(&query," WHERE ");
stralloc_cats(&query,sql_putsubs_where_defn);
result = sql_select(info,&query,2,params);
no = 0;
while (sql_fetch_row(info,result,1,&addr)) {
if (subwrite(addr.s,addr.len) == -1) die_write();
no++; /* count for list-list fxn */
}
sql_free_result(info,result);
return no;
}
static char *set_workdir(char *action)
{
if (case_starts(action,"digest")) { /* digest */
action += 6;
stralloc_cats(&outlocal,"-digest");
workdir = "digest";
flagdig = FLD_DIGEST;
} else if (case_starts(action,ACTION_ALLOW)) { /* allow */
action += str_len(ACTION_ALLOW);
stralloc_append(&outlocal,'-');
stralloc_cats(&outlocal,ACTION_ALLOW);
workdir = "allow";
flagdig = FLD_ALLOW;
} else if (case_starts(action,ACTION_DENY)) { /* deny */
action += str_len(ACTION_DENY);
stralloc_append(&outlocal,'-');
stralloc_cats(&outlocal,ACTION_DENY);
workdir = "deny";
flagdig = FLD_DENY;
}
else {
workdir = ".";
flagdig = 0;
}
if (flagdig) /* zap '-' after db specifier */
if (*(action++) != '-') die_badaddr();
return action;
}
/* Creates an entry for message num and the list listno and code "done".
* Returns NULL on success, and the error string on error. */
const char *sub_sql_logmsg(struct subdbinfo *info,
unsigned long num,
unsigned long listno,
unsigned long subs,
int done)
{
char *s;
char strnum[FMT_ULONG];
stralloc_copys(&query,"INSERT INTO ");
stralloc_cats(&query,info->base_table);
stralloc_cats(&query,"_mlog (msgnum,listno,subs,done) VALUES ");
stralloc_cats(&query,sql_logmsg_values_defn);
stralloc_copyb(¶ms[0],strnum,fmt_ulong(strnum,num));
stralloc_copyb(¶ms[1],strnum,fmt_ulong(strnum,listno));
stralloc_copyb(¶ms[2],strnum,fmt_ulong(strnum,subs));
s = strnum;
if (done < 0) {
done = - done;
*s++ = '-';
}
s[fmt_uint(s,done)] = 0;
stralloc_copys(¶ms[3],s);
sql_exec(info,&query,4,params); /* ignore dups */
return 0;
}
static const char *remove_table(struct subdbinfo *info,
const char *suffix1,
const char *suffix2)
{
sqlite3_stmt *stmt;
int res;
if (table_exists(info,suffix1,suffix2) == 0)
return 0;
if (!stralloc_copys(&line,"DROP TABLE ")) die_nomem();
if (!stralloc_cats(&line,info->base_table)) die_nomem();
if (!stralloc_cats(&line,suffix1)) die_nomem();
if (!stralloc_cats(&line,suffix2)) die_nomem();
if (!stralloc_0(&line)) die_nomem();
if ((stmt = _sqlquery(info, &line)) == NULL)
return sqlite3_errmsg((sqlite3*)info->conn);
res = sqlite3_step(stmt);
sqlite3_finalize(stmt);
if (res != SQLITE_DONE)
return sqlite3_errmsg((sqlite3*)info->conn);
return 0;
}
void logaddr(const char *subdir,const char *event,
const char *addr,const char *comment)
{
char ch;
int fd;
stralloc_copyb(&line,num,fmt_ulong(num,(unsigned long) now()));
stralloc_cats(&line," ");
stralloc_cats(&line,event);
stralloc_cats(&line," ");
while ((ch = *addr++) != 0) {
if ((ch < 33) || (ch > 126)) ch = '?';
stralloc_append(&line,ch);
}
if (comment && *comment) {
stralloc_cats(&line," ");
while ((ch = *comment++) != 0) {
if (ch == '\t')
ch = ' ';
else
if ((ch < 32) || (ch > 126)) ch = '?';
stralloc_append(&line,ch);
}
}
stralloc_cats(&line,"\n");
makepath(&fn,subdir,"/Log",0);
fd = open_append(fn.s);
if (fd == -1) return;
substdio_fdbuf(&ss,write,fd,NULL,0);
substdio_putflush(&ss,line.s,line.len);
close(fd);
return;
}
int dateline(stralloc *dt, unsigned long d)
/* converts yyyymm from unsigned long d to text dt */
{
const char *mo;
switch (d % 100) {
case 1: mo = "January"; break;
case 2: mo = "February"; break;
case 3: mo = "March"; break;
case 4: mo = "April"; break;
case 5: mo = "May"; break;
case 6: mo = "June"; break;
case 7: mo = "July"; break;
case 8: mo = "August"; break;
case 9: mo = "September"; break;
case 10: mo = "October"; break;
case 11: mo = "November"; break;
case 12: mo = "December"; break;
case 0: mo = "????"; break;
default: cgierr("I don't know any month > 12",
"","");
}
if (!stralloc_copys(dt,mo)) return -1;
if (!stralloc_cats(dt," ")) return -1;
if ((d/100)) {
if (!stralloc_catb(dt,strnum,fmt_ulong(strnum,d/100))) return -1;
} else
if (!stralloc_cats(dt,"????")) return 0;
return 1;
}
static void make_name(struct subdbinfo *info,
const char *suffix1,
const char *suffix2,
int terminate)
{
stralloc_copys(&name,info->base_table);
if (suffix1) stralloc_cats(&name,suffix1);
if (suffix2) stralloc_cats(&name,suffix2);
if (terminate) stralloc_0(&name);
}
int write_fifodir(char *dirname, stralloc *sa, void (*oaw_func)(char *, stralloc *))
{
DIR *dir = NULL;
stralloc name = {0};
struct dirent *x = NULL;
static struct stat st;
/* read directory */
dir = opendir(dirname);
if(dir == NULL)
{
strerr_warn3("can't opendir() ", dirname, ": ", &strerr_sys);
return -1;
}
while (x = readdir(dir))
{
if(x == NULL)
{
strerr_warn3("can't readdir() ", dirname, ": ", &strerr_sys);
if(name.a)
stralloc_free(&name);
return -1;
}
/* Ignore everything starting with a . */
if(x->d_name[0] != '.')
{
stralloc_copys(&name, dirname);
stralloc_cats(&name, "/");
stralloc_cats(&name, x->d_name);
stralloc_0(&name);
if(stat(name.s, &st) == -1)
{
strerr_warn2("can't stat ", name.s, &strerr_sys);
}
if(S_ISFIFO(st.st_mode))
{
oaw_func(name.s, sa);
}
else
{
buffer_puts(buffer_2, "ddnsd: warning: ");
buffer_puts(buffer_2, name.s);
buffer_puts(buffer_2, " is no fifo, ignoring\n");
buffer_flush(buffer_2);
}
}
}
closedir(dir);
return 0;
}
int geton(const char *action)
{
const char *fl;
int r;
unsigned int i;
unsigned char ch;
fl = get_from(target.s,action); /* try to match up */
r = subscribe(workdir,target.s,1,fl,(*action == ACTION_RC[0]) ? "+mod" : "+",-1);
if (flagdig == FLD_DENY || flagdig == FLD_ALLOW)
strerr_die2x(0,INFO,MSG1(ERR_EXTRA_SUB,target.s));
switch (r) {
case 1:
qmail_puts(&qq,"List-Unsubscribe: <mailto:"); /*rfc2369 */
qmail_put(&qq,outlocal.s,outlocal.len);
qmail_puts(&qq,"-unsubscribe-");
/* url-encode since verptarget is controlled by sender */
/* note &verptarget ends in '\0', hence len - 1! */
for (i = 0; i < verptarget.len - 1; i++) {
ch = verptarget.s[i];
if (str_chr("\"?;<>&/:%+#",ch) < 10 ||
(ch <= ' ') || (ch & 0x80)) {
urlstr[1] = hex[ch / 16];
urlstr[2] = hex[ch & 0xf];
qmail_put(&qq,urlstr,3);
} else {
qmail_put(&qq,verptarget.s + i, 1);
}
}
qmail_puts(&qq,"@");
qmail_put(&qq,outhost.s,outhost.len); /* safe */
qmail_puts(&qq,">\n");
hdr_subject(MSG(SUB_WELCOME));
hdr_ctboundary();
stralloc_copy(&confirm,&outlocal);
stralloc_cats(&confirm,"-unsubscribe-");
stralloc_cats(&confirm,verptarget.s);
stralloc_append(&confirm,'@');
stralloc_cat(&confirm,&outhost);
stralloc_0(&confirm);
set_cpconfirm(confirm.s,outlocal.len); /* for !R in copy */
copy(&qq,"text/top",flagcd);
copy_act("text/sub-ok");
break;
default:
if (str_start(action,ACTION_TC))
strerr_die2x(0,INFO,MSG(ERR_SUB_NOP));
hdr_subject(MSG(SUB_SUBSCRIBE_NOP));
hdr_ctboundary();
copy(&qq,"text/top",flagcd);
copy_act("text/sub-nop");
break;
}
return r;
}
int pathexec_env(const char *s,const char *t)
{
if (!s) return 1;
if (!stralloc_copys(&tmp,s)) return 0;
if (t) {
if (!stralloc_cats(&tmp,"=")) return 0;
if (!stralloc_cats(&tmp,t)) return 0;
}
if (!stralloc_0(&tmp)) return 0;
return stralloc_cat(&plus,&tmp);
}
static int stralloc_cat_table(stralloc *s,
const struct subdbinfo *info,
const char *table)
{
if (!stralloc_cats(s,info->base_table)) return 0;
if (table) {
if (!stralloc_append(s,"_")) return 0;
if (!stralloc_cats(s,table)) return 0;
}
return 1;
}
int
env_addmodif(stralloc* sa, const char* s, const char* t) {
size_t oldlen = sa->len;
if(!s)
return 1;
if(!stralloc_cats(sa, s))
return 0;
if((t && (!stralloc_catb(sa, "=", 1) || !stralloc_cats(sa, t))) || !stralloc_0(sa)) {
sa->len = oldlen;
return 0;
}
return 1;
}
/*
* generate the search command for a given manual;
* return a stralloc with the command string */
stralloc generateSearchCMD( char *manual , stralloc temp )
{
stralloc_cats( &temp, findCMD ); // append "/usr/bin/find "
//stralloc_cats( &temp, searchDIR_1 ); // append "/usr/local/share/man "
//stralloc_cats( &temp, searchDIR_2 ); // append "/usr/man "
stralloc_cats( &temp, searchDIR_3 ); // append "/usr/share/man "
stralloc_cats( &temp, findOption); // append "-name "
stralloc_cats( &temp, manual ); // append "[uncrustify]"
stralloc_cats( &temp, findAppendix ); // append ".* "
//stralloc_cats( &temp, ignoreError); // append "2>/dev/null"
//stralloc_cats( &temp, topResult ); // append "| head -1"
return temp;
}
static int _issub(struct subdbinfo *info,
const char *table,
const char *userhost,
stralloc *recorded)
{
sqlite3_stmt *stmt;
unsigned int j;
int res;
/* SELECT address FROM list WHERE address = 'userhost' AND hash */
/* BETWEEN 0 AND 52. Without the hash restriction, we'd make it */
/* even easier to defeat. Just faking sender to the list name would*/
/* work. Since sender checks for posts are bogus anyway, I don't */
/* know if it's worth the cost of the "WHERE ...". */
if (!stralloc_copys(&addr,userhost)) die_nomem();
j = byte_rchr(addr.s,addr.len,'@');
if (j == addr.len) return 0;
case_lowerb(addr.s + j + 1,addr.len - j - 1);
if (!stralloc_copys(&line,"SELECT address FROM ")) die_nomem();
if (!stralloc_cat_table(&line,info,table)) die_nomem();
if (!stralloc_cats(&line," WHERE address LIKE '")) die_nomem();
if (!stralloc_cat(&line,&addr)) die_nomem();
if (!stralloc_cats(&line,"'")) die_nomem();
if (!stralloc_0(&line)) die_nomem();
if ((stmt = _sqlquery(info, &line)) == NULL) /* select */
strerr_die2x(111,FATAL,sqlite3_errmsg((sqlite3*)info->conn));
/* No data returned in QUERY */
res = sqlite3_step(stmt);
if (res != SQLITE_ROW)
{
if (res != SQLITE_DONE)
strerr_die2x(111,FATAL,sqlite3_errmsg((sqlite3*)info->conn));
sqlite3_finalize(stmt);
return 0;
}
if (recorded)
{
if (!stralloc_copyb(recorded, (const char*)sqlite3_column_text(stmt, 0), sqlite3_column_bytes(stmt, 0)))
die_nomem();
if (!stralloc_0(recorded)) die_nomem();
}
sqlite3_finalize(stmt);
return 1;
}
static int makeuniquename (stralloc *sa, char const *path, char const *magic)
{
unsigned int base = sa->len ;
int wasnull = !sa->s ;
if (!stralloc_cats(sa, path)) return 0 ;
if (!stralloc_cats(sa, magic)) goto err ;
if (random_sauniquename(sa, 8) == -1) goto err ;
if (!stralloc_0(sa)) goto err ;
return 1 ;
err:
if (wasnull) stralloc_free(sa) ; else sa->len = base ;
return 0 ;
}
/* Searches the subscriber log and outputs via subwrite(s,len) any entry
* that matches search. A '_' is search is a wildcard. Any other
* non-alphanum/'.' char is replaced by a '_'. */
static void _searchlog(struct subdbinfo *info,
const char *table,
char *search, /* search string */
int subwrite()) /* output fxn */
{
sqlite3_stmt *stmt;
int res;
datetime_sec when;
struct datetime dt;
char date[DATE822FMT];
/* SELECT (*) FROM list_slog WHERE fromline LIKE '%search%' OR address */
/* LIKE '%search%' ORDER BY tai; */
/* The '*' is formatted to look like the output of the non-mysql version */
/* This requires reading the entire table, since search fields are not */
/* indexed, but this is a rare query and time is not of the essence. */
if (!stralloc_copys(&line,"SELECT tai, edir||etype||' '||address||' '||fromline"
" FROM ")) die_nomem();
if (!stralloc_cat_table(&line,info,table)) die_nomem();
if (!stralloc_cats(&line,"_slog")) die_nomem();
if (*search) { /* We can afford to wait for LIKE '%xx%' */
if (!stralloc_cats(&line," WHERE fromline LIKE '%")) die_nomem();
if (!stralloc_cats(&line,search)) die_nomem();
if (!stralloc_cats(&line,"%' OR address LIKE '%")) die_nomem();
if (!stralloc_cats(&line,search)) die_nomem();
if (!stralloc_cats(&line,"%'")) die_nomem();
} /* ordering by tai which is an index */
if (!stralloc_cats(&line," ORDER by tai")) die_nomem();
if (!stralloc_0(&line)) die_nomem();
if ((stmt = _sqlquery(info, &line)) == NULL)
strerr_die2x(111,FATAL,sqlite3_errmsg((sqlite3*)info->conn));
while ((res = sqlite3_step(stmt)) != SQLITE_DONE) {
if (res != SQLITE_ROW)
strerr_die2x(111,FATAL,sqlite3_errmsg((sqlite3*)info->conn));
(void)scan_ulong((const char*)sqlite3_column_text(stmt,0),&when);
datetime_tai(&dt,when);
if (!stralloc_copyb(&line,date,date822fmt(date,&dt)-1)) die_nomem();
if (!stralloc_cats(&line,": ")) die_nomem();
if (!stralloc_catb(&line,strnum,fmt_ulong(strnum,when))) die_nomem();
if (!stralloc_cats(&line," ")) die_nomem();
if (!stralloc_catb(&line,
(const char*)sqlite3_column_text(stmt,1),
sqlite3_column_bytes(stmt,1)))
die_nomem();
if (subwrite(line.s,line.len) == -1) die_write();
}
sqlite3_finalize(stmt);
}
int main (int argc, char const *const *argv)
{
stralloc sa = STRALLOC_ZERO ;
unsigned int n = 8 ;
PROG = "s6-uniquename" ;
{
subgetopt_t l = SUBGETOPT_ZERO ;
for (;;)
{
register int opt = subgetopt_r(argc, argv, "n:", &l) ;
if (opt == -1) break ;
switch (opt)
{
case 'n' : if (!uint0_scan(l.arg, &n)) usage() ; break ;
default : usage() ;
}
}
argc -= l.ind ; argv += l.ind ;
}
if (argc < 1) usage() ;
if (!stralloc_cats(&sa, argv[0])) strerr_diefu1sys(111, "stralloc_cats") ;
if ((n ? random_sauniquename(&sa, n) : sauniquename(&sa)) < 0)
strerr_diefu1sys(111, "make unique name") ;
if (!stralloc_catb(&sa, "\n", 1)) strerr_diefu1sys(111, "stralloc_cats") ;
if (allwrite(1, sa.s, sa.len) < sa.len) strerr_diefu1sys(111, "write to stdout") ;
return 0 ;
}
static int decode_prvs(const char *s)
{
/* The BATV standard says the user part should have the format
* "tag-type=tag-val=loc-core" where "loc-core" is the original local
* address, but all the examples I could find in actual use had the
* last two parts reversed. What a mess. So, I have to check if
* either the first or second part is a valid prvs tag, and use the
* other one. */
int at;
int sep;
if (s[at = str_rchr(s,'@')] == 0)
return 0;
/* Format: [email protected] */
for (sep = 5; sep < at && s[sep] != '='; ++sep)
;
if (sep >= at)
return 0;
if (is_prvs_tag(s+5,sep-5)) {
if (!stralloc_copys(&realsender,s+sep+1)) die_nomem();
if (!stralloc_0(&realsender)) die_nomem();
return 1;
}
/* Format: [email protected] */
for (sep = at - 1; sep > 5 && s[sep] != '='; --sep)
;
if (is_prvs_tag(s + sep + 1, at - sep - 1)) {
if (!stralloc_copyb(&realsender,s+5,sep-5)) die_nomem();
if (!stralloc_cats(&realsender,s+at)) die_nomem();
if (!stralloc_0(&realsender)) die_nomem();
return 1;
}
return 0;
}
static int doit(stralloc *work,const char *rule)
{
char ch;
unsigned int colon;
unsigned int prefixlen;
ch = *rule++;
if ((ch != '?') && (ch != '=') && (ch != '*') && (ch != '-')) return 1;
colon = str_chr(rule,':');
if (!rule[colon]) return 1;
if (work->len < colon) return 1;
prefixlen = work->len - colon;
if ((ch == '=') && prefixlen) return 1;
if (case_diffb(rule,colon,work->s + prefixlen)) return 1;
if (ch == '?') {
if (byte_chr(work->s,prefixlen,'.') < prefixlen) return 1;
if (byte_chr(work->s,prefixlen,':') < prefixlen) return 1;
if (byte_chr(work->s,prefixlen,'[') < prefixlen) return 1;
if (byte_chr(work->s,prefixlen,']') < prefixlen) return 1;
}
work->len = prefixlen;
if (ch == '-') work->len = 0;
return stralloc_cats(work,rule + colon + 1);
}
int stralloc_copys(stralloc *r, const void *xv) {
if (!r) { errno = EINVAL; return 0; }
r->len = 0;
return stralloc_cats(r, xv);
}
static const char *create_table(struct subdbinfo *info,
const char *suffix1,
const char *suffix2,
const char *definition)
{
make_name(info,suffix1,suffix2,1);
if (sql_table_exists(info,name.s) > 0)
return 0;
stralloc_copys(&query,"CREATE TABLE ");
stralloc_cats(&query,name.s);
stralloc_cats(&query," (");
stralloc_cats(&query,definition);
stralloc_cats(&query,")");
stralloc_0(&query);
return sql_create_table(info,query.s);
}
int
filter_start(stralloc *filter)
{
if (!stralloc_copys(filter, ""))
return 0;
if (objectclass.s != (char *)0 && objectclass.len != 0) {
/* (&(objectclass=...)%searchfilter%) */
if (!stralloc_copys(filter, "(&(") ||
!stralloc_cats(filter, LDAP_OBJECTCLASS) ||
!stralloc_cats(filter, "=") ||
!stralloc_cat(filter, &objectclass) ||
!stralloc_cats(filter, ")"))
return 0;
}
return 1;
}
int absolutepath (stralloc *sa, const char *path)
{
int r = 1 ;
if (!path) r = stralloc_copys(sa, "/") ;
else if (path[0] == '/') r = stralloc_copys(sa, path) ;
else
{
unsigned int n = 0 ;
for (;;)
{
n += 1024 ;
if (!stralloc_ready(sa, n))
{
r = 0 ;
break ;
}
if (getcwd(sa->s, n)) break ;
if (errno != ENOMEM)
{
r = 0 ;
break ;
}
}
sa->len = str_len(sa->s) ;
if (r) r = stralloc_append(sa, "/") && stralloc_cats(sa, path) ;
if (!r) stralloc_free(sa) ;
}
return r ? stralloc_0(sa) : 0 ;
}
int sql_table_exists(struct subdbinfo *info,
const char *name)
{
MYSQL_RES *result;
stralloc_copys(&line,"SELECT 0 FROM ");
stralloc_cats(&line,name);
stralloc_cats(&line," LIMIT 1");
stralloc_0(&line);
if (mysql_real_query((MYSQL*)info->conn,line.s,line.len) == 0) {
if ((result = mysql_use_result((MYSQL*)info->conn)) != 0)
mysql_free_result(result);
return 1;
}
return (mysql_errno((MYSQL*)info->conn) == ER_BAD_TABLE_ERROR) ? 0 : -1;
}
static void dispatch(const char *dir,const char *def)
/* Hand off control to one of the command files in the list directory. */
{
if (!is_dir(dir))
return;
if (!stralloc_append(&basedir,"/")) die_nomem();
if (!stralloc_cats(&basedir,dir)) die_nomem();
/* FIXME: set up $EXT $EXT2 $EXT3 $EXT4 ? Is it feasable? */
if (def == 0 || *def == 0)
execute("editor",0);
else if (str_diff(def,"owner") == 0)
execute("owner",0);
else if (str_diff(def,"digest-owner") == 0)
execute("owner",0);
else {
try_dispatch(def,"digest-return-",14,"digest/bouncer");
try_dispatch(def,"return-",7,"bouncer");
try_dispatch(def,"confirm-",8,"confirmer");
try_dispatch(def,"discard-",8,"confirmer");
try_dispatch(def,"accept-",7,"moderator");
try_dispatch(def,"reject-",7,"moderator");
/* If nothing else matches, call the manager. */
execute("manager",def);
}
}
void presub(unsigned long from,unsigned long to,stralloc *subject,
int factype, /* action type (AC_THREAD,AC_GET,AC_DIGEST) */
char format) /* output format type (see idx.h) */
/* Starts within header, outputs "subject" and optional headers, terminates*/
/* header and handles output before table-of-contents */
{
switch(format) {
case MIME:
case VIRGIN:
case NATIVE:
case MIXED:
hdr_mime((format == MIXED) ? CTYPE_MULTIPART : CTYPE_DIGEST);
hdr_add2("Subject: ",subject->s,subject->len);
hdr_boundary(0);
hdr_ctype(CTYPE_TEXT);
hdr_transferenc(); /* content-transfer-enc header if needed */
break;
case RFC1153:
hdr_mime(CTYPE_TEXT);
hdr_add2("Subject: ",subject->s,subject->len);
qmail_puts(&qq,"\n");
flagcd = '\0'; /* We make 8-bit messages, not QP/base64 for rfc1153 */
break; /* Since messages themselves aren't encoded */
}
if (!stralloc_cats(subject,"\n\n")) die_nomem();
code_qput(subject->s,subject->len);
if (format != NATIVE && factype != AC_THREAD && factype != AC_INDEX) {
strnum[fmt_ulong(strnum,from)] = 0;
strnum2[fmt_ulong(strnum2,to)] = 0;
code_qputs(MSG2(TXT_TOP_TOPICS,strnum,strnum2));
}
}
static int
it_loops_dms (direntry *d, void *data)
{
stralloc **sas = data;
int i;
size_t l;
if (d->d_type != DT_BLK)
return 0;
if (!str_diffn (d->d_name, "loop", 4) && d->d_name[4] >= '0' && d->d_name[4] <= '9')
i = 0;
else if (!str_diffn (d->d_name, "dm-", 3))
i = 1;
else
return 0;
l = sas[i]->len;
if (!stralloc_cats (sas[i], "/dev/") || !stralloc_cats (sas[i], d->d_name)
|| !stralloc_0 (sas[i]))
aa_strerr_diefu1sys (2, "stralloc_catb");
/* /dev/loop* always exists, let's find the actual ones */
if (i == 0)
{
int fd;
fd = open_read (sas[i]->s + l);
if (fd < 0)
sas[i]->len = l;
else
{
struct loop_info64 info;
int r;
/* make sure it is one/in use; we get ENXIO when not */
r = ioctl (fd, LOOP_GET_STATUS64, &info);
if (r < 0)
/* treat all errors the same though */
sas[i]->len = l;
fd_close (fd);
}
}
return 0;
}
void doheaders(void)
{
int flaggoodfield,match;
if (act == AC_DIGEST)
copy(&qq,"headeradd",'H');
hdr_add2s("Mailing-List: ",MSG(TXT_MAILING_LIST));
if (listid.len > 0)
hdr_add2("List-ID: ",listid.s,listid.len);
hdr_datemsgid(when);
hdr_from("-help");
if (!stralloc_copys(&mydtline,"Delivered-To: responder for ")) die_nomem();
if (!stralloc_catb(&mydtline,outlocal.s,outlocal.len)) die_nomem();
if (!stralloc_cats(&mydtline,"@")) die_nomem();
if (!stralloc_catb(&mydtline,outhost.s,outhost.len)) die_nomem();
if (!stralloc_cats(&mydtline,"\n")) die_nomem();
qmail_put(&qq,mydtline.s,mydtline.len);
flaggoodfield = 0;
if (act != AC_DIGEST)
for (;;) {
if (getln(&ssin,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!match) break;
if (line.len == 1) break;
if ((line.s[0] != ' ') && (line.s[0] != '\t')) {
flaggoodfield = 0;
if (case_startb(line.s,line.len,"mailing-list:")) {
if (flageditor) /* we may be running from a sublist */
flaggoodfield = 0;
else
strerr_die2x(100,FATAL,MSG(ERR_MAILING_LIST));
}
if (line.len == mydtline.len)
if (byte_equal(line.s,line.len,mydtline.s))
strerr_die2x(100,FATAL,MSG(ERR_LOOPING));
if (case_startb(line.s,line.len,"delivered-to:"))
flaggoodfield = 1;
if (case_startb(line.s,line.len,"received:"))
flaggoodfield = 1;
}
if (flaggoodfield)
qmail_put(&qq,line.s,line.len);
}
}
