/*
 * $Revision: 1.1 $ *
 * 
 *  History file routines.
 */
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <unistd.h>
#include "cmbbs.h"
#include "innbbsconf.h"
#include "his.h"
#include "dbz.h"
#include "externs.h"

#define STATIC static
/* STATIC char	HIShistpath[] = _PATH_HISTORY; */
STATIC FILE    *HISwritefp;
STATIC int      HISreadfd;
STATIC int      HISdirty;
STATIC int      HISincore = XINDEX_DBZINCORE;
STATIC char    *LogName = "xindexchan";

#ifndef EXPIREDAYS
#define EXPIREDAYS 4
#endif

#ifndef DEFAULT_HIST_SIZE
#define DEFAULT_HIST_SIZE 100000
#endif

void
hisincore(flag)
    int             flag;
{
    HISincore = flag;
}

void
makedbz(histpath, entry)
    char           *histpath;
    long            entry;
{
    long            size;
    size = dbzsize(entry);
    dbzfresh(histpath, size, '\t', 0, 1);
    dbmclose();
}

void            HISsetup();
void            HISclose();

void
mkhistory(srchist)
    char           *srchist;
{
    FILE           *hismaint;
    char            maintbuff[256];
    char           *ptr;
    hismaint = fopen(srchist, "r");
    if (hismaint == NULL) {
	return;
    } {
	char            newhistpath[1024];
	char            newhistdirpath[1024];
	char            newhistpagpath[1024];
	sprintf(newhistpath, "%s.n", srchist);
	sprintf(newhistdirpath, "%s.n.dir", srchist);
	sprintf(newhistpagpath, "%s.n.pag", srchist);
	if (!dashf(newhistdirpath) || !dashf(newhistpagpath)) {
	    makedbz(newhistpath, DEFAULT_HIST_SIZE);
	}
	myHISsetup(newhistpath);
	while (fgets(maintbuff, sizeof(maintbuff), hismaint) != NULL) {
	    datum           key;
	    ptr = (char *)strchr(maintbuff, '\t');
	    if (ptr != NULL) {
		*ptr = '\0';
		ptr++;
	    }
	    key.dptr = maintbuff;
	    key.dsize = strlen(maintbuff);
	    myHISwrite(&key, ptr);
	}
	(void)HISclose();
	/*
	 * rename(newhistpath, srchist); 	rename(newhistdirpath,
	 * fileglue("%s.dir", srchist)); rename(newhistpagpath,
	 * fileglue("%s.pag", srchist));
	 */
    }
    fclose(hismaint);
}

time_t
gethisinfo(void)
{
    FILE           *hismaint;
    time_t          lasthist;
    char            maintbuff[4096];
    char           *ptr;
    hismaint = fopen(HISTORY, "r");
    if (hismaint == NULL) {
	return 0;
    }
    fgets(maintbuff, sizeof(maintbuff), hismaint);
    fclose(hismaint);
    ptr = (char *)strchr(maintbuff, '\t');
    if (ptr != NULL) {
	ptr++;
	lasthist = atol(ptr);
	return lasthist;
    }
    return 0;
}

