contrib/tcsh/sh.dir.c

   1 /* $Header: /src/pub/tcsh/sh.dir.c,v 3.60 2002/07/08 21:03:04 christos Exp $ */
   2 /*
   3  * sh.dir.c: Directory manipulation functions
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$Id: sh.dir.c,v 3.60 2002/07/08 21:03:04 christos Exp $")
  36
  37 /*
  38  * C Shell - directory management
  39  */
  40
  41 static  void                     dstart         __P((const char *));
  42 static  struct directory        *dfind          __P((Char *));
  43 static  Char                    *dfollow        __P((Char *));
  44 static  void                     printdirs      __P((int));
  45 static  Char                    *dgoto          __P((Char *));
  46 static  void                     dnewcwd        __P((struct directory *, int));
  47 static  void                     dset           __P((Char *));
  48 static  void                     dextract       __P((struct directory *));
  49 static  int                      skipargs       __P((Char ***, char *, char *));
  50 static  void                     dgetstack      __P((void));
  51
  52 static struct directory dhead INIT_ZERO_STRUCT;         /* "head" of loop */
  53 static int    printd;                   /* force name to be printed */
  54
  55 int     bequiet = 0;            /* do not print dir stack -strike */
  56
  57 static void
  58 dstart(from)
  59     const char *from;
  60 {
  61     xprintf(CGETS(12, 1, "%s: Trying to start from \"%s\"\n"), progname, from);
  62 }
  63
  64 /*
  65  * dinit - initialize current working directory
  66  */
  67 void
  68 dinit(hp)
  69     Char   *hp;
  70 {
  71     register char *tcp;
  72     register Char *cp;
  73     register struct directory *dp;
  74     char    path[MAXPATHLEN];
  75
  76     /* Don't believe the login shell home, because it may be a symlink */
  77     tcp = (char *) getcwd(path, sizeof(path));
  78     if (tcp == NULL || *tcp == '\0') {
  79         xprintf("%s: %s\n", progname, strerror(errno));
  80         if (hp && *hp) {
  81             tcp = short2str(hp);
  82             dstart(tcp);
  83             if (chdir(tcp) == -1)
  84                 cp = NULL;
  85             else
  86                 cp = Strsave(hp);
  87         }
  88         else
  89             cp = NULL;
  90         if (cp == NULL) {
  91             dstart("/");
  92             if (chdir("/") == -1)
  93                 /* I am not even try to print an error message! */
  94                 xexit(1);
  95             cp = SAVE("/");
  96         }
  97     }
  98     else {
  99 #ifdef S_IFLNK
 100         struct stat swd, shp;
 101
 102         /*
 103          * See if $HOME is the working directory we got and use that
 104          */
 105         if (hp && *hp &&
 106             stat(tcp, &swd) != -1 && stat(short2str(hp), &shp) != -1 &&
 107             DEV_DEV_COMPARE(swd.st_dev, shp.st_dev)  &&
 108                 swd.st_ino == shp.st_ino)
 109             cp = Strsave(hp);
 110         else {
 111             char   *cwd;
 112
 113             /*
 114              * use PWD if we have it (for subshells)
 115              */
 116             if ((cwd = getenv("PWD")) != NULL) {
 117                 if (stat(cwd, &shp) != -1 &&
 118                         DEV_DEV_COMPARE(swd.st_dev, shp.st_dev) &&
 119                     swd.st_ino == shp.st_ino)
 120                     tcp = cwd;
 121             }
 122             cp = dcanon(SAVE(tcp), STRNULL);
 123         }
 124 #else /* S_IFLNK */
 125         cp = dcanon(SAVE(tcp), STRNULL);
 126 #endif /* S_IFLNK */
 127     }
 128
 129     dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
 130     dp->di_name = cp;
 131     dp->di_count = 0;
 132     dhead.di_next = dhead.di_prev = dp;
 133     dp->di_next = dp->di_prev = &dhead;
 134     printd = 0;
 135     dnewcwd(dp, 0);
 136     set(STRdirstack, Strsave(dp->di_name), VAR_READWRITE|VAR_NOGLOB);
 137 }
 138
 139 static void
 140 dset(dp)
 141 Char *dp;
 142 {
 143     /*
 144      * Don't call set() directly cause if the directory contains ` or
 145      * other junk characters glob will fail.
 146      */
 147     set(STRowd, Strsave(varval(STRcwd)), VAR_READWRITE|VAR_NOGLOB);
 148     set(STRcwd, Strsave(dp), VAR_READWRITE|VAR_NOGLOB);
 149
 150     tsetenv(STRPWD, dp);
 151 }
 152
 153 #define DIR_PRINT       0x01    /* -p */
 154 #define DIR_LONG        0x02    /* -l */
 155 #define DIR_VERT        0x04    /* -v */
 156 #define DIR_LINE        0x08    /* -n */
 157 #define DIR_SAVE        0x10    /* -S */
 158 #define DIR_LOAD        0x20    /* -L */
 159 #define DIR_CLEAR       0x40    /* -c */
 160 #define DIR_OLD         0x80    /* - */
 161
 162 static int
 163 skipargs(v, dstr, str)
 164     Char ***v;
 165     char   *dstr;
 166     char   *str;
 167 {
 168     Char  **n = *v, *s;
 169
 170     int dflag = 0, loop = 1;
 171     for (n++; loop && *n != NULL && (*n)[0] == '-'; n++)
 172         if (*(s = &((*n)[1])) == '\0')  /* test for bare "-" argument */
 173             dflag |= DIR_OLD;
 174         else {
 175             char *p;
 176             while (loop && *s != '\0')  /* examine flags */
 177             {
 178                 if ((p = strchr(dstr, *s++)) != NULL)
 179                     dflag |= (1 << (p - dstr));
 180                 else {
 181                     stderror(ERR_DIRUS, short2str(**v), dstr, str);
 182                     loop = 0;   /* break from both loops */
 183                     break;
 184                 }
 185             }
 186         }
 187     if (*n && (dflag & DIR_OLD))
 188         stderror(ERR_DIRUS, short2str(**v), dstr, str);
 189     *v = n;
 190     /* make -l, -v, and -n imply -p */
 191     if (dflag & (DIR_LONG|DIR_VERT|DIR_LINE))
 192         dflag |= DIR_PRINT;
 193     return dflag;
 194 }
 195
 196 /*
 197  * dodirs - list all directories in directory loop
 198  */
 199 /*ARGSUSED*/
 200 void
 201 dodirs(v, c)
 202     Char  **v;
 203     struct command *c;
 204 {
 205     static char flags[] = "plvnSLc";
 206     int dflag = skipargs(&v, flags, "");
 207
 208     USE(c);
 209     if ((dflag & DIR_CLEAR) != 0) {
 210         struct directory *dp, *fdp;
 211         for (dp = dcwd->di_next; dp != dcwd; ) {
 212             fdp = dp;
 213             dp = dp->di_next;
 214             if (fdp != &dhead)
 215                 dfree(fdp);
 216         }
 217         dhead.di_next = dhead.di_prev = dp;
 218         dp->di_next = dp->di_prev = &dhead;
 219     }
 220     if ((dflag & DIR_LOAD) != 0)
 221         loaddirs(*v);
 222     else if ((dflag & DIR_SAVE) != 0)
 223         recdirs(*v, 1);
 224
 225     if (*v && (dflag & (DIR_SAVE|DIR_LOAD)))
 226         v++;
 227
 228     if (*v != NULL || (dflag & DIR_OLD))
 229         stderror(ERR_DIRUS, "dirs", flags, "");
 230     if ((dflag & (DIR_CLEAR|DIR_LOAD|DIR_SAVE)) == 0 || (dflag & DIR_PRINT))
 231         printdirs(dflag);
 232 }
 233
 234 static void
 235 printdirs(dflag)
 236     int dflag;
 237 {
 238     register struct directory *dp;
 239     Char   *s, *user;
 240     int     idx, len, cur;
 241     extern int T_Cols;
 242
 243     dp = dcwd;
 244     idx = 0;
 245     cur = 0;
 246     do {
 247         if (dp == &dhead)
 248             continue;
 249         if (dflag & DIR_VERT) {
 250             xprintf("%d\t", idx++);
 251             cur = 0;
 252         }
 253         s = dp->di_name;
 254         user = NULL;
 255         if (!(dflag & DIR_LONG) && (user = getusername(&s)) != NULL)
 256             len = (int) (Strlen(user) + Strlen(s) + 2);
 257         else
 258             len = (int) (Strlen(s) + 1);
 259
 260         cur += len;
 261         if ((dflag & DIR_LINE) && cur >= T_Cols - 1 && len < T_Cols) {
 262             xputchar('\n');
 263             cur = len;
 264         }
 265         if (user)
 266             xprintf("~%S", user);
 267         xprintf("%S%c", s, (dflag & DIR_VERT) ? '\n' : ' ');
 268     } while ((dp = dp->di_prev) != dcwd);
 269     if (!(dflag & DIR_VERT))
 270         xputchar('\n');
 271 }
 272
 273 void
 274 dtildepr(dir)
 275     Char *dir;
 276 {
 277     Char* user;
 278     if ((user = getusername(&dir)) != NULL)
 279         xprintf("~%S%S", user, dir);
 280     else
 281         xprintf("%S", dir);
 282 }
 283
 284 void
 285 dtilde()
 286 {
 287     struct directory *d = dcwd;
 288
 289     do {
 290         if (d == &dhead)
 291             continue;
 292         d->di_name = dcanon(d->di_name, STRNULL);
 293     } while ((d = d->di_prev) != dcwd);
 294
 295     dset(dcwd->di_name);
 296 }
 297
 298
 299 /* dnormalize():
 300  *      The path will be normalized if it
 301  *      1) is "..",
 302  *      2) or starts with "../",
 303  *      3) or ends with "/..",
 304  *      4) or contains the string "/../",
 305  *      then it will be normalized, unless those strings are quoted.
 306  *      Otherwise, a copy is made and sent back.
 307  */
 308 Char   *
 309 dnormalize(cp, exp)
 310     Char   *cp;
 311     int exp;
 312 {
 313
 314 /* return true if dp is of the form "../xxx" or "/../xxx" */
 315 #define IS_DOTDOT(sp, p) (ISDOTDOT(p) && ((p) == (sp) || *((p) - 1) == '/'))
 316 #define IS_DOT(sp, p) (ISDOT(p) && ((p) == (sp) || *((p) - 1) == '/'))
 317
 318 #ifdef S_IFLNK
 319     if (exp) {
 320         int     dotdot = 0;
 321         Char   *dp, *cwd, *start = cp, buf[MAXPATHLEN];
 322         struct stat sb;
 323 # ifdef apollo
 324         bool slashslash;
 325 # endif /* apollo */
 326
 327         /*
 328          * count the number of "../xxx" or "xxx/../xxx" in the path
 329          */
 330         for (dp=start; *dp && *(dp+1); dp++)
 331             if (IS_DOTDOT(start, dp))
 332                 dotdot++;
 333         /*
 334          * if none, we are done.
 335          */
 336         if (dotdot == 0)
 337             return (Strsave(cp));
 338
 339         /*
 340          * If the path doesn't exist, we are done too.
 341          */
 342         if (lstat(short2str(cp), &sb) != 0 && errno == ENOENT)
 343             return (Strsave(cp));
 344
 345
 346         cwd = (Char *) xmalloc((size_t) (((int) Strlen(dcwd->di_name) + 3) *
 347                                            sizeof(Char)));
 348         (void) Strcpy(cwd, dcwd->di_name);
 349
 350         /*
 351          * If the path starts with a slash, we are not relative to
 352          * the current working directory.
 353          */
 354         if (ABSOLUTEP(start))
 355             *cwd = '\0';
 356 # ifdef apollo
 357         slashslash = cwd[0] == '/' && cwd[1] == '/';
 358 # endif /* apollo */
 359
 360         /*
 361          * Ignore . and count ..'s
 362          */
 363         for (;;) {
 364             dotdot = 0;
 365             buf[0] = '\0';
 366             dp = buf;
 367             while (*cp)
 368                 if (IS_DOT(start, cp)) {
 369                     if (*++cp)
 370                         cp++;
 371                 }
 372                 else if (IS_DOTDOT(start, cp)) {
 373                     if (buf[0])
 374                         break; /* finish analyzing .././../xxx/[..] */
 375                     dotdot++;
 376                     cp += 2;
 377                     if (*cp)
 378                         cp++;
 379                 }
 380                 else
 381                         *dp++ = *cp++;
 382
 383             *dp = '\0';
 384             while (dotdot > 0)
 385                 if ((dp = Strrchr(cwd, '/')) != NULL) {
 386 # ifdef apollo
 387                     if (dp == &cwd[1])
 388                         slashslash = 1;
 389 # endif /* apollo */
 390                         *dp = '\0';
 391                         dotdot--;
 392                 }
 393                 else
 394                     break;
 395
 396             if (!*cwd) {        /* too many ..'s, starts with "/" */
 397                 cwd[0] = '/';
 398 # ifdef apollo
 399                 cwd[1] = '/';
 400                 cwd[2] = '\0';
 401 # else /* !apollo */
 402                 cwd[1] = '\0';
 403 # endif /* apollo */
 404             }
 405 # ifdef apollo
 406             else if (slashslash && cwd[1] == '\0') {
 407                 cwd[1] = '/';
 408                 cwd[2] = '\0';
 409             }
 410 # endif /* apollo */
 411
 412             if (buf[0]) {
 413                 if ((TRM(cwd[(dotdot = (int) Strlen(cwd)) - 1])) != '/')
 414                     cwd[dotdot++] = '/';
 415                 cwd[dotdot] = '\0';
 416                 dp = Strspl(cwd, TRM(buf[0]) == '/' ? &buf[1] : buf);
 417                 xfree((ptr_t) cwd);
 418                 cwd = dp;
 419                 if ((TRM(cwd[(dotdot = (int) Strlen(cwd)) - 1])) == '/')
 420                     cwd[--dotdot] = '\0';
 421             }
 422             /* Reduction of ".." following the stuff we collected in buf
 423              * only makes sense if the directory item in buf really exists.
 424              * Avoid reduction of "-I../.." (typical compiler call) to ""
 425              * or "/usr/nonexistant/../bin" to "/usr/bin":
 426              */
 427             if (cwd[0]) {
 428                 struct stat exists;
 429                 if (0 != stat(short2str(cwd), &exists)) {
 430                     xfree((ptr_t) cwd);
 431                     return Strsave(start);
 432                 }
 433             }
 434             if (!*cp)
 435                 break;
 436         }
 437         return cwd;
 438     }
 439 #endif /* S_IFLNK */
 440     return Strsave(cp);
 441 }
 442
 443
 444 /*
 445  * dochngd - implement chdir command.
 446  */
 447 /*ARGSUSED*/
 448 void
 449 dochngd(v, c)
 450     Char  **v;
 451     struct command *c;
 452 {
 453     register Char *cp;
 454     register struct directory *dp;
 455     int dflag = skipargs(&v, "plvn", "[-|<dir>]");
 456
 457     USE(c);
 458     printd = 0;
 459     cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
 460
 461     if (cp == NULL) {
 462         if ((cp = varval(STRhome)) == STRNULL || *cp == 0)
 463             stderror(ERR_NAME | ERR_NOHOMEDIR);
 464         if (chdir(short2str(cp)) < 0)
 465             stderror(ERR_NAME | ERR_CANTCHANGE);
 466         cp = Strsave(cp);
 467     }
 468     else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
 469         stderror(ERR_NAME | ERR_TOOMANY);
 470         /* NOTREACHED */
 471         return;
 472     }
 473     else if ((dp = dfind(cp)) != 0) {
 474         char   *tmp;
 475
 476         printd = 1;
 477         if (chdir(tmp = short2str(dp->di_name)) < 0)
 478             stderror(ERR_SYSTEM, tmp, strerror(errno));
 479         dcwd->di_prev->di_next = dcwd->di_next;
 480         dcwd->di_next->di_prev = dcwd->di_prev;
 481         dfree(dcwd);
 482         dnewcwd(dp, dflag);
 483         return;
 484     }
 485     else
 486         if ((cp = dfollow(cp)) == NULL)
 487             return;
 488     dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
 489     dp->di_name = cp;
 490     dp->di_count = 0;
 491     dp->di_next = dcwd->di_next;
 492     dp->di_prev = dcwd->di_prev;
 493     dp->di_prev->di_next = dp;
 494     dp->di_next->di_prev = dp;
 495     dfree(dcwd);
 496     dnewcwd(dp, dflag);
 497 }
 498
 499 static Char *
 500 dgoto(cp)
 501     Char   *cp;
 502 {
 503     Char   *dp;
 504
 505     if (!ABSOLUTEP(cp))
 506     {
 507         register Char *p, *q;
 508         int     cwdlen;
 509
 510         for (p = dcwd->di_name; *p++;)
 511             continue;
 512         if ((cwdlen = (int) (p - dcwd->di_name - 1)) == 1)      /* root */
 513             cwdlen = 0;
 514         for (p = cp; *p++;)
 515             continue;
 516         dp = (Char *) xmalloc((size_t)((cwdlen + (p - cp) + 1) * sizeof(Char)));
 517         for (p = dp, q = dcwd->di_name; (*p++ = *q++) != '\0';)
 518             continue;
 519         if (cwdlen)
 520             p[-1] = '/';
 521         else
 522             p--;                /* don't add a / after root */
 523         for (q = cp; (*p++ = *q++) != '\0';)
 524             continue;
 525         xfree((ptr_t) cp);
 526         cp = dp;
 527         dp += cwdlen;
 528     }
 529     else
 530         dp = cp;
 531
 532 #ifdef WINNT_NATIVE
 533     cp = SAVE(getcwd(NULL, 0));
 534 #else /* !WINNT_NATIVE */
 535     cp = dcanon(cp, dp);
 536 #endif /* WINNT_NATIVE */
 537     return cp;
 538 }
 539
 540 /*
 541  * dfollow - change to arg directory; fall back on cdpath if not valid
 542  */
 543 static Char *
 544 dfollow(cp)
 545     register Char *cp;
 546 {
 547     register Char *dp;
 548     struct varent *c;
 549     char    ebuf[MAXPATHLEN];
 550     int serrno;
 551
 552     cp = globone(cp, G_ERROR);
 553 #ifdef apollo
 554     if (Strchr(cp, '`')) {
 555         char *dptr, *ptr;
 556         if (chdir(dptr = short2str(cp)) < 0)
 557             stderror(ERR_SYSTEM, dptr, strerror(errno));
 558         else if ((ptr = getcwd(ebuf, sizeof(ebuf))) && *ptr != '\0') {
 559                 xfree((ptr_t) cp);
 560                 cp = Strsave(str2short(ptr));
 561                 return dgoto(cp);
 562         }
 563         else
 564             stderror(ERR_SYSTEM, dptr, ebuf);
 565     }
 566 #endif /* apollo */
 567
 568     (void) strncpy(ebuf, short2str(cp), MAXPATHLEN);
 569     ebuf[MAXPATHLEN-1] = '\0';
 570     /*
 571      * if we are ignoring symlinks, try to fix relatives now.
 572      * if we are expading symlinks, it should be done by now.
 573      */
 574     dp = dnormalize(cp, symlinks == SYM_IGNORE);
 575     if (chdir(short2str(dp)) >= 0) {
 576         xfree((ptr_t) cp);
 577         return dgoto(dp);
 578     }
 579     else {
 580         xfree((ptr_t) dp);
 581         if (chdir(short2str(cp)) >= 0)
 582             return dgoto(cp);
 583         else if (errno != ENOENT && errno != ENOTDIR)
 584             stderror(ERR_SYSTEM, ebuf, strerror(errno));
 585         serrno = errno;
 586     }
 587
 588     if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
 589         && (c = adrof(STRcdpath)) && c->vec != NULL) {
 590         Char  **cdp;
 591         register Char *p;
 592         Char    buf[MAXPATHLEN];
 593
 594         for (cdp = c->vec; *cdp; cdp++) {
 595             for (dp = buf, p = *cdp; (*dp++ = *p++) != '\0';)
 596                 continue;
 597             dp[-1] = '/';
 598             for (p = cp; (*dp++ = *p++) != '\0';)
 599                 continue;
 600             /*
 601              * We always want to fix the directory here
 602              * If we are normalizing symlinks
 603              */
 604             dp = dnormalize(buf, symlinks == SYM_IGNORE ||
 605                                  symlinks == SYM_EXPAND);
 606             if (chdir(short2str(dp)) >= 0) {
 607                 printd = 1;
 608                 xfree((ptr_t) cp);
 609                 return dgoto(dp);
 610             }
 611             else if (chdir(short2str(cp)) >= 0) {
 612                 printd = 1;
 613                 xfree((ptr_t) dp);
 614                 return dgoto(cp);
 615             }
 616         }
 617     }
 618     dp = varval(cp);
 619     if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
 620         xfree((ptr_t) cp);
 621         cp = Strsave(dp);
 622         printd = 1;
 623         return dgoto(cp);
 624     }
 625     xfree((ptr_t) cp);
 626     /*
 627      * on login source of ~/.cshdirs, errors are eaten. the dir stack is all
 628      * directories we could get to.
 629      */
 630     if (!bequiet) {
 631         stderror(ERR_SYSTEM, ebuf, strerror(serrno));
 632         return (NULL);
 633     }
 634     else
 635         return (NULL);
 636 }
 637
 638
 639 /*
 640  * dopushd - push new directory onto directory stack.
 641  *      with no arguments exchange top and second.
 642  *      with numeric argument (+n) bring it to top.
 643  */
 644 /*ARGSUSED*/
 645 void
 646 dopushd(v, c)
 647     Char  **v;
 648     struct command *c;
 649 {
 650     register struct directory *dp;
 651     register Char *cp;
 652     int dflag = skipargs(&v, "plvn", " [-|<dir>|+<n>]");
 653
 654     USE(c);
 655     printd = 1;
 656     cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
 657
 658     if (cp == NULL) {
 659         if (adrof(STRpushdtohome)) {
 660             if ((cp = varval(STRhome)) == STRNULL || *cp == 0)
 661                 stderror(ERR_NAME | ERR_NOHOMEDIR);
 662             if (chdir(short2str(cp)) < 0)
 663                 stderror(ERR_NAME | ERR_CANTCHANGE);
 664             cp = Strsave(cp);   /* hmmm... PWP */
 665             if ((cp = dfollow(cp)) == NULL)
 666                 return;
 667             dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
 668             dp->di_name = cp;
 669             dp->di_count = 0;
 670             dp->di_prev = dcwd;
 671             dp->di_next = dcwd->di_next;
 672             dcwd->di_next = dp;
 673             dp->di_next->di_prev = dp;
 674         }
 675         else {
 676             char   *tmp;
 677
 678             if ((dp = dcwd->di_prev) == &dhead)
 679                 dp = dhead.di_prev;
 680             if (dp == dcwd)
 681                 stderror(ERR_NAME | ERR_NODIR);
 682             if (chdir(tmp = short2str(dp->di_name)) < 0)
 683                 stderror(ERR_SYSTEM, tmp, strerror(errno));
 684             dp->di_prev->di_next = dp->di_next;
 685             dp->di_next->di_prev = dp->di_prev;
 686             dp->di_next = dcwd->di_next;
 687             dp->di_prev = dcwd;
 688             dcwd->di_next->di_prev = dp;
 689             dcwd->di_next = dp;
 690         }
 691     }
 692     else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
 693         stderror(ERR_NAME | ERR_TOOMANY);
 694         /* NOTREACHED */
 695         return;
 696     }
 697     else if ((dp = dfind(cp)) != NULL) {
 698         char   *tmp;
 699
 700         if (chdir(tmp = short2str(dp->di_name)) < 0)
 701             stderror(ERR_SYSTEM, tmp, strerror(errno));
 702         /*
 703          * kfk - 10 Feb 1984 - added new "extraction style" pushd +n
 704          */
 705         if (adrof(STRdextract))
 706             dextract(dp);
 707     }
 708     else {
 709         register Char *ccp;
 710
 711         if ((ccp = dfollow(cp)) == NULL)
 712             return;
 713         dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
 714         dp->di_name = ccp;
 715         dp->di_count = 0;
 716         dp->di_prev = dcwd;
 717         dp->di_next = dcwd->di_next;
 718         dcwd->di_next = dp;
 719         dp->di_next->di_prev = dp;
 720     }
 721     dnewcwd(dp, dflag);
 722 }
 723
 724 /*
 725  * dfind - find a directory if specified by numeric (+n) argument
 726  */
 727 static struct directory *
 728 dfind(cp)
 729     register Char *cp;
 730 {
 731     register struct directory *dp;
 732     register int i;
 733     register Char *ep;
 734
 735     if (*cp++ != '+')
 736         return (0);
 737     for (ep = cp; Isdigit(*ep); ep++)
 738         continue;
 739     if (*ep)
 740         return (0);
 741     i = getn(cp);
 742     if (i <= 0)
 743         return (0);
 744     for (dp = dcwd; i != 0; i--) {
 745         if ((dp = dp->di_prev) == &dhead)
 746             dp = dp->di_prev;
 747         if (dp == dcwd)
 748             stderror(ERR_NAME | ERR_DEEP);
 749     }
 750     return (dp);
 751 }
 752
 753 /*
 754  * dopopd - pop a directory out of the directory stack
 755  *      with a numeric argument just discard it.
 756  */
 757 /*ARGSUSED*/
 758 void
 759 dopopd(v, c)
 760     Char  **v;
 761     struct command *c;
 762 {
 763     Char *cp;
 764     register struct directory *dp, *p = NULL;
 765     int dflag = skipargs(&v, "plvn", " [-|+<n>]");
 766
 767     USE(c);
 768     printd = 1;
 769     cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
 770
 771     if (cp == NULL)
 772         dp = dcwd;
 773     else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
 774         stderror(ERR_NAME | ERR_TOOMANY);
 775         /* NOTREACHED */
 776         return;
 777     }
 778     else if ((dp = dfind(cp)) == 0)
 779         stderror(ERR_NAME | ERR_BADDIR);
 780     if (dp->di_prev == &dhead && dp->di_next == &dhead)
 781         stderror(ERR_NAME | ERR_EMPTY);
 782     if (dp == dcwd) {
 783         char   *tmp;
 784
 785         if ((p = dp->di_prev) == &dhead)
 786             p = dhead.di_prev;
 787         if (chdir(tmp = short2str(p->di_name)) < 0)
 788             stderror(ERR_SYSTEM, tmp, strerror(errno));
 789     }
 790     dp->di_prev->di_next = dp->di_next;
 791     dp->di_next->di_prev = dp->di_prev;
 792     if (dp == dcwd) {
 793         dnewcwd(p, dflag);
 794     }
 795     else {
 796         printdirs(dflag);
 797     }
 798     dfree(dp);
 799 }
 800
 801 /*
 802  * dfree - free the directory (or keep it if it still has ref count)
 803  */
 804 void
 805 dfree(dp)
 806     register struct directory *dp;
 807 {
 808
 809     if (dp->di_count != 0) {
 810         dp->di_next = dp->di_prev = 0;
 811     }
 812     else {
 813         xfree((ptr_t) dp->di_name);
 814         xfree((ptr_t) dp);
 815     }
 816 }
 817
 818 /*
 819  * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
 820  *      we are of course assuming that the file system is standardly
 821  *      constructed (always have ..'s, directories have links)
 822  */
 823 Char   *
 824 dcanon(cp, p)
 825     register Char *cp, *p;
 826 {
 827     register Char *sp;
 828     register Char *p1, *p2;     /* general purpose */
 829     bool    slash;
 830 #ifdef apollo
 831     bool    slashslash;
 832 #endif /* apollo */
 833     size_t  clen;
 834
 835 #ifdef S_IFLNK                  /* if we have symlinks */
 836     Char    link[MAXPATHLEN];
 837     char    tlink[MAXPATHLEN];
 838     int     cc;
 839     Char   *newcp;
 840 #endif /* S_IFLNK */
 841
 842     /*
 843      * if the path given is too long truncate it!
 844      */
 845     if ((clen = Strlen(cp)) >= MAXPATHLEN)
 846         cp[clen = MAXPATHLEN - 1] = '\0';
 847
 848     /*
 849      * christos: if the path given does not start with a slash prepend cwd. If
 850      * cwd does not start with a slash or the result would be too long try to
 851      * correct it.
 852      */
 853     if (!ABSOLUTEP(cp)) {
 854         Char    tmpdir[MAXPATHLEN];
 855         size_t  len;
 856
 857         p1 = varval(STRcwd);
 858         if (p1 == STRNULL || !ABSOLUTEP(p1)) {
 859             char *tmp = (char *)getcwd((char *)tmpdir, sizeof(tmpdir));
 860             if (tmp == NULL || *tmp == '\0') {
 861                 xprintf("%s: %s\n", progname, strerror(errno));
 862                 set(STRcwd, SAVE("/"), VAR_READWRITE|VAR_NOGLOB);
 863             } else {
 864                 set(STRcwd, SAVE(tmp), VAR_READWRITE|VAR_NOGLOB);
 865             }
 866             p1 = varval(STRcwd);
 867         }
 868         len = Strlen(p1);
 869         if (len + clen + 1 >= MAXPATHLEN)
 870             cp[MAXPATHLEN - (len + 1)] = '\0';
 871         (void) Strcpy(tmpdir, p1);
 872         (void) Strcat(tmpdir, STRslash);
 873         (void) Strcat(tmpdir, cp);
 874         xfree((ptr_t) cp);
 875         cp = p = Strsave(tmpdir);
 876     }
 877
 878 #ifdef apollo
 879     slashslash = (cp[0] == '/' && cp[1] == '/');
 880 #endif /* apollo */
 881
 882     while (*p) {                /* for each component */
 883         sp = p;                 /* save slash address */
 884         while (*++p == '/')     /* flush extra slashes */
 885             continue;
 886         if (p != ++sp)
 887             for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
 888                 continue;
 889         p = sp;                 /* save start of component */
 890         slash = 0;
 891         if (*p)
 892             while (*++p)        /* find next slash or end of path */
 893                 if (*p == '/') {
 894                     slash = 1;
 895                     *p = 0;
 896                     break;
 897                 }
 898
 899 #ifdef apollo
 900         if (&cp[1] == sp && sp[0] == '.' && sp[1] == '.' && sp[2] == '\0')
 901             slashslash = 1;
 902 #endif /* apollo */
 903         if (*sp == '\0') {      /* if component is null */
 904             if (--sp == cp)     /* if path is one char (i.e. /) */
 905                 break;
 906             else
 907                 *sp = '\0';
 908         }
 909         else if (sp[0] == '.' && sp[1] == 0) {
 910             if (slash) {
 911                 for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';)
 912                     continue;
 913                 p = --sp;
 914             }
 915             else if (--sp != cp)
 916                 *sp = '\0';
 917             else
 918                 sp[1] = '\0';
 919         }
 920         else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
 921             /*
 922              * We have something like "yyy/xxx/..", where "yyy" can be null or
 923              * a path starting at /, and "xxx" is a single component. Before
 924              * compressing "xxx/..", we want to expand "yyy/xxx", if it is a
 925              * symbolic link.
 926              */
 927             *--sp = 0;          /* form the pathname for readlink */
 928 #ifdef S_IFLNK                  /* if we have symlinks */
 929             if (sp != cp && /* symlinks != SYM_IGNORE && */
 930                 (cc = readlink(short2str(cp), tlink,
 931                                sizeof tlink)) >= 0) {
 932                 tlink[cc] = '\0';
 933                 (void) Strncpy(link, str2short(tlink),
 934                     sizeof(link) / sizeof(Char));
 935                 link[sizeof(link) / sizeof(Char) - 1] = '\0';
 936
 937                 if (slash)
 938                     *p = '/';
 939                 /*
 940                  * Point p to the '/' in "/..", and restore the '/'.
 941                  */
 942                 *(p = sp) = '/';
 943                 /*
 944                  * find length of p
 945                  */
 946                 for (p1 = p; *p1++;)
 947                     continue;
 948                 if (*link != '/') {
 949                     /*
 950                      * Relative path, expand it between the "yyy/" and the
 951                      * "/..". First, back sp up to the character past "yyy/".
 952                      */
 953                     while (*--sp != '/')
 954                         continue;
 955                     sp++;
 956                     *sp = 0;
 957                     /*
 958                      * New length is "yyy/" + link + "/.." and rest
 959                      */
 960                     p1 = newcp = (Char *) xmalloc((size_t)
 961                                                 (((sp - cp) + cc + (p1 - p)) *
 962                                                  sizeof(Char)));
 963                     /*
 964                      * Copy new path into newcp
 965                      */
 966                     for (p2 = cp; (*p1++ = *p2++) != '\0';)
 967                         continue;
 968                     for (p1--, p2 = link; (*p1++ = *p2++) != '\0';)
 969                         continue;
 970                     for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 971                         continue;
 972                     /*
 973                      * Restart canonicalization at expanded "/xxx".
 974                      */
 975                     p = sp - cp - 1 + newcp;
 976                 }
 977                 else {
 978                     /*
 979                      * New length is link + "/.." and rest
 980                      */
 981                     p1 = newcp = (Char *) xmalloc((size_t)
 982                                             ((cc + (p1 - p)) * sizeof(Char)));
 983                     /*
 984                      * Copy new path into newcp
 985                      */
 986                     for (p2 = link; (*p1++ = *p2++) != '\0';)
 987                         continue;
 988                     for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
 989                         continue;
 990                     /*
 991                      * Restart canonicalization at beginning
 992                      */
 993                     p = newcp;
 994                 }
 995                 xfree((ptr_t) cp);
 996                 cp = newcp;
 997 #ifdef apollo
 998                 slashslash = (cp[0] == '/' && cp[1] == '/');
 999 #endif /* apollo */
1000                 continue;       /* canonicalize the link */
1001             }
1002 #endif /* S_IFLNK */
1003             *sp = '/';
1004             if (sp != cp)
1005                 while (*--sp != '/')
1006                     continue;
1007             if (slash) {
1008                 for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
1009                     continue;
1010                 p = sp;
1011             }
1012             else if (cp == sp)
1013                 *++sp = '\0';
1014             else
1015                 *sp = '\0';
1016         }
1017         else {                  /* normal dir name (not . or .. or nothing) */
1018
1019 #ifdef S_IFLNK                  /* if we have symlinks */
1020             if (sp != cp && symlinks == SYM_CHASE &&
1021                 (cc = readlink(short2str(cp), tlink,
1022                                sizeof tlink)) >= 0) {
1023                 tlink[cc] = '\0';
1024                 (void) Strncpy(link, str2short(tlink),
1025                     sizeof(link) / sizeof(Char));
1026                 link[sizeof(link) / sizeof(Char) - 1] = '\0';
1027
1028                 /*
1029                  * restore the '/'.
1030                  */
1031                 if (slash)
1032                     *p = '/';
1033
1034                 /*
1035                  * point sp to p (rather than backing up).
1036                  */
1037                 sp = p;
1038
1039                 /*
1040                  * find length of p
1041                  */
1042                 for (p1 = p; *p1++;)
1043                     continue;
1044                 if (*link != '/') {
1045                     /*
1046                      * Relative path, expand it between the "yyy/" and the
1047                      * remainder. First, back sp up to the character past
1048                      * "yyy/".
1049                      */
1050                     while (*--sp != '/')
1051                         continue;
1052                     sp++;
1053                     *sp = 0;
1054                     /*
1055                      * New length is "yyy/" + link + "/.." and rest
1056                      */
1057                     p1 = newcp = (Char *) xmalloc((size_t)
1058                                                   (((sp - cp) + cc + (p1 - p))
1059                                                    * sizeof(Char)));
1060                     /*
1061                      * Copy new path into newcp
1062                      */
1063                     for (p2 = cp; (*p1++ = *p2++) != '\0';)
1064                         continue;
1065                     for (p1--, p2 = link; (*p1++ = *p2++) != '\0';)
1066                         continue;
1067                     for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
1068                         continue;
1069                     /*
1070                      * Restart canonicalization at expanded "/xxx".
1071                      */
1072                     p = sp - cp - 1 + newcp;
1073                 }
1074                 else {
1075                     /*
1076                      * New length is link + the rest
1077                      */
1078                     p1 = newcp = (Char *) xmalloc((size_t)
1079                                             ((cc + (p1 - p)) * sizeof(Char)));
1080                     /*
1081                      * Copy new path into newcp
1082                      */
1083                     for (p2 = link; (*p1++ = *p2++) != '\0';)
1084                         continue;
1085                     for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
1086                         continue;
1087                     /*
1088                      * Restart canonicalization at beginning
1089                      */
1090                     p = newcp;
1091                 }
1092                 xfree((ptr_t) cp);
1093                 cp = newcp;
1094 #ifdef apollo
1095                 slashslash = (cp[0] == '/' && cp[1] == '/');
1096 #endif /* apollo */
1097                 continue;       /* canonicalize the link */
1098             }
1099 #endif /* S_IFLNK */
1100             if (slash)
1101                 *p = '/';
1102         }
1103     }
1104
1105     /*
1106      * fix home...
1107      */
1108 #ifdef S_IFLNK
1109     p1 = varval(STRhome);
1110     cc = (int) Strlen(p1);
1111     /*
1112      * See if we're not in a subdir of STRhome
1113      */
1114     if (p1 && *p1 == '/' && (Strncmp(p1, cp, (size_t) cc) != 0 ||
1115         (cp[cc] != '/' && cp[cc] != '\0'))) {
1116         static ino_t home_ino = (ino_t) -1;
1117         static dev_t home_dev = (dev_t) -1;
1118         static Char *home_ptr = NULL;
1119         struct stat statbuf;
1120         int found;
1121
1122         /*
1123          * Get dev and ino of STRhome
1124          */
1125         if (home_ptr != p1 &&
1126             stat(short2str(p1), &statbuf) != -1) {
1127             home_dev = statbuf.st_dev;
1128             home_ino = statbuf.st_ino;
1129             home_ptr = p1;
1130         }
1131         /*
1132          * Start comparing dev & ino backwards
1133          */
1134         p2 = Strncpy(link, cp, sizeof(link) / sizeof(Char));
1135         link[sizeof(link) / sizeof(Char) - 1] = '\0';
1136         found = 0;
1137         while (*p2 && stat(short2str(p2), &statbuf) != -1) {
1138             if (DEV_DEV_COMPARE(statbuf.st_dev, home_dev) &&
1139                         statbuf.st_ino == home_ino) {
1140                         found = 1;
1141                         break;
1142             }
1143             if ((sp = Strrchr(p2, '/')) != NULL)
1144                 *sp = '\0';
1145         }
1146         /*
1147          * See if we found it
1148          */
1149         if (*p2 && found) {
1150             /*
1151              * Use STRhome to make '~' work
1152              */
1153             newcp = Strspl(p1, cp + Strlen(p2));
1154             xfree((ptr_t) cp);
1155             cp = newcp;
1156         }
1157     }
1158 #endif /* S_IFLNK */
1159
1160 #ifdef apollo
1161     if (slashslash) {
1162         if (cp[1] != '/') {
1163             p = (Char *) xmalloc((size_t) (Strlen(cp) + 2) * sizeof(Char));
1164             *p = '/';
1165             (void) Strcpy(&p[1], cp);
1166             xfree((ptr_t) cp);
1167             cp = p;
1168         }
1169     }
1170     if (cp[1] == '/' && cp[2] == '/')
1171         (void) Strcpy(&cp[1], &cp[2]);
1172 #endif /* apollo */
1173     return cp;
1174 }
1175
1176
1177 /*
1178  * dnewcwd - make a new directory in the loop the current one
1179  */
1180 static void
1181 dnewcwd(dp, dflag)
1182     register struct directory *dp;
1183     int dflag;
1184 {
1185     int print;
1186
1187     if (adrof(STRdunique)) {
1188         struct directory *dn;
1189
1190         for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev)
1191             if (dn != dp && Strcmp(dn->di_name, dp->di_name) == 0) {
1192                 dn->di_next->di_prev = dn->di_prev;
1193                 dn->di_prev->di_next = dn->di_next;
1194                 dfree(dn);
1195                 break;
1196             }
1197     }
1198     dcwd = dp;
1199     dset(dcwd->di_name);
1200     dgetstack();
1201     print = printd;             /* if printd is set, print dirstack... */
1202     if (adrof(STRpushdsilent))  /* but pushdsilent overrides printd... */
1203         print = 0;
1204     if (dflag & DIR_PRINT)      /* but DIR_PRINT overrides pushdsilent... */
1205         print = 1;
1206     if (bequiet)                /* and bequiet overrides everything */
1207         print = 0;
1208     if (print)
1209         printdirs(dflag);
1210     cwd_cmd();                  /* PWP: run the defined cwd command */
1211 }
1212
1213 void
1214 dsetstack()
1215 {
1216     Char **cp;
1217     struct varent *vp;
1218     struct directory *dn, *dp;
1219
1220     if ((vp = adrof(STRdirstack)) == NULL || vp->vec == NULL)
1221         return;
1222
1223     /* Free the whole stack */
1224     while ((dn = dhead.di_prev) != &dhead) {
1225         dn->di_next->di_prev = dn->di_prev;
1226         dn->di_prev->di_next = dn->di_next;
1227         if (dn != dcwd)
1228             dfree(dn);
1229     }
1230
1231     /* thread the current working directory */
1232     dhead.di_prev = dhead.di_next = dcwd;
1233     dcwd->di_next = dcwd->di_prev = &dhead;
1234
1235     /* put back the stack */
1236     for (cp = vp->vec; cp && *cp && **cp; cp++) {
1237         dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
1238         dp->di_name = Strsave(*cp);
1239         dp->di_count = 0;
1240         dp->di_prev = dcwd;
1241         dp->di_next = dcwd->di_next;
1242         dcwd->di_next = dp;
1243         dp->di_next->di_prev = dp;
1244     }
1245     dgetstack();        /* Make $dirstack reflect the current state */
1246 }
1247
1248 static void
1249 dgetstack()
1250 {
1251     int i = 0;
1252     Char **dblk, **dbp;
1253     struct directory *dn;
1254
1255     if (adrof(STRdirstack) == NULL)
1256         return;
1257
1258     for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev, i++)
1259         continue;
1260     dbp = dblk = (Char**) xmalloc((size_t) (i + 1) * sizeof(Char *));
1261     for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev, dbp++)
1262          *dbp = Strsave(dn->di_name);
1263     *dbp = NULL;
1264     setq(STRdirstack, dblk, &shvhed, VAR_READWRITE);
1265 }
1266
1267 /*
1268  * getstakd - added by kfk 17 Jan 1984
1269  * Support routine for the stack hack.  Finds nth directory in
1270  * the directory stack, or finds last directory in stack.
1271  */
1272 int
1273 getstakd(s, cnt)
1274     Char   *s;
1275     int     cnt;
1276 {
1277     struct directory *dp;
1278
1279     dp = dcwd;
1280     if (cnt < 0) {              /* < 0 ==> last dir requested. */
1281         dp = dp->di_next;
1282         if (dp == &dhead)
1283             dp = dp->di_next;
1284     }
1285     else {
1286         while (cnt-- > 0) {
1287             dp = dp->di_prev;
1288             if (dp == &dhead)
1289                 dp = dp->di_prev;
1290             if (dp == dcwd)
1291                 return (0);
1292         }
1293     }
1294     (void) Strncpy(s, dp->di_name, BUFSIZE);
1295     s[BUFSIZE - 1] = '\0';
1296     return (1);
1297 }
1298
1299 /*
1300  * Karl Kleinpaste - 10 Feb 1984
1301  * Added dextract(), which is used in pushd +n.
1302  * Instead of just rotating the entire stack around, dextract()
1303  * lets the user have the nth dir extracted from its current
1304  * position, and pushes it onto the top.
1305  */
1306 static void
1307 dextract(dp)
1308     struct directory *dp;
1309 {
1310     if (dp == dcwd)
1311         return;
1312     dp->di_next->di_prev = dp->di_prev;
1313     dp->di_prev->di_next = dp->di_next;
1314     dp->di_next = dcwd->di_next;
1315     dp->di_prev = dcwd;
1316     dp->di_next->di_prev = dp;
1317     dcwd->di_next = dp;
1318 }
1319
1320 void
1321 loaddirs(fname)
1322     Char *fname;
1323 {
1324     static Char *loaddirs_cmd[] = { STRsource, NULL, NULL };
1325
1326     bequiet = 1;
1327     if (fname)
1328         loaddirs_cmd[1] = fname;
1329     else if ((fname = varval(STRdirsfile)) != STRNULL)
1330         loaddirs_cmd[1] = fname;
1331     else
1332         loaddirs_cmd[1] = STRtildotdirs;
1333     dosource(loaddirs_cmd, (struct command *)0);
1334     bequiet = 0;
1335 }
1336
1337 /*
1338  * create a file called ~/.cshdirs which has a sequence
1339  * of pushd commands which will restore the dir stack to
1340  * its state before exit/logout. remember that the order
1341  * is reversed in the file because we are pushing.
1342  * -strike
1343  */
1344 void
1345 recdirs(fname, def)
1346     Char *fname;
1347     int def;
1348 {
1349     int     fp, ftmp, oldidfds;
1350     int     cdflag = 0;
1351     extern struct directory *dcwd;
1352     struct directory *dp;
1353     unsigned int    num;
1354     Char   *snum;
1355     Char    qname[MAXPATHLEN*2];
1356
1357     if (fname == NULL && !def)
1358         return;
1359
1360     if (fname == NULL) {
1361         if ((fname = varval(STRdirsfile)) == STRNULL)
1362             fname = Strspl(varval(STRhome), &STRtildotdirs[1]);
1363         else
1364             fname = Strsave(fname);
1365     }
1366     else
1367         fname = globone(fname, G_ERROR);
1368
1369     if ((fp = creat(short2str(fname), 0600)) == -1) {
1370         xfree((ptr_t) fname);
1371         return;
1372     }
1373
1374     if ((snum = varval(STRsavedirs)) == STRNULL || snum[0] == '\0')
1375         num = (unsigned int) ~0;
1376     else
1377         num = (unsigned int) atoi(short2str(snum));
1378
1379     oldidfds = didfds;
1380     didfds = 0;
1381     ftmp = SHOUT;
1382     SHOUT = fp;
1383
1384     dp = dcwd->di_next;
1385     do {
1386         if (dp == &dhead)
1387             continue;
1388
1389         if (cdflag == 0) {
1390             cdflag = 1;
1391             xprintf("cd %S\n", quote_meta(qname, dp->di_name));
1392         }
1393         else
1394             xprintf("pushd %S\n", quote_meta(qname, dp->di_name));
1395
1396         if (num-- == 0)
1397             break;
1398
1399     } while ((dp = dp->di_next) != dcwd->di_next);
1400
1401     (void) close(fp);
1402     SHOUT = ftmp;
1403     didfds = oldidfds;
1404     xfree((ptr_t) fname);
1405 }