libzypp  17.31.31
MediaCD.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 extern "C"
13 {
14 #include <sys/ioctl.h>
15 #include <linux/cdrom.h>
16 #if HAVE_UDEV
17 #include <libudev.h>
18 #endif
19 }
20 
21 #include <cstring> // strerror
22 #include <cstdlib> // getenv
23 #include <iostream>
24 
25 #include <zypp/base/Logger.h>
26 #include <zypp/ExternalProgram.h>
27 #include <zypp-media/Mount>
28 #include <zypp-media/CDTools>
29 #include <zypp/media/MediaCD.h>
31 #include <zypp/Url.h>
32 #include <zypp/AutoDispose.h>
33 
34 using std::endl;
35 
36 /*
37 ** if to throw exception on eject errors or ignore them
38 */
39 #define REPORT_EJECT_ERRORS 0
40 
41 
43 namespace zypp
44 {
46  namespace media
47  {
48 
50  namespace
51  {
52  typedef std::list<MediaSource> DeviceList;
53 
59  DeviceList systemDetectDevices( bool supportingDVD_r )
60  {
61  DeviceList detected;
62 
63 #ifdef HAVE_UDEV
64  // http://www.kernel.org/pub/linux/utils/kernel/hotplug/libudev/index.html
65  zypp::AutoDispose<struct udev *> udev( ::udev_new(), ::udev_unref );
66  if ( ! udev )
67  {
68  ERR << "Can't create udev context." << endl;
69  return DeviceList();
70  }
71 
72  zypp::AutoDispose<struct udev_enumerate *> enumerate( ::udev_enumerate_new(udev), ::udev_enumerate_unref );
73  if ( ! enumerate )
74  {
75  ERR << "Can't create udev list entry." << endl;
76  return DeviceList();
77  }
78 
79  ::udev_enumerate_add_match_subsystem( enumerate, "block" );
80  ::udev_enumerate_add_match_property( enumerate, "ID_CDROM", "1" );
81  ::udev_enumerate_scan_devices( enumerate );
82 
83  struct udev_list_entry * entry = 0;
84  udev_list_entry_foreach( entry, ::udev_enumerate_get_list_entry( enumerate ) )
85  {
86  zypp::AutoDispose<struct udev_device *> device( ::udev_device_new_from_syspath( ::udev_enumerate_get_udev( enumerate ),
87  ::udev_list_entry_get_name( entry ) ),
88  ::udev_device_unref );
89  if ( ! device )
90  {
91  ERR << "Can't create udev device." << endl;
92  continue;
93  }
94 
95  if ( supportingDVD_r && ! ::udev_device_get_property_value( device, "ID_CDROM_DVD" ) )
96  {
97  continue; // looking for dvd only
98  }
99 
100  const char * devnodePtr( ::udev_device_get_devnode( device ) );
101  if ( ! devnodePtr )
102  {
103  ERR << "Got NULL devicenode." << endl;
104  continue;
105  }
106 
107  // In case we need it someday:
108  //const char * mountpath = ::udev_device_get_property_value( device, "FSTAB_DIR" );
109 
110  PathInfo devnode( devnodePtr );
111  if ( devnode.isBlk() )
112  {
113  MediaSource media( "cdrom", devnode.path().asString(), devnode.devMajor(), devnode.devMinor() );
114  DBG << "Found (udev): " << media << std::endl;
115  detected.push_back( media );
116  }
117  }
118  if ( detected.empty() )
119  {
120  WAR << "Did not find any CD/DVD device." << endl;
121  }
122 #endif
123  return detected;
124  }
125 
126  } // namespace
128 
129 
130  MediaCD::MediaCD( const Url & url_r, const Pathname & attach_point_hint_r )
131  : MediaHandler( url_r, attach_point_hint_r, url_r.getPathName(), false )
132  , _lastdev( -1 )
133  , _lastdev_tried( -1 )
134  {
135  MIL << "MediaCD::MediaCD(" << url_r << ", " << attach_point_hint_r << ")" << endl;
136 
137  if ( url_r.getScheme() != "dvd" && url_r.getScheme() != "cd" )
138  {
139  ERR << "Unsupported schema in the Url: " << url_r.asString() << endl;
141  }
142 
143  std::string devices = _url.getQueryParam( "devices" );
144  if ( ! devices.empty() )
145  {
146  std::vector<std::string> words;
147  str::split( devices, std::back_inserter(words), "," );
148  for ( const std::string & device : words )
149  {
150  if ( device.empty() )
151  continue;
152 
153  MediaSource media( "cdrom", device, 0, 0 );
154  _devices.push_back( media );
155  DBG << "use device (delayed verify)" << device << endl;
156  }
157  }
158  else
159  {
160  DBG << "going to use on-demand device list" << endl;
161  return;
162  }
163 
164  if ( _devices.empty() )
165  {
166  ERR << "Unable to find any cdrom drive for " << _url.asString() << endl;
168  }
169  }
170 
172  //
173  //
174  // METHOD NAME : MediaCD::openTray
175  // METHOD TYPE : bool
176  //
177  bool MediaCD::openTray( const std::string & device_r )
178  {
179  return CDTools::openTray(device_r);
180  }
181 
183  //
184  //
185  // METHOD NAME : MediaCD::closeTray
186  // METHOD TYPE : bool
187  //
188  bool MediaCD::closeTray( const std::string & device_r )
189  {
190  return CDTools::closeTray(device_r);
191  }
192 
193 
194  MediaCD::DeviceList MediaCD::detectDevices( bool supportingDVD_r ) const
195  {
196  DeviceList detected( systemDetectDevices( supportingDVD_r ) );
197 
198  if ( detected.empty() )
199  {
200  WAR << "CD/DVD drive detection with UDEV failed! Guessing..." << std::endl;
201  PathInfo dvdinfo( "/dev/dvd" );
202  PathInfo cdrinfo( "/dev/cdrom" );
203  if ( dvdinfo.isBlk() )
204  {
205  MediaSource media( "cdrom", dvdinfo.path().asString(), dvdinfo.devMajor(), dvdinfo.devMinor() );
206  DBG << "Found (GUESS): " << media << std::endl;
207  detected.push_back( media );
208  }
209  if ( cdrinfo.isBlk()
210  && ! ( cdrinfo.devMajor() == dvdinfo.devMajor() && cdrinfo.devMinor() == dvdinfo.devMinor() ) )
211  {
212  MediaSource media( "cdrom", cdrinfo.path().asString(), cdrinfo.devMajor(), cdrinfo.devMinor() );
213  DBG << "Found (GUESS): " << media << std::endl;
214  detected.push_back( media );
215  }
216  }
217 
218  // NOTE: On the fly build on-demand device list. Code was moved to
219  // here to get rid of code duplication, while keeping the ABI. Acuallty
220  // this code should be moved to a _devices accessor method.
221  if ( _devices.empty() )
222  {
223  DBG << "creating on-demand device list" << endl;
224  //default is /dev/cdrom; for dvd: /dev/dvd if it exists
225  std::string device( "/dev/cdrom" );
226  if ( _url.getScheme() == "dvd" && PathInfo( "/dev/dvd" ).isBlk() )
227  {
228  device = "/dev/dvd";
229  }
230 
231  PathInfo dinfo( device );
232  if ( dinfo.isBlk() )
233  {
234  MediaSource media( "cdrom", device, dinfo.devMajor(), dinfo.devMinor() );
235  if ( detected.empty() )
236  {
237  _devices.push_front( media ); // better try this than nothing
238  }
239  else
240  {
241  for( const auto & d : detected )
242  {
243  // /dev/cdrom or /dev/dvd to the front
244  if ( media.equals( d ) )
245  _devices.push_front( d );
246  else
247  _devices.push_back( d );
248  }
249  }
250  }
251  else
252  {
253  // no /dev/cdrom or /dev/dvd link
254  _devices = detected;
255  }
256  }
257 
258  return detected;
259  }
260 
261 
263  //
264  //
265  // METHOD NAME : MediaCD::attachTo
266  // METHOD TYPE : PMError
267  //
268  // DESCRIPTION : Asserted that not already attached, and attachPoint is a directory.
269  //
270  void MediaCD::attachTo( bool next )
271  {
272  DBG << "next " << next << " last " << _lastdev << " last tried " << _lastdev_tried << endl;
273  if ( next && _lastdev == -1 )
275 
276  // This also fills the _devices list on demand
277  DeviceList detected( detectDevices( _url.getScheme() == "dvd" ? true : false ) );
278 
279  Mount mount;
280  MediaMountException merr;
281 
282  std::string options = _url.getQueryParam( "mountoptions" );
283  if ( options.empty() )
284  {
285  options="ro";
286  }
287 
288  //TODO: make configurable
289  std::list<std::string> filesystems;
290 
291  filesystems.push_back("iso9660");
292 
293  // if DVD, try UDF filesystem after iso9660
294  if ( _url.getScheme() == "dvd" )
295  filesystems.push_back("udf");
296 
297  // try all devices in sequence
298  int count = 0;
299  std::string mountpoint( attachPoint().asString() );
300  bool mountsucceeded = false;
301  for ( DeviceList::iterator it = _devices.begin() ; ! mountsucceeded && it != _devices.end() ; ++it, ++count )
302  {
303  DBG << "count " << count << endl;
304  if (next && count <=_lastdev_tried )
305  {
306  DBG << "skipping device " << it->name << endl;
307  continue;
308  }
309  _lastdev_tried = count;
310 
311  // bnc#755815: _devices contains either devices passed as url option
312  // or autodetected ones. Accept both as long as they are block
313  // devices.
314  MediaSource temp( *it );
315  PathInfo dinfo( temp.name );
316  if ( ! dinfo.isBlk() )
317  {
318  WAR << "skipping non block device: " << dinfo << endl;
319  continue;
320  }
321  DBG << "trying device " << dinfo << endl;
322 
323  temp.maj_nr = dinfo.devMajor();
324  temp.min_nr = dinfo.devMinor();
325  MediaSourceRef media( new MediaSource(temp));
326  AttachedMedia ret( findAttachedMedia( media));
327 
328  if( ret.mediaSource && ret.attachPoint &&
329  !ret.attachPoint->empty())
330  {
331  DBG << "Using a shared media "
332  << ret.mediaSource->name
333  << " attached on "
334  << ret.attachPoint->path
335  << endl;
339  _lastdev = count;
340  mountsucceeded = true;
341  break;
342  }
343 
344  {
345  MediaManager manager;
346  MountEntries entries( manager.getMountEntries());
347  MountEntries::const_iterator e;
348  for( e = entries.begin(); e != entries.end(); ++e)
349  {
350  bool is_device = false;
351  std::string dev_path(Pathname(e->src).asString());
352  PathInfo dev_info;
353 
354  if( dev_path.compare(0, sizeof("/dev/")-1, "/dev/") == 0 &&
355  dev_info(e->src) && dev_info.isBlk())
356  {
357  is_device = true;
358  }
359 
360  if( is_device && media->maj_nr == dev_info.devMajor() &&
361  media->min_nr == dev_info.devMinor())
362  {
363  AttachPointRef ap( new AttachPoint(e->dir, false));
364  AttachedMedia am( media, ap);
365  {
366  DBG << "Using a system mounted media "
367  << media->name
368  << " attached on "
369  << ap->path
370  << endl;
371 
372  media->iown = false; // mark attachment as foreign
373 
374  setMediaSource(media);
375  setAttachPoint(ap);
376  _lastdev = count;
377  mountsucceeded = true;
378  break;
379  }
380  }
381  }
382  if( mountsucceeded)
383  break;
384  }
385 
386  // close tray
387  closeTray( it->name );
388 
389  // try all filesystems in sequence
390  for(std::list<std::string>::iterator fsit = filesystems.begin()
391  ; !mountsucceeded && fsit != filesystems.end()
392  ; ++fsit)
393  {
394  try
395  {
397  {
399  mountpoint = attachPoint().asString();
400  }
401 
402  mount.mount(it->name, mountpoint, *fsit, options);
403 
404  setMediaSource(media);
405 
406  // wait for /etc/mtab update ...
407  // (shouldn't be needed)
408  int limit = 2;
409  while( !(mountsucceeded=isAttached()) && --limit)
410  {
411  WAR << "Wait for /proc/mounts update and retry...." << endl;
412  sleep(1);
413  }
414 
415  if( mountsucceeded)
416  {
417  _lastdev = count;
418  }
419  else
420  {
422  try
423  {
424  mount.umount(attachPoint().asString());
425  }
426  catch (const MediaException & excpt_r)
427  {
428  ZYPP_CAUGHT(excpt_r);
429  }
431  "Unable to verify that the media was mounted",
432  it->name, mountpoint
433  ));
434  }
435  }
436  catch (const MediaMountException &e)
437  {
438  merr = e;
440  ZYPP_CAUGHT(e);
441  }
442  catch (const MediaException & excpt_r)
443  {
445  ZYPP_CAUGHT(excpt_r);
446  }
447  } // for filesystems
448  } // for _devices
449 
450  if (!mountsucceeded)
451  {
452  _lastdev = -1;
453 
454  if( !merr.mountOutput().empty())
455  {
457  _url.asString(),
458  mountpoint,
459  merr.mountOutput()));
460  }
461  else
462  {
463  ZYPP_THROW(MediaMountException("Mounting media failed",
464  _url.asString(), mountpoint));
465  }
466  }
467  DBG << _lastdev << " " << count << endl;
468  }
469 
470 
472  //
473  //
474  // METHOD NAME : MediaCD::releaseFrom
475  // METHOD TYPE : PMError
476  //
477  // DESCRIPTION : Asserted that media is attached.
478  //
479  void MediaCD::releaseFrom( const std::string & ejectDev )
480  {
481  Mount mount;
482  try
483  {
485  if(am.mediaSource && am.mediaSource->iown)
486  mount.umount(am.attachPoint->path.asString());
487  }
488  catch (const Exception & excpt_r)
489  {
490  ZYPP_CAUGHT(excpt_r);
491  if (!ejectDev.empty())
492  {
493  forceRelaseAllMedia(false);
494  if(openTray( ejectDev ))
495  return;
496  }
497  ZYPP_RETHROW(excpt_r);
498  }
499 
500  // eject device
501  if (!ejectDev.empty())
502  {
503  forceRelaseAllMedia(false);
504  if( !openTray( ejectDev ))
505  {
506 #if REPORT_EJECT_ERRORS
508 #endif
509  }
510  }
511  }
512 
514  //
515  //
516  // METHOD NAME : MediaCD::forceEject
517  // METHOD TYPE : void
518  //
519  // Asserted that media is not attached.
520  //
521  void MediaCD::forceEject( const std::string & ejectDev_r )
522  {
523 #if REPORT_EJECT_ERRORS
524  bool ejected = false;
525 #endif
526  if ( ! isAttached() ) // no device mounted in this instance
527  {
528  // This also fills the _devices list on demand
529  DeviceList detected( detectDevices( _url.getScheme() == "dvd" ? true : false ) );
530  for_( it, _devices.begin(), _devices.end() )
531  {
532  MediaSourceRef media( new MediaSource( *it ) );
533  if ( media->name != ejectDev_r )
534  continue;
535 
536  // bnc#755815: _devices contains either devices passed as url option
537  // or autodetected ones. Accept both as long as they are block
538  // devices.
539  PathInfo dinfo( media->name );
540  if( ! dinfo.isBlk() )
541  {
542  WAR << "skipping non block device: " << dinfo << endl;
543  continue;
544  }
545  DBG << "trying device " << dinfo << endl;
546 
547  // FIXME: we have also to check if it is mounted in the system
548  AttachedMedia ret( findAttachedMedia( media));
549  if( !ret.mediaSource )
550  {
551  forceRelaseAllMedia( media, false );
552  if ( openTray( it->name ) )
553  {
554 #if REPORT_EJECT_ERRORS
555  ejected = true;
556 #endif
557  break; // on 1st success
558  }
559  }
560  }
561  }
562 #if REPORT_EJECT_ERRORS
563  if( !ejected)
564  {
566  }
567 #endif
568  }
569 
571  //
572  // METHOD NAME : MediaCD::isAttached
573  // METHOD TYPE : bool
574  //
575  // DESCRIPTION : Override check if media is attached.
576  //
577  bool
579  {
580  return checkAttached(false);
581  }
582 
584  //
585  // METHOD NAME : MediaCD::getFile
586  // METHOD TYPE : PMError
587  //
588  // DESCRIPTION : Asserted that media is attached.
589  //
590  void MediaCD::getFile( const OnMediaLocation &file ) const
591  {
592  MediaHandler::getFile( file );
593  }
594 
596  //
597  // METHOD NAME : MediaCD::getDir
598  // METHOD TYPE : PMError
599  //
600  // DESCRIPTION : Asserted that media is attached.
601  //
602  void MediaCD::getDir( const Pathname & dirname, bool recurse_r ) const
603  {
604  MediaHandler::getDir( dirname, recurse_r );
605  }
606 
608  //
609  //
610  // METHOD NAME : MediaCD::getDirInfo
611  // METHOD TYPE : PMError
612  //
613  // DESCRIPTION : Asserted that media is attached and retlist is empty.
614  //
615  void MediaCD::getDirInfo( std::list<std::string> & retlist,
616  const Pathname & dirname, bool dots ) const
617  {
618  MediaHandler::getDirInfo( retlist, dirname, dots );
619  }
620 
622  //
623  //
624  // METHOD NAME : MediaCD::getDirInfo
625  // METHOD TYPE : PMError
626  //
627  // DESCRIPTION : Asserted that media is attached and retlist is empty.
628  //
629  void MediaCD::getDirInfo( filesystem::DirContent & retlist, const Pathname & dirname, bool dots ) const
630  {
631  MediaHandler::getDirInfo( retlist, dirname, dots );
632  }
633 
634 
635  bool MediaCD::getDoesFileExist( const Pathname & filename ) const
636  {
637  return MediaHandler::getDoesFileExist( filename );
638  }
639 
640 
642  {
643  if (_devices.size() == 0)
644  return false;
645  else if (_lastdev_tried < 0)
646  return true;
647 
648  return (unsigned) _lastdev_tried < _devices.size() - 1;
649  }
650 
651 
652  void MediaCD::getDetectedDevices( std::vector<std::string> & devices, unsigned int & index ) const
653  {
654  if ( ! devices.empty() )
655  devices.clear();
656 
657  if ( _devices.empty() )
658  // This also fills the _devices list on demand
659  detectDevices( _url.getScheme() == "dvd" ? true : false );
660 
661  for ( const auto & it : _devices )
662  devices.push_back( it.name );
663 
664  index = ( _lastdev >= 0 ? (unsigned)_lastdev : 0 );
665 
666  MIL << "got " << devices.size() << " detected devices, current: "
667  << (index < devices.size() ? devices[index] : "<none>")
668  << "(" << index << ")" << endl;
669  }
670 
671  } // namespace media
673 } // namespace zypp
std::string getScheme() const
Returns the scheme name of the URL.
Definition: Url.cc:533
std::string asString(const Patch::Category &obj)
Definition: Patch.cc:122
Attach point of a media source.
Definition: MediaSource.h:105
#define MIL
Definition: Logger.h:96
const std::string & mountError() const
Interface to the mount program.
Definition: mount.h:74
virtual void releaseFrom(const std::string &ejectDev) override
Call concrete handler to release the media.
Definition: MediaCD.cc:479
const Pathname & path() const
Return current Pathname.
Definition: PathInfo.h:246
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:428
Describes a resource file located on a medium.
virtual void getDir(const Pathname &dirname, bool recurse_r) const =0
Call concrete handler to provide directory content (not recursive!) below attach point.
AttachedMedia attachedMedia() const
Returns the attached media.
MediaCD(const Url &url_r, const Pathname &attach_point_hint_r)
Definition: MediaCD.cc:130
zypp::RW_pointer< MediaSource > MediaSourceRef
Definition: MediaSource.h:124
unsigned int maj_nr
A major number if source is a device.
Definition: MediaSource.h:89
void setAttachPoint(const Pathname &path, bool temp)
Set a new attach point.
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28
bool isUseableAttachPoint(const Pathname &path, bool mtab=true) const
Ask media manager, if the specified path is already used as attach point or if there are another atta...
std::list< MediaSource > DeviceList
Definition: MediaCD.h:31
std::string name
A media handler specific source name.
Definition: MediaSource.h:92
virtual void getDir(const Pathname &dirname, bool recurse_r) const override
Call concrete handler to provide directory content (not recursive!) below attach point.
Definition: MediaCD.cc:602
unsigned int devMinor() const
Definition: PathInfo.cc:251
bool checkAttached(bool matchMountFs) const
Check actual mediaSource attachment against the current mount table of the system.
#define ERR
Definition: Logger.h:98
void mount(const std::string &source, const std::string &target, const std::string &filesystem, const std::string &options, const Environment &environment=Environment())
mount device
Definition: mount.cc:62
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:440
static bool openTray(const std::string &device_r)
Definition: MediaCD.cc:177
AttachPointRef attachPoint
Definition: MediaSource.h:145
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \, const Trim trim_r=NO_TRIM)
Split line_r into words.
Definition: String.h:531
std::string asString() const
Returns a default string representation of the Url object.
Definition: Url.cc:497
std::string getQueryParam(const std::string &param, EEncoding eflag=zypp::url::E_DECODED) const
Return the value for the specified query parameter.
Definition: Url.cc:660
MediaSourceRef mediaSource
Definition: MediaSource.h:144
Abstract base class for &#39;physical&#39; MediaHandler like MediaCD, etc.
Definition: MediaHandler.h:51
A simple structure containing references to a media source and its attach point.
Definition: MediaSource.h:133
const Url _url
Url to handle.
Definition: MediaHandler.h:113
void setMediaSource(const MediaSourceRef &ref)
Set new media source reference.
const std::string & asString() const
String representation.
Definition: Pathname.h:91
Just inherits Exception to separate media exceptions.
DeviceList detectDevices(bool supportingDVD) const
Definition: MediaCD.cc:194
#define WAR
Definition: Logger.h:97
virtual void forceEject(const std::string &ejectDev) override
Call concrete handler to physically eject the media (i.e.
Definition: MediaCD.cc:521
virtual void attachTo(bool next=false) override
Call concrete handler to attach the media.
Definition: MediaCD.cc:270
std::list< DirEntry > DirContent
Returned by readdir.
Definition: PathInfo.h:518
DeviceList _devices
list of devices to try to mount
Definition: MediaCD.h:33
void removeAttachPoint()
Remove unused attach point.
Media source internally used by MediaManager and MediaHandler.
Definition: MediaSource.h:36
virtual bool hasMoreDevices() override
Check if the media has one more device available for attach(true).
Definition: MediaCD.cc:641
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:436
static bool closeTray(const std::string &device_r)
Definition: cdtools.cc:86
Manages access to the &#39;physical&#39; media, e.g CDROM drives, Disk volumes, directory trees...
Definition: MediaManager.h:453
virtual void getDirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const override
Call concrete handler to provide a content list of directory on media via retlist.
Definition: MediaCD.cc:615
void forceRelaseAllMedia(bool matchMountFs)
Call to this function will try to release all media matching the currenlty attached media source...
virtual void getDirInfo(std::list< std::string > &retlist, const Pathname &dirname, bool dots=true) const =0
Call concrete handler to provide a content list of directory on media via retlist.
virtual bool getDoesFileExist(const Pathname &filename) const =0
check if a file exists
AttachedMedia findAttachedMedia(const MediaSourceRef &media) const
Ask the media manager if specified media source is already attached.
virtual bool getDoesFileExist(const Pathname &filename) const override
check if a file exists
Definition: MediaCD.cc:635
Base class for Exception.
Definition: Exception.h:145
Pathname attachPoint() const
Return the currently used attach point.
Url url() const
Url used.
Definition: MediaHandler.h:503
Reference counted access to a Tp object calling a custom Dispose function when the last AutoDispose h...
Definition: AutoDispose.h:93
virtual bool isAttached() const override
True if media is attached.
Definition: MediaCD.cc:578
unsigned int devMajor() const
Definition: PathInfo.cc:241
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
constexpr std::string_view device("device")
const std::string & mountOutput() const
static bool openTray(const std::string &device_r)
Definition: cdtools.cc:33
unsigned int min_nr
A minor number if source is a device.
Definition: MediaSource.h:90
virtual void getDetectedDevices(std::vector< std::string > &devices, unsigned int &index) const override
Fill in a vector of detected ejectable devices and the index of the currently attached device within ...
Definition: MediaCD.cc:652
Pathname createAttachPoint() const
Try to create a default / temporary attach point.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
int _lastdev
number of last successful mounted device in list
Definition: MediaCD.h:36
virtual void getFile(const OnMediaLocation &file) const
Call concrete handler to provide file below attach point.
Url manipulation class.
Definition: Url.h:91
void umount(const std::string &path)
umount device
Definition: mount.cc:117
#define DBG
Definition: Logger.h:95
static bool closeTray(const std::string &device_r)
Definition: MediaCD.cc:188
static std::vector< MountEntry > getMountEntries()
Get current mount entries from /etc/mtab file.
virtual void getFile(const OnMediaLocation &file) const override
Call concrete handler to provide file below attach point.
Definition: MediaCD.cc:590