libzypp  17.25.0
librpmDb.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include "librpm.h"
13 
14 #include <iostream>
15 
16 #include <zypp/base/Logger.h>
17 #include <zypp/PathInfo.h>
21 
22 #undef ZYPP_BASE_LOGGER_LOGGROUP
23 #define ZYPP_BASE_LOGGER_LOGGROUP "librpmDb"
24 
25 using std::endl;
26 
27 namespace zypp
28 {
29 namespace target
30 {
31 namespace rpm
32 {
34 //
35 // CLASS NAME : librpmDb::D
40 {
41  D & operator=( const D & ); // NO ASSIGNMENT!
42  D ( const D & ); // NO COPY!
43 public:
44 
45  const Pathname _root; // root directory for all operations
46  const Pathname _dbPath; // directory (below root) that contains the rpmdb
47  rpmts _ts; // transaction handle, includes database
48  shared_ptr<RpmException> _error; // database error
49 
50  friend std::ostream & operator<<( std::ostream & str, const D & obj )
51  {
52  str << "{" << obj._error << "(" << obj._root << ")" << obj._dbPath << "}";
53  return str;
54  }
55 
56  D( const Pathname & root_r, const Pathname & dbPath_r, bool readonly_r )
57  : _root ( root_r )
58  , _dbPath( dbPath_r )
59  , _ts ( 0 )
60  {
61  _error.reset();
62  // set %_dbpath macro
63  ::addMacro( NULL, "_dbpath", NULL, _dbPath.asString().c_str(), RMIL_CMDLINE );
64 
65  _ts = ::rpmtsCreate();
66  ::rpmtsSetRootDir( _ts, _root.c_str() );
67 
68  // open database (creates a missing one on the fly)
69  int res = ::rpmtsOpenDB( _ts, (readonly_r ? O_RDONLY : O_RDWR ));
70  if ( res )
71  {
72  ERR << "rpmdbOpen error(" << res << "): " << *this << endl;
73  _error = shared_ptr<RpmDbOpenException>(new RpmDbOpenException(_root, _dbPath));
74  rpmtsFree(_ts);
76  return;
77  }
78 
79  DBG << "DBACCESS " << *this << endl;
80  }
81 
82  ~D()
83  {
84  if ( _ts )
85  {
86  ::rpmtsFree(_ts);
87  }
88  }
89 };
90 
92 
94 //
95 // CLASS NAME : librpmDb (ststic interface)
96 //
98 
100 // NOTE: Former variable, but now locked to "/var/lib/rpm".
101 // A custom dbPath is not actually needed and would only work
102 // reliably if libsolv also supports it.
103 // The protected librpmDb ctor would allow to build a db_const_iterator
104 // to access (ro) a database at a custom location.
105 const Pathname librpmDb::_defaultDbPath( "/var/lib/rpm" );
107 bool librpmDb::_dbBlocked ( true );
108 
110 //
111 //
112 // METHOD NAME : librpmDb::globalInit
113 // METHOD TYPE : bool
114 //
116 {
117  static bool initialized = false;
118 
119  if ( initialized )
120  return true;
121 
122  int rc = ::rpmReadConfigFiles( NULL, NULL );
123  if ( rc )
124  {
125  ERR << "rpmReadConfigFiles returned " << rc << endl;
126  return false;
127  }
128 
129  initialized = true; // Necessary to be able to use exand().
130 
131 #define OUTVAL(n) << " (" #n ":" << expand( "%{" #n "}" ) << ")"
132  MIL << "librpm init done:"
133  OUTVAL(_target)
134  OUTVAL(_dbpath)
135  << endl;
136 #undef OUTVAL
137  return initialized;
138 }
139 
141 //
142 //
143 // METHOD NAME : librpmDb::expand
144 // METHOD TYPE : std::string
145 //
146 std::string librpmDb::expand( const std::string & macro_r )
147 {
148  if ( ! globalInit() )
149  return macro_r; // unexpanded
150 
151  char * val = ::rpmExpand( macro_r.c_str(), NULL );
152  if ( !val )
153  return "";
154 
155  std::string ret( val );
156  free( val );
157  return ret;
158 }
159 
161 //
162 //
163 // METHOD NAME : librpmDb::newLibrpmDb
164 // METHOD TYPE : librpmDb *
165 //
167 {
168  // initialize librpm
169  if ( ! globalInit() )
170  {
172  }
173 
174  // open rpmdb
175  librpmDb * ret = 0;
176  try
177  {
178  ret = new librpmDb( _defaultRoot, _defaultDbPath, /*readonly*/true );
179  }
180  catch (const RpmException & excpt_r)
181  {
182  ZYPP_CAUGHT(excpt_r);
183  delete ret;
184  ret = 0;
185  ZYPP_RETHROW(excpt_r);
186  }
187  return ret;
188 }
189 
191 //
192 //
193 // METHOD NAME : librpmDb::dbAccess
194 // METHOD TYPE : PMError
195 //
196 void librpmDb::dbAccess( const Pathname & root_r )
197 {
198  if ( _defaultDb )
199  {
200  // already accessing a database: switching is not allowed.
201  if ( _defaultRoot == root_r )
202  return;
203  else
205  }
206 
207  // got no database: we could switch to a new one (even if blocked!)
208 
209  if ( root_r.empty() || ! root_r.absolute() )
211 
212  PathInfo pi { root_r / _defaultDbPath };
213  if ( pi.isExist() && ! pi.isDir() ) {
214  RpmInvalidRootException excpt { root_r, _defaultDbPath };
215  excpt.addHistory( str::Str() << pi );
216  ZYPP_THROW(excpt);
217  }
218 
219  _defaultRoot = root_r;
220  MIL << "Set new database location: " << stringPath( _defaultRoot, _defaultDbPath ) << endl;
221 
222  return dbAccess();
223 }
224 
226 //
227 //
228 // METHOD NAME : librpmDb::dbAccess
229 // METHOD TYPE : PMError
230 //
232 {
233  if ( _dbBlocked )
234  {
236  }
237 
238  if ( !_defaultDb )
239  {
240  // get access
242  }
243 }
244 
246 //
247 //
248 // METHOD NAME : librpmDb::dbAccess
249 // METHOD TYPE : PMError
250 //
252 {
253  ptr_r = nullptr;
254  dbAccess();
255  ptr_r = _defaultDb;
256 }
257 
259 //
260 //
261 // METHOD NAME : librpmDb::dbRelease
262 // METHOD TYPE : unsigned
263 //
264 unsigned librpmDb::dbRelease( bool force_r )
265 {
266  if ( !_defaultDb )
267  {
268  return 0;
269  }
270 
271  unsigned outstanding = _defaultDb->refCount() - 1; // refCount can't be 0
272 
273  switch ( outstanding )
274  {
275  default:
276  if ( !force_r )
277  {
278  DBG << "dbRelease: keep access, outstanding " << outstanding << endl;
279  break;
280  }
281  // else fall through:
282  case 0:
283  DBG << "dbRelease: release" << (force_r && outstanding ? "(forced)" : "")
284  << ", outstanding " << outstanding << endl;
285 
286  _defaultDb->_d._error = shared_ptr<RpmAccessBlockedException>(new RpmAccessBlockedException(_defaultDb->_d._root, _defaultDb->_d._dbPath));
287  // tag handle invalid
288  _defaultDb = 0;
289  break;
290  }
291 
292  return outstanding;
293 }
294 
296 //
297 //
298 // METHOD NAME : librpmDb::blockAccess
299 // METHOD TYPE : unsigned
300 //
302 {
303  MIL << "Block access" << endl;
304  _dbBlocked = true;
305  return dbRelease( /*force*/true );
306 }
307 
309 //
310 //
311 // METHOD NAME : librpmDb::unblockAccess
312 // METHOD TYPE : void
313 //
315 {
316  MIL << "Unblock access" << endl;
317  _dbBlocked = false;
318 }
319 
321 //
322 //
323 // METHOD NAME : librpmDb::dumpState
324 // METHOD TYPE : ostream &
325 //
326 std::ostream & librpmDb::dumpState( std::ostream & str )
327 {
328  if ( !_defaultDb )
329  {
330  return str << "[librpmDb " << (_dbBlocked?"BLOCKED":"CLOSED") << " " << stringPath( _defaultRoot, _defaultDbPath ) << "]";
331  }
332  return str << "[" << _defaultDb << "]";
333 }
334 
336 //
337 // CLASS NAME : librpmDb (internal database handle interface (nonstatic))
338 //
340 
342 //
343 //
344 // METHOD NAME : librpmDb::librpmDb
345 // METHOD TYPE : Constructor
346 //
347 // DESCRIPTION :
348 //
349 librpmDb::librpmDb( const Pathname & root_r, const Pathname & dbPath_r, bool readonly_r )
350  : _d( * new D( root_r, dbPath_r, readonly_r ) )
351 {}
352 
354 //
355 //
356 // METHOD NAME : librpmDb::~librpmDb
357 // METHOD TYPE : Destructor
358 //
359 // DESCRIPTION :
360 //
362 {
363  delete &_d;
364 }
365 
367 //
368 //
369 // METHOD NAME : librpmDb::unref_to
370 // METHOD TYPE : void
371 //
372 void librpmDb::unref_to( unsigned refCount_r ) const
373 {
374  if ( refCount_r == 1 )
375  {
376  dbRelease();
377  }
378 }
379 
381 //
382 //
383 // METHOD NAME : librpmDb::root
384 // METHOD TYPE : const Pathname &
385 //
386 const Pathname & librpmDb::root() const
387 {
388  return _d._root;
389 }
390 
392 //
393 //
394 // METHOD NAME : librpmDb::dbPath
395 // METHOD TYPE : const Pathname &
396 //
397 const Pathname & librpmDb::dbPath() const
398 {
399  return _d._dbPath;
400 }
401 
403 //
404 //
405 // METHOD NAME : librpmDb::error
406 // METHOD TYPE : PMError
407 //
408 shared_ptr<RpmException> librpmDb::error() const
409 {
410  return _d._error;
411 }
412 
414 //
415 //
416 // METHOD NAME : librpmDb::empty
417 // METHOD TYPE : bool
418 //
419 bool librpmDb::empty() const
420 {
421  return( valid() && ! *db_const_iterator( this ) );
422 }
423 
425 //
426 //
427 // METHOD NAME : librpmDb::size
428 // METHOD TYPE : unsigned
429 //
430 unsigned librpmDb::size() const
431 {
432  unsigned count = 0;
433  if ( valid() )
434  {
435  db_const_iterator it( this );
436  for ( db_const_iterator it( this ); *it; ++it )
437  ++count;
438  }
439  return count;
440 }
441 
443 //
444 //
445 // METHOD NAME : librpmDb::dont_call_it
446 // METHOD TYPE : void *
447 //
449 {
450  return rpmtsGetRdb(_d._ts);
451 }
452 
454 //
455 //
456 // METHOD NAME : librpmDb::dumpOn
457 // METHOD TYPE : ostream &
458 //
459 // DESCRIPTION :
460 //
461 std::ostream & librpmDb::dumpOn( std::ostream & str ) const
462 {
464  return str;
465 }
466 
468 //
469 // CLASS NAME : librpmDb::db_const_iterator::D
474 {
475  D & operator=( const D & ); // NO ASSIGNMENT!
476  D ( const D & ); // NO COPY!
477 public:
478 
480  shared_ptr<RpmException> _dberr;
481 
483  rpmdbMatchIterator _mi;
484 
486  : _dbptr( dbptr_r )
487  , _mi( 0 )
488  {
489  if ( !_dbptr )
490  {
491  try
492  {
494  }
495  catch (const RpmException & excpt_r)
496  {
497  ZYPP_CAUGHT(excpt_r);
498  }
499  if ( !_dbptr )
500  {
501  WAR << "No database access: " << _dberr << endl;
502  }
503  }
504  else
505  {
506  destroy(); // Checks whether _dbptr still valid
507  }
508  }
509 
510  ~D()
511  {
512  if ( _mi )
513  {
514  ::rpmdbFreeIterator( _mi );
515  }
516  }
517 
522  bool create( int rpmtag, const void * keyp = NULL, size_t keylen = 0 )
523  {
524  destroy();
525  if ( ! _dbptr )
526  return false;
527  _mi = ::rpmtsInitIterator( _dbptr->_d._ts, rpmTag(rpmtag), keyp, keylen );
528  return _mi;
529  }
530 
535  bool destroy()
536  {
537  if ( _mi )
538  {
539  _mi = ::rpmdbFreeIterator( _mi );
540  _hptr = 0;
541  }
542  if ( _dbptr && _dbptr->error() )
543  {
544  _dberr = _dbptr->error();
545  WAR << "Lost database access: " << _dberr << endl;
546  _dbptr = 0;
547  }
548  return false;
549  }
550 
555  bool advance()
556  {
557  if ( !_mi )
558  return false;
559  Header h = ::rpmdbNextIterator( _mi );
560  if ( ! h )
561  {
562  destroy();
563  return false;
564  }
565  _hptr = new RpmHeader( h );
566  return true;
567  }
568 
572  bool init( int rpmtag, const void * keyp = NULL, size_t keylen = 0 )
573  {
574  if ( ! create( rpmtag, keyp, keylen ) )
575  return false;
576  return advance();
577  }
578 
583  bool set( int off_r )
584  {
585  if ( ! create( RPMDBI_PACKAGES ) )
586  return false;
587 #warning TESTCASE: rpmdbAppendIterator and (non)sequential access?
588 #ifdef RPMFILEITERMAX // since rpm.4.12
589  ::rpmdbAppendIterator( _mi, (const unsigned *)&off_r, 1 );
590 #else
591  ::rpmdbAppendIterator( _mi, &off_r, 1 );
592 #endif
593  return advance();
594  }
595 
596  unsigned offset()
597  {
598  return( _mi ? ::rpmdbGetIteratorOffset( _mi ) : 0 );
599  }
600 
601  int size()
602  {
603  if ( !_mi )
604  return 0;
605  int ret = ::rpmdbGetIteratorCount( _mi );
606 #warning TESTCASE: rpmdbGetIteratorCount returns 0 on sequential access?
607  return( ret ? ret : -1 ); // -1: sequential access
608  }
609 };
610 
612 
614 //
615 // CLASS NAME : librpmDb::Ptr::db_const_iterator
616 //
618 
620 //
621 //
622 // METHOD NAME : librpmDb::db_const_iterator::db_iterator
623 // METHOD TYPE : Constructor
624 //
626  : _d( * new D( dbptr_r ) )
627 {
628  findAll();
629 }
630 
632 //
633 //
634 // METHOD NAME : librpmDb::db_const_iterator::~db_const_iterator
635 // METHOD TYPE : Destructor
636 //
638 {
639  delete &_d;
640 }
641 
643 //
644 //
645 // METHOD NAME : librpmDb::db_const_iterator::operator++
646 // METHOD TYPE : void
647 //
649 {
650  _d.advance();
651 }
652 
654 //
655 //
656 // METHOD NAME : librpmDb::db_const_iterator::dbHdrNum
657 // METHOD TYPE : unsigned
658 //
660 {
661  return _d.offset();
662 }
663 
665 //
666 //
667 // METHOD NAME : librpmDb::db_const_iterator::operator*
668 // METHOD TYPE : const RpmHeader::constPtr &
669 //
671 {
672  return _d._hptr;
673 }
674 
676 //
677 //
678 // METHOD NAME : librpmDb::db_const_iterator::dbError
679 // METHOD TYPE : PMError
680 //
681 shared_ptr<RpmException> librpmDb::db_const_iterator::dbError() const
682 {
683  if ( _d._dbptr )
684  return _d._dbptr->error();
685 
686  return _d._dberr;
687 }
688 
689 /******************************************************************
690 **
691 **
692 ** FUNCTION NAME : operator<<
693 ** FUNCTION TYPE : ostream &
694 */
695 std::ostream & operator<<( std::ostream & str, const librpmDb::db_const_iterator & obj )
696 {
697  str << "db_const_iterator(" << obj._d._dbptr
698  << " Size:" << obj._d.size()
699  << " HdrNum:" << obj._d.offset()
700  << ")";
701  return str;
702 }
703 
705 //
706 //
707 // METHOD NAME : librpmDb::db_const_iterator::findAll
708 // METHOD TYPE : bool
709 //
711 {
712  return _d.init( RPMDBI_PACKAGES );
713 }
714 
716 //
717 //
718 // METHOD NAME : librpmDb::db_const_iterator::findByFile
719 // METHOD TYPE : bool
720 //
721 bool librpmDb::db_const_iterator::findByFile( const std::string & file_r )
722 {
723  return _d.init( RPMTAG_BASENAMES, file_r.c_str() );
724 }
725 
727 //
728 //
729 // METHOD NAME : librpmDb::db_const_iterator::findByProvides
730 // METHOD TYPE : bool
731 //
732 bool librpmDb::db_const_iterator::findByProvides( const std::string & tag_r )
733 {
734  return _d.init( RPMTAG_PROVIDENAME, tag_r.c_str() );
735 }
736 
738 //
739 //
740 // METHOD NAME : librpmDb::db_const_iterator::findByRequiredBy
741 // METHOD TYPE : bool
742 //
743 bool librpmDb::db_const_iterator::findByRequiredBy( const std::string & tag_r )
744 {
745  return _d.init( RPMTAG_REQUIRENAME, tag_r.c_str() );
746 }
747 
749 //
750 //
751 // METHOD NAME : librpmDb::db_const_iterator::findByConflicts
752 // METHOD TYPE : bool
753 //
754 bool librpmDb::db_const_iterator::findByConflicts( const std::string & tag_r )
755 {
756  return _d.init( RPMTAG_CONFLICTNAME, tag_r.c_str() );
757 }
758 
760 //
761 //
762 // METHOD NAME : librpmDb::findByName
763 // METHOD TYPE : bool
764 //
765 bool librpmDb::db_const_iterator::findByName( const std::string & name_r )
766 {
767  return _d.init( RPMTAG_NAME, name_r.c_str() );
768 }
769 
771 //
772 //
773 // METHOD NAME : librpmDb::db_const_iterator::findPackage
774 // METHOD TYPE : bool
775 //
776 bool librpmDb::db_const_iterator::findPackage( const std::string & name_r )
777 {
778  if ( ! _d.init( RPMTAG_NAME, name_r.c_str() ) )
779  return false;
780 
781  if ( _d.size() == 1 )
782  return true;
783 
784  // check installtime on multiple entries
785  int match = 0;
786  time_t itime = 0;
787  for ( ; operator*(); operator++() )
788  {
789  if ( operator*()->tag_installtime() > itime )
790  {
791  match = _d.offset();
792  itime = operator*()->tag_installtime();
793  }
794  }
795 
796  return _d.set( match );
797 }
798 
800 //
801 //
802 // METHOD NAME : librpmDb::db_const_iterator::findPackage
803 // METHOD TYPE : bool
804 //
805 bool librpmDb::db_const_iterator::findPackage( const std::string & name_r, const Edition & ed_r )
806 {
807  if ( ! _d.init( RPMTAG_NAME, name_r.c_str() ) )
808  return false;
809 
810  for ( ; operator*(); operator++() )
811  {
812  if ( ed_r == operator*()->tag_edition() )
813  {
814  int match = _d.offset();
815  return _d.set( match );
816  }
817  }
818 
819  return _d.destroy();
820 }
821 
823 //
824 //
825 // METHOD NAME : librpmDb::db_const_iterator::findPackage
826 // METHOD TYPE : bool
827 //
829 {
830  if ( ! which_r )
831  return _d.destroy();
832 
833  return findPackage( which_r->name(), which_r->edition() );
834 }
835 
836 } // namespace rpm
837 } // namespace target
838 } // namespace zypp
zypp::target::rpm::librpmDb::dumpOn
virtual std::ostream & dumpOn(std::ostream &str) const
Dump debug info.
Definition: librpmDb.cc:461
zypp::target::rpm::librpmDb::_dbBlocked
static bool _dbBlocked
Whether access is blocked (no _defaultDb will be available).
Definition: librpmDb.h:84
PathInfo.h
zypp::target::rpm::librpmDb::db_const_iterator::D::advance
bool advance()
Advance to the first/next header in iterator.
Definition: librpmDb.cc:555
zypp::target::rpm::librpmDb::D
librpmDb internal database handle
Definition: librpmDb.cc:39
std::dumpOn
std::ostream & dumpOn(std::ostream &str, const zypp::shared_ptr< void > &obj)
Definition: PtrTypes.h:151
zypp::filesystem::Pathname::absolute
bool absolute() const
Test for an absolute path.
Definition: Pathname.h:116
zypp::target::rpm::librpmDb::db_const_iterator::findByRequiredBy
bool findByRequiredBy(const std::string &tag_r)
Reset to iterate all packages that require a certain tag.
Definition: librpmDb.cc:742
zypp::target::rpm::librpmDb::valid
bool valid() const
Definition: librpmDb.h:284
RpmHeader.h
zypp::target::rpm::librpmDb::db_const_iterator::D::set
bool set(int off_r)
Create an itertator that contains the database entry located at off_r, and advance to the 1st header.
Definition: librpmDb.cc:583
zypp::target::rpm::librpmDb::_defaultDb
static librpmDb::constPtr _defaultDb
Current rpmdb handle.
Definition: librpmDb.h:79
zypp::target::rpm::librpmDb::db_const_iterator::dbHdrNum
unsigned dbHdrNum() const
Returns the current headers index in database, 0 if no header.
Definition: librpmDb.cc:659
zypp::target::rpm::librpmDb::db_const_iterator::D::init
bool init(int rpmtag, const void *keyp=NULL, size_t keylen=0)
Access a dbindex file and advance to the 1st header.
Definition: librpmDb.cc:572
zypp::target::rpm::librpmDb::globalInit
static bool globalInit()
Initialize lib librpm (read configfiles etc.).
Definition: librpmDb.cc:115
zypp::target::rpm::RpmHeader::constPtr
intrusive_ptr< const RpmHeader > constPtr
Definition: RpmHeader.h:64
MIL
#define MIL
Definition: Logger.h:79
zypp::Edition
Edition represents [epoch:]version[-release]
Definition: Edition.h:60
zypp::target::rpm::librpmDb::db_const_iterator::D::destroy
bool destroy()
Destroy iterator.
Definition: librpmDb.cc:535
ZYPP_THROW
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:392
zypp::Package::constPtr
TraitsType::constPtrType constPtr
Definition: Package.h:38
zypp::target::rpm::librpmDb::db_const_iterator::operator++
void operator++()
Advance to next RpmHeader::constPtr.
Definition: librpmDb.cc:648
zypp::target::rpm::librpmDb::db_const_iterator::findByProvides
bool findByProvides(const std::string &tag_r)
Reset to iterate all packages that provide a certain tag.
Definition: librpmDb.cc:731
RpmException.h
zypp::target::rpm::librpmDb::D::operator<<
friend std::ostream & operator<<(std::ostream &str, const D &obj)
Definition: librpmDb.cc:50
zypp::target::rpm::librpmDb::~librpmDb
virtual ~librpmDb()
Destructor.
Definition: librpmDb.cc:361
zypp::target::rpm::librpmDb::blockAccess
static unsigned blockAccess()
Blocks further access to rpmdb.
Definition: librpmDb.cc:301
zypp::target::rpm::librpmDb::unblockAccess
static void unblockAccess()
Allow access to rpmdb e.g.
Definition: librpmDb.cc:314
zypp::target::rpm::librpmDb::error
shared_ptr< RpmException > error() const
Return any database error.
Definition: librpmDb.cc:408
zypp::target::rpm::librpmDb::db_const_iterator::D::~D
~D()
Definition: librpmDb.cc:510
zypp::target::rpm::librpmDb::D::D
D(const Pathname &root_r, const Pathname &dbPath_r, bool readonly_r)
Definition: librpmDb.cc:56
zypp::filesystem::PathInfo
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
zypp::target::rpm::librpmDb::db_const_iterator::D::_mi
rpmdbMatchIterator _mi
Definition: librpmDb.cc:483
zypp::target::rpm::librpmDb::D::_dbPath
const Pathname _dbPath
Definition: librpmDb.cc:46
zypp::filesystem::Pathname::c_str
const char * c_str() const
String representation.
Definition: Pathname.h:110
zypp::target::rpm::librpmDb::db_const_iterator::D::_dberr
shared_ptr< RpmException > _dberr
Definition: librpmDb.cc:480
zypp::target::rpm::RpmInvalidRootException
Definition: RpmException.h:72
Logger.h
WAR
#define WAR
Definition: Logger.h:80
zypp::target::rpm::librpmDb::db_const_iterator::D::create
bool create(int rpmtag, const void *keyp=NULL, size_t keylen=0)
Let iterator access a dbindex file.
Definition: librpmDb.cc:522
zypp::target::rpm::librpmDb::empty
bool empty() const
Definition: librpmDb.cc:419
zypp::target::rpm::RpmDbOpenException
Definition: RpmException.h:161
zypp::target::rpm::librpmDb::_d
D & _d
Definition: librpmDb.h:242
zypp::target::rpm::librpmDb::dbAccess
static void dbAccess()
Access the database at the current default location.
Definition: librpmDb.cc:231
zypp::target::rpm::librpmDb::size
unsigned size() const
Definition: librpmDb.cc:430
zypp::target::rpm::librpmDb::stringPath
static std::string stringPath(const Pathname &root_r, const Pathname &sub_r)
Definition: librpmDb.h:127
zypp::target::rpm::librpmDb::db_const_iterator::D
Definition: librpmDb.cc:473
zypp::target::rpm::librpmDb::D::D
D(const D &)
zypp::target::rpm::RpmException
Just inherits Exception to separate media exceptions.
Definition: RpmException.h:37
zypp
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
zypp::target::rpm::librpmDb::dont_call_it
void * dont_call_it() const
Dont call it ;) It's for development and testing only.
Definition: librpmDb.cc:448
zypp::target::rpm::librpmDb::D::_error
shared_ptr< RpmException > _error
Definition: librpmDb.cc:48
zypp::target::rpm::librpmDb::db_const_iterator::findAll
bool findAll()
Reset to iterate all packages.
Definition: librpmDb.cc:709
zypp::target::rpm::librpmDb::db_const_iterator::D::size
int size()
Definition: librpmDb.cc:601
librpmDb.h
zypp::str::Str
Convenient building of std::string via std::ostringstream Basically a std::ostringstream autoconverti...
Definition: String.h:208
zypp::target::rpm::librpmDb::db_const_iterator::findByConflicts
bool findByConflicts(const std::string &tag_r)
Reset to iterate all packages that conflict with a certain tag.
Definition: librpmDb.cc:753
zypp::target::rpm::librpmDb::unref_to
virtual void unref_to(unsigned refCount_r) const
Trigger from Rep, after refCount was decreased.
Definition: librpmDb.cc:372
zypp::target::rpm::librpmDb::librpmDb
librpmDb(const Pathname &root_r, const Pathname &dbPath_r, bool readonly_r)
Private constructor! librpmDb objects are to be created via static interface only.
Definition: librpmDb.cc:349
zypp::target::rpm::GlobalRpmInitException
Definition: RpmException.h:57
zypp::target::rpm::librpmDb::db_const_iterator
Subclass to retrieve database content.
Definition: librpmDb.h:322
zypp::target::rpm::librpmDb::db_const_iterator::findByName
bool findByName(const std::string &name_r)
Reset to iterate all packages with a certain name.
Definition: librpmDb.cc:764
zypp::target::rpm::librpmDb::_defaultDbPath
static const Pathname _defaultDbPath
Current directory (below root) that contains the rpmdb.
Definition: librpmDb.h:74
zypp::target::rpm::librpmDb::db_const_iterator::findPackage
bool findPackage(const std::string &name_r)
Find package by name.
Definition: librpmDb.cc:775
zypp::target::rpm::librpmDb::D::_ts
rpmts _ts
Definition: librpmDb.cc:47
zypp::target::rpm::librpmDb::db_const_iterator::D::offset
unsigned offset()
Definition: librpmDb.cc:596
ZYPP_RETHROW
#define ZYPP_RETHROW(EXCPT)
Drops a logline and rethrows, updating the CodeLocation.
Definition: Exception.h:400
zypp::target::rpm::librpmDb::db_const_iterator::~db_const_iterator
~db_const_iterator()
Destructor.
Definition: librpmDb.cc:637
zypp::target::rpm::librpmDb::db_const_iterator::D::D
D(const D &)
zypp::target::rpm::librpmDb::db_const_iterator::operator*
const RpmHeader::constPtr & operator*() const
Returns the current RpmHeader::constPtr or NULL, if no more entries available.
Definition: librpmDb.cc:670
zypp::target::rpm::librpmDb::_defaultRoot
static Pathname _defaultRoot
Current root directory for all operations.
Definition: librpmDb.h:68
zypp::target::rpm::librpmDb::constPtr
intrusive_ptr< const librpmDb > constPtr
Definition: librpmDb.h:42
zypp::filesystem::Pathname::empty
bool empty() const
Test for an empty path.
Definition: Pathname.h:114
zypp::target::rpm::librpmDb::db_const_iterator::db_const_iterator
db_const_iterator(const db_const_iterator &)
zypp::target::rpm::librpmDb::D::~D
~D()
Definition: librpmDb.cc:82
zypp::filesystem::Pathname
Pathname.
Definition: Pathname.h:44
zypp::target::rpm::RpmAccessBlockedException
Definition: RpmException.h:102
ERR
#define ERR
Definition: Logger.h:81
zypp::target::rpm::librpmDb::D::_root
const Pathname _root
Definition: librpmDb.cc:45
DBG
#define DBG
Definition: Logger.h:78
zypp::target::rpm::librpmDb::dumpState
static std::ostream & dumpState(std::ostream &str)
Dump debug info.
Definition: librpmDb.cc:326
zypp::target::rpm::librpmDb::dbRelease
static unsigned dbRelease(bool force_r=false)
If there are no outstanding references to the database (e.g.
Definition: librpmDb.cc:264
zypp::target::rpm::librpmDb::dbPath
const Pathname & dbPath() const
Definition: librpmDb.cc:397
zypp::target::rpm::librpmDb::db_const_iterator::D::_dbptr
librpmDb::constPtr _dbptr
Definition: librpmDb.cc:479
librpm.h
zypp::target::rpm::librpmDb::D::operator=
D & operator=(const D &)
zypp::target::rpm::librpmDb::db_const_iterator::dbError
shared_ptr< RpmException > dbError() const
Return any database error.
Definition: librpmDb.cc:681
zypp::target::rpm::librpmDb::db_const_iterator::findByFile
bool findByFile(const std::string &file_r)
Reset to iterate all packages that own a certain file.
Definition: librpmDb.cc:720
zypp::target::rpm::librpmDb
Manage access to librpm database.
Definition: librpmDb.h:38
zypp::target::rpm::librpmDb::expand
static std::string expand(const std::string &macro_r)
Definition: librpmDb.cc:146
str
String related utilities and Regular expression matching.
ZYPP_CAUGHT
#define ZYPP_CAUGHT(EXCPT)
Drops a logline telling the Exception was caught (in order to handle it).
Definition: Exception.h:396
zypp::target::rpm::librpmDb::db_const_iterator::D::operator=
D & operator=(const D &)
zypp::target::rpm::RpmHeader
Wrapper class for rpm header struct.
Definition: RpmHeader.h:60
zypp::filesystem::Pathname::asString
const std::string & asString() const
String representation.
Definition: Pathname.h:91
zypp::target::rpm::librpmDb::root
const Pathname & root() const
Definition: librpmDb.cc:386
zypp::target::rpm::librpmDb::db_const_iterator::D::D
D(librpmDb::constPtr dbptr_r)
Definition: librpmDb.cc:485
zypp::base::ReferenceCounted::operator<<
friend std::ostream & operator<<(std::ostream &str, const ReferenceCounted &obj)
Stream output via dumpOn.
OUTVAL
#define OUTVAL(n)
zypp::target::rpm::librpmDb::newLibrpmDb
static librpmDb * newLibrpmDb()
For internal use.
Definition: librpmDb.cc:166
zypp::target::rpm::librpmDb::db_const_iterator::D::_hptr
RpmHeader::constPtr _hptr
Definition: librpmDb.cc:482
zypp::target::rpm::librpmDb::db_const_iterator::_d
D & _d
Definition: librpmDb.h:334
zypp::target::rpm::RpmDbAlreadyOpenException
Definition: RpmException.h:179