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 static const char *const 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 = zypp::getZYpp()->getTarget();
  89
  90   static const std::string _value(
  91       str::form(
  92           "X-Zypp-AnonymousId: %s",
  93           target ? target->anonymousUniqueId().c_str() : "" )
  94   );
  95   return _value.c_str();
  96 }
  97
  98 static const char *const distributionFlavorHeader()
  99 {
 100   // we need to add the release and identifier to the
 101   // agent string.
 102   // The target could be not initialized, and then this information
 103   // is not available.
 104   Target_Ptr target = zypp::getZYpp()->getTarget();
 105
 106   static const std::string _value(
 107       str::trim( str::form(
 108           "X-ZYpp-DistributionFlavor: %s",
 109           target ? target->distributionFlavor().c_str() : "" ) )
 110   );
 111   return _value.c_str();
 112 }
 113
 114 const char *const MediaAria2c::agentString()
 115 {
 116   // we need to add the release and identifier to the
 117   // agent string.
 118   // The target could be not initialized, and then this information
 119   // is not available.
 120   Target_Ptr target = zypp::getZYpp()->getTarget();
 121
 122   static const std::string _value(
 123     str::form(
 124        "ZYpp %s (%s) %s"
 125        , VERSION
 126        , MediaAria2c::_aria2cVersion.c_str()
 127        , target ? target->targetDistribution().c_str() : ""
 128     )
 129   );
 130   return _value.c_str();
 131 }
 132
 133
 134 MediaAria2c::MediaAria2c( const Url &      url_r,
 135                       const Pathname & attach_point_hint_r )
 136     : MediaHandler( url_r, attach_point_hint_r,
 137                     "/", // urlpath at attachpoint
 138                     true ) // does_download
 139 {
 140   MIL << "MediaAria2c::MediaAria2c(" << url_r << ", " << attach_point_hint_r << ")" << endl;
 141
 142   if( !attachPoint().empty())
 143   {
 144     PathInfo ainfo(attachPoint());
 145     Pathname apath(attachPoint() + "XXXXXX");
 146     char    *atemp = ::strdup( apath.asString().c_str());
 147     char    *atest = NULL;
 148     if( !ainfo.isDir() || !ainfo.userMayRWX() ||
 149          atemp == NULL || (atest=::mkdtemp(atemp)) == NULL)
 150     {
 151       WAR << "attach point " << ainfo.path()
 152           << " is not useable for " << url_r.getScheme() << endl;
 153       setAttachPoint("", true);
 154     }
 155     else if( atest != NULL)
 156       ::rmdir(atest);
 157
 158     if( atemp != NULL)
 159       ::free(atemp);
 160   }
 161
 162    //At this point, we initialize aria2c path
 163    _aria2cPath = Pathname( whereisAria2c().asString() );
 164
 165    //Get aria2c version
 166    _aria2cVersion = getAria2cVersion();
 167 }
 168
 169 void MediaAria2c::attachTo (bool next)
 170 {
 171    // clear last arguments
 172    _args.clear();
 173
 174   if ( next )
 175     ZYPP_THROW(MediaNotSupportedException(_url));
 176
 177   if ( !_url.isValid() )
 178     ZYPP_THROW(MediaBadUrlException(_url));
 179
 180   if( !isUseableAttachPoint(attachPoint()))
 181   {
 182     std::string mountpoint = createAttachPoint().asString();
 183
 184     if( mountpoint.empty())
 185       ZYPP_THROW( MediaBadAttachPointException(url()));
 186
 187     setAttachPoint( mountpoint, true);
 188   }
 189
 190   disconnectFrom();
 191
 192   // Build the aria command.
 193   _args.push_back(_aria2cPath.asString());
 194   _args.push_back(str::form("--user-agent=%s", agentString()));
 195   _args.push_back("--summary-interval=1");
 196   _args.push_back("--follow-metalink=mem");
 197   _args.push_back( "--check-integrity=true");
 198
 199    // add the anonymous id.
 200    _args.push_back(str::form("--header=%s", anonymousIdHeader() ));
 201    _args.push_back(str::form("--header=%s", distributionFlavorHeader() ));
 202   // TODO add debug option
 203
 204   // Transfer timeout
 205   {
 206     _xfer_timeout = TRANSFER_TIMEOUT;
 207
 208     std::string param(_url.getQueryParam("timeout"));
 209     if( !param.empty())
 210     {
 211       long num = str::strtonum<long>( param);
 212       if( num >= 0 && num <= TRANSFER_TIMEOUT_MAX)
 213         _xfer_timeout = num;
 214     }
 215   }
 216
 217   _args.push_back( str::form("--connect-timeout=%d", CONNECT_TIMEOUT));
 218
 219   // TODO limit redirections
 220   // TODO Implement certificate validation
 221
 222   // FTP defaults to anonymous
 223
 224
 225   if ( _url.getUsername().empty() )
 226   {
 227     if ( _url.getScheme() == "ftp" )
 228     {
 229       string id = "yast2@";
 230       id += VERSION;
 231       DBG << "Anonymous FTP identification: '" << id << "'" << endl;
 232       _userpwd = "anonymous:" + id;
 233     }
 234   }
 235   else
 236   {
 237      if ( _url.getScheme() == "ftp" )
 238      {
 239          _args.push_back(str::form("--ftp-user=%s", _url.getUsername().c_str() ));
 240      }
 241      else if ( _url.getScheme() == "http" ||
 242                _url.getScheme() == "https" )
 243     {
 244         _args.push_back(str::form("--http-user=%s", _url.getUsername().c_str() ));
 245     }
 246
 247     if ( _url.getPassword().size() )
 248     {
 249       if ( _url.getScheme() == "ftp" )
 250       {
 251           _args.push_back(str::form("--ftp-passwd=%s", _url.getPassword().c_str() ));
 252       }
 253       else if ( _url.getScheme() == "http" ||
 254                _url.getScheme() == "https" )
 255       {
 256           _args.push_back(str::form("--http-passwd=%s", _url.getPassword().c_str() ));
 257       }
 258     }
 259   }
 260
 261   // note, aria2c does not support setting the auth type with
 262   // (basic, digest yet)
 263
 264
 265   /*---------------------------------------------------------------*
 266    CURLOPT_PROXY: host[:port]
 267
 268    Url::option(proxy and proxyport)
 269    If not provided, /etc/sysconfig/proxy is evaluated
 270    *---------------------------------------------------------------*/
 271
 272   _proxy = _url.getQueryParam( "proxy" );
 273
 274   if ( ! _proxy.empty() )
 275   {
 276     string proxyport( _url.getQueryParam( "proxyport" ) );
 277     if ( ! proxyport.empty() ) {
 278       _proxy += ":" + proxyport;
 279     }
 280   }
 281   else
 282   {
 283
 284     ProxyInfo proxy_info (ProxyInfo::ImplPtr(new ProxyInfoSysconfig("proxy")));
 285
 286     if ( proxy_info.enabled())
 287     {
 288       bool useproxy = true;
 289
 290       std::list<std::string> nope = proxy_info.noProxy();
 291       for (ProxyInfo::NoProxyIterator it = proxy_info.noProxyBegin();
 292            it != proxy_info.noProxyEnd();
 293            it++)
 294       {
 295         std::string host( str::toLower(_url.getHost()));
 296         std::string temp( str::toLower(*it));
 297
 298         // no proxy if it points to a suffix
 299         // preceeded by a '.', that maches
 300         // the trailing portion of the host.
 301         if( temp.size() > 1 && temp.at(0) == '.')
 302         {
 303           if(host.size() > temp.size() &&
 304              host.compare(host.size() - temp.size(), temp.size(), temp) == 0)
 305           {
 306             DBG << "NO_PROXY: '" << *it  << "' matches host '"
 307                                  << host << "'" << endl;
 308             useproxy = false;
 309             break;
 310           }
 311         }
 312         else
 313         // no proxy if we have an exact match
 314         if( host == temp)
 315         {
 316           DBG << "NO_PROXY: '" << *it  << "' matches host '"
 317                                << host << "'" << endl;
 318           useproxy = false;
 319           break;
 320         }
 321       }
 322
 323       if ( useproxy ) {
 324         _proxy = proxy_info.proxy(_url.getScheme());
 325       }
 326     }
 327   }
 328
 329   DBG << "Proxy: " << (_proxy.empty() ? "-none-" : _proxy) << endl;
 330
 331   if ( ! _proxy.empty() )
 332   {
 333       _args.push_back(str::form("--http-proxy=%s", _proxy.c_str() ));
 334
 335      /*---------------------------------------------------------------*
 336      CURLOPT_PROXYUSERPWD: [user name]:[password]
 337
 338      Url::option(proxyuser and proxypassword) -> CURLOPT_PROXYUSERPWD
 339      If not provided, $HOME/.curlrc is evaluated
 340      *---------------------------------------------------------------*/
 341
 342     _proxyuserpwd = _url.getQueryParam( "proxyuser" );
 343
 344     if ( ! _proxyuserpwd.empty() ) {
 345         _args.push_back(str::form("--http-proxy-user=%s", _proxyuserpwd.c_str() ));
 346
 347       string proxypassword( _url.getQueryParam( "proxypassword" ) );
 348       if ( ! proxypassword.empty() ) {
 349           _args.push_back(str::form("--http-proxy-passwd=%s", proxypassword.c_str() ));
 350       }
 351     }
 352   }
 353
 354   //_currentCookieFile = _cookieFile.asString();
 355   //_args.push_back(str::form("--load-cookies=%s", _currentCookieFile.c_str()));
 356   //NOTE cookie jar?
 357
 358   // FIXME: need a derived class to propelly compare url's
 359   MediaSourceRef media( new MediaSource(_url.getScheme(), _url.asString()));
 360   setMediaSource(media);
 361
 362 }
 363
 364 bool
 365 MediaAria2c::checkAttachPoint(const Pathname &apoint) const
 366 {
 367   return MediaHandler::checkAttachPoint( apoint, true, true);
 368 }
 369
 370 void MediaAria2c::disconnectFrom()
 371 {
 372 }
 373
 374 void MediaAria2c::releaseFrom( const std::string & ejectDev )
 375 {
 376   disconnect();
 377 }
 378
 379 static Url getFileUrl(const Url & url, const Pathname & filename)
 380 {
 381   Url newurl(url);
 382   string path = url.getPathName();
 383   if ( !path.empty() && path != "/" && *path.rbegin() == '/' &&
 384        filename.absolute() )
 385   {
 386     // If url has a path with trailing slash, remove the leading slash from
 387     // the absolute file name
 388     path += filename.asString().substr( 1, filename.asString().size() - 1 );
 389   }
 390   else if ( filename.relative() )
 391   {
 392     // Add trailing slash to path, if not already there
 393     if (path.empty()) path = "/";
 394     else if (*path.rbegin() != '/' ) path += "/";
 395     // Remove "./" from begin of relative file name
 396     path += filename.asString().substr( 2, filename.asString().size() - 2 );
 397   }
 398   else
 399   {
 400     path += filename.asString();
 401   }
 402
 403   newurl.setPathName(path);
 404   return newurl;
 405 }
 406
 407 void MediaAria2c::getFile( const Pathname & filename ) const
 408 {
 409     // Use absolute file name to prevent access of files outside of the
 410     // hierarchy below the attach point.
 411     getFileCopy(filename, localPath(filename).absolutename());
 412 }
 413
 414 void MediaAria2c::getFileCopy( const Pathname & filename , const Pathname & target) const
 415 {
 416   callback::SendReport<DownloadProgressReport> report;
 417
 418   Url fileurl(getFileUrl(_url, filename));
 419
 420   bool retry = false;
 421
 422   ExternalProgram::Arguments args = _args;
 423   args.push_back(str::form("--dir=%s", target.dirname().c_str()));
 424
 425   args.push_back(fileurl.asString());
 426
 427   do
 428   {
 429     try
 430     {
 431       report->start(_url, target.asString() );
 432
 433       ExternalProgram aria(args, ExternalProgram::Stderr_To_Stdout);
 434       int nLine = 0;
 435
 436       //Process response
 437       for(std::string ariaResponse( aria.receiveLine());
 438           ariaResponse.length();
 439           ariaResponse = aria.receiveLine())
 440       {
 441         //cout << ariaResponse;
 442
 443         if (!ariaResponse.substr(0,31).compare("Exception: Authorization failed") )
 444         {
 445             ZYPP_THROW(MediaUnauthorizedException(
 446                   _url, "Login failed.", "Login failed", "auth hint"
 447                 ));
 448         }
 449         if (!ariaResponse.substr(0,29).compare("Exception: Resource not found") )
 450         {
 451             ZYPP_THROW(MediaFileNotFoundException(_url, filename));
 452         }
 453
 454         if (!ariaResponse.substr(0,9).compare("[#2 SIZE:"))
 455         {
 456           if (!nLine)
 457           {
 458             size_t left_bound = ariaResponse.find('(',0) + 1;
 459             size_t count = ariaResponse.find('%',left_bound) - left_bound;
 460             //cout << ariaResponse.substr(left_bound, count) << endl;
 461             //progressData.toMax();
 462             report->progress ( std::atoi(ariaResponse.substr(left_bound, count).c_str()), _url, -1, -1 );
 463             nLine = 1;
 464           }
 465           else
 466           {
 467             nLine = 0;
 468           }
 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.asUserHistory());
 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.asUserHistory());
 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 //