dir.c revision 1.26
1 /* $NetBSD: dir.c,v 1.26 2006/04/05 23:10:16 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1980, 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)dir.c 8.1 (Berkeley) 5/31/93"; 36 #else 37 __RCSID("$NetBSD: dir.c,v 1.26 2006/04/05 23:10:16 christos Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include <sys/param.h> 42 #include <sys/stat.h> 43 44 #include <errno.h> 45 #include <stdarg.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 50 #include "csh.h" 51 #include "dir.h" 52 #include "extern.h" 53 54 /* Directory management. */ 55 56 static struct directory *dfind(Char *); 57 static Char *dfollow(Char *); 58 static void printdirs(void); 59 static Char *dgoto(Char *); 60 static void skipargs(Char ***, const char *); 61 static void dnewcwd(struct directory *); 62 static void dset(Char *); 63 64 struct directory dhead; /* "head" of loop */ 65 int printd; /* force name to be printed */ 66 67 static int dirflag = 0; 68 69 /* 70 * dinit - initialize current working directory 71 */ 72 void 73 dinit(Char *hp) 74 { 75 static const char emsg[] = "csh: Trying to start from \"%s\"\n"; 76 char path[MAXPATHLEN]; 77 struct directory *dp; 78 const char *ecp; 79 Char *cp; 80 81 /* Don't believe the login shell home, because it may be a symlink */ 82 ecp = getcwd(path, MAXPATHLEN); 83 if (ecp == NULL || *ecp == '\0') { 84 (void)fprintf(csherr, "csh: %s\n", strerror(errno)); 85 if (hp && *hp) { 86 ecp = short2str(hp); 87 if (chdir(ecp) == -1) 88 cp = NULL; 89 else 90 cp = Strsave(hp); 91 (void)fprintf(csherr, emsg, vis_str(hp)); 92 } 93 else 94 cp = NULL; 95 if (cp == NULL) { 96 (void)fprintf(csherr, emsg, "/"); 97 if (chdir("/") == -1) { 98 /* I am not even try to print an error message! */ 99 xexit(1); 100 } 101 cp = SAVE("/"); 102 } 103 } 104 else { 105 struct stat swd, shp; 106 107 /* 108 * See if $HOME is the working directory we got and use that 109 */ 110 if (hp && *hp && 111 stat(ecp, &swd) != -1 && stat(short2str(hp), &shp) != -1 && 112 swd.st_dev == shp.st_dev && swd.st_ino == shp.st_ino) 113 cp = Strsave(hp); 114 else { 115 const char *cwd; 116 117 /* 118 * use PWD if we have it (for subshells) 119 */ 120 if ((cwd = getenv("PWD")) != NULL) { 121 if (stat(cwd, &shp) != -1 && swd.st_dev == shp.st_dev && 122 swd.st_ino == shp.st_ino) 123 ecp = cwd; 124 } 125 cp = dcanon(SAVE(ecp), STRNULL); 126 } 127 } 128 129 dp = (struct directory *)xcalloc(1, sizeof(struct directory)); 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); 136 } 137 138 static void 139 dset(Char *dp) 140 { 141 Char **vec; 142 143 /* 144 * Don't call set() directly cause if the directory contains ` or 145 * other junk characters glob will fail. 146 */ 147 148 vec = (Char **)xmalloc((size_t)(2 * sizeof(Char **))); 149 vec[0] = Strsave(dp); 150 vec[1] = 0; 151 setq(STRcwd, vec, &shvhed); 152 Setenv(STRPWD, dp); 153 } 154 155 #define DIR_LONG 1 156 #define DIR_VERT 2 157 #define DIR_LINE 4 158 159 static void 160 skipargs(Char ***v, const char *str) 161 { 162 Char **n, *s; 163 164 n = *v; 165 dirflag = 0; 166 for (n++; *n != NULL && (*n)[0] == '-'; n++) 167 for (s = &((*n)[1]); *s; s++) 168 switch (*s) { 169 case 'l': 170 dirflag |= DIR_LONG; 171 break; 172 case 'n': 173 dirflag |= DIR_LINE; 174 break; 175 case 'v': 176 dirflag |= DIR_VERT; 177 break; 178 default: 179 stderror(ERR_DIRUS, vis_str(**v), str); 180 /* NOTREACHED */ 181 } 182 *v = n; 183 } 184 185 /* 186 * dodirs - list all directories in directory loop 187 */ 188 void 189 /*ARGSUSED*/ 190 dodirs(Char **v, struct command *t) 191 { 192 skipargs(&v, ""); 193 194 if (*v != NULL) 195 stderror(ERR_DIRUS, "dirs", ""); 196 printdirs(); 197 } 198 199 static void 200 printdirs(void) 201 { 202 struct directory *dp; 203 Char *hp, *s; 204 int cur, idx, len; 205 206 hp = value(STRhome); 207 if (*hp == '\0') 208 hp = NULL; 209 dp = dcwd; 210 idx = 0; 211 cur = 0; 212 do { 213 if (dp == &dhead) 214 continue; 215 if (dirflag & DIR_VERT) { 216 (void)fprintf(cshout, "%d\t", idx++); 217 cur = 0; 218 } 219 if (!(dirflag & DIR_LONG) && hp != NULL && !eq(hp, STRslash) && 220 (len = Strlen(hp), Strncmp(hp, dp->di_name, len) == 0) && 221 (dp->di_name[len] == '\0' || dp->di_name[len] == '/')) 222 len = Strlen(s = (dp->di_name + len)) + 2; 223 else 224 len = Strlen(s = dp->di_name) + 1; 225 226 cur += len; 227 if ((dirflag & DIR_LINE) && cur >= 80 - 1 && len < 80) { 228 (void)fprintf(cshout, "\n"); 229 cur = len; 230 } 231 (void) fprintf(cshout, "%s%s%c", (s != dp->di_name)? "~" : "", 232 vis_str(s), (dirflag & DIR_VERT) ? '\n' : ' '); 233 } while ((dp = dp->di_prev) != dcwd); 234 if (!(dirflag & DIR_VERT)) 235 (void)fprintf(cshout, "\n"); 236 } 237 238 void 239 dtildepr(Char *home, Char *dir) 240 { 241 if (!eq(home, STRslash) && prefix(home, dir)) 242 (void)fprintf(cshout, "~%s", vis_str(dir + Strlen(home))); 243 else 244 (void)fprintf(cshout, "%s", vis_str(dir)); 245 } 246 247 void 248 dtilde(void) 249 { 250 struct directory *d; 251 252 d = dcwd; 253 do { 254 if (d == &dhead) 255 continue; 256 d->di_name = dcanon(d->di_name, STRNULL); 257 } while ((d = d->di_prev) != dcwd); 258 259 dset(dcwd->di_name); 260 } 261 262 263 /* dnormalize(): 264 * If the name starts with . or .. then we might need to normalize 265 * it depending on the symbolic link flags 266 */ 267 Char * 268 dnormalize(Char *cp) 269 { 270 #define UC (unsigned char) 271 #define ISDOT(c) (UC(c)[0] == '.' && ((UC(c)[1] == '\0') || (UC(c)[1] == '/'))) 272 #define ISDOTDOT(c) (UC(c)[0] == '.' && ISDOT(&((c)[1]))) 273 if ((unsigned char) cp[0] == '/') 274 return (Strsave(cp)); 275 276 if (adrof(STRignore_symlinks)) { 277 int dotdot = 0; 278 Char *dp, *cwd; 279 280 cwd = (Char *)xmalloc((size_t)((Strlen(dcwd->di_name) + 3) * 281 sizeof(Char))); 282 (void)Strcpy(cwd, dcwd->di_name); 283 284 /* 285 * Ignore . and count ..'s 286 */ 287 while (*cp) { 288 if (ISDOT(cp)) { 289 if (*++cp) 290 cp++; 291 } 292 else if (ISDOTDOT(cp)) { 293 dotdot++; 294 cp += 2; 295 if (*cp) 296 cp++; 297 } 298 else 299 break; 300 } 301 while (dotdot > 0) { 302 dp = Strrchr(cwd, '/'); 303 if (dp) { 304 *dp = '\0'; 305 dotdot--; 306 } 307 else 308 break; 309 } 310 311 if (*cp) { 312 cwd[dotdot = Strlen(cwd)] = '/'; 313 cwd[dotdot + 1] = '\0'; 314 dp = Strspl(cwd, cp); 315 xfree((ptr_t) cwd); 316 return dp; 317 } 318 else { 319 if (!*cwd) { 320 cwd[0] = '/'; 321 cwd[1] = '\0'; 322 } 323 return cwd; 324 } 325 } 326 return Strsave(cp); 327 } 328 329 /* 330 * dochngd - implement chdir command. 331 */ 332 void 333 /*ARGSUSED*/ 334 dochngd(Char **v, struct command *t) 335 { 336 struct directory *dp; 337 Char *cp; 338 339 skipargs(&v, " [<dir>]"); 340 printd = 0; 341 if (*v == NULL) { 342 if ((cp = value(STRhome)) == NULL || *cp == 0) 343 stderror(ERR_NAME | ERR_NOHOMEDIR); 344 if (chdir(short2str(cp)) < 0) 345 stderror(ERR_NAME | ERR_CANTCHANGE); 346 cp = Strsave(cp); 347 } 348 else if (v[1] != NULL) 349 stderror(ERR_NAME | ERR_TOOMANY); 350 else if ((dp = dfind(*v)) != 0) { 351 char *tmp; 352 353 printd = 1; 354 if (chdir(tmp = short2str(dp->di_name)) < 0) 355 stderror(ERR_SYSTEM, tmp, strerror(errno)); 356 dcwd->di_prev->di_next = dcwd->di_next; 357 dcwd->di_next->di_prev = dcwd->di_prev; 358 dfree(dcwd); 359 dnewcwd(dp); 360 return; 361 } 362 else 363 cp = dfollow(*v); 364 dp = (struct directory *)xcalloc(1, sizeof(struct directory)); 365 dp->di_name = cp; 366 dp->di_count = 0; 367 dp->di_next = dcwd->di_next; 368 dp->di_prev = dcwd->di_prev; 369 dp->di_prev->di_next = dp; 370 dp->di_next->di_prev = dp; 371 dfree(dcwd); 372 dnewcwd(dp); 373 } 374 375 static Char * 376 dgoto(Char *cp) 377 { 378 Char *dp; 379 380 if (*cp != '/') { 381 Char *p, *q; 382 int cwdlen; 383 384 for (p = dcwd->di_name; *p++;) 385 continue; 386 if ((cwdlen = p - dcwd->di_name - 1) == 1) /* root */ 387 cwdlen = 0; 388 for (p = cp; *p++;) 389 continue; 390 dp = (Char *)xmalloc((size_t)((cwdlen + (p - cp) + 1) * sizeof(Char))); 391 for (p = dp, q = dcwd->di_name; (*p++ = *q++) != '\0';) 392 continue; 393 if (cwdlen) 394 p[-1] = '/'; 395 else 396 p--; /* don't add a / after root */ 397 for (q = cp; (*p++ = *q++) != '\0';) 398 continue; 399 xfree((ptr_t) cp); 400 cp = dp; 401 dp += cwdlen; 402 } 403 else 404 dp = cp; 405 406 cp = dcanon(cp, dp); 407 return cp; 408 } 409 410 /* 411 * dfollow - change to arg directory; fall back on cdpath if not valid 412 */ 413 static Char * 414 dfollow(Char *cp) 415 { 416 char ebuf[MAXPATHLEN]; 417 struct varent *c; 418 Char *dp; 419 int serrno; 420 421 cp = globone(cp, G_ERROR); 422 /* 423 * if we are ignoring symlinks, try to fix relatives now. 424 */ 425 dp = dnormalize(cp); 426 if (chdir(short2str(dp)) >= 0) { 427 xfree((ptr_t) cp); 428 return dgoto(dp); 429 } 430 else { 431 xfree((ptr_t) dp); 432 if (chdir(short2str(cp)) >= 0) 433 return dgoto(cp); 434 serrno = errno; 435 } 436 437 if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp) 438 && (c = adrof(STRcdpath))) { 439 Char **cdp; 440 Char *p; 441 Char buf[MAXPATHLEN]; 442 443 for (cdp = c->vec; *cdp; cdp++) { 444 for (dp = buf, p = *cdp; (*dp++ = *p++) != '\0';) 445 continue; 446 dp[-1] = '/'; 447 for (p = cp; (*dp++ = *p++) != '\0';) 448 continue; 449 if (chdir(short2str(buf)) >= 0) { 450 printd = 1; 451 xfree((ptr_t) cp); 452 cp = Strsave(buf); 453 return dgoto(cp); 454 } 455 } 456 } 457 dp = value(cp); 458 if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) { 459 xfree((ptr_t) cp); 460 cp = Strsave(dp); 461 printd = 1; 462 return dgoto(cp); 463 } 464 (void)strcpy(ebuf, short2str(cp)); 465 xfree((ptr_t) cp); 466 stderror(ERR_SYSTEM, ebuf, strerror(serrno)); 467 /* NOTREACHED */ 468 } 469 470 /* 471 * dopushd - push new directory onto directory stack. 472 * with no arguments exchange top and second. 473 * with numeric argument (+n) bring it to top. 474 */ 475 void 476 /*ARGSUSED*/ 477 dopushd(Char **v, struct command *t) 478 { 479 struct directory *dp; 480 481 skipargs(&v, " [<dir>|+<n>]"); 482 printd = 1; 483 if (*v == NULL) { 484 char *tmp; 485 486 if ((dp = dcwd->di_prev) == &dhead) 487 dp = dhead.di_prev; 488 if (dp == dcwd) 489 stderror(ERR_NAME | ERR_NODIR); 490 if (chdir(tmp = short2str(dp->di_name)) < 0) 491 stderror(ERR_SYSTEM, tmp, strerror(errno)); 492 dp->di_prev->di_next = dp->di_next; 493 dp->di_next->di_prev = dp->di_prev; 494 dp->di_next = dcwd->di_next; 495 dp->di_prev = dcwd; 496 dcwd->di_next->di_prev = dp; 497 dcwd->di_next = dp; 498 } 499 else if (v[1] != NULL) 500 stderror(ERR_NAME | ERR_TOOMANY); 501 else if ((dp = dfind(*v)) != NULL) { 502 char *tmp; 503 504 if (chdir(tmp = short2str(dp->di_name)) < 0) 505 stderror(ERR_SYSTEM, tmp, strerror(errno)); 506 } 507 else { 508 Char *ccp; 509 510 ccp = dfollow(*v); 511 dp = (struct directory *)xcalloc(1, sizeof(struct directory)); 512 dp->di_name = ccp; 513 dp->di_count = 0; 514 dp->di_prev = dcwd; 515 dp->di_next = dcwd->di_next; 516 dcwd->di_next = dp; 517 dp->di_next->di_prev = dp; 518 } 519 dnewcwd(dp); 520 } 521 522 /* 523 * dfind - find a directory if specified by numeric (+n) argument 524 */ 525 static struct directory * 526 dfind(Char *cp) 527 { 528 struct directory *dp; 529 Char *ep; 530 int i; 531 532 if (*cp++ != '+') 533 return (0); 534 for (ep = cp; Isdigit(*ep); ep++) 535 continue; 536 if (*ep) 537 return (0); 538 i = getn(cp); 539 if (i <= 0) 540 return (0); 541 for (dp = dcwd; i != 0; i--) { 542 if ((dp = dp->di_prev) == &dhead) 543 dp = dp->di_prev; 544 if (dp == dcwd) 545 stderror(ERR_NAME | ERR_DEEP); 546 } 547 return (dp); 548 } 549 550 /* 551 * dopopd - pop a directory out of the directory stack 552 * with a numeric argument just discard it. 553 */ 554 void 555 /*ARGSUSED*/ 556 dopopd(Char **v, struct command *t) 557 { 558 struct directory *dp, *p = NULL; 559 560 skipargs(&v, " [+<n>]"); 561 printd = 1; 562 if (*v == NULL) 563 dp = dcwd; 564 else if (v[1] != NULL) 565 stderror(ERR_NAME | ERR_TOOMANY); 566 else if ((dp = dfind(*v)) == 0) 567 stderror(ERR_NAME | ERR_BADDIR); 568 if (dp->di_prev == &dhead && dp->di_next == &dhead) 569 stderror(ERR_NAME | ERR_EMPTY); 570 if (dp == dcwd) { 571 char *tmp; 572 573 if ((p = dp->di_prev) == &dhead) 574 p = dhead.di_prev; 575 if (chdir(tmp = short2str(p->di_name)) < 0) 576 stderror(ERR_SYSTEM, tmp, strerror(errno)); 577 } 578 dp->di_prev->di_next = dp->di_next; 579 dp->di_next->di_prev = dp->di_prev; 580 if (dp == dcwd) 581 dnewcwd(p); 582 else { 583 printdirs(); 584 } 585 dfree(dp); 586 } 587 588 /* 589 * dfree - free the directory (or keep it if it still has ref count) 590 */ 591 void 592 dfree(struct directory *dp) 593 { 594 595 if (dp->di_count != 0) { 596 dp->di_next = dp->di_prev = 0; 597 } 598 else { 599 xfree((char *) dp->di_name); 600 xfree((ptr_t) dp); 601 } 602 } 603 604 /* 605 * dcanon - canonicalize the pathname, removing excess ./ and ../ etc. 606 * we are of course assuming that the file system is standardly 607 * constructed (always have ..'s, directories have links) 608 */ 609 Char * 610 dcanon(Char *cp, Char *p) 611 { 612 Char slink[MAXPATHLEN]; 613 char tlink[MAXPATHLEN]; 614 Char *newcp, *sp; 615 Char *p1, *p2; /* general purpose */ 616 int cc; 617 bool slash; 618 619 /* 620 * christos: if the path given does not start with a slash prepend cwd. If 621 * cwd does not start with a path or the result would be too long abort(). 622 */ 623 if (*cp != '/') { 624 Char tmpdir[MAXPATHLEN]; 625 626 p1 = value(STRcwd); 627 if (p1 == NULL || *p1 != '/') 628 abort(); 629 if (Strlen(p1) + Strlen(cp) + 1 >= MAXPATHLEN) 630 abort(); 631 (void)Strcpy(tmpdir, p1); 632 (void)Strcat(tmpdir, STRslash); 633 (void)Strcat(tmpdir, cp); 634 xfree((ptr_t) cp); 635 cp = p = Strsave(tmpdir); 636 } 637 638 while (*p) { /* for each component */ 639 sp = p; /* save slash address */ 640 while (*++p == '/') /* flush extra slashes */ 641 continue; 642 if (p != ++sp) 643 for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';) 644 continue; 645 p = sp; /* save start of component */ 646 slash = 0; 647 while (*++p) /* find next slash or end of path */ 648 if (*p == '/') { 649 slash = 1; 650 *p = 0; 651 break; 652 } 653 654 if (*sp == '\0') { /* if component is null */ 655 if (--sp == cp) /* if path is one char (i.e. /) */ 656 break; 657 else 658 *sp = '\0'; 659 } else if (sp[0] == '.' && sp[1] == 0) { 660 if (slash) { 661 for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';) 662 continue; 663 p = --sp; 664 } 665 else if (--sp != cp) 666 *sp = '\0'; 667 } 668 else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) { 669 /* 670 * We have something like "yyy/xxx/..", where "yyy" can be null or 671 * a path starting at /, and "xxx" is a single component. Before 672 * compressing "xxx/..", we want to expand "yyy/xxx", if it is a 673 * symbolic link. 674 */ 675 *--sp = 0; /* form the pathname for readlink */ 676 if (sp != cp && !adrof(STRignore_symlinks) && 677 (cc = readlink(short2str(cp), tlink, 678 sizeof(tlink) - 1)) >= 0) { 679 tlink[cc] = '\0'; 680 (void)Strcpy(slink, str2short(tlink)); 681 682 if (slash) 683 *p = '/'; 684 /* 685 * Point p to the '/' in "/..", and restore the '/'. 686 */ 687 *(p = sp) = '/'; 688 /* 689 * find length of p 690 */ 691 for (p1 = p; *p1++;) 692 continue; 693 if (*slink != '/') { 694 /* 695 * Relative path, expand it between the "yyy/" and the 696 * "/..". First, back sp up to the character past "yyy/". 697 */ 698 while (*--sp != '/') 699 continue; 700 sp++; 701 *sp = 0; 702 /* 703 * New length is "yyy/" + slink + "/.." and rest 704 */ 705 p1 = newcp = (Char *)xmalloc( 706 (size_t)(((sp - cp) + cc + (p1 - p)) * sizeof(Char))); 707 /* 708 * Copy new path into newcp 709 */ 710 for (p2 = cp; (*p1++ = *p2++) != '\0';) 711 continue; 712 for (p1--, p2 = slink; (*p1++ = *p2++) != '\0';) 713 continue; 714 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';) 715 continue; 716 /* 717 * Restart canonicalization at expanded "/xxx". 718 */ 719 p = sp - cp - 1 + newcp; 720 } 721 else { 722 /* 723 * New length is slink + "/.." and rest 724 */ 725 p1 = newcp = (Char *)xmalloc( 726 (size_t)((cc + (p1 - p)) * sizeof(Char))); 727 /* 728 * Copy new path into newcp 729 */ 730 for (p2 = slink; (*p1++ = *p2++) != '\0';) 731 continue; 732 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';) 733 continue; 734 /* 735 * Restart canonicalization at beginning 736 */ 737 p = newcp; 738 } 739 xfree((ptr_t) cp); 740 cp = newcp; 741 continue; /* canonicalize the link */ 742 } 743 *sp = '/'; 744 if (sp != cp) 745 while (*--sp != '/') 746 continue; 747 if (slash) { 748 for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';) 749 continue; 750 p = sp; 751 } 752 else if (cp == sp) 753 *++sp = '\0'; 754 else 755 *sp = '\0'; 756 } 757 else { /* normal dir name (not . or .. or nothing) */ 758 759 if (sp != cp && adrof(STRchase_symlinks) && 760 !adrof(STRignore_symlinks) && 761 (cc = readlink(short2str(cp), tlink, sizeof(tlink)-1)) >= 0) { 762 tlink[cc] = '\0'; 763 (void)Strcpy(slink, str2short(tlink)); 764 765 /* 766 * restore the '/'. 767 */ 768 if (slash) 769 *p = '/'; 770 771 /* 772 * point sp to p (rather than backing up). 773 */ 774 sp = p; 775 776 /* 777 * find length of p 778 */ 779 for (p1 = p; *p1++;) 780 continue; 781 if (*slink != '/') { 782 /* 783 * Relative path, expand it between the "yyy/" and the 784 * remainder. First, back sp up to the character past 785 * "yyy/". 786 */ 787 while (*--sp != '/') 788 continue; 789 sp++; 790 *sp = 0; 791 /* 792 * New length is "yyy/" + slink + "/.." and rest 793 */ 794 p1 = newcp = (Char *)xmalloc( 795 (size_t)(((sp - cp) + cc + (p1 - p)) * sizeof(Char))); 796 /* 797 * Copy new path into newcp 798 */ 799 for (p2 = cp; (*p1++ = *p2++) != '\0';) 800 continue; 801 for (p1--, p2 = slink; (*p1++ = *p2++) != '\0';) 802 continue; 803 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';) 804 continue; 805 /* 806 * Restart canonicalization at expanded "/xxx". 807 */ 808 p = sp - cp - 1 + newcp; 809 } 810 else { 811 /* 812 * New length is slink + the rest 813 */ 814 p1 = newcp = (Char *)xmalloc( 815 (size_t)((cc + (p1 - p)) * sizeof(Char))); 816 /* 817 * Copy new path into newcp 818 */ 819 for (p2 = slink; (*p1++ = *p2++) != '\0';) 820 continue; 821 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';) 822 continue; 823 /* 824 * Restart canonicalization at beginning 825 */ 826 p = newcp; 827 } 828 xfree((ptr_t) cp); 829 cp = newcp; 830 continue; /* canonicalize the link */ 831 } 832 if (slash) 833 *p = '/'; 834 } 835 } 836 837 /* 838 * fix home... 839 */ 840 p1 = value(STRhome); 841 cc = Strlen(p1); 842 /* 843 * See if we're not in a subdir of STRhome 844 */ 845 if (p1 && *p1 == '/' && 846 (Strncmp(p1, cp, cc) != 0 || (cp[cc] != '/' && cp[cc] != '\0'))) { 847 static ino_t home_ino; 848 static dev_t home_dev = NODEV; 849 static Char *home_ptr = NULL; 850 struct stat statbuf; 851 852 /* 853 * Get dev and ino of STRhome 854 */ 855 if (home_ptr != p1 && 856 stat(short2str(p1), &statbuf) != -1) { 857 home_dev = statbuf.st_dev; 858 home_ino = statbuf.st_ino; 859 home_ptr = p1; 860 } 861 /* 862 * Start comparing dev & ino backwards 863 */ 864 p2 = Strcpy(slink, cp); 865 for (sp = NULL; *p2 && stat(short2str(p2), &statbuf) != -1;) { 866 if (statbuf.st_dev == home_dev && 867 statbuf.st_ino == home_ino) { 868 sp = (Char *) - 1; 869 break; 870 } 871 if ((sp = Strrchr(p2, '/')) != NULL) 872 *sp = '\0'; 873 } 874 /* 875 * See if we found it 876 */ 877 if (*p2 && sp == (Char *) -1) { 878 /* 879 * Use STRhome to make '~' work 880 */ 881 newcp = Strspl(p1, cp + Strlen(p2)); 882 xfree((ptr_t) cp); 883 cp = newcp; 884 } 885 } 886 return cp; 887 } 888 889 890 /* 891 * dnewcwd - make a new directory in the loop the current one 892 */ 893 static void 894 dnewcwd(struct directory *dp) 895 { 896 dcwd = dp; 897 dset(dcwd->di_name); 898 if (printd && !(adrof(STRpushdsilent))) 899 printdirs(); 900 } 901
Indexes created Tue Sep 23 07:09:52 GMT 2025