static int faxsend_cleanup(int errcode, char *errmsg, void *vp)
{
struct faxconv_err_args *args=(struct faxconv_err_args *)vp;
unsigned pages_sent=0;
char *p, *q;
int i;
time_t now_time;
unsigned coverpage_cnt=0;
unsigned page_cnt=0;
/* Check how many files sendfax renamed (were succesfully sent) */
while (args->file_list)
{
if (access(args->file_list->filename, 0) == 0)
break;
if (coverpage_cnt < args->n_cover_pages)
++coverpage_cnt;
else
++pages_sent;
args->file_list=args->file_list->next;
}
/* Strip out any blank lines in captured output from sendfax */
for (p=q=errmsg; *p; p++)
{
if (*p == '\n' && (p[1] == '\n' || p[1] == 0))
continue;
*q++=*p;
}
*q=0;
/* Find the last message from sendfax */
for (p=q=errmsg; *p; p++)
{
if (*p != '\n')
continue;
*p=0;
/* Dump sendfax's output to the log */
if (*q)
{
clog_msg_start_info();
clog_msg_str("courierfax: " SENDFAX ": ");
clog_msg_str(q);
clog_msg_send();
}
q=p+1;
}
if (*q) /* Last line of the error message */
{
clog_msg_start_info();
clog_msg_str("courierfax: " SENDFAX ": ");
clog_msg_str(q);
clog_msg_send();
}
else /* Default message */
{
q=SENDFAX ": completed.";
}
/*
** Ugly hack: capture the following message from sendfax:
**
** /usr/sbin/sendfax: cannot access fax device(s) (locked?)
*/
#if 0
lockflag=0;
p=strchr(q, ':');
if (p)
{
static const char msg1[]="cannot access fax device";
static const char msg2[]="locked";
++p;
while (*p && isspace((int)(unsigned char)*p))
p++;
if (*p && strncasecmp(p, msg1, sizeof(msg1)-1) == 0)
{
p += sizeof(msg1);
while (*p && !isspace((int)(unsigned char)*p))
++p;
p=strchr(p, '(');
if (p && strncmp(p+1, msg2, sizeof(msg2)-1) == 0)
{
args->is_locked=1;
clog_msg_start_info();
clog_msg_str("courierfax: detected locked"
" modem line, sleeping...");
clog_msg_send();
sleep(60);
return (-1);
}
}
}
#else
if (errcode == 2)
{
args->is_locked=1;
clog_msg_start_info();
clog_msg_str("courierfax: detected locked"
" modem line, sleeping...");
clog_msg_send();
sleep(60);
return (-1);
}
#endif
ctlfile_append_connectioninfo(args->ctf, args->nreceip,
COMCTLFILE_DELINFO_REPLY, q);
sprintf(errmsg, "%u cover pages, %u document pages sent.",
coverpage_cnt, page_cnt);
i=ctlfile_searchfirst(args->ctf, COMCTLFILE_FAXEXPIRES);
time(&now_time);
ctlfile_append_reply(args->ctf, args->nreceip,
errmsg,
(pages_sent == 0 &&
i >= 0 &&
errcode < 10 &&
now_time < strtotime(args->ctf->lines[i]+1)
? COMCTLFILE_DELDEFERRED:
COMCTLFILE_DELFAIL_NOTRACK), 0);
return (-1);
}
int msgcancel(const char *qid, const char **reason, int nreason,
int chkuid)
{
ino_t n;
struct ctlfile ctf;
struct stat stat_buf;
uid_t u=getuid();
int c, d;
struct iovec *iova;
static const char default_cancel_msg[]="Message cancelled.";
static const char *default_cancel_msgp[1]= { default_cancel_msg };
static const char x=COMCTLFILE_CANCEL_MSG;
char *s;
if (comparseqid(qid, &n)) return (-1);
if (ctlfile_openi(n, &ctf, 0)) return (-1);
if (fstat(ctf.fd, &stat_buf) || (chkuid && u && u != stat_buf.st_uid) ||
ctf.cancelled)
{
ctlfile_close(&ctf);
return (-1);
}
c=ctlfile_searchfirst(&ctf, COMCTLFILE_MSGID);
if (c < 0 || strcmp(ctf.lines[c]+1, qid))
{
ctlfile_close(&ctf);
return (-1);
}
if ((iova=(struct iovec *)malloc(sizeof(struct iovec) * 3 *
(nreason == 0 ? 1:nreason))) == 0)
{
perror("enomem");
exit(1);
}
if (nreason == 0)
{
reason=default_cancel_msgp;
nreason=1;
}
c=0;
while (nreason)
{
iova[c].iov_base=(caddr_t)&x;
iova[c].iov_len=1;
c++;
iova[c].iov_base=(caddr_t) *reason;
iova[c].iov_len=strlen( *reason );
c++;
iova[c].iov_base=(caddr_t)"\n";
iova[c].iov_len=1;
c++;
++reason;
--nreason;
}
s=malloc(sizeof(TRIGGER_FLUSHMSG)+strlen(qid)+3);
if (!s)
{
perror("malloc");
exit(1);
}
strcat(strcat(strcpy(s, TRIGGER_FLUSHMSG " "), qid), "\n");
d=writev(ctf.fd, iova, c);
ctlfile_close(&ctf);
while (c)
{
--c;
if (iova[c].iov_len > d)
{
perror("writev");
free(iova);
free(s);
return (0);
}
d -= iova[c].iov_len;
}
free(iova);
trigger(s);
free(s);
return (0);
}
int main(int argc, char **argv)
{
if (argc > 1 && strcmp(argv[1], "--version") == 0)
{
printf("%s\n", COURIER_COPYRIGHT);
exit(0);
}
if (chdir(courierdir()))
{
perror("chdir");
return (1);
}
if (argc < 2) return (0);
if (strcmp(argv[1], "stop") == 0)
{
int fd;
trigger(TRIGGER_STOP);
/* Wait until the exclusive lock goes away: */
signal(SIGHUP, SIG_DFL);
if ((fd=open(TMPDIR "/courierd.lock", O_RDWR|O_CREAT, 0600))
< 0) clog_msg_errno();
alarm(15); /* But abort after 15 seconds. */
ll_lock_ex(fd);
return (0);
}
if (strcmp(argv[1], "restart") == 0)
{
trigger(TRIGGER_RESTART);
return (0);
}
if (strcmp(argv[1], "flush") == 0)
{
ino_t n;
struct ctlfile ctf;
if (getuid())
{
/*
** We'll fail trying to open the pipe anyway, but let's
** give a meaningful error message now.
*/
fprintf(stderr,
"courier flush can be executed only by the superuser.\n");
exit(1);
}
if (argc < 3)
{
trigger(TRIGGER_FLUSH); /* Everything */
exit(0);
}
if (comparseqid(argv[2], &n) == 0 &&
ctlfile_openi(n, &ctf, 1) == 0)
{
int c=ctlfile_searchfirst(&ctf, COMCTLFILE_MSGID);
if (c >= 0 && strcmp(ctf.lines[c]+1, argv[2]) == 0)
{
char *s=courier_malloc(sizeof(TRIGGER_FLUSHMSG)+1+
strlen(argv[2]));
strcat(strcat(strcpy(s, TRIGGER_FLUSHMSG),
argv[2]), "\n");
trigger(s);
ctlfile_close(&ctf);
return (0);
}
ctlfile_close(&ctf);
}
fprintf(stderr, "No such message.\n");
exit(1);
return (1);
}
/* Might as well... */
if (strcmp(argv[1], "start") == 0)
{
pid_t p;
int waitstat;
char dummy;
/*
** Ok, courierd will close file descriptor 3 when it starts, so we
** put a pipe on there, and wait for it to close.
*/
int pipefd[2];
close(3);
if (open("/dev/null", O_RDONLY) != 3 || pipe(pipefd))
{
fprintf(stderr, "Cannot open pipe\n");
exit(1);
}
if (getuid())
{
/*
** We'll fail trying to execute courierd anyway, but let's
** give a meaningful error message now.
*/
fprintf(stderr, "courier start can be executed only by the superuser.\n");
return (1);
}
signal(SIGCHLD, SIG_DFL);
while ((p=fork()) == -1)
{
perror("fork");
sleep(10);
}
if (p == 0)
{
dup2(pipefd[1], 3);
close(pipefd[1]);
close(pipefd[0]);
while ((p=fork()) == -1)
{
perror("fork");
sleep(10);
}
if (p == 0)
{
/*
** stdin from the bitbucket. stdout to
** /dev/null, or the bitbucket.
*/
signal(SIGHUP, SIG_IGN);
close(0);
open("/dev/null", O_RDWR);
dup2(0, 1);
dup2(0, 2);
/* See if we can disconnect from the terminal */
#ifdef TIOCNOTTY
{
int fd=open("/dev/tty", O_RDWR);
if (fd >= 0)
{
ioctl(fd, TIOCNOTTY, 0);
close(fd);
}
}
#endif
/* Remove any process groups */
#if HAVE_SETPGRP
#if SETPGRP_VOID
setpgrp();
#else
setpgrp(0, 0);
#endif
#endif
execl( DATADIR "/courierctl.start",
"courierctl.start", (char *)0);
perror("exec");
_exit(1);
}
_exit(0);
}
close(pipefd[1]);
while (wait(&waitstat) != p)
;
if (read(pipefd[0], &dummy, 1) < 0)
; /* ignore */
close(pipefd[0]);
close(3);
return (0);
}
if (strcmp(argv[1], "clear") == 0 && argc > 2)
{
libmail_changeuidgid(MAILUID, MAILGID);
if (strcmp(argv[2], "all") == 0)
{
courier_clear_all();
}
else
{
track_save(argv[2], TRACK_ADDRACCEPTED);
printf("%s cleared.\n", argv[2]);
}
return (0);
}
if (argc > 2 && strcmp(argv[1], "show") == 0 &&
strcmp(argv[2], "all") == 0)
{
libmail_changeuidgid(MAILUID, MAILGID);
courier_show_all();
}
return (0);
}
int msgq::queuescan3(std::string subdir, std::string name,
const char *isnewmsg)
{
struct ctlfile ctlinfo;
ino_t inum;
time_t deltime, delsendtime;
const char *p=name.c_str();
struct stat stat_buf;
++p;
inum=strtoino(p);
while (isdigit(*p)) p++;
++p;
deltime=strtotime(p);
name= subdir + '/' + name;
if (ctlfile_openfn(name.c_str(), &ctlinfo, 0, 1))
{
if (errno)
{
clog_msg_start_err();
clog_msg_str("Cannot read ");
clog_msg_str(name.c_str());
clog_msg_send();
clog_msg_prerrno();
}
return (0);
}
delsendtime=deltime;
if (flushtime && ctlinfo.mtime < flushtime && flushtime < deltime)
delsendtime=flushtime;
if (!queuefree)
{
msgq *p;
//
// msgq array is full. See if we can remove the last message from the
// pending queue.
p=queuetail;
if (p && p->nextsenddel > delsendtime)
{
#if 0
clog_msg_start_info();
clog_msg_str("Removing ");
clog_msg_uint(p->msgnum);
clog_msg_str(" to make room for this message.");
clog_msg_send();
#endif
p->removewq();
p->removeq();
}
}
msgq *newq=queuefree;
if (!newq)
{
ctlfile_close(&ctlinfo);
if (queuefill && nextqueuefill == 0)
{
nextqueuefill=current_time + queuefill;
}
return (1);
}
const char *cn=qmsgsctlname(inum);
if ( stat(cn, &stat_buf) == -1 )
{
unlink(name.c_str());
unlink(qmsgsdatname(inum));
unlink(cn);
ctlfile_close(&ctlinfo);
return (0);
}
#if 0
clog_msg_start_info();
clog_msg_str("Adding ");
clog_msg_uint(inum);
clog_msg_str(" to queue.");
clog_msg_send();
#endif
queuefree=newq->next;
++queuedelivering;
ino_t hashbucket=inum % queuehashfirst.size();
if (queuehashfirst[hashbucket])
queuehashfirst[hashbucket]->prevhash=newq;
else
queuehashlast[hashbucket]=newq;
newq->nexthash=queuehashfirst[hashbucket];
newq->prevhash=0;
queuehashfirst[hashbucket]=newq;
newq->nksize= (unsigned long)stat_buf.st_size;
ctlinfo.starttime=stat_buf.st_mtime;
int k=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_MSGID);
newq->msgid= k < 0 ? "": ctlinfo.lines[k]+1;
newq->msgnum=inum;
newq->nextdel=deltime;
newq->nextsenddel=delsendtime;
newq->rcptinfo_list.resize(0);
newq->rcptcount=0;
newq->cancelled=ctlinfo.cancelled;
if (isnewmsg)
{
int auth;
clog_msg_start_info();
clog_msg_str("newmsg,id=");
logmsgid(newq);
auth=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_AUTHNAME);
if (auth >= 0)
{
clog_msg_str(", auth=");
clog_msg_str(ctlinfo.lines[auth]+1);
}
int m=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_FROMMTA);
if (m >= 0)
{
clog_msg_str(": ");
clog_msg_str(ctlinfo.lines[m]+1);
}
clog_msg_send();
}
unsigned i, j;
std::string host, addr;
k=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_SENDER);
struct rfc822t *sendert=rw_rewrite_tokenize(k < 0 ? "":ctlinfo.lines[k]+1);
std::string errmsg;
for (i=0; i<ctlinfo.nreceipients; i++)
{
for (j=0; ctlinfo.lines[j]; j++)
{
switch (ctlinfo.lines[j][0]) {
case COMCTLFILE_DELSUCCESS:
case COMCTLFILE_DELFAIL:
if ((unsigned)atoi(ctlinfo.lines[j]+1) == i)
break;
// This one has been delivered
default:
continue;
}
break;
}
if (ctlinfo.lines[j]) continue;
drvinfo *module=getdelinfo(sendert->tokens,
ctlinfo.receipients[i], host, addr, errmsg);
if (!module)
{
ctlfile_append_reply(&ctlinfo, i, errmsg.c_str(),
SMTPREPLY_TYPE(errmsg.c_str()),
0);
continue;
}
/* Check if it's time to move the message to a backup relay */
if (backup_relay_driver &&
ctlfile_searchfirst(&ctlinfo, COMCTLFILE_WARNINGSENT)
>= 0 &&
strcmp(module->module->name,
backup_relay_driver->module->name) == 0)
{
// module=backup_relay_driver;
host=backup_relay;
}
/* Group all recipients for the same driver and host together */
for (j=0; j<newq->rcptcount; j++)
if (strcmp(module->module->name,
newq->rcptinfo_list[j].delmodule->
module->name) == 0 &&
newq->rcptinfo_list[j].delhost == host &&
newq->rcptinfo_list[j].addresses.size()
< module->maxrcpt )
break;
if (j == newq->rcptcount)
{
#if 0
clog_msg_start_info();
clog_msg_str("id=");
logmsgid(newq);
clog_msg_str(",new rcpt list - module=");
clog_msg_str(module->module->name);
clog_msg_str(", host=");
clog_msg_str(host);
clog_msg_send();
#endif
newq->rcptinfo_list.resize(++newq->rcptcount);
struct rw_info_rewrite rwir;
struct rw_info rwi;
rwir.buf=0;
rwir.errmsg=0;
rw_info_init(&rwi, sendert->tokens, rw_err_func);
rwi.sender=0;
rwi.mode=RW_OUTPUT|RW_ENVSENDER;
rwi.udata= (void *)&rwir;
rw_rewrite_module(module->module, &rwi,
rw_rewrite_chksyn_print);
char *address=((struct rw_info_rewrite *)rwi.udata)->buf;
char *errmsg= ((struct rw_info_rewrite *)rwi.udata)->errmsg;
if (!address)
{
ctlfile_append_reply(&ctlinfo, i, errmsg,
SMTPREPLY_TYPE(errmsg), 0);
newq->rcptinfo_list.resize(--newq->rcptcount);
free(errmsg);
continue;
}
if (errmsg) free(errmsg);
newq->rcptinfo_list[j].init(newq, module, host, address);
free(address);
}
#if 0
clog_msg_start_info();
clog_msg_str("id=");
logmsgid(newq);
clog_msg_str(",module=");
clog_msg_str(module->module->name);
clog_msg_str(", host=");
clog_msg_str(host);
clog_msg_str(", addr=<");
clog_msg_str(addr);
clog_msg_str(">");
clog_msg_send();
#endif
newq->rcptinfo_list[j].addresses.push_back(addr);
newq->rcptinfo_list[j].addressesidx.push_back(i);
}
rfc822t_free(sendert);
ctlfile_close(&ctlinfo);
if (newq->nextsenddel <= current_time ||
/*
** If there are no more recipients, we want to call done() via
** start_message. HOWEVER, if DSN injection FAILED, we want to respect
** the rescheduled delivery attempt time. We can detect that if isnewmsg == 0
*/
(newq->rcptinfo_list.size() == 0 && isnewmsg))
{
newq->start_message();
return (0);
}
msgq *qp, *qprev;
for (qprev=queuetail, qp=0; qprev; qp=qprev, qprev=qp->prev)
if (qprev->nextsenddel < newq->nextsenddel)
break;
newq->next=qp;
newq->prev=qprev;
if (qprev) qprev->next=newq;
else queuehead=newq;
if (qp) qp->prev=newq;
else queuetail=newq;
++queuewaiting;
return (0);
}
int msgq::tmpscan()
{
int found=0;
time(¤t_time);
DIR *tmpdir=opendir(TMPDIR);
if (!tmpdir) clog_msg_errno();
struct dirent *de;
std::string subdir;
std::string ctlfile, datfile, newctlfile, newdatfile;
struct stat stat_buf;
std::string qdir, qname;
while ((de=readdir(tmpdir)) != 0)
{
const char *p;
for (p=de->d_name; *p; p++)
if (!isdigit((int)(unsigned char)*p)) break;
if (*p) continue; // Subdirs must be named all digits
subdir=TMPDIR "/";
subdir += de->d_name;
DIR *subde=opendir(subdir.c_str());
while ((de=readdir(subde)) != 0 && found < 100)
{
if (strcmp(de->d_name, ".") == 0 ||
strcmp(de->d_name, "..") == 0) continue;
ctlfile=subdir;
ctlfile += '/';
ctlfile += de->d_name;
int i=-1;
if (stat(ctlfile.c_str(), &stat_buf)) continue;
size_t j=ctlfile.size();
while (j)
{
if (ctlfile[--j] == '/')
break;
if (ctlfile[j] == '.')
{
i=j;
break;
}
}
ino_t inum=stat_buf.st_ino;
// Cleanup timeout. Should always be sufficiently longer than
// the submit timeout set in submit.C via alarm_timeout.
if (stat_buf.st_mtime < current_time - 48 * 60 * 60)
{
if (de->d_name[0] == 'D')
{
datfile=subdir + "/C" +
(de->d_name+1);
if (stat(datfile.c_str(), &stat_buf)
== 0)
continue;
// Wait until the C file is
// purged
// Be carefull with Cnnnn.x files, because
// Cnnnn.1 is used to hold submission of all
// of them. A race condition can leave
// Cnnnn.1 in a submittable state, so if it
// is removed, other copies of this message
// can become submittable, during a very small
// window.
} else if (de->d_name[0] == 'C' && i >= 0)
{
// This race condition is handled simply
// by not removing Cxxxxx.n if Cxxxxx.n+1
// exists.
char nbuf[NUMBUFSIZE];
datfile=ctlfile.substr(0, i);
size_t n=atoi( ctlfile.c_str()+i+1);
++n;
datfile += '.';
datfile += libmail_str_size_t(n, nbuf);
if (stat(datfile.c_str(), &stat_buf)
== 0)
continue;
// Wait until the C.1 file is
// purged
unlink(ctlfile.c_str());
ctlfile=subdir + "/D" +
(de->d_name+1);
/* FALLTHRU */
}
unlink(ctlfile.c_str());
continue;
}
if (de->d_name[0] != 'C') continue;
if (i >= 0)
{
datfile=ctlfile.substr(0, i);
datfile += ".1";
if (ctlfile == datfile ||
stat(datfile.c_str(), &stat_buf) == 0)
continue;
}
datfile=subdir + "/D" + (de->d_name+1);
newdatfile=qmsgsdatname(inum);
newctlfile=qmsgsctlname(inum);
struct ctlfile ctf;
if ((access(datfile.c_str(), 0) == 0 &&
access(newdatfile.c_str(), 0) == 0) ||
access(newctlfile.c_str(), 0) == 0 ||
ctlfile_openfn(ctlfile.c_str(), &ctf, 0, 0))
{
clog_msg_start_err();
clog_msg_str("QUEUE FILE CORRUPTION: inode ");
clog_msg_uint(inum);
clog_msg_send();
utime(ctlfile.c_str(), 0);
// Keep it around
continue;
}
time_t nextattempt=current_time+delaytime;
if ((i=ctlfile_searchfirst(&ctf,
COMCTLFILE_SUBMITDELAY)) >= 0)
nextattempt=current_time+
atoi(ctf.lines[i]+1);
qname=qmsgqname(inum, nextattempt);
ctlfile_nextattempt(&ctf, nextattempt);
if (link(ctlfile.c_str(), qname.c_str()))
{
mkdir(qmsgqdir(current_time),0755);
if (link(ctlfile.c_str(), qname.c_str())
&& errno != EEXIST)
clog_msg_errno();
}
if (rename(datfile.c_str(), newdatfile.c_str()))
{
mkdir(qmsgsdir(inum), 0755);
// We may need to create this dir
rename(datfile.c_str(), newdatfile.c_str());
}
if (rename(ctlfile.c_str(), newctlfile.c_str()))
clog_msg_errno();
for (i=qname.size(); i; )
{
if (qname[--i] == '/')
break;
}
qdir=qname.substr(0, i);
qname=qname.substr(i+1);
++found;
ctlfile_close(&ctf);
queuescan3(qdir, qname, de->d_name);
}
closedir(subde);
if (stat(subdir.c_str(), &stat_buf) == 0 &&
stat_buf.st_mtime < current_time - 2 * 60 * 60)
rmdir(subdir.c_str()); // Just give it a try
}
closedir(tmpdir);
return (found);
}
const char *ctlfile_security(struct ctlfile *p)
{
int i=ctlfile_searchfirst(p, COMCTLFILE_SECURITY);
return (i < 0 ? "":p->lines[i]+1);
}
