apt-pkg/acquire-item.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire-item.cc,v 1.46.2.9 2004/01/16 18:51:11 mdz Exp $
   4 /* ######################################################################
   5
   6    Acquire Item - Item to acquire
   7
   8    Each item can download to exactly one file at a time. This means you
   9    cannot create an item that fetches two uri's to two files at the same
  10    time. The pkgAcqIndex class creates a second class upon instantiation
  11    to fetch the other index files because of this.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #ifdef __GNUG__
  17 #pragma implementation "apt-pkg/acquire-item.h"
  18 #endif
  19 #include <apt-pkg/acquire-item.h>
  20 #include <apt-pkg/configuration.h>
  21 #include <apt-pkg/sourcelist.h>
  22 #include <apt-pkg/vendorlist.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/strutl.h>
  25 #include <apt-pkg/fileutl.h>
  26 #include <apt-pkg/md5.h>
  27
  28 #include <apti18n.h>
  29
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <string>
  34 #include <stdio.h>
  35                                                                         /*}}}*/
  36
  37 using namespace std;
  38
  39 // Acquire::Item::Item - Constructor                                    /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* */
  42 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),
  43                        PartialSize(0), Mode(0), ID(0), Complete(false),
  44                        Local(false), QueueCounter(0)
  45 {
  46    Owner->Add(this);
  47    Status = StatIdle;
  48 }
  49                                                                         /*}}}*/
  50 // Acquire::Item::~Item - Destructor                                    /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* */
  53 pkgAcquire::Item::~Item()
  54 {
  55    Owner->Remove(this);
  56 }
  57                                                                         /*}}}*/
  58 // Acquire::Item::Failed - Item failed to download                      /*{{{*/
  59 // ---------------------------------------------------------------------
  60 /* We return to an idle state if there are still other queues that could
  61    fetch this object */
  62 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
  63 {
  64    Status = StatIdle;
  65    ErrorText = LookupTag(Message,"Message");
  66    if (QueueCounter <= 1)
  67    {
  68       /* This indicates that the file is not available right now but might
  69          be sometime later. If we do a retry cycle then this should be
  70          retried [CDROMs] */
  71       if (Cnf->LocalOnly == true &&
  72           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
  73       {
  74          Status = StatIdle;
  75          Dequeue();
  76          return;
  77       }
  78
  79       Status = StatError;
  80       Dequeue();
  81    }
  82 }
  83                                                                         /*}}}*/
  84 // Acquire::Item::Start - Item has begun to download                    /*{{{*/
  85 // ---------------------------------------------------------------------
  86 /* Stash status and the file size. Note that setting Complete means
  87    sub-phases of the acquire process such as decompresion are operating */
  88 void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size)
  89 {
  90    Status = StatFetching;
  91    if (FileSize == 0 && Complete == false)
  92       FileSize = Size;
  93 }
  94                                                                         /*}}}*/
  95 // Acquire::Item::Done - Item downloaded OK                             /*{{{*/
  96 // ---------------------------------------------------------------------
  97 /* */
  98 void pkgAcquire::Item::Done(string Message,unsigned long Size,string,
  99                             pkgAcquire::MethodConfig *Cnf)
 100 {
 101    // We just downloaded something..
 102    string FileName = LookupTag(Message,"Filename");
 103    if (Complete == false && FileName == DestFile)
 104    {
 105       if (Owner->Log != 0)
 106          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 107    }
 108
 109    if (FileSize == 0)
 110       FileSize= Size;
 111
 112    Status = StatDone;
 113    ErrorText = string();
 114    Owner->Dequeue(this);
 115 }
 116                                                                         /*}}}*/
 117 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 118 // ---------------------------------------------------------------------
 119 /* This helper function is used by alot of item methods as thier final
 120    step */
 121 void pkgAcquire::Item::Rename(string From,string To)
 122 {
 123    if (rename(From.c_str(),To.c_str()) != 0)
 124    {
 125       char S[300];
 126       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 127               From.c_str(),To.c_str());
 128       Status = StatError;
 129       ErrorText = S;
 130    }
 131 }
 132                                                                         /*}}}*/
 133
 134 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 135 // ---------------------------------------------------------------------
 136 /* The package file is added to the queue and a second class is
 137    instantiated to fetch the revision file */
 138 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 139                          string URI,string URIDesc,string ShortDesc,
 140                          string ExpectedMD5, string comprExt) :
 141    Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5)
 142 {
 143    Decompression = false;
 144    Erase = false;
 145
 146    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 147    DestFile += URItoFileName(URI);
 148
 149    if(comprExt.empty())
 150    {
 151       // autoselect the compression method
 152       if(FileExists("/usr/bin/bzip2"))
 153          CompressionExtension = ".bz2";
 154       else
 155          CompressionExtension = ".gz";
 156    } else {
 157       CompressionExtension = comprExt;
 158    }
 159    Desc.URI = URI + CompressionExtension;
 160
 161    Desc.Description = URIDesc;
 162    Desc.Owner = this;
 163    Desc.ShortDesc = ShortDesc;
 164
 165    QueueURI(Desc);
 166 }
 167                                                                         /*}}}*/
 168 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 169 // ---------------------------------------------------------------------
 170 /* The only header we use is the last-modified header. */
 171 string pkgAcqIndex::Custom600Headers()
 172 {
 173    string Final = _config->FindDir("Dir::State::lists");
 174    Final += URItoFileName(RealURI);
 175
 176    struct stat Buf;
 177    if (stat(Final.c_str(),&Buf) != 0)
 178       return "\nIndex-File: true";
 179
 180    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 181 }
 182                                                                         /*}}}*/
 183
 184 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 185 {
 186    // no .bz2 found, retry with .gz
 187    if(Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1) == "bz2") {
 188       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz";
 189
 190       // retry with a gzip one
 191       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 192                       ExpectedMD5, string(".gz"));
 193       Status = StatDone;
 194       Complete = false;
 195       Dequeue();
 196       return;
 197    }
 198
 199
 200    Item::Failed(Message,Cnf);
 201 }
 202
 203
 204 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 205 // ---------------------------------------------------------------------
 206 /* This goes through a number of states.. On the initial fetch the
 207    method could possibly return an alternate filename which points
 208    to the uncompressed version of the file. If this is so the file
 209    is copied into the partial directory. In all other cases the file
 210    is decompressed with a gzip uri. */
 211 void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5,
 212                        pkgAcquire::MethodConfig *Cfg)
 213 {
 214    Item::Done(Message,Size,MD5,Cfg);
 215
 216    if (Decompression == true)
 217    {
 218       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 219       {
 220          std::cerr << std::endl << RealURI << ": Computed MD5: " << MD5;
 221          std::cerr << "  Expected MD5: " << ExpectedMD5 << std::endl;
 222       }
 223
 224       if (MD5.empty())
 225       {
 226          MD5Summation sum;
 227          FileFd Fd(DestFile, FileFd::ReadOnly);
 228          sum.AddFD(Fd.Fd(), Fd.Size());
 229          Fd.Close();
 230          MD5 = (string)sum.Result();
 231       }
 232
 233       if (!ExpectedMD5.empty() && MD5 != ExpectedMD5)
 234       {
 235          Status = StatAuthError;
 236          ErrorText = _("MD5Sum mismatch");
 237          Rename(DestFile,DestFile + ".FAILED");
 238          return;
 239       }
 240       // Done, move it into position
 241       string FinalFile = _config->FindDir("Dir::State::lists");
 242       FinalFile += URItoFileName(RealURI);
 243       Rename(DestFile,FinalFile);
 244       chmod(FinalFile.c_str(),0644);
 245
 246       /* We restore the original name to DestFile so that the clean operation
 247          will work OK */
 248       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 249       DestFile += URItoFileName(RealURI);
 250
 251       // Remove the compressed version.
 252       if (Erase == true)
 253          unlink(DestFile.c_str());
 254       return;
 255    }
 256
 257    Erase = false;
 258    Complete = true;
 259
 260    // Handle the unzipd case
 261    string FileName = LookupTag(Message,"Alt-Filename");
 262    if (FileName.empty() == false)
 263    {
 264       // The files timestamp matches
 265       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 266          return;
 267
 268       Decompression = true;
 269       Local = true;
 270       DestFile += ".decomp";
 271       Desc.URI = "copy:" + FileName;
 272       QueueURI(Desc);
 273       Mode = "copy";
 274       return;
 275    }
 276
 277    FileName = LookupTag(Message,"Filename");
 278    if (FileName.empty() == true)
 279    {
 280       Status = StatError;
 281       ErrorText = "Method gave a blank filename";
 282    }
 283
 284    // The files timestamp matches
 285    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 286       return;
 287
 288    if (FileName == DestFile)
 289       Erase = true;
 290    else
 291       Local = true;
 292
 293    string compExt = Desc.URI.substr(Desc.URI.size()-3,Desc.URI.size()-1);
 294    char *decompProg;
 295    if(compExt == "bz2")
 296       decompProg = "bzip2";
 297    else if(compExt == ".gz")
 298       decompProg = "gzip";
 299    else {
 300       _error->Error("Unsupported extension: %s", compExt.c_str());
 301       return;
 302    }
 303
 304    Decompression = true;
 305    DestFile += ".decomp";
 306    Desc.URI = string(decompProg) + ":" + FileName;
 307    QueueURI(Desc);
 308    Mode = decompProg;
 309 }
 310
 311 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
 312                              string URI,string URIDesc,string ShortDesc,
 313                              string MetaIndexURI, string MetaIndexURIDesc,
 314                              string MetaIndexShortDesc,
 315                              const vector<IndexTarget*>* IndexTargets,
 316                              indexRecords* MetaIndexParser) :
 317    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
 318    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc)
 319 {
 320    this->MetaIndexParser = MetaIndexParser;
 321    this->IndexTargets = IndexTargets;
 322    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 323    DestFile += URItoFileName(URI);
 324
 325    // remove any partial downloaded sig-file. it may confuse proxies
 326    // and is too small to warrant a partial download anyway
 327    unlink(DestFile.c_str());
 328
 329    // Create the item
 330    Desc.Description = URIDesc;
 331    Desc.Owner = this;
 332    Desc.ShortDesc = ShortDesc;
 333    Desc.URI = URI;
 334
 335
 336    string Final = _config->FindDir("Dir::State::lists");
 337    Final += URItoFileName(RealURI);
 338    struct stat Buf;
 339    if (stat(Final.c_str(),&Buf) == 0)
 340    {
 341       // File was already in place.  It needs to be re-verified
 342       // because Release might have changed, so Move it into partial
 343       Rename(Final,DestFile);
 344       // unlink the file and do not try to use I-M-S and Last-Modified
 345       // if the users proxy is broken
 346       if(_config->FindB("Acquire::BrokenProxy", false) == true) {
 347          std::cerr << "forcing re-get of the signature file as requested" << std::endl;
 348          unlink(DestFile.c_str());
 349       }
 350    }
 351
 352    QueueURI(Desc);
 353 }
 354                                                                         /*}}}*/
 355 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
 356 // ---------------------------------------------------------------------
 357 /* The only header we use is the last-modified header. */
 358 string pkgAcqMetaSig::Custom600Headers()
 359 {
 360    struct stat Buf;
 361    if (stat(DestFile.c_str(),&Buf) != 0)
 362       return "\nIndex-File: true";
 363
 364    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 365 }
 366
 367 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
 368                          pkgAcquire::MethodConfig *Cfg)
 369 {
 370    Item::Done(Message,Size,MD5,Cfg);
 371
 372    string FileName = LookupTag(Message,"Filename");
 373    if (FileName.empty() == true)
 374    {
 375       Status = StatError;
 376       ErrorText = "Method gave a blank filename";
 377       return;
 378    }
 379
 380    if (FileName != DestFile)
 381    {
 382       // We have to copy it into place
 383       Local = true;
 384       Desc.URI = "copy:" + FileName;
 385       QueueURI(Desc);
 386       return;
 387    }
 388
 389    Complete = true;
 390
 391    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
 392    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 393                        DestFile, IndexTargets, MetaIndexParser);
 394
 395 }
 396                                                                         /*}}}*/
 397 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 398 {
 399    // Delete any existing sigfile, so that this source isn't
 400    // mistakenly trusted
 401    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 402    unlink(Final.c_str());
 403
 404    // if we get a timeout if fail
 405    if(LookupTag(Message,"FailReason") == "Timeout" ||
 406       LookupTag(Message,"FailReason") == "TmpResolveFailure") {
 407       Item::Failed(Message,Cnf);
 408       return;
 409    }
 410
 411    // queue a pkgAcqMetaIndex with no sigfile
 412    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 413                        "", IndexTargets, MetaIndexParser);
 414
 415    if (Cnf->LocalOnly == true ||
 416        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 417    {
 418       // Ignore this
 419       Status = StatDone;
 420       Complete = false;
 421       Dequeue();
 422       return;
 423    }
 424
 425    Item::Failed(Message,Cnf);
 426 }
 427
 428 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,
 429                                  string URI,string URIDesc,string ShortDesc,
 430                                  string SigFile,
 431                                  const vector<struct IndexTarget*>* IndexTargets,
 432                                  indexRecords* MetaIndexParser) :
 433   Item(Owner), RealURI(URI), SigFile(SigFile)
 434 {
 435    this->AuthPass = false;
 436    this->MetaIndexParser = MetaIndexParser;
 437    this->IndexTargets = IndexTargets;
 438    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 439    DestFile += URItoFileName(URI);
 440
 441    // Create the item
 442    Desc.Description = URIDesc;
 443    Desc.Owner = this;
 444    Desc.ShortDesc = ShortDesc;
 445    Desc.URI = URI;
 446
 447    QueueURI(Desc);
 448 }
 449
 450                                                                         /*}}}*/
 451 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
 452 // ---------------------------------------------------------------------
 453 /* The only header we use is the last-modified header. */
 454 string pkgAcqMetaIndex::Custom600Headers()
 455 {
 456    string Final = _config->FindDir("Dir::State::lists");
 457    Final += URItoFileName(RealURI);
 458
 459    struct stat Buf;
 460    if (stat(Final.c_str(),&Buf) != 0)
 461       return "\nIndex-File: true";
 462
 463    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 464 }
 465
 466 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string MD5,
 467                            pkgAcquire::MethodConfig *Cfg)
 468 {
 469    Item::Done(Message,Size,MD5,Cfg);
 470
 471    // MetaIndexes are done in two passes: one to download the
 472    // metaindex with an appropriate method, and a second to verify it
 473    // with the gpgv method
 474
 475    if (AuthPass == true)
 476    {
 477       AuthDone(Message);
 478    }
 479    else
 480    {
 481       RetrievalDone(Message);
 482       if (!Complete)
 483          // Still more retrieving to do
 484          return;
 485
 486       if (SigFile == "")
 487       {
 488          // There was no signature file, so we are finished.  Download
 489          // the indexes without verification.
 490          QueueIndexes(false);
 491       }
 492       else
 493       {
 494          // There was a signature file, so pass it to gpgv for
 495          // verification
 496
 497          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 498             std::cerr << "Metaindex acquired, queueing gpg verification ("
 499                       << SigFile << "," << DestFile << ")\n";
 500          AuthPass = true;
 501          Desc.URI = "gpgv:" + SigFile;
 502          QueueURI(Desc);
 503          Mode = "gpgv";
 504       }
 505    }
 506 }
 507
 508 void pkgAcqMetaIndex::RetrievalDone(string Message)
 509 {
 510    // We have just finished downloading a Release file (it is not
 511    // verified yet)
 512
 513    string FileName = LookupTag(Message,"Filename");
 514    if (FileName.empty() == true)
 515    {
 516       Status = StatError;
 517       ErrorText = "Method gave a blank filename";
 518       return;
 519    }
 520
 521    if (FileName != DestFile)
 522    {
 523       Local = true;
 524       Desc.URI = "copy:" + FileName;
 525       QueueURI(Desc);
 526       return;
 527    }
 528
 529    Complete = true;
 530
 531    string FinalFile = _config->FindDir("Dir::State::lists");
 532    FinalFile += URItoFileName(RealURI);
 533
 534    // The files timestamp matches
 535    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == false)
 536    {
 537       // Move it into position
 538       Rename(DestFile,FinalFile);
 539    }
 540    DestFile = FinalFile;
 541 }
 542
 543 void pkgAcqMetaIndex::AuthDone(string Message)
 544 {
 545    // At this point, the gpgv method has succeeded, so there is a
 546    // valid signature from a key in the trusted keyring.  We
 547    // perform additional verification of its contents, and use them
 548    // to verify the indexes we are about to download
 549
 550    if (!MetaIndexParser->Load(DestFile))
 551    {
 552       Status = StatAuthError;
 553       ErrorText = MetaIndexParser->ErrorText;
 554       return;
 555    }
 556
 557    if (!VerifyVendor())
 558    {
 559       return;
 560    }
 561
 562    if (_config->FindB("Debug::pkgAcquire::Auth", false))
 563       std::cerr << "Signature verification succeeded: "
 564                 << DestFile << std::endl;
 565
 566    // Download further indexes with verification
 567    QueueIndexes(true);
 568
 569    // Done, move signature file into position
 570
 571    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 572       URItoFileName(RealURI) + ".gpg";
 573    Rename(SigFile,VerifiedSigFile);
 574    chmod(VerifiedSigFile.c_str(),0644);
 575 }
 576
 577 void pkgAcqMetaIndex::QueueIndexes(bool verify)
 578 {
 579    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
 580         Target != IndexTargets->end();
 581         Target++)
 582    {
 583       string ExpectedIndexMD5;
 584       if (verify)
 585       {
 586          const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
 587          if (!Record)
 588          {
 589             Status = StatAuthError;
 590             ErrorText = "Unable to find expected entry  "
 591                + (*Target)->MetaKey + " in Meta-index file (malformed Release file?)";
 592             return;
 593          }
 594          ExpectedIndexMD5 = Record->MD5Hash;
 595          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 596          {
 597             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
 598             std::cerr << "Expected MD5: " << ExpectedIndexMD5 << std::endl;
 599          }
 600          if (ExpectedIndexMD5.empty())
 601          {
 602             Status = StatAuthError;
 603             ErrorText = "Unable to find MD5 sum for "
 604                + (*Target)->MetaKey + " in Meta-index file";
 605             return;
 606          }
 607       }
 608
 609       // Queue Packages file
 610       new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
 611                       (*Target)->ShortDesc, ExpectedIndexMD5);
 612    }
 613 }
 614
 615 bool pkgAcqMetaIndex::VerifyVendor()
 616 {
 617 //    // Maybe this should be made available from above so we don't have
 618 //    // to read and parse it every time?
 619 //    pkgVendorList List;
 620 //    List.ReadMainList();
 621
 622 //    const Vendor* Vndr = NULL;
 623 //    for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
 624 //    {
 625 //       string::size_type pos = (*I).find("VALIDSIG ");
 626 //       if (_config->FindB("Debug::Vendor", false))
 627 //          std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
 628 //                    << std::endl;
 629 //       if (pos != std::string::npos)
 630 //       {
 631 //          string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
 632 //          if (_config->FindB("Debug::Vendor", false))
 633 //             std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
 634 //                std::endl;
 635 //          Vndr = List.FindVendor(Fingerprint) != "";
 636 //          if (Vndr != NULL);
 637 //          break;
 638 //       }
 639 //    }
 640
 641    string Transformed = MetaIndexParser->GetExpectedDist();
 642
 643    if (Transformed == "../project/experimental")
 644    {
 645       Transformed = "experimental";
 646    }
 647
 648    string::size_type pos = Transformed.rfind('/');
 649    if (pos != string::npos)
 650    {
 651       Transformed = Transformed.substr(0, pos);
 652    }
 653
 654    if (Transformed == ".")
 655    {
 656       Transformed = "";
 657    }
 658
 659    if (_config->FindB("Debug::pkgAcquire::Auth", false))
 660    {
 661       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
 662       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
 663       std::cerr << "Transformed Dist: " << Transformed << std::endl;
 664    }
 665
 666    if (MetaIndexParser->CheckDist(Transformed) == false)
 667    {
 668       // This might become fatal one day
 669 //       Status = StatAuthError;
 670 //       ErrorText = "Conflicting distribution; expected "
 671 //          + MetaIndexParser->GetExpectedDist() + " but got "
 672 //          + MetaIndexParser->GetDist();
 673 //       return false;
 674       if (!Transformed.empty())
 675       {
 676          _error->Warning("Conflicting distribution: %s (expected %s but got %s)",
 677                          Desc.Description.c_str(),
 678                          Transformed.c_str(),
 679                          MetaIndexParser->GetDist().c_str());
 680       }
 681    }
 682
 683    return true;
 684 }
 685                                                                 /*}}}*/
 686 // pkgAcqMetaIndex::Failed - no Release file present or no signature
 687 //      file present                                            /*{{{*/
 688 // ---------------------------------------------------------------------
 689 /* */
 690 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 691 {
 692    if (AuthPass == true)
 693    {
 694       // gpgv method failed
 695       _error->Warning("GPG error: %s: %s",
 696                       Desc.Description.c_str(),
 697                       LookupTag(Message,"Message").c_str());
 698    }
 699
 700    // No Release file was present, or verification failed, so fall
 701    // back to queueing Packages files without verification
 702    QueueIndexes(false);
 703 }
 704
 705                                                                         /*}}}*/
 706
 707 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
 708 // ---------------------------------------------------------------------
 709 /* This just sets up the initial fetch environment and queues the first
 710    possibilitiy */
 711 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
 712                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
 713                              string &StoreFilename) :
 714                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
 715                StoreFilename(StoreFilename), Vf(Version.FileList()),
 716                Trusted(false)
 717 {
 718    Retries = _config->FindI("Acquire::Retries",0);
 719
 720    if (Version.Arch() == 0)
 721    {
 722       _error->Error(_("I wasn't able to locate a file for the %s package. "
 723                       "This might mean you need to manually fix this package. "
 724                       "(due to missing arch)"),
 725                     Version.ParentPkg().Name());
 726       return;
 727    }
 728
 729    /* We need to find a filename to determine the extension. We make the
 730       assumption here that all the available sources for this version share
 731       the same extension.. */
 732    // Skip not source sources, they do not have file fields.
 733    for (; Vf.end() == false; Vf++)
 734    {
 735       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
 736          continue;
 737       break;
 738    }
 739
 740    // Does not really matter here.. we are going to fail out below
 741    if (Vf.end() != true)
 742    {
 743       // If this fails to get a file name we will bomb out below.
 744       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
 745       if (_error->PendingError() == true)
 746          return;
 747
 748       // Generate the final file name as: package_version_arch.foo
 749       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
 750                       QuoteString(Version.VerStr(),"_:") + '_' +
 751                       QuoteString(Version.Arch(),"_:.") +
 752                       "." + flExtension(Parse.FileName());
 753    }
 754
 755    // check if we have one trusted source for the package. if so, switch
 756    // to "TrustedOnly" mode
 757    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++)
 758    {
 759       pkgIndexFile *Index;
 760       if (Sources->FindIndex(i.File(),Index) == false)
 761          continue;
 762       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 763       {
 764          std::cerr << "Checking index: " << Index->Describe()
 765                    << "(Trusted=" << Index->IsTrusted() << ")\n";
 766       }
 767       if (Index->IsTrusted()) {
 768          Trusted = true;
 769          break;
 770       }
 771    }
 772
 773    // Select a source
 774    if (QueueNext() == false && _error->PendingError() == false)
 775       _error->Error(_("I wasn't able to locate file for the %s package. "
 776                     "This might mean you need to manually fix this package."),
 777                     Version.ParentPkg().Name());
 778 }
 779                                                                         /*}}}*/
 780 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
 781 // ---------------------------------------------------------------------
 782 /* This queues the next available file version for download. It checks if
 783    the archive is already available in the cache and stashs the MD5 for
 784    checking later. */
 785 bool pkgAcqArchive::QueueNext()
 786 {
 787    for (; Vf.end() == false; Vf++)
 788    {
 789       // Ignore not source sources
 790       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
 791          continue;
 792
 793       // Try to cross match against the source list
 794       pkgIndexFile *Index;
 795       if (Sources->FindIndex(Vf.File(),Index) == false)
 796             continue;
 797
 798       // only try to get a trusted package from another source if that source
 799       // is also trusted
 800       if(Trusted && !Index->IsTrusted())
 801          continue;
 802
 803       // Grab the text package record
 804       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
 805       if (_error->PendingError() == true)
 806          return false;
 807
 808       string PkgFile = Parse.FileName();
 809       MD5 = Parse.MD5Hash();
 810       if (PkgFile.empty() == true)
 811          return _error->Error(_("The package index files are corrupted. No Filename: "
 812                               "field for package %s."),
 813                               Version.ParentPkg().Name());
 814
 815       Desc.URI = Index->ArchiveURI(PkgFile);
 816       Desc.Description = Index->ArchiveInfo(Version);
 817       Desc.Owner = this;
 818       Desc.ShortDesc = Version.ParentPkg().Name();
 819
 820       // See if we already have the file. (Legacy filenames)
 821       FileSize = Version->Size;
 822       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
 823       struct stat Buf;
 824       if (stat(FinalFile.c_str(),&Buf) == 0)
 825       {
 826          // Make sure the size matches
 827          if ((unsigned)Buf.st_size == Version->Size)
 828          {
 829             Complete = true;
 830             Local = true;
 831             Status = StatDone;
 832             StoreFilename = DestFile = FinalFile;
 833             return true;
 834          }
 835
 836          /* Hmm, we have a file and its size does not match, this means it is
 837             an old style mismatched arch */
 838          unlink(FinalFile.c_str());
 839       }
 840
 841       // Check it again using the new style output filenames
 842       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
 843       if (stat(FinalFile.c_str(),&Buf) == 0)
 844       {
 845          // Make sure the size matches
 846          if ((unsigned)Buf.st_size == Version->Size)
 847          {
 848             Complete = true;
 849             Local = true;
 850             Status = StatDone;
 851             StoreFilename = DestFile = FinalFile;
 852             return true;
 853          }
 854
 855          /* Hmm, we have a file and its size does not match, this shouldnt
 856             happen.. */
 857          unlink(FinalFile.c_str());
 858       }
 859
 860       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
 861
 862       // Check the destination file
 863       if (stat(DestFile.c_str(),&Buf) == 0)
 864       {
 865          // Hmm, the partial file is too big, erase it
 866          if ((unsigned)Buf.st_size > Version->Size)
 867             unlink(DestFile.c_str());
 868          else
 869             PartialSize = Buf.st_size;
 870       }
 871
 872       // Create the item
 873       Local = false;
 874       Desc.URI = Index->ArchiveURI(PkgFile);
 875       Desc.Description = Index->ArchiveInfo(Version);
 876       Desc.Owner = this;
 877       Desc.ShortDesc = Version.ParentPkg().Name();
 878       QueueURI(Desc);
 879
 880       Vf++;
 881       return true;
 882    }
 883    return false;
 884 }
 885                                                                         /*}}}*/
 886 // AcqArchive::Done - Finished fetching                                 /*{{{*/
 887 // ---------------------------------------------------------------------
 888 /* */
 889 void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash,
 890                          pkgAcquire::MethodConfig *Cfg)
 891 {
 892    Item::Done(Message,Size,Md5Hash,Cfg);
 893
 894    // Check the size
 895    if (Size != Version->Size)
 896    {
 897       Status = StatError;
 898       ErrorText = _("Size mismatch");
 899       return;
 900    }
 901
 902    // Check the md5
 903    if (Md5Hash.empty() == false && MD5.empty() == false)
 904    {
 905       if (Md5Hash != MD5)
 906       {
 907          Status = StatError;
 908          ErrorText = _("MD5Sum mismatch");
 909          if(FileExists(DestFile))
 910             Rename(DestFile,DestFile + ".FAILED");
 911          return;
 912       }
 913    }
 914
 915    // Grab the output filename
 916    string FileName = LookupTag(Message,"Filename");
 917    if (FileName.empty() == true)
 918    {
 919       Status = StatError;
 920       ErrorText = "Method gave a blank filename";
 921       return;
 922    }
 923
 924    Complete = true;
 925
 926    // Reference filename
 927    if (FileName != DestFile)
 928    {
 929       StoreFilename = DestFile = FileName;
 930       Local = true;
 931       return;
 932    }
 933
 934    // Done, move it into position
 935    string FinalFile = _config->FindDir("Dir::Cache::Archives");
 936    FinalFile += flNotDir(StoreFilename);
 937    Rename(DestFile,FinalFile);
 938
 939    StoreFilename = DestFile = FinalFile;
 940    Complete = true;
 941 }
 942                                                                         /*}}}*/
 943 // AcqArchive::Failed - Failure handler                                 /*{{{*/
 944 // ---------------------------------------------------------------------
 945 /* Here we try other sources */
 946 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 947 {
 948    ErrorText = LookupTag(Message,"Message");
 949
 950    /* We don't really want to retry on failed media swaps, this prevents
 951       that. An interesting observation is that permanent failures are not
 952       recorded. */
 953    if (Cnf->Removable == true &&
 954        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
 955    {
 956       // Vf = Version.FileList();
 957       while (Vf.end() == false) Vf++;
 958       StoreFilename = string();
 959       Item::Failed(Message,Cnf);
 960       return;
 961    }
 962
 963    if (QueueNext() == false)
 964    {
 965       // This is the retry counter
 966       if (Retries != 0 &&
 967           Cnf->LocalOnly == false &&
 968           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
 969       {
 970          Retries--;
 971          Vf = Version.FileList();
 972          if (QueueNext() == true)
 973             return;
 974       }
 975
 976       StoreFilename = string();
 977       Item::Failed(Message,Cnf);
 978    }
 979 }
 980                                                                         /*}}}*/
 981 // AcqArchive::IsTrusted - Determine whether this archive comes from a
 982 // trusted source                                                       /*{{{*/
 983 // ---------------------------------------------------------------------
 984 bool pkgAcqArchive::IsTrusted()
 985 {
 986    return Trusted;
 987 }
 988
 989 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
 990 // ---------------------------------------------------------------------
 991 /* */
 992 void pkgAcqArchive::Finished()
 993 {
 994    if (Status == pkgAcquire::Item::StatDone &&
 995        Complete == true)
 996       return;
 997    StoreFilename = string();
 998 }
 999                                                                         /*}}}*/
1000
1001 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1002 // ---------------------------------------------------------------------
1003 /* The file is added to the queue */
1004 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string MD5,
1005                        unsigned long Size,string Dsc,string ShortDesc) :
1006                        Item(Owner), Md5Hash(MD5)
1007 {
1008    Retries = _config->FindI("Acquire::Retries",0);
1009
1010    DestFile = flNotDir(URI);
1011
1012    // Create the item
1013    Desc.URI = URI;
1014    Desc.Description = Dsc;
1015    Desc.Owner = this;
1016
1017    // Set the short description to the archive component
1018    Desc.ShortDesc = ShortDesc;
1019
1020    // Get the transfer sizes
1021    FileSize = Size;
1022    struct stat Buf;
1023    if (stat(DestFile.c_str(),&Buf) == 0)
1024    {
1025       // Hmm, the partial file is too big, erase it
1026       if ((unsigned)Buf.st_size > Size)
1027          unlink(DestFile.c_str());
1028       else
1029          PartialSize = Buf.st_size;
1030    }
1031
1032    QueueURI(Desc);
1033 }
1034                                                                         /*}}}*/
1035 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1036 // ---------------------------------------------------------------------
1037 /* */
1038 void pkgAcqFile::Done(string Message,unsigned long Size,string MD5,
1039                       pkgAcquire::MethodConfig *Cnf)
1040 {
1041    // Check the md5
1042    if (Md5Hash.empty() == false && MD5.empty() == false)
1043    {
1044       if (Md5Hash != MD5)
1045       {
1046          Status = StatError;
1047          ErrorText = "MD5Sum mismatch";
1048          Rename(DestFile,DestFile + ".FAILED");
1049          return;
1050       }
1051    }
1052
1053    Item::Done(Message,Size,MD5,Cnf);
1054
1055    string FileName = LookupTag(Message,"Filename");
1056    if (FileName.empty() == true)
1057    {
1058       Status = StatError;
1059       ErrorText = "Method gave a blank filename";
1060       return;
1061    }
1062
1063    Complete = true;
1064
1065    // The files timestamp matches
1066    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1067       return;
1068
1069    // We have to copy it into place
1070    if (FileName != DestFile)
1071    {
1072       Local = true;
1073       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1074           Cnf->Removable == true)
1075       {
1076          Desc.URI = "copy:" + FileName;
1077          QueueURI(Desc);
1078          return;
1079       }
1080
1081       // Erase the file if it is a symlink so we can overwrite it
1082       struct stat St;
1083       if (lstat(DestFile.c_str(),&St) == 0)
1084       {
1085          if (S_ISLNK(St.st_mode) != 0)
1086             unlink(DestFile.c_str());
1087       }
1088
1089       // Symlink the file
1090       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1091       {
1092          ErrorText = "Link to " + DestFile + " failure ";
1093          Status = StatError;
1094          Complete = false;
1095       }
1096    }
1097 }
1098                                                                         /*}}}*/
1099 // AcqFile::Failed - Failure handler                                    /*{{{*/
1100 // ---------------------------------------------------------------------
1101 /* Here we try other sources */
1102 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1103 {
1104    ErrorText = LookupTag(Message,"Message");
1105
1106    // This is the retry counter
1107    if (Retries != 0 &&
1108        Cnf->LocalOnly == false &&
1109        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1110    {
1111       Retries--;
1112       QueueURI(Desc);
1113       return;
1114    }
1115
1116    Item::Failed(Message,Cnf);
1117 }
1118                                                                         /*}}}*/