git.ozlabs.org Git - ccan/blob - ccan/tal/path/path.c

   1 /* Licensed under BSD-MIT - see LICENSE file for details */
   2 #include <ccan/tal/path/path.h>
   3 #include <ccan/str/str.h>
   4 #include <ccan/take/take.h>
   5 #include <ccan/tal/str/str.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9 #include <unistd.h>
  10 #include <limits.h>
  11 #include <stdlib.h>
  12 #include <errno.h>
  13 #include <assert.h>
  14
  15 #define PATH_SEP_STR "/"
  16 #define PATH_SEP (PATH_SEP_STR[0])
  17
  18 char *path_cwd(const tal_t *ctx)
  19 {
  20         size_t len = 64;
  21         char *cwd;
  22
  23         /* *This* is why people hate C. */
  24         cwd = tal_arr(ctx, char, len);
  25         while (cwd && !getcwd(cwd, len)) {
  26                 if (errno != ERANGE || !tal_resize(&cwd, len *= 2))
  27                         cwd = tal_free(cwd);
  28         }
  29         return cwd;
  30 }
  31
  32 char *path_join(const tal_t *ctx, const char *base, const char *a)
  33 {
  34         char *ret = NULL;
  35         size_t len;
  36
  37         if (unlikely(!a) && taken(a)) {
  38                 if (taken(base))
  39                         tal_free(base);
  40                 return NULL;
  41         }
  42
  43         if (a[0] == PATH_SEP) {
  44                 if (taken(base))
  45                         tal_free(base);
  46                 return tal_strdup(ctx, a);
  47         }
  48
  49         if (unlikely(!base) && taken(base))
  50                 goto out;
  51
  52         len = strlen(base);
  53         ret = tal_dup(ctx, char, base, len, 1 + strlen(a) + 1);
  54         if (!ret)
  55                 goto out;
  56         if (ret[len-1] != PATH_SEP)
  57                 ret[len++] = PATH_SEP;
  58         strcpy(ret + len, a);
  59
  60 out:
  61         if (taken(a))
  62                 tal_free(a);
  63         return ret;
  64 }
  65
  66 #if HAVE_FCHDIR
  67 struct path_pushd {
  68         int fd;
  69 };
  70
  71 static void pushd_destroy(struct path_pushd *pushd)
  72 {
  73         close(pushd->fd);
  74 }
  75
  76 struct path_pushd *path_pushd(const tal_t *ctx, const char *dir)
  77 {
  78         struct path_pushd *old = tal(ctx, struct path_pushd);
  79
  80         if (!old)
  81                 return NULL;
  82
  83         if (unlikely(!dir) && taken(dir))
  84                 return tal_free(old);
  85
  86         if (!tal_add_destructor(old, pushd_destroy))
  87                 old = tal_free(old);
  88         else {
  89                 old->fd = open(".", O_RDONLY);
  90                 if (old->fd < 0)
  91                         old = tal_free(old);
  92                 else if (chdir(dir) != 0)
  93                         old = tal_free(old);
  94         }
  95
  96         if (taken(dir))
  97                 tal_free(dir);
  98         return old;
  99 }
 100
 101 bool path_popd(struct path_pushd *olddir)
 102 {
 103         bool ok = (fchdir(olddir->fd) == 0);
 104
 105         tal_free(olddir);
 106         return ok;
 107 }
 108 #else
 109 struct path_pushd {
 110         const char *olddir;
 111 };
 112
 113 struct path_pushd *path_pushd(const tal_t *ctx, const char *dir)
 114 {
 115         struct path_pushd *old = tal(ctx, struct path_pushd);
 116
 117         if (!old)
 118                 return NULL;
 119
 120         old->olddir = path_cwd(old);
 121         if (unlikely(!old->olddir))
 122                 old = tal_free(old);
 123         else if (unlikely(!dir) && is_taken(dir))
 124                 old = tal_free(old);
 125         else if (chdir(dir) != 0)
 126                 old = tal_free(old);
 127
 128         if (taken(dir))
 129                 tal_free(dir);
 130
 131         return old;
 132 }
 133
 134 bool path_popd(struct path_pushd *olddir)
 135 {
 136         bool ok = (chdir(olddir->olddir) == 0);
 137
 138         tal_free(olddir);
 139         return ok;
 140 }
 141 #endif /* !HAVE_FCHDIR */
 142
 143 char *path_canon(const tal_t *ctx, const char *a)
 144 {
 145 #if 0
 146         char *oldcwd, *path, *p;
 147         void *tmpctx;
 148         size_t len;
 149         struct path_pushd *olddir;
 150
 151         /* A good guess as to size. */
 152         len = strlen(a) + 1;
 153         if (a[0] != PATH_SEP) {
 154                 tmpctx = oldcwd = path_cwd(ctx);
 155                 if (!oldcwd)
 156                         return NULL;
 157                 len += strlen(oldcwd) + strlen(PATH_SEP_STR);
 158
 159                 path = tal_array(tmpctx, char, len);
 160                 if (!path)
 161                         goto out;
 162
 163                 len = strlen(oldcwd);
 164                 memcpy(path, oldcwd, len);
 165                 path[len++] = PATH_SEP;
 166         } else {
 167                 tmpctx = path = tal_array(ctx, char, len);
 168                 if (!path)
 169                         return NULL;
 170                 len = 0;
 171         }
 172         strcpy(path + len, a);
 173
 174         p = strrchr(path, PATH_SEP);
 175         *p = '\0';
 176
 177         olddir = path_pushd(tmpctx, path);
 178         if (!olddir)
 179                 goto out;
 180
 181         /* Make OS canonicalize path for us. */
 182         path = path_cwd(tmpctx);
 183         if (!path)
 184                 goto out;
 185
 186         /* Append rest of old path. */
 187         len = strlen(p+1);
 188         if (len) {
 189                 size_t oldlen = tal_array_length(path);
 190                 if (path[oldlen-1] != PATH_SEP) {
 191                         /* Include / to append. */
 192                         *p = PATH_SEP;
 193                         p--;
 194                         len++;
 195                 }
 196                 path = tal_realloc(NULL, path, char, oldlen+len+1);
 197                 if (!path)
 198                         goto out;
 199                 memcpy(path + oldlen, p, len+1);
 200         }
 201
 202         path = tal_steal(ctx, path);
 203 out:
 204         /* This can happen if old cwd is deleted. */
 205         if (!path_popd(olddir))
 206                 path = tal_free(path);
 207
 208         tal_free(tmpctx);
 209         return path;
 210 #else
 211         char *path;
 212         if (unlikely(!a) && is_taken(a))
 213                 path = NULL;
 214         else {
 215                 path = tal_arr(ctx, char, PATH_MAX);
 216                 if (path && !realpath(a, path))
 217                         path = tal_free(path);
 218         }
 219         if (taken(a))
 220                 tal_free(a);
 221         return path;
 222 #endif
 223 }
 224
 225 /* Symlinks make this hard! */
 226 char *path_rel(const tal_t *ctx, const char *from, const char *to)
 227 {
 228         char *cfrom, *cto, *ret, *p;
 229         tal_t *tmpctx;
 230         size_t common, num_back, i, postlen;
 231
 232         /* This frees from if we're supposed to take it. */
 233         tmpctx = cfrom = path_canon(ctx, from);
 234         if (!cfrom)
 235                 goto fail_take_to;
 236
 237         /* From is a directory, so we append / to it. */
 238         if (!streq(cfrom, PATH_SEP_STR)) {
 239                 if (!tal_resize(&cfrom, strlen(cfrom)+2))
 240                         goto fail_take_to;
 241                 tmpctx = cfrom;
 242                 strcat(cfrom, PATH_SEP_STR);
 243         }
 244
 245         /* This frees to if we're supposed to take it. */
 246         cto = path_canon(tmpctx, to);
 247         if (!cto)
 248                 goto out;
 249
 250         /* How much is in common? */
 251         for (common = i = 0; cfrom[i] && cto[i]; i++) {
 252                 if (cfrom[i] != cto[i])
 253                         break;
 254                 if (cfrom[i] == PATH_SEP)
 255                         common = i + 1;
 256         }
 257
 258         /* Skip over / if matches end of other path.  */
 259         if (!cfrom[i] && cto[i] == PATH_SEP) {
 260                 cto++;
 261                 common = i;
 262         } else if (!cto[i] && cfrom[i] == PATH_SEP) {
 263                 cfrom++;
 264                 common = i;
 265         }
 266
 267         /* Normalize so strings point past common area. */
 268         cfrom += common;
 269         cto += common;
 270
 271         /* One .. for every path element remaining in 'from', to get
 272          * back to common prefix.  Then the rest of 'to'. */
 273         num_back = strcount(cfrom, PATH_SEP_STR);
 274         postlen = strlen(cto) + 1;
 275
 276         /* Nothing left?  That's ".". */
 277         if (num_back == 0 && postlen == 1) {
 278                 ret = tal_strdup(ctx, ".");
 279                 goto out;
 280         }
 281
 282         ret = tal_arr(ctx, char,
 283                       strlen(".." PATH_SEP_STR) * num_back + postlen);
 284         if (!ret)
 285                 goto out;
 286
 287         for (i = 0, p = ret; i < num_back; i++, p += strlen(".." PATH_SEP_STR))
 288                 memcpy(p, ".." PATH_SEP_STR, strlen(".." PATH_SEP_STR));
 289         /* Nothing to append?  Trim the final / */
 290         if (postlen == 1)
 291                 p--;
 292         memcpy(p, cto, postlen);
 293
 294 out:
 295         tal_free(tmpctx);
 296         return ret;
 297
 298 fail_take_to:
 299         if (taken(to))
 300                 tal_free(to);
 301         ret = NULL;
 302         goto out;
 303 }
 304
 305  char *path_readlink(const tal_t *ctx, const char *linkname)
 306  {
 307         ssize_t len, maxlen = 64; /* good first guess. */
 308         char *ret = NULL;
 309
 310         if (unlikely(!linkname) && is_taken(linkname))
 311                 goto fail;
 312
 313         ret = tal_arr(ctx, char, maxlen + 1);
 314
 315         while (ret) {
 316                 len = readlink(linkname, ret, maxlen);
 317                 if (len < 0)
 318                         goto fail;
 319                 if (len < maxlen)
 320                         break;
 321
 322                 if (!tal_resize(&ret, maxlen *= 2 + 1))
 323                         goto fail;
 324         }
 325
 326         ret[len] = '\0';
 327 out:
 328         if (taken(linkname))
 329                 tal_free(linkname);
 330
 331         return ret;
 332
 333 fail:
 334         ret = tal_free(ret);
 335         goto out;
 336 }
 337
 338 char *path_simplify(const tal_t *ctx, const char *path)
 339 {
 340         size_t i, j, start, len;
 341         char *ret;
 342         bool ended = false;
 343
 344         ret = tal_strdup(ctx, path);
 345         if (!ret)
 346                 return NULL;
 347
 348         /* Always need first / if there is one. */
 349         if (ret[0] == PATH_SEP)
 350                 start = 1;
 351         else
 352                 start = 0;
 353
 354         for (i = j = start; !ended; i += len) {
 355                 /* Get length of this segment, including terminator. */
 356                 for (len = 0; ret[i+len] != PATH_SEP; len++) {
 357                         if (!ret[i+len]) {
 358                                 ended = true;
 359                                 break;
 360                         }
 361                 }
 362                 len++;
 363
 364                 /* Empty segment is //; ignore first one. */
 365                 if (len == 1)
 366                         continue;
 367
 368                 /* Always ignore slashdot. */
 369                 if (len == 2 && ret[i] == '.')
 370                         continue;
 371
 372                 /* .. => remove previous if there is one, unless symlink. */
 373                 if (len == 3 && ret[i] == '.' && ret[i+1] == '.') {
 374                         struct stat st;
 375
 376                         if (j > start) {
 377                                 /* eg. /foo/, foo/ or foo/bar/ */
 378                                 assert(ret[j-1] == PATH_SEP);
 379                                 ret[j-1] = '\0';
 380
 381                                 /* Avoid stepping back over ..! */
 382                                 if (streq(ret, "..")
 383                                     || strends(ret, PATH_SEP_STR"..")) {
 384                                         ret[j-1] = PATH_SEP;
 385                                         goto copy;
 386                                 }
 387
 388                                 if (lstat(ret, &st) == 0
 389                                     && !S_ISLNK(st.st_mode)) {
 390                                         char *sep = strrchr(ret, PATH_SEP);
 391                                         if (sep)
 392                                                 j = sep - ret + 1;
 393                                         else
 394                                                 j = 0;
 395                                 }
 396                                 continue;
 397                         } else if (start) {
 398                                 /* /.. => / */
 399                                 j = 1;
 400                                 /* nul term in case we're at end */
 401                                 ret[1] = '\0';
 402                                 continue;
 403                         }
 404                 }
 405
 406         copy:
 407                 memmove(ret + j, ret + i, len);
 408                 /* Don't count nul terminator. */
 409                 j += len - ended;
 410         }
 411
 412         /* Empty string created by ../ elimination. */
 413         if (j == 0) {
 414                 ret[0] = '.';
 415                 ret[1] = '\0';
 416         } else if (j > 1 && ret[j-1] == PATH_SEP) {
 417                 ret[j-1] = '\0';
 418         } else
 419                 ret[j] = '\0';
 420
 421         return ret;
 422 }
 423
 424 char *path_basename(const tal_t *ctx, const char *path)
 425 {
 426         const char *sep;
 427         char *ret;
 428
 429         if (unlikely(!path) && taken(path))
 430                 return NULL;
 431
 432         sep = strrchr(path, PATH_SEP);
 433         if (!sep)
 434                 return tal_strdup(ctx, path);
 435
 436         /* Trailing slashes need to be trimmed. */
 437         if (!sep[1]) {
 438                 const char *end;
 439
 440                 for (end = sep; end != path; end--)
 441                         if (*end != PATH_SEP)
 442                                 break;
 443
 444                 /* Find *previous* / */
 445                 for (sep = end; sep >= path && *sep != PATH_SEP; sep--);
 446
 447                 /* All /?  Just return / */
 448                 if (end == sep)
 449                         ret = tal_strdup(ctx, PATH_SEP_STR);
 450                 else
 451                         ret = tal_strndup(ctx, sep+1, end - sep);
 452         } else
 453                 ret = tal_strdup(ctx, sep + 1);
 454
 455         if (taken(path))
 456                 tal_free(path);
 457         return ret;
 458 }
 459
 460 /* This reuses str if we're to take it. */
 461 static char *fixed_string(const tal_t *ctx,
 462                           const char *str, const char *path)
 463 {
 464         char *ret = tal_dup(ctx, char, path, 0, strlen(str)+1);
 465         if (ret)
 466                 strcpy(ret, str);
 467         return ret;
 468 }
 469
 470 char *path_dirname(const tal_t *ctx, const char *path)
 471 {
 472         const char *sep;
 473
 474         if (unlikely(!path) && taken(path))
 475                 return NULL;
 476
 477         sep = strrchr(path, PATH_SEP);
 478         if (!sep)
 479                 return fixed_string(ctx, ".", path);
 480
 481         /* Trailing slashes need to be trimmed. */
 482         if (!sep[1]) {
 483                 const char *end;
 484
 485                 for (end = sep; end != path; end--)
 486                         if (*end != PATH_SEP)
 487                                 break;
 488
 489                 /* Find *previous* / */
 490                 for (sep = end; sep > path && *sep != PATH_SEP; sep--);
 491         }
 492
 493         /* In case there are multiple / in a row. */
 494         while (sep > path && sep[-1] == PATH_SEP)
 495                 sep--;
 496
 497         if (sep == path) {
 498                 if (path_is_abs(path))
 499                         return tal_strndup(ctx, path, 1);
 500                 else
 501                         return fixed_string(ctx, ".", path);
 502         }
 503         return tal_strndup(ctx, path, sep - path);
 504 }
 505
 506 bool path_is_abs(const char *path)
 507 {
 508         return path[0] == PATH_SEP;
 509 }
 510
 511 bool path_is_file(const char *path)
 512 {
 513         struct stat st;
 514
 515         return stat(path, &st) == 0 && S_ISREG(st.st_mode);
 516 }
 517
 518 bool path_is_dir(const char *path)
 519 {
 520         struct stat st;
 521
 522         return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
 523 }
 524
 525 char **path_split(const tal_t *ctx, const char *path)
 526 {
 527         bool empty = path && !path[0];
 528         char **ret = strsplit(ctx, path, PATH_SEP_STR, STR_NO_EMPTY);
 529
 530         /* Handle the "/" case */
 531         if (ret && !empty && !ret[0]) {
 532                 if (!tal_resize(&ret, 2))
 533                         ret = tal_free(ret);
 534                 else {
 535                         ret[1] = NULL;
 536                         ret[0] = tal_strdup(ret, PATH_SEP_STR);
 537                         if (!ret[0])
 538                                 ret = tal_free(ret);
 539                 }
 540         }
 541
 542         return ret;
 543 }
 544
 545 size_t path_ext_off(const char *path)
 546 {
 547         const char *dot, *base;
 548
 549         dot = strrchr(path, '.');
 550         if (dot) {
 551                 base = strrchr(path, PATH_SEP);
 552                 if (!base)
 553                         base = path;
 554                 else
 555                         base++;
 556                 if (dot > base)
 557                         return dot - path;
 558         }
 559         return strlen(path);
 560 }