/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2018, Joyent, Inc.
 */

/*
 * This program is copyright Alec Muffett 1993. The author disclaims all
 * responsibility or liability with respect to it's usage or its effect
 * upon hardware or computer systems, and maintains copyright as set out
 * in the "LICENCE" document which accompanies distributions of Crack v4.0
 * and upwards.
 */

#include "packer.h"

void
PWRemove(char *path)
{
	char fname[PATH_MAX];

	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
	    DICT_DATABASE_PWI);
	(void) unlink(fname);
	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
	    DICT_DATABASE_PWD);
	(void) unlink(fname);
	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
	    DICT_DATABASE_HWM);
	(void) unlink(fname);
}

PWDICT *
PWOpen(char *path, char *mode)
{
	PWDICT *pdesc;
	char iname[PATH_MAX];
	char dname[PATH_MAX];
	char wname[PATH_MAX];
	int fd_d;
	int fd_i;
	int fd_w;
	FILE *dfp;
	FILE *ifp;
	FILE *wfp;

	if ((pdesc = calloc(1, sizeof (PWDICT))) == NULL)
		return ((PWDICT *) 0);

	if (pdesc->header.pih_magic == PIH_MAGIC) {
		return ((PWDICT *) 0);
	}
	(void) memset(pdesc, '\0', sizeof (pdesc));

	(void) snprintf(iname, sizeof (iname), "%s/%s", path,
	    DICT_DATABASE_PWI);
	(void) snprintf(dname, sizeof (dname), "%s/%s", path,
	    DICT_DATABASE_PWD);
	(void) snprintf(wname, sizeof (wname), "%s/%s", path,
	    DICT_DATABASE_HWM);

	if ((fd_d = open(dname, O_RDWR|O_CREAT, 0600)) == -1)
		syslog(LOG_ERR, "PWopen: can't open %s: %s", dname,
		    strerror(errno));
	if ((fd_i = open(iname, O_RDWR|O_CREAT, 0600)) == -1)
		syslog(LOG_ERR, "PWopen: can't open %s: %s", iname,
		    strerror(errno));
	if ((fd_w = open(wname, O_RDWR|O_CREAT, 0600)) == -1)
		syslog(LOG_ERR, "PWopen: can't open %s: %s", wname,
		    strerror(errno));

	if (!(pdesc->dfp = fdopen(fd_d, mode))) {
		return ((PWDICT *) 0);
	}

	if (!(pdesc->ifp = fdopen(fd_i, mode))) {
		(void) fclose(pdesc->dfp);
		return ((PWDICT *) 0);
	}

	if (pdesc->wfp = fdopen(fd_w, mode)) {
		pdesc->flags |= PFOR_USEHWMS;
	}

	ifp = pdesc->ifp;
	dfp = pdesc->dfp;
	wfp = pdesc->wfp;

	if (mode[0] == 'w') {
		pdesc->flags |= PFOR_WRITE;
		pdesc->header.pih_magic = PIH_MAGIC;
		pdesc->header.pih_blocklen = NUMWORDS;
		pdesc->header.pih_numwords = 0;

		(void) fwrite((char *)&(pdesc->header), sizeof (pdesc->header),
		    1, ifp);
	} else {
		pdesc->flags &= ~PFOR_WRITE;

		if (!fread((char *)&(pdesc->header), sizeof (pdesc->header),
		    1, ifp)) {
			pdesc->header.pih_magic = 0;
			(void) fclose(ifp);
			(void) fclose(dfp);
			return ((PWDICT *) 0);
		}

		if (pdesc->header.pih_magic != PIH_MAGIC) {
			pdesc->header.pih_magic = 0;
			(void) fclose(ifp);
			(void) fclose(dfp);
			return ((PWDICT *) 0);
		}

		if (pdesc->header.pih_blocklen != NUMWORDS) {
			pdesc->header.pih_magic = 0;
			(void) fclose(ifp);
			(void) fclose(dfp);
			return ((PWDICT *) 0);
		}

		if (pdesc->flags & PFOR_USEHWMS) {
			if (fread(pdesc->hwms, 1, sizeof (pdesc->hwms), wfp) !=
			    sizeof (pdesc->hwms)) {
				pdesc->flags &= ~PFOR_USEHWMS;
			}
		}
	}
	return (pdesc);
}

