/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/* Copyright (c) 1981 Regents of the University of California */

#include <stdio.h>      /* BUFSIZ: stdio = 1024, VMUNIX = 1024 */
#ifndef TRACE
#undef  NULL
#endif

#include "ex.h"
#include "ex_temp.h"
#include "ex_tty.h"
#include "ex_tune.h"
#include <pwd.h>
#include <locale.h>
#include <dirent.h>
#include <unistd.h>
#include <errno.h>

#define DIRSIZ  MAXNAMLEN

short tfile = -1;       /* ditto */

/*
 *
 * This program searches through the specified directory and then
 * the directory usrpath(preserve) looking for an instance of the specified
 * file from a crashed editor or a crashed system.
 * If this file is found, it is unscrambled and written to
 * the standard output.
 *
 * If this program terminates without a "broken pipe" diagnostic
 * (i.e. the editor doesn't die right away) then the buffer we are
 * writing from is removed when we finish.  This is potentially a mistake
 * as there is not enough handshaking to guarantee that the file has actually
 * been recovered, but should suffice for most cases.
 */

/*
 * This directory definition also appears (obviously) in expreserve.c.
 * Change both if you change either.
 */
unsigned char   mydir[PATH_MAX+1];

/*
 * Limit on the number of printed entries
 * when an, e.g. ``ex -r'' command is given.
 */
#define NENTRY  50

unsigned char   nb[BUFSIZE];
int     vercnt;                 /* Count number of versions of file found */
void rputfile(void);
void rsyserror(void);
void searchdir(unsigned char *);
void scrapbad(void);
void findtmp(unsigned char *);
void listfiles(unsigned char *);

int
main(int argc, char *argv[])
{
        unsigned char string[50];
        unsigned char *cp;
        int c, b, i;
        int rflg = 0, errflg = 0;
        int label;
        line *tmpadr;
        extern unsigned char *mypass();
        struct passwd *pp = getpwuid(getuid());
        unsigned char rmcmd[PATH_MAX+1];

        (void)setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void)textdomain(TEXT_DOMAIN);
        cp = string;
        strcpy(mydir, USRPRESERVE);
        if (pp == NULL) {
                fprintf(stderr, gettext("Unable to get user's id\n"));
                exit(-1);
        }
        strcat(mydir, pp->pw_name);

        /*
         * Initialize as though the editor had just started.
         */
        fendcore = (line *) sbrk(0);
        dot = zero = dol = fendcore;
        one = zero + 1;
        endcore = fendcore - 2;
        iblock = oblock = -1;

        while ((c=getopt(argc, (char **)argv, "rx")) != EOF)
                switch (c) {
                        case 'r':
                                rflg++;
                                break;

                        case 'x':
                                xflag++;
                                break;

                        case '?':
                                errflg++;
                                break;
                }
        argc -= optind;
        argv = &argv[optind];

        if (errflg)
                exit(2);

        /*
         * If given only a -r argument, then list the saved files.
         * (NOTE: single -r argument is scheduled to be replaced by -L).
         */
        if (rflg && argc == 0) {
                fprintf(stderr,"%s:\n", mydir);
                listfiles(mydir);
                fprintf(stderr,"%s:\n", TMPDIR);
                listfiles((unsigned char *)TMPDIR);
                exit(0);
        }

        if (argc != 2)
                error(gettext(" Wrong number of arguments to exrecover"), 0);

        CP(file, argv[1]);

        /*
         * Search for this file.
         */
        findtmp((unsigned char *)argv[0]);

        /*
         * Got (one of the versions of) it, write it back to the editor.
         */
        (void)cftime((char *)cp, "%a %h %d %T", &H.Time);
        fprintf(stderr, vercnt > 1 ?
                gettext(" [Dated: %s, newest of %d saved]") :
                gettext(" [Dated: %s]"), cp, vercnt);
        fprintf(stderr, "\r\n");

        if(H.encrypted) {
                if(xflag) {
                        kflag = run_setkey(perm, (unsigned char *)getenv("CrYpTkEy"));
                } else
                        kflag = run_setkey(perm, mypass("Enter key:"));
                if(kflag == -1) {
                        kflag = 0;
                        xflag = 0;
                        fprintf(stderr,gettext("Encryption facility not available\n"));
                        exit(-1);
                }
                xtflag = 1;
                if (makekey(tperm) != 0) {
                        xtflag = 0;
                        fprintf(stderr,gettext("Warning--Cannot encrypt temporary buffer\n"));
                        exit(-1);
                }
        }
        fprintf(stderr,gettext("\r\n [Hit return to continue]"));
        fflush(stderr);
        setbuf(stdin, (char *)NULL);
        while((c = getchar()) != '\n' && c != '\r');
        H.Flines++;

        /*
         * Allocate space for the line pointers from the temp file.
         */
        if ((int) sbrk((int) (H.Flines * sizeof (line))) == -1)
                error(gettext(" Not enough core for lines"), 0);
