zypp/PathInfo.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/PathInfo.cc
  10  *
  11 */
  12
  13 #include <utime.h>     // for ::utime
  14 #include <sys/statvfs.h>
  15 #include <sys/sysmacros.h> // for ::minor, ::major macros
  16
  17 #include <iostream>
  18 #include <fstream>
  19 #include <iomanip>
  20
  21 #include <zypp/base/LogTools.h>
  22 #include <zypp/base/String.h>
  23 #include <zypp/base/IOStream.h>
  24 #include <zypp/base/StrMatcher.h>
  25 #include <zypp/base/Errno.h>
  26
  27 #include <zypp/AutoDispose.h>
  28 #include <zypp/ExternalProgram.h>
  29 #include <zypp/PathInfo.h>
  30 #include <zypp/Digest.h>
  31 #include <zypp/TmpPath.h>
  32
  33 using std::endl;
  34 using std::string;
  35
  36 ///////////////////////////////////////////////////////////////////
  37 namespace zypp
  38 { /////////////////////////////////////////////////////////////////
  39   ///////////////////////////////////////////////////////////////////
  40   namespace filesystem
  41   { /////////////////////////////////////////////////////////////////
  42
  43     /******************************************************************
  44      **
  45      ** FUNCTION NAME : operator<<
  46      ** FUNCTION TYPE : std::ostream &
  47     */
  48     std::ostream & operator<<( std::ostream & str, FileType obj )
  49     {
  50       switch ( obj ) {
  51 #define EMUMOUT(T) case T: return str << #T; break
  52         EMUMOUT( FT_NOT_AVAIL );
  53         EMUMOUT( FT_NOT_EXIST );
  54         EMUMOUT( FT_FILE );
  55         EMUMOUT( FT_DIR );
  56         EMUMOUT( FT_CHARDEV );
  57         EMUMOUT( FT_BLOCKDEV );
  58         EMUMOUT( FT_FIFO );
  59         EMUMOUT( FT_LINK );
  60         EMUMOUT( FT_SOCKET );
  61 #undef EMUMOUT
  62       }
  63       return str;
  64     }
  65
  66     ///////////////////////////////////////////////////////////////////
  67     //
  68     //  METHOD NAME : StatMode::fileType
  69     //  METHOD TYPE : FileType
  70     //
  71     FileType StatMode::fileType() const
  72     {
  73       if ( isFile() )
  74         return FT_FILE;
  75       if ( isDir() )
  76         return FT_DIR;
  77       if ( isLink() )
  78         return FT_LINK;
  79       if ( isChr() )
  80         return FT_CHARDEV;
  81       if ( isBlk() )
  82         return FT_BLOCKDEV;
  83       if ( isFifo() )
  84         return FT_FIFO;
  85       if ( isSock() )
  86         return FT_SOCKET ;
  87
  88       return FT_NOT_AVAIL;
  89     }
  90
  91     /******************************************************************
  92      **
  93      ** FUNCTION NAME : operator<<
  94      ** FUNCTION TYPE : std::ostream &
  95     */
  96     std::ostream & operator<<( std::ostream & str, const StatMode & obj )
  97     {
  98       iostr::IosFmtFlagsSaver autoResoreState( str );
  99
 100       char t = '?';
 101       if ( obj.isFile() )
 102         t = '-';
 103       else if ( obj.isDir() )
 104         t = 'd';
 105       else if ( obj.isLink() )
 106         t = 'l';
 107       else if ( obj.isChr() )
 108         t = 'c';
 109       else if ( obj.isBlk() )
 110         t = 'b';
 111       else if ( obj.isFifo() )
 112         t = 'p';
 113       else if ( obj.isSock() )
 114         t = 's';
 115
 116       str << t << " " << std::setfill( '0' ) << std::setw( 4 ) << std::oct << obj.perm();
 117       return str;
 118     }
 119
 120     ///////////////////////////////////////////////////////////////////
 121     //
 122     //  Class : PathInfo
 123     //
 124     ///////////////////////////////////////////////////////////////////
 125
 126     ///////////////////////////////////////////////////////////////////
 127     //
 128     //  METHOD NAME : PathInfo::PathInfo
 129     //  METHOD TYPE : Constructor
 130     //
 131     PathInfo::PathInfo()
 132     : mode_e( STAT )
 133     , error_i( -1 )
 134     {}
 135
 136     ///////////////////////////////////////////////////////////////////
 137     //
 138     //  METHOD NAME : PathInfo::PathInfo
 139     //  METHOD TYPE : Constructor
 140     //
 141     PathInfo::PathInfo( const Pathname & path, Mode initial )
 142     : path_t( path )
 143     , mode_e( initial )
 144     , error_i( -1 )
 145     {
 146       operator()();
 147     }
 148
 149     ///////////////////////////////////////////////////////////////////
 150     //
 151     //  METHOD NAME : PathInfo::PathInfo
 152     //  METHOD TYPE : Constructor
 153     //
 154     PathInfo::PathInfo( const std::string & path, Mode initial )
 155     : path_t( path )
 156     , mode_e( initial )
 157     , error_i( -1 )
 158     {
 159       operator()();
 160     }
 161
 162     ///////////////////////////////////////////////////////////////////
 163     //
 164     //  METHOD NAME : PathInfo::PathInfo
 165     //  METHOD TYPE : Constructor
 166     //
 167     PathInfo::PathInfo( const char * path, Mode initial )
 168     : path_t( path )
 169     , mode_e( initial )
 170     , error_i( -1 )
 171     {
 172       operator()();
 173     }
 174
 175     ///////////////////////////////////////////////////////////////////
 176     //
 177     //  METHOD NAME : PathInfo::~PathInfo
 178     //  METHOD TYPE : Destructor
 179     //
 180     PathInfo::~PathInfo()
 181     {
 182     }
 183
 184     ///////////////////////////////////////////////////////////////////
 185     //
 186     //  METHOD NAME : PathInfo::operator()
 187     //  METHOD TYPE : bool
 188     //
 189     bool PathInfo::operator()()
 190     {
 191       if ( path_t.empty() ) {
 192         error_i = -1;
 193       } else {
 194         switch ( mode_e ) {
 195         case STAT:
 196           error_i = ::stat( path_t.asString().c_str(), &statbuf_C );
 197           break;
 198         case LSTAT:
 199           error_i = ::lstat( path_t.asString().c_str(), &statbuf_C );
 200           break;
 201         }
 202         if ( error_i == -1 )
 203           error_i = errno;
 204       }
 205       return !error_i;
 206     }
 207
 208     ///////////////////////////////////////////////////////////////////
 209     //
 210     //  METHOD NAME : PathInfo::fileType
 211     //  METHOD TYPE : File_type
 212     //
 213     FileType PathInfo::fileType() const
 214     {
 215       if ( isExist() )
 216         return asStatMode().fileType();
 217       return FT_NOT_EXIST;
 218     }
 219
 220     ///////////////////////////////////////////////////////////////////
 221     //
 222     //  METHOD NAME : PathInfo::userMay
 223     //  METHOD TYPE : mode_t
 224     //
 225     mode_t PathInfo::userMay() const
 226     {
 227       if ( !isExist() )
 228         return 0;
 229       if ( owner() == geteuid() ) {
 230         return( uperm()/0100 );
 231       } else if ( group() == getegid() ) {
 232         return( gperm()/010 );
 233       }
 234       return operm();
 235     }
 236
 237     /******************************************************************
 238      **
 239      ** FUNCTION NAME : PathInfo::devMajor
 240      ** FUNCTION TYPE : unsigned int
 241      */
 242     unsigned int PathInfo::devMajor() const
 243     {
 244       return isBlk() || isChr() ? major(statbuf_C.st_rdev) : 0;
 245     }
 246
 247     /******************************************************************
 248      **
 249      ** FUNCTION NAME : PathInfo::devMinor
 250      ** FUNCTION TYPE : unsigned int
 251      */
 252     unsigned int PathInfo::devMinor() const
 253     {
 254       return isBlk() || isChr() ? minor(statbuf_C.st_rdev) : 0;
 255     }
 256
 257     /******************************************************************
 258      **
 259      ** FUNCTION NAME : operator<<
 260      ** FUNCTION TYPE :  std::ostream &
 261     */
 262     std::ostream & operator<<( std::ostream & str, const PathInfo & obj )
 263     {
 264       iostr::IosFmtFlagsSaver autoResoreState( str );
 265
 266       str << obj.asString() << "{";
 267       if ( !obj.isExist() ) {
 268         str << Errno( obj.error() );
 269       } else {
 270         str << obj.asStatMode() << " " << std::dec << obj.owner() << "/" << obj.group();
 271
 272         if ( obj.isFile() )
 273           str << " size " << obj.size();
 274       }
 275
 276       return str << "}";
 277     }
 278
 279     ///////////////////////////////////////////////////////////////////
 280     //
 281     //  filesystem utilities
 282     //
 283     ///////////////////////////////////////////////////////////////////
 284
 285 #define logResult MIL << endl, doLogResult
 286     namespace {
 287       /**  Helper function to log return values. */
 288       inline int doLogResult( const int res, const char * rclass = 0 /*errno*/ )
 289       {
 290         if ( res )
 291         {
 292           if ( rclass )
 293             WAR << " FAILED: " << rclass << " " << res << endl;
 294           else
 295             WAR << " FAILED: " << str::strerror( res ) << endl;
 296         }
 297         return res;
 298       }
 299     } // namespace
 300
 301     ///////////////////////////////////////////////////////////////////
 302     //
 303     //  METHOD NAME : PathInfo::mkdir
 304     //  METHOD TYPE : int
 305     //
 306     int mkdir( const Pathname & path, unsigned mode )
 307     {
 308       MIL << "mkdir " << path << ' ' << str::octstring( mode );
 309       if ( ::mkdir( path.asString().c_str(), mode ) == -1 ) {
 310         return logResult( errno );
 311       }
 312       return logResult( 0 );
 313     }
 314
 315     ///////////////////////////////////////////////////////////////////
 316     //
 317     //  METHOD NAME : assert_dir()
 318     //  METHOD TYPE : int
 319     //
 320     int assert_dir( const Pathname & path, unsigned mode )
 321     {
 322       if ( path.empty() )
 323         return ENOENT;
 324
 325       { // Handle existing paths in advance.
 326         PathInfo pi( path );
 327         if ( pi.isDir() )
 328           return 0;
 329         if ( pi.isExist() )
 330           return EEXIST;
 331       }
 332
 333       string spath = path.asString()+"/";
 334       std::string::size_type lastpos = ( path.relative() ? 2 : 1 ); // skip leasding './' or '/'
 335       std::string::size_type pos = std::string::npos;
 336       int ret = 0;
 337
 338       while ( (pos = spath.find('/',lastpos)) != std::string::npos )
 339       {
 340         string dir( spath.substr(0,pos) );
 341         ret = ::mkdir( dir.c_str(), mode );
 342         if ( ret == -1 )
 343         {
 344           if ( errno == EEXIST ) // ignore errors about already existing paths
 345             ret = 0;
 346           else
 347           {
 348             ret = errno;
 349             WAR << " FAILED: mkdir " << dir << ' ' << str::octstring( mode ) << " errno " << ret << endl;
 350           }
 351         }
 352         else
 353         {
 354           MIL << "mkdir " << dir << ' ' << str::octstring( mode ) << endl;
 355         }
 356         lastpos = pos+1;
 357       }
 358
 359       return ret;
 360     }
 361
 362     ///////////////////////////////////////////////////////////////////
 363     //
 364     //  METHOD NAME : rmdir
 365     //  METHOD TYPE : int
 366     //
 367     int rmdir( const Pathname & path )
 368     {
 369       MIL << "rmdir " << path;
 370       if ( ::rmdir( path.asString().c_str() ) == -1 ) {
 371         return logResult( errno );
 372       }
 373       return logResult( 0 );
 374     }
 375
 376     ///////////////////////////////////////////////////////////////////
 377     //
 378     //  METHOD NAME : recursive_rmdir
 379     //  METHOD TYPE : int
 380     //
 381     static int recursive_rmdir_1( const Pathname & dir, bool removeDir = true )
 382     {
 383       DIR * dp;
 384       struct dirent * d;
 385
 386       if ( ! (dp = opendir( dir.c_str() )) )
 387         return logResult( errno );
 388
 389       while ( (d = readdir(dp)) )
 390       {
 391         std::string direntry = d->d_name;
 392         if ( direntry == "." || direntry == ".." )
 393           continue;
 394         Pathname new_path( dir / d->d_name );
 395
 396         struct stat st;
 397         if ( ! lstat( new_path.c_str(), &st ) )
 398         {
 399           if ( S_ISDIR( st.st_mode ) )
 400             recursive_rmdir_1( new_path );
 401           else
 402             ::unlink( new_path.c_str() );
 403         }
 404       }
 405       closedir( dp );
 406
 407       if ( removeDir && ::rmdir( dir.c_str() ) < 0 )
 408         return errno;
 409
 410       return 0;
 411     }
 412     ///////////////////////////////////////////////////////////////////
 413     int recursive_rmdir( const Pathname & path )
 414     {
 415       MIL << "recursive_rmdir " << path << ' ';
 416       PathInfo p( path );
 417
 418       if ( !p.isExist() ) {
 419         return logResult( 0 );
 420       }
 421
 422       if ( !p.isDir() ) {
 423         return logResult( ENOTDIR );
 424       }
 425
 426       return logResult( recursive_rmdir_1( path ) );
 427     }
 428
 429     ///////////////////////////////////////////////////////////////////
 430     //
 431     //  METHOD NAME : clean_dir
 432     //  METHOD TYPE : int
 433     //
 434     int clean_dir( const Pathname & path )
 435     {
 436       MIL << "clean_dir " << path << ' ';
 437       PathInfo p( path );
 438
 439       if ( !p.isExist() ) {
 440         return logResult( 0 );
 441       }
 442
 443       if ( !p.isDir() ) {
 444         return logResult( ENOTDIR );
 445       }
 446
 447       return logResult( recursive_rmdir_1( path, false/* don't remove path itself */ ) );
 448     }
 449
 450     ///////////////////////////////////////////////////////////////////
 451     //
 452     //  METHOD NAME : copy_dir
 453     //  METHOD TYPE : int
 454     //
 455     int copy_dir( const Pathname & srcpath, const Pathname & destpath )
 456     {
 457       MIL << "copy_dir " << srcpath << " -> " << destpath << ' ';
 458
 459       PathInfo sp( srcpath );
 460       if ( !sp.isDir() ) {
 461         return logResult( ENOTDIR );
 462       }
 463
 464       PathInfo dp( destpath );
 465       if ( !dp.isDir() ) {
 466         return logResult( ENOTDIR );
 467       }
 468
 469       PathInfo tp( destpath + srcpath.basename() );
 470       if ( tp.isExist() ) {
 471         return logResult( EEXIST );
 472       }
 473
 474
 475       const char *const argv[] = {
 476         "/bin/cp",
 477         "-dR",
 478         "--",
 479         srcpath.asString().c_str(),
 480         destpath.asString().c_str(),
 481         NULL
 482       };
 483       ExternalProgram prog( argv, ExternalProgram::Stderr_To_Stdout );
 484       for ( string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 485         MIL << "  " << output;
 486       }
 487       int ret = prog.close();
 488       return logResult( ret, "returned" );
 489     }
 490
 491     ///////////////////////////////////////////////////////////////////
 492     //
 493     //  METHOD NAME : copy_dir_content
 494     //  METHOD TYPE : int
 495     //
 496     int copy_dir_content(const Pathname & srcpath, const Pathname & destpath)
 497     {
 498       MIL << "copy_dir " << srcpath << " -> " << destpath << ' ';
 499
 500       PathInfo sp( srcpath );
 501       if ( !sp.isDir() ) {
 502         return logResult( ENOTDIR );
 503       }
 504
 505       PathInfo dp( destpath );
 506       if ( !dp.isDir() ) {
 507         return logResult( ENOTDIR );
 508       }
 509
 510       if ( srcpath == destpath ) {
 511         return logResult( EEXIST );
 512       }
 513
 514       std::string src( srcpath.asString());
 515       src += "/.";
 516       const char *const argv[] = {
 517         "/bin/cp",
 518         "-dR",
 519         "--",
 520         src.c_str(),
 521         destpath.asString().c_str(),
 522         NULL
 523       };
 524       ExternalProgram prog( argv, ExternalProgram::Stderr_To_Stdout );
 525       for ( string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 526         MIL << "  " << output;
 527       }
 528       int ret = prog.close();
 529       return logResult( ret, "returned" );
 530     }
 531
 532     ///////////////////////////////////////////////////////////////////////
 533     // dirForEach
 534     ///////////////////////////////////////////////////////////////////////
 535
 536     const StrMatcher & matchNoDots()
 537     {
 538       static StrMatcher noDots( "[^.]*", Match::GLOB );
 539       return noDots;
 540     }
 541
 542     int dirForEach( const Pathname & dir_r, function<bool(const Pathname &, const char *const)> fnc_r )
 543     {
 544       if ( ! fnc_r )
 545         return 0;
 546
 547       AutoDispose<DIR *> dir( ::opendir( dir_r.c_str() ),
 548                               []( DIR * dir_r ) { if ( dir_r ) ::closedir( dir_r ); } );
 549
 550       MIL << "readdir " << dir_r << ' ';
 551       if ( ! dir )
 552         return logResult( errno );
 553       MIL << endl; // close line before callbacks are invoked.
 554
 555       int ret = 0;
 556       for ( struct dirent * entry = ::readdir( dir ); entry; entry = ::readdir( dir ) )
 557       {
 558         if ( entry->d_name[0] == '.' && ( entry->d_name[1] == '\0' || ( entry->d_name[1] == '.' && entry->d_name[2] == '\0' ) ) )
 559           continue; // omitt . and ..
 560
 561         if ( ! fnc_r( dir_r, entry->d_name ) )
 562         {
 563           ret = -1;
 564           break;
 565         }
 566       }
 567       return ret;
 568     }
 569
 570     int dirForEach( const Pathname & dir_r, const StrMatcher & matcher_r, function<bool( const Pathname &, const char *const)> fnc_r )
 571     {
 572       if ( ! fnc_r )
 573         return 0;
 574
 575       bool nodots = ( &matcher_r == &matchNoDots() );
 576       return dirForEach( dir_r,
 577                          [&]( const Pathname & dir_r, const char *const name_r )->bool
 578                          {
 579                            if ( ( nodots && name_r[0] == '.' ) || ! matcher_r( name_r ) )
 580                              return true;
 581                            return fnc_r( dir_r, name_r );
 582                          } );
 583     }
 584
 585     ///////////////////////////////////////////////////////////////////
 586     // readdir
 587     ///////////////////////////////////////////////////////////////////
 588
 589     int readdir( std::list<std::string> & retlist_r, const Pathname & path_r, bool dots_r )
 590     {
 591       retlist_r.clear();
 592       return dirForEach( path_r,
 593                          [&]( const Pathname & dir_r, const char *const name_r )->bool
 594                          {
 595                            if ( dots_r || name_r[0] != '.' )
 596                              retlist_r.push_back( name_r );
 597                            return true;
 598                          } );
 599     }
 600
 601
 602     int readdir( std::list<Pathname> & retlist_r, const Pathname & path_r, bool dots_r )
 603     {
 604       retlist_r.clear();
 605       return dirForEach( path_r,
 606                          [&]( const Pathname & dir_r, const char *const name_r )->bool
 607                          {
 608                            if ( dots_r || name_r[0] != '.' )
 609                              retlist_r.push_back( dir_r/name_r );
 610                            return true;
 611                          } );
 612     }
 613
 614     bool DirEntry::operator==( const DirEntry &rhs ) const
 615     {
 616       // if one of the types is not known, use the name only
 617       if ( type == FT_NOT_AVAIL || rhs.type == FT_NOT_AVAIL )
 618         return ( name == rhs.name );
 619       return ((name == rhs.name ) && (type == rhs.type));
 620     }
 621
 622     int readdir( DirContent & retlist_r, const Pathname & path_r, bool dots_r, PathInfo::Mode statmode_r )
 623     {
 624       retlist_r.clear();
 625       return dirForEach( path_r,
 626                          [&]( const Pathname & dir_r, const char *const name_r )->bool
 627                          {
 628                            if ( dots_r || name_r[0] != '.' )
 629                              retlist_r.push_back( DirEntry( name_r, PathInfo( dir_r/name_r, statmode_r ).fileType() ) );
 630                            return true;
 631                          } );
 632     }
 633
 634     std::ostream & operator<<( std::ostream & str, const DirContent & obj )
 635     { return dumpRange( str, obj.begin(), obj.end() ); }
 636
 637     ///////////////////////////////////////////////////////////////////
 638     // is_empty_dir
 639     ///////////////////////////////////////////////////////////////////
 640
 641     int is_empty_dir( const Pathname & path_r )
 642     {
 643       return dirForEach( path_r,
 644                          [&]( const Pathname & dir_r, const char *const name_r )->bool
 645                          { return false; } );
 646     }
 647
 648     ///////////////////////////////////////////////////////////////////
 649     //
 650     //  METHOD NAME : unlink
 651     //  METHOD TYPE : int
 652     //
 653     int unlink( const Pathname & path )
 654     {
 655       MIL << "unlink " << path;
 656       if ( ::unlink( path.asString().c_str() ) == -1 ) {
 657         return logResult( errno );
 658       }
 659       return logResult( 0 );
 660     }
 661
 662     ///////////////////////////////////////////////////////////////////
 663     namespace
 664     {
 665       int safe_rename( const Pathname & oldpath, const Pathname & newpath )
 666       {
 667         int ret = ::rename( oldpath.asString().c_str(), newpath.asString().c_str() );
 668
 669         // rename(2) can fail on OverlayFS. Fallback to using mv(1), which is
 670         // explicitly mentioned in the kernel docs to deal correctly with OverlayFS.
 671         if ( ret == -1 && errno == EXDEV ) {
 672           const char *const argv[] = {
 673             "/usr/bin/mv",
 674             oldpath.asString().c_str(),
 675             newpath.asString().c_str(),
 676             NULL
 677           };
 678           ExternalProgram prog( argv, ExternalProgram::Stderr_To_Stdout );
 679           for ( string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 680             MIL << "  " << output;
 681           }
 682           ret = prog.close();
 683         }
 684
 685         return ret;
 686       }
 687     } // namespace
 688     ///////////////////////////////////////////////////////////////////
 689
 690     ///////////////////////////////////////////////////////////////////
 691     //
 692     //  METHOD NAME : rename
 693     //  METHOD TYPE : int
 694     //
 695     int rename( const Pathname & oldpath, const Pathname & newpath )
 696     {
 697       MIL << "rename " << oldpath << " -> " << newpath;
 698       if ( safe_rename( oldpath.asString().c_str(), newpath.asString().c_str() ) == -1 ) {
 699         return logResult( errno );
 700       }
 701       return logResult( 0 );
 702     }
 703
 704     ///////////////////////////////////////////////////////////////////
 705     //
 706     //  METHOD NAME : exchange
 707     //  METHOD TYPE : int
 708     //
 709     int exchange( const Pathname & lpath, const Pathname & rpath )
 710     {
 711       MIL << "exchange " << lpath << " <-> " << rpath;
 712       if ( lpath.empty() || rpath.empty() )
 713         return logResult( EINVAL );
 714
 715       PathInfo linfo( lpath );
 716       PathInfo rinfo( rpath );
 717
 718       if ( ! linfo.isExist() )
 719       {
 720         if ( ! rinfo.isExist() )
 721           return logResult( 0 ); // both don't exist.
 722
 723         // just rename rpath -> lpath
 724         int ret = assert_dir( lpath.dirname() );
 725         if ( ret != 0 )
 726           return logResult( ret );
 727         if ( safe_rename( rpath.c_str(), lpath.c_str() ) == -1 ) {
 728           return logResult( errno );
 729         }
 730         return logResult( 0 );
 731       }
 732
 733       // HERE: lpath exists:
 734       if ( ! rinfo.isExist() )
 735       {
 736         // just rename lpath -> rpath
 737         int ret = assert_dir( rpath.dirname() );
 738         if ( ret != 0 )
 739           return logResult( ret );
 740         if ( safe_rename( lpath.c_str(), rpath.c_str() ) == -1 ) {
 741           return logResult( errno );
 742         }
 743         return logResult( 0 );
 744       }
 745
 746       // HERE: both exist
 747       TmpFile tmpfile( TmpFile::makeSibling( rpath ) );
 748       if ( ! tmpfile )
 749         return logResult( errno );
 750       Pathname tmp( tmpfile.path() );
 751       ::unlink( tmp.c_str() );
 752
 753       if ( safe_rename( lpath.c_str(), tmp.c_str() ) == -1 ) {
 754         return logResult( errno );
 755       }
 756       if ( safe_rename( rpath.c_str(), lpath.c_str() ) == -1 ) {
 757         safe_rename( tmp.c_str(), lpath.c_str() );
 758         return logResult( errno );
 759       }
 760       if ( safe_rename( tmp.c_str(), rpath.c_str() ) == -1 ) {
 761         safe_rename( lpath.c_str(), rpath.c_str() );
 762         safe_rename( tmp.c_str(), lpath.c_str() );
 763         return logResult( errno );
 764       }
 765       return logResult( 0 );
 766     }
 767
 768     ///////////////////////////////////////////////////////////////////
 769     //
 770     //  METHOD NAME : copy
 771     //  METHOD TYPE : int
 772     //
 773     int copy( const Pathname & file, const Pathname & dest )
 774     {
 775       MIL << "copy " << file << " -> " << dest << ' ';
 776
 777       PathInfo sp( file );
 778       if ( !sp.isFile() ) {
 779         return logResult( EINVAL );
 780       }
 781
 782       PathInfo dp( dest );
 783       if ( dp.isDir() ) {
 784         return logResult( EISDIR );
 785       }
 786
 787       const char *const argv[] = {
 788         "/bin/cp",
 789         "--remove-destination",
 790         "--",
 791         file.asString().c_str(),
 792         dest.asString().c_str(),
 793         NULL
 794       };
 795       ExternalProgram prog( argv, ExternalProgram::Stderr_To_Stdout );
 796       for ( string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 797         MIL << "  " << output;
 798       }
 799       int ret = prog.close();
 800       return logResult( ret, "returned" );
 801     }
 802
 803     ///////////////////////////////////////////////////////////////////
 804     //
 805     //  METHOD NAME : symlink
 806     //  METHOD TYPE : int
 807     //
 808     int symlink( const Pathname & oldpath, const Pathname & newpath )
 809     {
 810       MIL << "symlink " << newpath << " -> " << oldpath;
 811       if ( ::symlink( oldpath.asString().c_str(), newpath.asString().c_str() ) == -1 ) {
 812         return logResult( errno );
 813       }
 814       return logResult( 0 );
 815     }
 816
 817     ///////////////////////////////////////////////////////////////////
 818     //
 819     //  METHOD NAME : hardlink
 820     //  METHOD TYPE : int
 821     //
 822     int hardlink( const Pathname & oldpath, const Pathname & newpath )
 823     {
 824       MIL << "hardlink " << newpath << " -> " << oldpath;
 825       if ( ::link( oldpath.asString().c_str(), newpath.asString().c_str() ) == -1 ) {
 826         return logResult( errno );
 827       }
 828       return logResult( 0 );
 829     }
 830
 831     ///////////////////////////////////////////////////////////////////
 832     //
 833     //  METHOD NAME : hardlink
 834     //  METHOD TYPE : int
 835     //
 836     int hardlinkCopy( const Pathname & oldpath, const Pathname & newpath )
 837     {
 838       MIL << "hardlinkCopy " << oldpath << " -> " << newpath;
 839
 840       PathInfo pi( oldpath, PathInfo::LSTAT );
 841       if ( pi.isLink() )
 842       {
 843         // dont hardlink symlinks!
 844         MIL << " => copy" << endl;
 845         return copy( oldpath, newpath );
 846       }
 847
 848       pi.lstat( newpath );
 849       if ( pi.isExist() )
 850       {
 851         int res = unlink( newpath );
 852         if ( res != 0 )
 853           return logResult( res );
 854       }
 855
 856       // Here: no symlink, no newpath
 857       if ( ::link( oldpath.asString().c_str(), newpath.asString().c_str() ) == -1 )
 858       {
 859         switch ( errno )
 860         {
 861           case EPERM: // /proc/sys/fs/protected_hardlink in proc(5)
 862           case EXDEV: // oldpath  and  newpath are not on the same mounted file system
 863             MIL << " => copy" << endl;
 864             return copy( oldpath, newpath );
 865             break;
 866         }
 867         return logResult( errno );
 868       }
 869       return logResult( 0 );
 870     }
 871
 872     ///////////////////////////////////////////////////////////////////
 873     //
 874     //  METHOD NAME : readlink
 875     //  METHOD TYPE : int
 876     //
 877     int readlink( const Pathname & symlink_r, Pathname & target_r )
 878     {
 879       static const ssize_t bufsiz = 2047;
 880       static char buf[bufsiz+1];
 881       ssize_t ret = ::readlink( symlink_r.c_str(), buf, bufsiz );
 882       if ( ret == -1 )
 883       {
 884         target_r = Pathname();
 885         MIL << "readlink " << symlink_r;
 886         return logResult( errno );
 887       }
 888       buf[ret] = '\0';
 889       target_r = buf;
 890       return 0;
 891     }
 892
 893     ///////////////////////////////////////////////////////////////////
 894     //
 895     //  METHOD NAME : expandlink
 896     //  METHOD TYPE : Pathname
 897     //
 898     Pathname expandlink( const Pathname & path_r )
 899     {
 900       static const unsigned int level_limit = 256;
 901       static unsigned int count;
 902       Pathname path(path_r);
 903       PathInfo info(path_r, PathInfo::LSTAT);
 904
 905       for (count = level_limit; info.isLink() && count; count--)
 906       {
 907         DBG << "following symlink " << path;
 908         path = path.dirname() / readlink(path);
 909         DBG << "->" << path << std::endl;
 910         info = PathInfo(path, PathInfo::LSTAT);
 911       }
 912
 913       // expand limit reached
 914       if (count == 0)
 915       {
 916         ERR << "Expand level limit reached. Probably a cyclic symbolic link." << endl;
 917         return Pathname();
 918       }
 919       // symlink
 920       else if (count < level_limit)
 921       {
 922         // check for a broken link
 923         if (PathInfo(path).isExist())
 924           return path;
 925         // broken link, return an empty path
 926         else
 927         {
 928           ERR << path << " is broken (expanded from " << path_r << ")" << endl;
 929           return Pathname();
 930         }
 931       }
 932
 933       // not a symlink, return the original pathname
 934       DBG << "not a symlink" << endl;
 935       return path;
 936     }
 937
 938     ///////////////////////////////////////////////////////////////////
 939     //
 940     //  METHOD NAME : copy_file2dir
 941     //  METHOD TYPE : int
 942     //
 943     int copy_file2dir( const Pathname & file, const Pathname & dest )
 944     {
 945       MIL << "copy_file2dir " << file << " -> " << dest << ' ';
 946
 947       PathInfo sp( file );
 948       if ( !sp.isFile() ) {
 949         return logResult( EINVAL );
 950       }
 951
 952       PathInfo dp( dest );
 953       if ( !dp.isDir() ) {
 954         return logResult( ENOTDIR );
 955       }
 956
 957       const char *const argv[] = {
 958         "/bin/cp",
 959         "--",
 960         file.asString().c_str(),
 961         dest.asString().c_str(),
 962         NULL
 963       };
 964       ExternalProgram prog( argv, ExternalProgram::Stderr_To_Stdout );
 965       for ( string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() ) {
 966         MIL << "  " << output;
 967       }
 968       int ret = prog.close();
 969       return logResult( ret, "returned" );
 970     }
 971
 972     ///////////////////////////////////////////////////////////////////
 973     //
 974     //  METHOD NAME : md5sum
 975     //  METHOD TYPE : std::string
 976     //
 977     std::string md5sum( const Pathname & file )
 978     {
 979       if ( ! PathInfo( file ).isFile() ) {
 980         return string();
 981       }
 982       std::ifstream istr( file.asString().c_str() );
 983       if ( ! istr ) {
 984         return string();
 985       }
 986       return Digest::digest( "MD5", istr );
 987     }
 988
 989     ///////////////////////////////////////////////////////////////////
 990     //
 991     //  METHOD NAME : sha1sum
 992     //  METHOD TYPE : std::string
 993     //
 994     std::string sha1sum( const Pathname & file )
 995     {
 996       return checksum(file, "SHA1");
 997     }
 998
 999     ///////////////////////////////////////////////////////////////////
1000     //
1001     //  METHOD NAME : checksum
1002     //  METHOD TYPE : std::string
1003     //
1004     std::string checksum( const Pathname & file, const std::string &algorithm )
1005     {
1006       if ( ! PathInfo( file ).isFile() ) {
1007         return string();
1008       }
1009       std::ifstream istr( file.asString().c_str() );
1010       if ( ! istr ) {
1011         return string();
1012       }
1013       return Digest::digest( algorithm, istr );
1014     }
1015
1016     bool is_checksum( const Pathname & file, const CheckSum &checksum )
1017     {
1018       return ( filesystem::checksum(file,  checksum.type()) == checksum.checksum() );
1019     }
1020
1021     ///////////////////////////////////////////////////////////////////
1022     //
1023     //  METHOD NAME : erase
1024     //  METHOD TYPE : int
1025     //
1026     int erase( const Pathname & path )
1027     {
1028       int res = 0;
1029       PathInfo p( path, PathInfo::LSTAT );
1030       if ( p.isExist() )
1031         {
1032           if ( p.isDir() )
1033             res = recursive_rmdir( path );
1034           else
1035             res = unlink( path );
1036         }
1037       return res;
1038     }
1039
1040     ///////////////////////////////////////////////////////////////////
1041     //
1042     //  METHOD NAME : chmod
1043     //  METHOD TYPE : int
1044     //
1045     int chmod( const Pathname & path, mode_t mode )
1046     {
1047       MIL << "chmod " << path << ' ' << str::octstring( mode );
1048       if ( ::chmod( path.asString().c_str(), mode ) == -1 ) {
1049         return logResult( errno );
1050       }
1051       return logResult( 0 );
1052     }
1053
1054     int addmod( const Pathname & path, mode_t mode )
1055     {
1056       mode_t omode( PathInfo( path ).st_mode() );
1057       mode_t tmode( omode | mode );
1058       if ( omode != mode )
1059         return chmod( path, tmode );
1060       return 0;
1061     }
1062
1063     int delmod( const Pathname & path, mode_t mode )
1064     {
1065       mode_t omode( PathInfo( path ).st_mode() );
1066       mode_t tmode( omode & ~mode );
1067       if ( omode != mode )
1068         return chmod( path, tmode );
1069       return 0;
1070     }
1071
1072    //////////////////////////////////////////////////////////////////
1073     //
1074     //  METHOD NAME : zipType
1075     //  METHOD TYPE : ZIP_TYPE
1076     //
1077     ZIP_TYPE zipType( const Pathname & file )
1078     {
1079       ZIP_TYPE ret = ZT_NONE;
1080
1081       int fd = open( file.asString().c_str(), O_RDONLY|O_CLOEXEC );
1082
1083       if ( fd != -1 ) {
1084         const int magicSize = 5;
1085         unsigned char magic[magicSize];
1086         memset( magic, 0, magicSize );
1087         if ( read( fd, magic, magicSize ) == magicSize ) {
1088           if ( magic[0] == 0037 && magic[1] == 0213 ) {
1089             ret = ZT_GZ;
1090           } else if ( magic[0] == 'B' && magic[1] == 'Z' && magic[2] == 'h' ) {
1091             ret = ZT_BZ2;
1092           } else if ( magic[0] == '\0' && magic[1] == 'Z' && magic[2] == 'C' && magic[3] == 'K' && magic[4] == '1') {
1093             ret = ZT_ZCHNK;
1094
1095           }
1096         }
1097         close( fd );
1098       }
1099
1100       return ret;
1101     }
1102
1103     ///////////////////////////////////////////////////////////////////
1104     //
1105     //  METHOD NAME : df
1106     //  METHOD TYPE : ByteCount
1107     //
1108     ByteCount df( const Pathname & path_r )
1109     {
1110       ByteCount ret( -1 );
1111       struct statvfs sb;
1112       if ( statvfs( path_r.c_str(), &sb ) == 0 )
1113         {
1114           ret = sb.f_bfree * sb.f_bsize;
1115         }
1116       return ret;
1117     }
1118
1119     ///////////////////////////////////////////////////////////////////
1120     //
1121     //  METHOD NAME : getUmask
1122     //  METHOD TYPE : mode_t
1123     //
1124     mode_t getUmask()
1125     {
1126       mode_t mask = ::umask( 0022 );
1127       ::umask( mask );
1128       return mask;
1129     }
1130
1131     ///////////////////////////////////////////////////////////////////
1132     //
1133     //  METHOD NAME : getUmask
1134     //  METHOD TYPE : mode_t
1135     //
1136     int assert_file( const Pathname & path, unsigned mode )
1137     {
1138       int ret = assert_dir( path.dirname() );
1139       MIL << "assert_file " << str::octstring( mode ) << " " << path;
1140       if ( ret != 0 )
1141         return logResult( ret );
1142
1143       PathInfo pi( path );
1144       if ( pi.isExist() )
1145         return logResult( pi.isFile() ? 0 : EEXIST );
1146
1147       int fd = ::creat( path.c_str(), mode );
1148       if ( fd == -1 )
1149         return logResult( errno );
1150
1151       ::close( fd );
1152       return logResult( 0 );
1153     }
1154
1155     int assert_file_mode( const Pathname & path, unsigned mode )
1156     {
1157       int ret = assert_dir( path.dirname() );
1158       MIL << "assert_file_mode " << str::octstring( mode ) << " " << path;
1159       if ( ret != 0 )
1160         return logResult( ret );
1161
1162       PathInfo pi( path );
1163       if ( pi.isExist() )
1164       {
1165         if ( ! pi.isFile() )
1166           return logResult( EEXIST );
1167
1168         mode = applyUmaskTo( mode );
1169         if ( pi.st_mode() != mode )
1170           return chmod( path, mode );
1171
1172         return logResult( 0 );
1173       }
1174
1175       int fd = ::creat( path.c_str(), mode );
1176       if ( fd == -1 )
1177         return logResult( errno );
1178       ::close( fd );
1179       return logResult( 0 );
1180     }
1181
1182     ///////////////////////////////////////////////////////////////////
1183     //
1184     //  METHOD NAME : touch
1185     //  METHOD TYPE : int
1186     //
1187     int touch (const Pathname & path)
1188     {
1189       MIL << "touch " << path;
1190       struct ::utimbuf times;
1191       times.actime = ::time( 0 );
1192       times.modtime = ::time( 0 );
1193       if ( ::utime( path.asString().c_str(), &times ) == -1 ) {
1194         return logResult( errno );
1195       }
1196       return logResult( 0 );
1197     }
1198
1199     /////////////////////////////////////////////////////////////////
1200   } // namespace filesystem
1201   ///////////////////////////////////////////////////////////////////
1202   /////////////////////////////////////////////////////////////////
1203 } // namespace zypp
1204 ///////////////////////////////////////////////////////////////////