TmpPath.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <cstdlib>
#include <cstring>
#include <cerrno>
 
#include <iostream>
 
#include <zypp-core/base/ReferenceCounted.h>
#include <zypp-core/base/NonCopyable.h>
#include <zypp-core/base/Logger.h>
#include <zypp-core/fs/PathInfo.h>
#include <zypp-core/fs/TmpPath.h>
 
using std::endl;
 
namespace zypp {
  namespace filesystem {
 
    //
    //  CLASS NAME : TmpPath::Impl
    class TmpPath::Impl : public base::ReferenceCounted, private base::NonCopyable
    {
      public:
 
        enum Flags
          {
            NoOp         = 0,
            Autodelete   = 1L << 0,
            KeepTopdir   = 1L << 1,
            //
            CtorDefault  = Autodelete
          };
 
      public:
 
        Impl( const Pathname & path_r, Flags flags_r = CtorDefault )
        : _path( path_r ), _flags( flags_r )
        {}
 
        ~Impl()
        {
          if ( ! (_flags & Autodelete) || _path.empty() )
            return;
 
          PathInfo p( _path, PathInfo::LSTAT );
          if ( ! p.isExist() )
            return;
 
          int res = 0;
          if ( p.isDir() )
            {
              if ( _flags & KeepTopdir )
                res = clean_dir( _path );
              else
                res = recursive_rmdir( _path );
            }
          else
            res = unlink( _path );
 
          if ( res )
            INT << "TmpPath cleanup error (" << res << ") " << p << endl;
          else
            DBG << "TmpPath cleaned up " << p << endl;
        }
 
        const Pathname &
        path() const
        { return _path; }
 
        bool autoCleanup() const
        { return( _flags & Autodelete ); }
 
        void autoCleanup( bool yesno_r )
        { _flags = yesno_r ? CtorDefault : NoOp; }
 
      private:
        Pathname _path;
        Flags    _flags;
    };
 
    //
    //  CLASS NAME : TmpPath
    //
 
    //
    //  METHOD NAME : TmpPath::TmpPath
    //  METHOD TYPE : Constructor
    //
    TmpPath::TmpPath()
    {}
 
    //
    //  METHOD NAME : TmpPath::TmpPath
    //  METHOD TYPE : Constructor
    //
    TmpPath::TmpPath( const Pathname & tmpPath_r )
    :_impl( tmpPath_r.empty() ? nullptr : new Impl( tmpPath_r ) )
    {}
 
    //
    //  METHOD NAME : TmpPath::~TmpPath
    //  METHOD TYPE : Destructor
    //
    TmpPath::~TmpPath()
    {
      // virtual not inlined dtor.
    }
 
    //
    //      METHOD NAME : TmpPath::operator const void *
    //      METHOD TYPE :
    //
    TmpPath::operator bool() const
    {
      return _impl.get();
    }
 
    //
    //  METHOD NAME : TmpPath::path
    //  METHOD TYPE : Pathname
    //
    Pathname
    TmpPath::path() const
    {
      return _impl.get() ? _impl->path() : Pathname();
    }
 
    //
    //  METHOD NAME : TmpPath::defaultLocation
    //  METHOD TYPE : const Pathname &
    //
    const Pathname &
    TmpPath::defaultLocation()
    {
      static Pathname p( getenv("ZYPPTMPDIR") ? getenv("ZYPPTMPDIR") : "/var/tmp" );
      return p;
    }
 
    bool TmpPath::autoCleanup() const
    { return _impl.get() ? _impl->autoCleanup() : false; }
 
    void TmpPath::autoCleanup( bool yesno_r )
    { if ( _impl.get() ) _impl->autoCleanup( yesno_r ); }
 
