external/bsd/atf/dist/atf-c++/fs.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2007, 2008, 2009 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 #if defined(HAVE_CONFIG_H)
  31 #include "bconfig.h"
  32 #endif
  33
  34 extern "C" {
  35 #include <sys/param.h>
  36 #include <sys/types.h>
  37 #include <sys/mount.h>
  38 #include <sys/stat.h>
  39 #include <sys/wait.h>
  40 #include <dirent.h>
  41 #include <libgen.h>
  42 #include <unistd.h>
  43 }
  44
  45 #include <cerrno>
  46 #include <cstdlib>
  47 #include <cstring>
  48
  49 extern "C" {
  50 #include "atf-c/error.h"
  51 }
  52
  53 #include "atf-c++/exceptions.hpp"
  54 #include "atf-c++/env.hpp"
  55 #include "atf-c++/fs.hpp"
  56 #include "atf-c++/io.hpp"
  57 #include "atf-c++/sanity.hpp"
  58 #include "atf-c++/text.hpp"
  59 #include "atf-c++/user.hpp"
  60 #include "atf-c++/utils.hpp"
  61
  62 namespace impl = atf::fs;
  63 #define IMPL_NAME "atf::fs"
  64
  65 // ------------------------------------------------------------------------
  66 // Auxiliary functions.
  67 // ------------------------------------------------------------------------
  68
  69 //!
  70 //! \brief A controlled version of access(2).
  71 //!
  72 //! This function reimplements the standard access(2) system call to
  73 //! safely control its exit status and raise an exception in case of
  74 //! failure.
  75 //!
  76 static
  77 bool
  78 safe_access(const impl::path& p, int mode, int experr)
  79 {
  80     bool ok;
  81
  82     atf_error_t err = atf_fs_eaccess(p.c_path(), mode);
  83     if (atf_is_error(err)) {
  84         if (atf_error_is(err, "libc")) {
  85             if (atf_libc_error_code(err) == experr) {
  86                 atf_error_free(err);
  87                 ok = false;
  88             } else {
  89                 atf::throw_atf_error(err);
  90                 // XXX Silence warning; maybe throw_atf_error should be
  91                 // an exception and not a function.
  92                 ok = false;
  93             }
  94         } else {
  95             atf::throw_atf_error(err);
  96             // XXX Silence warning; maybe throw_atf_error should be
  97             // an exception and not a function.
  98             ok = false;
  99         }
 100     } else
 101         ok = true;
 102
 103     return ok;
 104 }
 105
 106 // ------------------------------------------------------------------------
 107 // The "path" class.
 108 // ------------------------------------------------------------------------
 109
 110 impl::path::path(const std::string& s)
 111 {
 112     atf_error_t err = atf_fs_path_init_fmt(&m_path, "%s", s.c_str());
 113     if (atf_is_error(err))
 114         throw_atf_error(err);
 115 }
 116
 117 impl::path::path(const path& p)
 118 {
 119     atf_error_t err = atf_fs_path_copy(&m_path, &p.m_path);
 120     if (atf_is_error(err))
 121         throw_atf_error(err);
 122 }
 123
 124 impl::path::path(const atf_fs_path_t *p)
 125 {
 126     atf_error_t err = atf_fs_path_copy(&m_path, p);
 127     if (atf_is_error(err))
 128         throw_atf_error(err);
 129 }
 130
 131 impl::path::~path(void)
 132 {
 133     atf_fs_path_fini(&m_path);
 134 }
 135
 136 const char*
 137 impl::path::c_str(void)
 138     const
 139 {
 140     return atf_fs_path_cstring(&m_path);
 141 }
 142
 143 const atf_fs_path_t*
 144 impl::path::c_path(void)
 145     const
 146 {
 147     return &m_path;
 148 }
 149
 150 std::string
 151 impl::path::str(void)
 152     const
 153 {
 154     return c_str();
 155 }
 156
 157 bool
 158 impl::path::is_absolute(void)
 159     const
 160 {
 161     return atf_fs_path_is_absolute(&m_path);
 162 }
 163
 164 bool
 165 impl::path::is_root(void)
 166     const
 167 {
 168     return atf_fs_path_is_root(&m_path);
 169 }
 170
 171 impl::path
 172 impl::path::branch_path(void)
 173     const
 174 {
 175     atf_fs_path_t bp;
 176     atf_error_t err;
 177
 178     err = atf_fs_path_branch_path(&m_path, &bp);
 179     if (atf_is_error(err))
 180         throw_atf_error(err);
 181
 182     path p(atf_fs_path_cstring(&bp));
 183     atf_fs_path_fini(&bp);
 184     return p;
 185 }
 186
 187 std::string
 188 impl::path::leaf_name(void)
 189     const
 190 {
 191     atf_dynstr_t ln;
 192     atf_error_t err;
 193
 194     err = atf_fs_path_leaf_name(&m_path, &ln);
 195     if (atf_is_error(err))
 196         throw_atf_error(err);
 197
 198     std::string s(atf_dynstr_cstring(&ln));
 199     atf_dynstr_fini(&ln);
 200     return s;
 201 }
 202
 203 impl::path
 204 impl::path::to_absolute(void)
 205     const
 206 {
 207     atf_fs_path_t pa;
 208
 209     atf_error_t err = atf_fs_path_to_absolute(&m_path, &pa);
 210     if (atf_is_error(err))
 211         throw_atf_error(err);
 212
 213     path p(atf_fs_path_cstring(&pa));
 214     atf_fs_path_fini(&pa);
 215     return p;
 216 }
 217
 218 impl::path&
 219 impl::path::operator=(const path& p)
 220 {
 221     atf_fs_path_t tmp;
 222
 223     atf_error_t err = atf_fs_path_init_fmt(&tmp, "%s", p.c_str());
 224     if (atf_is_error(err))
 225         throw_atf_error(err);
 226     else {
 227         atf_fs_path_fini(&m_path);
 228         m_path = tmp;
 229     }
 230
 231     return *this;
 232 }
 233
 234 bool
 235 impl::path::operator==(const path& p)
 236     const
 237 {
 238     return atf_equal_fs_path_fs_path(&m_path, &p.m_path);
 239 }
 240
 241 bool
 242 impl::path::operator!=(const path& p)
 243     const
 244 {
 245     return !atf_equal_fs_path_fs_path(&m_path, &p.m_path);
 246 }
 247
 248 impl::path
 249 impl::path::operator/(const std::string& p)
 250     const
 251 {
 252     path p2 = *this;
 253
 254     atf_error_t err = atf_fs_path_append_fmt(&p2.m_path, "%s", p.c_str());
 255     if (atf_is_error(err))
 256         throw_atf_error(err);
 257
 258     return p2;
 259 }
 260
 261 impl::path
 262 impl::path::operator/(const path& p)
 263     const
 264 {
 265     path p2 = *this;
 266
 267     atf_error_t err = atf_fs_path_append_fmt(&p2.m_path, "%s",
 268                                              atf_fs_path_cstring(&p.m_path));
 269     if (atf_is_error(err))
 270         throw_atf_error(err);
 271
 272     return p2;
 273 }
 274
 275 bool
 276 impl::path::operator<(const path& p)
 277     const
 278 {
 279     const char *s1 = atf_fs_path_cstring(&m_path);
 280     const char *s2 = atf_fs_path_cstring(&p.m_path);
 281     return std::strcmp(s1, s2) < 0;
 282 }
 283
 284 // ------------------------------------------------------------------------
 285 // The "file_info" class.
 286 // ------------------------------------------------------------------------
 287
 288 const int impl::file_info::blk_type = atf_fs_stat_blk_type;
 289 const int impl::file_info::chr_type = atf_fs_stat_chr_type;
 290 const int impl::file_info::dir_type = atf_fs_stat_dir_type;
 291 const int impl::file_info::fifo_type = atf_fs_stat_fifo_type;
 292 const int impl::file_info::lnk_type = atf_fs_stat_lnk_type;
 293 const int impl::file_info::reg_type = atf_fs_stat_reg_type;
 294 const int impl::file_info::sock_type = atf_fs_stat_sock_type;
 295 const int impl::file_info::wht_type = atf_fs_stat_wht_type;
 296
 297 impl::file_info::file_info(const path& p)
 298 {
 299     atf_error_t err;
 300
 301     err = atf_fs_stat_init(&m_stat, p.c_path());
 302     if (atf_is_error(err))
 303         throw_atf_error(err);
 304 }
 305
 306 impl::file_info::file_info(const file_info& fi)
 307 {
 308     atf_fs_stat_copy(&m_stat, &fi.m_stat);
 309 }
 310
 311 impl::file_info::~file_info(void)
 312 {
 313     atf_fs_stat_fini(&m_stat);
 314 }
 315
 316 dev_t
 317 impl::file_info::get_device(void)
 318     const
 319 {
 320     return atf_fs_stat_get_device(&m_stat);
 321 }
 322
 323 ino_t
 324 impl::file_info::get_inode(void)
 325     const
 326 {
 327     return atf_fs_stat_get_inode(&m_stat);
 328 }
 329
 330 mode_t
 331 impl::file_info::get_mode(void)
 332     const
 333 {
 334     return atf_fs_stat_get_mode(&m_stat);
 335 }
 336
 337 off_t
 338 impl::file_info::get_size(void)
 339     const
 340 {
 341     return atf_fs_stat_get_size(&m_stat);
 342 }
 343
 344 int
 345 impl::file_info::get_type(void)
 346     const
 347 {
 348     return atf_fs_stat_get_type(&m_stat);
 349 }
 350
 351 bool
 352 impl::file_info::is_owner_readable(void)
 353     const
 354 {
 355     return atf_fs_stat_is_owner_readable(&m_stat);
 356 }
 357
 358 bool
 359 impl::file_info::is_owner_writable(void)
 360     const
 361 {
 362     return atf_fs_stat_is_owner_writable(&m_stat);
 363 }
 364
 365 bool
 366 impl::file_info::is_owner_executable(void)
 367     const
 368 {
 369     return atf_fs_stat_is_owner_executable(&m_stat);
 370 }
 371
 372 bool
 373 impl::file_info::is_group_readable(void)
 374     const
 375 {
 376     return atf_fs_stat_is_group_readable(&m_stat);
 377 }
 378
 379 bool
 380 impl::file_info::is_group_writable(void)
 381     const
 382 {
 383     return atf_fs_stat_is_group_writable(&m_stat);
 384 }
 385
 386 bool
 387 impl::file_info::is_group_executable(void)
 388     const
 389 {
 390     return atf_fs_stat_is_group_executable(&m_stat);
 391 }
 392
 393 bool
 394 impl::file_info::is_other_readable(void)
 395     const
 396 {
 397     return atf_fs_stat_is_other_readable(&m_stat);
 398 }
 399
 400 bool
 401 impl::file_info::is_other_writable(void)
 402     const
 403 {
 404     return atf_fs_stat_is_other_writable(&m_stat);
 405 }
 406
 407 bool
 408 impl::file_info::is_other_executable(void)
 409     const
 410 {
 411     return atf_fs_stat_is_other_executable(&m_stat);
 412 }
 413
 414 // ------------------------------------------------------------------------
 415 // The "directory" class.
 416 // ------------------------------------------------------------------------
 417
 418 impl::directory::directory(const path& p)
 419 {
 420     DIR* dp = ::opendir(p.c_str());
 421     if (dp == NULL)
 422         throw system_error(IMPL_NAME "::directory::directory(" +
 423                            p.str() + ")", "opendir(3) failed", errno);
 424
 425     struct dirent* dep;
 426     while ((dep = ::readdir(dp)) != NULL) {
 427         path entryp = p / dep->d_name;
 428         insert(value_type(dep->d_name, file_info(entryp)));
 429     }
 430
 431     if (::closedir(dp) == -1)
 432         throw system_error(IMPL_NAME "::directory::directory(" +
 433                            p.str() + ")", "closedir(3) failed", errno);
 434 }
 435
 436 std::set< std::string >
 437 impl::directory::names(void)
 438     const
 439 {
 440     std::set< std::string > ns;
 441
 442     for (const_iterator iter = begin(); iter != end(); iter++)
 443         ns.insert((*iter).first);
 444
 445     return ns;
 446 }
 447
 448 // ------------------------------------------------------------------------
 449 // The "temp_dir" class.
 450 // ------------------------------------------------------------------------
 451
 452 impl::temp_dir::temp_dir(const path& p)
 453 {
 454     atf::utils::auto_array< char > buf(new char[p.str().length() + 1]);
 455     std::strcpy(buf.get(), p.c_str());
 456     if (::mkdtemp(buf.get()) == NULL)
 457         throw system_error(IMPL_NAME "::temp_dir::temp_dir(" +
 458                            p.str() + ")", "mkdtemp(3) failed",
 459                            errno);
 460
 461     m_path.reset(new path(buf.get()));
 462 }
 463
 464 impl::temp_dir::~temp_dir(void)
 465 {
 466     cleanup(*m_path);
 467 }
 468
 469 const impl::path&
 470 impl::temp_dir::get_path(void)
 471     const
 472 {
 473     return *m_path;
 474 }
 475
 476 // ------------------------------------------------------------------------
 477 // The "temp_file" class.
 478 // ------------------------------------------------------------------------
 479
 480 impl::temp_file::temp_file(const path& p) :
 481     std::ostream(NULL),
 482     m_fd(-1)
 483 {
 484     atf::utils::auto_array< char > buf(new char[p.str().length() + 1]);
 485     std::strcpy(buf.get(), p.c_str());
 486
 487     m_fd = ::mkstemp(buf.get());
 488     if (m_fd == -1)
 489         throw system_error(IMPL_NAME "::temp_file::temp_file(" +
 490                            p.str() + ")", "mkstemp(3) failed",
 491                            errno);
 492     m_systembuf.reset(new io::systembuf(m_fd));
 493     rdbuf(m_systembuf.get());
 494
 495     m_path.reset(new path(buf.get()));
 496 }
 497
 498 impl::temp_file::~temp_file(void)
 499 {
 500     close();
 501     try {
 502         remove(*m_path);
 503     } catch (const atf::system_error& e) {
 504         // Ignore deletion errors.
 505     }
 506 }
 507
 508 const impl::path&
 509 impl::temp_file::get_path(void)
 510     const
 511 {
 512     return *m_path;
 513 }
 514
 515 void
 516 impl::temp_file::close(void)
 517 {
 518     if (m_fd != -1) {
 519         flush();
 520         ::close(m_fd);
 521         m_fd = -1;
 522     }
 523 }
 524
 525 int
 526 impl::temp_file::fd(void)
 527 {
 528     INV(m_fd != -1);
 529     return m_fd;
 530 }
 531
 532 // ------------------------------------------------------------------------
 533 // Free functions.
 534 // ------------------------------------------------------------------------
 535
 536 impl::path
 537 impl::change_directory(const path& dir)
 538 {
 539     path olddir = get_current_dir();
 540
 541     if (olddir != dir) {
 542         if (::chdir(dir.c_str()) == -1)
 543             throw system_error(IMPL_NAME "::chdir(" + dir.str() + ")",
 544                                "chdir(2) failed", errno);
 545     }
 546
 547     return olddir;
 548 }
 549
 550 bool
 551 impl::exists(const path& p)
 552 {
 553     atf_error_t err;
 554     bool b;
 555
 556     err = atf_fs_exists(p.c_path(), &b);
 557     if (atf_is_error(err))
 558         throw_atf_error(err);
 559
 560     return b;
 561 }
 562
 563 bool
 564 impl::have_prog_in_path(const std::string& prog)
 565 {
 566     PRE(prog.find('/') == std::string::npos);
 567
 568     // Do not bother to provide a default value for PATH.  If it is not
 569     // there something is broken in the user's environment.
 570     if (!atf::env::has("PATH"))
 571         throw std::runtime_error("PATH not defined in the environment");
 572     std::vector< std::string > dirs =
 573         atf::text::split(atf::env::get("PATH"), ":");
 574
 575     bool found = false;
 576     for (std::vector< std::string >::const_iterator iter = dirs.begin();
 577          !found && iter != dirs.end(); iter++) {
 578         const path& dir = path(*iter);
 579
 580         if (is_executable(dir / prog))
 581             found = true;
 582     }
 583     return found;
 584 }
 585
 586 impl::path
 587 impl::get_current_dir(void)
 588 {
 589     atf_fs_path_t cwd;
 590
 591     atf_error_t err = atf_fs_getcwd(&cwd);
 592     if (atf_is_error(err))
 593         throw_atf_error(err);
 594
 595     path p(atf_fs_path_cstring(&cwd));
 596     atf_fs_path_fini(&cwd);
 597     return p;
 598 }
 599
 600 bool
 601 impl::is_executable(const path& p)
 602 {
 603     if (!exists(p))
 604         return false;
 605     return safe_access(p, atf_fs_access_x, EACCES);
 606 }
 607
 608 void
 609 impl::remove(const path& p)
 610 {
 611     if (file_info(p).get_type() == file_info::dir_type)
 612         throw atf::system_error(IMPL_NAME "::remove(" + p.str() + ")",
 613                                 "Is a directory",
 614                                 EPERM);
 615     if (::unlink(p.c_str()) == -1)
 616         throw atf::system_error(IMPL_NAME "::remove(" + p.str() + ")",
 617                                 "unlink(" + p.str() + ") failed",
 618                                 errno);
 619 }
 620
 621 void
 622 impl::cleanup(const path& p)
 623 {
 624     atf_error_t err;
 625
 626     err = atf_fs_cleanup(p.c_path());
 627     if (atf_is_error(err))
 628         throw_atf_error(err);
 629 }
 630
 631 void
 632 impl::rmdir(const path& p)
 633 {
 634     atf_error_t err = atf_fs_rmdir(p.c_path());
 635     if (atf_is_error(err))
 636         throw_atf_error(err);
 637 }
 638
 639 // XXX: This is racy if we have other threads.  We should grab the current
 640 // umask durent program initialization and never query it again, provided
 641 // that we don't modify it, of course.
 642 mode_t
 643 impl::current_umask(void)
 644 {
 645     const mode_t current = umask(0);
 646     (void)umask(current);
 647     return current;
 648 }