int
PWClose(PWDICT *pwp)
{
	if (pwp->header.pih_magic != PIH_MAGIC) {
		return (-1);
	}

	if (pwp->flags & PFOR_WRITE) {
		pwp->flags |= PFOR_FLUSH;
		(void) PutPW(pwp, (char *)0);	/* flush last index if necess */

		if (fseek(pwp->ifp, 0L, 0)) {
			return (-1);
		}

		if (!fwrite((char *)&pwp->header, sizeof (pwp->header),
		    1, pwp->ifp)) {
			return (-1);
		}

		if (pwp->flags & PFOR_USEHWMS) {
			int i;
			for (i = 1; i <= 0xff; i++) {
				if (!pwp->hwms[i]) {
					pwp->hwms[i] = pwp->hwms[i-1];
				}
			}
			(void) fwrite(pwp->hwms, 1, sizeof (pwp->hwms),
			    pwp->wfp);
		}
	}

	(void) fclose(pwp->ifp);
	(void) fclose(pwp->dfp);
	(void) fclose(pwp->wfp);

	pwp->header.pih_magic = 0;

	free(pwp);

	return (0);
}

int
PutPW(PWDICT *pwp, char *string)
{
	if (!(pwp->flags & PFOR_WRITE)) {
		return (-1);
	}

	if (string) {
		(void) strncpy(pwp->data[pwp->count], string, MAXWORDLEN);
		pwp->data[pwp->count][MAXWORDLEN - 1] = '\0';

		pwp->hwms[string[0] & 0xff] = pwp->header.pih_numwords;

		++(pwp->count);
		++(pwp->header.pih_numwords);

	} else if (!(pwp->flags & PFOR_FLUSH)) {
		return (-1);
	}

	if ((pwp->flags & PFOR_FLUSH) || !(pwp->count % NUMWORDS)) {
		int i;
		uint32_t datum;
		register char *ostr;

		datum = (uint32_t)ftell(pwp->dfp);

		(void) fwrite((char *)&datum, sizeof (datum), 1, pwp->ifp);

		(void) fputs(pwp->data[0], pwp->dfp);
		(void) putc(0, pwp->dfp);

		ostr = pwp->data[0];

		for (i = 1; i < NUMWORDS; i++) {
			register int j;
			register char *nstr;

			nstr = pwp->data[i];

			if (nstr[0]) {
				for (j = 0; ostr[j] && nstr[j] &&
				    (ostr[j] == nstr[j]); j++)
					;
				(void) putc(j & 0xff, pwp->dfp);
				(void) fputs(nstr + j, pwp->dfp);
			}
			(void) putc(0, pwp->dfp);

			ostr = nstr;
		}

		(void) memset(pwp->data, '\0', sizeof (pwp->data));
		pwp->count = 0;
	}
	return (0);
}

char *
GetPW(PWDICT *pwp, uint32_t number)
{
	uint32_t datum;
	register int i;
	register char *ostr;
	register char *nstr;
	register char *bptr;
	char buffer[NUMWORDS * MAXWORDLEN];
	static char data[NUMWORDS][MAXWORDLEN];
	static uint32_t prevblock = 0xffffffff;
	uint32_t thisblock;

	thisblock = number / NUMWORDS;

	if (prevblock == thisblock) {
		return (data[number % NUMWORDS]);
	}

	if (fseek(pwp->ifp, sizeof (struct pi_header) +
	    (thisblock * sizeof (uint32_t)), 0)) {
		return (NULL);
	}

	if (!fread((char *)&datum, sizeof (datum), 1, pwp->ifp)) {
		return (NULL);
	}

	if (fseek(pwp->dfp, datum, 0)) {
		return (NULL);
	}

	if (!fread(buffer, 1, sizeof (buffer), pwp->dfp)) {
		return (NULL);
	}

	prevblock = thisblock;

	bptr = buffer;

	for (ostr = data[0]; *(ostr++) = *(bptr++); /* nothing */)
		;

	ostr = data[0];

	for (i = 1; i < NUMWORDS; i++) {
		nstr = data[i];
		(void) strcpy(nstr, ostr);
		ostr = nstr + *(bptr++);
		while (*(ostr++) = *(bptr++))
			;

		ostr = nstr;
	}

	return (data[number % NUMWORDS]);
}

uint32_t
FindPW(PWDICT *pwp, char *string)
{
	int lwm;
	int hwm;
	int idx;

	if (string == NULL)
		return (PW_WORDS(pwp));

	if (pwp->flags & PFOR_USEHWMS) {
		idx = string[0] & 0xff;
		lwm = idx ? pwp->hwms[idx - 1] : 0;
		hwm = pwp->hwms[idx];
	} else {
		lwm = 0;
		hwm = PW_WORDS(pwp) - 1;
	}

	for (;;) {
		int cmp;
		int pivot;
		char *this;

		pivot = lwm + ((hwm+1)-lwm)/2;

		if (feof(pwp->ifp) && feof(pwp->dfp) && feof(pwp->wfp))
			break;

		if ((this = GetPW(pwp, pivot)) == NULL)
			break;

		cmp = strcmp(string, this);		/* INLINE ? */

		if (cmp == 0)
			return (pivot);
		else if (cmp < 0)
			hwm = pivot-1;
		else
			lwm = pivot+1;

		if (lwm > hwm)	/* searched all; not found */
			break;
	}

	/* not found */
	return (PW_WORDS(pwp));
}