/** \file zypp/media/MediaCD.cc
*
*/
+extern "C"
+{
+#include <sys/ioctl.h>
+#include <linux/cdrom.h>
+#if HAVE_UDEV
+#include <libudev.h>
+#endif
+}
+
+#ifndef HAVE_UDEV
+#if HAVE_HAL
+#include "zypp/target/hal/HalContext.h"
+#endif
+#endif
+#include <cstring> // strerror
+#include <cstdlib> // getenv
#include <iostream>
#include "zypp/base/Logger.h"
#include "zypp/media/MediaCD.h"
#include "zypp/media/MediaManager.h"
#include "zypp/Url.h"
-#include "zypp/target/hal/HalContext.h"
-
-#include <cstring> // strerror
-#include <cstdlib> // getenv
-
-#include <errno.h>
-#include <dirent.h>
-
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h> // geteuid, ...
-
-#include <linux/cdrom.h>
+#include "zypp/AutoDispose.h"
-/*
-** try umount of foreign (user/automounter) media on eject
-** 0 = don't force, 1 = automounted only, 2 == all
-*/
-#define FORCE_RELEASE_FOREIGN 2
-/*
-** Reuse foreign (user/automounter) mount points.
-** 0 = don't use, 1 = automounted only, 2 = all
-*/
-#define REUSE_FOREIGN_MOUNTS 2
/*
** if to throw exception on eject errors or ignore them
*/
-#define REPORT_EJECT_ERRORS 1
+#define REPORT_EJECT_ERRORS 0
/*
** If defined to the full path of the eject utility,
using namespace std;
-namespace zypp {
- namespace media {
+//////////////////////////////////////////////////////////////////
+namespace zypp
+{
+ //////////////////////////////////////////////////////////////////
+ namespace media
+ {
-///////////////////////////////////////////////////////////////////
-//
-// CLASS NAME : MediaCD
-//
-///////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////
+ namespace
+ {
+ typedef std::list<MediaSource> DeviceList;
+
+ //////////////////////////////////////////////////////////////////
+ /// \brief Try to detect cd/dvd devices using hal/udev
+ ///
+ /// Returns an empty device list on error.
+ ///
+ /// \todo I took the code more or less as it was from MediaCD::detectDevices
+ /// into this function. Semantic between HAL and UDEV seems to be slightly
+ /// different, esp. in supportingDVD mode. This should be investigated and fixed.
+ //////////////////////////////////////////////////////////////////
+ DeviceList systemDetectDevices( bool supportingDVD_r )
+ {
+ DeviceList detected;
+
+#ifdef HAVE_UDEV
+ // http://www.kernel.org/pub/linux/utils/kernel/hotplug/libudev/index.html
+ zypp::AutoDispose<struct udev *> udev( ::udev_new(), ::udev_unref );
+ if ( ! udev )
+ {
+ ERR << "Can't create udev context." << endl;
+ return DeviceList();
+ }
+
+ zypp::AutoDispose<struct udev_enumerate *> enumerate( ::udev_enumerate_new(udev), ::udev_enumerate_unref );
+ if ( ! enumerate )
+ {
+ ERR << "Can't create udev list entry." << endl;
+ return DeviceList();
+ }
+
+ ::udev_enumerate_add_match_subsystem( enumerate, "block" );
+ ::udev_enumerate_add_match_property( enumerate, "ID_CDROM", "1" );
+ ::udev_enumerate_scan_devices( enumerate );
+
+ struct udev_list_entry * entry = 0;
+ udev_list_entry_foreach( entry, ::udev_enumerate_get_list_entry( enumerate ) )
+ {
+ zypp::AutoDispose<struct udev_device *> device( ::udev_device_new_from_syspath( ::udev_enumerate_get_udev( enumerate ),
+ ::udev_list_entry_get_name( entry ) ),
+ ::udev_device_unref );
+ if ( ! device )
+ {
+ ERR << "Can't create udev device." << endl;
+ continue;
+ }
+
+ if ( supportingDVD_r && ! ::udev_device_get_property_value( device, "ID_CDROM_DVD" ) )
+ {
+ continue; // looking for dvd only
+ }
+
+ const char * devnodePtr( ::udev_device_get_devnode( device ) );
+ if ( ! devnodePtr )
+ {
+ ERR << "Got NULL devicenode." << endl;
+ continue;
+ }
+
+ // In case we need it someday:
+ //const char * mountpath = ::udev_device_get_property_value( device, "FSTAB_DIR" );
+
+ PathInfo devnode( devnodePtr );
+ if ( devnode.isBlk() )
+ {
+ MediaSource media( "cdrom", devnode.path().asString(), devnode.devMajor(), devnode.devMinor() );
+ DBG << "Found (udev): " << media << std::endl;
+ detected.push_back( media );
+ }
+ }
+ if ( detected.empty() )
+ {
+ WAR << "Did not find any CD/DVD device." << endl;
+ }
+#elif HAVE_HAL
+ using namespace zypp::target::hal;
+ try
+ {
+ HalContext hal(true);
+
+ std::vector<std::string> drv_udis;
+ drv_udis = hal.findDevicesByCapability("storage.cdrom");
+
+ DBG << "Found " << drv_udis.size() << " cdrom drive udis" << std::endl;
+ for(size_t d = 0; d < drv_udis.size(); d++)
+ {
+ HalDrive drv( hal.getDriveFromUDI( drv_udis[d]));
+
+ if( drv)
+ {
+ bool supportsDVD=false;
+ if( supportingDVD_r)
+ {
+ std::vector<std::string> caps;
+ try {
+ caps = drv.getCdromCapabilityNames();
+ }
+ catch(const HalException &e)
+ {
+ ZYPP_CAUGHT(e);
+ }
+
+ std::vector<std::string>::const_iterator ci;
+ for( ci=caps.begin(); ci != caps.end(); ++ci)
+ {
+ if( *ci == "dvd")
+ supportsDVD = true;
+ }
+ }
+
+ MediaSource media("cdrom", drv.getDeviceFile(),
+ drv.getDeviceMajor(),
+ drv.getDeviceMinor());
+ DBG << "Found " << drv_udis[d] << ": "
+ << media.asString() << std::endl;
+ if( supportingDVD_r && supportsDVD)
+ {
+ detected.push_front(media);
+ }
+ else
+ {
+ detected.push_back(media);
+ }
+ }
+ }
+ }
+ catch(const zypp::target::hal::HalException &e)
+ {
+ ZYPP_CAUGHT(e);
+ }
+#endif
+ return detected;
+ }
+ } // namespace
+ //////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////////////////////
- //
- //
- // METHOD NAME : MediaCD::MediaCD
- // METHOD TYPE : Constructor
- //
- // DESCRIPTION :
- //
- MediaCD::MediaCD( const Url & url_r,
- const Pathname & attach_point_hint_r )
- : MediaHandler( url_r, attach_point_hint_r,
- url_r.getPathName(), // urlpath below attachpoint
- false ),
- _lastdev(-1), _lastdev_tried(-1)
+
+ MediaCD::MediaCD( const Url & url_r, const Pathname & attach_point_hint_r )
+ : MediaHandler( url_r, attach_point_hint_r, url_r.getPathName(), false )
+ , _lastdev( -1 )
+ , _lastdev_tried( -1 )
{
- MIL << "MediaCD::MediaCD(" << url_r << ", " << attach_point_hint_r << ")"
- << endl;
+ MIL << "MediaCD::MediaCD(" << url_r << ", " << attach_point_hint_r << ")" << endl;
- if( url_r.getScheme() != "dvd" && url_r.getScheme() != "cd")
+ if ( url_r.getScheme() != "dvd" && url_r.getScheme() != "cd" )
{
ERR << "Unsupported schema in the Url: " << url_r.asString() << endl;
ZYPP_THROW(MediaUnsupportedUrlSchemeException(_url));
}
- string devices = _url.getQueryParam("devices");
- if (!devices.empty())
+ string devices = _url.getQueryParam( "devices" );
+ if ( ! devices.empty() )
{
- string::size_type pos;
- DBG << "parse " << devices << endl;
- while(!devices.empty())
+ std::vector<std::string> words;
+ str::split( devices, std::back_inserter(words), "," );
+ for ( const std::string & device : words )
{
- pos = devices.find(',');
- string device = devices.substr(0,pos);
- if (!device.empty())
- {
- MediaSource media("cdrom", device, 0, 0);
- _devices.push_back( media);
- DBG << "use device (delayed verify)" << device << endl;
- }
- if (pos!=string::npos)
- devices=devices.substr(pos+1);
- else
- devices.erase();
+ if ( device.empty() )
+ continue;
+
+ MediaSource media( "cdrom", device, 0, 0 );
+ _devices.push_back( media );
+ DBG << "use device (delayed verify)" << device << endl;
}
}
else
return;
}
- if( _devices.empty())
+ if ( _devices.empty() )
{
ERR << "Unable to find any cdrom drive for " << _url.asString() << endl;
ZYPP_THROW(MediaBadUrlEmptyDestinationException(_url));
//
bool MediaCD::openTray( const std::string & device_r )
{
- int fd = ::open( device_r.c_str(), O_RDONLY|O_NONBLOCK );
+ int fd = ::open( device_r.c_str(), O_RDONLY|O_NONBLOCK|O_CLOEXEC );
int res = -1;
if ( fd != -1)
cmd[1] = device_r.c_str();
cmd[2] = NULL;
ExternalProgram eject(cmd, ExternalProgram::Stderr_To_Stdout);
-
+
for(std::string out( eject.receiveLine());
out.length(); out = eject.receiveLine())
{
DBG << " " << out;
}
-
+
if(eject.close() != 0)
{
WAR << "Eject of " << device_r << " failed." << std::endl;
//
bool MediaCD::closeTray( const std::string & device_r )
{
- int fd = ::open( device_r.c_str(), O_RDONLY|O_NONBLOCK );
+ int fd = ::open( device_r.c_str(), O_RDONLY|O_NONBLOCK|O_CLOEXEC );
if ( fd == -1 ) {
WAR << "Unable to open '" << device_r << "' (" << ::strerror( errno ) << ")" << endl;
return false;
return true;
}
- ///////////////////////////////////////////////////////////////////
- //
- //
- // METHOD NAME : MediaCD::detectDevices
- // METHOD TYPE : MediaCD::DeviceList
- //
- MediaCD::DeviceList
- MediaCD::detectDevices(bool supportingDVD)
+
+ MediaCD::DeviceList MediaCD::detectDevices( bool supportingDVD_r ) const
{
- using namespace zypp::target::hal;
+ DeviceList detected( systemDetectDevices( supportingDVD_r ) );
- DeviceList detected;
- try
+ if ( detected.empty() )
{
- HalContext hal(true);
-
- std::vector<std::string> drv_udis;
- drv_udis = hal.findDevicesByCapability("storage.cdrom");
-
- DBG << "Found " << drv_udis.size() << " cdrom drive udis" << std::endl;
- for(size_t d = 0; d < drv_udis.size(); d++)
+ WAR << "CD/DVD drive detection with HAL/UDEV failed! Guessing..." << std::endl;
+ PathInfo dvdinfo( "/dev/dvd" );
+ PathInfo cdrinfo( "/dev/cdrom" );
+ if ( dvdinfo.isBlk() )
{
- HalDrive drv( hal.getDriveFromUDI( drv_udis[d]));
-
- if( drv)
- {
- bool supportsDVD=false;
- if( supportingDVD)
- {
- std::vector<std::string> caps;
- try {
- caps = drv.getCdromCapabilityNames();
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- }
-
- std::vector<std::string>::const_iterator ci;
- for( ci=caps.begin(); ci != caps.end(); ++ci)
- {
- if( *ci == "dvd")
- supportsDVD = true;
- }
- }
-
- MediaSource media("cdrom", drv.getDeviceFile(),
- drv.getDeviceMajor(),
- drv.getDeviceMinor());
- DBG << "Found " << drv_udis[d] << ": "
- << media.asString() << std::endl;
- if( supportingDVD && supportsDVD)
- {
- detected.push_front(media);
- }
- else
- {
- detected.push_back(media);
- }
- }
+ MediaSource media( "cdrom", dvdinfo.path().asString(), dvdinfo.devMajor(), dvdinfo.devMinor() );
+ DBG << "Found (GUESS): " << media << std::endl;
+ detected.push_back( media );
+ }
+ if ( cdrinfo.isBlk()
+ && ! ( cdrinfo.devMajor() == dvdinfo.devMajor() && cdrinfo.devMinor() == dvdinfo.devMinor() ) )
+ {
+ MediaSource media( "cdrom", cdrinfo.path().asString(), cdrinfo.devMajor(), cdrinfo.devMinor() );
+ DBG << "Found (GUESS): " << media << std::endl;
+ detected.push_back( media );
}
}
- catch(const zypp::target::hal::HalException &e)
+
+ // NOTE: On the fly build on-demand device list. Code was moved to
+ // here to get rid of code duplication, while keeping the ABI. Acuallty
+ // this code should be moved to a _devices accessor method.
+ if ( _devices.empty() )
{
- ZYPP_CAUGHT(e);
+ DBG << "creating on-demand device list" << endl;
+ //default is /dev/cdrom; for dvd: /dev/dvd if it exists
+ string device( "/dev/cdrom" );
+ if ( _url.getScheme() == "dvd" && PathInfo( "/dev/dvd" ).isBlk() )
+ {
+ device = "/dev/dvd";
+ }
+
+ PathInfo dinfo( device );
+ if ( dinfo.isBlk() )
+ {
+ MediaSource media( "cdrom", device, dinfo.devMajor(), dinfo.devMinor() );
+ if ( detected.empty() )
+ {
+ _devices.push_front( media ); // better try this than nothing
+ }
+ else
+ {
+ for( const auto & d : detected )
+ {
+ // /dev/cdrom or /dev/dvd to the front
+ if ( media.equals( d ) )
+ _devices.push_front( d );
+ else
+ _devices.push_back( d );
+ }
+ }
+ }
+ else
+ {
+ // no /dev/cdrom or /dev/dvd link
+ _devices = detected;
+ }
}
return detected;
//
// DESCRIPTION : Asserted that not already attached, and attachPoint is a directory.
//
- void MediaCD::attachTo(bool next)
+ void MediaCD::attachTo( bool next )
{
DBG << "next " << next << " last " << _lastdev << " last tried " << _lastdev_tried << endl;
- if (next && _lastdev == -1)
+ if ( next && _lastdev == -1 )
ZYPP_THROW(MediaNotSupportedException(url()));
- DeviceList detected(
- detectDevices(_url.getScheme() == "dvd" ? true : false));
+ // This also fills the _devices list on demand
+ DeviceList detected( detectDevices( _url.getScheme() == "dvd" ? true : false ) );
- if(_devices.empty())
+ if( !isUseableAttachPoint( attachPoint() ) )
{
- DBG << "creating on-demand device list" << endl;
- //default is /dev/cdrom; for dvd: /dev/dvd if it exists
- string device( "/dev/cdrom" );
- if ( _url.getScheme() == "dvd" && PathInfo( "/dev/dvd" ).isBlk() )
- {
- device = "/dev/dvd";
- }
-
- PathInfo dinfo(device);
- if( dinfo.isBlk())
- {
- MediaSource media("cdrom", device, dinfo.major(), dinfo.minor());
-
- DeviceList::const_iterator d( detected.begin());
- for( ; d != detected.end(); ++d)
- {
- // /dev/cdrom or /dev/dvd to the front
- if( media.equals( *d))
- _devices.push_front( *d);
- else
- _devices.push_back( *d);
- }
- }
- else
- {
- // no /dev/cdrom or /dev/dvd link
- _devices = detected;
- }
+ setAttachPoint( createAttachPoint(), true );
}
+ std::string mountpoint( attachPoint().asString() );
Mount mount;
- string mountpoint = attachPoint().asString();
- bool mountsucceeded = false;
- int count = 0;
MediaMountException merr;
- string options = _url.getQueryParam("mountoptions");
- if (options.empty())
+ string options = _url.getQueryParam( "mountoptions" );
+ if ( options.empty() )
{
options="ro";
}
filesystems.push_back("iso9660");
// try all devices in sequence
- for (DeviceList::iterator it = _devices.begin()
- ; !mountsucceeded && it != _devices.end()
- ; ++it, count++ )
+ int count = 0;
+ bool mountsucceeded = false;
+ for ( DeviceList::iterator it = _devices.begin() ; ! mountsucceeded && it != _devices.end() ; ++it, ++count )
{
DBG << "count " << count << endl;
if (next && count <=_lastdev_tried )
DBG << "skipping device " << it->name << endl;
continue;
}
-
_lastdev_tried = count;
- MediaSource temp( *it);
- bool valid=false;
- PathInfo dinfo(temp.name);
- if( dinfo.isBlk())
- {
- temp.maj_nr = dinfo.major();
- temp.min_nr = dinfo.minor();
-
- DeviceList::const_iterator d( detected.begin());
- for( ; d != detected.end(); ++d)
- {
- if( temp.equals( *d))
- {
- valid = true;
- break;
- }
- }
- }
- if( !valid)
+ // bnc#755815: _devices contains either devices passed as url option
+ // or autodetected ones. Accept both as long as they are block
+ // devices.
+ MediaSource temp( *it );
+ PathInfo dinfo( temp.name );
+ if ( ! dinfo.isBlk() )
{
- DBG << "skipping invalid device: " << it->name << endl;
- continue;
+ WAR << "skipping non block device: " << dinfo << endl;
+ continue;
}
+ DBG << "trying device " << dinfo << endl;
+ temp.maj_nr = dinfo.devMajor();
+ temp.min_nr = dinfo.devMinor();
MediaSourceRef media( new MediaSource(temp));
AttachedMedia ret( findAttachedMedia( media));
break;
}
-#if REUSE_FOREIGN_MOUNTS > 0
{
MediaManager manager;
MountEntries entries( manager.getMountEntries());
is_device = true;
}
- if( is_device && media->maj_nr == dev_info.major() &&
- media->min_nr == dev_info.minor())
+ if( is_device && media->maj_nr == dev_info.devMajor() &&
+ media->min_nr == dev_info.devMinor())
{
AttachPointRef ap( new AttachPoint(e->dir, false));
AttachedMedia am( media, ap);
- //
- // 1 = automounted only, 2 == all
- //
-#if REUSE_FOREIGN_MOUNTS == 1
- if( isAutoMountedMedia(am))
-#endif
{
DBG << "Using a system mounted media "
<< media->name
if( mountsucceeded)
break;
}
-#endif // REUSE_FOREIGN_MOUNTS
// close tray
closeTray( it->name );
{
try
{
- if( !isUseableAttachPoint(Pathname(mountpoint)))
- {
- mountpoint = createAttachPoint().asString();
- setAttachPoint( mountpoint, true);
- if( mountpoint.empty())
- {
- ZYPP_THROW( MediaBadAttachPointException(url()));
- }
- }
-
mount.mount(it->name, mountpoint, *fsit, options);
setMediaSource(media);
// wait for /etc/mtab update ...
// (shouldn't be needed)
- int limit = 5;
+ int limit = 2;
while( !(mountsucceeded=isAttached()) && --limit)
{
+ WAR << "Wait for /proc/mounts update and retry...." << endl;
sleep(1);
}
//
// DESCRIPTION : Asserted that media is attached.
//
- void MediaCD::releaseFrom( bool eject )
+ void MediaCD::releaseFrom( const std::string & ejectDev )
{
Mount mount;
try
catch (const Exception & excpt_r)
{
ZYPP_CAUGHT(excpt_r);
- if (eject)
+ if (!ejectDev.empty())
{
-#if FORCE_RELEASE_FOREIGN > 0
- /* 1 = automounted only, 2 = all */
- forceRelaseAllMedia(false, FORCE_RELEASE_FOREIGN == 1);
-#endif
- if(openTray( mediaSourceName()))
+ forceRelaseAllMedia(false);
+ if(openTray( ejectDev ))
return;
}
ZYPP_RETHROW(excpt_r);
}
// eject device
- if (eject)
+ if (!ejectDev.empty())
{
-#if FORCE_RELEASE_FOREIGN > 0
- /* 1 = automounted only, 2 = all */
- forceRelaseAllMedia(false, FORCE_RELEASE_FOREIGN == 1);
-#endif
- if( !openTray( mediaSourceName() ))
+ forceRelaseAllMedia(false);
+ if( !openTray( ejectDev ))
{
#if REPORT_EJECT_ERRORS
- ZYPP_THROW(MediaNotEjectedException(mediaSourceName()));
+ ZYPP_THROW(MediaNotEjectedException(ejectDev));
#endif
}
}
//
// Asserted that media is not attached.
//
- void MediaCD::forceEject()
+ void MediaCD::forceEject( const std::string & ejectDev_r )
{
- bool ejected=false;
- if ( !isAttached()) { // no device mounted in this instance
-
- DeviceList detected(
- detectDevices(_url.getScheme() == "dvd" ? true : false));
-
- if(_devices.empty())
+#if REPORT_EJECT_ERRORS
+ bool ejected = false;
+#endif
+ if ( ! isAttached() ) // no device mounted in this instance
+ {
+ // This also fills the _devices list on demand
+ DeviceList detected( detectDevices( _url.getScheme() == "dvd" ? true : false ) );
+ for_( it, _devices.begin(), _devices.end() )
{
- DBG << "creating on-demand device list" << endl;
- //default is /dev/cdrom; for dvd: /dev/dvd if it exists
- string device( "/dev/cdrom" );
- if ( _url.getScheme() == "dvd" && PathInfo( "/dev/dvd" ).isBlk() ) {
- device = "/dev/dvd";
- }
-
- PathInfo dinfo(device);
- if( dinfo.isBlk())
- {
- MediaSource media("cdrom", device, dinfo.major(), dinfo.minor());
-
- DeviceList::const_iterator d( detected.begin());
- for( ; d != detected.end(); ++d)
- {
- // /dev/cdrom or /dev/dvd to the front
- if( media.equals( *d))
- _devices.push_front( *d);
- else
- _devices.push_back( *d);
- }
- }
- else
- {
- // no /dev/cdrom or /dev/dvd link
- _devices = detected;
- }
- }
-
- DeviceList::iterator it;
- for( it = _devices.begin(); it != _devices.end(); ++it ) {
- MediaSourceRef media( new MediaSource( *it));
-
- bool valid=false;
- PathInfo dinfo(media->name);
- if( dinfo.isBlk())
- {
- media->maj_nr = dinfo.major();
- media->min_nr = dinfo.minor();
-
- DeviceList::const_iterator d( detected.begin());
- for( ; d != detected.end(); ++d)
- {
- if( media->equals( *d))
- {
- valid = true;
- break;
- }
- }
- }
- if( !valid)
- {
- DBG << "skipping invalid device: " << it->name << endl;
+ MediaSourceRef media( new MediaSource( *it ) );
+ if ( media->name != ejectDev_r )
continue;
- }
+
+ // bnc#755815: _devices contains either devices passed as url option
+ // or autodetected ones. Accept both as long as they are block
+ // devices.
+ PathInfo dinfo( media->name );
+ if( ! dinfo.isBlk() )
+ {
+ WAR << "skipping non block device: " << dinfo << endl;
+ continue;
+ }
+ DBG << "trying device " << dinfo << endl;
// FIXME: we have also to check if it is mounted in the system
AttachedMedia ret( findAttachedMedia( media));
- if( !ret.mediaSource)
+ if( !ret.mediaSource )
{
-#if FORCE_RELEASE_FOREIGN > 0
- /* 1 = automounted only, 2 = all */
- forceRelaseAllMedia(media, false, FORCE_RELEASE_FOREIGN == 1);
-#endif
+ forceRelaseAllMedia( media, false );
if ( openTray( it->name ) )
{
+#if REPORT_EJECT_ERRORS
ejected = true;
+#endif
break; // on 1st success
}
}
}
}
+#if REPORT_EJECT_ERRORS
if( !ejected)
{
-#if REPORT_EJECT_ERRORS
ZYPP_THROW(MediaNotEjectedException());
-#endif
- }
- }
-
- bool MediaCD::isAutoMountedMedia(const AttachedMedia &media)
- {
- bool is_automounted = false;
- if( media.mediaSource && !media.mediaSource->name.empty())
- {
- using namespace zypp::target::hal;
-
- try
- {
- HalContext hal(true);
-
- HalVolume vol = hal.getVolumeFromDeviceFile(media.mediaSource->name);
- if( vol)
- {
- std::string udi = vol.getUDI();
- std::string key;
- std::string mnt;
-
- try
- {
- key = "info.hal_mount.created_mount_point";
- mnt = hal.getDevicePropertyString(udi, key);
-
- if(media.attachPoint->path == mnt)
- is_automounted = true;
- }
- catch(const HalException &e1)
- {
- ZYPP_CAUGHT(e1);
-
- try
- {
- key = "volume.mount_point";
- mnt = hal.getDevicePropertyString(udi, key);
-
- if(media.attachPoint->path == mnt)
- is_automounted = true;
- }
- catch(const HalException &e2)
- {
- ZYPP_CAUGHT(e2);
- }
- }
- }
- }
- catch(const HalException &e)
- {
- ZYPP_CAUGHT(e);
- }
}
- DBG << "Media " << media.mediaSource->asString()
- << " attached on " << media.attachPoint->path
- << " is" << (is_automounted ? "" : " not")
- << " automounted" << std::endl;
- return is_automounted;
+#endif
}
///////////////////////////////////////////////////////////////////
//
// DESCRIPTION : Asserted that media is attached and retlist is empty.
//
- void MediaCD::getDirInfo( filesystem::DirContent & retlist,
- const Pathname & dirname, bool dots ) const
+ void MediaCD::getDirInfo( filesystem::DirContent & retlist, const Pathname & dirname, bool dots ) const
{
MediaHandler::getDirInfo( retlist, dirname, dots );
}
+
bool MediaCD::getDoesFileExist( const Pathname & filename ) const
{
return MediaHandler::getDoesFileExist( filename );
}
+
bool MediaCD::hasMoreDevices()
{
if (_devices.size() == 0)
}
+ void MediaCD::getDetectedDevices( std::vector<std::string> & devices, unsigned int & index ) const
+ {
+ if ( ! devices.empty() )
+ devices.clear();
+
+ if ( _devices.empty() )
+ // This also fills the _devices list on demand
+ detectDevices( _url.getScheme() == "dvd" ? true : false );
+
+ for ( const auto & it : _devices )
+ devices.push_back( it.name );
+
+ index = ( _lastdev >= 0 ? (unsigned)_lastdev : 0 );
+
+ MIL << "got " << devices.size() << " detected devices, current: "
+ << (index < devices.size() ? devices[index] : "<none>")
+ << "(" << index << ")" << endl;
+ }
+
} // namespace media
+ //////////////////////////////////////////////////////////////////
} // namespace zypp
-// vim: set ts=8 sts=2 sw=2 ai noet:
+//////////////////////////////////////////////////////////////////