void
HISmaint(void)
{
    FILE           *hismaint;
    time_t          lasthist, now;
    char            maintbuff[4096];
    char           *ptr;

    if (!dashf(HISTORY)) {
	makedbz(HISTORY, DEFAULT_HIST_SIZE);
    }
    hismaint = fopen(HISTORY, "r");
    if (hismaint == NULL) {
	return;
    }
    fgets(maintbuff, sizeof(maintbuff), hismaint);
    ptr = (char *)strchr(maintbuff, '\t');
    if (ptr != NULL) {
	ptr++;
	lasthist = atol(ptr);
	time(&now);
	if (lasthist + 86400 * Expiredays * 2 < now) {
	    char            newhistpath[1024];
	    char            newhistdirpath[1024];
	    char            newhistpagpath[1024];
	    (void)HISclose();
	    sprintf(newhistpath, "%s.n", HISTORY);
	    sprintf(newhistdirpath, "%s.n.dir", HISTORY);
	    sprintf(newhistpagpath, "%s.n.pag", HISTORY);
	    if (!dashf(newhistdirpath)) {
		makedbz(newhistpath, DEFAULT_HIST_SIZE);
	    }
	    myHISsetup(newhistpath);
	    while (fgets(maintbuff, sizeof(maintbuff), hismaint) != NULL) {
		datum           key;
		ptr = (char *)strchr(maintbuff, '\t');
		if (ptr != NULL) {
		    *ptr = '\0';
		    ptr++;
		    lasthist = atol(ptr);
		} else {
		    continue;
		}
		if (lasthist + 99600 * Expiredays < now)
		    continue;
		key.dptr = maintbuff;
		key.dsize = strlen(maintbuff);
		myHISwrite(&key, ptr);
	    }
	    (void)HISclose();
	    rename(HISTORY, (char *)fileglue("%s.o", HISTORY));
	    rename(newhistpath, HISTORY);
	    rename(newhistdirpath, (char *)fileglue("%s.dir", HISTORY));
	    rename(newhistpagpath, (char *)fileglue("%s.pag", HISTORY));
	    (void)HISsetup();
	}
    }
    fclose(hismaint);
}


/*
 * *  Set up the history files.
 */
void
HISsetup(void)
{
    myHISsetup(HISTORY);
}

int
myHISsetup(histpath)
    char           *histpath;
{
    if (HISwritefp == NULL) {
	/* Open the history file for appending formatted I/O. */
	if ((HISwritefp = fopen(histpath, "a")) == NULL) {
	    syslog(LOG_CRIT, "%s cant fopen %s %m", LogName, histpath);
	    exit(1);
	}
	CloseOnExec((int)fileno(HISwritefp), TRUE);

	/* Open the history file for reading. */
	if ((HISreadfd = open(histpath, O_RDONLY)) < 0) {
	    syslog(LOG_CRIT, "%s cant open %s %m", LogName, histpath);
	    exit(1);
	}
	CloseOnExec(HISreadfd, TRUE);

	/* Open the DBZ file. */
	/* (void)dbzincore(HISincore); */
	(void)dbzincore(HISincore);
	(void)dbzwritethrough(1);
	if (dbminit(histpath) < 0) {
	    syslog(LOG_CRIT, "%s cant dbminit %s %m", histpath, LogName);
	    exit(1);
	}
    }
    return 0;
}


/*
 * *  Synchronize the in-core history file (flush it).
 */
void
HISsync()
{
    if (HISdirty) {
	if (dbzsync()) {
	    syslog(LOG_CRIT, "%s cant dbzsync %m", LogName);
	    exit(1);
	}
	HISdirty = 0;
    }
}


/*
 * *  Close the history files.
 */
void
HISclose(void)
{
    if (HISwritefp != NULL) {
	/*
	 * Since dbmclose calls dbzsync we could replace this line with
	 * "HISdirty = 0;".  Oh well, it keeps the abstraction clean.
	 */
	HISsync();
	if (dbmclose() < 0)
	    syslog(LOG_ERR, "%s cant dbmclose %m", LogName);
	if (fclose(HISwritefp) == EOF)
	    syslog(LOG_ERR, "%s cant fclose history %m", LogName);
	HISwritefp = NULL;
	if (close(HISreadfd) < 0)
	    syslog(LOG_ERR, "%s cant close history %m", LogName);
	HISreadfd = -1;
    }
}

/*
 * *  Get the list of files under which a Message-ID is stored.
 */
