src/common/compat/directory-handle.c

   1 /*
   2  * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <common/compat/directory-handle.h>
   9 #include <common/error.h>
  10 #include <common/macros.h>
  11 #include <common/runas.h>
  12 #include <common/credentials.h>
  13 #include <lttng/constant.h>
  14 #include <common/dynamic-array.h>
  15
  16 #include <assert.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21 #include <dirent.h>
  22
  23 /*
  24  * This compatibility layer shares a common "base" that is implemented
  25  * in terms of an internal API. This file contains two implementations
  26  * of the internal API below.
  27  */
  28 static
  29 int lttng_directory_handle_mkdir(
  30                 const struct lttng_directory_handle *handle,
  31                 const char *path, mode_t mode);
  32 static
  33 int _run_as_mkdir(const struct lttng_directory_handle *handle, const char *path,
  34                 mode_t mode, uid_t uid, gid_t gid);
  35 static
  36 int _run_as_mkdir_recursive(const struct lttng_directory_handle *handle,
  37                 const char *path, mode_t mode, uid_t uid, gid_t gid);
  38 static
  39 int lttng_directory_handle_open(const struct lttng_directory_handle *handle,
  40                 const char *filename, int flags, mode_t mode);
  41 static
  42 int _run_as_open(const struct lttng_directory_handle *handle,
  43                 const char *filename,
  44                 int flags, mode_t mode, uid_t uid, gid_t gid);
  45 static
  46 int lttng_directory_handle_unlink(
  47                 const struct lttng_directory_handle *handle,
  48                 const char *filename);
  49 static
  50 int _run_as_unlink(const struct lttng_directory_handle *handle,
  51                 const char *filename, uid_t uid, gid_t gid);
  52 static
  53 int _lttng_directory_handle_rename(
  54                 const struct lttng_directory_handle *old_handle,
  55                 const char *old_name,
  56                 const struct lttng_directory_handle *new_handle,
  57                 const char *new_name);
  58 static
  59 int _run_as_rename(const struct lttng_directory_handle *old_handle,
  60                 const char *old_name,
  61                 const struct lttng_directory_handle *new_handle,
  62                 const char *new_name, uid_t uid, gid_t gid);
  63 static
  64 DIR *lttng_directory_handle_opendir(const struct lttng_directory_handle *handle,
  65                 const char *path);
  66 static
  67 int lttng_directory_handle_rmdir(
  68                 const struct lttng_directory_handle *handle, const char *name);
  69 static
  70 int _run_as_rmdir(const struct lttng_directory_handle *handle,
  71                 const char *name, uid_t uid, gid_t gid);
  72 static
  73 int _run_as_rmdir_recursive(
  74                 const struct lttng_directory_handle *handle, const char *name,
  75                 uid_t uid, gid_t gid, int flags);
  76 static
  77 void lttng_directory_handle_invalidate(struct lttng_directory_handle *handle);
  78 static
  79 void lttng_directory_handle_release(struct urcu_ref *ref);
  80
  81 #ifdef COMPAT_DIRFD
  82
  83 /*
  84  * Special inode number reserved to represent the "current working directory".
  85  * ino_t is spec'ed as being an unsigned integral type.
  86  */
  87 #define RESERVED_AT_FDCWD_INO                      \
  88         ({                                         \
  89                 uint64_t reserved_val;             \
  90                 switch (sizeof(ino_t)) {           \
  91                 case 4:                            \
  92                         reserved_val = UINT32_MAX; \
  93                         break;                     \
  94                 case 8:                            \
  95                         reserved_val = UINT64_MAX; \
  96                         break;                     \
  97                 default:                           \
  98                         abort();                   \
  99                 }                                  \
 100                 (ino_t) reserved_val;              \
 101         })
 102
 103 LTTNG_HIDDEN
 104 struct lttng_directory_handle *lttng_directory_handle_create(const char *path)
 105 {
 106         const struct lttng_directory_handle cwd_handle = {
 107                 .dirfd = AT_FDCWD,
 108         };
 109
 110         /* Open a handle to the CWD if NULL is passed. */
 111         return lttng_directory_handle_create_from_handle(path, &cwd_handle);
 112 }
 113
 114 LTTNG_HIDDEN
 115 struct lttng_directory_handle *lttng_directory_handle_create_from_handle(
 116                 const char *path,
 117                 const struct lttng_directory_handle *ref_handle)
 118 {
 119         int dirfd;
 120         struct lttng_directory_handle *handle = NULL;
 121
 122         if (!path) {
 123                 handle = lttng_directory_handle_copy(ref_handle);
 124                 goto end;
 125         }
 126         if (!*path) {
 127                 ERR("Failed to initialize directory handle: provided path is an empty string");
 128                 goto end;
 129         }
 130
 131         dirfd = openat(ref_handle->dirfd, path, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 132         if (dirfd == -1) {
 133                 PERROR("Failed to initialize directory handle to \"%s\"", path);
 134                 goto end;
 135         }
 136
 137         handle = lttng_directory_handle_create_from_dirfd(dirfd);
 138         if (!handle) {
 139                 goto error_close;
 140         }
 141 end:
 142         return handle;
 143 error_close:
 144         if (close(dirfd)) {
 145                 PERROR("Failed to close directory file descriptor");
 146         }
 147         return NULL;
 148 }
 149
 150 LTTNG_HIDDEN
 151 struct lttng_directory_handle *lttng_directory_handle_create_from_dirfd(
 152                 int dirfd)
 153 {
 154         int ret;
 155         struct lttng_directory_handle *handle = zmalloc(sizeof(*handle));
 156         struct stat stat_buf;
 157
 158         if (!handle) {
 159                 goto end;
 160         }
 161
 162         if (dirfd != AT_FDCWD) {
 163                 ret = fstat(dirfd, &stat_buf);
 164                 if (ret) {
 165                         PERROR("Failed to fstat directory file descriptor %i", dirfd);
 166                         lttng_directory_handle_release(&handle->ref);
 167                         handle = NULL;
 168                         goto end;
 169                 }
 170         } else {
 171                 handle->directory_inode = RESERVED_AT_FDCWD_INO;
 172         }
 173         handle->dirfd = dirfd;
 174         urcu_ref_init(&handle->ref);
 175 end:
 176         return handle;
 177 }
 178
 179 static
 180 void lttng_directory_handle_release(struct urcu_ref *ref)
 181 {
 182         int ret;
 183         struct lttng_directory_handle *handle =
 184                         container_of(ref, struct lttng_directory_handle, ref);
 185
 186         if (handle->destroy_cb) {
 187                 handle->destroy_cb(handle, handle->destroy_cb_data);
 188         }
 189
 190         if (handle->dirfd == AT_FDCWD || handle->dirfd == -1) {
 191                 goto end;
 192         }
 193         ret = close(handle->dirfd);
 194         if (ret == -1) {
 195                 PERROR("Failed to close directory file descriptor of directory handle");
 196         }
 197 end:
 198         lttng_directory_handle_invalidate(handle);
 199         free(handle);
 200 }
 201
 202 LTTNG_HIDDEN
 203 struct lttng_directory_handle *lttng_directory_handle_copy(
 204                 const struct lttng_directory_handle *handle)
 205 {
 206         struct lttng_directory_handle *new_handle = NULL;
 207
 208         if (handle->dirfd == AT_FDCWD) {
 209                 new_handle = lttng_directory_handle_create_from_dirfd(AT_FDCWD);
 210         } else {
 211                 const int new_dirfd = dup(handle->dirfd);
 212
 213                 if (new_dirfd == -1) {
 214                         PERROR("Failed to duplicate directory file descriptor of directory handle");
 215                         goto end;
 216                 }
 217                 new_handle = lttng_directory_handle_create_from_dirfd(
 218                                 new_dirfd);
 219                 if (!new_handle && close(new_dirfd)) {
 220                         PERROR("Failed to close directory file descriptor of directory handle");
 221                 }
 222         }
 223 end:
 224         return new_handle;
 225 }
 226
 227 LTTNG_HIDDEN
 228 bool lttng_directory_handle_equals(const struct lttng_directory_handle *lhs,
 229                 const struct lttng_directory_handle *rhs)
 230 {
 231         return lhs->directory_inode == rhs->directory_inode;
 232 }
 233
 234 static
 235 void lttng_directory_handle_invalidate(struct lttng_directory_handle *handle)
 236 {
 237         handle->dirfd = -1;
 238 }
 239
 240 LTTNG_HIDDEN
 241 int lttng_directory_handle_stat(const struct lttng_directory_handle *handle,
 242                 const char *path, struct stat *st)
 243 {
 244         return fstatat(handle->dirfd, path, st, 0);
 245 }
 246
 247 LTTNG_HIDDEN
 248 bool lttng_directory_handle_uses_fd(
 249                 const struct lttng_directory_handle *handle)
 250 {
 251         return handle->dirfd != AT_FDCWD;
 252 }
 253
 254 static
 255 int lttng_directory_handle_mkdir(
 256                 const struct lttng_directory_handle *handle,
 257                 const char *path, mode_t mode)
 258 {
 259         return mkdirat(handle->dirfd, path, mode);
 260 }
 261
 262 static
 263 int lttng_directory_handle_open(const struct lttng_directory_handle *handle,
 264                 const char *filename, int flags, mode_t mode)
 265 {
 266         return openat(handle->dirfd, filename, flags, mode);
 267 }
 268
 269 static
 270 int _run_as_open(const struct lttng_directory_handle *handle,
 271                 const char *filename,
 272                 int flags, mode_t mode, uid_t uid, gid_t gid)
 273 {
 274         return run_as_openat(handle->dirfd, filename, flags, mode, uid, gid);
 275 }
 276
 277 static
 278 int _run_as_unlink(const struct lttng_directory_handle *handle,
 279                 const char *filename, uid_t uid, gid_t gid)
 280 {
 281         return run_as_unlinkat(handle->dirfd, filename, uid, gid);
 282 }
 283
 284 static
 285 int lttng_directory_handle_unlink(
 286                 const struct lttng_directory_handle *handle,
 287                 const char *filename)
 288 {
 289         return unlinkat(handle->dirfd, filename, 0);
 290 }
 291
 292 static
 293 int _run_as_mkdir(const struct lttng_directory_handle *handle,
 294                 const char *path, mode_t mode, uid_t uid, gid_t gid)
 295 {
 296         return run_as_mkdirat(handle->dirfd, path, mode, uid, gid);
 297 }
 298
 299 static
 300 int _run_as_mkdir_recursive(const struct lttng_directory_handle *handle,
 301                 const char *path, mode_t mode, uid_t uid, gid_t gid)
 302 {
 303         return run_as_mkdirat_recursive(handle->dirfd, path, mode, uid, gid);
 304 }
 305
 306 static
 307 int _lttng_directory_handle_rename(
 308                 const struct lttng_directory_handle *old_handle,
 309                 const char *old_name,
 310                 const struct lttng_directory_handle *new_handle,
 311                 const char *new_name)
 312 {
 313         return renameat(old_handle->dirfd, old_name,
 314                         new_handle->dirfd, new_name);
 315 }
 316
 317 static
 318 int _run_as_rename(const struct lttng_directory_handle *old_handle,
 319                 const char *old_name,
 320                 const struct lttng_directory_handle *new_handle,
 321                 const char *new_name, uid_t uid, gid_t gid)
 322 {
 323         return run_as_renameat(old_handle->dirfd, old_name, new_handle->dirfd,
 324                         new_name, uid, gid);
 325 }
 326
 327 static
 328 DIR *lttng_directory_handle_opendir(const struct lttng_directory_handle *handle,
 329                 const char *path)
 330 {
 331         DIR *dir_stream = NULL;
 332         int fd = openat(handle->dirfd, path, O_RDONLY);
 333
 334         if (fd < 0) {
 335                 goto end;
 336         }
 337
 338         dir_stream = fdopendir(fd);
 339         if (!dir_stream) {
 340                 int ret;
 341
 342                 PERROR("Failed to open directory stream");
 343                 ret = close(fd);
 344                 if (ret) {
 345                         PERROR("Failed to close file descriptor to %s", path);
 346                 }
 347                 goto end;
 348         }
 349
 350 end:
 351         return dir_stream;
 352 }
 353
 354 static
 355 int lttng_directory_handle_rmdir(
 356                 const struct lttng_directory_handle *handle, const char *name)
 357 {
 358         int ret = unlinkat(handle->dirfd, name, AT_REMOVEDIR);
 359         if (ret) {
 360                 PERROR("Failed to remove directory `%s`", name);
 361         }
 362
 363         return ret;
 364 }
 365
 366 static
 367 int _run_as_rmdir(const struct lttng_directory_handle *handle,
 368                 const char *name, uid_t uid, gid_t gid)
 369 {
 370         return run_as_rmdirat(handle->dirfd, name, uid, gid);
 371 }
 372
 373 static
 374 int _run_as_rmdir_recursive(
 375                 const struct lttng_directory_handle *handle, const char *name,
 376                 uid_t uid, gid_t gid, int flags)
 377 {
 378         return run_as_rmdirat_recursive(handle->dirfd, name, uid, gid, flags);
 379 }
 380
 381 #else /* COMPAT_DIRFD */
 382
 383 static
 384 int get_full_path(const struct lttng_directory_handle *handle,
 385                 const char *subdirectory, char *fullpath, size_t size)
 386 {
 387         int ret;
 388         const bool subdirectory_is_absolute =
 389                         subdirectory && *subdirectory == '/';
 390         const char * const base = subdirectory_is_absolute ?
 391                         subdirectory : handle->base_path;
 392         const char * const end = subdirectory && !subdirectory_is_absolute ?
 393                         subdirectory : NULL;
 394         const size_t base_len = strlen(base);
 395         const size_t end_len = end ? strlen(end) : 0;
 396         const bool add_separator_slash = end && base[base_len - 1] != '/';
 397         const bool add_trailing_slash = end && end[end_len - 1] != '/';
 398
 399         ret = snprintf(fullpath, size, "%s%s%s%s",
 400                         base,
 401                         add_separator_slash ? "/" : "",
 402                         end ? end : "",
 403                         add_trailing_slash ? "/" : "");
 404         if (ret == -1 || ret >= size) {
 405                 ERR("Failed to format subdirectory from directory handle");
 406                 ret = -1;
 407                 goto end;
 408         }
 409         ret = 0;
 410 end:
 411         return ret;
 412 }
 413
 414 static
 415 struct lttng_directory_handle *_lttng_directory_handle_create(char *path)
 416 {
 417         struct lttng_directory_handle *handle = zmalloc(sizeof(*handle));
 418
 419         if (!handle) {
 420                 goto end;
 421         }
 422         urcu_ref_init(&handle->ref);
 423         handle->base_path = path;
 424 end:
 425         return handle;
 426 }
 427
 428 LTTNG_HIDDEN
 429 struct lttng_directory_handle *lttng_directory_handle_create(
 430                 const char *path)
 431 {
 432         int ret;
 433         const char *cwd = "";
 434         size_t cwd_len, path_len;
 435         char cwd_buf[LTTNG_PATH_MAX] = {};
 436         char handle_buf[LTTNG_PATH_MAX] = {};
 437         struct lttng_directory_handle *new_handle = NULL;
 438         bool add_cwd_slash = false, add_trailing_slash = false;
 439         const struct lttng_directory_handle cwd_handle = {
 440                 .base_path = handle_buf,
 441         };
 442
 443         path_len = path ? strlen(path) : 0;
 444         add_trailing_slash = path && path[path_len - 1] != '/';
 445         if (!path || (path && *path != '/')) {
 446                 cwd = getcwd(cwd_buf, sizeof(cwd_buf));
 447                 if (!cwd) {
 448                         PERROR("Failed to initialize directory handle, can't get current working directory");
 449                         ret = -1;
 450                         goto end;
 451                 }
 452                 cwd_len = strlen(cwd);
 453                 if (cwd_len == 0) {
 454                         ERR("Failed to initialize directory handle, current working directory path has a length of 0");
 455                         ret = -1;
 456                         goto end;
 457                 }
 458                 add_cwd_slash = cwd[cwd_len - 1] != '/';
 459         }
 460
 461         ret = snprintf(handle_buf, sizeof(handle_buf), "%s%s%s%s",
 462                         cwd,
 463                         add_cwd_slash ? "/" : "",
 464                         path ? : "",
 465                         add_trailing_slash ? "/" : "");
 466         if (ret == -1 || ret >= LTTNG_PATH_MAX) {
 467                 ERR("Failed to initialize directory handle, failed to format directory path");
 468                 goto end;
 469         }
 470
 471         new_handle = lttng_directory_handle_create_from_handle(path, &cwd_handle);
 472 end:
 473         return new_handle;
 474 }
 475
 476 LTTNG_HIDDEN
 477 struct lttng_directory_handle *lttng_directory_handle_create_from_handle(
 478                 const char *path,
 479                 const struct lttng_directory_handle *ref_handle)
 480 {
 481         int ret;
 482         size_t path_len, handle_path_len;
 483         bool add_trailing_slash;
 484         struct stat stat_buf;
 485         struct lttng_directory_handle *new_handle = NULL;
 486         char *new_path = NULL;
 487
 488         assert(ref_handle && ref_handle->base_path);
 489
 490         ret = lttng_directory_handle_stat(ref_handle, path, &stat_buf);
 491         if (ret == -1) {
 492                 PERROR("Failed to create directory handle");
 493                 goto end;
 494         } else if (!S_ISDIR(stat_buf.st_mode)) {
 495                 char full_path[LTTNG_PATH_MAX];
 496
 497                 /* Best effort for logging purposes. */
 498                 ret = get_full_path(ref_handle, path, full_path,
 499                                 sizeof(full_path));
 500                 if (ret) {
 501                         full_path[0] = '\0';
 502                 }
 503
 504                 ERR("Failed to initialize directory handle to \"%s\": not a directory",
 505                                 full_path);
 506                 goto end;
 507         }
 508         if (!path) {
 509                 new_handle = lttng_directory_handle_copy(ref_handle);
 510                 goto end;
 511         }
 512
 513         path_len = strlen(path);
 514         if (path_len == 0) {
 515                 ERR("Failed to initialize directory handle: provided path is an empty string");
 516                 ret = -1;
 517                 goto end;
 518         }
 519         if (*path == '/') {
 520                 new_path = strdup(path);
 521                 if (!new_path) {
 522                         goto end;
 523                 }
 524                 /* Takes ownership of new_path. */
 525                 new_handle = _lttng_directory_handle_create(new_path);
 526                 new_path = NULL;
 527                 goto end;
 528         }
 529
 530         add_trailing_slash = path[path_len - 1] != '/';
 531
 532         handle_path_len = strlen(ref_handle->base_path) + path_len +
 533                         !!add_trailing_slash;
 534         if (handle_path_len >= LTTNG_PATH_MAX) {
 535                 ERR("Failed to initialize directory handle as the resulting path's length (%zu bytes) exceeds the maximal allowed length (%d bytes)",
 536                                 handle_path_len, LTTNG_PATH_MAX);
 537                 goto end;
 538         }
 539         new_path = zmalloc(handle_path_len);
 540         if (!new_path) {
 541                 PERROR("Failed to initialize directory handle");
 542                 goto end;
 543         }
 544
 545         ret = sprintf(new_handle->base_path, "%s%s%s",
 546                         ref_handle->base_path,
 547                         path,
 548                         add_trailing_slash ? "/" : "");
 549         if (ret == -1 || ret >= handle_path_len) {
 550                 ERR("Failed to initialize directory handle: path formatting failed");
 551                 goto end;
 552         }
 553         new_handle = _lttng_directory_handle_create(new_path);
 554         new_path = NULL;
 555 end:
 556         free(new_path);
 557         return new_handle;
 558 }
 559
 560 LTTNG_HIDDEN
 561 struct lttng_directory_handle *lttng_directory_handle_create_from_dirfd(
 562                 int dirfd)
 563 {
 564         assert(dirfd == AT_FDCWD);
 565         return lttng_directory_handle_create(NULL);
 566 }
 567
 568 static
 569 void lttng_directory_handle_release(struct urcu_ref *ref)
 570 {
 571         struct lttng_directory_handle *handle =
 572                         container_of(ref, struct lttng_directory_handle, ref);
 573
 574         free(handle->base_path);
 575         lttng_directory_handle_invalidate(handle);
 576         free(handle);
 577 }
 578
 579 LTTNG_HIDDEN
 580 struct lttng_directory_handle *lttng_directory_handle_copy(
 581                 const struct lttng_directory_handle *handle)
 582 {
 583         struct lttng_directory_handle *new_handle = NULL;
 584         char *new_path = NULL;
 585
 586         if (handle->base_path) {
 587                 new_path = strdup(handle->base_path);
 588                 if (!new_path) {
 589                         goto end;
 590                 }
 591         }
 592         new_handle = _lttng_directory_handle_create(new_path);
 593 end:
 594         return new_handle;
 595 }
 596
 597 LTTNG_HIDDEN
 598 bool lttng_directory_handle_equals(const struct lttng_directory_handle *lhs,
 599                 const struct lttng_directory_handle *rhs)
 600 {
 601         return strcmp(lhs->base_path, rhs->base_path) == 0;
 602 }
 603
 604 static
 605 void lttng_directory_handle_invalidate(struct lttng_directory_handle *handle)
 606 {
 607         handle->base_path = NULL;
 608 }
 609
 610 LTTNG_HIDDEN
 611 int lttng_directory_handle_stat(const struct lttng_directory_handle *handle,
 612                 const char *subdirectory, struct stat *st)
 613 {
 614         int ret;
 615         char fullpath[LTTNG_PATH_MAX];
 616
 617         ret = get_full_path(handle, subdirectory, fullpath, sizeof(fullpath));
 618         if (ret) {
 619                 errno = ENOMEM;
 620                 goto end;
 621         }
 622
 623         ret = stat(fullpath, st);
 624 end:
 625         return ret;
 626 }
 627
 628 LTTNG_HIDDEN
 629 bool lttng_directory_handle_uses_fd(
 630                 const struct lttng_directory_handle *handle)
 631 {
 632         return false;
 633 }
 634
 635 static
 636 int lttng_directory_handle_mkdir(const struct lttng_directory_handle *handle,
 637                 const char *subdirectory, mode_t mode)
 638 {
 639         int ret;
 640         char fullpath[LTTNG_PATH_MAX];
 641
 642         ret = get_full_path(handle, subdirectory, fullpath, sizeof(fullpath));
 643         if (ret) {
 644                 errno = ENOMEM;
 645                 goto end;
 646         }
 647
 648         ret = mkdir(fullpath, mode);
 649 end:
 650         return ret;
 651 }
 652
 653 static
 654 int lttng_directory_handle_open(const struct lttng_directory_handle *handle,
 655                 const char *filename, int flags, mode_t mode)
 656 {
 657         int ret;
 658         char fullpath[LTTNG_PATH_MAX];
 659
 660         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 661         if (ret) {
 662                 errno = ENOMEM;
 663                 goto end;
 664         }
 665
 666         ret = open(fullpath, flags, mode);
 667 end:
 668         return ret;
 669 }
 670
 671 static
 672 int lttng_directory_handle_unlink(
 673                 const struct lttng_directory_handle *handle,
 674                 const char *filename)
 675 {
 676         int ret;
 677         char fullpath[LTTNG_PATH_MAX];
 678
 679         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 680         if (ret) {
 681                 errno = ENOMEM;
 682                 goto end;
 683         }
 684
 685         ret = unlink(fullpath);
 686 end:
 687         return ret;
 688 }
 689
 690 static
 691 int _run_as_mkdir(const struct lttng_directory_handle *handle, const char *path,
 692                 mode_t mode, uid_t uid, gid_t gid)
 693 {
 694         int ret;
 695         char fullpath[LTTNG_PATH_MAX];
 696
 697         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 698         if (ret) {
 699                 errno = ENOMEM;
 700                 goto end;
 701         }
 702
 703         ret = run_as_mkdir(fullpath, mode, uid, gid);
 704 end:
 705         return ret;
 706 }
 707
 708 static
 709 int _run_as_open(const struct lttng_directory_handle *handle,
 710                 const char *filename,
 711                 int flags, mode_t mode, uid_t uid, gid_t gid)
 712 {
 713         int ret;
 714         char fullpath[LTTNG_PATH_MAX];
 715
 716         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 717         if (ret) {
 718                 errno = ENOMEM;
 719                 goto end;
 720         }
 721
 722         ret = run_as_open(fullpath, flags, mode, uid, gid);
 723 end:
 724         return ret;
 725 }
 726
 727 static
 728 int _run_as_unlink(const struct lttng_directory_handle *handle,
 729                 const char *filename, uid_t uid, gid_t gid)
 730 {
 731         int ret;
 732         char fullpath[LTTNG_PATH_MAX];
 733
 734         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 735         if (ret) {
 736                 errno = ENOMEM;
 737                 goto end;
 738         }
 739
 740         ret = run_as_unlink(fullpath, uid, gid);
 741 end:
 742         return ret;
 743 }
 744
 745 static
 746 int _run_as_mkdir_recursive(const struct lttng_directory_handle *handle,
 747                 const char *path, mode_t mode, uid_t uid, gid_t gid)
 748 {
 749         int ret;
 750         char fullpath[LTTNG_PATH_MAX];
 751
 752         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 753         if (ret) {
 754                 errno = ENOMEM;
 755                 goto end;
 756         }
 757
 758         ret = run_as_mkdir_recursive(fullpath, mode, uid, gid);
 759 end:
 760         return ret;
 761 }
 762
 763 static
 764 int _lttng_directory_handle_rename(
 765                 const struct lttng_directory_handle *old_handle,
 766                 const char *old_name,
 767                 const struct lttng_directory_handle *new_handle,
 768                 const char *new_name)
 769 {
 770         int ret;
 771         char old_fullpath[LTTNG_PATH_MAX];
 772         char new_fullpath[LTTNG_PATH_MAX];
 773
 774         ret = get_full_path(old_handle, old_name, old_fullpath,
 775                         sizeof(old_fullpath));
 776         if (ret) {
 777                 errno = ENOMEM;
 778                 goto end;
 779         }
 780         ret = get_full_path(new_handle, new_name, new_fullpath,
 781                         sizeof(new_fullpath));
 782         if (ret) {
 783                 errno = ENOMEM;
 784                 goto end;
 785         }
 786
 787         ret = rename(old_fullpath, new_fullpath);
 788 end:
 789         return ret;
 790 }
 791
 792 static
 793 int _run_as_rename(const struct lttng_directory_handle *old_handle,
 794                 const char *old_name,
 795                 const struct lttng_directory_handle *new_handle,
 796                 const char *new_name, uid_t uid, gid_t gid)
 797 {
 798         int ret;
 799         char old_fullpath[LTTNG_PATH_MAX];
 800         char new_fullpath[LTTNG_PATH_MAX];
 801
 802         ret = get_full_path(old_handle, old_name, old_fullpath,
 803                         sizeof(old_fullpath));
 804         if (ret) {
 805                 errno = ENOMEM;
 806                 goto end;
 807         }
 808         ret = get_full_path(new_handle, new_name, new_fullpath,
 809                         sizeof(new_fullpath));
 810         if (ret) {
 811                 errno = ENOMEM;
 812                 goto end;
 813         }
 814
 815         ret = run_as_rename(old_fullpath, new_fullpath, uid, gid);
 816 end:
 817         return ret;
 818 }
 819
 820 static
 821 DIR *lttng_directory_handle_opendir(const struct lttng_directory_handle *handle,
 822                 const char *path)
 823 {
 824         int ret;
 825         DIR *dir_stream = NULL;
 826         char fullpath[LTTNG_PATH_MAX];
 827
 828         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 829         if (ret) {
 830                 errno = ENOMEM;
 831                 goto end;
 832         }
 833
 834         dir_stream = opendir(fullpath);
 835 end:
 836         return dir_stream;
 837 }
 838
 839 static
 840 int lttng_directory_handle_rmdir(
 841                 const struct lttng_directory_handle *handle, const char *name)
 842 {
 843         int ret;
 844         char fullpath[LTTNG_PATH_MAX];
 845
 846         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 847         if (ret) {
 848                 errno = ENOMEM;
 849                 goto end;
 850         }
 851
 852         ret = rmdir(fullpath);
 853 end:
 854         return ret;
 855 }
 856
 857 static
 858 int _run_as_rmdir(const struct lttng_directory_handle *handle,
 859                 const char *name, uid_t uid, gid_t gid)
 860 {
 861         int ret;
 862         char fullpath[LTTNG_PATH_MAX];
 863
 864         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 865         if (ret) {
 866                 errno = ENOMEM;
 867                 goto end;
 868         }
 869
 870         ret = run_as_rmdir(fullpath, uid, gid);
 871 end:
 872         return ret;
 873 }
 874
 875 static
 876 int _run_as_rmdir_recursive(
 877                 const struct lttng_directory_handle *handle, const char *name,
 878                 uid_t uid, gid_t gid, int flags)
 879 {
 880         int ret;
 881         char fullpath[LTTNG_PATH_MAX];
 882
 883         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 884         if (ret) {
 885                 errno = ENOMEM;
 886                 goto end;
 887         }
 888
 889         ret = run_as_rmdir_recursive(fullpath, uid, gid, flags);
 890 end:
 891         return ret;
 892 }
 893
 894 #endif /* COMPAT_DIRFD */
 895
 896 /* Common implementation. */
 897
 898 /*
 899  * On some filesystems (e.g. nfs), mkdir will validate access rights before
 900  * checking for the existence of the path element. This means that on a setup
 901  * where "/home/" is a mounted NFS share, and running as an unpriviledged user,
 902  * recursively creating a path of the form "/home/my_user/trace/" will fail with
 903  * EACCES on mkdir("/home", ...).
 904  *
 905  * Checking the path for existence allows us to work around this behaviour.
 906  */
 907 static
 908 int create_directory_check_exists(const struct lttng_directory_handle *handle,
 909                 const char *path, mode_t mode)
 910 {
 911         int ret = 0;
 912         struct stat st;
 913
 914         ret = lttng_directory_handle_stat(handle, path, &st);
 915         if (ret == 0) {
 916                 if (S_ISDIR(st.st_mode)) {
 917                         /* Directory exists, skip. */
 918                         goto end;
 919                 } else {
 920                         /* Exists, but is not a directory. */
 921                         errno = ENOTDIR;
 922                         ret = -1;
 923                         goto end;
 924                 }
 925         } else if (errno != ENOENT) {
 926                 goto end;
 927         }
 928
 929         /*
 930          * Let mkdir handle other errors as the caller expects mkdir
 931          * semantics.
 932          */
 933         ret = lttng_directory_handle_mkdir(handle, path, mode);
 934 end:
 935         return ret;
 936 }
 937
 938 static
 939 int create_directory_recursive(const struct lttng_directory_handle *handle,
 940                 const char *path, mode_t mode)
 941 {
 942         char *p, tmp[LTTNG_PATH_MAX];
 943         size_t len;
 944         int ret;
 945
 946         assert(path);
 947
 948         ret = lttng_strncpy(tmp, path, sizeof(tmp));
 949         if (ret) {
 950                 ERR("Failed to create directory: provided path's length (%zu bytes) exceeds the maximal allowed length (%zu bytes)",
 951                                 strlen(path) + 1, sizeof(tmp));
 952                 goto error;
 953         }
 954
 955         len = strlen(path);
 956         if (tmp[len - 1] == '/') {
 957                 tmp[len - 1] = 0;
 958         }
 959
 960         for (p = tmp + 1; *p; p++) {
 961                 if (*p == '/') {
 962                         *p = 0;
 963                         if (tmp[strlen(tmp) - 1] == '.' &&
 964                                         tmp[strlen(tmp) - 2] == '.' &&
 965                                         tmp[strlen(tmp) - 3] == '/') {
 966                                 ERR("Using '/../' is not permitted in the trace path (%s)",
 967                                                 tmp);
 968                                 ret = -1;
 969                                 goto error;
 970                         }
 971                         ret = create_directory_check_exists(handle, tmp, mode);
 972                         if (ret < 0) {
 973                                 if (errno != EACCES) {
 974                                         PERROR("Failed to create directory \"%s\"",
 975                                                         path);
 976                                         ret = -errno;
 977                                         goto error;
 978                                 }
 979                         }
 980                         *p = '/';
 981                 }
 982         }
 983
 984         ret = create_directory_check_exists(handle, tmp, mode);
 985         if (ret < 0) {
 986                 PERROR("mkdirat recursive last element");
 987                 ret = -errno;
 988         }
 989 error:
 990         return ret;
 991 }
 992
 993 LTTNG_HIDDEN
 994 bool lttng_directory_handle_get(struct lttng_directory_handle *handle)
 995 {
 996         return urcu_ref_get_unless_zero(&handle->ref);
 997 }
 998
 999 LTTNG_HIDDEN
1000 void lttng_directory_handle_put(struct lttng_directory_handle *handle)
1001 {
1002         if (!handle) {
1003                 return;
1004         }
1005         assert(handle->ref.refcount);
1006         urcu_ref_put(&handle->ref, lttng_directory_handle_release);
1007 }
1008
1009 LTTNG_HIDDEN
1010 int lttng_directory_handle_create_subdirectory_as_user(
1011                 const struct lttng_directory_handle *handle,
1012                 const char *subdirectory,
1013                 mode_t mode, const struct lttng_credentials *creds)
1014 {
1015         int ret;
1016
1017         if (!creds) {
1018                 /* Run as current user. */
1019                 ret = create_directory_check_exists(handle,
1020                                 subdirectory, mode);
1021         } else {
1022                 ret = _run_as_mkdir(handle, subdirectory,
1023                                 mode, creds->uid, creds->gid);
1024         }
1025
1026         return ret;
1027 }
1028
1029 LTTNG_HIDDEN
1030 int lttng_directory_handle_create_subdirectory_recursive_as_user(
1031                 const struct lttng_directory_handle *handle,
1032                 const char *subdirectory_path,
1033                 mode_t mode, const struct lttng_credentials *creds)
1034 {
1035         int ret;
1036
1037         if (!creds) {
1038                 /* Run as current user. */
1039                 ret = create_directory_recursive(handle,
1040                                 subdirectory_path, mode);
1041         } else {
1042                 ret = _run_as_mkdir_recursive(handle, subdirectory_path,
1043                                 mode, creds->uid, creds->gid);
1044         }
1045
1046         return ret;
1047 }
1048
1049 LTTNG_HIDDEN
1050 int lttng_directory_handle_create_subdirectory(
1051                 const struct lttng_directory_handle *handle,
1052                 const char *subdirectory,
1053                 mode_t mode)
1054 {
1055         return lttng_directory_handle_create_subdirectory_as_user(
1056                         handle, subdirectory, mode, NULL);
1057 }
1058
1059 LTTNG_HIDDEN
1060 int lttng_directory_handle_create_subdirectory_recursive(
1061                 const struct lttng_directory_handle *handle,
1062                 const char *subdirectory_path,
1063                 mode_t mode)
1064 {
1065         return lttng_directory_handle_create_subdirectory_recursive_as_user(
1066                         handle, subdirectory_path, mode, NULL);
1067 }
1068
1069 LTTNG_HIDDEN
1070 int lttng_directory_handle_open_file_as_user(
1071                 const struct lttng_directory_handle *handle,
1072                 const char *filename,
1073                 int flags, mode_t mode,
1074                 const struct lttng_credentials *creds)
1075 {
1076         int ret;
1077
1078         if (!creds) {
1079                 /* Run as current user. */
1080                 ret = lttng_directory_handle_open(handle, filename, flags,
1081                                 mode);
1082         } else {
1083                 ret = _run_as_open(handle, filename, flags, mode,
1084                                 creds->uid, creds->gid);
1085         }
1086         return ret;
1087 }
1088
1089 LTTNG_HIDDEN
1090 int lttng_directory_handle_open_file(
1091                 const struct lttng_directory_handle *handle,
1092                 const char *filename,
1093                 int flags, mode_t mode)
1094 {
1095         return lttng_directory_handle_open_file_as_user(handle, filename, flags,
1096                         mode, NULL);
1097 }
1098
1099 LTTNG_HIDDEN
1100 int lttng_directory_handle_unlink_file_as_user(
1101                 const struct lttng_directory_handle *handle,
1102                 const char *filename,
1103                 const struct lttng_credentials *creds)
1104 {
1105         int ret;
1106
1107         if (!creds) {
1108                 /* Run as current user. */
1109                 ret = lttng_directory_handle_unlink(handle, filename);
1110         } else {
1111                 ret = _run_as_unlink(handle, filename, creds->uid, creds->gid);
1112         }
1113         return ret;
1114 }
1115
1116 LTTNG_HIDDEN
1117 int lttng_directory_handle_unlink_file(
1118                 const struct lttng_directory_handle *handle,
1119                 const char *filename)
1120 {
1121         return lttng_directory_handle_unlink_file_as_user(handle,
1122                         filename, NULL);
1123 }
1124
1125 LTTNG_HIDDEN
1126 int lttng_directory_handle_rename(
1127                 const struct lttng_directory_handle *old_handle,
1128                 const char *old_name,
1129                 const struct lttng_directory_handle *new_handle,
1130                 const char *new_name)
1131 {
1132         return lttng_directory_handle_rename_as_user(old_handle, old_name,
1133                         new_handle, new_name, NULL);
1134 }
1135
1136 LTTNG_HIDDEN
1137 int lttng_directory_handle_rename_as_user(
1138                 const struct lttng_directory_handle *old_handle,
1139                 const char *old_name,
1140                 const struct lttng_directory_handle *new_handle,
1141                 const char *new_name,
1142                 const struct lttng_credentials *creds)
1143 {
1144         int ret;
1145
1146         if (!creds) {
1147                 /* Run as current user. */
1148                 ret = _lttng_directory_handle_rename(old_handle,
1149                                 old_name, new_handle, new_name);
1150         } else {
1151                 ret = _run_as_rename(old_handle, old_name, new_handle,
1152                                 new_name, creds->uid, creds->gid);
1153         }
1154         return ret;
1155 }
1156
1157 LTTNG_HIDDEN
1158 int lttng_directory_handle_remove_subdirectory(
1159                 const struct lttng_directory_handle *handle,
1160                 const char *name)
1161 {
1162         return lttng_directory_handle_remove_subdirectory_as_user(handle, name,
1163                         NULL);
1164 }
1165
1166 LTTNG_HIDDEN
1167 int lttng_directory_handle_remove_subdirectory_as_user(
1168                 const struct lttng_directory_handle *handle,
1169                 const char *name,
1170                 const struct lttng_credentials *creds)
1171 {
1172         int ret;
1173
1174         if (!creds) {
1175                 /* Run as current user. */
1176                 ret = lttng_directory_handle_rmdir(handle, name);
1177         } else {
1178                 ret = _run_as_rmdir(handle, name, creds->uid, creds->gid);
1179         }
1180         return ret;
1181 }
1182
1183 struct rmdir_frame {
1184         ssize_t parent_frame_idx;
1185         DIR *dir;
1186         bool empty;
1187         /* Size including '\0'. */
1188         size_t path_size;
1189 };
1190
1191 static
1192 void rmdir_frame_fini(void *data)
1193 {
1194         int ret;
1195         struct rmdir_frame *frame = data;
1196
1197         ret = closedir(frame->dir);
1198         if (ret == -1) {
1199                 PERROR("Failed to close directory stream");
1200         }
1201 }
1202
1203 static
1204 int remove_directory_recursive(const struct lttng_directory_handle *handle,
1205                 const char *path, int flags)
1206 {
1207         int ret;
1208         struct lttng_dynamic_array frames;
1209         size_t current_frame_idx = 0;
1210         struct rmdir_frame initial_frame = {
1211                 .parent_frame_idx = -1,
1212                 .dir = lttng_directory_handle_opendir(handle, path),
1213                 .empty = true,
1214                 .path_size = strlen(path) + 1,
1215         };
1216         struct lttng_dynamic_buffer current_path;
1217         const char separator = '/';
1218
1219         lttng_dynamic_buffer_init(&current_path);
1220         lttng_dynamic_array_init(&frames, sizeof(struct rmdir_frame),
1221                         rmdir_frame_fini);
1222
1223         if (flags & ~(LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG |
1224                                     LTTNG_DIRECTORY_HANDLE_FAIL_NON_EMPTY_FLAG)) {
1225                 ERR("Unknown flags %d", flags);
1226                 ret = -1;
1227                 goto end;
1228         }
1229
1230         if (!initial_frame.dir) {
1231                 if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG &&
1232                                 errno == ENOENT) {
1233                         DBG("Cannot rmdir \"%s\": root does not exist", path);
1234                         ret = 0;
1235                         goto end;
1236                 } else {
1237                         PERROR("Failed to rmdir \"%s\"", path);
1238                         ret = -1;
1239                         goto end;
1240                 }
1241         }
1242
1243         ret = lttng_dynamic_array_add_element(&frames, &initial_frame);
1244         if (ret) {
1245                 ERR("Failed to push context frame during recursive directory removal");
1246                 rmdir_frame_fini(&initial_frame);
1247                 goto end;
1248         }
1249
1250         ret = lttng_dynamic_buffer_append(
1251                         &current_path, path, initial_frame.path_size);
1252         if (ret) {
1253                 ERR("Failed to set initial path during recursive directory removal");
1254                 ret = -1;
1255                 goto end;
1256         }
1257
1258         while (lttng_dynamic_array_get_count(&frames) > 0) {
1259                 struct dirent *entry;
1260                 struct rmdir_frame *current_frame =
1261                                 lttng_dynamic_array_get_element(
1262                                                 &frames, current_frame_idx);
1263
1264                 assert(current_frame->dir);
1265                 ret = lttng_dynamic_buffer_set_size(
1266                                 &current_path, current_frame->path_size);
1267                 assert(!ret);
1268                 current_path.data[current_path.size - 1] = '\0';
1269
1270                 while ((entry = readdir(current_frame->dir))) {
1271                         struct stat st;
1272
1273                         if (!strcmp(entry->d_name, ".") ||
1274                                         !strcmp(entry->d_name, "..")) {
1275                                 continue;
1276                         }
1277
1278                         /* Set current_path to the entry's path. */
1279                         ret = lttng_dynamic_buffer_set_size(
1280                                         &current_path, current_path.size - 1);
1281                         assert(!ret);
1282                         ret = lttng_dynamic_buffer_append(&current_path,
1283                                         &separator, sizeof(separator));
1284                         if (ret) {
1285                                 goto end;
1286                         }
1287                         ret = lttng_dynamic_buffer_append(&current_path,
1288                                         entry->d_name,
1289                                         strlen(entry->d_name) + 1);
1290                         if (ret) {
1291                                 goto end;
1292                         }
1293
1294                         if (lttng_directory_handle_stat(
1295                                             handle, current_path.data, &st)) {
1296                                 if ((flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG) &&
1297                                                 errno == ENOENT) {
1298                                         break;
1299                                 }
1300                                 PERROR("Failed to stat \"%s\"",
1301                                                 current_path.data);
1302                                 ret = -1;
1303                                 goto end;
1304                         }
1305
1306                         if (!S_ISDIR(st.st_mode)) {
1307                                 if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG) {
1308                                         current_frame->empty = false;
1309                                         break;
1310                                 } else {
1311                                         /* Not empty, abort. */
1312                                         DBG("Directory \"%s\" is not empty; refusing to remove directory",
1313                                                         current_path.data);
1314                                         ret = -1;
1315                                         goto end;
1316                                 }
1317                         } else {
1318                                 struct rmdir_frame new_frame = {
1319                                         .path_size = current_path.size,
1320                                         .dir = lttng_directory_handle_opendir(
1321                                                         handle,
1322                                                         current_path.data),
1323                                         .empty = true,
1324                                         .parent_frame_idx = current_frame_idx,
1325                                 };
1326
1327                                 if (!new_frame.dir) {
1328                                         if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG &&
1329                                                         errno == ENOENT) {
1330                                                 DBG("Non-existing directory stream during recursive directory removal");
1331                                                 break;
1332                                         } else {
1333                                                 PERROR("Failed to open directory stream during recursive directory removal");
1334                                                 ret = -1;
1335                                                 goto end;
1336                                         }
1337                                 }
1338                                 ret = lttng_dynamic_array_add_element(
1339                                                 &frames, &new_frame);
1340                                 if (ret) {
1341                                         ERR("Failed to push context frame during recursive directory removal");
1342                                         rmdir_frame_fini(&new_frame);
1343                                         goto end;
1344                                 }
1345                                 current_frame_idx++;
1346                                 /* We break iteration on readdir. */
1347                                 break;
1348                         }
1349                 }
1350                 if (entry) {
1351                         continue;
1352                 }
1353
1354                 /* Pop rmdir frame. */
1355                 if (current_frame->empty) {
1356                         ret = lttng_directory_handle_rmdir(
1357                                         handle, current_path.data);
1358                         if (ret) {
1359                                 if ((flags & LTTNG_DIRECTORY_HANDLE_FAIL_NON_EMPTY_FLAG) ||
1360                                                 errno != ENOENT) {
1361                                         PERROR("Failed to remove \"%s\" during recursive directory removal",
1362                                                         current_path.data);
1363                                         goto end;
1364                                 }
1365                                 DBG("Non-existing directory stream during recursive directory removal");
1366                         }
1367                 } else if (current_frame->parent_frame_idx >= 0) {
1368                         struct rmdir_frame *parent_frame;
1369
1370                         parent_frame = lttng_dynamic_array_get_element(&frames,
1371                                         current_frame->parent_frame_idx);
1372                         assert(parent_frame);
1373                         parent_frame->empty = false;
1374                 }
1375                 ret = lttng_dynamic_array_remove_element(
1376                                 &frames, current_frame_idx);
1377                 if (ret) {
1378                         ERR("Failed to pop context frame during recursive directory removal");
1379                         goto end;
1380                 }
1381                 current_frame_idx--;
1382         }
1383 end:
1384         lttng_dynamic_array_reset(&frames);
1385         lttng_dynamic_buffer_reset(&current_path);
1386         return ret;
1387 }
1388
1389 LTTNG_HIDDEN
1390 int lttng_directory_handle_remove_subdirectory_recursive(
1391                 const struct lttng_directory_handle *handle,
1392                 const char *name,
1393                 int flags)
1394 {
1395         return lttng_directory_handle_remove_subdirectory_recursive_as_user(
1396                         handle, name, NULL, flags);
1397 }
1398
1399 LTTNG_HIDDEN
1400 int lttng_directory_handle_remove_subdirectory_recursive_as_user(
1401                 const struct lttng_directory_handle *handle,
1402                 const char *name,
1403                 const struct lttng_credentials *creds,
1404                 int flags)
1405 {
1406         int ret;
1407
1408         if (!creds) {
1409                 /* Run as current user. */
1410                 ret = remove_directory_recursive(handle, name, flags);
1411         } else {
1412                 ret = _run_as_rmdir_recursive(handle, name, creds->uid,
1413                                 creds->gid, flags);
1414         }
1415         return ret;
1416 }