static void fax(struct moduledel *p)
{
struct ctlfile ctf;
unsigned nreceipients=p->nreceipients;
const char *host=p->host;
const char *receipient;
unsigned nrecipient=(unsigned)atol(p->receipients[0]);
int pipefd[2];
pid_t child_proc;
int faxopts;
int n_cover_pages;
FILE *fp;
struct faxconv_err_args err_args;
struct sort_file_list *page_list, *pp;
#if HAVE_SETPGRP
#if SETPGRP_VOID
setpgrp();
#else
setpgrp(0, 0);
#endif
#else
#if HAVE_SETPGID
setpgid(0, 0);
#endif
#endif
if (comgetfaxopts(host, &faxopts))
{
clog_msg_start_err();
clog_msg_str("courierfax: FATAL: invalid host");
clog_msg_send();
exit(1);
}
putenv(faxopts & FAX_LOWRES ? "FAXRES=lo":"FAXRES=hi");
if (nreceipients != 1)
{
clog_msg_start_err();
clog_msg_str("courierfax: FATAL: # receipients must be 1");
clog_msg_send();
exit(1);
}
receipient=p->receipients[1];
nrecipient=(unsigned)atol(p->receipients[0]);
if (ctlfile_openi(p->inum, &ctf, 0))
clog_msg_errno();
/* Convert message to fax format, use a child process */
signal(SIGTERM, faxabort);
if (pipe(pipefd) < 0)
{
clog_msg_errno();
}
child_proc=fork();
if (child_proc < 0)
{
clog_msg_errno();
return;
}
if (child_proc == 0)
{
const char *fn;
close(0);
if (open("/dev/null", O_RDONLY) != 0)
clog_msg_errno();
close(pipefd[0]);
close(1);
if (dup(pipefd[1]) != 1)
{
perror("dup");
exit(1);
}
close(2);
if (dup(pipefd[1]) != 2)
{
fprintf(stderr, "ERROR: dup failed\n");
exit(1);
}
close(pipefd[1]);
libmail_changeuidgid(MAILUID, MAILGID);
fn=qmsgsdatname(p->inum);
if (faxconvert(fn, faxopts, &n_cover_pages))
exit (1);
if ((fp=fopen(FAXTMPDIR "/.ncoverpages", "w")) == NULL ||
fprintf(fp, "%d\n", n_cover_pages) < 0 ||
fflush(fp) < 0)
exit(1);
fclose(fp);
exit(0);
}
close(pipefd[1]);
err_args.ctf= &ctf;
err_args.nreceip=nrecipient;
if (read_childerrmsg(child_proc, pipefd[0],
&faxconvert_cleanup, &err_args))
{
ctlfile_close(&ctf);
return;
}
/* Hit it */
if ((fp=fopen(FAXTMPDIR "/.ncoverpages", "r")) == NULL ||
fscanf(fp, "%d", &n_cover_pages) != 1)
{
if (fp)
fclose(fp);
ctlfile_append_reply(err_args.ctf,
err_args.nreceip,
"Internal error: cannot read number of cover pages",
COMCTLFILE_DELFAIL, 0);
ctlfile_close(&ctf);
exit(0);
}
page_list=read_dir_sort_filenames(FAXTMPDIR, FAXTMPDIR "/");
if (!page_list)
{
clog_msg_start_err();
clog_msg_str("courierfax: INTERNAL ERROR - no pages to xmit.");
clog_msg_send();
exit(1);
}
/* Keep trying until the modem line is unlocked */
do
{
if (pipe(pipefd) < 0)
{
clog_msg_errno();
}
child_proc=fork();
if (child_proc < 0)
{
clog_msg_errno();
return;
}
if (child_proc == 0)
{
unsigned page_cnt=0;
char **argvec;
close(pipefd[0]);
close(0);
if (open("/dev/null", O_RDONLY) != 0)
{
perror("/dev/null");
exit(1);
}
close(1);
if (dup(pipefd[1]) != 1)
{
perror("dup");
exit(1);
}
close(2);
if (dup(pipefd[1]) != 2)
{
fprintf(stderr, "ERROR: dup failed\n");
exit(1);
}
close(pipefd[1]);
for (pp=page_list; pp; pp=pp->next)
++page_cnt;
#if 0
while (page_list)
{
unlink(page_list->filename);
page_list=page_list->next;
}
exit(0);
#endif
argvec=(char **)courier_malloc(sizeof(char *)*
(page_cnt+10));
argvec[0]=SENDFAX;
argvec[1]="-v";
argvec[2]="-r";
page_cnt=3;
if (faxopts & FAX_LOWRES)
argvec[page_cnt++]="-n";
argvec[page_cnt++]=(char *)receipient;
while (page_list)
{
argvec[page_cnt++]=page_list->filename;
page_list=page_list->next;
}
argvec[page_cnt]=0;
execv(SENDFAX, argvec);
perror(SENDFAX);
exit(1);
}
close(pipefd[1]);
err_args.ctf= &ctf;
err_args.nreceip=nrecipient;
err_args.file_list=page_list;
err_args.is_locked=0;
err_args.n_cover_pages=n_cover_pages;
if (read_childerrmsg(child_proc, pipefd[0],
&faxsend_cleanup, &err_args) == 0)
{
size_t npages=0;
char fmtbuf[NUMBUFSIZE];
char fmtbuf1[NUMBUFSIZE];
char fmtbuf2[NUMBUFSIZE+100];
for (pp=page_list; pp; pp=pp->next)
++npages;
libmail_str_size_t(npages, fmtbuf);
libmail_str_size_t(n_cover_pages, fmtbuf1);
sprintf(fmtbuf2,
"%s pages - including %s cover page(s)"
" - sent by fax.", fmtbuf, fmtbuf1);
ctlfile_append_reply(&ctf, (unsigned)
nrecipient,
fmtbuf2,
COMCTLFILE_DELSUCCESS, " l");
break;
}
} while (err_args.is_locked);
ctlfile_close(&ctf);
rmdir_contents(FAXTMPDIR);
}
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 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)
{
struct moduledel *p;
clog_open_syslog("courierlocal");
if (chdir(courier_home=getenv("COURIER_HOME")))
clog_msg_errno();
if (atol(getenv("MAXRCPT")) > 1)
{
clog_msg_start_err();
clog_msg_str("Invalid configuration in config, set MAXRCPT=1");
clog_msg_send();
exit(1);
}
module_init(0);
module_delivery_timeout(config_readtime("localtimeout", 15*60));
while ((p=module_getdel()) != NULL)
{
unsigned delid=atol(p->delid);
unsigned rcptnum;
struct ctlfile ctf;
int pipe1[2], pipe2[2];
pid_t pid;
int datfd;
struct stat stat_buf;
pid=module_fork(delid, 0);
if (pid < 0)
{
clog_msg_prerrno();
module_completed(delid, delid);
continue;
}
if (pid) continue;
#if HAVE_SETPGRP
#if SETPGRP_VOID
setpgrp();
#else
setpgrp(0, 0);
#endif
#endif
if (p->nreceipients != 1)
{
clog_msg_start_err();
clog_msg_str("Invalid message from courierd.");
clog_msg_send();
_exit(0);
}
rcptnum=atol(p->receipients[0]);
if (ctlfile_openi(p->inum, &ctf, 0))
{
clog_msg_errno();
_exit(0);
}
if (pipe(pipe1) < 0 || pipe(pipe2) < 0
|| (pid=fork()) < 0)
{
clog_msg_prerrno();
ctlfile_append_reply(&ctf, rcptnum,
"Can't run courierdeliver.",
COMCTLFILE_DELDEFERRED, 0);
ctlfile_close(&ctf);
_exit(0);
return (0);
}
if ((datfd=open(qmsgsdatname(p->inum), O_RDONLY)) < 0)
{
clog_msg_prerrno();
ctlfile_append_reply(&ctf, rcptnum,
"Unable to read message file.",
COMCTLFILE_DELDEFERRED, 0);
ctlfile_close(&ctf);
_exit(0);
return (0);
}
if (pid == 0)
{
const char *host, *homedir, *maildir, *quota;
char *buf, *s;
char *username, *ext;
uid_t u;
gid_t g;
close(pipe1[0]);
close(pipe2[0]);
dup2(pipe2[1], 2);
close(pipe2[1]);
dup2(pipe1[1], 1);
close(pipe1[1]);
close(0);
if (dup(datfd) != 0)
{
clog_msg_start_err();
clog_msg_str("Unable to read message file.");
clog_msg_send();
_exit(EX_TEMPFAIL);
}
close(ctf.fd);
close(datfd);
/* Contents of host: */
/* acct!ext!uid!gid!homedir!maildir!quota */
host=p->host;
buf=strdup(host);
if (!buf)
{
clog_msg_prerrno();
_exit(EX_TEMPFAIL);
}
s=strchr(buf, '!');
username=buf;
if (s) *s++=0;
ext=s;
if (s) s=strchr(s, '!');
if (s) *s++=0;
u=0;
while (s && *s != '!')
{
if (isdigit((int)(unsigned char)*s))
u=u*10 + (*s - '0');
++s;
}
if (s) *s++=0;
g=0;
while (s && *s != '!')
{
if (isdigit((int)(unsigned char)*s))
g=g*10 + (*s - '0');
++s;
}
if (s) *s++=0;
homedir=s;
if (s) s=strchr(s, '!');
if (s) *s++=0;
maildir=s;
if (s) s=strchr(s, '!');
if (s) *s++=0;
quota=s;
if (!s)
{
clog_msg_start_err();
clog_msg_str("Invalid local recipient address.");
clog_msg_send();
_exit(EX_TEMPFAIL);
}
if (chdir(homedir))
{
clog_msg_str(homedir);
clog_msg_str(": ");
clog_msg_prerrno();
_exit(EX_TEMPFAIL);
}
libmail_changeuidgid(u, g);
execl( MODULEDIR "/local/courierdeliver",
"courierdeliver",
username,
homedir,
ext,
ctf.receipients[rcptnum],
verp_getsender(&ctf, ctf.receipients[rcptnum]),
quota,
maildir,
(const char *)0);
clog_msg_start_err();
clog_msg_prerrno();
clog_msg_send();
_exit(EX_TEMPFAIL);
}
close(pipe1[1]);
close(pipe2[1]);
libmail_changeuidgid(MAILUID, MAILGID);
if (fstat(datfd, &stat_buf) == 0)
ctf.msgsize=stat_buf.st_size;
close(datfd);
wait_delivery(pid, &ctf, rcptnum, pipe2[0], pipe1[0],
p->host, p->receipients[1]);
ctlfile_close(&ctf);
_exit(0);
}
return (0);
}