char           *
HISfilesfor(key, output)
    datum          *key;
    datum          *output;
{
    char           *dest;
    datum           val;
    long            offset;
    register char  *p;
    register int    i;
    int             Used;

    /* Get the seek value into the history file. */
    val = dbzfetch(*key);
    if (val.dptr == NULL || val.dsize != sizeof offset) {
	/* printf("fail here val.dptr %d\n",val.dptr); */
	return NULL;
    }
    /* Get space. */
    if (output->dptr == NULL) {
	printf("fail here output->dptr null\n");
	return NULL;
    }
    /* Copy the value to an aligned spot. */
    for (p = val.dptr, dest = (char *)&offset, i = sizeof offset; --i >= 0;)
	*dest++ = *p++;
    if (lseek(HISreadfd, offset, SEEK_SET) == -1) {
	printf("fail here lseek %ld\n", offset);
	return NULL;
    }
    /* Read the text until \n or EOF. */
    for (output->dsize = 0, Used = 0;;) {
	i = read(HISreadfd,
		 &output->dptr[output->dsize], LEN - 1);
	if (i <= 0) {
	    printf("fail here i %d\n", i);
	    return NULL;
	}
	Used += i;
	output->dptr[Used] = '\0';
	if ((p = (char *)strchr(output->dptr, '\n')) != NULL) {
	    *p = '\0';
	    break;
	}
    }

    /* Move past the first two fields -- Message-ID and date info. */
    if ((p = (char *)strchr(output->dptr, HIS_FIELDSEP)) == NULL) {
	printf("fail here no HIS_FILE\n");
	return NULL;
    }
    return p + 1;
    /*
     * if ((p = (char*)strchr(p + 1, HIS_FIELDSEP)) == NULL) return NULL;
     */

    /* Translate newsgroup separators to slashes, return the fieldstart. */
}

void
IOError(error)
    char           *error;
{
    fprintf(stderr, "%s\n", error);
}

/* BOOL */
int
myHISwrite(key, remain)
    datum          *key;
    char           *remain;
{
    long            offset;
    datum           val;
    int             i;

    val = dbzfetch(*key);
    if (val.dptr != NULL) {
	return FALSE;
    }
    flock(fileno(HISwritefp), LOCK_EX);
    offset = ftell(HISwritefp);
    i = fprintf(HISwritefp, "%s%c%s",
		key->dptr, HIS_FIELDSEP, remain);
    if (i == EOF || fflush(HISwritefp) == EOF) {
	/* The history line is now an orphan... */
	IOError("history");
	syslog(LOG_ERR, "%s cant write history %m", LogName);
	flock(fileno(HISwritefp), LOCK_UN);
	return FALSE;
    }
    /* Set up the database values and write them. */
    val.dptr = (char *)&offset;
    val.dsize = sizeof offset;
    if (dbzstore(*key, val) < 0) {
	IOError("my history database");
	syslog(LOG_ERR, "%s cant dbzstore %m", LogName);
	flock(fileno(HISwritefp), LOCK_UN);
	return FALSE;
    }
    if (++HISdirty >= ICD_SYNC_COUNT)
	HISsync();
    flock(fileno(HISwritefp), LOCK_UN);
    return TRUE;
}


/*
 * *  Write a history entry.
 */
BOOL
HISwrite(key, date, paths)
    datum          *key;
    long            date;
    char           *paths;
{
    long            offset;
    datum           val;
    int             i;

    flock(fileno(HISwritefp), LOCK_EX);
    offset = ftell(HISwritefp);
    i = fprintf(HISwritefp, "%s%c%ld%c%s\n",
		key->dptr, HIS_FIELDSEP, (long)date, HIS_FIELDSEP,
		paths);
    if (i == EOF || fflush(HISwritefp) == EOF) {
	/* The history line is now an orphan... */
	IOError("history");
	syslog(LOG_ERR, "%s cant write history %m", LogName);
	flock(fileno(HISwritefp), LOCK_UN);
	return FALSE;
    }
    /* Set up the database values and write them. */
    val.dptr = (char *)&offset;
    val.dsize = sizeof offset;
    if (dbzstore(*key, val) < 0) {
	IOError("history database");
	syslog(LOG_ERR, "%s cant dbzstore %m", LogName);
	flock(fileno(HISwritefp), LOCK_UN);
	return FALSE;
    }
    if (++HISdirty >= ICD_SYNC_COUNT)
	HISsync();
    flock(fileno(HISwritefp), LOCK_UN);
    return TRUE;
}
