common/exf.c

   1 /*-
   2  * Copyright (c) 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * %sccs.include.redist.c%
   6  */
   7
   8 #ifndef lint
   9 static char sccsid[] = "$Id: exf.c,v 8.60 1993/12/19 18:00:27 bostic Exp $ (Berkeley) $Date: 1993/12/19 18:00:27 $";
  10 #endif /* not lint */
  11
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14
  15 /*
  16  * We include <sys/file.h>, because the flock(2) #defines were
  17  * found there on historical systems.  We also include <fcntl.h>
  18  * because the open(2) #defines are found there on newer systems.
  19  */
  20 #include <sys/file.h>
  21
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27
  28 #include "vi.h"
  29 #include "excmd.h"
  30 #include "pathnames.h"
  31
  32 /*
  33  * file_add --
  34  *      Insert a file name into the FREF list, if it doesn't already
  35  *      appear in it.
  36  *
  37  * !!!
  38  * The "if it doesn't already appear" changes vi's semantics slightly.  If
  39  * you do a "vi foo bar", and then execute "next bar baz", the edit of bar
  40  * will reflect the line/column of the previous edit session.  Historic nvi
  41  * did not do this.  The change is a logical extension of the change where
  42  * vi now remembers the last location in any file that it has ever edited,
  43  * not just the previously edited file.
  44  */
  45 FREF *
  46 file_add(sp, frp_append, name, ignore)
  47         SCR *sp;
  48         FREF *frp_append;
  49         CHAR_T *name;
  50         int ignore;
  51 {
  52         FREF *frp;
  53         char *p;
  54
  55         /*
  56          * Return it if it already exists.  Note that we test against the
  57          * user's current name, whatever that happens to be, including if
  58          * it's a temporary file.  If the user is trying to set an argument
  59          * list, the ignore argument will be on -- if we're ignoring the
  60          * file turn off the ignore bit, so it's back in the argument list.
  61          */
  62         if (name != NULL)
  63                 for (frp = sp->frefq.cqh_first;
  64                     frp != (FREF *)&sp->frefq; frp = frp->q.cqe_next)
  65                         if ((p = FILENAME(frp)) != NULL && !strcmp(p, name)) {
  66                                 if (!ignore)
  67                                         F_CLR(frp, FR_IGNORE);
  68                                 return (frp);
  69                         }
  70
  71         /* Allocate and initialize the FREF structure. */
  72         CALLOC(sp, frp, FREF *, 1, sizeof(FREF));
  73         if (frp == NULL)
  74                 return (NULL);
  75
  76         /*
  77          * If no file name specified, or if the file name is a request
  78          * for something temporary, file_init() will allocate the file
  79          * name.  Temporary files are always ignored.
  80          */
  81 #define TEMPORARY_FILE_STRING   "/tmp"
  82         if (name != NULL && strcmp(name, TEMPORARY_FILE_STRING) &&
  83             (frp->name = strdup(name)) == NULL) {
  84                 FREE(frp, sizeof(FREF));
  85                 msgq(sp, M_SYSERR, NULL);
  86                 return (NULL);
  87         }
  88
  89         /* Only the initial argument list is "remembered". */
  90         if (ignore)
  91                 F_SET(frp, FR_IGNORE);
  92
  93         /* Append into the chain of file names. */
  94         if (frp_append != NULL) {
  95                 CIRCLEQ_INSERT_AFTER(&sp->frefq, frp_append, frp, q);
  96         } else
  97                 CIRCLEQ_INSERT_TAIL(&sp->frefq, frp, q);
  98
  99         return (frp);
 100 }
 101
 102 /*
 103  * file_first --
 104  *      Return the first file name for editing, if any.
 105  */
 106 FREF *
 107 file_first(sp)
 108         SCR *sp;
 109 {
 110         FREF *frp;
 111
 112         /* Return the first file name. */
 113         for (frp = sp->frefq.cqh_first;
 114             frp != (FREF *)&sp->frefq; frp = frp->q.cqe_next)
 115                 if (!F_ISSET(frp, FR_IGNORE))
 116                         return (frp);
 117         return (NULL);
 118 }
 119
 120 /*
 121  * file_next --
 122  *      Return the next file name, if any.
 123  */
 124 FREF *
 125 file_next(sp, frp)
 126         SCR *sp;
 127         FREF *frp;
 128 {
 129         while ((frp = frp->q.cqe_next) != (FREF *)&sp->frefq)
 130                 if (!F_ISSET(frp, FR_IGNORE))
 131                         return (frp);
 132         return (NULL);
 133 }
 134
 135 /*
 136  * file_prev --
 137  *      Return the previous file name, if any.
 138  */
 139 FREF *
 140 file_prev(sp, frp)
 141         SCR *sp;
 142         FREF *frp;
 143 {
 144         while ((frp = frp->q.cqe_prev) != (FREF *)&sp->frefq)
 145                 if (!F_ISSET(frp, FR_IGNORE))
 146                         return (frp);
 147         return (NULL);
 148 }
 149
 150 /*
 151  * file_unedited --
 152  *      Return if there are files that aren't ignored and are unedited.
 153  */
 154 FREF *
 155 file_unedited(sp)
 156         SCR *sp;
 157 {
 158         FREF *frp;
 159
 160         /* Return the next file name. */
 161         for (frp = sp->frefq.cqh_first;
 162             frp != (FREF *)&sp->frefq; frp = frp->q.cqe_next)
 163                 if (!F_ISSET(frp, FR_EDITED | FR_IGNORE))
 164                         return (frp);
 165         return (NULL);
 166 }
 167
 168 /*
 169  * file_init --
 170  *      Start editing a file, based on the FREF structure.  If successsful,
 171  *      let go of any previous file.  Don't release the previous file until
 172  *      absolutely sure we have the new one.
 173  */
 174 int
 175 file_init(sp, frp, rcv_name, force)
 176         SCR *sp;
 177         FREF *frp;
 178         char *rcv_name;
 179         int force;
 180 {
 181         EXF *ep;
 182         RECNOINFO oinfo;
 183         struct stat sb;
 184         size_t psize;
 185         int fd;
 186         char *p, *oname, tname[sizeof(_PATH_TMPNAME) + 1];
 187
 188         /*
 189          * Required ep initialization:
 190          *      Flush the line caches.
 191          *      Default recover mail file fd to -1.
 192          *      Set initial EXF flag bits.
 193          */
 194         CALLOC_RET(sp, ep, EXF *, 1, sizeof(EXF));
 195         ep->c_lno = ep->c_nlines = OOBLNO;
 196         ep->rcv_fd = -1;
 197         LIST_INIT(&ep->marks);
 198         F_SET(ep, F_FIRSTMODIFY);
 199
 200         /*
 201          * If no name or backing file, create a backing temporary file, saving
 202          * the temp file name so can later unlink it.  Repoint the name to the
 203          * temporary name (we display it to the user until they rename it).
 204          * There are some games we play with the FR_FREE_TNAME and FR_NONAME
 205          * flags (see ex/ex_file.c) to make sure that the temporary memory gets
 206          * free'd up.
 207          */
 208         if ((oname = FILENAME(frp)) == NULL || stat(oname, &sb)) {
 209                 (void)strcpy(tname, _PATH_TMPNAME);
 210                 if ((fd = mkstemp(tname)) == -1) {
 211                         msgq(sp, M_SYSERR, "Temporary file");
 212                         goto err;
 213                 }
 214                 (void)close(fd);
 215                 if ((frp->tname = strdup(tname)) == NULL) {
 216                         msgq(sp, M_SYSERR, NULL);
 217                         (void)unlink(tname);
 218                         goto err;
 219                 }
 220                 oname = frp->tname;
 221                 psize = 4 * 1024;
 222                 F_SET(frp, FR_NEWFILE);
 223         } else {
 224                 /* Try to keep it at 10 pages or less per file. */
 225                 if (sb.st_size < 40 * 1024)
 226                         psize = 4 * 1024;
 227                 else if (sb.st_size < 320 * 1024)
 228                         psize = 32 * 1024;
 229                 else
 230                         psize = 64 * 1024;
 231
 232                 frp->mtime = sb.st_mtime;
 233         }
 234
 235         /* Set up recovery. */
 236         memset(&oinfo, 0, sizeof(RECNOINFO));
 237         oinfo.bval = '\n';                      /* Always set. */
 238         oinfo.psize = psize;
 239         oinfo.flags = F_ISSET(sp->gp, G_SNAPSHOT) ? R_SNAPSHOT : 0;
 240         if (rcv_name == NULL) {
 241                 if (rcv_tmp(sp, ep, FILENAME(frp)))
 242                         msgq(sp, M_ERR,
 243                     "Modifications not recoverable if the system crashes.");
 244                 else
 245                         oinfo.bfname = ep->rcv_path;
 246         } else if ((ep->rcv_path = strdup(rcv_name)) == NULL) {
 247                 msgq(sp, M_SYSERR, NULL);
 248                 goto err;
 249         } else {
 250                 oinfo.bfname = ep->rcv_path;
 251                 F_SET(ep, F_MODIFIED | F_RCV_ON);
 252         }
 253
 254         /* Open a db structure. */
 255         if ((ep->db = dbopen(rcv_name == NULL ? oname : NULL,
 256             O_NONBLOCK | O_RDONLY, DEFFILEMODE, DB_RECNO, &oinfo)) == NULL) {
 257                 msgq(sp, M_SYSERR, rcv_name == NULL ? oname : rcv_name);
 258                 goto err;
 259         }
 260
 261         /* Init file marks. */
 262         if (mark_init(sp, ep))
 263                 goto err;
 264
 265         /* Start logging. */
 266         if (log_init(sp, ep))
 267                 goto err;
 268
 269         /*
 270          * The -R flag, or doing a "set readonly" during a session causes
 271          * all files edited during the session (using an edit command, or
 272          * even using tags) to be marked read-only.  Changing the file name
 273          * (see ex/ex_file.c), clears this flag.
 274          *
 275          * Otherwise, try and figure out if a file is readonly.  This is a
 276          * dangerous thing to do.  The kernel is the only arbiter of whether
 277          * or not a file is writeable, and the best that a user program can
 278          * do is guess.  Obvious loopholes are files that are on a file system
 279          * mounted readonly (access catches this one on a few systems), or
 280          * alternate protection mechanisms, ACL's for example, that we can't
 281          * portably check.  Lots of fun, and only here because users whined.
 282          *
 283          * !!!
 284          * Historic vi displayed the readonly message if none of the file
 285          * write bits were set, or if an an access(2) call on the path
 286          * failed.  This seems reasonable.  If the file is mode 444, root
 287          * users may want to know that the owner of the file did not expect
 288          * it to be written.
 289          *
 290          * Historic vi set the readonly bit if no write bits were set for
 291          * a file, even if the access call would have succeeded.  This makes
 292          * the superuser force the write even when vi expects that it will
 293          * succeed.  I'm less supportive of this semantic, but it's historic
 294          * practice and the conservative approach to vi'ing files as root.
 295          *
 296          * It would be nice if there was some way to update this when the user
 297          * does a "^Z; chmod ...".  The problem is that we'd first have to
 298          * distinguish between readonly bits set because of file permissions
 299          * and those set for other reasons.  That's not too hard, but deciding
 300          * when to reevaluate the permissions is trickier.  An alternative
 301          * might be to turn off the readonly bit if the user forces a write
 302          * and it succeeds.
 303          *
 304          * XXX
 305          * Access(2) doesn't consider the effective uid/gid values.  This
 306          * probably isn't a problem for vi when it's running standalone.
 307          */
 308         if (O_ISSET(sp, O_READONLY) || !F_ISSET(frp, FR_NEWFILE) &&
 309             (!(sb.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) ||
 310             access(FILENAME(frp), W_OK)))
 311                 F_SET(frp, FR_RDONLY);
 312         else
 313                 F_CLR(frp, FR_RDONLY);
 314
 315         /*
 316          * Close the previous file; if that fails, close the new one
 317          * and run for the border.
 318          */
 319         if (sp->ep != NULL && file_end(sp, sp->ep, force)) {
 320                 (void)file_end(sp, ep, 1);
 321                 goto err;
 322         }
 323
 324         /*
 325          * 4.4BSD supports locking in the open call, other systems don't.
 326          * Since the user can't interrupt us between the open and here,
 327          * it's a don't care.
 328          *
 329          * !!!
 330          * We need to distinguish a lock not being available for the file
 331          * from the file system not supporting locking.  Assume that EAGAIN
 332          * is the former.  There isn't a portable way to do this.
 333          *
 334          * XXX
 335          * The locking is flock(2) style, not fcntl(2).  The latter is known
 336          * to fail badly on some systems, and its only advantage is that it
 337          * occasionally works over NFS.
 338          */
 339         if (flock(ep->db->fd(ep->db), LOCK_EX | LOCK_NB))
 340                 if (errno == EAGAIN) {
 341                         msgq(sp, M_INFO,
 342                             "%s already locked, session is read-only", oname);
 343                         F_SET(frp, FR_RDONLY);
 344                 } else
 345                         msgq(sp, M_VINFO, "%s cannot be locked", oname);
 346
 347         /*
 348          * Set the previous file pointer and the alternate file name to be
 349          * the file we're about to discard.
 350          *
 351          * !!!
 352          * If the current file was a temporary file, the call to file_end()
 353          * unlinked it and free'd the name.  So, there is no previous file,
 354          * and there is no alternate file name.  This matches historical
 355          * practice, although in historical vi it could only happen as the
 356          * result of the initial command, i.e. if vi was execute without a
 357          * file name.
 358          */
 359         if (sp->frp != NULL) {
 360                 p = FILENAME(sp->frp);
 361                 if (p == NULL)
 362                         sp->p_frp = NULL;
 363                 else
 364                         sp->p_frp = sp->frp;
 365                 set_alt_name(sp, p);
 366         }
 367
 368         /* The new file has now been officially edited. */
 369         F_SET(frp, FR_EDITED);
 370
 371         /* Switch... */
 372         ++ep->refcnt;
 373         sp->ep = ep;
 374         sp->frp = frp;
 375         return (0);
 376
 377 err:    if (frp->tname != NULL) {
 378                 (void)unlink(frp->tname);
 379                 free(frp->tname);
 380                 frp->tname = NULL;
 381         }
 382         if (ep->rcv_path != NULL) {
 383                 free(ep->rcv_path);
 384                 ep->rcv_path = NULL;
 385         }
 386         FREE(ep, sizeof(EXF));
 387         return (1);
 388 }
 389
 390 /*
 391  * file_end --
 392  *      Stop editing a file.
 393  */
 394 int
 395 file_end(sp, ep, force)
 396         SCR *sp;
 397         EXF *ep;
 398         int force;
 399 {
 400         FREF *frp;
 401
 402         /*
 403          *
 404          * sp->ep MAY NOT BE THE SAME AS THE ARGUMENT ep, SO DON'T USE IT!
 405          *
 406          * Save the cursor location.
 407          *
 408          * XXX
 409          * It would be cleaner to do this somewhere else, but by the time
 410          * ex or vi knows that we're changing files it's already happened.
 411          */
 412         frp = sp->frp;
 413         frp->lno = sp->lno;
 414         frp->cno = sp->cno;
 415         F_SET(frp, FR_CURSORSET);
 416
 417         /* If multiply referenced, just decrement the count and return. */
 418         if (--ep->refcnt != 0)
 419                 return (0);
 420
 421         /* Close the db structure. */
 422         if (ep->db->close != NULL && ep->db->close(ep->db) && !force) {
 423                 msgq(sp, M_ERR,
 424                     "%s: close: %s", FILENAME(frp), strerror(errno));
 425                 return (1);
 426         }
 427
 428         /* COMMITTED TO THE CLOSE.  THERE'S NO GOING BACK... */
 429
 430         /* Stop logging. */
 431         (void)log_end(sp, ep);
 432
 433         /* Free up any marks. */
 434         mark_end(sp, ep);
 435
 436         /*
 437          * Delete the recovery files, close the open descriptor,
 438          * free recovery memory.
 439          */
 440         if (!F_ISSET(ep, F_RCV_NORM)) {
 441                 if (ep->rcv_path != NULL && unlink(ep->rcv_path))
 442                         msgq(sp, M_ERR,
 443                             "%s: remove: %s", ep->rcv_path, strerror(errno));
 444                 if (ep->rcv_mpath != NULL && unlink(ep->rcv_mpath))
 445                         msgq(sp, M_ERR,
 446                             "%s: remove: %s", ep->rcv_mpath, strerror(errno));
 447         }
 448         if (ep->rcv_fd != -1)
 449                 (void)close(ep->rcv_fd);
 450         if (ep->rcv_path != NULL)
 451                 free(ep->rcv_path);
 452         if (ep->rcv_mpath != NULL)
 453                 free(ep->rcv_mpath);
 454
 455         /* Unlink any temporary file, file name. */
 456         if (frp->tname != NULL) {
 457                 if (unlink(frp->tname))
 458                         msgq(sp, M_ERR,
 459                             "%s: remove: %s", frp->tname, strerror(errno));
 460                 free(frp->tname);
 461                 frp->tname = NULL;
 462         }
 463
 464         /* Free the EXF structure. */
 465         FREE(ep, sizeof(EXF));
 466         return (0);
 467 }
 468
 469 /*
 470  * file_write --
 471  *      Write the file to disk.  Historic vi had fairly convoluted
 472  *      semantics for whether or not writes would happen.  That's
 473  *      why all the flags.
 474  */
 475 int
 476 file_write(sp, ep, fm, tm, name, flags)
 477         SCR *sp;
 478         EXF *ep;
 479         MARK *fm, *tm;
 480         char *name;
 481         int flags;
 482 {
 483         struct stat sb;
 484         FILE *fp;
 485         FREF *frp;
 486         MARK from, to;
 487         u_long nlno, nch;
 488         int fd, oflags, rval;
 489         char *msg;
 490
 491         /*
 492          * Don't permit writing to temporary files.  The problem is that
 493          * if it's a temp file, and the user does ":wq", we write and quit,
 494          * unlinking the temporary file.  Not what the user had in mind
 495          * at all.  This test cannot be forced.
 496          */
 497         frp = sp->frp;
 498         if (name == NULL && frp->cname == NULL && frp->name == NULL) {
 499                 msgq(sp, M_ERR, "No filename to which to write.");
 500                 return (1);
 501         }
 502
 503         /* Can't write files marked read-only, unless forced. */
 504         if (!LF_ISSET(FS_FORCE) &&
 505             name == NULL && F_ISSET(frp, FR_RDONLY)) {
 506                 if (LF_ISSET(FS_POSSIBLE))
 507                         msgq(sp, M_ERR,
 508                             "Read-only file, not written; use ! to override.");
 509                 else
 510                         msgq(sp, M_ERR,
 511                             "Read-only file, not written.");
 512                 return (1);
 513         }
 514
 515         /* If not forced, not appending, and "writeany" not set ... */
 516         if (!LF_ISSET(FS_FORCE | FS_APPEND) && !O_ISSET(sp, O_WRITEANY)) {
 517                 /* Don't overwrite anything but the original file. */
 518                 if (name != NULL) {
 519                         if (!stat(name, &sb))
 520                                 goto exists;
 521                 } else if (frp->cname != NULL &&
 522                     !F_ISSET(frp, FR_CHANGEWRITE) && !stat(frp->cname, &sb)) {
 523                         name = frp->cname;
 524 exists:                 if (LF_ISSET(FS_POSSIBLE))
 525                                 msgq(sp, M_ERR,
 526                 "%s exists, not written; use ! to override.", name);
 527                         else
 528                                 msgq(sp, M_ERR,
 529                                     "%s exists, not written.", name);
 530                         return (1);
 531                 }
 532
 533                 /*
 534                  * Don't write part of any existing file.  Only test for the
 535                  * original file, the previous test catches anything else.
 536                  */
 537                 if (!LF_ISSET(FS_ALL) && name == NULL &&
 538                     frp->cname == NULL && !stat(frp->name, &sb)) {
 539                         if (LF_ISSET(FS_POSSIBLE))
 540                                 msgq(sp, M_ERR,
 541                                     "Use ! to write a partial file.");
 542                         else
 543                                 msgq(sp, M_ERR, "Partial file, not written.");
 544                         return (1);
 545                 }
 546         }
 547
 548         /*
 549          * Figure out if the file already exists -- if it doesn't, we display
 550          * the "new file" message.  The stat might not be necessary, but we
 551          * just repeat it because it's easier than hacking the previous tests.
 552          * The information is only used for the user message and modification
 553          * time test, so we can ignore the obvious race condition.
 554          *
 555          * If the user is overwriting a file other than the original file, and
 556          * O_WRITEANY was what got us here (neither force nor append was set),
 557          * display the "existing file" messsage.  Since the FR_CHANGEWRITE flag
 558          * is set on a successful write, the message only appears once when the
 559          * user changes a file name.  This is historic practice.
 560          *
 561          * One final test.  If we're not forcing or appending, and we have a
 562          * saved modification time, stop the user if it's been written since
 563          * we last edited or wrote it, and make them force it.
 564          */
 565         if (stat(name == NULL ? FILENAME(frp) : name, &sb))
 566                 msg = ": new file";
 567         else {
 568                 msg = "";
 569                 if (!LF_ISSET(FS_FORCE | FS_APPEND)) {
 570                         if (frp->mtime && sb.st_mtime > frp->mtime) {
 571                                 msgq(sp, M_ERR,
 572                         "%s: file modified more recently than this copy%s.",
 573                                     name == NULL ? frp->name : name,
 574                                     LF_ISSET(FS_POSSIBLE) ?
 575                                     "; use ! to override" : "");
 576                                 return (1);
 577                         }
 578                         if (name != NULL ||
 579                             !F_ISSET(frp, FR_CHANGEWRITE) && frp->cname != NULL)
 580                                 msg = ": existing file";
 581                 }
 582         }
 583
 584         /* We no longer care where the name came from. */
 585         if (name == NULL)
 586                 name = FILENAME(frp);
 587
 588         /* Set flags to either append or truncate. */
 589         oflags = O_CREAT | O_WRONLY;
 590         if (LF_ISSET(FS_APPEND))
 591                 oflags |= O_APPEND;
 592         else
 593                 oflags |= O_TRUNC;
 594
 595         /* Open the file. */
 596         if ((fd = open(name, oflags, DEFFILEMODE)) < 0) {
 597                 msgq(sp, M_SYSERR, name);
 598                 return (1);
 599         }
 600
 601         /* Use stdio for buffering. */
 602         if ((fp = fdopen(fd, "w")) == NULL) {
 603                 (void)close(fd);
 604                 msgq(sp, M_SYSERR, name);
 605                 return (1);
 606         }
 607
 608         /* Build fake addresses, if necessary. */
 609         if (fm == NULL) {
 610                 from.lno = 1;
 611                 from.cno = 0;
 612                 fm = &from;
 613                 if (file_lline(sp, ep, &to.lno))
 614                         return (1);
 615                 to.cno = 0;
 616                 tm = &to;
 617         }
 618
 619         /* Write the file. */
 620         rval = ex_writefp(sp, ep, name, fp, fm, tm, &nlno, &nch);
 621
 622         /*
 623          * Save the new last modification time -- even if the write fails
 624          * we re-init the time if we wrote anything.  That way the user can
 625          * clean up the disk and rewrite without having to force it.
 626          */
 627         if (nlno || nch)
 628                 frp->mtime = stat(name, &sb) ? 0 : sb.st_mtime;
 629
 630         /* If the write failed, complain loudly. */
 631         if (rval) {
 632                 if (!LF_ISSET(FS_APPEND))
 633                         msgq(sp, M_ERR, "%s: WARNING: file truncated!", name);
 634                 return (1);
 635         }
 636
 637         /*
 638          * Once we've actually written the file, it doesn't matter that the
 639          * file name was changed -- if it was, we've already whacked it.
 640          */
 641         F_SET(frp, FR_CHANGEWRITE);
 642
 643         /* If wrote the entire file, clear the modified bit. */
 644         if (LF_ISSET(FS_ALL))
 645                 F_CLR(ep, F_MODIFIED);
 646
 647         msgq(sp, M_INFO, "%s%s: %lu line%s, %lu characters.",
 648             name, msg, nlno, nlno == 1 ? "" : "s", nch);
 649
 650         return (0);
 651 }