contrib/nvi/common/recover.c

   1 /*-
   2  * Copyright (c) 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1993, 1994, 1995, 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #ifndef lint
  13 static const char sccsid[] = "$Id: recover.c,v 11.3 2015/04/04 03:50:42 zy Exp $";
  14 #endif /* not lint */
  15
  16 #include <sys/types.h>
  17 #include <sys/queue.h>
  18 #include <sys/stat.h>
  19
  20 /*
  21  * We include <sys/file.h>, because the open #defines were found there
  22  * on historical systems.  We also include <fcntl.h> because the open(2)
  23  * #defines are found there on newer systems.
  24  */
  25 #include <sys/file.h>
  26
  27 #include <bitstring.h>
  28 #include <dirent.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <limits.h>
  32 #include <pwd.h>
  33 #include <netinet/in.h>         /* Required by resolv.h. */
  34 #include <resolv.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <time.h>
  39 #include <unistd.h>
  40
  41 #include "../ex/version.h"
  42 #include "common.h"
  43 #include "pathnames.h"
  44
  45 /*
  46  * Recovery code.
  47  *
  48  * The basic scheme is as follows.  In the EXF structure, we maintain full
  49  * paths of a b+tree file and a mail recovery file.  The former is the file
  50  * used as backing store by the DB package.  The latter is the file that
  51  * contains an email message to be sent to the user if we crash.  The two
  52  * simple states of recovery are:
  53  *
  54  *      + first starting the edit session:
  55  *              the b+tree file exists and is mode 700, the mail recovery
  56  *              file doesn't exist.
  57  *      + after the file has been modified:
  58  *              the b+tree file exists and is mode 600, the mail recovery
  59  *              file exists, and is exclusively locked.
  60  *
  61  * In the EXF structure we maintain a file descriptor that is the locked
  62  * file descriptor for the mail recovery file.
  63  *
  64  * To find out if a recovery file/backing file pair are in use, try to get
  65  * a lock on the recovery file.
  66  *
  67  * To find out if a backing file can be deleted at boot time, check for an
  68  * owner execute bit.  (Yes, I know it's ugly, but it's either that or put
  69  * special stuff into the backing file itself, or correlate the files at
  70  * boot time, neither of which looks like fun.)  Note also that there's a
  71  * window between when the file is created and the X bit is set.  It's small,
  72  * but it's there.  To fix the window, check for 0 length files as well.
  73  *
  74  * To find out if a file can be recovered, check the F_RCV_ON bit.  Note,
  75  * this DOES NOT mean that any initialization has been done, only that we
  76  * haven't yet failed at setting up or doing recovery.
  77  *
  78  * To preserve a recovery file/backing file pair, set the F_RCV_NORM bit.
  79  * If that bit is not set when ending a file session:
  80  *      If the EXF structure paths (rcv_path and rcv_mpath) are not NULL,
  81  *      they are unlink(2)'d, and free(3)'d.
  82  *      If the EXF file descriptor (rcv_fd) is not -1, it is closed.
  83  *
  84  * The backing b+tree file is set up when a file is first edited, so that
  85  * the DB package can use it for on-disk caching and/or to snapshot the
  86  * file.  When the file is first modified, the mail recovery file is created,
  87  * the backing file permissions are updated, the file is sync(2)'d to disk,
  88  * and the timer is started.  Then, at RCV_PERIOD second intervals, the
  89  * b+tree file is synced to disk.  RCV_PERIOD is measured using SIGALRM, which
  90  * means that the data structures (SCR, EXF, the underlying tree structures)
  91  * must be consistent when the signal arrives.
  92  *
  93  * The recovery mail file contains normal mail headers, with two additional
  94  *
  95  *      X-vi-data: <file|path>;<base64 encoded path>
  96  *
  97  * MIME headers; the folding character is limited to ' '.
  98  *
  99  * Btree files are named "vi.XXXXXX" and recovery files are named
 100  * "recover.XXXXXX".
 101  */
 102
 103 #define VI_DHEADER      "X-vi-data:"
 104
 105 static int       rcv_copy(SCR *, int, char *);
 106 static void      rcv_email(SCR *, char *);
 107 static int       rcv_mailfile(SCR *, int, char *);
 108 static int       rcv_mktemp(SCR *, char *, char *);
 109 static int       rcv_dlnwrite(SCR *, const char *, const char *, FILE *);
 110 static int       rcv_dlnread(SCR *, char **, char **, FILE *);
 111
 112 /*
 113  * rcv_tmp --
 114  *      Build a file name that will be used as the recovery file.
 115  *
 116  * PUBLIC: int rcv_tmp(SCR *, EXF *, char *);
 117  */
 118 int
 119 rcv_tmp(
 120         SCR *sp,
 121         EXF *ep,
 122         char *name)
 123 {
 124         struct stat sb;
 125         int fd;
 126         char *dp, *path;
 127
 128         /*
 129          * !!!
 130          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
 131          *
 132          *
 133          * If the recovery directory doesn't exist, try and create it.  As
 134          * the recovery files are themselves protected from reading/writing
 135          * by other than the owner, the worst that can happen is that a user
 136          * would have permission to remove other user's recovery files.  If
 137          * the sticky bit has the BSD semantics, that too will be impossible.
 138          */
 139         if (opts_empty(sp, O_RECDIR, 0))
 140                 goto err;
 141         dp = O_STR(sp, O_RECDIR);
 142         if (stat(dp, &sb)) {
 143                 if (errno != ENOENT || mkdir(dp, 0)) {
 144                         msgq(sp, M_SYSERR, "%s", dp);
 145                         goto err;
 146                 }
 147                 (void)chmod(dp, S_IRWXU | S_IRWXG | S_IRWXO | S_ISVTX);
 148         }
 149
 150         if ((path = join(dp, "vi.XXXXXX")) == NULL)
 151                 goto err;
 152         if ((fd = rcv_mktemp(sp, path, dp)) == -1) {
 153                 free(path);
 154                 goto err;
 155         }
 156         (void)fchmod(fd, S_IRWXU);
 157         (void)close(fd);
 158
 159         ep->rcv_path = path;
 160         if (0) {
 161 err:            msgq(sp, M_ERR,
 162                     "056|Modifications not recoverable if the session fails");
 163                 return (1);
 164         }
 165
 166         /* We believe the file is recoverable. */
 167         F_SET(ep, F_RCV_ON);
 168         return (0);
 169 }
 170
 171 /*
 172  * rcv_init --
 173  *      Force the file to be snapshotted for recovery.
 174  *
 175  * PUBLIC: int rcv_init(SCR *);
 176  */
 177 int
 178 rcv_init(SCR *sp)
 179 {
 180         EXF *ep;
 181         recno_t lno;
 182
 183         ep = sp->ep;
 184
 185         /* Only do this once. */
 186         F_CLR(ep, F_FIRSTMODIFY);
 187
 188         /* If we already know the file isn't recoverable, we're done. */
 189         if (!F_ISSET(ep, F_RCV_ON))
 190                 return (0);
 191
 192         /* Turn off recoverability until we figure out if this will work. */
 193         F_CLR(ep, F_RCV_ON);
 194
 195         /* Test if we're recovering a file, not editing one. */
 196         if (ep->rcv_mpath == NULL) {
 197                 /* Build a file to mail to the user. */
 198                 if (rcv_mailfile(sp, 0, NULL))
 199                         goto err;
 200
 201                 /* Force a read of the entire file. */
 202                 if (db_last(sp, &lno))
 203                         goto err;
 204
 205                 /* Turn on a busy message, and sync it to backing store. */
 206                 sp->gp->scr_busy(sp,
 207                     "057|Copying file for recovery...", BUSY_ON);
 208                 if (ep->db->sync(ep->db, R_RECNOSYNC)) {
 209                         msgq_str(sp, M_SYSERR, ep->rcv_path,
 210                             "058|Preservation failed: %s");
 211                         sp->gp->scr_busy(sp, NULL, BUSY_OFF);
 212                         goto err;
 213                 }
 214                 sp->gp->scr_busy(sp, NULL, BUSY_OFF);
 215         }
 216
 217         /* Turn off the owner execute bit. */
 218         (void)chmod(ep->rcv_path, S_IRUSR | S_IWUSR);
 219
 220         /* We believe the file is recoverable. */
 221         F_SET(ep, F_RCV_ON);
 222         return (0);
 223
 224 err:    msgq(sp, M_ERR,
 225             "059|Modifications not recoverable if the session fails");
 226         return (1);
 227 }
 228
 229 /*
 230  * rcv_sync --
 231  *      Sync the file, optionally:
 232  *              flagging the backup file to be preserved
 233  *              snapshotting the backup file and send email to the user
 234  *              sending email to the user if the file was modified
 235  *              ending the file session
 236  *
 237  * PUBLIC: int rcv_sync(SCR *, u_int);
 238  */
 239 int
 240 rcv_sync(
 241         SCR *sp,
 242         u_int flags)
 243 {
 244         EXF *ep;
 245         int fd, rval;
 246         char *dp, *buf;
 247
 248         /* Make sure that there's something to recover/sync. */
 249         ep = sp->ep;
 250         if (ep == NULL || !F_ISSET(ep, F_RCV_ON))
 251                 return (0);
 252
 253         /* Sync the file if it's been modified. */
 254         if (F_ISSET(ep, F_MODIFIED)) {
 255                 if (ep->db->sync(ep->db, R_RECNOSYNC)) {
 256                         F_CLR(ep, F_RCV_ON | F_RCV_NORM);
 257                         msgq_str(sp, M_SYSERR,
 258                             ep->rcv_path, "060|File backup failed: %s");
 259                         return (1);
 260                 }
 261
 262                 /* REQUEST: don't remove backing file on exit. */
 263                 if (LF_ISSET(RCV_PRESERVE))
 264                         F_SET(ep, F_RCV_NORM);
 265
 266                 /* REQUEST: send email. */
 267                 if (LF_ISSET(RCV_EMAIL))
 268                         rcv_email(sp, ep->rcv_mpath);
 269         }
 270
 271         /*
 272          * !!!
 273          * Each time the user exec's :preserve, we have to snapshot all of
 274          * the recovery information, i.e. it's like the user re-edited the
 275          * file.  We copy the DB(3) backing file, and then create a new mail
 276          * recovery file, it's simpler than exiting and reopening all of the
 277          * underlying files.
 278          *
 279          * REQUEST: snapshot the file.
 280          */
 281         rval = 0;
 282         if (LF_ISSET(RCV_SNAPSHOT)) {
 283                 if (opts_empty(sp, O_RECDIR, 0))
 284                         goto err;
 285                 dp = O_STR(sp, O_RECDIR);
 286                 if ((buf = join(dp, "vi.XXXXXX")) == NULL) {
 287                         msgq(sp, M_SYSERR, NULL);
 288                         goto err;
 289                 }
 290                 if ((fd = rcv_mktemp(sp, buf, dp)) == -1) {
 291                         free(buf);
 292                         goto err;
 293                 }
 294                 sp->gp->scr_busy(sp,
 295                     "061|Copying file for recovery...", BUSY_ON);
 296                 if (rcv_copy(sp, fd, ep->rcv_path) ||
 297                     close(fd) || rcv_mailfile(sp, 1, buf)) {
 298                         (void)unlink(buf);
 299                         (void)close(fd);
 300                         rval = 1;
 301                 }
 302                 free(buf);
 303                 sp->gp->scr_busy(sp, NULL, BUSY_OFF);
 304         }
 305         if (0) {
 306 err:            rval = 1;
 307         }
 308
 309         /* REQUEST: end the file session. */
 310         if (LF_ISSET(RCV_ENDSESSION) && file_end(sp, NULL, 1))
 311                 rval = 1;
 312
 313         return (rval);
 314 }
 315
 316 /*
 317  * rcv_mailfile --
 318  *      Build the file to mail to the user.
 319  */
 320 static int
 321 rcv_mailfile(
 322         SCR *sp,
 323         int issync,
 324         char *cp_path)
 325 {
 326         EXF *ep;
 327         GS *gp;
 328         struct passwd *pw;
 329         int len;
 330         time_t now;
 331         uid_t uid;
 332         int fd;
 333         FILE *fp;
 334         char *dp, *p, *t, *qt, *buf, *mpath;
 335         char *t1, *t2, *t3;
 336         int st;
 337
 338         /*
 339          * XXX
 340          * MAXHOSTNAMELEN/HOST_NAME_MAX are deprecated. We try sysconf(3)
 341          * first, then fallback to _POSIX_HOST_NAME_MAX.
 342          */
 343         char *host;
 344         long hostmax = sysconf(_SC_HOST_NAME_MAX);
 345         if (hostmax < 0)
 346                 hostmax = _POSIX_HOST_NAME_MAX;
 347
 348         gp = sp->gp;
 349         if ((pw = getpwuid(uid = getuid())) == NULL) {
 350                 msgq(sp, M_ERR,
 351                     "062|Information on user id %u not found", uid);
 352                 return (1);
 353         }
 354
 355         if (opts_empty(sp, O_RECDIR, 0))
 356                 return (1);
 357         dp = O_STR(sp, O_RECDIR);
 358         if ((mpath = join(dp, "recover.XXXXXX")) == NULL) {
 359                 msgq(sp, M_SYSERR, NULL);
 360                 return (1);
 361         }
 362         if ((fd = rcv_mktemp(sp, mpath, dp)) == -1) {
 363                 free(mpath);
 364                 return (1);
 365         }
 366         if ((fp = fdopen(fd, "w")) == NULL) {
 367                 free(mpath);
 368                 close(fd);
 369                 return (1);
 370         }
 371
 372         /*
 373          * XXX
 374          * We keep an open lock on the file so that the recover option can
 375          * distinguish between files that are live and those that need to
 376          * be recovered.  There's an obvious window between the mkstemp call
 377          * and the lock, but it's pretty small.
 378          */
 379         ep = sp->ep;
 380         if (file_lock(sp, NULL, fd, 1) != LOCK_SUCCESS)
 381                 msgq(sp, M_SYSERR, "063|Unable to lock recovery file");
 382         if (!issync) {
 383                 /* Save the recover file descriptor, and mail path. */
 384                 ep->rcv_fd = dup(fd);
 385                 ep->rcv_mpath = mpath;
 386                 cp_path = ep->rcv_path;
 387         }
 388
 389         t = sp->frp->name;
 390         if ((p = strrchr(t, '/')) == NULL)
 391                 p = t;
 392         else
 393                 ++p;
 394         (void)time(&now);
 395
 396         if ((st = rcv_dlnwrite(sp, "file", t, fp))) {
 397                 if (st == 1)
 398                         goto werr;
 399                 goto err;
 400         }
 401         if ((st = rcv_dlnwrite(sp, "path", cp_path, fp))) {
 402                 if (st == 1)
 403                         goto werr;
 404                 goto err;
 405         }
 406
 407         MALLOC(sp, host, char *, hostmax + 1);
 408         if (host == NULL)
 409                 goto err;
 410         (void)gethostname(host, hostmax + 1);
 411
 412         len = fprintf(fp, "%s%s%s\n%s%s%s%s\n%s%.40s\n%s\n\n",
 413             "From: root@", host, " (Nvi recovery program)",
 414             "To: ", pw->pw_name, "@", host,
 415             "Subject: Nvi saved the file ", p,
 416             "Precedence: bulk");                /* For vacation(1). */
 417         if (len < 0) {
 418                 free(host);
 419                 goto werr;
 420         }
 421
 422         if ((qt = quote(t)) == NULL) {
 423                 free(host);
 424                 msgq(sp, M_SYSERR, NULL);
 425                 goto err;
 426         }
 427         len = asprintf(&buf, "%s%.24s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n\n",
 428             "On ", ctime(&now), ", the user ", pw->pw_name,
 429             " was editing a file named ", t, " on the machine ",
 430             host, ", when it was saved for recovery. ",
 431             "You can recover most, if not all, of the changes ",
 432             "to this file using the -r option to ", gp->progname, ":\n\n\t",
 433             gp->progname, " -r ", qt);
 434         free(qt);
 435         free(host);
 436         if (buf == NULL) {
 437                 msgq(sp, M_SYSERR, NULL);
 438                 goto err;
 439         }
 440
 441         /*
 442          * Format the message.  (Yes, I know it's silly.)
 443          * Requires that the message end in a <newline>.
 444          */
 445 #define FMTCOLS 60
 446         for (t1 = buf; len > 0; len -= t2 - t1, t1 = t2) {
 447                 /* Check for a short length. */
 448                 if (len <= FMTCOLS) {
 449                         t2 = t1 + (len - 1);
 450                         goto wout;
 451                 }
 452
 453                 /* Check for a required <newline>. */
 454                 t2 = strchr(t1, '\n');
 455                 if (t2 - t1 <= FMTCOLS)
 456                         goto wout;
 457
 458                 /* Find the closest space, if any. */
 459                 for (t3 = t2; t2 > t1; --t2)
 460                         if (*t2 == ' ') {
 461                                 if (t2 - t1 <= FMTCOLS)
 462                                         goto wout;
 463                                 t3 = t2;
 464                         }
 465                 t2 = t3;
 466
 467                 /* t2 points to the last character to display. */
 468 wout:           *t2++ = '\n';
 469
 470                 /* t2 points one after the last character to display. */
 471                 if (fwrite(t1, 1, t2 - t1, fp) != t2 - t1) {
 472                         free(buf);
 473                         goto werr;
 474                 }
 475         }
 476
 477         if (issync) {
 478                 fflush(fp);
 479                 rcv_email(sp, mpath);
 480                 free(mpath);
 481         }
 482         if (fclose(fp)) {
 483                 free(buf);
 484 werr:           msgq(sp, M_SYSERR, "065|Recovery file");
 485                 goto err;
 486         }
 487         free(buf);
 488         return (0);
 489
 490 err:    if (!issync)
 491                 ep->rcv_fd = -1;
 492         if (fp != NULL)
 493                 (void)fclose(fp);
 494         return (1);
 495 }
 496
 497 /*
 498  *      people making love
 499  *      never exactly the same
 500  *      just like a snowflake
 501  *
 502  * rcv_list --
 503  *      List the files that can be recovered by this user.
 504  *
 505  * PUBLIC: int rcv_list(SCR *);
 506  */
 507 int
 508 rcv_list(SCR *sp)
 509 {
 510         struct dirent *dp;
 511         struct stat sb;
 512         DIR *dirp;
 513         FILE *fp;
 514         int found;
 515         char *p, *file, *path;
 516         char *dtype, *data;
 517         int st;
 518
 519         /* Open the recovery directory for reading. */
 520         if (opts_empty(sp, O_RECDIR, 0))
 521                 return (1);
 522         p = O_STR(sp, O_RECDIR);
 523         if (chdir(p) || (dirp = opendir(".")) == NULL) {
 524                 msgq_str(sp, M_SYSERR, p, "recdir: %s");
 525                 return (1);
 526         }
 527
 528         /* Read the directory. */
 529         for (found = 0; (dp = readdir(dirp)) != NULL;) {
 530                 if (strncmp(dp->d_name, "recover.", 8))
 531                         continue;
 532
 533                 /* If it's readable, it's recoverable. */
 534                 if ((fp = fopen(dp->d_name, "r")) == NULL)
 535                         continue;
 536
 537                 switch (file_lock(sp, NULL, fileno(fp), 1)) {
 538                 case LOCK_FAILED:
 539                         /*
 540                          * XXX
 541                          * Assume that a lock can't be acquired, but that we
 542                          * should permit recovery anyway.  If this is wrong,
 543                          * and someone else is using the file, we're going to
 544                          * die horribly.
 545                          */
 546                         break;
 547                 case LOCK_SUCCESS:
 548                         break;
 549                 case LOCK_UNAVAIL:
 550                         /* If it's locked, it's live. */
 551                         (void)fclose(fp);
 552                         continue;
 553                 }
 554
 555                 /* Check the headers. */
 556                 for (file = NULL, path = NULL;
 557                     file == NULL || path == NULL;) {
 558                         if ((st = rcv_dlnread(sp, &dtype, &data, fp))) {
 559                                 if (st == 1)
 560                                         msgq_str(sp, M_ERR, dp->d_name,
 561                                             "066|%s: malformed recovery file");
 562                                 goto next;
 563                         }
 564                         if (dtype == NULL)
 565                                 continue;
 566                         if (!strcmp(dtype, "file"))
 567                                 file = data;
 568                         else if (!strcmp(dtype, "path"))
 569                                 path = data;
 570                         else
 571                                 free(data);
 572                 }
 573
 574                 /*
 575                  * If the file doesn't exist, it's an orphaned recovery file,
 576                  * toss it.
 577                  *
 578                  * XXX
 579                  * This can occur if the backup file was deleted and we crashed
 580                  * before deleting the email file.
 581                  */
 582                 errno = 0;
 583                 if (stat(path, &sb) &&
 584                     errno == ENOENT) {
 585                         (void)unlink(dp->d_name);
 586                         goto next;
 587                 }
 588
 589                 /* Get the last modification time and display. */
 590                 (void)fstat(fileno(fp), &sb);
 591                 (void)printf("%.24s: %s\n",
 592                     ctime(&sb.st_mtime), file);
 593                 found = 1;
 594
 595                 /* Close, discarding lock. */
 596 next:           (void)fclose(fp);
 597                 if (file != NULL)
 598                         free(file);
 599                 if (path != NULL)
 600                         free(path);
 601         }
 602         if (found == 0)
 603                 (void)printf("%s: No files to recover\n", sp->gp->progname);
 604         (void)closedir(dirp);
 605         return (0);
 606 }
 607
 608 /*
 609  * rcv_read --
 610  *      Start a recovered file as the file to edit.
 611  *
 612  * PUBLIC: int rcv_read(SCR *, FREF *);
 613  */
 614 int
 615 rcv_read(
 616         SCR *sp,
 617         FREF *frp)
 618 {
 619         struct dirent *dp;
 620         struct stat sb;
 621         DIR *dirp;
 622         FILE *fp;
 623         EXF *ep;
 624         struct timespec rec_mtim = { 0, 0 };
 625         int found, locked = 0, requested, sv_fd;
 626         char *name, *p, *t, *rp, *recp, *pathp;
 627         char *file, *path, *recpath;
 628         char *dtype, *data;
 629         int st;
 630
 631         if (opts_empty(sp, O_RECDIR, 0))
 632                 return (1);
 633         rp = O_STR(sp, O_RECDIR);
 634         if ((dirp = opendir(rp)) == NULL) {
 635                 msgq_str(sp, M_SYSERR, rp, "%s");
 636                 return (1);
 637         }
 638
 639         name = frp->name;
 640         sv_fd = -1;
 641         recp = pathp = NULL;
 642         for (found = requested = 0; (dp = readdir(dirp)) != NULL;) {
 643                 if (strncmp(dp->d_name, "recover.", 8))
 644                         continue;
 645                 if ((recpath = join(rp, dp->d_name)) == NULL) {
 646                         msgq(sp, M_SYSERR, NULL);
 647                         continue;
 648                 }
 649
 650                 /* If it's readable, it's recoverable. */
 651                 if ((fp = fopen(recpath, "r")) == NULL) {
 652                         free(recpath);
 653                         continue;
 654                 }
 655
 656                 switch (file_lock(sp, NULL, fileno(fp), 1)) {
 657                 case LOCK_FAILED:
 658                         /*
 659                          * XXX
 660                          * Assume that a lock can't be acquired, but that we
 661                          * should permit recovery anyway.  If this is wrong,
 662                          * and someone else is using the file, we're going to
 663                          * die horribly.
 664                          */
 665                         locked = 0;
 666                         break;
 667                 case LOCK_SUCCESS:
 668                         locked = 1;
 669                         break;
 670                 case LOCK_UNAVAIL:
 671                         /* If it's locked, it's live. */
 672                         (void)fclose(fp);
 673                         continue;
 674                 }
 675
 676                 /* Check the headers. */
 677                 for (file = NULL, path = NULL;
 678                     file == NULL || path == NULL;) {
 679                         if ((st = rcv_dlnread(sp, &dtype, &data, fp))) {
 680                                 if (st == 1)
 681                                         msgq_str(sp, M_ERR, dp->d_name,
 682                                             "067|%s: malformed recovery file");
 683                                 goto next;
 684                         }
 685                         if (dtype == NULL)
 686                                 continue;
 687                         if (!strcmp(dtype, "file"))
 688                                 file = data;
 689                         else if (!strcmp(dtype, "path"))
 690                                 path = data;
 691                         else
 692                                 free(data);
 693                 }
 694                 ++found;
 695
 696                 /*
 697                  * If the file doesn't exist, it's an orphaned recovery file,
 698                  * toss it.
 699                  *
 700                  * XXX
 701                  * This can occur if the backup file was deleted and we crashed
 702                  * before deleting the email file.
 703                  */
 704                 errno = 0;
 705                 if (stat(path, &sb) &&
 706                     errno == ENOENT) {
 707                         (void)unlink(dp->d_name);
 708                         goto next;
 709                 }
 710
 711                 /* Check the file name. */
 712                 if (strcmp(file, name))
 713                         goto next;
 714
 715                 ++requested;
 716
 717                 /* If we've found more than one, take the most recent. */
 718                 (void)fstat(fileno(fp), &sb);
 719                 if (recp == NULL ||
 720                     timespeccmp(&rec_mtim, &sb.st_mtimespec, <)) {
 721                         p = recp;
 722                         t = pathp;
 723                         recp = recpath;
 724                         pathp = path;
 725                         if (p != NULL) {
 726                                 free(p);
 727                                 free(t);
 728                         }
 729                         rec_mtim = sb.st_mtimespec;
 730                         if (sv_fd != -1)
 731                                 (void)close(sv_fd);
 732                         sv_fd = dup(fileno(fp));
 733                 } else {
 734 next:                   free(recpath);
 735                         if (path != NULL)
 736                                 free(path);
 737                 }
 738                 (void)fclose(fp);
 739                 if (file != NULL)
 740                         free(file);
 741         }
 742         (void)closedir(dirp);
 743
 744         if (recp == NULL) {
 745                 msgq_str(sp, M_INFO, name,
 746                     "068|No files named %s, readable by you, to recover");
 747                 return (1);
 748         }
 749         if (found) {
 750                 if (requested > 1)
 751                         msgq(sp, M_INFO,
 752             "069|There are older versions of this file for you to recover");
 753                 if (found > requested)
 754                         msgq(sp, M_INFO,
 755                             "070|There are other files for you to recover");
 756         }
 757
 758         /*
 759          * Create the FREF structure, start the btree file.
 760          *
 761          * XXX
 762          * file_init() is going to set ep->rcv_path.
 763          */
 764         if (file_init(sp, frp, pathp, 0)) {
 765                 free(recp);
 766                 free(pathp);
 767                 (void)close(sv_fd);
 768                 return (1);
 769         }
 770         free(pathp);
 771
 772         /*
 773          * We keep an open lock on the file so that the recover option can
 774          * distinguish between files that are live and those that need to
 775          * be recovered.  The lock is already acquired, just copy it.
 776          */
 777         ep = sp->ep;
 778         ep->rcv_mpath = recp;
 779         ep->rcv_fd = sv_fd;
 780         if (!locked)
 781                 F_SET(frp, FR_UNLOCKED);
 782
 783         /* We believe the file is recoverable. */
 784         F_SET(ep, F_RCV_ON);
 785         return (0);
 786 }
 787
 788 /*
 789  * rcv_copy --
 790  *      Copy a recovery file.
 791  */
 792 static int
 793 rcv_copy(
 794         SCR *sp,
 795         int wfd,
 796         char *fname)
 797 {
 798         int nr, nw, off, rfd;
 799         char buf[8 * 1024];
 800
 801         if ((rfd = open(fname, O_RDONLY, 0)) == -1)
 802                 goto err;
 803         while ((nr = read(rfd, buf, sizeof(buf))) > 0)
 804                 for (off = 0; nr; nr -= nw, off += nw)
 805                         if ((nw = write(wfd, buf + off, nr)) < 0)
 806                                 goto err;
 807         if (nr == 0)
 808                 return (0);
 809
 810 err:    msgq_str(sp, M_SYSERR, fname, "%s");
 811         return (1);
 812 }
 813
 814 /*
 815  * rcv_mktemp --
 816  *      Paranoid make temporary file routine.
 817  */
 818 static int
 819 rcv_mktemp(
 820         SCR *sp,
 821         char *path,
 822         char *dname)
 823 {
 824         int fd;
 825
 826         if ((fd = mkstemp(path)) == -1)
 827                 msgq_str(sp, M_SYSERR, dname, "%s");
 828         return (fd);
 829 }
 830
 831 /*
 832  * rcv_email --
 833  *      Send email.
 834  */
 835 static void
 836 rcv_email(
 837         SCR *sp,
 838         char *fname)
 839 {
 840         char *buf;
 841
 842         (void)asprintf(&buf, _PATH_SENDMAIL " -odb -t < %s", fname);
 843         if (buf == NULL) {
 844                 msgq_str(sp, M_ERR, strerror(errno),
 845                     "071|not sending email: %s");
 846                 return;
 847         }
 848         (void)system(buf);
 849         free(buf);
 850 }
 851
 852 /*
 853  * rcv_dlnwrite --
 854  *      Encode a string into an X-vi-data line and write it.
 855  */
 856 static int
 857 rcv_dlnwrite(
 858         SCR *sp,
 859         const char *dtype,
 860         const char *src,
 861         FILE *fp)
 862 {
 863         char *bp = NULL, *p;
 864         size_t blen = 0;
 865         size_t dlen, len;
 866         int plen, xlen;
 867
 868         len = strlen(src);
 869         dlen = strlen(dtype);
 870         GET_SPACE_GOTOC(sp, bp, blen, (len + 2) / 3 * 4 + dlen + 2);
 871         (void)memcpy(bp, dtype, dlen);
 872         bp[dlen] = ';';
 873         if ((xlen = b64_ntop((u_char *)src,
 874             len, bp + dlen + 1, blen)) == -1)
 875                 goto err;
 876         xlen += dlen + 1;
 877
 878         /* Output as an MIME folding header. */
 879         if ((plen = fprintf(fp, VI_DHEADER " %.*s\n",
 880             FMTCOLS - (int)sizeof(VI_DHEADER), bp)) < 0)
 881                 goto err;
 882         plen -= (int)sizeof(VI_DHEADER) + 1;
 883         for (p = bp, xlen -= plen; xlen > 0; xlen -= plen) {
 884                 p += plen;
 885                 if ((plen = fprintf(fp, " %.*s\n", FMTCOLS - 1, p)) < 0)
 886                         goto err;
 887                 plen -= 2;
 888         }
 889         FREE_SPACE(sp, bp, blen);
 890         return (0);
 891
 892 err:    FREE_SPACE(sp, bp, blen);
 893         return (1);
 894 alloc_err:
 895         msgq(sp, M_SYSERR, NULL);
 896         return (-1);
 897 }
 898
 899 /*
 900  * rcv_dlnread --
 901  *      Read an X-vi-data line and decode it.
 902  */
 903 static int
 904 rcv_dlnread(
 905         SCR *sp,
 906         char **dtypep,
 907         char **datap,           /* free *datap if != NULL after use. */
 908         FILE *fp)
 909 {
 910         int ch;
 911         char buf[1024];
 912         char *bp = NULL, *p, *src;
 913         size_t blen = 0;
 914         size_t len, off, dlen;
 915         char *dtype, *data;
 916         int xlen;
 917
 918         if (fgets(buf, sizeof(buf), fp) == NULL)
 919                 return (1);
 920         if (strncmp(buf, VI_DHEADER, sizeof(VI_DHEADER) - 1)) {
 921                 *dtypep = NULL;
 922                 *datap = NULL;
 923                 return (0);
 924         }
 925
 926         /* Fetch an MIME folding header. */
 927         len = strlen(buf) - sizeof(VI_DHEADER) + 1;
 928         GET_SPACE_GOTOC(sp, bp, blen, len);
 929         (void)memcpy(bp, buf + sizeof(VI_DHEADER) - 1, len);
 930         p = bp + len;
 931         while ((ch = fgetc(fp)) == ' ') {
 932                 if (fgets(buf, sizeof(buf), fp) == NULL)
 933                         goto err;
 934                 off = strlen(buf);
 935                 len += off;
 936                 ADD_SPACE_GOTOC(sp, bp, blen, len);
 937                 p = bp + len - off;
 938                 (void)memcpy(p, buf, off);
 939         }
 940         bp[len] = '\0';
 941         (void)ungetc(ch, fp);
 942
 943         for (p = bp; *p == ' ' || *p == '\n'; p++);
 944         if ((src = strchr(p, ';')) == NULL)
 945                 goto err;
 946         dlen = src - p;
 947         src += 1;
 948         len -= src - bp;
 949
 950         /* Memory looks like: "<data>\0<dtype>\0". */
 951         MALLOC(sp, data, char *, dlen + len / 4 * 3 + 2);
 952         if (data == NULL)
 953                 goto err;
 954         if ((xlen = (b64_pton(p + dlen + 1,
 955             (u_char *)data, len / 4 * 3 + 1))) == -1) {
 956                 free(data);
 957                 goto err;
 958         }
 959         data[xlen] = '\0';
 960         dtype = data + xlen + 1;
 961         (void)memcpy(dtype, p, dlen);
 962         dtype[dlen] = '\0';
 963         FREE_SPACE(sp, bp, blen);
 964         *dtypep = dtype;
 965         *datap = data;
 966         return (0);
 967
 968 err:    FREE_SPACE(sp, bp, blen);
 969         return (1);
 970 alloc_err:
 971         msgq(sp, M_SYSERR, NULL);
 972         return (-1);
 973 }