    //
    //  CLASS NAME : TmpFile
    //
 
 
    //
    //  METHOD NAME : TmpFile::TmpFile
    //  METHOD TYPE : Constructor
    //
    TmpFile::TmpFile( const Pathname & inParentDir_r,
                      const std::string & prefix_r )
    {
      // parent dir must exist
      if ( filesystem::assert_dir( inParentDir_r ) != 0 )
      {
        ERR << "Parent directory '" << inParentDir_r << "' can't be created." << endl;
        return;
      }
 
      // create the temp file
      Pathname tmpPath = (inParentDir_r + prefix_r).extend( "XXXXXX");
      char * buf = ::strdup( tmpPath.asString().c_str() );
      if ( ! buf )
        {
          ERR << "Out of memory" << endl;
          return;
        }
 
      int tmpFd = ::mkostemp( buf, O_CLOEXEC );
      if ( tmpFd != -1 )
        {
          // success; create _impl
          ::close( tmpFd );
          _impl = RW_pointer<Impl>( new Impl( buf ) );
        }
      else
        ERR << "Cant create '" << buf << "' " << ::strerror( errno ) << endl;
 
      ::free( buf );
    }
 
    //
    //  METHOD NAME : TmpFile::makeSibling
    //  METHOD TYPE : TmpFile
    //
    TmpFile TmpFile::makeSibling( const Pathname & sibling_r )
    {
      TmpFile ret( sibling_r.dirname(), sibling_r.basename() );
      // clone mode if sibling_r exists
      PathInfo p( sibling_r );
      if ( p.isFile() )
      {
        ::chmod( ret.path().c_str(), p.st_mode() );
      }
      return ret;
    }
 
    ManagedFile TmpFile::asManagedFile()
    {
      filesystem::TmpFile tmpFile;
      ManagedFile mFile ( tmpFile.path(), filesystem::unlink );
      tmpFile.autoCleanup(false); //cleaned up by ManagedFile
      return mFile;
    }
 
    //
    //  METHOD NAME : TmpFile::defaultPrefix
    //  METHOD TYPE : const std::string &
    //
    const std::string &
    TmpFile::defaultPrefix()
    {
      static std::string p( "TmpFile." );
      return p;
    }
 
    //
    //  CLASS NAME : TmpDir
    //
 
    //
    //  METHOD NAME : TmpDir::TmpDir
    //  METHOD TYPE : Constructor
    //
    TmpDir::TmpDir( const Pathname & inParentDir_r,
                    const std::string & prefix_r )
    {
      // parent dir must exist
      if ( filesystem::assert_dir( inParentDir_r ) != 0  )
      {
        ERR << "Parent directory '" << inParentDir_r << "' can't be created." << endl;
        return;
      }
 
      // create the temp dir
      Pathname tmpPath = (inParentDir_r + prefix_r).extend( "XXXXXX");
      char * buf = ::strdup( tmpPath.asString().c_str() );
      if ( ! buf )
        {
          ERR << "Out of memory" << endl;
          return;
        }
 
      char * tmp = ::mkdtemp( buf );
      if ( tmp )
        // success; create _impl
        _impl = RW_pointer<Impl>( new Impl( tmp ) );
      else
        ERR << "Cant create '" << tmpPath << "' " << ::strerror( errno ) << endl;
 
      ::free( buf );
    }
 
    //
    //  METHOD NAME : TmpDir::makeSibling
    //  METHOD TYPE : TmpDir
    //
    TmpDir TmpDir::makeSibling( const Pathname & sibling_r )
    {
      TmpDir ret( sibling_r.dirname(), sibling_r.basename() );
      // clone mode if sibling_r exists
      PathInfo p( sibling_r );
      if ( p.isDir() )
      {
        ::chmod( ret.path().c_str(), p.st_mode() );
      }
      return ret;
    }
 
    //
    //  METHOD NAME : TmpDir::defaultPrefix
    //  METHOD TYPE : const std::string &
    //
    const std::string &
    TmpDir::defaultPrefix()
    {
      static std::string p( "TmpDir." );
      return p;
    }
 
  } // namespace filesystem
} // namespace zypp