#ifdef DEBUG
        fprintf(stderr, "%d lines\n", H.Flines);
#endif

        /*
         * Now go get the blocks of seek pointers which are scattered
         * throughout the temp file, reconstructing the incore
         * line pointers at point of crash.
         */
        b = 0;
        while (H.Flines > 0) {
                (void)lseek(tfile, (long) blocks[b] * BUFSIZE, 0);
                i = H.Flines < BUFSIZE / sizeof (line) ?
                        H.Flines * sizeof (line) : BUFSIZE;
                if (read(tfile, (char *) dot, i) != i) {
                        perror((char *)nb);
                        exit(1);
                }
                dot += i / sizeof (line);
                H.Flines -= i / sizeof (line);
                b++;
        }
        dot--; dol = dot;

        /*
         * Due to sandbagging some lines may really not be there.
         * Find and discard such.  This shouldn't happen often.
         */
        scrapbad();


        /*
         * Now if there were any lines in the recovered file
         * write them to the standard output.
         */
        if (dol > zero) {
                addr1 = one; addr2 = dol; io = 1;
                rputfile();
        }
        /*
         * Trash the saved buffer.
         * Hopefully the system won't crash before the editor
         * syncs the new recovered buffer; i.e. for an instant here
         * you may lose if the system crashes because this file
         * is gone, but the editor hasn't completed reading the recovered
         * file from the pipe from us to it.
         *
         * This doesn't work if we are coming from an non-absolute path
         * name since we may have chdir'ed but what the hay, noone really
         * ever edits with temporaries in "." anyways.
         */
        if (nb[0] == '/') {
                (void)unlink((const char *)nb);
                sprintf((char *)rmcmd, "rmdir %s 2> /dev/null", (char *)mydir);
                system((char *)rmcmd);
        }
        return (0);
}

/*
 * Print an error message (notably not in error
 * message file).  If terminal is in RAW mode, then
 * we should be writing output for "vi", so don't print
 * a newline which would mess up the screen.
 */
/*VARARGS2*/
void
error(str, inf)
        unsigned char *str;
        int inf;
{

        struct termio termio;
        if (inf)
                fprintf(stderr, (char *)str, inf);
        else
                fprintf(stderr, (char *)str);

        ioctl(2, TCGETA, &termio);
        if (termio.c_lflag & ICANON)
                fprintf(stderr, "\n");
        exit(1);
}

/*
 * Here we save the information about files, when
 * you ask us what files we have saved for you.
 * We buffer file name, number of lines, and the time
 * at which the file was saved.
 */
struct svfile {
        unsigned char   sf_name[FNSIZE + 1];
        int     sf_lines;
        unsigned char   sf_entry[DIRSIZ + 1];
        time_t  sf_time;
        short   sf_encrypted;
};
void enter(struct svfile *, unsigned char *, int);

