zypp/RepoInfo.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/RepoInfo.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include <vector>
  14
  15 #include "zypp/base/LogTools.h"
  16 #include "zypp/base/DefaultIntegral.h"
  17 #include "zypp/parser/xml/XmlEscape.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"
  24 #include "zypp/repo/RepoMirrorList.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
  35 ///////////////////////////////////////////////////////////////////
  36 namespace zypp
  37 { /////////////////////////////////////////////////////////////////
  38
  39   ///////////////////////////////////////////////////////////////////
  40   //
  41   //    CLASS NAME : RepoInfo::Impl
  42   //
  43   /** RepoInfo implementation. */
  44   struct RepoInfo::Impl
  45   {
  46     Impl()
  47       : _rawGpgCheck( indeterminate )
  48       , _rawRepoGpgCheck( indeterminate )
  49       , _rawPkgGpgCheck( indeterminate )
  50       , _validRepoSignature( indeterminate )
  51       , keeppackages(indeterminate)
  52       , _mirrorListForceMetalink(false)
  53       , type(repo::RepoType::NONE_e)
  54       , emptybaseurls(false)
  55     {}
  56
  57     ~Impl()
  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     {
  66       if ( type == repo::RepoType::NONE
  67            && t != repo::RepoType::NONE )
  68       {
  69         // lazy init!
  70         const_cast<Impl*>(this)->type = t;
  71       }
  72     }
  73
  74   public:
  75     /** Path to a license tarball in case it exists in the repo. */
  76     Pathname licenseTgz( const std::string & name_r ) const
  77     {
  78       Pathname ret;
  79       if ( !metadataPath().empty() )
  80       {
  81         std::string licenseStem( "license" );
  82         if ( !name_r.empty() )
  83         {
  84           licenseStem += "-";
  85           licenseStem += name_r;
  86         }
  87
  88         filesystem::Glob g;
  89         // TODO: REPOMD: this assumes we know the name of the tarball. In fact
  90         // we'd need to get the file from repomd.xml (<data type="license[-name_r]">)
  91         g.add( metadataPath() / path / ("repodata/*"+licenseStem+".tar.gz") );
  92         if ( g.empty() )
  93           g.add( metadataPath() / path / (licenseStem+".tar.gz") );
  94
  95         if ( !g.empty() )
  96           ret = *g.begin();
  97       }
  98       return ret;
  99     }
 100
 101     const RepoVariablesReplacedUrlList & baseUrls() const
 102     {
 103       const Url & mlurl( _mirrorListUrl.transformed() );        // Variables replaced!
 104       if ( _baseUrls.empty() && ! mlurl.asString().empty() )
 105       {
 106         emptybaseurls = true;
 107         DBG << "MetadataPath: " << metadataPath() << endl;
 108         repo::RepoMirrorList rmurls( mlurl, metadataPath(), _mirrorListForceMetalink );
 109         _baseUrls.raw().insert( _baseUrls.raw().end(), rmurls.getUrls().begin(), rmurls.getUrls().end() );
 110       }
 111       return _baseUrls;
 112     }
 113
 114     RepoVariablesReplacedUrlList & baseUrls()
 115     { return _baseUrls; }
 116
 117     bool baseurl2dump() const
 118     { return !emptybaseurls && !_baseUrls.empty(); }
 119
 120
 121     const RepoVariablesReplacedUrlList & gpgKeyUrls() const
 122     { return _gpgKeyUrls; }
 123
 124     RepoVariablesReplacedUrlList & gpgKeyUrls()
 125     { return _gpgKeyUrls; }
 126
 127
 128     const std::set<std::string> & contentKeywords() const
 129     { hasContent()/*init if not yet done*/; return _keywords.second; }
 130
 131     void addContent( const std::string & keyword_r )
 132     { _keywords.second.insert( keyword_r ); if ( ! hasContent() ) _keywords.first = true; }
 133
 134     bool hasContent() const
 135     {
 136       if ( !_keywords.first && ! metadataPath().empty() )
 137       {
 138         // HACK directly check master index file until RepoManager offers
 139         // some content probing and zypper uses it.
 140         /////////////////////////////////////////////////////////////////
 141         MIL << "Empty keywords...." << metadataPath() << endl;
 142         Pathname master;
 143         if ( PathInfo( (master=metadataPath()/"/repodata/repomd.xml") ).isFile() )
 144         {
 145           //MIL << "GO repomd.." << endl;
 146           xml::Reader reader( master );
 147           while ( reader.seekToNode( 2, "content" ) )
 148           {
 149             _keywords.second.insert( reader.nodeText().asString() );
 150             reader.seekToEndNode( 2, "content" );
 151           }
 152           _keywords.first = true;       // valid content in _keywords even if empty
 153         }
 154         else if ( PathInfo( (master=metadataPath()/"/content") ).isFile() )
 155         {
 156           //MIL << "GO content.." << endl;
 157           iostr::forEachLine( InputStream( master ),
 158                             [this]( int num_r, std::string line_r )->bool
 159                             {
 160                               if ( str::startsWith( line_r, "REPOKEYWORDS" ) )
 161                               {
 162                                 std::vector<std::string> words;
 163                                 if ( str::split( line_r, std::back_inserter(words) ) > 1
 164                                   && words[0].length() == 12 /*"REPOKEYWORDS"*/ )
 165                                 {
 166                                   this->_keywords.second.insert( ++words.begin(), words.end() );
 167                                 }
 168                                 return true; // mult. occurrances are ok.
 169                               }
 170                               return( ! str::startsWith( line_r, "META " ) );   // no need to parse into META section.
 171                             } );
 172           _keywords.first = true;       // valid content in _keywords even if empty
 173         }
 174         /////////////////////////////////////////////////////////////////
 175       }
 176       return _keywords.first;
 177     }
 178
 179     bool hasContent( const std::string & keyword_r ) const
 180     { return( hasContent() && _keywords.second.find( keyword_r ) != _keywords.second.end() ); }
 181
 182     /** Signature check result needs to be stored/retrieved from _metadataPath.
 183      * Don't call them from outside validRepoSignature/setValidRepoSignature
 184      */
 185     //@{
 186     TriBool internalValidRepoSignature() const
 187     {
 188       if ( ! indeterminate(_validRepoSignature) )
 189         return _validRepoSignature;
 190       // check metadata:
 191       if ( ! metadataPath().empty() )
 192       {
 193         // A missing ".repo_gpgcheck" might be plaindir(no Downloader) or not yet refreshed signed repo!
 194         TriBool linkval = triBoolFromPath( metadataPath() / ".repo_gpgcheck" );
 195         return linkval;
 196       }
 197       return indeterminate;
 198     }
 199
 200     void internalSetValidRepoSignature( TriBool value_r )
 201     {
 202       if ( PathInfo(metadataPath()).isDir() )
 203       {
 204         Pathname gpgcheckFile( metadataPath() / ".repo_gpgcheck" );
 205         if ( PathInfo(gpgcheckFile).isExist() )
 206         {
 207           TriBool linkval( indeterminate );
 208           if ( triBoolFromPath( gpgcheckFile, linkval ) && linkval == value_r )
 209             return;     // existing symlink fits value_r
 210           else
 211             filesystem::unlink( gpgcheckFile ); // will write a new one
 212         }
 213         filesystem::symlink( asString(value_r), gpgcheckFile );
 214       }
 215       _validRepoSignature = value_r;
 216     }
 217
 218     /** We definitely have a symlink pointing to "indeterminate" (for repoGpgCheckIsMandatory)?
 219      * I.e. user accepted the unsigned repo in Downloader. A test whether `internalValidRepoSignature`
 220      * is indeterminate would include not yet checked repos, which is unwanted here.
 221      */
 222     bool internalUnsignedConfirmed() const
 223     {
 224       TriBool linkval( true );  // want to see it being switched to indeterminate
 225       return triBoolFromPath( metadataPath() / ".repo_gpgcheck", linkval ) && indeterminate(linkval);
 226     }
 227
 228     bool triBoolFromPath( const Pathname & path_r, TriBool & ret_r ) const
 229     {
 230       static const Pathname truePath( "true" );
 231       static const Pathname falsePath( "false" );
 232       static const Pathname indeterminatePath( "indeterminate" );
 233
 234       // Quiet readlink;
 235       static const ssize_t bufsiz = 63;
 236       static char buf[bufsiz+1];
 237       ssize_t ret = ::readlink( path_r.c_str(), buf, bufsiz );
 238       buf[ret == -1 ? 0 : ret] = '\0';
 239
 240       Pathname linkval( buf );
 241
 242       bool known = true;
 243       if ( linkval == truePath )
 244         ret_r = true;
 245       else if ( linkval == falsePath )
 246         ret_r = false;
 247       else if ( linkval == indeterminatePath )
 248         ret_r = indeterminate;
 249       else
 250         known = false;
 251       return known;
 252     }
 253
 254     TriBool triBoolFromPath( const Pathname & path_r ) const
 255     { TriBool ret(indeterminate); triBoolFromPath( path_r, ret ); return ret; }
 256
 257     //@}
 258
 259   private:
 260     TriBool _rawGpgCheck;       ///< default gpgcheck behavior: Y/N/ZConf
 261     TriBool _rawRepoGpgCheck;   ///< need to check repo sign.: Y/N/(ZConf(Y/N/gpgCheck))
 262     TriBool _rawPkgGpgCheck;    ///< need to check pkg sign.: Y/N/(ZConf(Y/N/gpgCheck))
 263
 264   public:
 265     TriBool rawGpgCheck() const                 { return _rawGpgCheck; }
 266     TriBool rawRepoGpgCheck() const             { return _rawRepoGpgCheck; }
 267     TriBool rawPkgGpgCheck() const              { return _rawPkgGpgCheck; }
 268
 269     void rawGpgCheck( TriBool val_r )           { _rawGpgCheck = val_r; }
 270     void rawRepoGpgCheck( TriBool val_r )       { _rawRepoGpgCheck = val_r; }
 271     void rawPkgGpgCheck( TriBool val_r )        { _rawPkgGpgCheck = val_r; }
 272
 273     bool cfgGpgCheck() const
 274     { return indeterminate(_rawGpgCheck) ? ZConfig::instance().gpgCheck() : (bool)_rawGpgCheck; }
 275     TriBool cfgRepoGpgCheck() const
 276     { return indeterminate(_rawGpgCheck) && indeterminate(_rawRepoGpgCheck) ? ZConfig::instance().repoGpgCheck() : _rawRepoGpgCheck; }
 277     TriBool cfgPkgGpgCheck() const
 278     { return indeterminate(_rawGpgCheck) && indeterminate(_rawPkgGpgCheck) ? ZConfig::instance().pkgGpgCheck() : _rawPkgGpgCheck; }
 279
 280   private:
 281     TriBool _validRepoSignature;///< have  signed and valid repo metadata
 282   public:
 283     TriBool keeppackages;
 284     RepoVariablesReplacedUrl _mirrorListUrl;
 285     bool                     _mirrorListForceMetalink;
 286     repo::RepoType type;
 287     Pathname path;
 288     std::string service;
 289     std::string targetDistro;
 290
 291     void metadataPath( Pathname new_r )
 292     { _metadataPath = std::move( new_r ); }
 293
 294     void packagesPath( Pathname new_r )
 295     { _packagesPath = std::move( new_r ); }
 296
 297     bool usesAutoMethadataPaths() const
 298     { return str::hasSuffix( _metadataPath.asString(), "/%AUTO%" ); }
 299
 300     Pathname metadataPath() const
 301     {
 302       if ( usesAutoMethadataPaths() )
 303         return _metadataPath.dirname() / "%RAW%";
 304       return _metadataPath;
 305     }
 306
 307     Pathname packagesPath() const
 308     {
 309       if ( _packagesPath.empty() && usesAutoMethadataPaths() )
 310         return _metadataPath.dirname() / "%PKG%";
 311       return _packagesPath;
 312     }
 313
 314     DefaultIntegral<unsigned,defaultPriority> priority;
 315     mutable bool emptybaseurls;
 316
 317   private:
 318     Pathname _metadataPath;
 319     Pathname _packagesPath;
 320
 321     mutable RepoVariablesReplacedUrlList _baseUrls;
 322     mutable std::pair<FalseBool, std::set<std::string> > _keywords;
 323
 324     RepoVariablesReplacedUrlList _gpgKeyUrls;
 325
 326     friend Impl * rwcowClone<Impl>( const Impl * rhs );
 327     /** clone for RWCOW_pointer */
 328     Impl * clone() const
 329     { return new Impl( *this ); }
 330   };
 331   ///////////////////////////////////////////////////////////////////
 332
 333   /** \relates RepoInfo::Impl Stream output */
 334   inline std::ostream & operator<<( std::ostream & str, const RepoInfo::Impl & obj )
 335   {
 336     return str << "RepoInfo::Impl";
 337   }
 338
 339   ///////////////////////////////////////////////////////////////////
 340   //
 341   //    CLASS NAME : RepoInfo
 342   //
 343   ///////////////////////////////////////////////////////////////////
 344
 345   const RepoInfo RepoInfo::noRepo;
 346
 347   RepoInfo::RepoInfo()
 348   : _pimpl( new Impl() )
 349   {}
 350
 351   RepoInfo::~RepoInfo()
 352   {}
 353
 354   unsigned RepoInfo::priority() const
 355   { return _pimpl->priority; }
 356
 357   unsigned RepoInfo::defaultPriority()
 358   { return Impl::defaultPriority; }
 359
 360   unsigned RepoInfo::noPriority()
 361   { return Impl::noPriority; }
 362
 363   void RepoInfo::setPriority( unsigned newval_r )
 364   { _pimpl->priority = newval_r ? newval_r : Impl::defaultPriority; }
 365
 366
 367   bool RepoInfo::gpgCheck() const
 368   { return _pimpl->cfgGpgCheck(); }
 369
 370   void RepoInfo::setGpgCheck( TriBool value_r )
 371   { _pimpl->rawGpgCheck( value_r ); }
 372
 373   void RepoInfo::setGpgCheck( bool value_r ) // deprecated legacy and for squid
 374   { setGpgCheck( TriBool(value_r) ); }
 375
 376
 377   bool RepoInfo::repoGpgCheck() const
 378   { return gpgCheck() || _pimpl->cfgRepoGpgCheck(); }
 379
 380   bool RepoInfo::repoGpgCheckIsMandatory() const
 381   {
 382     bool ret = ( gpgCheck() && indeterminate(_pimpl->cfgRepoGpgCheck()) ) || _pimpl->cfgRepoGpgCheck();
 383     if ( ret && _pimpl->internalUnsignedConfirmed() )   // relax if unsigned repo was confirmed in the past
 384       ret = false;
 385     return ret;
 386   }
 387
 388   void RepoInfo::setRepoGpgCheck( TriBool value_r )
 389   { _pimpl->rawRepoGpgCheck( value_r ); }
 390
 391
 392   bool RepoInfo::pkgGpgCheck() const
 393   { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && !bool(validRepoSignature())/*enforced*/ ) ; }
 394
 395   bool RepoInfo::pkgGpgCheckIsMandatory() const
 396   { return _pimpl->cfgPkgGpgCheck() || ( gpgCheck() && indeterminate(_pimpl->cfgPkgGpgCheck()) && !bool(validRepoSignature())/*enforced*/ ); }
 397
 398   void RepoInfo::setPkgGpgCheck( TriBool value_r )
 399   { _pimpl->rawPkgGpgCheck( value_r ); }
 400
 401
 402   void RepoInfo::getRawGpgChecks( TriBool & g_r, TriBool & r_r, TriBool & p_r ) const
 403   {
 404     g_r = _pimpl->rawGpgCheck();
 405     r_r = _pimpl->rawRepoGpgCheck();
 406     p_r = _pimpl->rawPkgGpgCheck();
 407   }
 408
 409
 410   TriBool RepoInfo::validRepoSignature() const
 411   {
 412     TriBool ret( _pimpl->internalValidRepoSignature() );
 413     if ( ret && !repoGpgCheck() ) ret = false;  // invalidate any old signature if repoGpgCheck is off
 414     return ret;
 415   }
 416
 417   void RepoInfo::setValidRepoSignature( TriBool value_r )
 418   { _pimpl->internalSetValidRepoSignature( value_r ); }
 419
 420   ///////////////////////////////////////////////////////////////////
 421   namespace
 422   {
 423     inline bool changeGpgCheckTo( TriBool & lhs, TriBool rhs )
 424     { if ( ! sameTriboolState( lhs, rhs ) ) { lhs = rhs; return true; } return false; }
 425
 426     inline bool changeGpgCheckTo( TriBool ogpg[3], TriBool g, TriBool r, TriBool p )
 427     {
 428       bool changed = false;
 429       if ( changeGpgCheckTo( ogpg[0], g ) ) changed = true;
 430       if ( changeGpgCheckTo( ogpg[1], r ) ) changed = true;
 431       if ( changeGpgCheckTo( ogpg[2], p ) ) changed = true;
 432       return changed;
 433     }
 434   } // namespace
 435   ///////////////////////////////////////////////////////////////////
 436   bool RepoInfo::setGpgCheck( GpgCheck mode_r )
 437   {
 438     TriBool ogpg[3];    // Gpg RepoGpg PkgGpg
 439     getRawGpgChecks( ogpg[0], ogpg[1], ogpg[2] );
 440
 441     bool changed = false;
 442     switch ( mode_r )
 443     {
 444       case GpgCheck::On:
 445         changed = changeGpgCheckTo( ogpg, true,          indeterminate, indeterminate );
 446         break;
 447       case GpgCheck::Strict:
 448         changed = changeGpgCheckTo( ogpg, true,          true,          true          );
 449         break;
 450       case GpgCheck::AllowUnsigned:
 451         changed = changeGpgCheckTo( ogpg, true,          false,         false         );
 452         break;
 453       case GpgCheck::AllowUnsignedRepo:
 454         changed = changeGpgCheckTo( ogpg, true,          false,         indeterminate );
 455         break;
 456       case GpgCheck::AllowUnsignedPackage:
 457         changed = changeGpgCheckTo( ogpg, true,          indeterminate, false         );
 458         break;
 459       case GpgCheck::Default:
 460         changed = changeGpgCheckTo( ogpg, indeterminate, indeterminate, indeterminate );
 461         break;
 462       case GpgCheck::Off:
 463         changed = changeGpgCheckTo( ogpg, false,         indeterminate, indeterminate );
 464         break;
 465       case GpgCheck::indeterminate:     // no change
 466         break;
 467     }
 468
 469     if ( changed )
 470     {
 471       setGpgCheck    ( ogpg[0] );
 472       setRepoGpgCheck( ogpg[1] );
 473       setPkgGpgCheck ( ogpg[2] );
 474     }
 475     return changed;
 476   }
 477
 478   void RepoInfo::setMirrorListUrl( const Url & url_r )  // Raw
 479   { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = false; }
 480
 481   void  RepoInfo::setMetalinkUrl( const Url & url_r )   // Raw
 482   { _pimpl->_mirrorListUrl.raw() = url_r; _pimpl->_mirrorListForceMetalink = true; }
 483
 484   void RepoInfo::setGpgKeyUrls( url_set urls )
 485   { _pimpl->gpgKeyUrls().raw().swap( urls ); }
 486
 487   void RepoInfo::setGpgKeyUrl( const Url & url_r )
 488   {
 489     _pimpl->gpgKeyUrls().raw().clear();
 490     _pimpl->gpgKeyUrls().raw().push_back( url_r );
 491   }
 492
 493   void RepoInfo::addBaseUrl( const Url & url_r )
 494   {
 495     for ( const auto & url : _pimpl->baseUrls().raw() ) // Raw unique!
 496       if ( url == url_r )
 497         return;
 498     _pimpl->baseUrls().raw().push_back( url_r );
 499   }
 500
 501   void RepoInfo::setBaseUrl( const Url & url_r )
 502   {
 503     _pimpl->baseUrls().raw().clear();
 504     _pimpl->baseUrls().raw().push_back( url_r );
 505   }
 506
 507   void RepoInfo::setBaseUrls( url_set urls )
 508   { _pimpl->baseUrls().raw().swap( urls ); }
 509
 510   void RepoInfo::setPath( const Pathname &path )
 511   { _pimpl->path = path; }
 512
 513   void RepoInfo::setType( const repo::RepoType &t )
 514   { _pimpl->type = t; }
 515
 516   void RepoInfo::setProbedType( const repo::RepoType &t ) const
 517   { _pimpl->setProbedType( t ); }
 518
 519
 520   void RepoInfo::setMetadataPath( const Pathname &path )
 521   { _pimpl->metadataPath( path ); }
 522
 523   void RepoInfo::setPackagesPath( const Pathname &path )
 524   { _pimpl->packagesPath( path ); }
 525
 526   void RepoInfo::setKeepPackages( bool keep )
 527   { _pimpl->keeppackages = keep; }
 528
 529   void RepoInfo::setService( const std::string& name )
 530   { _pimpl->service = name; }
 531
 532   void RepoInfo::setTargetDistribution( const std::string & targetDistribution )
 533   { _pimpl->targetDistro = targetDistribution; }
 534
 535   bool RepoInfo::keepPackages() const
 536   { return indeterminate(_pimpl->keeppackages) ? false : (bool)_pimpl->keeppackages; }
 537
 538   Pathname RepoInfo::metadataPath() const
 539   { return _pimpl->metadataPath(); }
 540
 541   Pathname RepoInfo::packagesPath() const
 542   { return _pimpl->packagesPath(); }
 543
 544   bool RepoInfo::usesAutoMethadataPaths() const
 545   { return _pimpl->usesAutoMethadataPaths(); }
 546
 547   repo::RepoType RepoInfo::type() const
 548   { return _pimpl->type; }
 549
 550   Url RepoInfo::mirrorListUrl() const                   // Variables replaced!
 551   { return _pimpl->_mirrorListUrl.transformed(); }
 552
 553   Url RepoInfo::rawMirrorListUrl() const                // Raw
 554   { return _pimpl->_mirrorListUrl.raw(); }
 555
 556   bool RepoInfo::gpgKeyUrlsEmpty() const
 557   { return _pimpl->gpgKeyUrls().empty(); }
 558
 559   RepoInfo::urls_size_type RepoInfo::gpgKeyUrlsSize() const
 560   { return _pimpl->gpgKeyUrls().size(); }
 561
 562   RepoInfo::url_set RepoInfo::gpgKeyUrls() const        // Variables replaced!
 563   { return _pimpl->gpgKeyUrls().transformed(); }
 564
 565   RepoInfo::url_set RepoInfo::rawGpgKeyUrls() const     // Raw
 566   { return _pimpl->gpgKeyUrls().raw(); }
 567
 568   Url RepoInfo::gpgKeyUrl() const                       // Variables replaced!
 569   { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().transformedBegin() ); }
 570
 571   Url RepoInfo::rawGpgKeyUrl() const                    // Raw
 572   { return( _pimpl->gpgKeyUrls().empty() ? Url() : *_pimpl->gpgKeyUrls().rawBegin() ) ; }
 573
 574   RepoInfo::url_set RepoInfo::baseUrls() const          // Variables replaced!
 575   { return _pimpl->baseUrls().transformed(); }
 576
 577   RepoInfo::url_set RepoInfo::rawBaseUrls() const       // Raw
 578   { return _pimpl->baseUrls().raw(); }
 579
 580   Pathname RepoInfo::path() const
 581   { return _pimpl->path; }
 582
 583   std::string RepoInfo::service() const
 584   { return _pimpl->service; }
 585
 586   std::string RepoInfo::targetDistribution() const
 587   { return _pimpl->targetDistro; }
 588
 589   Url RepoInfo::rawUrl() const
 590   { return( _pimpl->baseUrls().empty() ? Url() : *_pimpl->baseUrls().rawBegin() ); }
 591
 592   RepoInfo::urls_const_iterator RepoInfo::baseUrlsBegin() const
 593   { return _pimpl->baseUrls().transformedBegin(); }
 594
 595   RepoInfo::urls_const_iterator RepoInfo::baseUrlsEnd() const
 596   { return _pimpl->baseUrls().transformedEnd(); }
 597
 598   RepoInfo::urls_size_type RepoInfo::baseUrlsSize() const
 599   { return _pimpl->baseUrls().size(); }
 600
 601   bool RepoInfo::baseUrlsEmpty() const
 602   { return _pimpl->baseUrls().empty(); }
 603
 604   bool RepoInfo::baseUrlSet() const
 605   { return _pimpl->baseurl2dump(); }
 606
 607   const std::set<std::string> & RepoInfo::contentKeywords() const
 608   { return _pimpl->contentKeywords(); }
 609
 610   void RepoInfo::addContent( const std::string & keyword_r )
 611   { _pimpl->addContent( keyword_r ); }
 612
 613   bool RepoInfo::hasContent() const
 614   { return _pimpl->hasContent(); }
 615
 616   bool RepoInfo::hasContent( const std::string & keyword_r ) const
 617   { return _pimpl->hasContent( keyword_r ); }
 618
 619   ///////////////////////////////////////////////////////////////////
 620
 621   bool RepoInfo::hasLicense() const
 622   { return hasLicense( std::string() ); }
 623
 624   bool RepoInfo::hasLicense( const std::string & name_r ) const
 625   { return !_pimpl->licenseTgz( name_r ).empty(); }
 626
 627
 628   bool RepoInfo::needToAcceptLicense() const
 629   { return needToAcceptLicense( std::string() ); }
 630
 631   bool RepoInfo::needToAcceptLicense( const std::string & name_r ) const
 632   {
 633     const Pathname & licenseTgz( _pimpl->licenseTgz( name_r ) );
 634     if ( licenseTgz.empty() )
 635       return false;     // no licenses at all
 636
 637     ExternalProgram::Arguments cmd;
 638     cmd.push_back( "tar" );
 639     cmd.push_back( "-t" );
 640     cmd.push_back( "-z" );
 641     cmd.push_back( "-f" );
 642     cmd.push_back( licenseTgz.asString() );
 643     ExternalProgram prog( cmd, ExternalProgram::Stderr_To_Stdout );
 644
 645     bool accept = true;
 646     static const std::string noAcceptanceFile = "no-acceptance-needed\n";
 647     for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
 648     {
 649       if ( output == noAcceptanceFile )
 650       {
 651         accept = false;
 652       }
 653     }
 654     MIL << "License(" << name_r << ") in " << name() << " has to be accepted: " << (accept?"true":"false" ) << endl;
 655     return accept;
 656   }
 657
 658
 659   std::string RepoInfo::getLicense( const Locale & lang_r )
 660   { return const_cast<const RepoInfo *>(this)->getLicense( std::string(), lang_r ); }
 661
 662   std::string RepoInfo::getLicense( const Locale & lang_r ) const
 663   { return getLicense( std::string(), lang_r ); }
 664
 665   std::string RepoInfo::getLicense( const std::string & name_r, const Locale & lang_r ) const
 666   {
 667     LocaleSet avlocales( getLicenseLocales( name_r ) );
 668     if ( avlocales.empty() )
 669       return std::string();
 670
 671     Locale getLang( Locale::bestMatch( avlocales, lang_r ) );
 672     if ( !getLang && avlocales.find( Locale::noCode ) == avlocales.end() )
 673     {
 674       WAR << "License(" << name_r << ") in " << name() << " contains no fallback text!" << endl;
 675       // Using the fist locale instead of returning no text at all.
 676       // So the user might recognize that there is a license, even if he
 677       // can't read it.
 678       getLang = *avlocales.begin();
 679     }
 680
 681     // now extract the license file.
 682     static const std::string licenseFileFallback( "license.txt" );
 683     std::string licenseFile( !getLang ? licenseFileFallback
 684                                       : str::form( "license.%s.txt", getLang.c_str() ) );
 685
 686     ExternalProgram::Arguments cmd;
 687     cmd.push_back( "tar" );
 688     cmd.push_back( "-x" );
 689     cmd.push_back( "-z" );
 690     cmd.push_back( "-O" );
 691     cmd.push_back( "-f" );
 692     cmd.push_back( _pimpl->licenseTgz( name_r ).asString() ); // if it not exists, avlocales was empty.
 693     cmd.push_back( licenseFile );
 694
 695     std::string ret;
 696     ExternalProgram prog( cmd, ExternalProgram::Discard_Stderr );
 697     for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
 698     {
 699       ret += output;
 700     }
 701     prog.close();
 702     return ret;
 703   }
 704
 705
 706   LocaleSet RepoInfo::getLicenseLocales() const
 707   { return getLicenseLocales( std::string() ); }
 708
 709   LocaleSet RepoInfo::getLicenseLocales( const std::string & name_r ) const
 710   {
 711     const Pathname & licenseTgz( _pimpl->licenseTgz( name_r ) );
 712     if ( licenseTgz.empty() )
 713       return LocaleSet();
 714
 715     ExternalProgram::Arguments cmd;
 716     cmd.push_back( "tar" );
 717     cmd.push_back( "-t" );
 718     cmd.push_back( "-z" );
 719     cmd.push_back( "-f" );
 720     cmd.push_back( licenseTgz.asString() );
 721
 722     LocaleSet ret;
 723     ExternalProgram prog( cmd, ExternalProgram::Stderr_To_Stdout );
 724     for ( std::string output( prog.receiveLine() ); output.length(); output = prog.receiveLine() )
 725     {
 726       static const C_Str license( "license." );
 727       static const C_Str dotTxt( ".txt\n" );
 728       if ( str::hasPrefix( output, license ) && str::hasSuffix( output, dotTxt ) )
 729       {
 730         if ( output.size() <= license.size() +  dotTxt.size() ) // license.txt
 731           ret.insert( Locale() );
 732         else
 733           ret.insert( Locale( std::string( output.c_str()+license.size(), output.size()- license.size() - dotTxt.size() ) ) );
 734       }
 735     }
 736     prog.close();
 737     return ret;
 738   }
 739
 740   ///////////////////////////////////////////////////////////////////
 741
 742   std::ostream & RepoInfo::dumpOn( std::ostream & str ) const
 743   {
 744     RepoInfoBase::dumpOn(str);
 745     if ( _pimpl->baseurl2dump() )
 746     {
 747       for ( const auto & url : _pimpl->baseUrls().raw() )
 748       {
 749         str << "- url         : " << url << std::endl;
 750       }
 751     }
 752
 753     // print if non empty value
 754     auto strif( [&] ( const std::string & tag_r, const std::string & value_r ) {
 755       if ( ! value_r.empty() )
 756         str << tag_r << value_r << std::endl;
 757     });
 758
 759     strif( (_pimpl->_mirrorListForceMetalink ? "- metalink    : " : "- mirrorlist  : "), rawMirrorListUrl().asString() );
 760     strif( "- path        : ", path().asString() );
 761     str << "- type        : " << type() << std::endl;
 762     str << "- priority    : " << priority() << std::endl;
 763
 764     // Yes No Default(Y) Default(N)
 765 #define OUTS(T,B) ( indeterminate(T) ? (std::string("D(")+(B?"Y":"N")+")") : ((bool)T?"Y":"N") )
 766     str << "- gpgcheck    : " << OUTS(_pimpl->rawGpgCheck(),gpgCheck())
 767                               << " repo" << OUTS(_pimpl->rawRepoGpgCheck(),repoGpgCheck()) << (repoGpgCheckIsMandatory() ? "* ": " " )
 768                               << "sig" << asString( validRepoSignature(), "?", "Y", "N" )
 769                               << " pkg" << OUTS(_pimpl->rawPkgGpgCheck(),pkgGpgCheck()) << (pkgGpgCheckIsMandatory() ? "* ": " " )
 770                               << std::endl;
 771 #undef OUTS
 772
 773     for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
 774     {
 775       str << "- gpgkey      : " << url << std::endl;
 776     }
 777
 778     if ( ! indeterminate(_pimpl->keeppackages) )
 779       str << "- keeppackages: " << keepPackages() << std::endl;
 780
 781     strif( "- service     : ", service() );
 782     strif( "- targetdistro: ", targetDistribution() );
 783     strif( "- filePath:     ", filepath().asString() );
 784     strif( "- metadataPath: ", metadataPath().asString() );
 785     strif( "- packagesPath: ", packagesPath().asString() );
 786
 787     return str;
 788   }
 789
 790   std::ostream & RepoInfo::dumpAsIniOn( std::ostream & str ) const
 791   {
 792     RepoInfoBase::dumpAsIniOn(str);
 793
 794     if ( _pimpl->baseurl2dump() )
 795     {
 796       str << "baseurl=";
 797       std::string indent;
 798       for ( const auto & url : _pimpl->baseUrls().raw() )
 799       {
 800         str << indent << url << endl;
 801         if ( indent.empty() ) indent = "        ";      // "baseurl="
 802       }
 803     }
 804
 805     if ( ! _pimpl->path.empty() )
 806       str << "path="<< path() << endl;
 807
 808     if ( ! (rawMirrorListUrl().asString().empty()) )
 809       str << (_pimpl->_mirrorListForceMetalink ? "metalink=" : "mirrorlist=") << rawMirrorListUrl() << endl;
 810
 811     str << "type=" << type().asString() << endl;
 812
 813     if ( priority() != defaultPriority() )
 814       str << "priority=" << priority() << endl;
 815
 816     if ( ! indeterminate(_pimpl->rawGpgCheck()) )
 817       str << "gpgcheck=" << (_pimpl->rawGpgCheck() ? "1" : "0") << endl;
 818
 819     if ( ! indeterminate(_pimpl->rawRepoGpgCheck()) )
 820       str << "repo_gpgcheck=" << (_pimpl->rawRepoGpgCheck() ? "1" : "0") << endl;
 821
 822     if ( ! indeterminate(_pimpl->rawPkgGpgCheck()) )
 823       str << "pkg_gpgcheck=" << (_pimpl->rawPkgGpgCheck() ? "1" : "0") << endl;
 824
 825     {
 826       std::string indent( "gpgkey=");
 827       for ( const auto & url : _pimpl->gpgKeyUrls().raw() )
 828       {
 829         str << indent << url << endl;
 830         if ( indent[0] != ' ' )
 831           indent = "       ";
 832       }
 833     }
 834
 835     if (!indeterminate(_pimpl->keeppackages))
 836       str << "keeppackages=" << keepPackages() << endl;
 837
 838     if( ! service().empty() )
 839       str << "service=" << service() << endl;
 840
 841     return str;
 842   }
 843
 844   std::ostream & RepoInfo::dumpAsXmlOn( std::ostream & str, const std::string & content ) const
 845   {
 846     std::string tmpstr;
 847     str
 848       << "<repo"
 849       << " alias=\"" << escape(alias()) << "\""
 850       << " name=\"" << escape(name()) << "\"";
 851     if (type() != repo::RepoType::NONE)
 852       str << " type=\"" << type().asString() << "\"";
 853     str
 854       << " priority=\"" << priority() << "\""
 855       << " enabled=\"" << enabled() << "\""
 856       << " autorefresh=\"" << autorefresh() << "\""
 857       << " gpgcheck=\"" << gpgCheck() << "\""
 858       << " repo_gpgcheck=\"" << repoGpgCheck() << "\""
 859       << " pkg_gpgcheck=\"" << pkgGpgCheck() << "\"";
 860     if (!(tmpstr = gpgKeyUrl().asString()).empty())
 861       str << " gpgkey=\"" << escape(tmpstr) << "\"";
 862     if (!(tmpstr = mirrorListUrl().asString()).empty())
 863       str << (_pimpl->_mirrorListForceMetalink ? " metalink=\"" : " mirrorlist=\"") << escape(tmpstr) << "\"";
 864     str << ">" << endl;
 865
 866     if ( _pimpl->baseurl2dump() )
 867     {
 868       for_( it, baseUrlsBegin(), baseUrlsEnd() )        // !transform iterator replaces variables
 869         str << "<url>" << escape((*it).asString()) << "</url>" << endl;
 870     }
 871
 872     str << "</repo>" << endl;
 873     return str;
 874   }
 875
 876
 877   std::ostream & operator<<( std::ostream & str, const RepoInfo & obj )
 878   {
 879     return obj.dumpOn(str);
 880   }
 881
 882   std::ostream & operator<<( std::ostream & str, const RepoInfo::GpgCheck & obj )
 883   {
 884     switch ( obj )
 885     {
 886 #define OUTS( V ) case RepoInfo::V: return str << #V; break
 887       OUTS( GpgCheck::On );
 888       OUTS( GpgCheck::Strict );
 889       OUTS( GpgCheck::AllowUnsigned );
 890       OUTS( GpgCheck::AllowUnsignedRepo );
 891       OUTS( GpgCheck::AllowUnsignedPackage );
 892       OUTS( GpgCheck::Default );
 893       OUTS( GpgCheck::Off );
 894       OUTS( GpgCheck::indeterminate );
 895 #undef OUTS
 896     }
 897     return str << "GpgCheck::UNKNOWN";
 898   }
 899
 900   /////////////////////////////////////////////////////////////////
 901 } // namespace zypp
 902 ///////////////////////////////////////////////////////////////////