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.63 1993/12/23 19:29:38 bostic Exp $ (Berkeley) $Date: 1993/12/23 19:29:38 $";
  10 #endif /* not lint */
  11
  12 #include <sys/param.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[MAXPATHLEN];
 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)snprintf(tname, sizeof(tname),
 210                     "%s/vi.XXXXXX", O_STR(sp, O_DIRECTORY));
 211                 if ((fd = mkstemp(tname)) == -1) {
 212                         msgq(sp, M_SYSERR, "Temporary file");
 213                         goto err;
 214                 }
 215                 (void)close(fd);
 216                 if ((frp->tname = strdup(tname)) == NULL) {
 217                         msgq(sp, M_SYSERR, NULL);
 218                         (void)unlink(tname);
 219                         goto err;
 220                 }
 221                 oname = frp->tname;
 222                 psize = 4 * 1024;
 223                 F_SET(frp, FR_NEWFILE);
 224         } else {
 225                 /* Try to keep it at 10 pages or less per file. */
 226                 if (sb.st_size < 40 * 1024)
 227                         psize = 4 * 1024;
 228                 else if (sb.st_size < 320 * 1024)
 229                         psize = 32 * 1024;
 230                 else
 231                         psize = 64 * 1024;
 232
 233                 frp->mtime = sb.st_mtime;
 234         }
 235
 236         /* Set up recovery. */
 237         memset(&oinfo, 0, sizeof(RECNOINFO));
 238         oinfo.bval = '\n';                      /* Always set. */
 239         oinfo.psize = psize;
 240         oinfo.flags = F_ISSET(sp->gp, G_SNAPSHOT) ? R_SNAPSHOT : 0;
 241         if (rcv_name == NULL) {
 242                 if (rcv_tmp(sp, ep, FILENAME(frp)))
 243                         msgq(sp, M_ERR,
 244                     "Modifications not recoverable if the system crashes.");
 245                 else
 246                         oinfo.bfname = ep->rcv_path;
 247         } else if ((ep->rcv_path = strdup(rcv_name)) == NULL) {
 248                 msgq(sp, M_SYSERR, NULL);
 249                 goto err;
 250         } else {
 251                 oinfo.bfname = ep->rcv_path;
 252                 F_SET(ep, F_MODIFIED | F_RCV_ON);
 253         }
 254
 255         /* Open a db structure. */
 256         if ((ep->db = dbopen(rcv_name == NULL ? oname : NULL,
 257             O_NONBLOCK | O_RDONLY, DEFFILEMODE, DB_RECNO, &oinfo)) == NULL) {
 258                 msgq(sp, M_SYSERR, rcv_name == NULL ? oname : rcv_name);
 259                 goto err;
 260         }
 261
 262         /* Init file marks. */
 263         if (mark_init(sp, ep))
 264                 goto err;
 265
 266         /* Start logging. */
 267         if (log_init(sp, ep))
 268                 goto err;
 269
 270         /*
 271          * The -R flag, or doing a "set readonly" during a session causes
 272          * all files edited during the session (using an edit command, or
 273          * even using tags) to be marked read-only.  Changing the file name
 274          * (see ex/ex_file.c), clears this flag.
 275          *
 276          * Otherwise, try and figure out if a file is readonly.  This is a
 277          * dangerous thing to do.  The kernel is the only arbiter of whether
 278          * or not a file is writeable, and the best that a user program can
 279          * do is guess.  Obvious loopholes are files that are on a file system
 280          * mounted readonly (access catches this one on a few systems), or
 281          * alternate protection mechanisms, ACL's for example, that we can't
 282          * portably check.  Lots of fun, and only here because users whined.
 283          *
 284          * !!!
 285          * Historic vi displayed the readonly message if none of the file
 286          * write bits were set, or if an an access(2) call on the path
 287          * failed.  This seems reasonable.  If the file is mode 444, root
 288          * users may want to know that the owner of the file did not expect
 289          * it to be written.
 290          *
 291          * Historic vi set the readonly bit if no write bits were set for
 292          * a file, even if the access call would have succeeded.  This makes
 293          * the superuser force the write even when vi expects that it will
 294          * succeed.  I'm less supportive of this semantic, but it's historic
 295          * practice and the conservative approach to vi'ing files as root.
 296          *
 297          * It would be nice if there was some way to update this when the user
 298          * does a "^Z; chmod ...".  The problem is that we'd first have to
 299          * distinguish between readonly bits set because of file permissions
 300          * and those set for other reasons.  That's not too hard, but deciding
 301          * when to reevaluate the permissions is trickier.  An alternative
 302          * might be to turn off the readonly bit if the user forces a write
 303          * and it succeeds.
 304          *
 305          * XXX
 306          * Access(2) doesn't consider the effective uid/gid values.  This
 307          * probably isn't a problem for vi when it's running standalone.
 308          */
 309         if (O_ISSET(sp, O_READONLY) || !F_ISSET(frp, FR_NEWFILE) &&
 310             (!(sb.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) ||
 311             access(FILENAME(frp), W_OK)))
 312                 F_SET(frp, FR_RDONLY);
 313         else
 314                 F_CLR(frp, FR_RDONLY);
 315
 316         /*
 317          * Close the previous file; if that fails, close the new one
 318          * and run for the border.
 319          */
 320         if (sp->ep != NULL && file_end(sp, sp->ep, force)) {
 321                 (void)file_end(sp, ep, 1);
 322                 goto err;
 323         }
 324
 325         /*
 326          * 4.4BSD supports locking in the open call, other systems don't.
 327          * Since the user can't interrupt us between the open and here,
 328          * it's a don't care.
 329          *
 330          * !!!
 331          * We need to distinguish a lock not being available for the file
 332          * from the file system not supporting locking.  Assume that EAGAIN
 333          * is the former.  There isn't a portable way to do this.
 334          *
 335          * XXX
 336          * The locking is flock(2) style, not fcntl(2).  The latter is known
 337          * to fail badly on some systems, and its only advantage is that it
 338          * occasionally works over NFS.
 339          */
 340         if (flock(ep->db->fd(ep->db), LOCK_EX | LOCK_NB))
 341                 if (errno == EAGAIN) {
 342                         msgq(sp, M_INFO,
 343                             "%s already locked, session is read-only", oname);
 344                         F_SET(frp, FR_RDONLY);
 345                 } else
 346                         msgq(sp, M_VINFO, "%s cannot be locked", oname);
 347
 348         /*
 349          * Set the previous file pointer and the alternate file name to be
 350          * the file we're about to discard.
 351          *
 352          * !!!
 353          * If the current file was a temporary file, the call to file_end()
 354          * unlinked it and free'd the name.  So, there is no previous file,
 355          * and there is no alternate file name.  This matches historical
 356          * practice, although in historical vi it could only happen as the
 357          * result of the initial command, i.e. if vi was execute without a
 358          * file name.
 359          */
 360         if (sp->frp != NULL) {
 361                 p = FILENAME(sp->frp);
 362                 if (p == NULL)
 363                         sp->p_frp = NULL;
 364                 else
 365                         sp->p_frp = sp->frp;
 366                 set_alt_name(sp, p);
 367         }
 368
 369         /* The new file has now been officially edited. */
 370         F_SET(frp, FR_EDITED);
 371
 372         /* Switch... */
 373         ++ep->refcnt;
 374         sp->ep = ep;
 375         sp->frp = frp;
 376         return (0);
 377
 378 err:    if (frp->tname != NULL) {
 379                 (void)unlink(frp->tname);
 380                 free(frp->tname);
 381                 frp->tname = NULL;
 382         }
 383         if (ep->rcv_path != NULL) {
 384                 free(ep->rcv_path);
 385                 ep->rcv_path = NULL;
 386         }
 387         FREE(ep, sizeof(EXF));
 388         return (1);
 389 }
 390
 391 /*
 392  * file_end --
 393  *      Stop editing a file.
 394  */
 395 int
 396 file_end(sp, ep, force)
 397         SCR *sp;
 398         EXF *ep;
 399         int force;
 400 {
 401         FREF *frp;
 402
 403         /*
 404          *
 405          * sp->ep MAY NOT BE THE SAME AS THE ARGUMENT ep, SO DON'T USE IT!
 406          *
 407          * Save the cursor location.
 408          *
 409          * XXX
 410          * It would be cleaner to do this somewhere else, but by the time
 411          * ex or vi knows that we're changing files it's already happened.
 412          */
 413         frp = sp->frp;
 414         frp->lno = sp->lno;
 415         frp->cno = sp->cno;
 416         F_SET(frp, FR_CURSORSET);
 417
 418         /* If multiply referenced, just decrement the count and return. */
 419         if (--ep->refcnt != 0)
 420                 return (0);
 421
 422         /* Close the db structure. */
 423         if (ep->db->close != NULL && ep->db->close(ep->db) && !force) {
 424                 msgq(sp, M_ERR,
 425                     "%s: close: %s", FILENAME(frp), strerror(errno));
 426                 ++ep->refcnt;
 427                 return (1);
 428         }
 429
 430         /* COMMITTED TO THE CLOSE.  THERE'S NO GOING BACK... */
 431
 432         /* Stop logging. */
 433         (void)log_end(sp, ep);
 434
 435         /* Free up any marks. */
 436         mark_end(sp, ep);
 437
 438         /*
 439          * Delete the recovery files, close the open descriptor,
 440          * free recovery memory.
 441          */
 442         if (!F_ISSET(ep, F_RCV_NORM)) {
 443                 if (ep->rcv_path != NULL && unlink(ep->rcv_path))
 444                         msgq(sp, M_ERR,
 445                             "%s: remove: %s", ep->rcv_path, strerror(errno));
 446                 if (ep->rcv_mpath != NULL && unlink(ep->rcv_mpath))
 447                         msgq(sp, M_ERR,
 448                             "%s: remove: %s", ep->rcv_mpath, strerror(errno));
 449         }
 450         if (ep->rcv_fd != -1)
 451                 (void)close(ep->rcv_fd);
 452         if (ep->rcv_path != NULL)
 453                 free(ep->rcv_path);
 454         if (ep->rcv_mpath != NULL)
 455                 free(ep->rcv_mpath);
 456
 457         /*
 458          * Unlink any temporary file, file name.  We also turn on the
 459          * ignore bit at this point, because it was a "created" file,
 460          * not an argument file.
 461          */
 462         if (frp->tname != NULL) {
 463                 if (unlink(frp->tname))
 464                         msgq(sp, M_ERR,
 465                             "%s: remove: %s", frp->tname, strerror(errno));
 466                 free(frp->tname);
 467                 frp->tname = NULL;
 468
 469                 if (frp->name == NULL && frp->cname == NULL)
 470                         F_SET(frp, FR_IGNORE);
 471         }
 472         /* Free the EXF structure. */
 473         FREE(ep, sizeof(EXF));
 474         return (0);
 475 }
 476
 477 /*
 478  * file_write --
 479  *      Write the file to disk.  Historic vi had fairly convoluted
 480  *      semantics for whether or not writes would happen.  That's
 481  *      why all the flags.
 482  */
 483 int
 484 file_write(sp, ep, fm, tm, name, flags)
 485         SCR *sp;
 486         EXF *ep;
 487         MARK *fm, *tm;
 488         char *name;
 489         int flags;
 490 {
 491         struct stat sb;
 492         FILE *fp;
 493         FREF *frp;
 494         MARK from, to;
 495         u_long nlno, nch;
 496         int fd, oflags, rval;
 497         char *msg;
 498
 499         /*
 500          * Don't permit writing to temporary files.  The problem is that
 501          * if it's a temp file, and the user does ":wq", we write and quit,
 502          * unlinking the temporary file.  Not what the user had in mind
 503          * at all.  This test cannot be forced.
 504          */
 505         frp = sp->frp;
 506         if (name == NULL && frp->cname == NULL && frp->name == NULL) {
 507                 msgq(sp, M_ERR, "No filename to which to write.");
 508                 return (1);
 509         }
 510
 511         /* Can't write files marked read-only, unless forced. */
 512         if (!LF_ISSET(FS_FORCE) &&
 513             name == NULL && F_ISSET(frp, FR_RDONLY)) {
 514                 if (LF_ISSET(FS_POSSIBLE))
 515                         msgq(sp, M_ERR,
 516                             "Read-only file, not written; use ! to override.");
 517                 else
 518                         msgq(sp, M_ERR,
 519                             "Read-only file, not written.");
 520                 return (1);
 521         }
 522
 523         /* If not forced, not appending, and "writeany" not set ... */
 524         if (!LF_ISSET(FS_FORCE | FS_APPEND) && !O_ISSET(sp, O_WRITEANY)) {
 525                 /* Don't overwrite anything but the original file. */
 526                 if (name != NULL) {
 527                         if (!stat(name, &sb))
 528                                 goto exists;
 529                 } else if (frp->cname != NULL &&
 530                     !F_ISSET(frp, FR_CHANGEWRITE) && !stat(frp->cname, &sb)) {
 531                         name = frp->cname;
 532 exists:                 if (LF_ISSET(FS_POSSIBLE))
 533                                 msgq(sp, M_ERR,
 534                 "%s exists, not written; use ! to override.", name);
 535                         else
 536                                 msgq(sp, M_ERR,
 537                                     "%s exists, not written.", name);
 538                         return (1);
 539                 }
 540
 541                 /*
 542                  * Don't write part of any existing file.  Only test for the
 543                  * original file, the previous test catches anything else.
 544                  */
 545                 if (!LF_ISSET(FS_ALL) && name == NULL &&
 546                     frp->cname == NULL && !stat(frp->name, &sb)) {
 547                         if (LF_ISSET(FS_POSSIBLE))
 548                                 msgq(sp, M_ERR,
 549                                     "Use ! to write a partial file.");
 550                         else
 551                                 msgq(sp, M_ERR, "Partial file, not written.");
 552                         return (1);
 553                 }
 554         }
 555
 556         /*
 557          * Figure out if the file already exists -- if it doesn't, we display
 558          * the "new file" message.  The stat might not be necessary, but we
 559          * just repeat it because it's easier than hacking the previous tests.
 560          * The information is only used for the user message and modification
 561          * time test, so we can ignore the obvious race condition.
 562          *
 563          * If the user is overwriting a file other than the original file, and
 564          * O_WRITEANY was what got us here (neither force nor append was set),
 565          * display the "existing file" messsage.  Since the FR_CHANGEWRITE flag
 566          * is set on a successful write, the message only appears once when the
 567          * user changes a file name.  This is historic practice.
 568          *
 569          * One final test.  If we're not forcing or appending, and we have a
 570          * saved modification time, stop the user if it's been written since
 571          * we last edited or wrote it, and make them force it.
 572          */
 573         if (stat(name == NULL ? FILENAME(frp) : name, &sb))
 574                 msg = ": new file";
 575         else {
 576                 msg = "";
 577                 if (!LF_ISSET(FS_FORCE | FS_APPEND)) {
 578                         if (frp->mtime && sb.st_mtime > frp->mtime) {
 579                                 msgq(sp, M_ERR,
 580                         "%s: file modified more recently than this copy%s.",
 581                                     name == NULL ? frp->name : name,
 582                                     LF_ISSET(FS_POSSIBLE) ?
 583                                     "; use ! to override" : "");
 584                                 return (1);
 585                         }
 586                         if (name != NULL ||
 587                             !F_ISSET(frp, FR_CHANGEWRITE) && frp->cname != NULL)
 588                                 msg = ": existing file";
 589                 }
 590         }
 591
 592         /* We no longer care where the name came from. */
 593         if (name == NULL)
 594                 name = FILENAME(frp);
 595
 596         /* Set flags to either append or truncate. */
 597         oflags = O_CREAT | O_WRONLY;
 598         if (LF_ISSET(FS_APPEND))
 599                 oflags |= O_APPEND;
 600         else
 601                 oflags |= O_TRUNC;
 602
 603         /* Open the file. */
 604         if ((fd = open(name, oflags, DEFFILEMODE)) < 0) {
 605                 msgq(sp, M_SYSERR, name);
 606                 return (1);
 607         }
 608
 609         /* Use stdio for buffering. */
 610         if ((fp = fdopen(fd, "w")) == NULL) {
 611                 (void)close(fd);
 612                 msgq(sp, M_SYSERR, name);
 613                 return (1);
 614         }
 615
 616         /* Build fake addresses, if necessary. */
 617         if (fm == NULL) {
 618                 from.lno = 1;
 619                 from.cno = 0;
 620                 fm = &from;
 621                 if (file_lline(sp, ep, &to.lno))
 622                         return (1);
 623                 to.cno = 0;
 624                 tm = &to;
 625         }
 626
 627         /* Write the file. */
 628         rval = ex_writefp(sp, ep, name, fp, fm, tm, &nlno, &nch);
 629
 630         /*
 631          * Save the new last modification time -- even if the write fails
 632          * we re-init the time if we wrote anything.  That way the user can
 633          * clean up the disk and rewrite without having to force it.
 634          */
 635         if (nlno || nch)
 636                 frp->mtime = stat(name, &sb) ? 0 : sb.st_mtime;
 637
 638         /* If the write failed, complain loudly. */
 639         if (rval) {
 640                 if (!LF_ISSET(FS_APPEND))
 641                         msgq(sp, M_ERR, "%s: WARNING: file truncated!", name);
 642                 return (1);
 643         }
 644
 645         /*
 646          * Once we've actually written the file, it doesn't matter that the
 647          * file name was changed -- if it was, we've already whacked it.
 648          */
 649         F_SET(frp, FR_CHANGEWRITE);
 650
 651         /* If wrote the entire file, clear the modified bit. */
 652         if (LF_ISSET(FS_ALL))
 653                 F_CLR(ep, F_MODIFIED);
 654
 655         msgq(sp, M_INFO, "%s%s: %lu line%s, %lu characters.",
 656             name, msg, nlno, nlno == 1 ? "" : "s", nch);
 657
 658         return (0);
 659 }