void
listfiles(unsigned char *dirname)
{
        DIR *dir;
        struct dirent64 *direntry;
        int ecount, qucmp();
        int f;
        unsigned char cp[50];
        unsigned char cp2[50];
        unsigned char *filname;
        struct svfile *fp, svbuf[NENTRY];

        /*
         * Open usrpath(preserve), and go there to make things quick.
         */
        if ((dir = opendir((char *)dirname)) == NULL)
        {
                fprintf(stderr,gettext("No files saved.\n"));
                return;
        }
        if (chdir((const char *)dirname) < 0) {
                perror((char *)dirname);
                return;
        }

        /*
         * Look at the candidate files in usrpath(preserve).
         */
        fp = &svbuf[0];
        ecount = 0;
        while ((direntry = readdir64(dir)) != NULL)
        {
                filname = (unsigned char *)direntry->d_name;
                if (filname[0] != 'E')
                        continue;
#ifdef DEBUG
                fprintf(stderr, "considering %s\n", filname);
#endif
                /*
                 * Name begins with E; open it and
                 * make sure the uid in the header is our uid.
                 * If not, then don't bother with this file, it can't
                 * be ours.
                 */
                f = open(filname, 0);
                if (f < 0) {
#ifdef DEBUG
                        fprintf(stderr, "open failed\n");
#endif
                        continue;
                }
                if (read(f, (char *) &H, sizeof H) != sizeof H) {
#ifdef DEBUG
                        fprintf(stderr, "could not read header\n");
#endif
                        (void)close(f);
                        continue;
                }
                (void)close(f);
                if (getuid() != H.Uid) {
#ifdef DEBUG
                        fprintf(stderr, "uid wrong\n");
#endif
                        continue;
                }

                /*
                 * Saved the day!
                 */
                enter(fp++, filname, ecount);
                ecount++;
#ifdef DEBUG
                fprintf(stderr, "entered file %s\n", filname);
#endif
        }
        (void)closedir(dir);
        /*
         * If any files were saved, then sort them and print
         * them out.
         */
        if (ecount == 0) {
                fprintf(stderr, gettext("No files saved.\n"));
                return;
        }
        qsort(&svbuf[0], ecount, sizeof svbuf[0], qucmp);
        for (fp = &svbuf[0]; fp < &svbuf[ecount]; fp++) {
                (void)cftime((char *)cp, "%a %b %d", &fp->sf_time);
                (void)cftime((char *)cp2, "%R", &fp->sf_time);
                fprintf(stderr,
                    gettext("On %s at %s, saved %d lines of file \"%s\" "),
                    cp, cp2, fp->sf_lines, fp->sf_name);
                fprintf(stderr, "%s\n",
                    (fp->sf_encrypted) ? gettext("[ENCRYPTED]") : "");
        }
}

/*
 * Enter a new file into the saved file information.
 */
void
enter(struct svfile *fp, unsigned char *fname, int count)
{
        unsigned char *cp, *cp2;
        struct svfile *f, *fl;
        time_t curtime;

        f = 0;
        if (count >= NENTRY) {
                /*
                 * Trash the oldest as the most useless.
                 */
                fl = fp - count + NENTRY - 1;
                curtime = fl->sf_time;
                for (f = fl; --f > fp-count; )
                        if (f->sf_time < curtime)
                                curtime = f->sf_time;
                for (f = fl; --f > fp-count; )
                        if (f->sf_time == curtime)
                                break;
                fp = f;
        }

        /*
         * Gotcha.
         */
        fp->sf_time = H.Time;
        fp->sf_lines = H.Flines;
        fp->sf_encrypted = H.encrypted;
        for (cp2 = fp->sf_name, cp = savedfile; *cp;)
                *cp2++ = *cp++;
        *cp2++ = 0;
        for (cp2 = fp->sf_entry, cp = fname; *cp && cp-fname < 14;)
                *cp2++ = *cp++;
        *cp2++ = 0;
}

/*
 * Do the qsort compare to sort the entries first by file name,
 * then by modify time.
 */
