4.4BSD/usr/src/contrib/news/inn/backends/batcher.c
/* $Revision: 1.17 $
**
** Read batchfiles on standard input and spew out batches.
*/
#include "configdata.h"
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#if defined(DO_NEED_TIME)
#include <time.h>
#endif /* defined(DO_NEED_TIME) */
#include <sys/time.h>
#include "paths.h"
#include "libinn.h"
#include "logging.h"
#include "clibrary.h"
#include "macros.h"
/*
** Global variables.
*/
STATIC BOOL BATCHopen;
STATIC BOOL STATprint;
STATIC double STATbegin;
STATIC double STATend;
STATIC char *Host;
STATIC char *InitialString;
STATIC char *Input;
STATIC char *Processor;
STATIC int ArtsInBatch;
STATIC int ArtsWritten;
STATIC int BATCHcount;
STATIC int MaxBatches;
STATIC int BATCHstatus;
STATIC long BytesInBatch = 60 * 1024;
STATIC long BytesWritten;
STATIC long MaxArts;
STATIC long MaxBytes;
STATIC SIGVAR GotInterrupt;
STATIC STRING Separator = "#! rnews %ld";
/*
** Start a batch process.
*/
STATIC FILE *
BATCHstart()
{
FILE *F;
char buff[SMBUF];
if (Processor && *Processor) {
(void)sprintf(buff, Processor, Host);
F = popen(buff, "w");
if (F == NULL)
return NULL;
}
else
F = stdout;
BATCHopen = TRUE;
BATCHcount++;
return F;
}
/*
** Close a batch, return exit status.
*/
STATIC int
BATCHclose(F)
FILE *F;
{
BATCHopen = FALSE;
if (F == stdout)
return fflush(stdout) == EOF ? 1 : 0;
return pclose(F);
}
/*
** Update the batch file and exit.
*/
STATIC NORETURN
RequeueAndExit(Cookie, line, BytesInArt)
OFFSET_T Cookie;
char *line;
long BytesInArt;
{
static char LINE1[] = "batcher %s times user %.3f system %.3f elapsed %.3f";
static char LINE2[] ="batcher %s stats batches %d articles %d bytes %ld";
static char NOWRITE[] = "batcher %s cant write spool %s\n";
static char BATCHDIR[] = _PATH_BATCHDIR;
char temp[BUFSIZ];
char buff[BUFSIZ];
int i;
FILE *F;
TIMEINFO Now;
double usertime;
double systime;
/* Do statistics. */
(void)GetTimeInfo(&Now);
STATend = TIMEINFOasDOUBLE(Now);
if (GetResourceUsage(&usertime, &systime) < 0) {
usertime = 0;
systime = 0;
}
if (STATprint) {
(void)printf(LINE1, Host, usertime, systime, STATend - STATbegin);
(void)printf("\n");
(void)printf(LINE2, Host, BATCHcount, ArtsWritten, BytesWritten);
(void)printf("\n");
}
(void)openlog("batcher", L_OPENLOG_FLAGS | LOG_PID, LOG_INN_PROG);
syslog(L_NOTICE, LINE1, Host, usertime, systime, STATend - STATbegin);
syslog(L_NOTICE, LINE2, Host, BATCHcount, ArtsWritten, BytesWritten);
/* Last batch exit okay? */
if (BATCHstatus == 0) {
if (feof(stdin)) {
/* Yes, and we're all done -- remove input and exit. */
(void)fclose(stdin);
if (Input)
(void)unlink(Input);
exit(0);
}
/* Don't seek back -- batch was fine. */
Cookie = -1;
}
/* Make an appropriate spool file. */
if (Input == NULL)
(void)sprintf(temp, "%s/%s", BATCHDIR, Host);
else
(void)sprintf(temp, "%s.bch", Input);
if ((F = xfopena(temp)) == NULL) {
(void)fprintf(stderr, "batcher %s cant open %s %s\n",
Host, temp, strerror(errno));
exit(1);
}
/* If we can back up to where the batch started, do so. */
i = 0;
if (Cookie != -1 && fseek(stdin, Cookie, SEEK_SET) == -1) {
(void)fprintf(stderr, "batcher %s cant seek %s\n",
Host, strerror(errno));
i = 1;
}
/* Write the line we had; if the fseek worked, this will be an
* extra line, but that's okay. */
if (line && fprintf(F, "%s %ld\n", line, BytesInArt) == EOF) {
(void)fprintf(stderr, NOWRITE, Host, strerror(errno));
i = 1;
}
/* Write rest of stdin to spool. */
while (fgets(buff, sizeof buff, stdin) != NULL)
if (fputs(buff, F) == EOF) {
(void)fprintf(stderr, NOWRITE, Host, strerror(errno));
i = 1;
break;
}
if (fclose(F) == EOF) {
(void)fprintf(stderr, "batcher %s cant close spool %s\n",
Host, strerror(errno));
i = 1;
}
/* If we had a named input file, try to rename the spool. */
if (Input != NULL && rename(temp, Input) < 0) {
(void)fprintf(stderr, "batcher %s cant rename spool %s\n",
Host, strerror(errno));
i = 1;
}
exit(i);
/* NOTREACHED */
}
/*
** Mark that we got interrupted.
*/
STATIC SIGHANDLER
CATCHinterrupt(s)
int s;
{
GotInterrupt = TRUE;
/* Let two interrupts kill us. */
(void)signal(s, SIG_DFL);
}
/*
** Print a usage message and exit.
*/
STATIC NORETURN
Usage()
{
(void)fprintf(stderr, "batcher usage_error.\n");
exit(1);
}
int
main(ac, av)
int ac;
char *av[];
{
static char SKIPPING[] = "batcher %s skipping \"%.40s...\" %s\n";
static char SPOOL[] = _PATH_SPOOL;
static char BATCHDIR[] = _PATH_BATCHDIR;
BOOL Redirect;
FILE *F;
STRING AltSpool;
TIMEINFO Now;
char *p;
char *data;
char line[BUFSIZ];
char buff[BUFSIZ];
long BytesInArt;
long BytesInCB;
OFFSET_T Cookie;
SIZE_T datasize;
int i;
int artfd;
int ArtsInCB;
int length;
struct stat Sb;
/* Set defaults. */
AltSpool = NULL;
Redirect = TRUE;
(void)umask(NEWSUMASK);
/* Parse JCL. */
while ((i = getopt(ac, av, "a:A:b:B:i:N:p:rs:S:v")) != EOF)
switch (i) {
default:
Usage();
/* NOTREACHED */
case 'a':
ArtsInBatch = atoi(optarg);
break;
case 'A':
MaxArts = atol(optarg);
break;
case 'b':
BytesInBatch = atol(optarg);
break;
case 'B':
MaxBytes = atol(optarg);
break;
case 'i':
InitialString = optarg;
break;
case 'N':
MaxBatches = atoi(optarg);
break;
case 'p':
Processor = optarg;
break;
case 'r':
Redirect = FALSE;
break;
case 's':
Separator = optarg;
break;
case 'S':
AltSpool = optarg;
break;
case 'v':
STATprint = TRUE;
break;
}
if (MaxArts && ArtsInBatch == 0)
ArtsInBatch = MaxArts;
if (MaxBytes && BytesInBatch == 0)
BytesInBatch = MaxBytes;
/* Parse arguments. */
ac -= optind;
av += optind;
if (ac != 1 && ac != 2)
Usage();
Host = av[0];
if ((Input = av[1]) != NULL) {
if (Input[0] != '/') {
Input = NEW(char, STRLEN(BATCHDIR) + 1 + strlen(av[1]) + 1);
(void)sprintf(Input, "%s/%s", BATCHDIR, av[1]);
}
if (freopen(Input, "r", stdin) == NULL) {
(void)fprintf(stderr, "batcher %s cant open %s %s\n",
Host, Input, strerror(errno));
exit(1);
}
}
if (Redirect)
(void)freopen(_PATH_ERRLOG, "a", stderr);
/* Go to where the articles are. */
if (chdir(SPOOL) < 0) {
(void)fprintf(stderr, "batcher %s cant cd %s %s\n",
Host, SPOOL, strerror(errno));
exit(1);
}
/* Set initial counters, etc. */
datasize = 8 * 1024;
data = NEW(char, datasize);
BytesInCB = 0;
ArtsInCB = 0;
Cookie = -1;
GotInterrupt = FALSE;
(void)signal(SIGHUP, CATCHinterrupt);
(void)signal(SIGINT, CATCHinterrupt);
(void)signal(SIGTERM, CATCHinterrupt);
/* (void)signal(SIGPIPE, CATCHinterrupt); */
(void)GetTimeInfo(&Now);
STATbegin = TIMEINFOasDOUBLE(Now);
F = NULL;
while (fgets(line, sizeof line, stdin) != NULL) {
/* Record line length in case we do an ftell. Not portable to
* systems with non-Unix file formats. */
length = strlen(line);
/* Get lines like "name size" */
if ((p = strchr(line, '\n')) == NULL) {
(void)fprintf(stderr, SKIPPING, Host, line, "too long");
continue;
}
*p = '\0';
if (line[0] == '\0' || line[0] == COMMENT_CHAR)
continue;
if ((p = strchr(line, ' ')) != NULL) {
*p++ = '\0';
BytesInArt = atol(p);
}
else
BytesInArt = -1;
/* Strip of leading spool pathname. */
if (line[0] == '/'
&& line[STRLEN(SPOOL)] == '/'
&& EQn(line, SPOOL, STRLEN(SPOOL)))
p = line + STRLEN(SPOOL) + 1;
else
p = line;
/* Open the file. */
if ((artfd = open(p, O_RDONLY)) < 0) {
if (errno != ENOENT)
(void)fprintf(stderr, SKIPPING, Host, p, strerror(errno));
if (AltSpool == NULL)
continue;
(void)sprintf(buff, "%s/%s", AltSpool, p);
if ((artfd = open(buff, O_RDONLY)) < 0) {
if (errno != ENOENT)
(void)fprintf(stderr, SKIPPING,
Host, buff, strerror(errno));
continue;
}
}
/* If we need to, get its size. */
if (BytesInArt < 0) {
if (fstat(artfd, &Sb) < 0) {
(void)fprintf(stderr, SKIPPING, Host, line, strerror(errno));
(void)close(artfd);
continue;
}
if (!S_ISREG(Sb.st_mode)) {
(void)fprintf(stderr, SKIPPING, Host, line, "not a file");
(void)close(artfd);
continue;
}
BytesInArt = Sb.st_size;
}
/* Have an open article, do we need to open a batch? This code
* is here (rather then up before the while loop) so that we
* can avoid sending an empty batch. The goto makes the code
* a bit more clear. */
if (F == NULL) {
if (GotInterrupt) {
(void)close(artfd);
RequeueAndExit(Cookie, (char *)NULL, 0L);
}
if ((F = BATCHstart()) == NULL) {
(void)fprintf(stderr, "batcher %s cant startbatch %d %s\n",
Host, BATCHcount, strerror(errno));
(void)close(artfd);
break;
}
if (InitialString && *InitialString) {
(void)fprintf(F, "%s\n", InitialString);
BytesInCB += strlen(InitialString) + 1;
BytesWritten += strlen(InitialString) + 1;
}
Cookie = ftell(stdin) - length;
goto SendIt;
}
/* We're writing a batch, see if adding the current article
* would exceed the limits. */
if ((ArtsInBatch > 0 && ArtsInCB + 1 >= ArtsInBatch)
|| (BytesInBatch > 0 && BytesInCB + BytesInArt >= BytesInBatch)) {
if ((BATCHstatus = BATCHclose(F)) != 0) {
if (BATCHstatus == -1)
(void)fprintf(stderr, "batcher %s cant closebatch %d %s\n",
Host, BATCHcount, strerror(errno));
else
(void)fprintf(stderr, "batcher %s batch %d exit %d\n",
Host, BATCHcount, BATCHstatus);
(void)close(artfd);
break;
}
ArtsInCB = 0;
BytesInCB = 0;
/* See if we can start a new batch. */
if ((MaxBatches > 0 && BATCHcount >= MaxBatches)
|| (MaxBytes > 0 && BytesWritten + BytesInArt >= MaxBytes)
|| (MaxArts > 0 && ArtsWritten + 1 >= MaxArts)) {
(void)close(artfd);
break;
}
if (GotInterrupt) {
(void)close(artfd);
RequeueAndExit(Cookie, line, BytesInArt);
}
if ((F = BATCHstart()) == NULL) {
(void)fprintf(stderr, "batcher %s cant startbatch %d %s\n",
Host, BATCHcount, strerror(errno));
(void)close(artfd);
break;
}
Cookie = ftell(stdin) - length;
}
SendIt:
/* Now we can start to send the article! */
if (Separator && *Separator) {
(void)sprintf(buff, Separator, BytesInArt);
BytesInCB += strlen(buff) + 1;
BytesWritten += strlen(buff) + 1;
if (fprintf(F, "%s\n", buff) == EOF || ferror(F)) {
(void)fprintf(stderr, "batcher %s cant write separator %s\n",
Host, strerror(errno));
(void)close(artfd);
break;
}
}
/* Write the article. In case of interrupts, retry the read but
* not the fwrite because we can't check that reliably and
* portably. */
while ((i = read(artfd, (POINTER)data, datasize)) > 0 || errno == EINTR)
if (fwrite((POINTER)data, (SIZE_T)1, (SIZE_T)i, F) != i)
break;
if (ferror(F)) {
(void)fprintf(stderr, "batcher %s cant write article %s\n",
Host, strerror(errno));
(void)close(artfd);
break;
}
(void)close(artfd);
/* Update the counts. */
BytesInCB += BytesInArt;
BytesWritten += BytesInArt;
ArtsInCB++;
ArtsWritten++;
if (GotInterrupt) {
BATCHstatus = BATCHclose(F);
RequeueAndExit(Cookie, line, BytesInArt);
}
}
if (BATCHopen)
BATCHstatus = BATCHclose(F);
RequeueAndExit(Cookie, (char *)NULL, 0L);
/* NOTREACHED */
}