lib/path.c

   1 /*
   2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
   3  * Copyright (c) 2015 Theo de Raadt <deraadt@openbsd.org>
   4  * Copyright (c) 1997 Todd C. Miller <millert@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "got_compat.h"
  20
  21 #include <sys/queue.h>
  22 #include <sys/stat.h>
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <limits.h>
  27 #include <libgen.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <dirent.h>
  33 #include <paths.h>
  34
  35 #include "got_error.h"
  36 #include "got_path.h"
  37
  38 #ifndef MIN
  39 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
  40 #endif
  41
  42 int
  43 got_path_is_absolute(const char *path)
  44 {
  45         return path[0] == '/';
  46 }
  47
  48 /* based on canonpath() from kern_pledge.c */
  49 const struct got_error *
  50 got_canonpath(const char *input, char *buf, size_t bufsize)
  51 {
  52         const char *p;
  53         char *q;
  54
  55         /* can't canon relative paths, don't bother */
  56         if (!got_path_is_absolute(input)) {
  57                 if (strlcpy(buf, input, bufsize) >= bufsize)
  58                         return got_error(GOT_ERR_NO_SPACE);
  59                 return NULL;
  60         }
  61
  62         p = input;
  63         q = buf;
  64         while (*p && (q - buf < bufsize)) {
  65                 if (p[0] == '/' && (p[1] == '/' || p[1] == '\0')) {
  66                         p += 1;
  67
  68                 } else if (p[0] == '/' && p[1] == '.' &&
  69                     (p[2] == '/' || p[2] == '\0')) {
  70                         p += 2;
  71
  72                 } else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
  73                     (p[3] == '/' || p[3] == '\0')) {
  74                         p += 3;
  75                         if (q != buf)   /* "/../" at start of buf */
  76                                 while (*--q != '/')
  77                                         continue;
  78
  79                 } else {
  80                         *q++ = *p++;
  81                 }
  82         }
  83         if ((*p == '\0') && (q - buf < bufsize)) {
  84                 *q = 0;
  85                 return NULL;
  86         } else
  87                 return got_error(GOT_ERR_NO_SPACE);
  88 }
  89
  90 const struct got_error *
  91 got_path_skip_common_ancestor(char **child, const char *parent_abspath,
  92     const char *abspath)
  93 {
  94         const struct got_error *err = NULL;
  95         size_t len_parent, len, bufsize;
  96
  97         *child = NULL;
  98
  99         len_parent = strlen(parent_abspath);
 100         len = strlen(abspath);
 101         if (len_parent >= len)
 102                 return got_error_path(abspath, GOT_ERR_BAD_PATH);
 103         if (strncmp(parent_abspath, abspath, len_parent) != 0)
 104                 return got_error_path(abspath, GOT_ERR_BAD_PATH);
 105         if (!got_path_is_root_dir(parent_abspath) && abspath[len_parent] != '/')
 106                 return got_error_path(abspath, GOT_ERR_BAD_PATH);
 107         while (abspath[len_parent] == '/')
 108                 abspath++;
 109         bufsize = len - len_parent + 1;
 110         *child = malloc(bufsize);
 111         if (*child == NULL)
 112                 return got_error_from_errno("malloc");
 113         if (strlcpy(*child, abspath + len_parent, bufsize) >= bufsize) {
 114                 err = got_error_from_errno("strlcpy");
 115                 free(*child);
 116                 *child = NULL;
 117                 return err;
 118         }
 119         return NULL;
 120 }
 121
 122 const struct got_error *
 123 got_path_strip(char **out, const char *path, int n)
 124 {
 125         const char *p, *c;
 126
 127         p = path;
 128         *out = NULL;
 129
 130         while (n > 0 && (c = strchr(p, '/')) != NULL) {
 131                 p = c + 1;
 132                 n--;
 133         }
 134
 135         if (n > 0)
 136                 return got_error_fmt(GOT_ERR_BAD_PATH,
 137                     "can't strip %d path-components from %s", n, path);
 138
 139         if ((*out = strdup(p)) == NULL)
 140                 return got_error_from_errno("strdup");
 141         return NULL;
 142 }
 143
 144 int
 145 got_path_is_root_dir(const char *path)
 146 {
 147         while (*path == '/')
 148                 path++;
 149         return (*path == '\0');
 150 }
 151
 152 int
 153 got_path_is_child(const char *child, const char *parent, size_t parent_len)
 154 {
 155         if (parent_len == 0 || got_path_is_root_dir(parent))
 156                 return 1;
 157
 158         if (strncmp(parent, child, parent_len) != 0)
 159                 return 0;
 160         if (child[parent_len] != '/')
 161                 return 0;
 162
 163         return 1;
 164 }
 165
 166 int
 167 got_path_cmp(const char *path1, const char *path2, size_t len1, size_t len2)
 168 {
 169         size_t min_len;
 170         size_t i = 0;
 171
 172         /* Leading directory separators are insignificant. */
 173         while (path1[0] == '/') {
 174                 path1++;
 175                 len1--;
 176         }
 177         while (path2[0] == '/') {
 178                 path2++;
 179                 len2--;
 180         }
 181
 182         min_len = MIN(len1, len2);
 183
 184         /* Skip over common prefix. */
 185         while (i < min_len && path1[i] == path2[i])
 186                 i++;
 187
 188         /* Are the paths exactly equal (besides path separators)? */
 189         if (len1 == len2 && i >= min_len)
 190                 return 0;
 191
 192         /* Skip over redundant trailing path seperators. */
 193         while (path1[i] == '/' && path1[i + 1] == '/')
 194                 path1++;
 195         while (path2[i] == '/' && path2[i + 1] == '/')
 196                 path2++;
 197
 198         /* Trailing path separators are insignificant. */
 199         if (path1[i] == '/' && path1[i + 1] == '\0' && path2[i] == '\0')
 200                 return 0;
 201         if (path2[i] == '/' && path2[i + 1] == '\0' && path1[i] == '\0')
 202                 return 0;
 203
 204         /* Order children in subdirectories directly after their parents. */
 205         if (path1[i] == '/' && path2[i] == '\0')
 206                 return 1;
 207         if (path2[i] == '/' && path1[i] == '\0')
 208                 return -1;
 209         if (path1[i] == '/' && path2[i] != '\0')
 210                 return -1;
 211         if (path2[i] == '/' && path1[i] != '\0')
 212                 return 1;
 213
 214         /* Next character following the common prefix determines order. */
 215         return (unsigned char)path1[i] < (unsigned char)path2[i] ? -1 : 1;
 216 }
 217
 218 const struct got_error *
 219 got_pathlist_insert(struct got_pathlist_entry **inserted,
 220     struct got_pathlist_head *pathlist, const char *path, void *data)
 221 {
 222         struct got_pathlist_entry *new, *pe;
 223         size_t path_len = strlen(path);
 224
 225         if (inserted)
 226                 *inserted = NULL;
 227
 228         /*
 229          * Many callers will provide paths in a somewhat sorted order while
 230          * constructing a path list from inputs such as tree objects or
 231          * dirents. Iterating backwards from the tail of the list should
 232          * be more efficient than traversing through the entire list each
 233          * time an element is inserted.
 234          */
 235         pe = TAILQ_LAST(pathlist, got_pathlist_head);
 236         while (pe) {
 237                 int cmp = got_path_cmp(pe->path, path, pe->path_len, path_len);
 238                 if (cmp == 0)
 239                         return NULL;  /* duplicate */
 240                 else if (cmp < 0)
 241                         break;
 242                 pe = TAILQ_PREV(pe, got_pathlist_head, entry);
 243         }
 244
 245         new = malloc(sizeof(*new));
 246         if (new == NULL)
 247                 return got_error_from_errno("malloc");
 248         new->path = path;
 249         new->path_len = path_len;
 250         new->data = data;
 251         if (pe)
 252                 TAILQ_INSERT_AFTER(pathlist, pe, new, entry);
 253         else
 254                 TAILQ_INSERT_HEAD(pathlist, new, entry);
 255         if (inserted)
 256                 *inserted = new;
 257         return NULL;
 258 }
 259
 260 const struct got_error *
 261 got_pathlist_append(struct got_pathlist_head *pathlist,
 262     const char *path, void *data)
 263 {
 264         struct got_pathlist_entry *new;
 265
 266         new = malloc(sizeof(*new));
 267         if (new == NULL)
 268                 return got_error_from_errno("malloc");
 269         new->path = path;
 270         new->path_len = strlen(path);
 271         new->data = data;
 272         TAILQ_INSERT_TAIL(pathlist, new, entry);
 273         return NULL;
 274 }
 275
 276 void
 277 got_pathlist_free(struct got_pathlist_head *pathlist, int freemask)
 278 {
 279         struct got_pathlist_entry *pe;
 280
 281         while ((pe = TAILQ_FIRST(pathlist)) != NULL) {
 282                 if (freemask & GOT_PATHLIST_FREE_PATH) {
 283                         free((char *)pe->path);
 284                         pe->path = NULL;
 285                 }
 286                 if (freemask & GOT_PATHLIST_FREE_DATA) {
 287                         free(pe->data);
 288                         pe->data = NULL;
 289                 }
 290                 TAILQ_REMOVE(pathlist, pe, entry);
 291                 free(pe);
 292         }
 293 }
 294
 295 static const struct got_error *
 296 make_parent_dirs(const char *abspath)
 297 {
 298         const struct got_error *err = NULL;
 299         char *parent;
 300
 301         err = got_path_dirname(&parent, abspath);
 302         if (err)
 303                 return err;
 304
 305         if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1) {
 306                 if (errno == ENOENT) {
 307                         err = make_parent_dirs(parent);
 308                         if (err)
 309                                 goto done;
 310                         if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1) {
 311                                 err = got_error_from_errno2("mkdir", parent);
 312                                 goto done;
 313                         }
 314                 } else
 315                         err = got_error_from_errno2("mkdir", parent);
 316         }
 317 done:
 318         free(parent);
 319         return err;
 320 }
 321
 322 const struct got_error *
 323 got_path_mkdir(const char *abspath)
 324 {
 325         const struct got_error *err = NULL;
 326
 327         if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1) {
 328                 if (errno == ENOENT) {
 329                         err = make_parent_dirs(abspath);
 330                         if (err)
 331                                 goto done;
 332                         if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1)
 333                                 err = got_error_from_errno2("mkdir", abspath);
 334                 } else
 335                         err = got_error_from_errno2("mkdir", abspath);
 336         }
 337
 338 done:
 339         return err;
 340 }
 341
 342 int
 343 got_path_dir_is_empty(const char *dir)
 344 {
 345         DIR *d;
 346         struct dirent *dent;
 347         int empty = 1;
 348
 349         d = opendir(dir);
 350         if (d == NULL)
 351                 return 1;
 352
 353         while ((dent = readdir(d)) != NULL) {
 354                 if (strcmp(dent->d_name, ".") == 0 ||
 355                     strcmp(dent->d_name, "..") == 0)
 356                         continue;
 357
 358                 empty = 0;
 359                 break;
 360         }
 361
 362         closedir(d);
 363         return empty;
 364 }
 365
 366 const struct got_error *
 367 got_path_dirname(char **parent, const char *path)
 368 {
 369         char buf[PATH_MAX];
 370         char *p;
 371
 372         if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf))
 373                 return got_error(GOT_ERR_NO_SPACE);
 374
 375         p = dirname(buf);
 376         if (p == NULL)
 377                 return got_error_from_errno2("dirname", path);
 378
 379         if (p[0] == '.' && p[1] == '\0')
 380                 return got_error_path(path, GOT_ERR_BAD_PATH);
 381
 382         *parent = strdup(p);
 383         if (*parent == NULL)
 384                 return got_error_from_errno("strdup");
 385
 386         return NULL;
 387 }
 388
 389 const struct got_error *
 390 got_path_dirent_type(int *type, const char *path_parent, struct dirent *dent)
 391 {
 392         const struct got_error *err = NULL;
 393         char *path_child;
 394         struct stat sb;
 395
 396         if (dent->d_type != DT_UNKNOWN) {
 397                 *type = dent->d_type;
 398                 return NULL;
 399         }
 400
 401         *type = DT_UNKNOWN;
 402
 403         /*
 404          * This is a fallback to accommodate filesystems which do not
 405          * provide directory entry type information. DT_UNKNOWN directory
 406          * entries occur on NFS mounts without "readdir plus" RPC.
 407          */
 408
 409         if (asprintf(&path_child, "%s/%s", path_parent, dent->d_name) == -1)
 410                 return got_error_from_errno("asprintf");
 411
 412         if (lstat(path_child, &sb) == -1) {
 413                 err = got_error_from_errno2("lstat", path_child);
 414                 goto done;
 415         }
 416
 417         if (S_ISFIFO(sb.st_mode))
 418                 *type = DT_FIFO;
 419         else if (S_ISCHR(sb.st_mode))
 420                 *type = DT_CHR;
 421         else if (S_ISDIR(sb.st_mode))
 422                 *type = DT_DIR;
 423         else if (S_ISBLK(sb.st_mode))
 424                 *type = DT_BLK;
 425         else if (S_ISLNK(sb.st_mode))
 426                 *type = DT_LNK;
 427         else if (S_ISREG(sb.st_mode))
 428                 *type = DT_REG;
 429         else if (S_ISSOCK(sb.st_mode))
 430                 *type = DT_SOCK;
 431 done:
 432         free(path_child);
 433         return err;
 434 }
 435
 436 const struct got_error *
 437 got_path_basename(char **s, const char *path)
 438 {
 439         char buf[PATH_MAX];
 440         char *base;
 441
 442         if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf))
 443                 return got_error(GOT_ERR_NO_SPACE);
 444
 445         base = basename(buf);
 446         if (base == NULL)
 447                 return got_error_from_errno2("basename", path);
 448
 449         *s = strdup(base);
 450         if (*s == NULL)
 451                 return got_error_from_errno("strdup");
 452
 453         return NULL;
 454 }
 455
 456 void
 457 got_path_strip_trailing_slashes(char *path)
 458 {
 459         size_t x;
 460
 461         x = strlen(path);
 462         while (x-- > 0 && path[x] == '/')
 463                 path[x] = '\0';
 464 }
 465
 466 /* based on findprog() from usr.bin/which/which.c */
 467 const struct got_error *
 468 got_path_find_prog(char **filename, const char *prog)
 469 {
 470         const struct got_error *err = NULL;
 471         const char *path;
 472         char *p;
 473         int len;
 474         struct stat sbuf;
 475         char *pathcpy, *dup = NULL;
 476
 477         *filename = NULL;
 478
 479         path = getenv("PATH");
 480         if (path == NULL)
 481                 path = _PATH_DEFPATH;
 482
 483         /* Special case if prog contains '/' */
 484         if (strchr(prog, '/')) {
 485                 if ((stat(prog, &sbuf) == 0) && S_ISREG(sbuf.st_mode) &&
 486                     access(prog, X_OK) == 0) {
 487                         *filename = strdup(prog);
 488                         if (*filename == NULL)
 489                                 return got_error_from_errno("strdup");
 490                 }
 491                 return NULL;
 492         }
 493
 494         if ((dup = strdup(path)) == NULL)
 495                 return got_error_from_errno("strdup");
 496         pathcpy = dup;
 497
 498         while ((p = strsep(&pathcpy, ":")) != NULL) {
 499                 const char *d;
 500
 501                 len = strlen(p);
 502                 while (len > 0 && p[len-1] == '/')
 503                         p[--len] = '\0';        /* strip trailing '/' */
 504
 505                 d = p;
 506                 if (*d == '\0')
 507                         d = ".";
 508
 509                 if (asprintf(filename, "%s/%s", d, prog) == -1) {
 510                         err = got_error_from_errno("asprintf");
 511                         break;
 512                 }
 513                 if ((stat(*filename, &sbuf) == 0) && S_ISREG(sbuf.st_mode) &&
 514                     access(*filename, X_OK) == 0)
 515                         break;
 516                 free(*filename);
 517                 *filename = NULL;
 518         }
 519         free(dup);
 520         return err;
 521 }
 522
 523 const struct got_error *
 524 got_path_create_file(const char *path, const char *content)
 525 {
 526         const struct got_error *err = NULL;
 527         int fd = -1;
 528
 529         fd = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC,
 530             GOT_DEFAULT_FILE_MODE);
 531         if (fd == -1) {
 532                 err = got_error_from_errno2("open", path);
 533                 goto done;
 534         }
 535
 536         if (content) {
 537                 int len = dprintf(fd, "%s\n", content);
 538                 if (len != strlen(content) + 1) {
 539                         err = got_error_from_errno("dprintf");
 540                         goto done;
 541                 }
 542         }
 543
 544 done:
 545         if (fd != -1 && close(fd) == -1 && err == NULL)
 546                 err = got_error_from_errno("close");
 547         return err;
 548 }
 549
 550 const struct got_error *
 551 got_path_move_file(const char *oldpath, const char *newpath)
 552 {
 553         const struct got_error *err;
 554
 555         if (rename(oldpath, newpath) != -1)
 556                 return NULL;
 557
 558         if (errno != ENOENT)
 559                 return got_error_from_errno3("rename", oldpath, newpath);
 560
 561         err = make_parent_dirs(newpath);
 562         if (err)
 563                 return err;
 564
 565         if (rename(oldpath, newpath) == -1)
 566                 return got_error_from_errno3("rename", oldpath, newpath);
 567
 568         return NULL;
 569 }