int
qucmp(struct svfile *p1, struct svfile *p2)
{
        int t;

        if (t = strcmp(p1->sf_name, p2->sf_name))
                return(t);
        if (p1->sf_time > p2->sf_time)
                return(-1);
        return(p1->sf_time < p2->sf_time);
}

/*
 * Scratch for search.
 */
unsigned char   bestnb[BUFSIZE];                /* Name of the best one */
long    besttime = 0;           /* Time at which the best file was saved */
int     bestfd;                 /* Keep best file open so it dont vanish */

/*
 * Look for a file, both in the users directory option value
 * (i.e. usually /tmp) and in usrpath(preserve).
 * Want to find the newest so we search on and on.
 */
void
findtmp(unsigned char *dir)
{

        /*
         * No name or file so far.
         */
        bestnb[0] = 0;
        bestfd = -1;

        /*
         * Search usrpath(preserve) and, if we can get there, /tmp
         * (actually the user's "directory" option).
         */
        searchdir(dir);
        if (chdir((const char *)mydir) == 0)
                searchdir(mydir);
        if (bestfd != -1) {
                /*
                 * Gotcha.
                 * Put the file (which is already open) in the file
                 * used by the temp file routines, and save its
                 * name for later unlinking.
                 */
                tfile = bestfd;
                CP(nb, bestnb);
                (void)lseek(tfile, 0l, 0);

                /*
                 * Gotta be able to read the header or fall through
                 * to lossage.
                 */
                if (read(tfile, (char *) &H, sizeof H) == sizeof H)
                        return;
        }

        /*
         * Extreme lossage...
         */
        error((unsigned char *)gettext(" File not found"), 0);
}

/*
 * Search for the file in directory dirname.
 *
 * Don't chdir here, because the users directory
 * may be ".", and we would move away before we searched it.
 * Note that we actually chdir elsewhere (because it is too slow
 * to look around in usrpath(preserve) without chdir'ing there) so we
 * can't win, because we don't know the name of '.' and if the path
 * name of the file we want to unlink is relative, rather than absolute
 * we won't be able to find it again.
 */
void
searchdir(unsigned char *dirname)
{
        struct dirent64 *direntry;
        DIR *dir;
        unsigned char dbuf[BUFSIZE];
        unsigned char *filname;
        if ((dir = opendir((char *)dirname)) == NULL)
                return;
        while ((direntry = readdir64(dir)) != NULL)
        {
                filname = (unsigned char *)direntry->d_name;
                if (filname[0] != 'E' || filname[1] != 'x')
                        continue;
                /*
                 * Got a file in the directory starting with Ex...
                 * Save a consed up name for the file to unlink
                 * later, and check that this is really a file
                 * we are looking for.
                 */
                (void)strcat(strcat(strcpy(nb, dirname), "/"), filname);
                if (yeah(nb)) {
                        /*
                         * Well, it is the file we are looking for.
                         * Is it more recent than any version we found before?
                         */
                        if (H.Time > besttime) {
                                /*
                                 * A winner.
                                 */
                                (void)close(bestfd);
                                bestfd = dup(tfile);
                                besttime = H.Time;
                                CP(bestnb, nb);
                        }
                        /*
                         * Count versions and tell user
                         */
                        vercnt++;
                }
                (void)close(tfile);
        }
        (void)closedir(dir);
}

/*
 * Given a candidate file to be recovered, see
 * if it's really an editor temporary and of this
 * user and the file specified.
 */
int
yeah(unsigned char *name)
{

        tfile = open(name, 2);
        if (tfile < 0)
                return (0);
        if (read(tfile, (char *) &H, sizeof H) != sizeof H) {
nope:
                (void)close(tfile);
                return (0);
        }
        if (!eq(savedfile, file))
                goto nope;
        if (getuid() != H.Uid)
                goto nope;
        /*
         * Old code: puts a word LOST in the header block, so that lost lines
         * can be made to point at it.
         */
        (void)lseek(tfile, (long)(BUFSIZE*HBLKS-8), 0);
        (void)write(tfile, "LOST", 5);
        return (1);
}

