+++ /dev/null
-/*---------------------------------------------------------------------\
-| ____ _ __ __ ___ |
-| |__ / \ / / . \ . \ |
-| / / \ V /| _/ _/ |
-| / /__ | | | | | | |
-| /_____||_| |_| |_| |
-| |
-\---------------------------------------------------------------------*/
-/** \file zypp/media/MediaHandler.cc
- *
-*/
-
-#include <iostream>
-#include <fstream>
-#include <sstream>
-
-#include "zypp/TmpPath.h"
-#include "zypp/base/Logger.h"
-#include "zypp/base/String.h"
-#include "zypp/media/MediaHandler.h"
-#include "zypp/media/MediaManager.h"
-#include "zypp/media/Mount.h"
-#include <limits.h>
-#include <stdlib.h>
-#include <errno.h>
-
-
-using namespace std;
-
-// use directory.yast on every media (not just via ftp/http)
-#define NONREMOTE_DIRECTORY_YAST 1
-
-namespace zypp {
- namespace media {
-
- Pathname MediaHandler::_attachPrefix("");
-
-///////////////////////////////////////////////////////////////////
-//
-// CLASS NAME : MediaHandler
-//
-///////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::MediaHandler
-// METHOD TYPE : Constructor
-//
-// DESCRIPTION :
-//
-MediaHandler::MediaHandler ( const Url & url_r,
- const Pathname & attach_point_r,
- const Pathname & urlpath_below_attachpoint_r,
- const bool does_download_r )
- : _mediaSource()
- , _attachPoint( new AttachPoint())
- , _AttachPointHint()
- , _relativeRoot( urlpath_below_attachpoint_r)
- , _does_download( does_download_r )
- , _attach_mtime(0)
- , _url( url_r )
- , _parentId(0)
-{
- Pathname real_attach_point( getRealPath(attach_point_r.asString()));
-
- if ( !real_attach_point.empty() ) {
- ///////////////////////////////////////////////////////////////////
- // check if provided attachpoint is usable.
- ///////////////////////////////////////////////////////////////////
-
- PathInfo adir( real_attach_point );
- //
- // The verify if attach_point_r isn't a mountpoint of another
- // device is done in the particular media handler (if needed).
- //
- // We just verify, if attach_point_r is a directory and for
- // schemes other than "file" and "dir", if it is absolute.
- //
- if ( !adir.isDir()
- || (_url.getScheme() != "file"
- && _url.getScheme() != "dir"
- && !real_attach_point.absolute()) )
- {
- ERR << "Provided attach point is not a absolute directory: "
- << adir << endl;
- }
- else {
- attachPointHint( real_attach_point, false);
- setAttachPoint( real_attach_point, false);
- }
- }
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::~MediaHandler
-// METHOD TYPE : Destructor
-//
-// DESCRIPTION :
-//
-MediaHandler::~MediaHandler()
-{
- try
- {
- removeAttachPoint();
- }
- catch(...) {}
-}
-
-void
-MediaHandler::resetParentId()
-{
- _parentId = 0;
-}
-
-std::string
-MediaHandler::getRealPath(const std::string &path)
-{
- std::string real;
- if( !path.empty())
- {
-#if __GNUC__ > 2
- /** GNU extension */
- char *ptr = ::realpath(path.c_str(), NULL);
- if( ptr != NULL)
- {
- real = ptr;
- free( ptr);
- }
- else
- /** the SUSv2 way */
- if( EINVAL == errno)
- {
- char buff[PATH_MAX + 2];
- memset(buff, '\0', sizeof(buff));
- if( ::realpath(path.c_str(), buff) != NULL)
- {
- real = buff;
- }
- }
-#else
- char buff[PATH_MAX + 2];
- memset(buff, '\0', sizeof(buff));
- if( ::realpath(path.c_str(), buff) != NULL)
- {
- real = buff;
- }
-#endif
- }
- return real;
-}
-
-zypp::Pathname
-MediaHandler::getRealPath(const Pathname &path)
-{
- return zypp::Pathname(getRealPath(path.asString()));
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::removeAttachPoint
-// METHOD TYPE : void
-//
-// DESCRIPTION :
-//
-void
-MediaHandler::removeAttachPoint()
-{
- if ( _mediaSource ) {
- INT << "MediaHandler deleted with media attached." << endl;
- return; // no cleanup if media still mounted!
- }
-
- DBG << "MediaHandler - checking if to remove attach point" << endl;
- if ( _attachPoint.unique() &&
- _attachPoint->temp &&
- !_attachPoint->path.empty() &&
- PathInfo(_attachPoint->path).isDir())
- {
- Pathname path(_attachPoint->path);
-
- setAttachPoint("", true);
-
- int res = recursive_rmdir( path );
- if ( res == 0 ) {
- MIL << "Deleted default attach point " << path << endl;
- } else {
- ERR << "Failed to Delete default attach point " << path
- << " errno(" << res << ")" << endl;
- }
- }
- else
- {
- if( !_attachPoint->path.empty() && !_attachPoint->temp)
- DBG << "MediaHandler - attachpoint is not temporary" << endl;
- }
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachPoint
-// METHOD TYPE : Pathname
-//
-// DESCRIPTION :
-//
-Pathname
-MediaHandler::attachPoint() const
-{
- return _attachPoint->path;
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachPoint
-// METHOD TYPE :
-//
-// DESCRIPTION :
-//
-void
-MediaHandler::setAttachPoint(const Pathname &path, bool temporary)
-{
- _attachPoint.reset( new AttachPoint(path, temporary));
-}
-
-Pathname
-MediaHandler::localRoot() const
-{
- if( _attachPoint->path.empty())
- return Pathname();
- else
- return _attachPoint->path + _relativeRoot;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachPoint
-// METHOD TYPE :
-//
-// DESCRIPTION :
-//
-void
-MediaHandler::setAttachPoint(const AttachPointRef &ref)
-{
- if( ref)
- AttachPointRef(ref).swap(_attachPoint);
- else
- _attachPoint.reset( new AttachPoint());
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachPointHint
-// METHOD TYPE : void
-//
-// DESCRIPTION :
-//
-void
-MediaHandler::attachPointHint(const Pathname &path, bool temporary)
-{
- _AttachPointHint.path = path;
- _AttachPointHint.temp = temporary;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachPointHint
-// METHOD TYPE : AttachPoint
-//
-// DESCRIPTION :
-//
-AttachPoint
-MediaHandler::attachPointHint() const
-{
- return _AttachPointHint;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::findAttachedMedia
-// METHOD TYPE : AttachedMedia
-//
-// DESCRIPTION :
-//
-AttachedMedia
-MediaHandler::findAttachedMedia(const MediaSourceRef &media) const
-{
- return MediaManager().findAttachedMedia(media);
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::setAttachPrefix
-// METHOD TYPE : void
-//
-// DESCRIPTION :
-//
-bool
-MediaHandler::setAttachPrefix(const Pathname &attach_prefix)
-{
- if( attach_prefix.empty())
- {
- MIL << "Reseting to built-in attach point prefixes."
- << std::endl;
- MediaHandler::_attachPrefix = attach_prefix;
- return true;
- }
- else
- if( MediaHandler::checkAttachPoint(attach_prefix, false, true))
- {
- MIL << "Setting user defined attach point prefix: "
- << attach_prefix << std::endl;
- MediaHandler::_attachPrefix = attach_prefix;
- return true;
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attach
-// METHOD TYPE : Pathname
-//
-// DESCRIPTION :
-//
-Pathname
-MediaHandler::createAttachPoint() const
-{
- /////////////////////////////////////////////////////////////////
- // provide a default (temporary) attachpoint
- /////////////////////////////////////////////////////////////////
- const char * defmounts[] = {
- "/var/adm/mount", filesystem::TmpPath::defaultLocation().c_str(), /**/NULL/**/
- };
-
- Pathname apoint;
- Pathname aroot( MediaHandler::_attachPrefix);
-
- if( !aroot.empty())
- {
- apoint = createAttachPoint(aroot);
- }
- for ( const char ** def = defmounts; *def && apoint.empty(); ++def ) {
- aroot = *def;
- if( aroot.empty())
- continue;
-
- apoint = createAttachPoint(aroot);
- }
-
- if ( aroot.empty() ) {
- ERR << "Create attach point: Can't find a writable directory to create an attach point" << std::endl;
- return aroot;
- }
-
- if ( !apoint.empty() ) {
- MIL << "Created default attach point " << apoint << std::endl;
- }
- return apoint;
-}
-
-Pathname
-MediaHandler::createAttachPoint(const Pathname &attach_root) const
-{
- Pathname apoint;
-
- if( attach_root.empty() || !attach_root.absolute()) {
- ERR << "Create attach point: invalid attach root: '"
- << attach_root << "'" << std::endl;
- return apoint;
- }
-
- PathInfo adir( attach_root);
- if( !adir.isDir() || (getuid() != 0 && !adir.userMayRWX())) {
- DBG << "Create attach point: attach root is not a writable directory: '"
- << attach_root << "'" << std::endl;
- return apoint;
- }
-
- DBG << "Trying to create attach point in " << attach_root << std::endl;
-
- //
- // FIXME: use mkdtemp?
- //
-#warning Use class TmpDir from TmpPath.h
- Pathname abase( attach_root + "AP_" );
- // ma and sh need more than 42 for debugging :-)
- // since the readonly fs are handled now, ...
- for ( unsigned i = 1; i < 1000; ++i ) {
- adir( Pathname::extend( abase, str::hexstring( i ) ) );
- if ( ! adir.isExist() ) {
- int err = mkdir( adir.path() );
- if (err == 0 ) {
- apoint = getRealPath(adir.asString());
- if( apoint.empty())
- {
- ERR << "Unable to resolve a real path for "
- << adir.path() << std::endl;
- rmdir(adir.path());
- }
- break;
- }
- else
- if (err != EEXIST) // readonly fs or other, dont try further
- break;
- }
- }
-
- if ( apoint.empty()) {
- ERR << "Unable to create an attach point below of "
- << attach_root << std::endl;
- }
- return apoint;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::isUseableAttachPoint
-// METHOD TYPE : bool
-//
-// DESCRIPTION :
-//
-bool
-MediaHandler::isUseableAttachPoint(const Pathname &path, bool mtab) const
-{
- MediaManager manager;
- return manager.isUseableAttachPoint(path, mtab);
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::setMediaSource
-// METHOD TYPE : void
-//
-// DESCRIPTION :
-//
-void
-MediaHandler::setMediaSource(const MediaSourceRef &ref)
-{
- _mediaSource.reset();
- if( ref && !ref->type.empty() && !ref->name.empty())
- _mediaSource = ref;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attachedMedia
-// METHOD TYPE : AttachedMedia
-//
-// DESCRIPTION :
-//
-AttachedMedia
-MediaHandler::attachedMedia() const
-{
- if ( _mediaSource && _attachPoint)
- return AttachedMedia(_mediaSource, _attachPoint);
- else
- return AttachedMedia();
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::isSharedMedia
-// METHOD TYPE : bool
-//
-// DESCRIPTION :
-//
-bool
-MediaHandler::isSharedMedia() const
-{
- return !_mediaSource.unique();
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::checkAttached
-// METHOD TYPE : bool
-//
-// DESCRIPTION :
-//
-bool
-MediaHandler::checkAttached(bool matchMountFs) const
-{
- bool _isAttached = false;
-
- AttachedMedia ref( attachedMedia());
- if( ref.mediaSource)
- {
- time_t old_mtime = _attach_mtime;
- _attach_mtime = MediaManager::getMountTableMTime();
- if( !(old_mtime <= 0 || _attach_mtime != old_mtime))
- {
- // OK, skip the check (we've seen it at least once)
- _isAttached = true;
- }
- else
- {
- if( old_mtime > 0)
- DBG << "Mount table changed - rereading it" << std::endl;
- else
- DBG << "Forced check of the mount table" << std::endl;
-
- MountEntries entries( MediaManager::getMountEntries());
- MountEntries::const_iterator e;
- for( e = entries.begin(); e != entries.end(); ++e)
- {
- bool is_device = false;
- std::string dev_path(Pathname(e->src).asString());
- PathInfo dev_info;
-
- if( dev_path.compare(0, sizeof("/dev/")-1, "/dev/") == 0 &&
- dev_info(e->src) && dev_info.isBlk())
- {
- is_device = true;
- }
-
- if( is_device && (ref.mediaSource->maj_nr &&
- ref.mediaSource->bdir.empty()))
- {
- std::string mtype(matchMountFs ? e->type : ref.mediaSource->type);
- MediaSource media(mtype, e->src, dev_info.major(), dev_info.minor());
-
- if( ref.mediaSource->equals( media) &&
- ref.attachPoint->path == Pathname(e->dir))
- {
- DBG << "Found media device "
- << ref.mediaSource->asString()
- << " in the mount table as " << e->src << std::endl;
- _isAttached = true;
- break;
- }
- // differs
- }
- else
- if(!is_device && (!ref.mediaSource->maj_nr ||
- !ref.mediaSource->bdir.empty()))
- {
- std::string mtype(matchMountFs ? e->type : ref.mediaSource->type);
- if( ref.mediaSource->bdir.empty())
- {
- MediaSource media(mtype, e->src);
-
- if( ref.mediaSource->equals( media) &&
- ref.attachPoint->path == Pathname(e->dir))
- {
- DBG << "Found media name "
- << ref.mediaSource->asString()
- << " in the mount table as " << e->src << std::endl;
- _isAttached = true;
- break;
- }
- }
- else
- {
- if(ref.mediaSource->bdir == e->src &&
- ref.attachPoint->path == Pathname(e->dir))
- {
- DBG << "Found bound media "
- << ref.mediaSource->asString()
- << " in the mount table as " << e->src << std::endl;
- _isAttached = true;
- break;
- }
- }
- // differs
- }
- }
-
- if( !_isAttached)
- {
- if( entries.empty())
- {
- ERR << "Unable to find any entry in the /etc/mtab file" << std::endl;
- }
- else
- {
- MountEntries::const_iterator e;
- for( e = entries.begin(); e != entries.end(); ++e)
- {
- XXX << "mount entry: " << e->src << " on " << e->dir
- << " type " << e->type << "(" << e->opts << ")" << endl;
- }
- }
- if( old_mtime > 0)
- {
- ERR << "Attached media not in mount table any more - forcing reset!"
- << std::endl;
-
- _mediaSource.reset();
- }
- else
- {
- WAR << "Attached media not in mount table ..." << std::endl;
- }
-
- // reset the mtime and force a new check to make sure,
- // that we've found the media at least once in the mtab.
- _attach_mtime = 0;
- }
- }
- }
- return _isAttached;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::attach
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::attach( bool next )
-{
- if ( isAttached() )
- return;
-
- // reset it in case of overloaded isAttached()
- // that checks the media against /etc/mtab ...
- setMediaSource(MediaSourceRef());
-
- AttachPoint ap( attachPointHint());
- setAttachPoint(ap.path, ap.temp);
-
- try
- {
- attachTo( next ); // pass to concrete handler
- }
- catch(const MediaException &e)
- {
- removeAttachPoint();
- ZYPP_RETHROW(e);
- }
- MIL << "Attached: " << *this << endl;
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::localPath
-// METHOD TYPE : Pathname
-//
-Pathname MediaHandler::localPath( const Pathname & pathname ) const
-{
- Pathname _localRoot( localRoot());
- if ( _localRoot.empty() )
- return _localRoot;
-
- // we must check maximum file name length
- // this is important for fetching the suseservers, the
- // url with all parameters can get too long (bug #42021)
-
- return _localRoot + pathname.absolutename();
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::disconnect
-// METHOD TYPE : PMError
-//
-void MediaHandler::disconnect()
-{
- if ( !isAttached() )
- return;
-
- disconnectFrom(); // pass to concrete handler
- MIL << "Disconnected: " << *this << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::release
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::release( const std::string & ejectDev )
-{
- if ( !isAttached() ) {
- DBG << "Request to release media - not attached; eject '" << ejectDev << "'"
- << std::endl;
- if ( !ejectDev.empty() )
- forceEject(ejectDev);
- return;
- }
-
- DBG << "Request to release attached media "
- << _mediaSource->asString()
- << ", use count=" << _mediaSource.use_count()
- << std::endl;
-
- if( _mediaSource.unique())
- {
- DBG << "Releasing media " << _mediaSource->asString() << std::endl;
- try {
- releaseFrom( ejectDev ); // pass to concrete handler
- }
- catch(const MediaNotEjectedException &e)
- {
- // not ejected because the media
- // is mounted by somebody else
- // (if our attach point is busy,
- // we get an umount exception)
- _mediaSource.reset(NULL);
- removeAttachPoint();
- // OK, retrow now
- ZYPP_RETHROW(e);
- }
- _mediaSource.reset(NULL);
- removeAttachPoint();
- }
- else if( !ejectDev.empty() ) {
- //
- // Can't eject a shared media
- //
- //ZYPP_THROW(MediaIsSharedException(_mediaSource->asString()));
-
- MediaSourceRef media( new MediaSource(*_mediaSource));
- _mediaSource.reset(NULL);
-
- MediaManager manager;
- manager.forceReleaseShared(media);
-
- setMediaSource(media);
- DBG << "Releasing media (forced) " << _mediaSource->asString() << std::endl;
- try {
- releaseFrom( ejectDev ); // pass to concrete handler
- }
- catch(const MediaNotEjectedException &e)
- {
- // not ejected because the media
- // is mounted by somebody else
- // (if our attach point is busy,
- // we get an umount exception)
- _mediaSource.reset(NULL);
- removeAttachPoint();
- // OK, retrow now
- ZYPP_RETHROW(e);
- }
- _mediaSource.reset(NULL);
- removeAttachPoint();
- }
- else {
- DBG << "Releasing shared media reference only" << std::endl;
- _mediaSource.reset(NULL);
- setAttachPoint("", true);
- }
- MIL << "Released: " << *this << endl;
-}
-
-bool MediaHandler::isAutoMountedMedia(const AttachedMedia &media)
-{
- (void)media;
- return false;
-}
-
-void MediaHandler::forceRelaseAllMedia(bool matchMountFs, bool autoMountedOny)
-{
- forceRelaseAllMedia( attachedMedia().mediaSource, matchMountFs, autoMountedOny);
-}
-
-void MediaHandler::forceRelaseAllMedia(const MediaSourceRef &ref,
- bool matchMountFs,
- bool autoMountedOny)
-{
- if( !ref)
- return;
-
- MountEntries entries( MediaManager::getMountEntries());
- MountEntries::const_iterator e;
- for( e = entries.begin(); e != entries.end(); ++e)
- {
- bool is_device = false;
- std::string dev_path(Pathname(e->src).asString());
- PathInfo dev_info;
-
- if( dev_path.compare(0, sizeof("/dev/")-1, "/dev/") == 0 &&
- dev_info(e->src) && dev_info.isBlk())
- {
- is_device = true;
- }
-
- if( is_device && ref->maj_nr)
- {
- std::string mtype(matchMountFs ? e->type : ref->type);
- MediaSource media(mtype, e->src, dev_info.major(), dev_info.minor());
-
- if( ref->equals( media) && e->type != "subfs")
- {
- if(autoMountedOny)
- {
- try {
- AttachedMedia am(MediaSourceRef(new MediaSource(media)),
- AttachPointRef(new AttachPoint(e->dir)));
- if( !isAutoMountedMedia(am))
- continue;
- }
- catch(...)
- {
- continue;
- }
- }
- DBG << "Forcing release of media device "
- << ref->asString()
- << " in the mount table as "
- << e->src << std::endl;
- try {
- Mount mount;
- mount.umount(e->dir);
- }
- catch (const Exception &e)
- {
- ZYPP_CAUGHT(e);
- }
- }
- }
- else
- if(!is_device && !ref->maj_nr)
- {
- std::string mtype(matchMountFs ? e->type : ref->type);
- MediaSource media(mtype, e->src);
- if( ref->equals( media))
- {
- if(autoMountedOny)
- {
- try {
- AttachedMedia am(MediaSourceRef(new MediaSource(media)),
- AttachPointRef(new AttachPoint(e->dir)));
- if( !isAutoMountedMedia(am))
- continue;
- }
- catch(...)
- {
- continue;
- }
- }
- DBG << "Forcing release of media name "
- << ref->asString()
- << " in the mount table as "
- << e->src << std::endl;
- try {
- Mount mount;
- mount.umount(e->dir);
- }
- catch (const Exception &e)
- {
- ZYPP_CAUGHT(e);
- }
- }
- }
- }
-}
-
-bool
-MediaHandler::checkAttachPoint(const Pathname &apoint) const
-{
- return MediaHandler::checkAttachPoint( apoint, true, false);
-}
-
-// STATIC
-bool
-MediaHandler::checkAttachPoint(const Pathname &apoint,
- bool emptydir,
- bool writeable)
-{
- if( apoint.empty() || !apoint.absolute())
- {
- ERR << "Attach point '" << apoint << "' is not absolute"
- << std::endl;
- return false;
- }
- if( apoint == "/")
- {
- ERR << "Attach point '" << apoint << "' is not allowed"
- << std::endl;
- return false;
- }
-
- PathInfo ainfo(apoint);
- if( !ainfo.isDir())
- {
- ERR << "Attach point '" << apoint << "' is not a directory"
- << std::endl;
- return false;
- }
-
- if( emptydir)
- {
- if( 0 != zypp::filesystem::is_empty_dir(apoint))
- {
- ERR << "Attach point '" << apoint << "' is not a empty directory"
- << std::endl;
- return false;
- }
- }
-
- if( writeable)
- {
- Pathname apath(apoint + "XXXXXX");
- char *atemp = ::strdup( apath.asString().c_str());
- char *atest = NULL;
- if( !ainfo.userMayRWX() || atemp == NULL ||
- (atest=::mkdtemp(atemp)) == NULL)
- {
- if( atemp != NULL)
- ::free(atemp);
-
- ERR << "Attach point '" << ainfo.path()
- << "' is not a writeable directory" << std::endl;
- return false;
- }
- else if( atest != NULL)
- ::rmdir(atest);
-
- if( atemp != NULL)
- ::free(atemp);
- }
- return true;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-// METHOD NAME : MediaHandler::dependsOnParent
-// METHOD TYPE : bool
-//
-// DESCRIPTION :
-//
-bool
-MediaHandler::dependsOnParent()
-{
- return _parentId != 0;
-}
-
-bool
-MediaHandler::dependsOnParent(MediaAccessId parentId, bool exactIdMatch)
-{
- if( _parentId != 0)
- {
- if(parentId == _parentId)
- return true;
-
- if( !exactIdMatch)
- {
- MediaManager mm;
- AttachedMedia am1 = mm.getAttachedMedia(_parentId);
- AttachedMedia am2 = mm.getAttachedMedia(parentId);
- if( am1.mediaSource && am2.mediaSource)
- {
- return am1.mediaSource->equals( *(am2.mediaSource));
- }
- }
- }
- return false;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::provideFile
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::provideFileCopy( Pathname srcFilename,
- Pathname targetFilename ) const
-{
- if ( !isAttached() ) {
- INT << "Media not_attached on provideFileCopy(" << srcFilename
- << "," << targetFilename << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getFileCopy( srcFilename, targetFilename ); // pass to concrete handler
- DBG << "provideFileCopy(" << srcFilename << "," << targetFilename << ")" << endl;
-}
-
-void MediaHandler::provideFile( Pathname filename ) const
-{
- if ( !isAttached() ) {
- INT << "Error: Not attached on provideFile(" << filename << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getFile( filename ); // pass to concrete handler
- DBG << "provideFile(" << filename << ")" << endl;
-}
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::provideDir
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::provideDir( Pathname dirname ) const
-{
- if ( !isAttached() ) {
- INT << "Error: Not attached on provideDir(" << dirname << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getDir( dirname, /*recursive*/false ); // pass to concrete handler
- MIL << "provideDir(" << dirname << ")" << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::provideDirTree
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::provideDirTree( Pathname dirname ) const
-{
- if ( !isAttached() ) {
- INT << "Error Not attached on provideDirTree(" << dirname << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getDir( dirname, /*recursive*/true ); // pass to concrete handler
- MIL << "provideDirTree(" << dirname << ")" << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::releasePath
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::releasePath( Pathname pathname ) const
-{
- if ( ! _does_download || _attachPoint->empty() )
- return;
-
- PathInfo info( localPath( pathname ) );
-
- if ( info.isFile() ) {
- unlink( info.path() );
- } else if ( info.isDir() ) {
- if ( info.path() != localRoot() ) {
- recursive_rmdir( info.path() );
- } else {
- clean_dir( info.path() );
- }
- }
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::dirInfo
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::dirInfo( std::list<std::string> & retlist,
- const Pathname & dirname, bool dots ) const
-{
- retlist.clear();
-
- if ( !isAttached() ) {
- INT << "Error: Not attached on dirInfo(" << dirname << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getDirInfo( retlist, dirname, dots ); // pass to concrete handler
- MIL << "dirInfo(" << dirname << ")" << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::dirInfo
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-void MediaHandler::dirInfo( filesystem::DirContent & retlist,
- const Pathname & dirname, bool dots ) const
-{
- retlist.clear();
-
- if ( !isAttached() ) {
- INT << "Error: Not attached on dirInfo(" << dirname << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
-
- getDirInfo( retlist, dirname, dots ); // pass to concrete handler
- MIL << "dirInfo(" << dirname << ")" << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::doesFileExist
-// METHOD TYPE : PMError
-//
-// DESCRIPTION :
-//
-bool MediaHandler::doesFileExist( const Pathname & filename ) const
-{
- // TODO do some logging
- if ( !isAttached() ) {
- INT << "Error Not attached on doesFileExist(" << filename << ")" << endl;
- ZYPP_THROW(MediaNotAttachedException(url()));
- }
- return getDoesFileExist( filename );
- MIL << "doesFileExist(" << filename << ")" << endl;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDirectoryYast
-// METHOD TYPE : PMError
-//
-void MediaHandler::getDirectoryYast( std::list<std::string> & retlist,
- const Pathname & dirname, bool dots ) const
-{
- retlist.clear();
-
- filesystem::DirContent content;
- getDirectoryYast( content, dirname, dots );
-
- // convert to std::list<std::string>
- for ( filesystem::DirContent::const_iterator it = content.begin(); it != content.end(); ++it ) {
- retlist.push_back( it->name );
- }
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDirectoryYast
-// METHOD TYPE : PMError
-//
-void MediaHandler::getDirectoryYast( filesystem::DirContent & retlist,
- const Pathname & dirname, bool dots ) const
-{
- retlist.clear();
-
- // look for directory.yast
- Pathname dirFile = dirname + "directory.yast";
- getFile( dirFile );
- DBG << "provideFile(" << dirFile << "): " << "OK" << endl;
-
- // using directory.yast
- ifstream dir( localPath( dirFile ).asString().c_str() );
- if ( dir.fail() ) {
- ERR << "Unable to load '" << localPath( dirFile ) << "'" << endl;
- ZYPP_THROW(MediaSystemException(url(),
- "Unable to load '" + localPath( dirFile ).asString() + "'"));
- }
-
- string line;
- while( getline( dir, line ) ) {
- if ( line.empty() ) continue;
- if ( line == "directory.yast" ) continue;
-
- // Newer directory.yast append '/' to directory names
- // Remaining entries are unspecified, although most probabely files.
- filesystem::FileType type = filesystem::FT_NOT_AVAIL;
- if ( *line.rbegin() == '/' ) {
- line.erase( line.end()-1 );
- type = filesystem::FT_DIR;
- }
-
- if ( dots ) {
- if ( line == "." || line == ".." ) continue;
- } else {
- if ( *line.begin() == '.' ) continue;
- }
-
- retlist.push_back( filesystem::DirEntry( line, type ) );
- }
-}
-
-/******************************************************************
-**
-**
-** FUNCTION NAME : operator<<
-** FUNCTION TYPE : ostream &
-*/
-ostream & operator<<( ostream & str, const MediaHandler & obj )
-{
- str << obj.url() << ( obj.isAttached() ? "" : " not" )
- << " attached; localRoot \"" << obj.localRoot() << "\"";
- return str;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getFile
-// METHOD TYPE : PMError
-//
-// DESCRIPTION : Asserted that media is attached.
-// Default implementation of pure virtual.
-//
-void MediaHandler::getFile( const Pathname & filename ) const
-{
- PathInfo info( localPath( filename ) );
- if( info.isFile() ) {
- return;
- }
-
- if (info.isExist())
- ZYPP_THROW(MediaNotAFileException(url(), localPath(filename)));
- else
- ZYPP_THROW(MediaFileNotFoundException(url(), filename));
-}
-
-
-void MediaHandler::getFileCopy ( const Pathname & srcFilename, const Pathname & targetFilename ) const
-{
- getFile(srcFilename);
-
- if ( copy( localPath( srcFilename ), targetFilename ) != 0 ) {
- ZYPP_THROW(MediaWriteException(targetFilename));
- }
-}
-
-
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDir
-// METHOD TYPE : PMError
-//
-// DESCRIPTION : Asserted that media is attached.
-// Default implementation of pure virtual.
-//
-void MediaHandler::getDir( const Pathname & dirname, bool recurse_r ) const
-{
- PathInfo info( localPath( dirname ) );
- if( info.isDir() ) {
- return;
- }
-
- if (info.isExist())
- ZYPP_THROW(MediaNotADirException(url(), localPath(dirname)));
- else
- ZYPP_THROW(MediaFileNotFoundException(url(), dirname));
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDirInfo
-// METHOD TYPE : PMError
-//
-// DESCRIPTION : Asserted that media is attached and retlist is empty.
-// Default implementation of pure virtual.
-//
-void MediaHandler::getDirInfo( std::list<std::string> & retlist,
- const Pathname & dirname, bool dots ) const
-{
- PathInfo info( localPath( dirname ) );
- if( ! info.isDir() ) {
- ZYPP_THROW(MediaNotADirException(url(), localPath(dirname)));
- }
-
-#if NONREMOTE_DIRECTORY_YAST
- // use directory.yast if available
- try {
- getDirectoryYast( retlist, dirname, dots );
- }
- catch (const MediaException & excpt_r)
- {
-#endif
-
- // readdir
- int res = readdir( retlist, info.path(), dots );
- if ( res )
- {
- MediaSystemException nexcpt(url(), "readdir failed");
-#if NONREMOTE_DIRECTORY_YAST
- nexcpt.remember(excpt_r);
-#endif
- ZYPP_THROW(nexcpt);
- }
-
-#if NONREMOTE_DIRECTORY_YAST
- }
-#endif
-
- return;
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDirInfo
-// METHOD TYPE : PMError
-//
-// DESCRIPTION : Asserted that media is attached and retlist is empty.
-// Default implementation of pure virtual.
-//
-void MediaHandler::getDirInfo( filesystem::DirContent & retlist,
- const Pathname & dirname, bool dots ) const
-{
- PathInfo info( localPath( dirname ) );
- if( ! info.isDir() ) {
- ZYPP_THROW(MediaNotADirException(url(), localPath(dirname)));
- }
-
-#if NONREMOTE_DIRECTORY_YAST
- // use directory.yast if available
- try {
- getDirectoryYast( retlist, dirname, dots );
- }
- catch (const MediaException & excpt_r)
- {
-#endif
-
- // readdir
- int res = readdir( retlist, info.path(), dots );
- if ( res )
- {
- MediaSystemException nexcpt(url(), "readdir failed");
-#if NONREMOTE_DIRECTORY_YAST
- nexcpt.remember(excpt_r);
-#endif
- ZYPP_THROW(nexcpt);
- }
-#if NONREMOTE_DIRECTORY_YAST
- }
-#endif
-}
-
-///////////////////////////////////////////////////////////////////
-//
-//
-// METHOD NAME : MediaHandler::getDoesFileExist
-// METHOD TYPE : PMError
-//
-// DESCRIPTION : Asserted that file is not a directory
-// Default implementation of pure virtual.
-//
-bool MediaHandler::getDoesFileExist( const Pathname & filename ) const
-{
- PathInfo info( localPath( filename ) );
- if( info.isDir() ) {
- ZYPP_THROW(MediaNotAFileException(url(), localPath(filename)));
- }
- return info.isExist();
-}
-
-bool MediaHandler::hasMoreDevices()
-{
- return false;
-}
-
-void MediaHandler::getDetectedDevices(std::vector<std::string> & devices,
- unsigned int & index) const
-{
- // clear the vector by default
- if (!devices.empty())
- devices.clear();
- index = 0;
-
- DBG << "No devices for this medium" << endl;
-}
-
-
- } // namespace media
-} // namespace zypp
-// vim: set ts=8 sts=2 sw=2 ai noet:
projects / platform / upstream / libzypp.git / commitdiff