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 (aria2c %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("--ftp-user");
 242        _args.push_back(_url.getUsername());
 243      }
 244      else if ( _url.getScheme() == "http" ||
 245                _url.getScheme() == "https" )
 246     {
 247       _args.push_back("--http-user");
 248       _args.push_back(_url.getUsername());
 249     }
 250
 251     if ( _url.getPassword().size() )
 252     {
 253       if ( _url.getScheme() == "ftp" )
 254       {
 255         _args.push_back("--ftp-passwd");
 256         _args.push_back(_url.getPassword());
 257       }
 258       else if ( _url.getScheme() == "http" ||
 259                _url.getScheme() == "https" )
 260       {
 261         _args.push_back("--http-passwd");
 262         _args.push_back(_url.getPassword());
 263       }
 264     }
 265   }
 266
 267   // note, aria2c does not support setting the auth type with
 268   // (basic, digest yet)
 269
 270
 271   /*---------------------------------------------------------------*
 272    CURLOPT_PROXY: host[:port]
 273
 274    Url::option(proxy and proxyport)
 275    If not provided, /etc/sysconfig/proxy is evaluated
 276    *---------------------------------------------------------------*/
 277
 278   _proxy = _url.getQueryParam( "proxy" );
 279
 280   if ( ! _proxy.empty() )
 281   {
 282     string proxyport( _url.getQueryParam( "proxyport" ) );
 283     if ( ! proxyport.empty() ) {
 284       _proxy += ":" + proxyport;
 285     }
 286   }
 287   else
 288   {
 289
 290     ProxyInfo proxy_info (ProxyInfo::ImplPtr(new ProxyInfoSysconfig("proxy")));
 291
 292     if ( proxy_info.enabled())
 293     {
 294       bool useproxy = true;
 295
 296       std::list<std::string> nope = proxy_info.noProxy();
 297       for (ProxyInfo::NoProxyIterator it = proxy_info.noProxyBegin();
 298            it != proxy_info.noProxyEnd();
 299            it++)
 300       {
 301         std::string host( str::toLower(_url.getHost()));
 302         std::string temp( str::toLower(*it));
 303
 304         // no proxy if it points to a suffix
 305         // preceeded by a '.', that maches
 306         // the trailing portion of the host.
 307         if( temp.size() > 1 && temp.at(0) == '.')
 308         {
 309           if(host.size() > temp.size() &&
 310              host.compare(host.size() - temp.size(), temp.size(), temp) == 0)
 311           {
 312             DBG << "NO_PROXY: '" << *it  << "' matches host '"
 313                                  << host << "'" << endl;
 314             useproxy = false;
 315             break;
 316           }
 317         }
 318         else
 319         // no proxy if we have an exact match
 320         if( host == temp)
 321         {
 322           DBG << "NO_PROXY: '" << *it  << "' matches host '"
 323                                << host << "'" << endl;
 324           useproxy = false;
 325           break;
 326         }
 327       }
 328
 329       if ( useproxy ) {
 330         _proxy = proxy_info.proxy(_url.getScheme());
 331       }
 332     }
 333   }
 334
 335   DBG << "Proxy: " << (_proxy.empty() ? "-none-" : _proxy) << endl;
 336
 337   if ( ! _proxy.empty() )
 338   {
 339     _args.push_back("-—http-proxy");
 340     _args.push_back(_proxy);
 341
 342      /*---------------------------------------------------------------*
 343      CURLOPT_PROXYUSERPWD: [user name]:[password]
 344
 345      Url::option(proxyuser and proxypassword) -> CURLOPT_PROXYUSERPWD
 346      If not provided, $HOME/.curlrc is evaluated
 347      *---------------------------------------------------------------*/
 348
 349     _proxyuserpwd = _url.getQueryParam( "proxyuser" );
 350
 351     if ( ! _proxyuserpwd.empty() ) {
 352       _args.push_back("-—http-proxy-user");
 353       _args.push_back(_proxyuserpwd);
 354
 355       string proxypassword( _url.getQueryParam( "proxypassword" ) );
 356       if ( ! proxypassword.empty() ) {
 357         _args.push_back("-—http-proxy-passwd");
 358         _args.push_back(proxypassword);
 359       }
 360     }
 361   }
 362
 363   _currentCookieFile = _cookieFile.asString();
 364   _args.push_back("-—load-cookies");
 365   _args.push_back(_currentCookieFile);
 366
 367   // NOTE cookie jar?
 368
 369   // FIXME: need a derived class to propelly compare url's
 370   MediaSourceRef media( new MediaSource(_url.getScheme(), _url.asString()));
 371   setMediaSource(media);
 372
 373 }
 374
 375 bool
 376 MediaAria2c::checkAttachPoint(const Pathname &apoint) const
 377 {
 378   return MediaHandler::checkAttachPoint( apoint, true, true);
 379 }
 380
 381 void MediaAria2c::disconnectFrom()
 382 {
 383 }
 384
 385 void MediaAria2c::releaseFrom( const std::string & ejectDev )
 386 {
 387   disconnect();
 388 }
 389
 390 static Url getFileUrl(const Url & url, const Pathname & filename)
 391 {
 392   Url newurl(url);
 393   string path = url.getPathName();
 394   if ( !path.empty() && path != "/" && *path.rbegin() == '/' &&
 395        filename.absolute() )
 396   {
 397     // If url has a path with trailing slash, remove the leading slash from
 398     // the absolute file name
 399     path += filename.asString().substr( 1, filename.asString().size() - 1 );
 400   }
 401   else if ( filename.relative() )
 402   {
 403     // Add trailing slash to path, if not already there
 404     if (path.empty()) path = "/";
 405     else if (*path.rbegin() != '/' ) path += "/";
 406     // Remove "./" from begin of relative file name
 407     path += filename.asString().substr( 2, filename.asString().size() - 2 );
 408   }
 409   else
 410   {
 411     path += filename.asString();
 412   }
 413
 414   newurl.setPathName(path);
 415   return newurl;
 416 }
 417
 418 void MediaAria2c::getFile( const Pathname & filename ) const
 419 {
 420     // Use absolute file name to prevent access of files outside of the
 421     // hierarchy below the attach point.
 422     getFileCopy(filename, localPath(filename).absolutename());
 423 }
 424
 425 void MediaAria2c::getFileCopy( const Pathname & filename , const Pathname & target) const
 426 {
 427   callback::SendReport<DownloadProgressReport> report;
 428
 429   Url fileurl(getFileUrl(_url, filename));
 430
 431   bool retry = false;
 432
 433   ExternalProgram::Arguments args = _args;
 434   args.push_back(str::form("--dir=\"%s\"", target.dirname().c_str()));
 435   args.push_back(fileurl.asString());
 436
 437   do
 438   {
 439     try
 440     {
 441       report->start(_url, target.asString() );
 442
 443       ExternalProgram aria(args, ExternalProgram::Stderr_To_Stdout);
 444       int nLine = 0;
 445
 446       //Process response
 447       for(std::string ariaResponse( aria.receiveLine());
 448           ariaResponse.length();
 449           ariaResponse = aria.receiveLine())
 450       {
 451         //cout << ariaResponse;
 452
 453         if (!ariaResponse.substr(0,31).compare("Exception: Authorization failed") )
 454         {
 455             ZYPP_THROW(MediaUnauthorizedException(
 456                   _url, "Login failed.", "Login failed", "auth hint"
 457                 ));
 458         }
 459         if (!ariaResponse.substr(0,29).compare("Exception: Resource not found") )
 460         {
 461             ZYPP_THROW(MediaFileNotFoundException(_url, filename));
 462         }
 463
 464         if (!ariaResponse.substr(0,9).compare("[#2 SIZE:")) {
 465
 466           if (!nLine)
 467           {
 468             size_t left_bound = ariaResponse.find('(',0) + 1;
 469             size_t count = ariaResponse.find('%',left_bound) - left_bound;
 470             //cout << ariaResponse.substr(left_bound, count) << endl;
 471             //progressData.toMax();
 472             report->progress ( std::atoi(ariaResponse.substr(left_bound, count).c_str()), _url, -1, -1 );
 473             nLine = 1;
 474           }
 475           else
 476           {
 477             nLine = 0;
 478           }
 479         }
 480       }
 481       aria.close();
 482
 483       report->finish( _url ,  zypp::media::DownloadProgressReport::NO_ERROR, "");
 484       retry = false;
 485     }
 486
 487     // retry with proper authentication data
 488     catch (MediaUnauthorizedException & ex_r)
 489     {
 490       if(authenticate(ex_r.hint(), !retry))
 491         retry = true;
 492       else
 493       {
 494         report->finish(fileurl, zypp::media::DownloadProgressReport::ACCESS_DENIED, ex_r.asUserString());
 495         ZYPP_RETHROW(ex_r);
 496       }
 497
 498     }
 499     // unexpected exception
 500     catch (MediaException & excpt_r)
 501     {
 502       // FIXME: error number fix
 503       report->finish(fileurl, zypp::media::DownloadProgressReport::ERROR, excpt_r.asUserString());
 504       ZYPP_RETHROW(excpt_r);
 505     }
 506   }
 507   while (retry);
 508
 509   report->finish(fileurl, zypp::media::DownloadProgressReport::NO_ERROR, "");
 510 }
 511
 512 bool MediaAria2c::getDoesFileExist( const Pathname & filename ) const
 513 {
 514   bool retry = false;
 515   AuthData auth_data;
 516
 517   do
 518   {
 519     try
 520     {
 521       return doGetDoesFileExist( filename );
 522     }
 523     // authentication problem, retry with proper authentication data
 524     catch (MediaUnauthorizedException & ex_r)
 525     {
 526       if(authenticate(ex_r.hint(), !retry))
 527         retry = true;
 528       else
 529         ZYPP_RETHROW(ex_r);
 530     }
 531     // unexpected exception
 532     catch (MediaException & excpt_r)
 533     {
 534       ZYPP_RETHROW(excpt_r);
 535     }
 536   }
 537   while (retry);
 538
 539   return false;
 540 }
 541
 542 bool MediaAria2c::doGetDoesFileExist( const Pathname & filename ) const
 543 {
 544
 545   DBG << filename.asString() << endl;
 546   return true;
 547 }
 548
 549 void MediaAria2c::getDir( const Pathname & dirname, bool recurse_r ) const
 550 {
 551   filesystem::DirContent content;
 552   getDirInfo( content, dirname, /*dots*/false );
 553
 554   for ( filesystem::DirContent::const_iterator it = content.begin(); it != content.end(); ++it ) {
 555       Pathname filename = dirname + it->name;
 556       int res = 0;
 557
 558       switch ( it->type ) {
 559       case filesystem::FT_NOT_AVAIL: // old directory.yast contains no typeinfo at all
 560       case filesystem::FT_FILE:
 561         getFile( filename );
 562         break;
 563       case filesystem::FT_DIR: // newer directory.yast contain at least directory info
 564         if ( recurse_r ) {
 565           getDir( filename, recurse_r );
 566         } else {
 567           res = assert_dir( localPath( filename ) );
 568           if ( res ) {
 569             WAR << "Ignore error (" << res <<  ") on creating local directory '" << localPath( filename ) << "'" << endl;
 570           }
 571         }
 572         break;
 573       default:
 574         // don't provide devices, sockets, etc.
 575         break;
 576       }
 577   }
 578 }
 579
 580 bool MediaAria2c::authenticate(const std::string & availAuthTypes, bool firstTry) const
 581 {
 582     return false;
 583 }
 584
 585
 586 void MediaAria2c::getDirInfo( std::list<std::string> & retlist,
 587                                const Pathname & dirname, bool dots ) const
 588 {
 589   getDirectoryYast( retlist, dirname, dots );
 590 }
 591
 592 void MediaAria2c::getDirInfo( filesystem::DirContent & retlist,
 593                             const Pathname & dirname, bool dots ) const
 594 {
 595   getDirectoryYast( retlist, dirname, dots );
 596 }
 597
 598 std::string MediaAria2c::getAria2cVersion()
 599 {
 600     const char* argv[] =
 601     {
 602         _aria2cPath.c_str(),
 603       "--version",
 604       NULL
 605     };
 606
 607     ExternalProgram aria(argv, ExternalProgram::Stderr_To_Stdout);
 608
 609     std::string vResponse = aria.receiveLine();
 610     aria.close();
 611     return vResponse;
 612 }
 613
 614 #define ARIA_DEFAULT_BINARY "/usr/bin/aria2c"
 615
 616 Pathname MediaAria2c::whereisAria2c()
 617 {
 618     Pathname aria2cPathr(ARIA_DEFAULT_BINARY);
 619
 620     const char* argv[] =
 621     {
 622       "whereis",
 623       "-b",
 624       "aria2c",
 625       NULL
 626     };
 627
 628     ExternalProgram aria(argv, ExternalProgram::Stderr_To_Stdout);
 629
 630     std::string ariaResponse( aria.receiveLine());
 631     aria.close();
 632
 633     string::size_type pos = ariaResponse.find('/', 0 );
 634     if( pos != string::npos )
 635     {
 636         aria2cPathr = ariaResponse;
 637         string::size_type pose = ariaResponse.find(' ', pos + 1 );
 638         aria2cPathr = ariaResponse.substr( pos , pose - pos );
 639         MIL << "We will use aria2c located here:  " << ariaResponse.substr( pos , pose - pos) << endl;
 640     }
 641     else
 642     {
 643         MIL << "We don't know were is ari2ac binary. We will use aria2c located here:  " << aria2cPathr << endl;
 644     }
 645
 646     return aria2cPathr;
 647 }
 648
 649 } // namespace media
 650 } // namespace zypp
 651 //