/*
 * Find the true end of the scratch file, and ``LOSE''
 * lines which point into thin air.  This lossage occurs
 * due to the sandbagging of i/o which can cause blocks to
 * be written in a non-obvious order, different from the order
 * in which the editor tried to write them.
 *
 * Lines which are lost are replaced with the text LOST so
 * they are easy to find.  We work hard at pretty formatting here
 * as lines tend to be lost in blocks.
 *
 * This only seems to happen on very heavily loaded systems, and
 * not very often.
 */
void
scrapbad(void)
{
        line *ip;
        struct stat64 stbuf;
        off_t size, maxt;
        int bno, cnt, bad, was;
        unsigned char bk[BUFSIZE];

        (void)fstat64(tfile, &stbuf);
        size = (off_t)stbuf.st_size;
        maxt = (size >> SHFT) | (BNDRY-1);
        bno = (maxt >> OFFBTS) & BLKMSK;
#ifdef DEBUG
        fprintf(stderr, "size %ld, maxt %o, bno %d\n", size, maxt, bno);
#endif

        /*
         * Look for a null separating two lines in the temp file;
         * if last line was split across blocks, then it is lost
         * if the last block is.
         */
        while (bno > 0) {
                (void)lseek(tfile, (long) BUFSIZE * bno, 0);
                cnt = read(tfile, (char *) bk, BUFSIZE);
        if(xtflag)
                if (run_crypt(0L, bk, CRSIZE, tperm) == -1)
                    rsyserror();
#ifdef DEBUG
        fprintf(stderr,"UNENCRYPTED: BLK %d\n",bno);
#endif
                while (cnt > 0)
                        if (bk[--cnt] == 0)
                                goto null;
                bno--;
        }
null:

        /*
         * Magically calculate the largest valid pointer in the temp file,
         * consing it up from the block number and the count.
         */
        maxt = ((bno << OFFBTS) | (cnt >> SHFT)) & ~1;
#ifdef DEBUG
        fprintf(stderr, "bno %d, cnt %d, maxt %o\n", bno, cnt, maxt);
#endif

        /*
         * Now cycle through the line pointers,
         * trashing the Lusers.
         */
        was = bad = 0;
        for (ip = one; ip <= dol; ip++)
                if (*ip > maxt) {
#ifdef DEBUG
                        fprintf(stderr, "%d bad, %o > %o\n", ip - zero, *ip, maxt);
#endif
                        if (was == 0)
                                was = ip - zero;
                        *ip = ((HBLKS*BUFSIZE)-8) >> SHFT;
                } else if (was) {
                        if (bad == 0)
                                fprintf(stderr, gettext(" [Lost line(s):"));
                        fprintf(stderr, " %d", was);
                        if ((ip - 1) - zero > was)
                                fprintf(stderr, "-%d", (ip - 1) - zero);
                        bad++;
                        was = 0;
                }
        if (was != 0) {
                if (bad == 0)
                        fprintf(stderr, " [Lost line(s):");
                fprintf(stderr, " %d", was);
                if (dol - zero != was)
                        fprintf(stderr, "-%d", dol - zero);
                bad++;
        }
        if (bad)
                fprintf(stderr, "]");
}

int     cntch, cntln, cntodd, cntnull;
/*
 * Following routines stolen mercilessly from ex.
 */
