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_arr(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                 ret = NULL;
 249                 goto out;
 250         }
 251
 252         /* How much is in common? */
 253         for (common = i = 0; cfrom[i] && cto[i]; i++) {
 254                 if (cfrom[i] != cto[i])
 255                         break;
 256                 if (cfrom[i] == PATH_SEP)
 257                         common = i + 1;
 258         }
 259
 260         /* Skip over / if matches end of other path.  */
 261         if (!cfrom[i] && cto[i] == PATH_SEP) {
 262                 cto++;
 263                 common = i;
 264         } else if (!cto[i] && cfrom[i] == PATH_SEP) {
 265                 cfrom++;
 266                 common = i;
 267         }
 268
 269         /* Normalize so strings point past common area. */
 270         cfrom += common;
 271         cto += common;
 272
 273         /* One .. for every path element remaining in 'from', to get
 274          * back to common prefix.  Then the rest of 'to'. */
 275         num_back = strcount(cfrom, PATH_SEP_STR);
 276         postlen = strlen(cto) + 1;
 277
 278         /* Nothing left?  That's ".". */
 279         if (num_back == 0 && postlen == 1) {
 280                 ret = tal_strdup(ctx, ".");
 281                 goto out;
 282         }
 283
 284         ret = tal_arr(ctx, char,
 285                       strlen(".." PATH_SEP_STR) * num_back + postlen);
 286         if (!ret)
 287                 goto out;
 288
 289         for (i = 0, p = ret; i < num_back; i++, p += strlen(".." PATH_SEP_STR))
 290                 memcpy(p, ".." PATH_SEP_STR, strlen(".." PATH_SEP_STR));
 291         /* Nothing to append?  Trim the final / */
 292         if (postlen == 1)
 293                 p--;
 294         memcpy(p, cto, postlen);
 295
 296 out:
 297         tal_free(tmpctx);
 298         return ret;
 299
 300 fail_take_to:
 301         if (taken(to))
 302                 tal_free(to);
 303         ret = NULL;
 304         goto out;
 305 }
 306
 307  char *path_readlink(const tal_t *ctx, const char *linkname)
 308  {
 309         ssize_t len, maxlen = 64; /* good first guess. */
 310         char *ret = NULL;
 311
 312         if (unlikely(!linkname) && is_taken(linkname))
 313                 goto fail;
 314
 315         ret = tal_arr(ctx, char, maxlen + 1);
 316
 317         while (ret) {
 318                 len = readlink(linkname, ret, maxlen);
 319                 if (len < 0)
 320                         goto fail;
 321                 if (len < maxlen)
 322                         break;
 323
 324                 if (!tal_resize(&ret, maxlen *= 2 + 1))
 325                         goto fail;
 326         }
 327
 328         if (ret)
 329                 ret[len] = '\0';
 330
 331 out:
 332         if (taken(linkname))
 333                 tal_free(linkname);
 334
 335         return ret;
 336
 337 fail:
 338         ret = tal_free(ret);
 339         goto out;
 340 }
 341
 342 char *path_simplify(const tal_t *ctx, const char *path)
 343 {
 344         size_t i, j, start, len;
 345         char *ret;
 346         bool ended = false;
 347
 348         ret = tal_strdup(ctx, path);
 349         if (!ret)
 350                 return NULL;
 351
 352         /* Always need first / if there is one. */
 353         if (ret[0] == PATH_SEP)
 354                 start = 1;
 355         else
 356                 start = 0;
 357
 358         for (i = j = start; !ended; i += len) {
 359                 /* Get length of this segment, including terminator. */
 360                 for (len = 0; ret[i+len] != PATH_SEP; len++) {
 361                         if (!ret[i+len]) {
 362                                 ended = true;
 363                                 break;
 364                         }
 365                 }
 366                 len++;
 367
 368                 /* Empty segment is //; ignore first one. */
 369                 if (len == 1)
 370                         continue;
 371
 372                 /* Always ignore slashdot. */
 373                 if (len == 2 && ret[i] == '.')
 374                         continue;
 375
 376                 /* .. => remove previous if there is one, unless symlink. */
 377                 if (len == 3 && ret[i] == '.' && ret[i+1] == '.') {
 378                         struct stat st;
 379
 380                         if (j > start) {
 381                                 /* eg. /foo/, foo/ or foo/bar/ */
 382                                 assert(ret[j-1] == PATH_SEP);
 383                                 ret[j-1] = '\0';
 384
 385                                 /* Avoid stepping back over ..! */
 386                                 if (streq(ret, "..")
 387                                     || strends(ret, PATH_SEP_STR"..")) {
 388                                         ret[j-1] = PATH_SEP;
 389                                         goto copy;
 390                                 }
 391
 392                                 if (lstat(ret, &st) == 0
 393                                     && !S_ISLNK(st.st_mode)) {
 394                                         char *sep = strrchr(ret, PATH_SEP);
 395                                         if (sep)
 396                                                 j = sep - ret + 1;
 397                                         else
 398                                                 j = 0;
 399                                 }
 400                                 continue;
 401                         } else if (start) {
 402                                 /* /.. => / */
 403                                 j = 1;
 404                                 /* nul term in case we're at end */
 405                                 ret[1] = '\0';
 406                                 continue;
 407                         }
 408                 }
 409
 410         copy:
 411                 memmove(ret + j, ret + i, len);
 412                 /* Don't count nul terminator. */
 413                 j += len - ended;
 414         }
 415
 416         /* Empty string created by ../ elimination. */
 417         if (j == 0) {
 418                 ret[0] = '.';
 419                 ret[1] = '\0';
 420         } else if (j > 1 && ret[j-1] == PATH_SEP) {
 421                 ret[j-1] = '\0';
 422         } else
 423                 ret[j] = '\0';
 424
 425         return ret;
 426 }
 427
 428 char *path_basename(const tal_t *ctx, const char *path)
 429 {
 430         const char *sep;
 431         char *ret;
 432
 433         if (unlikely(!path) && taken(path))
 434                 return NULL;
 435
 436         sep = strrchr(path, PATH_SEP);
 437         if (!sep)
 438                 return tal_strdup(ctx, path);
 439
 440         /* Trailing slashes need to be trimmed. */
 441         if (!sep[1]) {
 442                 const char *end;
 443
 444                 for (end = sep; end != path; end--)
 445                         if (*end != PATH_SEP)
 446                                 break;
 447
 448                 /* Find *previous* / */
 449                 for (sep = end; sep >= path && *sep != PATH_SEP; sep--);
 450
 451                 /* All /?  Just return / */
 452                 if (end == sep)
 453                         ret = tal_strdup(ctx, PATH_SEP_STR);
 454                 else
 455                         ret = tal_strndup(ctx, sep+1, end - sep);
 456         } else
 457                 ret = tal_strdup(ctx, sep + 1);
 458
 459         if (taken(path))
 460                 tal_free(path);
 461         return ret;
 462 }
 463
 464 /* This reuses str if we're to take it. */
 465 static char *fixed_string(const tal_t *ctx,
 466                           const char *str, const char *path)
 467 {
 468         char *ret = tal_dup_arr(ctx, char, path, 0, strlen(str)+1);
 469         if (ret)
 470                 strcpy(ret, str);
 471         return ret;
 472 }
 473
 474 char *path_dirname(const tal_t *ctx, const char *path)
 475 {
 476         const char *sep;
 477
 478         if (unlikely(!path) && taken(path))
 479                 return NULL;
 480
 481         sep = strrchr(path, PATH_SEP);
 482         if (!sep)
 483                 return fixed_string(ctx, ".", path);
 484
 485         /* Trailing slashes need to be trimmed. */
 486         if (!sep[1]) {
 487                 const char *end;
 488
 489                 for (end = sep; end != path; end--)
 490                         if (*end != PATH_SEP)
 491                                 break;
 492
 493                 /* Find *previous* / */
 494                 for (sep = end; sep > path && *sep != PATH_SEP; sep--);
 495         }
 496
 497         /* In case there are multiple / in a row. */
 498         while (sep > path && sep[-1] == PATH_SEP)
 499                 sep--;
 500
 501         if (sep == path) {
 502                 if (path_is_abs(path))
 503                         return tal_strndup(ctx, path, 1);
 504                 else
 505                         return fixed_string(ctx, ".", path);
 506         }
 507         return tal_strndup(ctx, path, sep - path);
 508 }
 509
 510 bool path_is_abs(const char *path)
 511 {
 512         return path[0] == PATH_SEP;
 513 }
 514
 515 bool path_is_file(const char *path)
 516 {
 517         struct stat st;
 518
 519         return stat(path, &st) == 0 && S_ISREG(st.st_mode);
 520 }
 521
 522 bool path_is_dir(const char *path)
 523 {
 524         struct stat st;
 525
 526         return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
 527 }
 528
 529 char **path_split(const tal_t *ctx, const char *path)
 530 {
 531         bool empty = path && !path[0];
 532         char **ret = tal_strsplit(ctx, path, PATH_SEP_STR, STR_NO_EMPTY);
 533
 534         /* Handle the "/" case */
 535         if (ret && !empty && !ret[0]) {
 536                 if (!tal_resize(&ret, 2))
 537                         ret = tal_free(ret);
 538                 else {
 539                         ret[1] = NULL;
 540                         ret[0] = tal_strdup(ret, PATH_SEP_STR);
 541                         if (!ret[0])
 542                                 ret = tal_free(ret);
 543                 }
 544         }
 545
 546         return ret;
 547 }
 548
 549 size_t path_ext_off(const char *path)
 550 {
 551         const char *dot, *base;
 552
 553         dot = strrchr(path, '.');
 554         if (dot) {
 555                 base = strrchr(path, PATH_SEP);
 556                 if (!base)
 557                         base = path;
 558                 else
 559                         base++;
 560                 if (dot > base)
 561                         return dot - path;
 562         }
 563         return strlen(path);
 564 }