zypp/media/MediaAria2c.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/media/MediaAria2c.cc
  10  *
  11 */
  12
  13 #include <iostream>
  14 #include <list>
  15
  16 #include "zypp/base/Logger.h"
  17 #include "zypp/ExternalProgram.h"
  18 #include "zypp/ProgressData.h"
  19 #include "zypp/base/String.h"
  20 #include "zypp/base/Gettext.h"
  21 #include "zypp/base/Sysconfig.h"
  22 #include "zypp/base/Gettext.h"
  23 #include "zypp/ZYppCallbacks.h"
  24
  25 #include "zypp/Target.h"
  26 #include "zypp/ZYppFactory.h"
  27
  28 #include "zypp/media/MediaAria2c.h"
  29 #include "zypp/media/proxyinfo/ProxyInfos.h"
  30 #include "zypp/media/ProxyInfo.h"
  31 #include "zypp/media/MediaUserAuth.h"
  32 #include "zypp/thread/Once.h"
  33 #include <cstdlib>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <sys/mount.h>
  37 #include <errno.h>
  38 #include <dirent.h>
  39 #include <unistd.h>
  40 #include <boost/format.hpp>
  41
  42 #define  DETECT_DIR_INDEX       0
  43 #define  CONNECT_TIMEOUT        60
  44 #define  TRANSFER_TIMEOUT       60 * 3
  45 #define  TRANSFER_TIMEOUT_MAX   60 * 60
  46
  47
  48 using namespace std;
  49 using namespace zypp::base;
  50
  51 namespace zypp
  52 {
  53 namespace media
  54 {
  55
  56 Pathname MediaAria2c::_cookieFile = "/var/lib/YaST2/cookies";
  57 Pathname MediaAria2c::_aria2cPath = "/usr/local/bin/aria2c";
  58 std::string MediaAria2c::_aria2cVersion = "WE DON'T KNOW ARIA2C VERSION";
  59
  60 //check if aria2c is present in the system
  61 bool
  62 MediaAria2c::existsAria2cmd()
  63 {
  64     const char* argv[] =
  65     {
  66       "whereis",
  67       "-b",
  68       "aria2c",
  69       NULL
  70     };
  71
  72     ExternalProgram aria(argv, ExternalProgram::Stderr_To_Stdout);
  73
  74     std::string ariaResponse( aria.receiveLine());
  75     string::size_type pos = ariaResponse.find('/', 0 );
  76     if( pos != string::npos )
  77         return true;
  78     else
  79         return false;
  80 }
  81
  82 const char *const MediaAria2c::anonymousIdHeader()
  83 {
  84   // we need to add the release and identifier to the
  85   // agent string.
  86   // The target could be not initialized, and then this information
  87   // is not available.
  88   Target_Ptr target;
  89   // FIXME this has to go away as soon as the target
  90   // does not throw when not initialized.
  91   try {
  92       target = zypp::getZYpp()->target();
  93   }
  94   catch ( const Exception &e )
  95   {
  96       // nothing to do
  97   }
  98
  99   static const std::string _value(
 100       str::form(
 101           "X-ZYpp-AnonymousUniqueId: %s",
 102           target ? target->anonymousUniqueId().c_str() : "" )
 103   );
 104   return _value.c_str();
 105 }
 106
 107 const char *const MediaAria2c::agentString()
 108 {
 109   // we need to add the release and identifier to the
 110   // agent string.
 111   // The target could be not initialized, and then this information
 112   // is not available.
 113   Target_Ptr target;
 114   // FIXME this has to go away as soon as the target
 115   // does not throw when not initialized.
 116   try {
 117       target = zypp::getZYpp()->target();
 118   }
 119   catch ( const Exception &e )
 120   {
 121       // nothing to do
 122   }
 123
 124   static const std::string _value(
 125     str::form(
 126        "ZYpp %s (%s) %s"
 127        , VERSION
 128        , MediaAria2c::_aria2cVersion.c_str()
 129        , target ? target->targetDistribution().c_str() : ""
 130     )
 131   );
 132   return _value.c_str();
 133 }
 134
 135
 136 MediaAria2c::MediaAria2c( const Url &      url_r,
 137                       const Pathname & attach_point_hint_r )
 138     : MediaHandler( url_r, attach_point_hint_r,
 139                     "/", // urlpath at attachpoint
 140                     true ) // does_download
 141 {
 142   MIL << "MediaAria2c::MediaAria2c(" << url_r << ", " << attach_point_hint_r << ")" << endl;
 143
 144   if( !attachPoint().empty())
 145   {
 146     PathInfo ainfo(attachPoint());
 147     Pathname apath(attachPoint() + "XXXXXX");
 148     char    *atemp = ::strdup( apath.asString().c_str());
 149     char    *atest = NULL;
 150     if( !ainfo.isDir() || !ainfo.userMayRWX() ||
 151          atemp == NULL || (atest=::mkdtemp(atemp)) == NULL)
 152     {
 153       WAR << "attach point " << ainfo.path()
 154           << " is not useable for " << url_r.getScheme() << endl;
 155       setAttachPoint("", true);
 156     }
 157     else if( atest != NULL)
 158       ::rmdir(atest);
 159
 160     if( atemp != NULL)
 161       ::free(atemp);
 162   }
 163
 164    //At this point, we initialize aria2c path
 165    _aria2cPath = Pathname( whereisAria2c().asString() );
 166
 167    //Get aria2c version
 168    _aria2cVersion = getAria2cVersion();
 169 }
 170
 171 void MediaAria2c::attachTo (bool next)
 172 {
 173    // clear last arguments
 174    _args.clear();
 175
 176   if ( next )
 177     ZYPP_THROW(MediaNotSupportedException(_url));
 178
 179   if ( !_url.isValid() )
 180     ZYPP_THROW(MediaBadUrlException(_url));
 181
 182   if( !isUseableAttachPoint(attachPoint()))
 183   {
 184     std::string mountpoint = createAttachPoint().asString();
 185
 186     if( mountpoint.empty())
 187       ZYPP_THROW( MediaBadAttachPointException(url()));
 188
 189     setAttachPoint( mountpoint, true);
 190   }
 191
 192   disconnectFrom();
 193
 194   // Build the aria command.
 195   _args.push_back(_aria2cPath.asString());
 196   _args.push_back(str::form("--user-agent=%s", agentString()));
 197   _args.push_back("--summary-interval=1");
 198   _args.push_back("--follow-metalink=mem");
 199   _args.push_back( "--check-integrity=true");
 200
 201    // add the anonymous id.
 202    _args.push_back(str::form("--header=%s", anonymousIdHeader() ));
 203
 204   // TODO add debug option
 205
 206   // Transfer timeout
 207   {
 208     _xfer_timeout = TRANSFER_TIMEOUT;
 209
 210     std::string param(_url.getQueryParam("timeout"));
 211     if( !param.empty())
 212     {
 213       long num = str::strtonum<long>( param);
 214       if( num >= 0 && num <= TRANSFER_TIMEOUT_MAX)
 215         _xfer_timeout = num;
 216     }
 217   }
 218
 219   _args.push_back( str::form("--connect-timeout=%d", CONNECT_TIMEOUT));
 220
 221   // TODO limit redirections
 222   // TODO Implement certificate validation
 223
 224   // FTP defaults to anonymous
 225
 226
 227   if ( _url.getUsername().empty() )
 228   {
 229     if ( _url.getScheme() == "ftp" )
 230     {
 231       string id = "yast2@";
 232       id += VERSION;
 233       DBG << "Anonymous FTP identification: '" << id << "'" << endl;
 234       _userpwd = "anonymous:" + id;
 235     }
 236   }
 237   else
 238   {
 239      if ( _url.getScheme() == "ftp" )
 240      {
 241          _args.push_back(str::form("--ftp-user=%s", _url.getUsername().c_str() ));
 242      }
 243      else if ( _url.getScheme() == "http" ||
 244                _url.getScheme() == "https" )
 245     {
 246         _args.push_back(str::form("--http-user=%s", _url.getUsername().c_str() ));
 247     }
 248
 249     if ( _url.getPassword().size() )
 250     {
 251       if ( _url.getScheme() == "ftp" )
 252       {
 253           _args.push_back(str::form("--ftp-passwd=%s", _url.getPassword().c_str() ));
 254       }
 255       else if ( _url.getScheme() == "http" ||
 256                _url.getScheme() == "https" )
 257       {
 258           _args.push_back(str::form("--http-passwd=%s", _url.getPassword().c_str() ));
 259       }
 260     }
 261   }
 262
 263   // note, aria2c does not support setting the auth type with
 264   // (basic, digest yet)
 265
 266
 267   /*---------------------------------------------------------------*
 268    CURLOPT_PROXY: host[:port]
 269
 270    Url::option(proxy and proxyport)
 271    If not provided, /etc/sysconfig/proxy is evaluated
 272    *---------------------------------------------------------------*/
 273
 274   _proxy = _url.getQueryParam( "proxy" );
 275
 276   if ( ! _proxy.empty() )
 277   {
 278     string proxyport( _url.getQueryParam( "proxyport" ) );
 279     if ( ! proxyport.empty() ) {
 280       _proxy += ":" + proxyport;
 281     }
 282   }
 283   else
 284   {
 285
 286     ProxyInfo proxy_info (ProxyInfo::ImplPtr(new ProxyInfoSysconfig("proxy")));
 287
 288     if ( proxy_info.enabled())
 289     {
 290       bool useproxy = true;
 291
 292       std::list<std::string> nope = proxy_info.noProxy();
 293       for (ProxyInfo::NoProxyIterator it = proxy_info.noProxyBegin();
 294            it != proxy_info.noProxyEnd();
 295            it++)
 296       {
 297         std::string host( str::toLower(_url.getHost()));
 298         std::string temp( str::toLower(*it));
 299
 300         // no proxy if it points to a suffix
 301         // preceeded by a '.', that maches
 302         // the trailing portion of the host.
 303         if( temp.size() > 1 && temp.at(0) == '.')
 304         {
 305           if(host.size() > temp.size() &&
 306              host.compare(host.size() - temp.size(), temp.size(), temp) == 0)
 307           {
 308             DBG << "NO_PROXY: '" << *it  << "' matches host '"
 309                                  << host << "'" << endl;
 310             useproxy = false;
 311             break;
 312           }
 313         }
 314         else
 315         // no proxy if we have an exact match
 316         if( host == temp)
 317         {
 318           DBG << "NO_PROXY: '" << *it  << "' matches host '"
 319                                << host << "'" << endl;
 320           useproxy = false;
 321           break;
 322         }
 323       }
 324
 325       if ( useproxy ) {
 326         _proxy = proxy_info.proxy(_url.getScheme());
 327       }
 328     }
 329   }
 330
 331   DBG << "Proxy: " << (_proxy.empty() ? "-none-" : _proxy) << endl;
 332
 333   if ( ! _proxy.empty() )
 334   {
 335       _args.push_back(str::form("--http-proxy=%s", _proxy.c_str() ));
 336
 337      /*---------------------------------------------------------------*
 338      CURLOPT_PROXYUSERPWD: [user name]:[password]
 339
 340      Url::option(proxyuser and proxypassword) -> CURLOPT_PROXYUSERPWD
 341      If not provided, $HOME/.curlrc is evaluated
 342      *---------------------------------------------------------------*/
 343
 344     _proxyuserpwd = _url.getQueryParam( "proxyuser" );
 345
 346     if ( ! _proxyuserpwd.empty() ) {
 347         _args.push_back(str::form("--http-proxy-user=%s", _proxyuserpwd.c_str() ));
 348
 349       string proxypassword( _url.getQueryParam( "proxypassword" ) );
 350       if ( ! proxypassword.empty() ) {
 351           _args.push_back(str::form("--http-proxy-passwd=%s", proxypassword.c_str() ));
 352       }
 353     }
 354   }
 355
 356   //_currentCookieFile = _cookieFile.asString();
 357   //_args.push_back(str::form("--load-cookies=%s", _currentCookieFile.c_str()));
 358   //NOTE cookie jar?
 359
 360   // FIXME: need a derived class to propelly compare url's
 361   MediaSourceRef media( new MediaSource(_url.getScheme(), _url.asString()));
 362   setMediaSource(media);
 363
 364 }
 365
 366 bool
 367 MediaAria2c::checkAttachPoint(const Pathname &apoint) const
 368 {
 369   return MediaHandler::checkAttachPoint( apoint, true, true);
 370 }
 371
 372 void MediaAria2c::disconnectFrom()
 373 {
 374 }
 375
 376 void MediaAria2c::releaseFrom( const std::string & ejectDev )
 377 {
 378   disconnect();
 379 }
 380
 381 static Url getFileUrl(const Url & url, const Pathname & filename)
 382 {
 383   Url newurl(url);
 384   string path = url.getPathName();
 385   if ( !path.empty() && path != "/" && *path.rbegin() == '/' &&
 386        filename.absolute() )
 387   {
 388     // If url has a path with trailing slash, remove the leading slash from
 389     // the absolute file name
 390     path += filename.asString().substr( 1, filename.asString().size() - 1 );
 391   }
 392   else if ( filename.relative() )
 393   {
 394     // Add trailing slash to path, if not already there
 395     if (path.empty()) path = "/";
 396     else if (*path.rbegin() != '/' ) path += "/";
 397     // Remove "./" from begin of relative file name
 398     path += filename.asString().substr( 2, filename.asString().size() - 2 );
 399   }
 400   else
 401   {
 402     path += filename.asString();
 403   }
 404
 405   newurl.setPathName(path);
 406   return newurl;
 407 }
 408
 409 void MediaAria2c::getFile( const Pathname & filename ) const
 410 {
 411     // Use absolute file name to prevent access of files outside of the
 412     // hierarchy below the attach point.
 413     getFileCopy(filename, localPath(filename).absolutename());
 414 }
 415
 416 void MediaAria2c::getFileCopy( const Pathname & filename , const Pathname & target) const
 417 {
 418   callback::SendReport<DownloadProgressReport> report;
 419
 420   Url fileurl(getFileUrl(_url, filename));
 421
 422   bool retry = false;
 423
 424   ExternalProgram::Arguments args = _args;
 425   args.push_back(str::form("--dir=%s", target.dirname().c_str()));
 426   args.push_back(fileurl.asString());
 427
 428   do
 429   {
 430     try
 431     {
 432       report->start(_url, target.asString() );
 433
 434       ExternalProgram aria(args, ExternalProgram::Stderr_To_Stdout);
 435       int nLine = 0;
 436
 437       //Process response
 438       for(std::string ariaResponse( aria.receiveLine());
 439           ariaResponse.length();
 440           ariaResponse = aria.receiveLine())
 441       {
 442         //cout << ariaResponse;
 443
 444         if (!ariaResponse.substr(0,31).compare("Exception: Authorization failed") )
 445         {
 446             ZYPP_THROW(MediaUnauthorizedException(
 447                   _url, "Login failed.", "Login failed", "auth hint"
 448                 ));
 449         }
 450         if (!ariaResponse.substr(0,29).compare("Exception: Resource not found") )
 451         {
 452             ZYPP_THROW(MediaFileNotFoundException(_url, filename));
 453         }
 454
 455         if (!ariaResponse.substr(0,9).compare("[#2 SIZE:")) {
 456
 457           if (!nLine)
 458           {
 459             size_t left_bound = ariaResponse.find('(',0) + 1;
 460             size_t count = ariaResponse.find('%',left_bound) - left_bound;
 461             //cout << ariaResponse.substr(left_bound, count) << endl;
 462             //progressData.toMax();
 463             report->progress ( std::atoi(ariaResponse.substr(left_bound, count).c_str()), _url, -1, -1 );
 464             nLine = 1;
 465           }
 466           else
 467           {
 468             nLine = 0;
 469           }
 470         }
 471       }
 472       aria.close();
 473
 474       report->finish( _url ,  zypp::media::DownloadProgressReport::NO_ERROR, "");
 475       retry = false;
 476     }
 477
 478     // retry with proper authentication data
 479     catch (MediaUnauthorizedException & ex_r)
 480     {
 481       if(authenticate(ex_r.hint(), !retry))
 482         retry = true;
 483       else
 484       {
 485         report->finish(fileurl, zypp::media::DownloadProgressReport::ACCESS_DENIED, ex_r.asUserString());
 486         ZYPP_RETHROW(ex_r);
 487       }
 488
 489     }
 490     // unexpected exception
 491     catch (MediaException & excpt_r)
 492     {
 493       // FIXME: error number fix
 494       report->finish(fileurl, zypp::media::DownloadProgressReport::ERROR, excpt_r.asUserString());
 495       ZYPP_RETHROW(excpt_r);
 496     }
 497   }
 498   while (retry);
 499
 500   report->finish(fileurl, zypp::media::DownloadProgressReport::NO_ERROR, "");
 501 }
 502
 503 bool MediaAria2c::getDoesFileExist( const Pathname & filename ) const
 504 {
 505   bool retry = false;
 506   AuthData auth_data;
 507
 508   do
 509   {
 510     try
 511     {
 512       return doGetDoesFileExist( filename );
 513     }
 514     // authentication problem, retry with proper authentication data
 515     catch (MediaUnauthorizedException & ex_r)
 516     {
 517       if(authenticate(ex_r.hint(), !retry))
 518         retry = true;
 519       else
 520         ZYPP_RETHROW(ex_r);
 521     }
 522     // unexpected exception
 523     catch (MediaException & excpt_r)
 524     {
 525       ZYPP_RETHROW(excpt_r);
 526     }
 527   }
 528   while (retry);
 529
 530   return false;
 531 }
 532
 533 bool MediaAria2c::doGetDoesFileExist( const Pathname & filename ) const
 534 {
 535
 536   DBG << filename.asString() << endl;
 537   return true;
 538 }
 539
 540 void MediaAria2c::getDir( const Pathname & dirname, bool recurse_r ) const
 541 {
 542   filesystem::DirContent content;
 543   getDirInfo( content, dirname, /*dots*/false );
 544
 545   for ( filesystem::DirContent::const_iterator it = content.begin(); it != content.end(); ++it ) {
 546       Pathname filename = dirname + it->name;
 547       int res = 0;
 548
 549       switch ( it->type ) {
 550       case filesystem::FT_NOT_AVAIL: // old directory.yast contains no typeinfo at all
 551       case filesystem::FT_FILE:
 552         getFile( filename );
 553         break;
 554       case filesystem::FT_DIR: // newer directory.yast contain at least directory info
 555         if ( recurse_r ) {
 556           getDir( filename, recurse_r );
 557         } else {
 558           res = assert_dir( localPath( filename ) );
 559           if ( res ) {
 560             WAR << "Ignore error (" << res <<  ") on creating local directory '" << localPath( filename ) << "'" << endl;
 561           }
 562         }
 563         break;
 564       default:
 565         // don't provide devices, sockets, etc.
 566         break;
 567       }
 568   }
 569 }
 570
 571 bool MediaAria2c::authenticate(const std::string & availAuthTypes, bool firstTry) const
 572 {
 573     return false;
 574 }
 575
 576
 577 void MediaAria2c::getDirInfo( std::list<std::string> & retlist,
 578                                const Pathname & dirname, bool dots ) const
 579 {
 580   getDirectoryYast( retlist, dirname, dots );
 581 }
 582
 583 void MediaAria2c::getDirInfo( filesystem::DirContent & retlist,
 584                             const Pathname & dirname, bool dots ) const
 585 {
 586   getDirectoryYast( retlist, dirname, dots );
 587 }
 588
 589 std::string MediaAria2c::getAria2cVersion()
 590 {
 591     const char* argv[] =
 592     {
 593         _aria2cPath.c_str(),
 594       "--version",
 595       NULL
 596     };
 597
 598     ExternalProgram aria(argv, ExternalProgram::Stderr_To_Stdout);
 599
 600     std::string vResponse = aria.receiveLine();
 601     aria.close();
 602     return str::trim(vResponse);
 603 }
 604
 605 #define ARIA_DEFAULT_BINARY "/usr/bin/aria2c"
 606
 607 Pathname MediaAria2c::whereisAria2c()
 608 {
 609     Pathname aria2cPathr(ARIA_DEFAULT_BINARY);
 610
 611     const char* argv[] =
 612     {
 613       "whereis",
 614       "-b",
 615       "aria2c",
 616       NULL
 617     };
 618
 619     ExternalProgram aria(argv, ExternalProgram::Stderr_To_Stdout);
 620
 621     std::string ariaResponse( aria.receiveLine());
 622     aria.close();
 623
 624     string::size_type pos = ariaResponse.find('/', 0 );
 625     if( pos != string::npos )
 626     {
 627         aria2cPathr = ariaResponse;
 628         string::size_type pose = ariaResponse.find(' ', pos + 1 );
 629         aria2cPathr = ariaResponse.substr( pos , pose - pos );
 630         MIL << "We will use aria2c located here:  " << ariaResponse.substr( pos , pose - pos) << endl;
 631     }
 632     else
 633     {
 634         MIL << "We don't know were is ari2ac binary. We will use aria2c located here:  " << aria2cPathr << endl;
 635     }
 636
 637     return aria2cPathr;
 638 }
 639
 640 } // namespace media
 641 } // namespace zypp
 642 //