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         return unlinkat(handle->dirfd, name, AT_REMOVEDIR);
 359 }
 360
 361 static
 362 int _run_as_rmdir(const struct lttng_directory_handle *handle,
 363                 const char *name, uid_t uid, gid_t gid)
 364 {
 365         return run_as_rmdirat(handle->dirfd, name, uid, gid);
 366 }
 367
 368 static
 369 int _run_as_rmdir_recursive(
 370                 const struct lttng_directory_handle *handle, const char *name,
 371                 uid_t uid, gid_t gid, int flags)
 372 {
 373         return run_as_rmdirat_recursive(handle->dirfd, name, uid, gid, flags);
 374 }
 375
 376 #else /* COMPAT_DIRFD */
 377
 378 static
 379 int get_full_path(const struct lttng_directory_handle *handle,
 380                 const char *subdirectory, char *fullpath, size_t size)
 381 {
 382         int ret;
 383         const bool subdirectory_is_absolute =
 384                         subdirectory && *subdirectory == '/';
 385         const char * const base = subdirectory_is_absolute ?
 386                         subdirectory : handle->base_path;
 387         const char * const end = subdirectory && !subdirectory_is_absolute ?
 388                         subdirectory : NULL;
 389         const size_t base_len = strlen(base);
 390         const size_t end_len = end ? strlen(end) : 0;
 391         const bool add_separator_slash = end && base[base_len - 1] != '/';
 392         const bool add_trailing_slash = end && end[end_len - 1] != '/';
 393
 394         ret = snprintf(fullpath, size, "%s%s%s%s",
 395                         base,
 396                         add_separator_slash ? "/" : "",
 397                         end ? end : "",
 398                         add_trailing_slash ? "/" : "");
 399         if (ret == -1 || ret >= size) {
 400                 ERR("Failed to format subdirectory from directory handle");
 401                 ret = -1;
 402                 goto end;
 403         }
 404         ret = 0;
 405 end:
 406         return ret;
 407 }
 408
 409 static
 410 struct lttng_directory_handle *_lttng_directory_handle_create(char *path)
 411 {
 412         struct lttng_directory_handle *handle = zmalloc(sizeof(*handle));
 413
 414         if (!handle) {
 415                 goto end;
 416         }
 417         urcu_ref_init(&handle->ref);
 418         handle->base_path = path;
 419 end:
 420         return handle;
 421 }
 422
 423 LTTNG_HIDDEN
 424 struct lttng_directory_handle *lttng_directory_handle_create(
 425                 const char *path)
 426 {
 427         int ret;
 428         const char *cwd = "";
 429         size_t cwd_len, path_len;
 430         char cwd_buf[LTTNG_PATH_MAX] = {};
 431         char handle_buf[LTTNG_PATH_MAX] = {};
 432         struct lttng_directory_handle *new_handle = NULL;
 433         bool add_cwd_slash = false, add_trailing_slash = false;
 434         const struct lttng_directory_handle cwd_handle = {
 435                 .base_path = handle_buf,
 436         };
 437
 438         path_len = path ? strlen(path) : 0;
 439         add_trailing_slash = path && path[path_len - 1] != '/';
 440         if (!path || (path && *path != '/')) {
 441                 cwd = getcwd(cwd_buf, sizeof(cwd_buf));
 442                 if (!cwd) {
 443                         PERROR("Failed to initialize directory handle, can't get current working directory");
 444                         ret = -1;
 445                         goto end;
 446                 }
 447                 cwd_len = strlen(cwd);
 448                 if (cwd_len == 0) {
 449                         ERR("Failed to initialize directory handle, current working directory path has a length of 0");
 450                         ret = -1;
 451                         goto end;
 452                 }
 453                 add_cwd_slash = cwd[cwd_len - 1] != '/';
 454         }
 455
 456         ret = snprintf(handle_buf, sizeof(handle_buf), "%s%s%s%s",
 457                         cwd,
 458                         add_cwd_slash ? "/" : "",
 459                         path ? : "",
 460                         add_trailing_slash ? "/" : "");
 461         if (ret == -1 || ret >= LTTNG_PATH_MAX) {
 462                 ERR("Failed to initialize directory handle, failed to format directory path");
 463                 goto end;
 464         }
 465
 466         new_handle = lttng_directory_handle_create_from_handle(path, &cwd_handle);
 467 end:
 468         return new_handle;
 469 }
 470
 471 LTTNG_HIDDEN
 472 struct lttng_directory_handle *lttng_directory_handle_create_from_handle(
 473                 const char *path,
 474                 const struct lttng_directory_handle *ref_handle)
 475 {
 476         int ret;
 477         size_t path_len, handle_path_len;
 478         bool add_trailing_slash;
 479         struct stat stat_buf;
 480         struct lttng_directory_handle *new_handle = NULL;
 481         char *new_path = NULL;
 482
 483         assert(ref_handle && ref_handle->base_path);
 484
 485         ret = lttng_directory_handle_stat(ref_handle, path, &stat_buf);
 486         if (ret == -1) {
 487                 PERROR("Failed to create directory handle");
 488                 goto end;
 489         } else if (!S_ISDIR(stat_buf.st_mode)) {
 490                 char full_path[LTTNG_PATH_MAX];
 491
 492                 /* Best effort for logging purposes. */
 493                 ret = get_full_path(ref_handle, path, full_path,
 494                                 sizeof(full_path));
 495                 if (ret) {
 496                         full_path[0] = '\0';
 497                 }
 498
 499                 ERR("Failed to initialize directory handle to \"%s\": not a directory",
 500                                 full_path);
 501                 goto end;
 502         }
 503         if (!path) {
 504                 new_handle = lttng_directory_handle_copy(ref_handle);
 505                 goto end;
 506         }
 507
 508         path_len = strlen(path);
 509         if (path_len == 0) {
 510                 ERR("Failed to initialize directory handle: provided path is an empty string");
 511                 ret = -1;
 512                 goto end;
 513         }
 514         if (*path == '/') {
 515                 new_path = strdup(path);
 516                 if (!new_path) {
 517                         goto end;
 518                 }
 519                 /* Takes ownership of new_path. */
 520                 new_handle = _lttng_directory_handle_create(new_path);
 521                 new_path = NULL;
 522                 goto end;
 523         }
 524
 525         add_trailing_slash = path[path_len - 1] != '/';
 526
 527         handle_path_len = strlen(ref_handle->base_path) + path_len +
 528                         !!add_trailing_slash;
 529         if (handle_path_len >= LTTNG_PATH_MAX) {
 530                 ERR("Failed to initialize directory handle as the resulting path's length (%zu bytes) exceeds the maximal allowed length (%d bytes)",
 531                                 handle_path_len, LTTNG_PATH_MAX);
 532                 goto end;
 533         }
 534         new_path = zmalloc(handle_path_len);
 535         if (!new_path) {
 536                 PERROR("Failed to initialize directory handle");
 537                 goto end;
 538         }
 539
 540         ret = sprintf(new_handle->base_path, "%s%s%s",
 541                         ref_handle->base_path,
 542                         path,
 543                         add_trailing_slash ? "/" : "");
 544         if (ret == -1 || ret >= handle_path_len) {
 545                 ERR("Failed to initialize directory handle: path formatting failed");
 546                 goto end;
 547         }
 548         new_handle = _lttng_directory_handle_create(new_path);
 549         new_path = NULL;
 550 end:
 551         free(new_path);
 552         return new_handle;
 553 }
 554
 555 LTTNG_HIDDEN
 556 struct lttng_directory_handle *lttng_directory_handle_create_from_dirfd(
 557                 int dirfd)
 558 {
 559         assert(dirfd == AT_FDCWD);
 560         return lttng_directory_handle_create(NULL);
 561 }
 562
 563 static
 564 void lttng_directory_handle_release(struct urcu_ref *ref)
 565 {
 566         struct lttng_directory_handle *handle =
 567                         container_of(ref, struct lttng_directory_handle, ref);
 568
 569         free(handle->base_path);
 570         lttng_directory_handle_invalidate(handle);
 571         free(handle);
 572 }
 573
 574 LTTNG_HIDDEN
 575 struct lttng_directory_handle *lttng_directory_handle_copy(
 576                 const struct lttng_directory_handle *handle)
 577 {
 578         struct lttng_directory_handle *new_handle = NULL;
 579         char *new_path = NULL;
 580
 581         if (handle->base_path) {
 582                 new_path = strdup(handle->base_path);
 583                 if (!new_path) {
 584                         goto end;
 585                 }
 586         }
 587         new_handle = _lttng_directory_handle_create(new_path);
 588 end:
 589         return new_handle;
 590 }
 591
 592 LTTNG_HIDDEN
 593 bool lttng_directory_handle_equals(const struct lttng_directory_handle *lhs,
 594                 const struct lttng_directory_handle *rhs)
 595 {
 596         return strcmp(lhs->base_path, rhs->base_path) == 0;
 597 }
 598
 599 static
 600 void lttng_directory_handle_invalidate(struct lttng_directory_handle *handle)
 601 {
 602         handle->base_path = NULL;
 603 }
 604
 605 LTTNG_HIDDEN
 606 int lttng_directory_handle_stat(const struct lttng_directory_handle *handle,
 607                 const char *subdirectory, struct stat *st)
 608 {
 609         int ret;
 610         char fullpath[LTTNG_PATH_MAX];
 611
 612         ret = get_full_path(handle, subdirectory, fullpath, sizeof(fullpath));
 613         if (ret) {
 614                 errno = ENOMEM;
 615                 goto end;
 616         }
 617
 618         ret = stat(fullpath, st);
 619 end:
 620         return ret;
 621 }
 622
 623 LTTNG_HIDDEN
 624 bool lttng_directory_handle_uses_fd(
 625                 const struct lttng_directory_handle *handle)
 626 {
 627         return false;
 628 }
 629
 630 static
 631 int lttng_directory_handle_mkdir(const struct lttng_directory_handle *handle,
 632                 const char *subdirectory, mode_t mode)
 633 {
 634         int ret;
 635         char fullpath[LTTNG_PATH_MAX];
 636
 637         ret = get_full_path(handle, subdirectory, fullpath, sizeof(fullpath));
 638         if (ret) {
 639                 errno = ENOMEM;
 640                 goto end;
 641         }
 642
 643         ret = mkdir(fullpath, mode);
 644 end:
 645         return ret;
 646 }
 647
 648 static
 649 int lttng_directory_handle_open(const struct lttng_directory_handle *handle,
 650                 const char *filename, int flags, mode_t mode)
 651 {
 652         int ret;
 653         char fullpath[LTTNG_PATH_MAX];
 654
 655         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 656         if (ret) {
 657                 errno = ENOMEM;
 658                 goto end;
 659         }
 660
 661         ret = open(fullpath, flags, mode);
 662 end:
 663         return ret;
 664 }
 665
 666 static
 667 int lttng_directory_handle_unlink(
 668                 const struct lttng_directory_handle *handle,
 669                 const char *filename)
 670 {
 671         int ret;
 672         char fullpath[LTTNG_PATH_MAX];
 673
 674         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 675         if (ret) {
 676                 errno = ENOMEM;
 677                 goto end;
 678         }
 679
 680         ret = unlink(fullpath);
 681 end:
 682         return ret;
 683 }
 684
 685 static
 686 int _run_as_mkdir(const struct lttng_directory_handle *handle, const char *path,
 687                 mode_t mode, uid_t uid, gid_t gid)
 688 {
 689         int ret;
 690         char fullpath[LTTNG_PATH_MAX];
 691
 692         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 693         if (ret) {
 694                 errno = ENOMEM;
 695                 goto end;
 696         }
 697
 698         ret = run_as_mkdir(fullpath, mode, uid, gid);
 699 end:
 700         return ret;
 701 }
 702
 703 static
 704 int _run_as_open(const struct lttng_directory_handle *handle,
 705                 const char *filename,
 706                 int flags, mode_t mode, uid_t uid, gid_t gid)
 707 {
 708         int ret;
 709         char fullpath[LTTNG_PATH_MAX];
 710
 711         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 712         if (ret) {
 713                 errno = ENOMEM;
 714                 goto end;
 715         }
 716
 717         ret = run_as_open(fullpath, flags, mode, uid, gid);
 718 end:
 719         return ret;
 720 }
 721
 722 static
 723 int _run_as_unlink(const struct lttng_directory_handle *handle,
 724                 const char *filename, uid_t uid, gid_t gid)
 725 {
 726         int ret;
 727         char fullpath[LTTNG_PATH_MAX];
 728
 729         ret = get_full_path(handle, filename, fullpath, sizeof(fullpath));
 730         if (ret) {
 731                 errno = ENOMEM;
 732                 goto end;
 733         }
 734
 735         ret = run_as_unlink(fullpath, uid, gid);
 736 end:
 737         return ret;
 738 }
 739
 740 static
 741 int _run_as_mkdir_recursive(const struct lttng_directory_handle *handle,
 742                 const char *path, mode_t mode, uid_t uid, gid_t gid)
 743 {
 744         int ret;
 745         char fullpath[LTTNG_PATH_MAX];
 746
 747         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 748         if (ret) {
 749                 errno = ENOMEM;
 750                 goto end;
 751         }
 752
 753         ret = run_as_mkdir_recursive(fullpath, mode, uid, gid);
 754 end:
 755         return ret;
 756 }
 757
 758 static
 759 int _lttng_directory_handle_rename(
 760                 const struct lttng_directory_handle *old_handle,
 761                 const char *old_name,
 762                 const struct lttng_directory_handle *new_handle,
 763                 const char *new_name)
 764 {
 765         int ret;
 766         char old_fullpath[LTTNG_PATH_MAX];
 767         char new_fullpath[LTTNG_PATH_MAX];
 768
 769         ret = get_full_path(old_handle, old_name, old_fullpath,
 770                         sizeof(old_fullpath));
 771         if (ret) {
 772                 errno = ENOMEM;
 773                 goto end;
 774         }
 775         ret = get_full_path(new_handle, new_name, new_fullpath,
 776                         sizeof(new_fullpath));
 777         if (ret) {
 778                 errno = ENOMEM;
 779                 goto end;
 780         }
 781
 782         ret = rename(old_fullpath, new_fullpath);
 783 end:
 784         return ret;
 785 }
 786
 787 static
 788 int _run_as_rename(const struct lttng_directory_handle *old_handle,
 789                 const char *old_name,
 790                 const struct lttng_directory_handle *new_handle,
 791                 const char *new_name, uid_t uid, gid_t gid)
 792 {
 793         int ret;
 794         char old_fullpath[LTTNG_PATH_MAX];
 795         char new_fullpath[LTTNG_PATH_MAX];
 796
 797         ret = get_full_path(old_handle, old_name, old_fullpath,
 798                         sizeof(old_fullpath));
 799         if (ret) {
 800                 errno = ENOMEM;
 801                 goto end;
 802         }
 803         ret = get_full_path(new_handle, new_name, new_fullpath,
 804                         sizeof(new_fullpath));
 805         if (ret) {
 806                 errno = ENOMEM;
 807                 goto end;
 808         }
 809
 810         ret = run_as_rename(old_fullpath, new_fullpath, uid, gid);
 811 end:
 812         return ret;
 813 }
 814
 815 static
 816 DIR *lttng_directory_handle_opendir(const struct lttng_directory_handle *handle,
 817                 const char *path)
 818 {
 819         int ret;
 820         DIR *dir_stream = NULL;
 821         char fullpath[LTTNG_PATH_MAX];
 822
 823         ret = get_full_path(handle, path, fullpath, sizeof(fullpath));
 824         if (ret) {
 825                 errno = ENOMEM;
 826                 goto end;
 827         }
 828
 829         dir_stream = opendir(fullpath);
 830 end:
 831         return dir_stream;
 832 }
 833
 834 static
 835 int lttng_directory_handle_rmdir(
 836                 const struct lttng_directory_handle *handle, const char *name)
 837 {
 838         int ret;
 839         char fullpath[LTTNG_PATH_MAX];
 840
 841         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 842         if (ret) {
 843                 errno = ENOMEM;
 844                 goto end;
 845         }
 846
 847         ret = rmdir(fullpath);
 848 end:
 849         return ret;
 850 }
 851
 852 static
 853 int _run_as_rmdir(const struct lttng_directory_handle *handle,
 854                 const char *name, uid_t uid, gid_t gid)
 855 {
 856         int ret;
 857         char fullpath[LTTNG_PATH_MAX];
 858
 859         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 860         if (ret) {
 861                 errno = ENOMEM;
 862                 goto end;
 863         }
 864
 865         ret = run_as_rmdir(fullpath, uid, gid);
 866 end:
 867         return ret;
 868 }
 869
 870 static
 871 int _run_as_rmdir_recursive(
 872                 const struct lttng_directory_handle *handle, const char *name,
 873                 uid_t uid, gid_t gid, int flags)
 874 {
 875         int ret;
 876         char fullpath[LTTNG_PATH_MAX];
 877
 878         ret = get_full_path(handle, name, fullpath, sizeof(fullpath));
 879         if (ret) {
 880                 errno = ENOMEM;
 881                 goto end;
 882         }
 883
 884         ret = run_as_rmdir_recursive(fullpath, uid, gid, flags);
 885 end:
 886         return ret;
 887 }
 888
 889 #endif /* COMPAT_DIRFD */
 890
 891 /* Common implementation. */
 892
 893 /*
 894  * On some filesystems (e.g. nfs), mkdir will validate access rights before
 895  * checking for the existence of the path element. This means that on a setup
 896  * where "/home/" is a mounted NFS share, and running as an unpriviledged user,
 897  * recursively creating a path of the form "/home/my_user/trace/" will fail with
 898  * EACCES on mkdir("/home", ...).
 899  *
 900  * Checking the path for existence allows us to work around this behaviour.
 901  */
 902 static
 903 int create_directory_check_exists(const struct lttng_directory_handle *handle,
 904                 const char *path, mode_t mode)
 905 {
 906         int ret = 0;
 907         struct stat st;
 908
 909         ret = lttng_directory_handle_stat(handle, path, &st);
 910         if (ret == 0) {
 911                 if (S_ISDIR(st.st_mode)) {
 912                         /* Directory exists, skip. */
 913                         goto end;
 914                 } else {
 915                         /* Exists, but is not a directory. */
 916                         errno = ENOTDIR;
 917                         ret = -1;
 918                         goto end;
 919                 }
 920         } else if (errno != ENOENT) {
 921                 goto end;
 922         }
 923
 924         /*
 925          * Let mkdir handle other errors as the caller expects mkdir
 926          * semantics.
 927          */
 928         ret = lttng_directory_handle_mkdir(handle, path, mode);
 929 end:
 930         return ret;
 931 }
 932
 933 static
 934 int create_directory_recursive(const struct lttng_directory_handle *handle,
 935                 const char *path, mode_t mode)
 936 {
 937         char *p, tmp[LTTNG_PATH_MAX];
 938         size_t len;
 939         int ret;
 940
 941         assert(path);
 942
 943         ret = lttng_strncpy(tmp, path, sizeof(tmp));
 944         if (ret) {
 945                 ERR("Failed to create directory: provided path's length (%zu bytes) exceeds the maximal allowed length (%zu bytes)",
 946                                 strlen(path) + 1, sizeof(tmp));
 947                 goto error;
 948         }
 949
 950         len = strlen(path);
 951         if (tmp[len - 1] == '/') {
 952                 tmp[len - 1] = 0;
 953         }
 954
 955         for (p = tmp + 1; *p; p++) {
 956                 if (*p == '/') {
 957                         *p = 0;
 958                         if (tmp[strlen(tmp) - 1] == '.' &&
 959                                         tmp[strlen(tmp) - 2] == '.' &&
 960                                         tmp[strlen(tmp) - 3] == '/') {
 961                                 ERR("Using '/../' is not permitted in the trace path (%s)",
 962                                                 tmp);
 963                                 ret = -1;
 964                                 goto error;
 965                         }
 966                         ret = create_directory_check_exists(handle, tmp, mode);
 967                         if (ret < 0) {
 968                                 if (errno != EACCES) {
 969                                         PERROR("Failed to create directory \"%s\"",
 970                                                         path);
 971                                         ret = -errno;
 972                                         goto error;
 973                                 }
 974                         }
 975                         *p = '/';
 976                 }
 977         }
 978
 979         ret = create_directory_check_exists(handle, tmp, mode);
 980         if (ret < 0) {
 981                 PERROR("mkdirat recursive last element");
 982                 ret = -errno;
 983         }
 984 error:
 985         return ret;
 986 }
 987
 988 LTTNG_HIDDEN
 989 bool lttng_directory_handle_get(struct lttng_directory_handle *handle)
 990 {
 991         return urcu_ref_get_unless_zero(&handle->ref);
 992 }
 993
 994 LTTNG_HIDDEN
 995 void lttng_directory_handle_put(struct lttng_directory_handle *handle)
 996 {
 997         if (!handle) {
 998                 return;
 999         }
1000         assert(handle->ref.refcount);
1001         urcu_ref_put(&handle->ref, lttng_directory_handle_release);
1002 }
1003
1004 LTTNG_HIDDEN
1005 int lttng_directory_handle_create_subdirectory_as_user(
1006                 const struct lttng_directory_handle *handle,
1007                 const char *subdirectory,
1008                 mode_t mode, const struct lttng_credentials *creds)
1009 {
1010         int ret;
1011
1012         if (!creds) {
1013                 /* Run as current user. */
1014                 ret = create_directory_check_exists(handle,
1015                                 subdirectory, mode);
1016         } else {
1017                 ret = _run_as_mkdir(handle, subdirectory,
1018                                 mode, creds->uid, creds->gid);
1019         }
1020
1021         return ret;
1022 }
1023
1024 LTTNG_HIDDEN
1025 int lttng_directory_handle_create_subdirectory_recursive_as_user(
1026                 const struct lttng_directory_handle *handle,
1027                 const char *subdirectory_path,
1028                 mode_t mode, const struct lttng_credentials *creds)
1029 {
1030         int ret;
1031
1032         if (!creds) {
1033                 /* Run as current user. */
1034                 ret = create_directory_recursive(handle,
1035                                 subdirectory_path, mode);
1036         } else {
1037                 ret = _run_as_mkdir_recursive(handle, subdirectory_path,
1038                                 mode, creds->uid, creds->gid);
1039         }
1040
1041         return ret;
1042 }
1043
1044 LTTNG_HIDDEN
1045 int lttng_directory_handle_create_subdirectory(
1046                 const struct lttng_directory_handle *handle,
1047                 const char *subdirectory,
1048                 mode_t mode)
1049 {
1050         return lttng_directory_handle_create_subdirectory_as_user(
1051                         handle, subdirectory, mode, NULL);
1052 }
1053
1054 LTTNG_HIDDEN
1055 int lttng_directory_handle_create_subdirectory_recursive(
1056                 const struct lttng_directory_handle *handle,
1057                 const char *subdirectory_path,
1058                 mode_t mode)
1059 {
1060         return lttng_directory_handle_create_subdirectory_recursive_as_user(
1061                         handle, subdirectory_path, mode, NULL);
1062 }
1063
1064 LTTNG_HIDDEN
1065 int lttng_directory_handle_open_file_as_user(
1066                 const struct lttng_directory_handle *handle,
1067                 const char *filename,
1068                 int flags, mode_t mode,
1069                 const struct lttng_credentials *creds)
1070 {
1071         int ret;
1072
1073         if (!creds) {
1074                 /* Run as current user. */
1075                 ret = lttng_directory_handle_open(handle, filename, flags,
1076                                 mode);
1077         } else {
1078                 ret = _run_as_open(handle, filename, flags, mode,
1079                                 creds->uid, creds->gid);
1080         }
1081         return ret;
1082 }
1083
1084 LTTNG_HIDDEN
1085 int lttng_directory_handle_open_file(
1086                 const struct lttng_directory_handle *handle,
1087                 const char *filename,
1088                 int flags, mode_t mode)
1089 {
1090         return lttng_directory_handle_open_file_as_user(handle, filename, flags,
1091                         mode, NULL);
1092 }
1093
1094 LTTNG_HIDDEN
1095 int lttng_directory_handle_unlink_file_as_user(
1096                 const struct lttng_directory_handle *handle,
1097                 const char *filename,
1098                 const struct lttng_credentials *creds)
1099 {
1100         int ret;
1101
1102         if (!creds) {
1103                 /* Run as current user. */
1104                 ret = lttng_directory_handle_unlink(handle, filename);
1105         } else {
1106                 ret = _run_as_unlink(handle, filename, creds->uid, creds->gid);
1107         }
1108         return ret;
1109 }
1110
1111 LTTNG_HIDDEN
1112 int lttng_directory_handle_unlink_file(
1113                 const struct lttng_directory_handle *handle,
1114                 const char *filename)
1115 {
1116         return lttng_directory_handle_unlink_file_as_user(handle,
1117                         filename, NULL);
1118 }
1119
1120 LTTNG_HIDDEN
1121 int lttng_directory_handle_rename(
1122                 const struct lttng_directory_handle *old_handle,
1123                 const char *old_name,
1124                 const struct lttng_directory_handle *new_handle,
1125                 const char *new_name)
1126 {
1127         return lttng_directory_handle_rename_as_user(old_handle, old_name,
1128                         new_handle, new_name, NULL);
1129 }
1130
1131 LTTNG_HIDDEN
1132 int lttng_directory_handle_rename_as_user(
1133                 const struct lttng_directory_handle *old_handle,
1134                 const char *old_name,
1135                 const struct lttng_directory_handle *new_handle,
1136                 const char *new_name,
1137                 const struct lttng_credentials *creds)
1138 {
1139         int ret;
1140
1141         if (!creds) {
1142                 /* Run as current user. */
1143                 ret = _lttng_directory_handle_rename(old_handle,
1144                                 old_name, new_handle, new_name);
1145         } else {
1146                 ret = _run_as_rename(old_handle, old_name, new_handle,
1147                                 new_name, creds->uid, creds->gid);
1148         }
1149         return ret;
1150 }
1151
1152 LTTNG_HIDDEN
1153 int lttng_directory_handle_remove_subdirectory(
1154                 const struct lttng_directory_handle *handle,
1155                 const char *name)
1156 {
1157         return lttng_directory_handle_remove_subdirectory_as_user(handle, name,
1158                         NULL);
1159 }
1160
1161 LTTNG_HIDDEN
1162 int lttng_directory_handle_remove_subdirectory_as_user(
1163                 const struct lttng_directory_handle *handle,
1164                 const char *name,
1165                 const struct lttng_credentials *creds)
1166 {
1167         int ret;
1168
1169         if (!creds) {
1170                 /* Run as current user. */
1171                 ret = lttng_directory_handle_rmdir(handle, name);
1172         } else {
1173                 ret = _run_as_rmdir(handle, name, creds->uid, creds->gid);
1174         }
1175         return ret;
1176 }
1177
1178 struct rmdir_frame {
1179         ssize_t parent_frame_idx;
1180         DIR *dir;
1181         bool empty;
1182         /* Size including '\0'. */
1183         size_t path_size;
1184 };
1185
1186 static
1187 void rmdir_frame_fini(void *data)
1188 {
1189         int ret;
1190         struct rmdir_frame *frame = data;
1191
1192         ret = closedir(frame->dir);
1193         if (ret == -1) {
1194                 PERROR("Failed to close directory stream");
1195         }
1196 }
1197
1198 static
1199 int remove_directory_recursive(const struct lttng_directory_handle *handle,
1200                 const char *path, int flags)
1201 {
1202         int ret;
1203         struct lttng_dynamic_array frames;
1204         size_t current_frame_idx = 0;
1205         struct rmdir_frame initial_frame = {
1206                 .parent_frame_idx = -1,
1207                 .dir = lttng_directory_handle_opendir(handle, path),
1208                 .empty = true,
1209                 .path_size = strlen(path) + 1,
1210         };
1211         struct lttng_dynamic_buffer current_path;
1212         const char separator = '/';
1213
1214         lttng_dynamic_buffer_init(&current_path);
1215         lttng_dynamic_array_init(&frames, sizeof(struct rmdir_frame),
1216                         rmdir_frame_fini);
1217
1218         if (flags & ~(LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG |
1219                                     LTTNG_DIRECTORY_HANDLE_FAIL_NON_EMPTY_FLAG)) {
1220                 ERR("Unknown flags %d", flags);
1221                 ret = -1;
1222                 goto end;
1223         }
1224
1225         if (!initial_frame.dir) {
1226                 if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG &&
1227                                 errno == ENOENT) {
1228                         DBG("Cannot rmdir \"%s\": root does not exist", path);
1229                         ret = 0;
1230                         goto end;
1231                 } else {
1232                         PERROR("Failed to rmdir \"%s\"", path);
1233                         ret = -1;
1234                         goto end;
1235                 }
1236         }
1237
1238         ret = lttng_dynamic_array_add_element(&frames, &initial_frame);
1239         if (ret) {
1240                 ERR("Failed to push context frame during recursive directory removal");
1241                 rmdir_frame_fini(&initial_frame);
1242                 goto end;
1243         }
1244
1245         ret = lttng_dynamic_buffer_append(
1246                         &current_path, path, initial_frame.path_size);
1247         if (ret) {
1248                 ERR("Failed to set initial path during recursive directory removal");
1249                 ret = -1;
1250                 goto end;
1251         }
1252
1253         while (lttng_dynamic_array_get_count(&frames) > 0) {
1254                 struct dirent *entry;
1255                 struct rmdir_frame *current_frame =
1256                                 lttng_dynamic_array_get_element(
1257                                                 &frames, current_frame_idx);
1258
1259                 assert(current_frame->dir);
1260                 ret = lttng_dynamic_buffer_set_size(
1261                                 &current_path, current_frame->path_size);
1262                 assert(!ret);
1263                 current_path.data[current_path.size - 1] = '\0';
1264
1265                 while ((entry = readdir(current_frame->dir))) {
1266                         struct stat st;
1267
1268                         if (!strcmp(entry->d_name, ".") ||
1269                                         !strcmp(entry->d_name, "..")) {
1270                                 continue;
1271                         }
1272
1273                         /* Set current_path to the entry's path. */
1274                         ret = lttng_dynamic_buffer_set_size(
1275                                         &current_path, current_path.size - 1);
1276                         assert(!ret);
1277                         ret = lttng_dynamic_buffer_append(&current_path,
1278                                         &separator, sizeof(separator));
1279                         if (ret) {
1280                                 goto end;
1281                         }
1282                         ret = lttng_dynamic_buffer_append(&current_path,
1283                                         entry->d_name,
1284                                         strlen(entry->d_name) + 1);
1285                         if (ret) {
1286                                 goto end;
1287                         }
1288
1289                         if (lttng_directory_handle_stat(
1290                                             handle, current_path.data, &st)) {
1291                                 if ((flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG) &&
1292                                                 errno == ENOENT) {
1293                                         break;
1294                                 }
1295                                 PERROR("Failed to stat \"%s\"",
1296                                                 current_path.data);
1297                                 ret = -1;
1298                                 goto end;
1299                         }
1300
1301                         if (!S_ISDIR(st.st_mode)) {
1302                                 if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG) {
1303                                         current_frame->empty = false;
1304                                         break;
1305                                 } else {
1306                                         /* Not empty, abort. */
1307                                         DBG("Directory \"%s\" is not empty; refusing to remove directory",
1308                                                         current_path.data);
1309                                         ret = -1;
1310                                         goto end;
1311                                 }
1312                         } else {
1313                                 struct rmdir_frame new_frame = {
1314                                         .path_size = current_path.size,
1315                                         .dir = lttng_directory_handle_opendir(
1316                                                         handle,
1317                                                         current_path.data),
1318                                         .empty = true,
1319                                         .parent_frame_idx = current_frame_idx,
1320                                 };
1321
1322                                 if (!new_frame.dir) {
1323                                         if (flags & LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG &&
1324                                                         errno == ENOENT) {
1325                                                 DBG("Non-existing directory stream during recursive directory removal");
1326                                                 break;
1327                                         } else {
1328                                                 PERROR("Failed to open directory stream during recursive directory removal");
1329                                                 ret = -1;
1330                                                 goto end;
1331                                         }
1332                                 }
1333                                 ret = lttng_dynamic_array_add_element(
1334                                                 &frames, &new_frame);
1335                                 if (ret) {
1336                                         ERR("Failed to push context frame during recursive directory removal");
1337                                         rmdir_frame_fini(&new_frame);
1338                                         goto end;
1339                                 }
1340                                 current_frame_idx++;
1341                                 /* We break iteration on readdir. */
1342                                 break;
1343                         }
1344                 }
1345                 if (entry) {
1346                         continue;
1347                 }
1348
1349                 /* Pop rmdir frame. */
1350                 if (current_frame->empty) {
1351                         ret = lttng_directory_handle_rmdir(
1352                                         handle, current_path.data);
1353                         if (ret) {
1354                                 if ((flags & LTTNG_DIRECTORY_HANDLE_FAIL_NON_EMPTY_FLAG) ||
1355                                                 errno != ENOENT) {
1356                                         PERROR("Failed to remove \"%s\" during recursive directory removal",
1357                                                         current_path.data);
1358                                         goto end;
1359                                 }
1360                                 DBG("Non-existing directory stream during recursive directory removal");
1361                         }
1362                 } else if (current_frame->parent_frame_idx >= 0) {
1363                         struct rmdir_frame *parent_frame;
1364
1365                         parent_frame = lttng_dynamic_array_get_element(&frames,
1366                                         current_frame->parent_frame_idx);
1367                         assert(parent_frame);
1368                         parent_frame->empty = false;
1369                 }
1370                 ret = lttng_dynamic_array_remove_element(
1371                                 &frames, current_frame_idx);
1372                 if (ret) {
1373                         ERR("Failed to pop context frame during recursive directory removal");
1374                         goto end;
1375                 }
1376                 current_frame_idx--;
1377         }
1378 end:
1379         lttng_dynamic_array_reset(&frames);
1380         lttng_dynamic_buffer_reset(&current_path);
1381         return ret;
1382 }
1383
1384 LTTNG_HIDDEN
1385 int lttng_directory_handle_remove_subdirectory_recursive(
1386                 const struct lttng_directory_handle *handle,
1387                 const char *name,
1388                 int flags)
1389 {
1390         return lttng_directory_handle_remove_subdirectory_recursive_as_user(
1391                         handle, name, NULL, flags);
1392 }
1393
1394 LTTNG_HIDDEN
1395 int lttng_directory_handle_remove_subdirectory_recursive_as_user(
1396                 const struct lttng_directory_handle *handle,
1397                 const char *name,
1398                 const struct lttng_credentials *creds,
1399                 int flags)
1400 {
1401         int ret;
1402
1403         if (!creds) {
1404                 /* Run as current user. */
1405                 ret = remove_directory_recursive(handle, name, flags);
1406         } else {
1407                 ret = _run_as_rmdir_recursive(handle, name, creds->uid,
1408                                 creds->gid, flags);
1409         }
1410         return ret;
1411 }