void
rputfile(void)
{
        line *a1;
        unsigned char *fp, *lp;
        int nib;

        a1 = addr1;
        clrstats();
        cntln = addr2 - a1 + 1;
        if (cntln == 0)
                return;
        nib = BUFSIZE;
        fp = genbuf;
        do {
#ifdef DEBUG
                fprintf(stderr,"GETTING A LINE \n");
#endif
                getaline(*a1++);
                lp = linebuf;
#ifdef DEBUG
                fprintf(stderr,"LINE:%s\n",linebuf);
#endif
                for (;;) {
                        if (--nib < 0) {
                                nib = fp - genbuf;
                                if (write(io, genbuf, nib) != nib)
                                        wrerror();
                                cntch += nib;
                                nib = BUFSIZE;
                                fp = genbuf;
                        }
                        if ((*fp++ = *lp++) == 0) {
                                fp[-1] = '\n';
                                break;
                        }
                }
        } while (a1 <= addr2);
        nib = fp - genbuf;
        if (write(io, genbuf, nib) != nib)
                wrerror();
        cntch += nib;
}

void
wrerror(void)
{

        rsyserror();
}

void
clrstats(void)
{

        ninbuf = 0;
        cntch = 0;
        cntln = 0;
        cntnull = 0;
        cntodd = 0;
}

#define READ    0
#define WRITE   1

void
getaline(line tl)
{
        unsigned char *bp, *lp;
        int nl;

        lp = linebuf;
        bp = getblock(tl);
        nl = nleft;
        tl &= ~OFFMSK;
        while (*lp++ = *bp++)
                if (--nl == 0) {
                        bp = getblock(tl += INCRMT);
                        nl = nleft;
                }
}

int     read();
int     write();

unsigned char *
getblock(atl)
        line atl;
{
        int bno, off;
        unsigned char *p1, *p2;
        int n;

        bno = (atl >> OFFBTS) & BLKMSK;
#ifdef DEBUG
        fprintf(stderr,"GETBLOCK: BLK %d\n",bno);
#endif
        off = (atl << SHFT) & LBTMSK;
        if (bno >= NMBLKS)
                error((unsigned char *)gettext(" Tmp file too large"));
        nleft = BUFSIZE - off;
        if (bno == iblock)
                return (ibuff + off);
        iblock = bno;
        blkio(bno, ibuff, read);
        if(xtflag)
                if (run_crypt(0L, ibuff, CRSIZE, tperm) == -1)
                    rsyserror();
#ifdef DEBUG
        fprintf(stderr,"UNENCRYPTED: BLK %d\n",bno);
#endif
        return (ibuff + off);
}

void
blkio(short b, unsigned char *buf, int (*iofcn)())
{

        int rc;
        lseek(tfile, (long) (unsigned) b * BUFSIZE, 0);
        if ((rc =(*iofcn)(tfile, buf, BUFSIZE)) != BUFSIZE) {
                (void)fprintf(stderr,gettext("Failed on BLK: %d with %d/%d\n"),b,rc,BUFSIZE);
                perror("");
                rsyserror();
        }
}

void
rsyserror(void)
{
        int save_err = errno;

        dirtcnt = 0;
        write(2, " ", 1);
        error(strerror(save_err));
        exit(1);
}

static int intrupt;

static void catch();

unsigned char *
mypass(prompt)
unsigned char   *prompt;
{
        struct termio ttyb;
        unsigned short flags;
        unsigned char *p;
        int c;
        static unsigned char pbuf[9];
        void    (*sig)();

        setbuf(stdin, (char*)NULL);
        sig = signal(SIGINT, catch);
        intrupt = 0;
        (void) ioctl(fileno(stdin), TCGETA, &ttyb);
        flags = ttyb.c_lflag;
        ttyb.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
        (void) ioctl(fileno(stdin), TCSETAF, &ttyb);
        (void) fputs((char *)prompt, stderr);
        for(p=pbuf; !intrupt && (c = getc(stdin)) != '\n' && c!= '\r' && c != EOF; ) {
                if(p < &pbuf[8])
                        *p++ = c;
        }
        *p = '\0';
        (void) putc('\n', stderr);
        ttyb.c_lflag = flags;
        (void) ioctl(fileno(stdin), TCSETA, &ttyb);
        (void) signal(SIGINT, sig);
        if(intrupt)
                (void) kill(getpid(), SIGINT);
        return(pbuf);
}

static void
catch()
{
        ++intrupt;
}