/*
Usage: bbsnnrp [options] nntpserver activefile
-h|? (help)
-v (verbose protocol transactions)
-c (reset active files only; don't receive articles)
-r remotehost(send articles to remotehost, default=local)
-p port|(send articles to remotehost at port, default=7777)
path(send articles to local at path, default=~bbs/innd/.innbbsd)
-n (don't ask innbbsd server and stat articles)
-w seconds (wait for seconds and run infinitely, default=once)
-a max_art (maximum number of articles received for a group each time)
-s max_stat(maximum number of articles stated for a group each time)
-t stdin|nntp (default=nntp)
*/
#include "innbbsconf.h"
#include <sys/mman.h>
#ifndef AIX
# include <sys/fcntl.h>
#endif
#include "bbslib.h"
#include "daemon.h"
#include "nntp.h"
#ifndef MAX_ARTS
# define MAX_ARTS 100
#endif
#ifndef MAX_STATS
# define MAX_STATS 1000
#endif
#if defined(__linux)
#define NO_USE_MMAP
#else
#define USE_MMAP
#endif
int Max_Arts= MAX_ARTS;
int Max_Stats = MAX_STATS;
typedef struct NEWSRC_T {
char *nameptr, *lowptr, *highptr, *modeptr;
int namelen, lowlen, highlen;
ULONG low, high;
int mode, subscribe;
} newsrc_t;
typedef struct NNRP_T {
int nnrpfd;
int innbbsfd;
FILE *nnrpin, *nnrpout;
FILE *innbbsin, *innbbsout;
char activefile[MAXPATHLEN];
char rcfile[MAXPATHLEN];
newsrc_t *newsrc;
char *actpointer, *actend;
int actsize, actfd, actdirty;
} nnrp_t;
typedef struct XHDR_T {
char *header;
ULONG artno;
} xhdr_t;
xhdr_t XHDR[MAX_ARTS];
char LockFile[1024];
#define NNRPGroupOK NNTP_GROUPOK_VAL
#define NNRPXhdrOK NNTP_HEAD_FOLLOWS_VAL
#define NNRParticleOK NNTP_ARTICLE_FOLLOWS_VAL
#define INNBBSstatOK NNTP_NOTHING_FOLLOWS_VAL
#define INNBBSihaveOK NNTP_SENDIT_VAL
#define NNRPconnectOK NNTP_POSTOK_VAL
#define NNRPstatOK NNTP_NOTHING_FOLLOWS_VAL
#define INNBBSconnectOK NNTP_POSTOK_VAL
nnrp_t BBSNNRP;
void doterm(s)
int s;
{
printf("bbsnnrp terminated. Signal %d\n", s);
writerc(&BBSNNRP);
if (isfile(LockFile))
unlink(LockFile);
exit(1);
}
extern char *optarg;
extern int opterr, optind;
#ifndef MIN_WAIT
# define MIN_WAIT 60
#endif
int ResetActive = 0;
int StatHistory = 1;
int AskLocal = 1;
int RunOnce = 1;
int DefaultWait = MIN_WAIT;
char *DefaultPort = DefaultINNBBSPort;
char *DefaultPath = LOCALDAEMON;
char *DefaultRemoteHost;
#ifndef MAXBUFLEN
#define MAXBUFLEN 256
#endif
char DefaultNewsgroups[MAXBUFLEN];
char DefaultOrganization[MAXBUFLEN];
char DefaultModerator[MAXBUFLEN];
char DefaultTrustfrom[MAXBUFLEN];
char DefaultTrustFrom[MAXBUFLEN];
usage(arg)
char *arg;
{
fprintf(stderr,"Usage: %s [options] nntpserver activefile\n", arg);
fprintf(stderr," -h|? (help) \n");
fprintf(stderr," -v (verbose protocol transactions)\n");
fprintf(stderr," -c (reset active files only; don't receive articles)\n");
fprintf(stderr," -r [proto:]remotehost\n");
fprintf(stderr," (send articles to remotehost, default=ihave:local)\n");
fprintf(stderr," -p port|(send articles to remotehost at port, default=%s)\n",DefaultINNBBSPort);
fprintf(stderr," path(send articles to local at path, default=~bbs/innd/.innbbsd)\n");
fprintf(stderr," -w seconds ( > 1 wait for seconds and run infinitely, default=once)\n");
fprintf(stderr," -n (don't ask innbbsd server and stat articles)\n");
fprintf(stderr," -a max_art(maximum number of articles received for a group each time)\n");
fprintf(stderr," default=%d\n", MAX_ARTS);
fprintf(stderr," -s max_stat(maximum number of articles stated for a group each time)\n");
fprintf(stderr," default=%d\n", MAX_STATS);
fprintf(stderr," -t stdin|nntp (default=nntp)\n");
fprintf(stderr," -g newsgroups\n");
fprintf(stderr," -m moderator\n");
fprintf(stderr," -o organization\n");
fprintf(stderr," -f trust_user (From: trust_user)\n");
fprintf(stderr," -F trust_user (From trust_user)\n");
fprintf(stderr," Please E-mail bug to skhuang@csie.nctu.edu.tw or\n");
fprintf(stderr," post to tw.bbs.admin.installbbs\n");
}
static char *StdinInputType="stdin";
static char *NntpInputType="nntp";
static char *NntpIhaveProtocol="ihave";
static char *NntpPostProtocol="post";
static char *DefaultNntpProtocol ;
main(argc, argv)
int argc;
char **argv;
{
char *ptr, *server, *active;
int c, errflag=0;
int lockfd;
char *inputtype;
DefaultNntpProtocol = NntpIhaveProtocol;
*DefaultNewsgroups = '\0';
*DefaultModerator = '\0';
*DefaultOrganization = '\0';
*DefaultTrustFrom = '\0';
*DefaultTrustfrom = '\0';
inputtype = NntpInputType;
while ((c = getopt(argc,argv,"f:F:m:o:g:w:r:p:a:s:t:h?ncv"))!= -1)
switch (c) {
case 'v':
verboseon("bbsnnrp.log");
break;
case 'c':
ResetActive = 1;
break;
case 'g':
strncpy(DefaultNewsgroups, optarg, sizeof DefaultNewsgroups);
break;
case 'm':
strncpy(DefaultModerator, optarg, sizeof DefaultModerator);
break;
case 'o':
strncpy(DefaultOrganization, optarg, sizeof DefaultOrganization);
break;
case 'f':
strncpy(DefaultTrustfrom, optarg, sizeof DefaultTrustfrom);
break;
case 'F':
strncpy(DefaultTrustFrom, optarg, sizeof DefaultTrustFrom);
break;
case 'r': {
char *hostptr;
AskLocal = 0;
DefaultRemoteHost = optarg;
if ((hostptr = strchr(optarg,':')) != NULL) {
*hostptr = '\0';
DefaultRemoteHost = hostptr+1;
if (strcasecmp( optarg, "post" ) == 0)
DefaultNntpProtocol = NntpPostProtocol;
*hostptr = ':';
}
break;
}
case 'w':
RunOnce = 0;
DefaultWait = atoi(optarg);
if (DefaultWait < MIN_WAIT)
DefaultWait = MIN_WAIT;
break;
case 'p':
if (AskLocal == 0) {
DefaultPort = optarg;
} else {
DefaultPath = optarg;
}
break;
case 'n':
StatHistory = 0;
break;
case 'a':
Max_Arts = atol(optarg);
if (Max_Arts < 0) Max_Arts = 0;
break;
case 's':
Max_Stats = atol(optarg);
if (Max_Stats < 0) Max_Stats = 0;
break;
case 't':
if ( strcasecmp(optarg,StdinInputType) == 0) {
inputtype = StdinInputType;
}
break;
case 'h':
case '?':
default:
errflag ++;
}
if (errflag > 0) {
usage(argv[0]);
return(1);
}
if (inputtype == NntpInputType && argc - optind < 2) {
usage(argv[0]);
exit(1);
}
if (inputtype == NntpInputType) {
server = argv[optind];
active = argv[optind+1];
if ( isfile(active) ) {
strncpy(BBSNNRP.activefile, active, sizeof BBSNNRP.activefile);
} else if ( strchr(active,'/') == NULL) {
sprintf(BBSNNRP.activefile, "%s/innd/%.*s",BBSHOME, sizeof BBSNNRP.activefile - 7 - strlen(BBSHOME), active);
} else {
strncpy(BBSNNRP.activefile, active, sizeof BBSNNRP.activefile);
}
strncpy(LockFile , (char*)fileglue("%s.lock",active), sizeof LockFile);
if ((lockfd = open(LockFile, O_RDONLY)) >= 0) {
char buf[10];
int pid;
if (read(lockfd, buf, sizeof buf) > 0 && (pid = atoi(buf))>0 && kill(pid,0)==0) {
fprintf(stderr, "another process [%d] running\n", pid);
exit(1);
} else {
fprintf(stderr, "no process [%d] running, but lock file existed, unlinked\n", pid);
unlink(LockFile);
}
close(lockfd);
}
if ((lockfd = open(LockFile, O_RDWR|O_CREAT|O_EXCL,0644)) < 0) {
fprintf( stderr, "maybe another %s process running\n",argv[0]);
exit(1);
} else {
char buf[10];
int pid;
sprintf(buf,"%-.8d\n",getpid());
write(lockfd, buf, strlen(buf));
close(lockfd);
}
for (;;) {
if (!initial_bbs(NULL)) {
fprintf(stderr, "Initial BBS failed\n");
exit(1);
}
initsockets(server, &BBSNNRP, inputtype);
ptr = (char*)strrchr(active,'/');
if (ptr != NULL)
ptr++;
else
ptr = active;
sprintf(BBSNNRP.rcfile,"%s/.newsrc.%s.%s",INNDHOME, server, ptr);
initrcfiles(&BBSNNRP);
signal(SIGTERM, doterm);
signal(SIGKILL, doterm);
signal(SIGHUP, doterm);
signal(SIGPIPE, doterm);
readnews(&BBSNNRP);
writerc(&BBSNNRP);
closesockets();
if (RunOnce) break;
sleep(DefaultWait);
}
unlink(LockFile);
} /* NntpInputType */
else {
if (!initial_bbs(NULL)) {
fprintf(stderr, "Initial BBS failed\n");
exit(1);
}
initsockets(server, &BBSNNRP, inputtype);
signal(SIGTERM, doterm);
signal(SIGKILL, doterm);
signal(SIGHUP, doterm);
signal(SIGPIPE, doterm);
stdinreadnews(&BBSNNRP);
closesockets();
} /* stdin input type */
return 0;
}
headbegin(buffer)
char *buffer;
{
if (strncmp(buffer,"Path: ",6)==0 ) {
if (strchr(buffer+6,'!') != NULL)
return 1;
}
if (strncmp(buffer,"From ",5)== 0 ) {
if (strchr(buffer+5,':') != NULL)
return 1;
}
return 0;
}
stdinreadnews(bbsnnrp)
nnrp_t *bbsnnrp;
{
int i;
char buffer[4096];
ULONG low, high;
char tmpfilename[MAXPATHLEN];
FILE *tmpfp = NULL;
char mid[1024];
int pathagain;
int ngmet, submet, midmet, pathmet, orgmet, approvedmet;
int discard;
char sending_path[MAXPATHLEN];
int sending_path_len=0;
strncpy(tmpfilename,(char*)fileglue("/tmp/bbsnnrp-stdin-%d-%d",getuid(),getpid()),sizeof tmpfilename);
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s", buffer);
if (atoi(buffer) != INNBBSconnectOK) {
fprintf(stderr, "INNBBS server not OK\n");
return;
}
if ( DefaultNntpProtocol == NntpPostProtocol ) {
fputs("MODE READER\r\n", bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: MODE READER\n");
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s",buffer);
}
if (StatHistory == 0) {
fputs("MIDCHECK OFF\r\n", bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: MIDCHECK OFF\n");
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s",buffer);
}
tmpfp = fopen(tmpfilename,"w");
if (tmpfp == NULL) return;
*mid = '\0';
for (;;) {
fprintf(stderr,"Try to read from stdin ...\n");
ngmet = 0, submet = 0, midmet = 0, pathmet = 0, orgmet = 0, approvedmet=0;
discard = 0;
while (fgets(buffer, sizeof buffer, stdin) != NULL) {
char *tmpptr;
tmpptr = strchr(buffer,'\n');
if (tmpptr != NULL) *tmpptr = '\0';
if (strncasecmp(buffer,"Message-ID: ",12)==0) {
strncpy(mid, buffer+12,sizeof mid);
midmet = 1;
} else if (strncmp(buffer,"Subject: ",9)==0) {
submet = 1;
} else if (strncmp(buffer,"Path: ",6)==0) {
pathmet = 1;
} else if (strncmp(buffer,"Organization: ",14)==0) {
orgmet = 1;
} else if (strncmp(buffer,"Approved: ",10) == 0) {
approvedmet = 1;
} else if (strncmp(buffer,"From: ",6)==0 && *DefaultTrustfrom ) {
if (strstr(buffer+6, DefaultTrustfrom)==NULL) {
discard = 1;
verboselog("Discard: %s for %s",buffer, DefaultTrustfrom);
}
} else if (strncmp(buffer,"From ",5)==0 && *DefaultTrustFrom ) {
if (strstr(buffer+5, DefaultTrustFrom)==NULL) {
discard = 1;
verboselog("Discard: %s for %s",buffer, DefaultTrustFrom);
}
} else if (strncmp(buffer,"Received: ",10)==0) {
char *rptr=buffer+10, *rrptr;
int savech, len;
if (strncmp(buffer+10,"from ",5)==0) {
rptr +=5;
rrptr = strchr(rptr,'(');
if (rrptr != NULL) rptr = rrptr + 1;
rrptr = strchr(rptr,' ');
savech = *rrptr;
if (rrptr != NULL) *rrptr = '\0';
} else if (strncmp(buffer+10,"(from ",6)==0) {
rptr +=6;
rrptr = strchr(rptr,')');
savech = *rrptr;
if (rrptr != NULL) *rrptr = '\0';
}
len = strlen(rptr) +1;
if (*rptr && sending_path_len + len < sizeof(sending_path)) {
if (*sending_path)
strcat(sending_path, "!");
strcat(sending_path, rptr);
sending_path_len += len ;
}
if (rrptr != NULL) *rrptr = savech;
}
if (strncmp(buffer,"Newsgroups: ",12)==0) {
if (*DefaultNewsgroups){
fprintf(tmpfp,"Newsgroups: %s\r\n",DefaultNewsgroups);
} else {
fprintf(tmpfp,"%s\r\n",buffer);
}
ngmet = 1;
} else {
if (buffer[0] == '\0') {
if (!ngmet && *DefaultNewsgroups) {
fprintf(tmpfp,"Newsgroups: %s\r\n",DefaultNewsgroups);
}
if (!submet) {
fprintf(tmpfp,"Subject: (no subject)\r\n");
}
if (!pathmet) {
fprintf(tmpfp,"Path: from-mail\r\n");
}
if (!midmet) {
static int seed;
time_t now;
time(&now);
fprintf(tmpfp,"Message-ID: <%d@%d.%d.%d>\r\n",now,getpid(), getuid(), seed);
sprintf(mid, "<%d@%d.%d.%d>", now, getpid(), getuid(), seed);
seed++;
}
if (!orgmet && *DefaultOrganization) {
fprintf(tmpfp,"Organization: %s\r\n", DefaultOrganization);
}
if (!approvedmet && *DefaultModerator) {
fprintf(tmpfp,"Approved: %s\r\n", DefaultModerator);
}
}
if (strncmp(buffer,"From ",5) != 0 && strncmp(buffer,"To: ",4) !=0) {
if (buffer[0] == '\0') {
if (*sending_path) {
fprintf(tmpfp,"X-Sending-Path: %s\r\n",sending_path);
}
}
fprintf(tmpfp,"%s\r\n",buffer);
}
}
if (buffer[0]=='\0') break;
}
fprintf(stderr,"Article Body begin ...\n");
pathagain = 0;
while (fgets(buffer, sizeof buffer, stdin) != NULL) {
char *tmpptr;
tmpptr = strchr(buffer,'\n');
if (tmpptr != NULL) *tmpptr = '\0';
if ( headbegin(buffer) ) {
FILE *oldfp = bbsnnrp->nnrpin;
pathagain = 1;
fputs(".\r\n",tmpfp);
fclose(tmpfp);
fprintf(stderr,"Try to post ...\n");
tmpfp = fopen(tmpfilename,"r");
bbsnnrp->nnrpin = tmpfp;
if (!discard)
if (INNBBSihave(bbsnnrp, -1, mid)== -1) {
fprintf(stderr,"post failed\n");
}
bbsnnrp->nnrpin = oldfp;
fclose(tmpfp);
*mid = '\0';
tmpfp = fopen(tmpfilename,"w");
fprintf(tmpfp,"%s\r\n",buffer);
break;
} else {
fprintf(tmpfp,"%s\r\n",buffer);
}
}
if (!pathagain) break;
}
if (!pathagain && tmpfp) {
FILE *oldfp = bbsnnrp->nnrpin;
fputs(".\r\n",tmpfp);
fclose(tmpfp);
fprintf(stderr,"Try to post ...\n");
tmpfp = fopen(tmpfilename,"r");
bbsnnrp->nnrpin = tmpfp;
if (!discard)
if (INNBBSihave(bbsnnrp, -1, mid)== -1) {
fprintf(stderr,"post failed\n");
}
bbsnnrp->nnrpin = oldfp;
fclose(tmpfp);
}
if (isfile(tmpfilename)) {
unlink(tmpfilename);
}
}
static char *ACT_BUF, *RC_BUF;
int ACT_COUNT;
initrcfiles(bbsnnrp)
nnrp_t *bbsnnrp;
{
FILE *actfp, *rcfp;
char buff[1024];
int actfd, i, count, actcount=0, rcount=0, maxcount;
struct stat st;
char *actlistptr, *ptr;
actfd = open(bbsnnrp->activefile, O_RDWR);
if (actfd < 0) {
fprintf( stderr, "can't read/write %s\n", bbsnnrp->activefile );
exit(1);
}
if (fstat(actfd, &st) != 0) {
fprintf( stderr, "can't stat %s\n", bbsnnrp->activefile );
exit(1);
}
bbsnnrp->actfd = actfd;
bbsnnrp->actsize = st.st_size;
#ifdef USE_MMAP
bbsnnrp->actpointer = mmap(0, st.st_size, PROT_WRITE | PROT_READ,
MAP_SHARED, actfd, 0);
if (bbsnnrp->actpointer == (char*)-1) {
fprintf( stderr, "mmap error \n");
exit(1);
}
#else
if (bbsnnrp->actpointer == NULL) {
bbsnnrp->actpointer = (char*)mymalloc(st.st_size);
} else {
bbsnnrp->actpointer = (char*)myrealloc(bbsnnrp->actpointer,st.st_size);
}
if (bbsnnrp->actpointer == NULL || read(actfd, bbsnnrp->actpointer, st.st_size) <= 0) {
fprintf( stderr, "read act error \n");
exit(1);
}
#endif
bbsnnrp->actend = bbsnnrp->actpointer + st.st_size;
i = 0, count = 0;
for (ptr = bbsnnrp->actpointer; ptr < bbsnnrp->actend && (actlistptr = (char*)strchr(ptr,'\n')) != NULL; ptr = actlistptr +1, ACT_COUNT++) {
if (*ptr == '\n') continue;
if (*ptr == '#') continue;
count ++;
}
bbsnnrp->newsrc = (newsrc_t*) mymalloc( sizeof(newsrc_t) * count);
ACT_COUNT = 0;
for (ptr = bbsnnrp->actpointer; ptr < bbsnnrp->actend && (actlistptr = (char*)strchr(ptr,'\n')) != NULL; ptr = actlistptr +1 ) {
register newsrc_t *rcptr;
char *nptr;
/**actlistptr = '\0';*/
if (*ptr == '\n') continue;
if (*ptr == '#') continue;
rcptr = &bbsnnrp->newsrc[ACT_COUNT];
rcptr->nameptr = NULL;
rcptr->namelen = 0;
rcptr->lowptr = NULL;
rcptr->lowlen = 0;
rcptr->highptr = NULL;
rcptr->highlen = 0;
rcptr->modeptr = NULL;
rcptr->low = 0;
rcptr->high = 0;
rcptr->mode = 'y';
for (nptr= ptr ;*nptr && isspace(*nptr); ) nptr++;
if ( nptr == actlistptr ) continue;
rcptr->nameptr = nptr;
for (nptr++; *nptr && !isspace(*nptr); ) nptr++;
rcptr->namelen = (int)(nptr - rcptr->nameptr);
if ( nptr == actlistptr) continue;
for (nptr++ ;*nptr && isspace(*nptr); ) nptr++;
if ( nptr == actlistptr) continue;
rcptr->highptr = nptr;
rcptr->high = atol(nptr);
for (nptr++; *nptr && !isspace(*nptr); ) nptr++;
rcptr->highlen = (int)(nptr - rcptr->highptr);
if ( nptr == actlistptr) continue;
for (nptr++ ;*nptr && isspace(*nptr); ) nptr++;
if ( nptr == actlistptr) continue;
rcptr->lowptr = nptr;
rcptr->low = atol(nptr);
for (nptr++; *nptr && !isspace(*nptr); ) nptr++;
rcptr->lowlen = (int)(nptr - rcptr->lowptr);
if ( nptr == actlistptr) continue;
for (nptr++ ;*nptr && isspace(*nptr); ) nptr++;
if ( nptr == actlistptr) continue;
rcptr->mode = *nptr;
rcptr->modeptr = nptr;
ACT_COUNT ++;
}
}
initsockets(server, bbsnnrp, type)
char *server;
nnrp_t *bbsnnrp;
char *type;
{
int nnrpfd ;
int innbbsfd;
if (AskLocal) {
innbbsfd = unixclient(DefaultPath,"tcp");
if (innbbsfd < 0) {
fprintf(stderr, "Connect to %s error. You may not run innbbsd\n", LOCALDAEMON);
/* unix connect fail, may run by inetd, try to connect to local once */
innbbsfd = inetclient("localhost",DefaultPort,"tcp");
if (innbbsfd < 0) {
exit(2);
}
close(innbbsfd);
/* try again */
innbbsfd = unixclient(DefaultPath,"tcp");
if (innbbsfd < 0) {
exit(3);
}
}
verboselog("INNBBS connect to %s\n",DefaultPath);
} else {
innbbsfd = inetclient(DefaultRemoteHost,DefaultPort,"tcp");
if (innbbsfd < 0) {
fprintf(stderr, "Connect to %s at %s error. Remote Server not Ready\n", DefaultRemoteHost, DefaultPort);
exit(2);
}
verboselog("INNBBS connect to %s\n",DefaultRemoteHost);
}
if (type == StdinInputType) {
bbsnnrp->nnrpfd = 0;
bbsnnrp->innbbsfd = innbbsfd;
if ((bbsnnrp->nnrpin = fdopen(0,"r")) == NULL ||
(bbsnnrp->nnrpout= fdopen(1,"w")) == NULL ||
(bbsnnrp->innbbsin= fdopen(innbbsfd,"r")) == NULL ||
(bbsnnrp->innbbsout= fdopen(innbbsfd,"w"))== NULL ) {
fprintf( stderr, "fdopen error\n");
exit(3);
}
return;
}
nnrpfd = inetclient(server, "nntp","tcp");
if (nnrpfd < 0) {
fprintf(stderr, " connect to %s error \n", server);
exit(2);
}
verboselog("NNRP connect to %s\n", server);
bbsnnrp->nnrpfd = nnrpfd;
bbsnnrp->innbbsfd = innbbsfd;
if ((bbsnnrp->nnrpin = fdopen(nnrpfd,"r")) == NULL ||
(bbsnnrp->nnrpout= fdopen(nnrpfd,"w")) == NULL ||
(bbsnnrp->innbbsin= fdopen(innbbsfd,"r")) == NULL ||
(bbsnnrp->innbbsout= fdopen(innbbsfd,"w"))== NULL ) {
fprintf( stderr, "fdopen error\n");
exit(3);
}
}
closesockets()
{
fclose(BBSNNRP.nnrpin);
fclose(BBSNNRP.nnrpout);
fclose(BBSNNRP.innbbsin);
fclose(BBSNNRP.innbbsout);
close(BBSNNRP.nnrpfd);
close(BBSNNRP.innbbsfd);
}
updaterc(actptr, len, value)
char *actptr;
int len;
ULONG value;
{
for (actptr += len -1; len -- >0; ) {
*actptr-- = value % 10 + '0';
value /= 10;
}
}
/*
if old file is empty, don't need to update
prevent from disk full
*/
int
myrename(old,new)
char *old, *new;
{
struct stat st;
if (stat(old,&st) != 0) return -1;
if (st.st_size <= 0) return -1;
return rename(old,new);
}
flushrc(bbsnnrp)
nnrp_t *bbsnnrp;
{
int backfd;
char *bak1;
if (bbsnnrp->actdirty == 0) return;
bak1 = (char*)strdup((char*)fileglue("%s.BAK",bbsnnrp->activefile));
if (isfile(bak1)) {
myrename(bak1, (char*)fileglue("%s.BAK.OLD",bbsnnrp->activefile));
}
#ifdef USE_MMAP
if ((backfd=open((char*)fileglue("%s.BAK",bbsnnrp->activefile),O_WRONLY | O_TRUNC | O_CREAT, 0664)) < 0 || write(backfd, bbsnnrp->actpointer, bbsnnrp->actsize) < bbsnnrp->actsize)
#else
myrename(bbsnnrp->activefile, bak1);
if ((backfd=open(bbsnnrp->activefile,O_WRONLY | O_TRUNC | O_CREAT, 0664)) < 0 || write(backfd, bbsnnrp->actpointer, bbsnnrp->actsize) < bbsnnrp->actsize)
#endif
{
char emergent[128];
sprintf(emergent,"/tmp/bbsnnrp.%d.active",getpid());
fprintf(stderr, "write to backup active fail. Maybe disk full\n");
fprintf(stderr, "try to write in %s\n",emergent);
if ((backfd = open(emergent,O_WRONLY | O_TRUNC | O_CREAT, 0644))<0 || write(backfd, bbsnnrp->actpointer, bbsnnrp->actsize) < bbsnnrp->actsize)
{
fprintf(stderr, "write to %sfail.\n", emergent);
} else {
close(backfd);
}
/* if write fail, should leave */
/*exit(1);*/
} else {
close(backfd);
}
free(bak1);
bbsnnrp->actdirty = 0;
}
writerc(bbsnnrp)
nnrp_t *bbsnnrp;
{
if (bbsnnrp->actpointer) {
flushrc(bbsnnrp);
#ifdef USE_MMAP
if (munmap(bbsnnrp->actpointer, bbsnnrp->actsize) < 0)
fprintf(stderr, "can't unmap\n");
/*free(bbsnnrp->actpointer);*/
bbsnnrp->actpointer = NULL;
#endif
if (close(bbsnnrp->actfd) < 0)
fprintf(stderr, "can't close actfd\n");
}
}
static FILE* Xhdrfp;
static char NNRPbuffer[4096];
static char INNBBSbuffer[4096];
char *
NNRPgets(string, len, fp)
char *string;
int len;
FILE *fp;
{
char* re = fgets(string, len, fp);
char *ptr;
if (re != NULL) {
if ((ptr = (char*)strchr(string,'\r'))!=NULL)
*ptr = '\0';
if ((ptr = (char*)strchr(string,'\n'))!=NULL)
*ptr = '\0';
}
return re;
}
int NNRPstat(bbsnnrp, artno, mid)
nnrp_t *bbsnnrp;
ULONG artno;
char **mid;
{
char *ptr;
int code;
*mid = NULL;
fprintf(bbsnnrp->nnrpout,"STAT %d\r\n",artno);
fflush(bbsnnrp->nnrpout);
verboselog("nnrpPut: STAT %d\n",artno);
NNRPgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin);
verboselog("nnrpGet: %s\n",NNRPbuffer);
ptr = (char*) strchr(NNRPbuffer, ' ');
if (ptr != NULL) *ptr++ = '\0';
code = atoi(NNRPbuffer);
ptr = (char*) strchr(ptr, ' ');
if (ptr != NULL) *ptr++ = '\0';
*mid = ptr;
ptr = (char*) strchr(ptr, ' ');
if (ptr != NULL) *ptr++ = '\0';
return code;
}
int
NNRPxhdr(pattern, bbsnnrp, i, low, high)
char *pattern;
nnrp_t *bbsnnrp;
int i;
ULONG low, high;
{
newsrc_t *rcptr = &bbsnnrp->newsrc[i];
int size, code;
Xhdrfp = bbsnnrp->nnrpin;
fprintf(bbsnnrp->nnrpout,"XHDR %s %d-%d\r\n",pattern,low, high );
#ifdef BBSNNRPDEBUG
printf("XHDR %s %d-%d\r\n",pattern,low, high );
#endif
fflush(bbsnnrp->nnrpout);
verboselog("nnrpPut: XHDR %s %d-%d\n",pattern,low, high );
NNRPgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin);
verboselog("nnrpGet: %s\n", NNRPbuffer);
code = atoi(NNRPbuffer);
return code;
}
int NNRPxhdrget(artno, mid, iscontrol)
int *artno;
char **mid;
int iscontrol;
{
*mid = NULL;
*artno = 0;
if (NNRPgets(NNRPbuffer, sizeof NNRPbuffer, Xhdrfp) == NULL)
return 0;
else {
char *ptr, *s;
if (strcmp(NNRPbuffer,".")==0) return 0;
ptr = (char*)strchr(NNRPbuffer,' ');
if (!ptr) return 1;
*ptr++ = '\0';
*artno = atol(NNRPbuffer);
if (iscontrol) {
ptr = (char*)strchr(s=ptr,' ');
if (!ptr) return 1;
*ptr++ = '\0';
if (strcmp(s,"cancel") != 0) return 1;
}
*mid = ptr;
return 1;
}
}
int INNBBSstat(bbsnnrp, i, mid)
nnrp_t *bbsnnrp;
int i;
char *mid;
{
newsrc_t *rcptr = &bbsnnrp->newsrc[i];
int size, code;
fprintf(bbsnnrp->innbbsout,"STAT %s\r\n", mid);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: STAT %s\n", mid);
NNRPgets(INNBBSbuffer, sizeof INNBBSbuffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s\n", INNBBSbuffer);
return atol(INNBBSbuffer);
}
int INNBBSihave(bbsnnrp, artno, mid)
nnrp_t *bbsnnrp;
ULONG artno;
char *mid;
{
int size, code;
int header=1;
if (DefaultNntpProtocol == NntpPostProtocol) {
fprintf(bbsnnrp->innbbsout,"POST\r\n");
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: POST %s\n", mid);
} else {
fprintf(bbsnnrp->innbbsout,"IHAVE %s\r\n", mid);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: IHAVE %s\n", mid);
}
if (NNRPgets(INNBBSbuffer, sizeof INNBBSbuffer, bbsnnrp->innbbsin)==NULL){
return -1;
}
verboselog("innbbsGet: %s\n", INNBBSbuffer);
#ifdef BBSNNRPDEBUG
printf("ihave got %s\n", INNBBSbuffer);
#endif
if (DefaultNntpProtocol == NntpPostProtocol) {
if ((code=atol(INNBBSbuffer)) != NNTP_START_POST_VAL) {
if (code == NNTP_POSTFAIL_VAL)
return 0;
else
return -1;
}
} else {
if ((code=atol(INNBBSbuffer)) != INNBBSihaveOK) {
if (code == 435 || code == 437)
return 0;
else
return -1;
}
}
if (artno != -1) {
fprintf(bbsnnrp->nnrpout,"ARTICLE %d\r\n", artno);
verboselog("nnrpPut: ARTICLE %d\n", artno);
#ifdef BBSNNRPDEBUG
printf("ARTICLE %d\r\n", artno);
#endif
fflush(bbsnnrp->nnrpout);
if (NNRPgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin)==NULL) {
return -1;
}
verboselog("nnrpGet: %s\n", NNRPbuffer);
#ifdef BBSNNRPDEBUG
printf("article got %s\n", NNRPbuffer);
#endif
if (atol(NNRPbuffer) != NNRParticleOK) {
fputs(".\r\n",bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
NNRPgets(INNBBSbuffer, sizeof INNBBSbuffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s\n",INNBBSbuffer);
return 0;
}
}
header = 1;
while ( fgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin) != NULL)
{
if (strcmp(NNRPbuffer,"\r\n") == 0)
header = 0;
if (strcmp(NNRPbuffer,".\r\n")==0) {
verboselog("nnrpGet: .\n");
fputs(NNRPbuffer,bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: .\n");
if (NNRPgets(INNBBSbuffer, sizeof INNBBSbuffer, bbsnnrp->innbbsin)==NULL)
return -1;
verboselog("innbbsGet: %s\n",INNBBSbuffer);
#ifdef BBSNNRPDEBUG
printf("end ihave got %s\n", INNBBSbuffer);
#endif
code = atol(INNBBSbuffer);
if (DefaultNntpProtocol == NntpPostProtocol) {
if (code == NNTP_POSTEDOK_VAL)
return 1;
if (code == NNTP_POSTFAIL_VAL)
return 0;
} else {
if (code == 235)
return 1;
if (code == 437 || code == 435)
return 0;
}
break;
}
if ( DefaultNntpProtocol == NntpPostProtocol &&
header && strncasecmp(NNRPbuffer,"NNTP-Posting-Host: ",19)==0) {
fprintf(bbsnnrp->innbbsout,"X-%s",NNRPbuffer);
} else {
fputs(NNRPbuffer,bbsnnrp->innbbsout);
}
}
fflush(bbsnnrp->innbbsout);
return -1;
}
int
NNRPgroup(bbsnnrp, i, low, high)
nnrp_t *bbsnnrp;
int i;
ULONG *low, *high;
{
newsrc_t *rcptr = &bbsnnrp->newsrc[i];
int size, code;
ULONG tmp;
fprintf(bbsnnrp->nnrpout,"GROUP %-.*s\r\n",
rcptr->namelen, rcptr->nameptr );
printf("GROUP %-.*s\r\n", rcptr->namelen, rcptr->nameptr );
verboselog("nnrpPut: GROUP %-.*s\n", rcptr->namelen, rcptr->nameptr );
fflush(bbsnnrp->nnrpout);
NNRPgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin);
verboselog("nnrpGet: %s\n",NNRPbuffer);
printf("%s\n",NNRPbuffer);
sscanf(NNRPbuffer, "%d %d %ld %ld", &code, &size, low, high);
if (*low > *high) {
tmp = *low;
*low = *high;
*high = tmp;
}
return code;
}
readnews(bbsnnrp)
nnrp_t *bbsnnrp;
{
int i;
char buffer[4096];
ULONG low, high;
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s", buffer);
if (atoi(buffer) != INNBBSconnectOK) {
fprintf(stderr, "INNBBS server not OK\n");
return;
}
#ifdef BBSNNRPDEBUG
printf("%s",buffer);
#endif
fgets(buffer, sizeof buffer, bbsnnrp->nnrpin);
verboselog("nnrpGet: %s", buffer);
if (buffer[0] != '2') {
/*if (atoi(buffer) != NNRPconnectOK && atoi(buffer) != NNTP_NOPOSTOK_VAL) {*/
fprintf(stderr, "NNRP server not OK\n");
return;
}
#ifdef BBSNNRPDEBUG
printf("%s",buffer);
#endif
fputs("MODE READER\r\n", bbsnnrp->nnrpout);
fflush(bbsnnrp->nnrpout);
verboselog("nnrpPut: MODE READER\n");
fgets(buffer, sizeof buffer, bbsnnrp->nnrpin);
verboselog("nnrpGet: %s",buffer);
if ( DefaultNntpProtocol == NntpPostProtocol ) {
fputs("MODE READER\r\n", bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: MODE READER\n");
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s",buffer);
}
#ifdef BBSNNRPDEBUG
printf("%s",buffer);
#endif
if (StatHistory == 0) {
fputs("MIDCHECK OFF\r\n", bbsnnrp->innbbsout);
fflush(bbsnnrp->innbbsout);
verboselog("innbbsPut: MIDCHECK OFF\n");
fgets(buffer, sizeof buffer, bbsnnrp->innbbsin);
verboselog("innbbsGet: %s",buffer);
}
bbsnnrp->actdirty = 0;
for (i =0; i< ACT_COUNT; i++) {
int code = NNRPgroup(bbsnnrp, i, &low, &high);
newsrc_t *rcptr = &bbsnnrp->newsrc[i];
int j;
ULONG artno;
char *mid;
int artcount;
#ifdef BBSNNRPDEBUG
printf("got reply %d %ld %ld\n",code, low, high);
#endif
artcount = 0;
if (code == NNRPGroupOK) {
int xcount;
ULONG maxartno= rcptr->high;
int isCancelControl = (strncmp(rcptr->nameptr,"control",rcptr->namelen)==0)
||
(strncmp(rcptr->nameptr,"control.cancel",rcptr->namelen)==0) ;
/* less than or equal to high, for server renumber */
if (rcptr->low != low) {
bbsnnrp->actdirty = 1;
rcptr->low = low;
updaterc(rcptr->lowptr, rcptr->lowlen, rcptr->low);
}
if (ResetActive) {
if (rcptr->high != high) {
bbsnnrp->actdirty = 1;
rcptr->high = high;
updaterc(rcptr->highptr, rcptr->highlen, rcptr->high);
}
} else if (rcptr->high < high) {
int xhdrcode;
ULONG maxget=high;
int exception=0;
if (rcptr->high < low) {
bbsnnrp->actdirty = 1;
rcptr->high = low;
updaterc(rcptr->highptr, rcptr->highlen, low);
}
if (high > rcptr->high + Max_Stats) {
maxget = rcptr->high + Max_Stats;
}
if ( isCancelControl )
xhdrcode = NNRPxhdr("Control",bbsnnrp, i, rcptr->high+1, maxget);
else
xhdrcode = NNRPxhdr("Message-ID",bbsnnrp, i, rcptr->high+1, maxget);
maxartno = maxget;
if ( xhdrcode == NNRPXhdrOK) {
while (NNRPxhdrget(&artno, &mid, isCancelControl)) {
/*#define DEBUG*/
#ifdef DEBUG
printf("no %d id %s\n",artno, mid);
#endif
if (artcount < Max_Arts) {
if (mid != NULL && !isCancelControl) {
if (!StatHistory || INNBBSstat(bbsnnrp,i,mid) != INNBBSstatOK) {
printf("** %d ** %d need it %s\n", artcount, artno,mid);
XHDR[artcount].artno = artno;
XHDR[artcount].header = restrdup(XHDR[artcount].header,mid);
/*INNBBSihave(bbsnnrp,i,artno,mid);*/
/* to get it */
artcount++;
}
} else if (mid != NULL) {
if (INNBBSstat(bbsnnrp,i,mid) == INNBBSstatOK) {
printf("** %d ** %d need cancel %s\n", artcount, artno,mid);
XHDR[artcount].artno = artno;
XHDR[artcount].header = restrdup(XHDR[artcount].header,mid);
artcount++;
}
}
maxartno = artno;
}
}
}/* while xhdr OK */
exception = 0;
for (xcount = 0; xcount < artcount; xcount++) {
ULONG artno;
char *mid;
artno = XHDR[xcount].artno;
mid = XHDR[xcount].header;
if (isCancelControl) {
if (NNRPstat(bbsnnrp,artno,&mid) == NNRPstatOK) {
}
}
printf("** %d ** %d i have it %s\n", xcount, artno, mid);
if (!ResetActive && mid != NULL)
exception = INNBBSihave(bbsnnrp,artno,mid);
if (exception == -1) break;
if (rcptr->high != artno) {
rcptr->high = artno;
updaterc(rcptr->highptr, rcptr->highlen, rcptr->high);
}
}
if (rcptr->high != maxartno && exception != -1) {
bbsnnrp->actdirty = 1;
rcptr->high = maxartno;
updaterc(rcptr->highptr, rcptr->highlen, maxartno);
}
}
}
/*
flushrc(bbsnnrp);
*/
}
fprintf(bbsnnrp->innbbsout,"quit\r\n");
fprintf(bbsnnrp->nnrpout,"quit\r\n");
fflush(bbsnnrp->innbbsout);
fflush(bbsnnrp->nnrpout);
fgets(NNRPbuffer, sizeof NNRPbuffer, bbsnnrp->nnrpin);
fgets(INNBBSbuffer, sizeof INNBBSbuffer, bbsnnrp->innbbsin);
/* bbsnnrp->newsrc[0].high = 1900;
updaterc(bbsnnrp->newsrc[0].highptr, bbsnnrp->newsrc[0].highlen,
bbsnnrp->newsrc[0].high);
*/
}
INNBBSDhalt()
{
}
