libzypp  16.15.6
RepoInfo.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <iostream>
13 #include <vector>
14 
15 #include "zypp/base/LogTools.h"
18 
19 #include "zypp/RepoInfo.h"
20 #include "zypp/Glob.h"
21 #include "zypp/TriBool.h"
22 #include "zypp/Pathname.h"
23 #include "zypp/ZConfig.h"
25 #include "zypp/ExternalProgram.h"
26 #include "zypp/media/MediaAccess.h"
27 
28 #include "zypp/base/IOStream.h"
29 #include "zypp/base/InputStream.h"
30 #include "zypp/parser/xml/Reader.h"
31 
32 using std::endl;
33 using zypp::xml::escape;
34 
36 namespace zypp
37 {
38 
40  //
41  // CLASS NAME : RepoInfo::Impl
42  //
45  {
46  Impl()
47  : _rawGpgCheck( indeterminate )
48  , _rawRepoGpgCheck( indeterminate )
49  , _rawPkgGpgCheck( indeterminate )
50  , _validRepoSignature( indeterminate )
51  , keeppackages(indeterminate)
53  , type(repo::RepoType::NONE_e)
54  , emptybaseurls(false)
55  {}
56 
58  {}
59 
60  public:
61  static const unsigned defaultPriority = 99;
62  static const unsigned noPriority = unsigned(-1);
63 
64  void setProbedType( const repo::RepoType & t ) const
65  {
67  && t != repo::RepoType::NONE )
68  {
69  // lazy init!
70  const_cast<Impl*>(this)->type = t;
71  }
72  }
73 
74  public:
76  Pathname licenseTgz() const
77  {
78  Pathname ret;
79  if ( !metadataPath().empty() )
80  {
82  g.add( metadataPath() / path / "repodata/*license.tar.gz" );
83  if ( g.empty() )
84  g.add( metadataPath() / path / "license.tar.gz" );
85 
86  if ( !g.empty() )
87  ret = *g.begin();
88  }
89  return ret;
90  }
91 
93  {
94  const Url & mlurl( _mirrorListUrl.transformed() ); // Variables replaced!
95  if ( _baseUrls.empty() && ! mlurl.asString().empty() )
96  {
97  emptybaseurls = true;
98  DBG << "MetadataPath: " << metadataPath() << endl;
100  _baseUrls.raw().insert( _baseUrls.raw().end(), rmurls.getUrls().begin(), rmurls.getUrls().end() );
101  }
102  return _baseUrls;
103  }
104 
106  { return _baseUrls; }
107 
108  bool baseurl2dump() const
109  { return !emptybaseurls && !_baseUrls.empty(); }
110 
111 
113  { return _gpgKeyUrls; }
114 
116  { return _gpgKeyUrls; }
117 
118 
119  const std::set<std::string> & contentKeywords() const
120  { hasContent()/*init if not yet done*/; return _keywords.second; }
121 
122  void addContent( const std::string & keyword_r )
123  { _keywords.second.insert( keyword_r ); if ( ! hasContent() ) _keywords.first = true; }
124 
125  bool hasContent() const
126  {
127  if ( !_keywords.first && ! metadataPath().empty() )
128  {
129  // HACK directly check master index file until RepoManager offers
130  // some content probing and zypper uses it.
132  MIL << "Empty keywords...." << metadataPath() << endl;
133  Pathname master;
134  if ( PathInfo( (master=metadataPath()/"/repodata/repomd.xml") ).isFile() )
135  {
136  //MIL << "GO repomd.." << endl;
137  xml::Reader reader( master );
138  while ( reader.seekToNode( 2, "content" ) )
139  {
140  _keywords.second.insert( reader.nodeText().asString() );
141  reader.seekToEndNode( 2, "content" );
142  }
143  _keywords.first = true; // valid content in _keywords even if empty
144  }
145  else if ( PathInfo( (master=metadataPath()/"/content") ).isFile() )
146  {
147  //MIL << "GO content.." << endl;
148  iostr::forEachLine( InputStream( master ),
149  [this]( int num_r, std::string line_r )->bool
150  {
151  if ( str::startsWith( line_r, "REPOKEYWORDS" ) )
152  {
153  std::vector<std::string> words;
154  if ( str::split( line_r, std::back_inserter(words) ) > 1
155  && words[0].length() == 12 /*"REPOKEYWORDS"*/ )
156  {
157  this->_keywords.second.insert( ++words.begin(), words.end() );
158  }
159  return true; // mult. occurrances are ok.
160  }
161  return( ! str::startsWith( line_r, "META " ) ); // no need to parse into META section.
162  } );
163  _keywords.first = true; // valid content in _keywords even if empty
164  }
166  }
167  return _keywords.first;
168  }
169 
170  bool hasContent( const std::string & keyword_r ) const
171  { return( hasContent() && _keywords.second.find( keyword_r ) != _keywords.second.end() ); }
172 
178  {
179  if ( ! indeterminate(_validRepoSignature) )
180  return _validRepoSignature;
181  // check metadata:
182  if ( ! metadataPath().empty() )
183  {
184  // A missing ".repo_gpgcheck" might be plaindir(no Downloader) or not yet refreshed signed repo!
185  TriBool linkval = triBoolFromPath( metadataPath() / ".repo_gpgcheck" );
186  return linkval;
187  }
188  return indeterminate;
189  }
190 
192  {
193  if ( PathInfo(metadataPath()).isDir() )
194  {
195  Pathname gpgcheckFile( metadataPath() / ".repo_gpgcheck" );
196  if ( PathInfo(gpgcheckFile).isExist() )
197  {
198  TriBool linkval( indeterminate );
199  if ( triBoolFromPath( gpgcheckFile, linkval ) && linkval == value_r )
200  return; // existing symlink fits value_r
201  else
202  filesystem::unlink( gpgcheckFile ); // will write a new one
203  }
204  filesystem::symlink( asString(value_r), gpgcheckFile );
205  }
206  _validRepoSignature = value_r;
207  }
208 
214  {
215  TriBool linkval( true ); // want to see it being switched to indeterminate
216  return triBoolFromPath( metadataPath() / ".repo_gpgcheck", linkval ) && indeterminate(linkval);
217  }
218 
219  bool triBoolFromPath( const Pathname & path_r, TriBool & ret_r ) const
220  {
221  static const Pathname truePath( "true" );
222  static const Pathname falsePath( "false" );
223  static const Pathname indeterminatePath( "indeterminate" );
224 
225  // Quiet readlink;
226  static const ssize_t bufsiz = 63;
227  static char buf[bufsiz+1];
228  ssize_t ret = ::readlink( path_r.c_str(), buf, bufsiz );
229  buf[ret == -1 ? 0 : ret] = '\0';
230 
231  Pathname linkval( buf );
232 
233  bool known = true;
234  if ( linkval == truePath )
235  ret_r = true;
236  else if ( linkval == falsePath )
237  ret_r = false;
238  else if ( linkval == indeterminatePath )
239  ret_r = indeterminate;
240  else
241  known = false;
242  return known;
243  }
244 
245  TriBool triBoolFromPath( const Pathname & path_r ) const
246  { TriBool ret(indeterminate); triBoolFromPath( path_r, ret ); return ret; }
247 
249 
250  private:
254 
255  public:
256  TriBool rawGpgCheck() const { return _rawGpgCheck; }
259 
260  void rawGpgCheck( TriBool val_r ) { _rawGpgCheck = val_r; }
261  void rawRepoGpgCheck( TriBool val_r ) { _rawRepoGpgCheck = val_r; }
262  void rawPkgGpgCheck( TriBool val_r ) { _rawPkgGpgCheck = val_r; }
263 
264  bool cfgGpgCheck() const
265  { return indeterminate(_rawGpgCheck) ? ZConfig::instance().gpgCheck() : (bool)_rawGpgCheck; }
267  { return indeterminate(_rawGpgCheck) && indeterminate(_rawRepoGpgCheck) ? ZConfig::instance().repoGpgCheck() : _rawRepoGpgCheck; }
269  { return indeterminate(_rawGpgCheck) && indeterminate(_rawPkgGpgCheck) ? ZConfig::instance().pkgGpgCheck() : _rawPkgGpgCheck; }
270 
271  private:
273  public:
278  Pathname path;
279  std::string service;
280  std::string targetDistro;
281 
282  void metadataPath( Pathname new_r )
283  { _metadataPath = std::move( new_r ); }
284 
285  void packagesPath( Pathname new_r )
286  { _packagesPath = std::move( new_r ); }
287 
289  { return str::hasSuffix( _metadataPath.asString(), "/%AUTO%" ); }
290 
291  Pathname metadataPath() const
292  {
293  if ( usesAutoMethadataPaths() )
294  return _metadataPath.dirname() / "%RAW%";
295  return _metadataPath;
296  }
297 
298  Pathname packagesPath() const
299  {
300  if ( _packagesPath.empty() && usesAutoMethadataPaths() )
301  return _metadataPath.dirname() / "%PKG%";
302  return _packagesPath;
303  }
304 
306  mutable bool emptybaseurls;
308 
309  private:
310  Pathname _metadataPath;
311  Pathname _packagesPath;
312 
314  mutable std::pair<FalseBool, std::set<std::string> > _keywords;
315 
317 
318  friend Impl * rwcowClone<Impl>( const Impl * rhs );
320  Impl * clone() const
321  { return new Impl( *this ); }
322  };
324 
326  inline std::ostream & operator<<( std::ostream & str, const RepoInfo::Impl & obj )
327  {
328  return str << "RepoInfo::Impl";
329  }
330 
332  //
333  // CLASS NAME : RepoInfo
334  //
336 
338 
340  : _pimpl( new Impl() )
341  {}
342 
344  {}
345 
346  unsigned RepoInfo::priority() const
347  { return _pimpl->priority; }
348 
350  { return Impl::defaultPriority; }
351 
353  { return Impl::noPriority; }
354 
355  void RepoInfo::setPriority( unsigned newval_r )
356  { _pimpl->priority = newval_r ? newval_r : Impl::defaultPriority; }
357 
358 
359  bool RepoInfo::gpgCheck() const
360  { return _pimpl->cfgGpgCheck(); }
361 
363  { _pimpl->rawGpgCheck( value_r ); }
364 
365  void RepoInfo::setGpgCheck( bool value_r ) // deprecated legacy and for squid
366  { setGpgCheck( TriBool(value_r) ); }
367 
368 
370  { return gpgCheck() || _pimpl->cfgRepoGpgCheck(); }
371 
373  {
374  bool ret = ( gpgCheck() && indeterminate(_pimpl->cfgRepoGpgCheck()) ) || _pimpl->cfgRepoGpgCheck();
375  if ( ret && _pimpl->internalUnsignedConfirmed() ) // relax if unsigned repo was confirmed in the past
376  ret = false;
377  return ret;
378  }
379 
381  { _pimpl->rawRepoGpgCheck( value_r ); }
382 
383 
385  { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && !bool(validRepoSignature())/*enforced*/ ) ; }
386 
388  { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && indeterminate(_pimpl->cfgPkgGpgCheck()) && !bool(validRepoSignature())/*enforced*/ ); }
389 
391  { _pimpl->rawPkgGpgCheck( value_r ); }
392 
393 
394  void RepoInfo::getRawGpgChecks( TriBool & g_r, TriBool & r_r, TriBool & p_r ) const
395  {
396  g_r = _pimpl->rawGpgCheck();
397  r_r = _pimpl->rawRepoGpgCheck();
398  p_r = _pimpl->rawPkgGpgCheck();
399  }
400 
401 
403  {
405  if ( ret && !repoGpgCheck() ) ret = false; // invalidate any old signature if repoGpgCheck is off
406  return ret;
407  }
408 
410  { _pimpl->internalSetValidRepoSignature( value_r ); }
411 
413  namespace
414  {
415  inline bool changeGpgCheckTo( TriBool & lhs, TriBool rhs )
416  { if ( ! sameTriboolState( lhs, rhs ) ) { lhs = rhs; return true; } return false; }
417 
418  inline bool changeGpgCheckTo( TriBool ogpg[3], TriBool g, TriBool r, TriBool p )
419  {
420  bool changed = false;
421  if ( changeGpgCheckTo( ogpg[0], g ) ) changed = true;
422  if ( changeGpgCheckTo( ogpg[1], r ) ) changed = true;
423  if ( changeGpgCheckTo( ogpg[2], p ) ) changed = true;
424  return changed;
425  }
426  } // namespace
429  {
430  TriBool ogpg[3]; // Gpg RepoGpg PkgGpg
431  getRawGpgChecks( ogpg[0], ogpg[1], ogpg[2] );
432 
433  bool changed = false;
434  switch ( mode_r )
435  {
436  case GpgCheck::On:
437  changed = changeGpgCheckTo( ogpg, true, indeterminate, indeterminate );
438  break;
439  case GpgCheck::Strict:
440  changed = changeGpgCheckTo( ogpg, true, true, true );
441  break;
443  changed = changeGpgCheckTo( ogpg, true, false, false );
444  break;
446  changed = changeGpgCheckTo( ogpg, true, false, indeterminate );
447  break;
449  changed = changeGpgCheckTo( ogpg, true, indeterminate, false );
450  break;
451  case GpgCheck::Default:
452  changed = changeGpgCheckTo( ogpg, indeterminate, indeterminate, indeterminate );
453  break;
454  case GpgCheck::Off:
455  changed = changeGpgCheckTo( ogpg, false, indeterminate, indeterminate );
456  break;
457  case GpgCheck::indeterminate: // no change
458  break;
459  }
460 
461  if ( changed )
462  {
463  setGpgCheck ( ogpg[0] );
464  setRepoGpgCheck( ogpg[1] );
465  setPkgGpgCheck ( ogpg[2] );
466  }
467  return changed;
468  }
469 
470  void RepoInfo::setMirrorListUrl( const Url & url_r ) // Raw
471  { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = false; }
472 
473  void RepoInfo::setMetalinkUrl( const Url & url_r ) // Raw
474  { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = true; }
475 
477  { _pimpl->gpgKeyUrls().raw().swap( urls ); }
478 
479  void RepoInfo::setGpgKeyUrl( const Url & url_r )
480  {
481  _pimpl->gpgKeyUrls().raw().clear();
482  _pimpl->gpgKeyUrls().raw().push_back( url_r );
483  }
484 
485  void RepoInfo::addBaseUrl( const Url & url_r )
486  {
487  for ( const auto & url : _pimpl->baseUrls().raw() ) // Raw unique!
488  if ( url == url_r )
489  return;
490  _pimpl->baseUrls().raw().push_back( url_r );
491  }
492 
493  void RepoInfo::setBaseUrl( const Url & url_r )
494  {
495  _pimpl->baseUrls().raw().clear();
496  _pimpl->baseUrls().raw().push_back( url_r );
497  }
498 
500  { _pimpl->baseUrls().raw().swap( urls ); }
501 
502  void RepoInfo::setPath( const Pathname &path )
503  { _pimpl->path = path; }
504 
506  { _pimpl->type = t; }
507 
509  { _pimpl->setProbedType( t ); }
510 
511 
512  void RepoInfo::setMetadataPath( const Pathname &path )
513  { _pimpl->metadataPath( path ); }
514 
515  void RepoInfo::setPackagesPath( const Pathname &path )
516  { _pimpl->packagesPath( path ); }
517 
518  void RepoInfo::setKeepPackages( bool keep )
519  { _pimpl->keeppackages = keep; }
520 
521  void RepoInfo::setService( const std::string& name )
522  { _pimpl->service = name; }
523 
526 
528  { return indeterminate(_pimpl->keeppackages) ? false : (bool)_pimpl->keeppackages; }
529 
530  Pathname RepoInfo::metadataPath() const
531  { return _pimpl->metadataPath(); }
532 
533  Pathname RepoInfo::packagesPath() const
534  { return _pimpl->packagesPath(); }
535 
537  { return _pimpl->usesAutoMethadataPaths(); }
538 
540  { return _pimpl->type; }
541 
542  Url RepoInfo::mirrorListUrl() const // Variables replaced!
543  { return _pimpl->_mirrorListUrl.transformed(); }
544 
546  { return _pimpl->_mirrorListUrl.raw(); }
547 
549  { return _pimpl->gpgKeyUrls().empty(); }
550 
552  { return _pimpl->gpgKeyUrls().size(); }
553 
554  RepoInfo::url_set RepoInfo::gpgKeyUrls() const // Variables replaced!
555  { return _pimpl->gpgKeyUrls().transformed(); }
556 
558  { return _pimpl->gpgKeyUrls().raw(); }
559 
560  Url RepoInfo::gpgKeyUrl() const // Variables replaced!
561  { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().transformedBegin() ); }
562 
564  { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().rawBegin() ) ; }
565 
566  RepoInfo::url_set RepoInfo::baseUrls() const // Variables replaced!
567  { return _pimpl->baseUrls().transformed(); }
568 
570  { return _pimpl->baseUrls().raw(); }
571 
572  Pathname RepoInfo::path() const
573  { return _pimpl->path; }
574 
575  std::string RepoInfo::service() const
576  { return _pimpl->service; }
577 
578  std::string RepoInfo::targetDistribution() const
579  { return _pimpl->targetDistro; }
580 
582  { return( _pimpl->baseUrls().empty() ? Url() : *_pimpl->baseUrls().rawBegin() ); }
583 
585  { return _pimpl->baseUrls().transformedBegin(); }
586 
588  { return _pimpl->baseUrls().transformedEnd(); }
589 
591  { return _pimpl->baseUrls().size(); }
592 
594  { return _pimpl->baseUrls().empty(); }
595 
596  bool RepoInfo::baseUrlSet() const
597  { return _pimpl->baseurl2dump(); }
598 
599  const std::set<std::string> & RepoInfo::contentKeywords() const
600  { return _pimpl->contentKeywords(); }
601 
602  void RepoInfo::addContent( const std::string & keyword_r )
603  { _pimpl->addContent( keyword_r ); }
604 
605  bool RepoInfo::hasContent() const
606  { return _pimpl->hasContent(); }
607 
608  bool RepoInfo::hasContent( const std::string & keyword_r ) const
609  { return _pimpl->hasContent( keyword_r ); }
610 
612 
613  bool RepoInfo::hasLicense() const
614  {
615  return !_pimpl->licenseTgz().empty();
616  }
617 
619  {
620  static const std::string noAcceptanceFile = "no-acceptance-needed\n";
621  bool accept = true;
622 
623  const Pathname & licenseTgz( _pimpl->licenseTgz() );
624  if ( licenseTgz.empty() )
625  return false; // no licenses at all
626 
628  cmd.push_back( "tar" );
629  cmd.push_back( "-t" );
630  cmd.push_back( "-z" );
631  cmd.push_back( "-f" );
632  cmd.push_back( licenseTgz.asString() );
633 
635  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
636  {
637  if ( output == noAcceptanceFile )
638  {
639  accept = false;
640  }
641  }
642  MIL << "License for " << name() << " has to be accepted: " << (accept?"true":"false" ) << endl;
643  return accept;
644  }
645 
646  std::string RepoInfo::getLicense( const Locale & lang_r )
647  { return const_cast<const RepoInfo *>(this)->getLicense( lang_r ); }
648 
649  std::string RepoInfo::getLicense( const Locale & lang_r ) const
650  {
651  LocaleSet avlocales( getLicenseLocales() );
652  if ( avlocales.empty() )
653  return std::string();
654 
655  Locale getLang( Locale::bestMatch( avlocales, lang_r ) );
656  if ( !getLang && avlocales.find( Locale::noCode ) == avlocales.end() )
657  {
658  WAR << "License.tar.gz contains no fallback text! " << *this << endl;
659  // Using the fist locale instead of returning no text at all.
660  // So the user might recognize that there is a license, even if he
661  // can't read it.
662  getLang = *avlocales.begin();
663  }
664 
665  // now extract the license file.
666  static const std::string licenseFileFallback( "license.txt" );
667  std::string licenseFile( !getLang ? licenseFileFallback
668  : str::form( "license.%s.txt", getLang.c_str() ) );
669 
671  cmd.push_back( "tar" );
672  cmd.push_back( "-x" );
673  cmd.push_back( "-z" );
674  cmd.push_back( "-O" );
675  cmd.push_back( "-f" );
676  cmd.push_back( _pimpl->licenseTgz().asString() ); // if it not exists, avlocales was empty.
677  cmd.push_back( licenseFile );
678 
679  std::string ret;
681  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
682  {
683  ret += output;
684  }
685  prog.close();
686  return ret;
687  }
688 
690  {
691  const Pathname & licenseTgz( _pimpl->licenseTgz() );
692  if ( licenseTgz.empty() )
693  return LocaleSet();
694 
696  cmd.push_back( "tar" );
697  cmd.push_back( "-t" );
698  cmd.push_back( "-z" );
699  cmd.push_back( "-f" );
700  cmd.push_back( licenseTgz.asString() );
701 
702  LocaleSet ret;
704  for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
705  {
706  static const C_Str license( "license." );
707  static const C_Str dotTxt( ".txt\n" );
708  if ( str::hasPrefix( output, license ) && str::hasSuffix( output, dotTxt ) )
709  {
710  if ( output.size() <= license.size() + dotTxt.size() ) // license.txt
711  ret.insert( Locale() );
712  else
713  ret.insert( Locale( std::string( output.c_str()+license.size(), output.size()- license.size() - dotTxt.size() ) ) );
714  }
715  }
716  prog.close();
717  return ret;
718  }
719 
721 
722  std::ostream & RepoInfo::dumpOn( std::ostream & str ) const
723  {
725  if ( _pimpl->baseurl2dump() )
726  {
727  for ( const auto & url : _pimpl->baseUrls().raw() )
728  {
729  str << "- url : " << url << std::endl;
730  }
731  }
732 
733  // print if non empty value
734  auto strif( [&] ( const std::string & tag_r, const std::string & value_r ) {
735  if ( ! value_r.empty() )
736  str << tag_r << value_r << std::endl;
737  });
738 
739  strif( (_pimpl->_mirrorListForceMetalink ? "- metalink : " : "- mirrorlist : "), rawMirrorListUrl().asString() );
740  strif( "- path : ", path().asString() );
741  str << "- type : " << type() << std::endl;
742  str << "- priority : " << priority() << std::endl;
743 
744  // Yes No Default(Y) Default(N)
745 #define OUTS(T,B) ( indeterminate(T) ? (std::string("D(")+(B?"Y":"N")+")") : ((bool)T?"Y":"N") )
746  str << "- gpgcheck : " << OUTS(_pimpl->rawGpgCheck(),gpgCheck())
747  << " repo" << OUTS(_pimpl->rawRepoGpgCheck(),repoGpgCheck()) << (repoGpgCheckIsMandatory() ? "* ": " " )
748  << "sig" << asString( validRepoSignature(), "?", "Y", "N" )
749  << " pkg" << OUTS(_pimpl->rawPkgGpgCheck(),pkgGpgCheck()) << (pkgGpgCheckIsMandatory() ? "* ": " " )
750  << std::endl;
751 #undef OUTS
752 
753  for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
754  {
755  str << "- gpgkey : " << url << std::endl;
756  }
757 
758  if ( ! indeterminate(_pimpl->keeppackages) )
759  str << "- keeppackages: " << keepPackages() << std::endl;
760 
761  strif( "- service : ", service() );
762  strif( "- targetdistro: ", targetDistribution() );
763  strif( "- filePath: ", filepath().asString() );
764  strif( "- metadataPath: ", metadataPath().asString() );
765  strif( "- packagesPath: ", packagesPath().asString() );
766 
767  return str;
768  }
769 
770  std::ostream & RepoInfo::dumpAsIniOn( std::ostream & str ) const
771  {
772  RepoInfoBase::dumpAsIniOn(str);
773 
774  if ( _pimpl->baseurl2dump() )
775  {
776  str << "baseurl=";
777  std::string indent;
778  for ( const auto & url : _pimpl->baseUrls().raw() )
779  {
780  str << indent << url << endl;
781  if ( indent.empty() ) indent = " "; // "baseurl="
782  }
783  }
784 
785  if ( ! _pimpl->path.empty() )
786  str << "path="<< path() << endl;
787 
788  if ( ! (rawMirrorListUrl().asString().empty()) )
789  str << (_pimpl->_mirrorListForceMetalink ? "metalink=" : "mirrorlist=") << rawMirrorListUrl() << endl;
790 
791  str << "type=" << type().asString() << endl;
792 
793  if ( priority() != defaultPriority() )
794  str << "priority=" << priority() << endl;
795 
796  if ( ! indeterminate(_pimpl->rawGpgCheck()) )
797  str << "gpgcheck=" << (_pimpl->rawGpgCheck() ? "1" : "0") << endl;
798 
799  if ( ! indeterminate(_pimpl->rawRepoGpgCheck()) )
800  str << "repo_gpgcheck=" << (_pimpl->rawRepoGpgCheck() ? "1" : "0") << endl;
801 
802  if ( ! indeterminate(_pimpl->rawPkgGpgCheck()) )
803  str << "pkg_gpgcheck=" << (_pimpl->rawPkgGpgCheck() ? "1" : "0") << endl;
804 
805  {
806  std::string indent( "gpgkey=");
807  for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
808  {
809  str << indent << url << endl;
810  if ( indent[0] != ' ' )
811  indent = " ";
812  }
813  }
814 
815  if (!indeterminate(_pimpl->keeppackages))
816  str << "keeppackages=" << keepPackages() << endl;
817 
818  if( ! service().empty() )
819  str << "service=" << service() << endl;
820 
821  return str;
822  }
823 
824  std::ostream & RepoInfo::dumpAsXmlOn( std::ostream & str, const std::string & content ) const
825  {
826  std::string tmpstr;
827  str
828  << "<repo"
829  << " alias=\"" << escape(alias()) << "\""
830  << " name=\"" << escape(name()) << "\"";
831  if (type() != repo::RepoType::NONE)
832  str << " type=\"" << type().asString() << "\"";
833  str
834  << " priority=\"" << priority() << "\""
835  << " enabled=\"" << enabled() << "\""
836  << " autorefresh=\"" << autorefresh() << "\""
837  << " gpgcheck=\"" << gpgCheck() << "\""
838  << " repo_gpgcheck=\"" << repoGpgCheck() << "\""
839  << " pkg_gpgcheck=\"" << pkgGpgCheck() << "\"";
840  if (!(tmpstr = gpgKeyUrl().asString()).empty())
841  str << " gpgkey=\"" << escape(tmpstr) << "\"";
842  if (!(tmpstr = mirrorListUrl().asString()).empty())
843  str << (_pimpl->_mirrorListForceMetalink ? " metalink=\"" : " mirrorlist=\"") << escape(tmpstr) << "\"";
844  str << ">" << endl;
845 
846  if ( _pimpl->baseurl2dump() )
847  {
848  for_( it, baseUrlsBegin(), baseUrlsEnd() ) // !transform iterator replaces variables
849  str << "<url>" << escape((*it).asString()) << "</url>" << endl;
850  }
851 
852  str << "</repo>" << endl;
853  return str;
854  }
855 
856 
857  std::ostream & operator<<( std::ostream & str, const RepoInfo & obj )
858  {
859  return obj.dumpOn(str);
860  }
861 
862  std::ostream & operator<<( std::ostream & str, const RepoInfo::GpgCheck & obj )
863  {
864  switch ( obj )
865  {
866 #define OUTS( V ) case RepoInfo::V: return str << #V; break
867  OUTS( GpgCheck::On );
873  OUTS( GpgCheck::Off );
875 #undef OUTS
876  }
877  return str << "GpgCheck::UNKNOWN";
878  }
879 
881 } // namespace zypp
static const Locale noCode
Empty code.
Definition: Locale.h:74
LocaleSet getLicenseLocales() const
Return the locales the license is available for.
Definition: RepoInfo.cc:689
TriBool internalValidRepoSignature() const
Signature check result needs to be stored/retrieved from _metadataPath.
Definition: RepoInfo.cc:177
std::string name() const
Repository name.
std::string targetDistribution() const
Distribution for which is this repository meant.
Definition: RepoInfo.cc:578
bool gpgKeyUrlsEmpty() const
Whether gpgkey URLs are defined.
Definition: RepoInfo.cc:548
#define MIL
Definition: Logger.h:64
void setGpgKeyUrl(const Url &gpgkey)
(leagcy API) Set the gpgkey URL defined for this repo
Definition: RepoInfo.cc:479
static unsigned defaultPriority()
The default priority (99).
Definition: RepoInfo.cc:349
std::string alias() const
unique identifier for this source.
TriBool repoGpgCheck() const
Check repo matadata signatures (indeterminate - according to gpgcheck)
Definition: ZConfig.cc:1016
Url rawUrl() const
Pars pro toto: The first repository raw url (no variables replaced)
Definition: RepoInfo.cc:581
virtual std::ostream & dumpAsIniOn(std::ostream &str) const
Write this RepoInfo object into str in a .repo file format.
Definition: RepoInfo.cc:770
void packagesPath(Pathname new_r)
Definition: RepoInfo.cc:285
std::string asString(const DefaultIntegral< Tp, TInitial > &obj)
bool _mirrorListForceMetalink
Definition: RepoInfo.cc:276
static ZConfig & instance()
Singleton ctor.
Definition: Resolver.cc:125
void setPriority(unsigned newval_r)
Set repository priority for solver.
Definition: RepoInfo.cc:355
int readlink(const Pathname &symlink_r, Pathname &target_r)
Like &#39;readlink&#39;.
Definition: PathInfo.cc:875
void rawGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:260
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: RepoInfo.h:531
Pathname filepath() const
File where this repo was read from.
Pathname metadataPath() const
Definition: RepoInfo.cc:291
url_set gpgKeyUrls() const
The list of gpgkey URLs defined for this repo.
Definition: RepoInfo.cc:554
void setMirrorListUrl(const Url &url)
Set mirror list url.
Definition: RepoInfo.cc:470
repo::RepoVariablesUrlReplacer replacer
Definition: RepoInfo.cc:307
urls_const_iterator baseUrlsBegin() const
iterator that points at begin of repository urls
Definition: RepoInfo.cc:584
std::string escape(const C_Str &str_r, const char sep_r)
Escape desired character c using a backslash.
Definition: String.cc:369
std::ostream & dumpOn(std::ostream &str, const zypp::shared_ptr< void > &obj)
Definition: PtrTypes.h:151
Pathname metadataPath() const
Path where this repo metadata was read from.
Definition: RepoInfo.cc:530
std::ostream & operator<<(std::ostream &str, const RepoInfo::Impl &obj)
Definition: RepoInfo.cc:326
String related utilities and Regular expression matching.
bool pkgGpgCheck() const
Whether the signature of rpm packages should be checked for this repo.
Definition: RepoInfo.cc:384
std::list< Url > url_set
Definition: RepoInfo.h:103
void setProbedType(const repo::RepoType &t) const
This allows to adjust the RepoType lazy, from NONE to some probed value, even for const objects...
Definition: RepoInfo.cc:508
TriBool rawPkgGpgCheck() const
Definition: RepoInfo.cc:258
What is known about a repository.
Definition: RepoInfo.h:71
void getRawGpgChecks(TriBool &g_r, TriBool &r_r, TriBool &p_r) const
Raw values for RepoManager.
Definition: RepoInfo.cc:394
void setGpgCheck(TriBool value_r)
Set the value for gpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:362
TriBool _rawPkgGpgCheck
need to check pkg sign.: Y/N/(ZConf(Y/N/gpgCheck))
Definition: RepoInfo.cc:253
Helper to create and pass std::istream.
Definition: InputStream.h:56
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
void setBaseUrl(const Url &url)
Clears current base URL list and adds url.
Definition: RepoInfo.cc:493
bool enabled() const
If enabled is false, then this repository must be ignored as if does not exists, except when checking...
urls_const_iterator baseUrlsEnd() const
iterator that points at end of repository urls
Definition: RepoInfo.cc:587
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
void internalSetValidRepoSignature(TriBool value_r)
Definition: RepoInfo.cc:191
Pathname packagesPath() const
Path where this repo packages are cached.
Definition: RepoInfo.cc:533
base::ValueTransform< Url, repo::RepoVariablesUrlReplacer > RepoVariablesReplacedUrl
unsigned priority() const
Repository priority for solver.
Definition: RepoInfo.cc:346
#define OUTS(T, B)
Pathname packagesPath() const
Definition: RepoInfo.cc:298
TriBool triBoolFromPath(const Pathname &path_r) const
Definition: RepoInfo.cc:245
void setValidRepoSignature(TriBool value_r)
Set the value for validRepoSignature (or indeterminate if unsigned).
Definition: RepoInfo.cc:409
std::vector< std::string > Arguments
bool repoGpgCheck() const
Whether the signature of repo metadata should be checked for this repo.
Definition: RepoInfo.cc:369
bool seekToNode(int depth_r, const std::string &name_r)
Definition: Reader.cc:212
url_set rawGpgKeyUrls() const
The list of raw gpgkey URLs defined for this repo (no variables replaced)
Definition: RepoInfo.cc:557
boost::logic::tribool TriBool
3-state boolean logic (true, false and indeterminate).
Definition: String.h:30
transform_iterator< repo::RepoVariablesUrlReplacer, url_set::const_iterator > urls_const_iterator
Definition: RepoInfo.h:105
Pathname _metadataPath
Definition: RepoInfo.cc:310
bool pkgGpgCheckIsMandatory() const
Mandatory check (pkgGpgCheck is not off) must ask to confirm using unsigned packages.
Definition: RepoInfo.cc:387
bool cfgGpgCheck() const
Definition: RepoInfo.cc:264
RepoVariablesReplacedUrlList _baseUrls
Definition: RepoInfo.cc:313
static Locale bestMatch(const LocaleSet &avLocales_r, Locale requested_r=Locale())
Return the best match for Locale requested_r within the available avLocales_r.
Definition: Locale.cc:210
RepoInfo implementation.
Definition: RepoInfo.cc:44
bool keepPackages() const
Whether packages downloaded from this repository will be kept in local cache.
Definition: RepoInfo.cc:527
bool needToAcceptLicense() const
Whether the repo license has to be accepted, e.g.
Definition: RepoInfo.cc:618
Url rawMirrorListUrl() const
The raw mirrorListUrl (no variables replaced).
Definition: RepoInfo.cc:545
unsigned split(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t")
Split line_r into words.
Definition: String.h:519
virtual ~RepoInfo()
Definition: RepoInfo.cc:343
GpgCheck
Some predefined settings.
Definition: RepoInfo.h:365
bool gpgCheck() const
Turn signature checking on/off (on)
Definition: ZConfig.cc:1015
Execute a program and give access to its io An object of this class encapsulates the execution of an ...
int unlink(const Pathname &path)
Like &#39;unlink&#39;.
Definition: PathInfo.cc:653
RepoVariablesReplacedUrlList & baseUrls()
Definition: RepoInfo.cc:105
void setRepoGpgCheck(TriBool value_r)
Set the value for repoGpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:380
Url mirrorListUrl() const
Url of a file which contains a list of repository urls.
Definition: RepoInfo.cc:542
bool hasContent() const
Definition: RepoInfo.cc:125
void addContent(const std::string &keyword_r)
Definition: RepoInfo.cc:122
bool internalUnsignedConfirmed() const
We definitely have a symlink pointing to "indeterminate" (for repoGpgCheckIsMandatory)? I.e.
Definition: RepoInfo.cc:213
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string...
Definition: String.h:90
int forEachLine(std::istream &str_r, function< bool(int, std::string)> consume_r)
Simple lineparser: Call functor consume_r for each line.
Definition: IOStream.cc:100
TriBool pkgGpgCheck() const
Check rpm package signatures (indeterminate - according to gpgcheck)
Definition: ZConfig.cc:1017
void setPath(const Pathname &path)
set the product path.
Definition: RepoInfo.cc:502
bool hasContent() const
Check for content keywords.
Definition: RepoInfo.cc:605
void setService(const std::string &name)
sets service which added this repository
Definition: RepoInfo.cc:521
#define WAR
Definition: Logger.h:65
void setMetadataPath(const Pathname &path)
Set the path where the local metadata is stored.
Definition: RepoInfo.cc:512
bool gpgCheck() const
Whether default signature checking should be performed.
Definition: RepoInfo.cc:359
RepoVariablesReplacedUrlList & gpgKeyUrls()
Definition: RepoInfo.cc:115
urls_size_type gpgKeyUrlsSize() const
Number of gpgkey URLs defined.
Definition: RepoInfo.cc:551
bool startsWith(const C_Str &str_r, const C_Str &prefix_r)
alias for hasPrefix
Definition: String.h:1086
void setType(const repo::RepoType &t)
set the repository type
Definition: RepoInfo.cc:505
TriBool _rawGpgCheck
default gpgcheck behavior: Y/N/ZConf
Definition: RepoInfo.cc:251
TriBool _validRepoSignature
have signed and valid repo metadata
Definition: RepoInfo.cc:272
bool baseUrlSet() const
Whether there are manualy configured repository urls.
Definition: RepoInfo.cc:596
Impl * clone() const
clone for RWCOW_pointer
Definition: RepoInfo.cc:320
std::pair< FalseBool, std::set< std::string > > _keywords
Definition: RepoInfo.cc:314
void setKeepPackages(bool keep)
Set if packaqes downloaded from this repository will be kept in local cache.
Definition: RepoInfo.cc:518
std::string service() const
Gets name of the service to which this repository belongs or empty string if it has been added manual...
Definition: RepoInfo.cc:575
bool baseurl2dump() const
Definition: RepoInfo.cc:108
const std::string & asString() const
Definition: RepoType.cc:56
TriBool cfgRepoGpgCheck() const
Definition: RepoInfo.cc:266
bool seekToEndNode(int depth_r, const std::string &name_r)
Definition: Reader.cc:232
int symlink(const Pathname &oldpath, const Pathname &newpath)
Like &#39;symlink&#39;.
Definition: PathInfo.cc:808
void addBaseUrl(const Url &url)
Add a base url.
Definition: RepoInfo.cc:485
std::string receiveLine()
Read one line from the input stream.
TriBool _rawRepoGpgCheck
need to check repo sign.: Y/N/(ZConf(Y/N/gpgCheck))
Definition: RepoInfo.cc:252
Find pathnames matching a pattern.
Definition: Glob.h:57
bool empty() const
Whether matches were found.
Definition: Glob.h:189
static const RepoType NONE
Definition: RepoType.h:32
static const unsigned noPriority
Definition: RepoInfo.cc:62
base::ContainerTransform< std::list< Url >, repo::RepoVariablesUrlReplacer > RepoVariablesReplacedUrlList
const_iterator begin() const
Iterator pointing to the first result.
Definition: Glob.h:197
int add(const Pathname &pattern_r, Flags flags_r=Flags())
Add pathnames matching pattern_r to the current result.
Definition: Glob.h:155
void setPackagesPath(const Pathname &path)
set the path where the local packages are stored
Definition: RepoInfo.cc:515
url_set baseUrls() const
The complete set of repository urls.
Definition: RepoInfo.cc:566
const std::vector< Url > & getUrls() const
url_set rawBaseUrls() const
The complete set of raw repository urls (no variables replaced)
Definition: RepoInfo.cc:569
std::string asString() const
Explicit conversion to std::string.
Definition: XmlString.h:77
int close()
Wait for the progamm to complete.
&#39;Language[_Country]&#39; codes.
Definition: Locale.h:49
void setMetalinkUrl(const Url &url)
Like setMirrorListUrl but expect metalink format.
Definition: RepoInfo.cc:473
bool baseUrlsEmpty() const
whether repository urls are available
Definition: RepoInfo.cc:593
void setGpgKeyUrls(url_set urls)
Set a list of gpgkey URLs defined for this repo.
Definition: RepoInfo.cc:476
repo::RepoType type() const
Type of repository,.
Definition: RepoInfo.cc:539
void setProbedType(const repo::RepoType &t) const
Definition: RepoInfo.cc:64
bool triBoolFromPath(const Pathname &path_r, TriBool &ret_r) const
Definition: RepoInfo.cc:219
const char * c_str() const
Definition: IdStringType.h:105
Pathname licenseTgz() const
Path to a license tarball in case it exists in the repo.
Definition: RepoInfo.cc:76
url_set::size_type urls_size_type
Definition: RepoInfo.h:104
bool hasSuffix(const C_Str &str_r, const C_Str &suffix_r)
Return whether str_r has suffix suffix_r.
Definition: String.h:1042
void rawRepoGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:261
const std::set< std::string > & contentKeywords() const
Definition: RepoInfo.cc:119
void setTargetDistribution(const std::string &targetDistribution)
Sets the distribution for which is this repository meant.
Definition: RepoInfo.cc:524
std::string getLicense(const Locale &lang_r=Locale()) const
Return the best license for the current (or a specified) locale.
Definition: RepoInfo.cc:649
bool autorefresh() const
If true, the repostory must be refreshed before creating resolvables from it.
XmlString nodeText()
If the current node is not empty, advances the reader to the next node, and returns the value...
Definition: Reader.cc:140
bool hasLicense() const
Whether there is a license associated with the repo.
Definition: RepoInfo.cc:613
RepoVariablesReplacedUrlList _gpgKeyUrls
Definition: RepoInfo.cc:316
bool hasContent(const std::string &keyword_r) const
Definition: RepoInfo.cc:170
bool repoGpgCheckIsMandatory() const
Mandatory check (repoGpgCheck is on) must ask to confirm using unsigned repos.
Definition: RepoInfo.cc:372
Url gpgKeyUrl() const
(leagcy API) The 1st gpgkey URL defined for this repo
Definition: RepoInfo.cc:560
RepoVariablesReplacedUrl _mirrorListUrl
Definition: RepoInfo.cc:275
DefaultIntegral< unsigned, defaultPriority > priority
Definition: RepoInfo.cc:305
Url url() const
Pars pro toto: The first repository url.
Definition: RepoInfo.h:131
const std::set< std::string > & contentKeywords() const
Content keywords defined.
Definition: RepoInfo.cc:599
bool usesAutoMethadataPaths() const
Definition: RepoInfo.cc:288
void setBaseUrls(url_set urls)
Clears current base URL list and adds an url_set.
Definition: RepoInfo.cc:499
std::string targetDistro
Definition: RepoInfo.cc:280
bool usesAutoMethadataPaths() const
Whether metadataPath uses AUTO% setup.
Definition: RepoInfo.cc:536
static const RepoInfo noRepo
Represents no Repository (one with an empty alias).
Definition: RepoInfo.h:80
void addContent(const std::string &keyword_r)
Add content keywords.
Definition: RepoInfo.cc:602
void rawPkgGpgCheck(TriBool val_r)
Definition: RepoInfo.cc:262
size_type size() const
Definition: String.h:105
virtual std::ostream & dumpAsXmlOn(std::ostream &str, const std::string &content="") const
Write an XML representation of this RepoInfo object.
Definition: RepoInfo.cc:824
repo::RepoType type
Definition: RepoInfo.cc:277
TriBool validRepoSignature() const
Whether the repo metadata are signed and successfully validated or indeterminate if unsigned...
Definition: RepoInfo.cc:402
Functor replacing repository variables.
urls_size_type baseUrlsSize() const
number of repository urls
Definition: RepoInfo.cc:590
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
TriBool rawRepoGpgCheck() const
Definition: RepoInfo.cc:257
static const unsigned defaultPriority
Definition: RepoInfo.cc:61
const RepoVariablesReplacedUrlList & gpgKeyUrls() const
Definition: RepoInfo.cc:112
static unsigned noPriority()
The least priority (unsigned(-1)).
Definition: RepoInfo.cc:352
bool hasPrefix(const C_Str &str_r, const C_Str &prefix_r)
Return whether str_r has prefix prefix_r.
Definition: String.h:1028
TriBool rawGpgCheck() const
Definition: RepoInfo.cc:256
const RepoVariablesReplacedUrlList & baseUrls() const
Definition: RepoInfo.cc:92
void setPkgGpgCheck(TriBool value_r)
Set the value for pkgGpgCheck (or indeterminate to use the default).
Definition: RepoInfo.cc:390
std::unordered_set< Locale > LocaleSet
Definition: Locale.h:27
Url rawGpgKeyUrl() const
(leagcy API) The 1st raw gpgkey URL defined for this repo (no variables replaced) ...
Definition: RepoInfo.cc:563
TriBool cfgPkgGpgCheck() const
Definition: RepoInfo.cc:268
Pathname _packagesPath
Definition: RepoInfo.cc:311
Url manipulation class.
Definition: Url.h:87
void metadataPath(Pathname new_r)
Definition: RepoInfo.cc:282
Pathname path() const
Repository path.
Definition: RepoInfo.cc:572
virtual std::ostream & dumpOn(std::ostream &str) const
Write a human-readable representation of this RepoInfo object into the str stream.
Definition: RepoInfo.cc:722
#define DBG
Definition: Logger.h:63
std::string service
Definition: RepoInfo.cc:279
detail::EscapedString escape(const std::string &in_r)
Escape xml special charaters (& -> &; from IoBind library).
Definition: XmlEscape.h:51
Repository type enumeration.
Definition: RepoType.h:27
friend std::ostream & operator<<(std::ostream &str, const RepoInfo &obj)
Definition: RepoInfo.cc:857