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 #include <config.h>
  17
  18 #include <apt-pkg/acquire-item.h>
  19 #include <apt-pkg/configuration.h>
  20 #include <apt-pkg/aptconfiguration.h>
  21 #include <apt-pkg/sourcelist.h>
  22 #include <apt-pkg/error.h>
  23 #include <apt-pkg/strutl.h>
  24 #include <apt-pkg/fileutl.h>
  25 #include <apt-pkg/md5.h>
  26 #include <apt-pkg/sha1.h>
  27 #include <apt-pkg/tagfile.h>
  28 #include <apt-pkg/indexrecords.h>
  29 #include <apt-pkg/metaindex.h>
  30
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34 #include <string>
  35 #include <sstream>
  36 #include <stdio.h>
  37 #include <ctime>
  38
  39 #include <apti18n.h>
  40                                                                         /*}}}*/
  41
  42 using namespace std;
  43
  44 // Acquire::Item::Item - Constructor                                    /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* */
  47 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),
  48                        PartialSize(0), Mode(0), ID(0), Complete(false),
  49                        Local(false), QueueCounter(0)
  50 {
  51    Owner->Add(this);
  52    Status = StatIdle;
  53 }
  54                                                                         /*}}}*/
  55 // Acquire::Item::~Item - Destructor                                    /*{{{*/
  56 // ---------------------------------------------------------------------
  57 /* */
  58 pkgAcquire::Item::~Item()
  59 {
  60    Owner->Remove(this);
  61 }
  62                                                                         /*}}}*/
  63 // Acquire::Item::Failed - Item failed to download                      /*{{{*/
  64 // ---------------------------------------------------------------------
  65 /* We return to an idle state if there are still other queues that could
  66    fetch this object */
  67 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
  68 {
  69    Status = StatIdle;
  70    ErrorText = LookupTag(Message,"Message");
  71    UsedMirror =  LookupTag(Message,"UsedMirror");
  72    if (QueueCounter <= 1)
  73    {
  74       /* This indicates that the file is not available right now but might
  75          be sometime later. If we do a retry cycle then this should be
  76          retried [CDROMs] */
  77       if (Cnf->LocalOnly == true &&
  78           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
  79       {
  80          Status = StatIdle;
  81          Dequeue();
  82          return;
  83       }
  84
  85       Status = StatError;
  86       Dequeue();
  87    }
  88
  89    // report mirror failure back to LP if we actually use a mirror
  90    string FailReason = LookupTag(Message, "FailReason");
  91    if(FailReason.size() != 0)
  92       ReportMirrorFailure(FailReason);
  93    else
  94       ReportMirrorFailure(ErrorText);
  95 }
  96                                                                         /*}}}*/
  97 // Acquire::Item::Start - Item has begun to download                    /*{{{*/
  98 // ---------------------------------------------------------------------
  99 /* Stash status and the file size. Note that setting Complete means
 100    sub-phases of the acquire process such as decompresion are operating */
 101 void pkgAcquire::Item::Start(string /*Message*/,unsigned long long Size)
 102 {
 103    Status = StatFetching;
 104    if (FileSize == 0 && Complete == false)
 105       FileSize = Size;
 106 }
 107                                                                         /*}}}*/
 108 // Acquire::Item::Done - Item downloaded OK                             /*{{{*/
 109 // ---------------------------------------------------------------------
 110 /* */
 111 void pkgAcquire::Item::Done(string Message,unsigned long long Size,string Hash,
 112                             pkgAcquire::MethodConfig *Cnf)
 113 {
 114    // We just downloaded something..
 115    string FileName = LookupTag(Message,"Filename");
 116    UsedMirror =  LookupTag(Message,"UsedMirror");
 117    if (Complete == false && !Local && FileName == DestFile)
 118    {
 119       if (Owner->Log != 0)
 120          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 121    }
 122
 123    if (FileSize == 0)
 124       FileSize= Size;
 125    Status = StatDone;
 126    ErrorText = string();
 127    Owner->Dequeue(this);
 128 }
 129                                                                         /*}}}*/
 130 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 131 // ---------------------------------------------------------------------
 132 /* This helper function is used by alot of item methods as thier final
 133    step */
 134 void pkgAcquire::Item::Rename(string From,string To)
 135 {
 136    if (rename(From.c_str(),To.c_str()) != 0)
 137    {
 138       char S[300];
 139       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 140               From.c_str(),To.c_str());
 141       Status = StatError;
 142       ErrorText = S;
 143    }
 144 }
 145                                                                         /*}}}*/
 146 // Acquire::Item::ReportMirrorFailure                                   /*{{{*/
 147 // ---------------------------------------------------------------------
 148 void pkgAcquire::Item::ReportMirrorFailure(string FailCode)
 149 {
 150    // we only act if a mirror was used at all
 151    if(UsedMirror.empty())
 152       return;
 153 #if 0
 154    std::cerr << "\nReportMirrorFailure: "
 155              << UsedMirror
 156              << " Uri: " << DescURI()
 157              << " FailCode: "
 158              << FailCode << std::endl;
 159 #endif
 160    const char *Args[40];
 161    unsigned int i = 0;
 162    string report = _config->Find("Methods::Mirror::ProblemReporting",
 163                                  "/usr/lib/apt/apt-report-mirror-failure");
 164    if(!FileExists(report))
 165       return;
 166    Args[i++] = report.c_str();
 167    Args[i++] = UsedMirror.c_str();
 168    Args[i++] = DescURI().c_str();
 169    Args[i++] = FailCode.c_str();
 170    Args[i++] = NULL;
 171    pid_t pid = ExecFork();
 172    if(pid < 0)
 173    {
 174       _error->Error("ReportMirrorFailure Fork failed");
 175       return;
 176    }
 177    else if(pid == 0)
 178    {
 179       execvp(Args[0], (char**)Args);
 180       std::cerr << "Could not exec " << Args[0] << std::endl;
 181       _exit(100);
 182    }
 183    if(!ExecWait(pid, "report-mirror-failure"))
 184    {
 185       _error->Warning("Couldn't report problem to '%s'",
 186                       _config->Find("Methods::Mirror::ProblemReporting").c_str());
 187    }
 188 }
 189                                                                         /*}}}*/
 190 // AcqSubIndex::AcqSubIndex - Constructor                               /*{{{*/
 191 // ---------------------------------------------------------------------
 192 /* Get a sub-index file based on checksums from a 'master' file and
 193    possibly query additional files */
 194 pkgAcqSubIndex::pkgAcqSubIndex(pkgAcquire *Owner, string const &URI,
 195                                  string const &URIDesc, string const &ShortDesc,
 196                                  HashString const &ExpectedHash)
 197    : Item(Owner), ExpectedHash(ExpectedHash)
 198 {
 199    /* XXX: Beware: Currently this class does nothing (of value) anymore ! */
 200    Debug = _config->FindB("Debug::pkgAcquire::SubIndex",false);
 201
 202    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 203    DestFile += URItoFileName(URI);
 204
 205    Desc.URI = URI;
 206    Desc.Description = URIDesc;
 207    Desc.Owner = this;
 208    Desc.ShortDesc = ShortDesc;
 209
 210    QueueURI(Desc);
 211
 212    if(Debug)
 213       std::clog << "pkgAcqSubIndex: " << Desc.URI << std::endl;
 214 }
 215                                                                         /*}}}*/
 216 // AcqSubIndex::Custom600Headers - Insert custom request headers        /*{{{*/
 217 // ---------------------------------------------------------------------
 218 /* The only header we use is the last-modified header. */
 219 string pkgAcqSubIndex::Custom600Headers()
 220 {
 221    string Final = _config->FindDir("Dir::State::lists");
 222    Final += URItoFileName(Desc.URI);
 223
 224    struct stat Buf;
 225    if (stat(Final.c_str(),&Buf) != 0)
 226       return "\nIndex-File: true\nFail-Ignore: true\n";
 227    return "\nIndex-File: true\nFail-Ignore: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 228 }
 229                                                                         /*}}}*/
 230 void pkgAcqSubIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)       /*{{{*/
 231 {
 232    if(Debug)
 233       std::clog << "pkgAcqSubIndex failed: " << Desc.URI << std::endl;
 234
 235    Complete = false;
 236    Status = StatDone;
 237    Dequeue();
 238
 239    // No good Index is provided
 240 }
 241                                                                         /*}}}*/
 242 void pkgAcqSubIndex::Done(string Message,unsigned long long Size,string Md5Hash,        /*{{{*/
 243                            pkgAcquire::MethodConfig *Cnf)
 244 {
 245    if(Debug)
 246       std::clog << "pkgAcqSubIndex::Done(): " << Desc.URI << std::endl;
 247
 248    string FileName = LookupTag(Message,"Filename");
 249    if (FileName.empty() == true)
 250    {
 251       Status = StatError;
 252       ErrorText = "Method gave a blank filename";
 253       return;
 254    }
 255
 256    if (FileName != DestFile)
 257    {
 258       Local = true;
 259       Desc.URI = "copy:" + FileName;
 260       QueueURI(Desc);
 261       return;
 262    }
 263
 264    Item::Done(Message,Size,Md5Hash,Cnf);
 265
 266    string FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(Desc.URI);
 267
 268    /* Downloaded invalid transindex => Error (LP: #346386) (Closes: #627642) */
 269    indexRecords SubIndexParser;
 270    if (FileExists(DestFile) == true && !SubIndexParser.Load(DestFile)) {
 271       Status = StatError;
 272       ErrorText = SubIndexParser.ErrorText;
 273       return;
 274    }
 275
 276    // sucess in downloading the index
 277    // rename the index
 278    if(Debug)
 279       std::clog << "Renaming: " << DestFile << " -> " << FinalFile << std::endl;
 280    Rename(DestFile,FinalFile);
 281    chmod(FinalFile.c_str(),0644);
 282    DestFile = FinalFile;
 283
 284    if(ParseIndex(DestFile) == false)
 285       return Failed("", NULL);
 286
 287    Complete = true;
 288    Status = StatDone;
 289    Dequeue();
 290    return;
 291 }
 292                                                                         /*}}}*/
 293 bool pkgAcqSubIndex::ParseIndex(string const &IndexFile)                /*{{{*/
 294 {
 295    indexRecords SubIndexParser;
 296    if (FileExists(IndexFile) == false || SubIndexParser.Load(IndexFile) == false)
 297       return false;
 298    // so something with the downloaded index
 299    return true;
 300 }
 301                                                                         /*}}}*/
 302 // AcqDiffIndex::AcqDiffIndex - Constructor                             /*{{{*/
 303 // ---------------------------------------------------------------------
 304 /* Get the DiffIndex file first and see if there are patches availabe
 305  * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
 306  * patches. If anything goes wrong in that process, it will fall back to
 307  * the original packages file
 308  */
 309 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
 310                                  string URI,string URIDesc,string ShortDesc,
 311                                  HashString ExpectedHash)
 312    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 313      Description(URIDesc)
 314 {
 315
 316    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 317
 318    Desc.Description = URIDesc + "/DiffIndex";
 319    Desc.Owner = this;
 320    Desc.ShortDesc = ShortDesc;
 321    Desc.URI = URI + ".diff/Index";
 322
 323    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 324    DestFile += URItoFileName(URI) + string(".DiffIndex");
 325
 326    if(Debug)
 327       std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
 328
 329    // look for the current package file
 330    CurrentPackagesFile = _config->FindDir("Dir::State::lists");
 331    CurrentPackagesFile += URItoFileName(RealURI);
 332
 333    // FIXME: this file:/ check is a hack to prevent fetching
 334    //        from local sources. this is really silly, and
 335    //        should be fixed cleanly as soon as possible
 336    if(!FileExists(CurrentPackagesFile) ||
 337       Desc.URI.substr(0,strlen("file:/")) == "file:/")
 338    {
 339       // we don't have a pkg file or we don't want to queue
 340       if(Debug)
 341          std::clog << "No index file, local or canceld by user" << std::endl;
 342       Failed("", NULL);
 343       return;
 344    }
 345
 346    if(Debug)
 347       std::clog << "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): "
 348                 << CurrentPackagesFile << std::endl;
 349
 350    QueueURI(Desc);
 351
 352 }
 353                                                                         /*}}}*/
 354 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 355 // ---------------------------------------------------------------------
 356 /* The only header we use is the last-modified header. */
 357 string pkgAcqDiffIndex::Custom600Headers()
 358 {
 359    string Final = _config->FindDir("Dir::State::lists");
 360    Final += URItoFileName(RealURI) + string(".IndexDiff");
 361
 362    if(Debug)
 363       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 364
 365    struct stat Buf;
 366    if (stat(Final.c_str(),&Buf) != 0)
 367       return "\nIndex-File: true";
 368
 369    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 370 }
 371                                                                         /*}}}*/
 372 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)              /*{{{*/
 373 {
 374    if(Debug)
 375       std::clog << "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile
 376                 << std::endl;
 377
 378    pkgTagSection Tags;
 379    string ServerSha1;
 380    vector<DiffInfo> available_patches;
 381
 382    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
 383    pkgTagFile TF(&Fd);
 384    if (_error->PendingError() == true)
 385       return false;
 386
 387    if(TF.Step(Tags) == true)
 388    {
 389       bool found = false;
 390       DiffInfo d;
 391       string size;
 392
 393       string const tmp = Tags.FindS("SHA1-Current");
 394       std::stringstream ss(tmp);
 395       ss >> ServerSha1 >> size;
 396       unsigned long const ServerSize = atol(size.c_str());
 397
 398       FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
 399       SHA1Summation SHA1;
 400       SHA1.AddFD(fd);
 401       string const local_sha1 = SHA1.Result();
 402
 403       if(local_sha1 == ServerSha1)
 404       {
 405          // we have the same sha1 as the server
 406          if(Debug)
 407             std::clog << "Package file is up-to-date" << std::endl;
 408          // set found to true, this will queue a pkgAcqIndexDiffs with
 409          // a empty availabe_patches
 410          found = true;
 411       }
 412       else
 413       {
 414          if(Debug)
 415             std::clog << "SHA1-Current: " << ServerSha1 << " and we start at "<< fd.Name() << " " << fd.Size() << " " << local_sha1 << std::endl;
 416
 417          // check the historie and see what patches we need
 418          string const history = Tags.FindS("SHA1-History");
 419          std::stringstream hist(history);
 420          while(hist >> d.sha1 >> size >> d.file)
 421          {
 422             // read until the first match is found
 423             // from that point on, we probably need all diffs
 424             if(d.sha1 == local_sha1)
 425                found=true;
 426             else if (found == false)
 427                continue;
 428
 429             if(Debug)
 430                std::clog << "Need to get diff: " << d.file << std::endl;
 431             available_patches.push_back(d);
 432          }
 433
 434          if (available_patches.empty() == false)
 435          {
 436             // patching with too many files is rather slow compared to a fast download
 437             unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
 438             if (fileLimit != 0 && fileLimit < available_patches.size())
 439             {
 440                if (Debug)
 441                   std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
 442                         << ") so fallback to complete download" << std::endl;
 443                return false;
 444             }
 445
 446             // see if the patches are too big
 447             found = false; // it was true and it will be true again at the end
 448             d = *available_patches.begin();
 449             string const firstPatch = d.file;
 450             unsigned long patchesSize = 0;
 451             std::stringstream patches(Tags.FindS("SHA1-Patches"));
 452             while(patches >> d.sha1 >> size >> d.file)
 453             {
 454                if (firstPatch == d.file)
 455                   found = true;
 456                else if (found == false)
 457                   continue;
 458
 459                patchesSize += atol(size.c_str());
 460             }
 461             unsigned long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
 462             if (sizeLimit > 0 && (sizeLimit/100) < patchesSize)
 463             {
 464                if (Debug)
 465                   std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
 466                         << ") so fallback to complete download" << std::endl;
 467                return false;
 468             }
 469          }
 470       }
 471
 472       // we have something, queue the next diff
 473       if(found)
 474       {
 475          // queue the diffs
 476          string::size_type const last_space = Description.rfind(" ");
 477          if(last_space != string::npos)
 478             Description.erase(last_space, Description.size()-last_space);
 479          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 480                               ExpectedHash, ServerSha1, available_patches);
 481          Complete = false;
 482          Status = StatDone;
 483          Dequeue();
 484          return true;
 485       }
 486    }
 487
 488    // Nothing found, report and return false
 489    // Failing here is ok, if we return false later, the full
 490    // IndexFile is queued
 491    if(Debug)
 492       std::clog << "Can't find a patch in the index file" << std::endl;
 493    return false;
 494 }
 495                                                                         /*}}}*/
 496 void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)      /*{{{*/
 497 {
 498    if(Debug)
 499       std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << std::endl
 500                 << "Falling back to normal index file aquire" << std::endl;
 501
 502    new pkgAcqIndex(Owner, RealURI, Description, Desc.ShortDesc,
 503                    ExpectedHash);
 504
 505    Complete = false;
 506    Status = StatDone;
 507    Dequeue();
 508 }
 509                                                                         /*}}}*/
 510 void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,string Md5Hash,       /*{{{*/
 511                            pkgAcquire::MethodConfig *Cnf)
 512 {
 513    if(Debug)
 514       std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
 515
 516    Item::Done(Message,Size,Md5Hash,Cnf);
 517
 518    string FinalFile;
 519    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 520
 521    // sucess in downloading the index
 522    // rename the index
 523    FinalFile += string(".IndexDiff");
 524    if(Debug)
 525       std::clog << "Renaming: " << DestFile << " -> " << FinalFile
 526                 << std::endl;
 527    Rename(DestFile,FinalFile);
 528    chmod(FinalFile.c_str(),0644);
 529    DestFile = FinalFile;
 530
 531    if(!ParseDiffIndex(DestFile))
 532       return Failed("", NULL);
 533
 534    Complete = true;
 535    Status = StatDone;
 536    Dequeue();
 537    return;
 538 }
 539                                                                         /*}}}*/
 540 // AcqIndexDiffs::AcqIndexDiffs - Constructor                           /*{{{*/
 541 // ---------------------------------------------------------------------
 542 /* The package diff is added to the queue. one object is constructed
 543  * for each diff and the index
 544  */
 545 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
 546                                    string URI,string URIDesc,string ShortDesc,
 547                                    HashString ExpectedHash,
 548                                    string ServerSha1,
 549                                    vector<DiffInfo> diffs)
 550    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 551      available_patches(diffs), ServerSha1(ServerSha1)
 552 {
 553
 554    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 555    DestFile += URItoFileName(URI);
 556
 557    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 558
 559    Description = URIDesc;
 560    Desc.Owner = this;
 561    Desc.ShortDesc = ShortDesc;
 562
 563    if(available_patches.empty() == true)
 564    {
 565       // we are done (yeah!)
 566       Finish(true);
 567    }
 568    else
 569    {
 570       // get the next diff
 571       State = StateFetchDiff;
 572       QueueNextDiff();
 573    }
 574 }
 575                                                                         /*}}}*/
 576 void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig *Cnf)     /*{{{*/
 577 {
 578    if(Debug)
 579       std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << std::endl
 580                 << "Falling back to normal index file aquire" << std::endl;
 581    new pkgAcqIndex(Owner, RealURI, Description,Desc.ShortDesc,
 582                    ExpectedHash);
 583    Finish();
 584 }
 585                                                                         /*}}}*/
 586 // Finish - helper that cleans the item out of the fetcher queue        /*{{{*/
 587 void pkgAcqIndexDiffs::Finish(bool allDone)
 588 {
 589    // we restore the original name, this is required, otherwise
 590    // the file will be cleaned
 591    if(allDone)
 592    {
 593       DestFile = _config->FindDir("Dir::State::lists");
 594       DestFile += URItoFileName(RealURI);
 595
 596       if(!ExpectedHash.empty() && !ExpectedHash.VerifyFile(DestFile))
 597       {
 598          Status = StatAuthError;
 599          ErrorText = _("MD5Sum mismatch");
 600          Rename(DestFile,DestFile + ".FAILED");
 601          Dequeue();
 602          return;
 603       }
 604
 605       // this is for the "real" finish
 606       Complete = true;
 607       Status = StatDone;
 608       Dequeue();
 609       if(Debug)
 610          std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
 611       return;
 612    }
 613
 614    if(Debug)
 615       std::clog << "Finishing: " << Desc.URI << std::endl;
 616    Complete = false;
 617    Status = StatDone;
 618    Dequeue();
 619    return;
 620 }
 621                                                                         /*}}}*/
 622 bool pkgAcqIndexDiffs::QueueNextDiff()                                  /*{{{*/
 623 {
 624
 625    // calc sha1 of the just patched file
 626    string FinalFile = _config->FindDir("Dir::State::lists");
 627    FinalFile += URItoFileName(RealURI);
 628
 629    FileFd fd(FinalFile, FileFd::ReadOnly);
 630    SHA1Summation SHA1;
 631    SHA1.AddFD(fd);
 632    string local_sha1 = string(SHA1.Result());
 633    if(Debug)
 634       std::clog << "QueueNextDiff: "
 635                 << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 636
 637    // final file reached before all patches are applied
 638    if(local_sha1 == ServerSha1)
 639    {
 640       Finish(true);
 641       return true;
 642    }
 643
 644    // remove all patches until the next matching patch is found
 645    // this requires the Index file to be ordered
 646    for(vector<DiffInfo>::iterator I=available_patches.begin();
 647        available_patches.empty() == false &&
 648           I != available_patches.end() &&
 649           I->sha1 != local_sha1;
 650        ++I)
 651    {
 652       available_patches.erase(I);
 653    }
 654
 655    // error checking and falling back if no patch was found
 656    if(available_patches.empty() == true)
 657    {
 658       Failed("", NULL);
 659       return false;
 660    }
 661
 662    // queue the right diff
 663    Desc.URI = string(RealURI) + ".diff/" + available_patches[0].file + ".gz";
 664    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
 665    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 666    DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file);
 667
 668    if(Debug)
 669       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
 670
 671    QueueURI(Desc);
 672
 673    return true;
 674 }
 675                                                                         /*}}}*/
 676 void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size,string Md5Hash,      /*{{{*/
 677                             pkgAcquire::MethodConfig *Cnf)
 678 {
 679    if(Debug)
 680       std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
 681
 682    Item::Done(Message,Size,Md5Hash,Cnf);
 683
 684    string FinalFile;
 685    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 686
 687    // sucess in downloading a diff, enter ApplyDiff state
 688    if(State == StateFetchDiff)
 689    {
 690
 691       // rred excepts the patch as $FinalFile.ed
 692       Rename(DestFile,FinalFile+".ed");
 693
 694       if(Debug)
 695          std::clog << "Sending to rred method: " << FinalFile << std::endl;
 696
 697       State = StateApplyDiff;
 698       Local = true;
 699       Desc.URI = "rred:" + FinalFile;
 700       QueueURI(Desc);
 701       Mode = "rred";
 702       return;
 703    }
 704
 705
 706    // success in download/apply a diff, queue next (if needed)
 707    if(State == StateApplyDiff)
 708    {
 709       // remove the just applied patch
 710       available_patches.erase(available_patches.begin());
 711
 712       // move into place
 713       if(Debug)
 714       {
 715          std::clog << "Moving patched file in place: " << std::endl
 716                    << DestFile << " -> " << FinalFile << std::endl;
 717       }
 718       Rename(DestFile,FinalFile);
 719       chmod(FinalFile.c_str(),0644);
 720
 721       // see if there is more to download
 722       if(available_patches.empty() == false) {
 723          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 724                               ExpectedHash, ServerSha1, available_patches);
 725          return Finish();
 726       } else
 727          return Finish(true);
 728    }
 729 }
 730                                                                         /*}}}*/
 731 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 732 // ---------------------------------------------------------------------
 733 /* The package file is added to the queue and a second class is
 734    instantiated to fetch the revision file */
 735 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 736                          string URI,string URIDesc,string ShortDesc,
 737                          HashString ExpectedHash, string comprExt)
 738    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash)
 739 {
 740    if(comprExt.empty() == true)
 741    {
 742       // autoselect the compression method
 743       std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 744       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 745          comprExt.append(*t).append(" ");
 746       if (comprExt.empty() == false)
 747          comprExt.erase(comprExt.end()-1);
 748    }
 749    CompressionExtension = comprExt;
 750
 751    Init(URI, URIDesc, ShortDesc);
 752 }
 753 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner, IndexTarget const *Target,
 754                          HashString const &ExpectedHash, indexRecords const *MetaIndexParser)
 755    : Item(Owner), RealURI(Target->URI), ExpectedHash(ExpectedHash)
 756 {
 757    // autoselect the compression method
 758    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 759    CompressionExtension = "";
 760    if (ExpectedHash.empty() == false)
 761    {
 762       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 763          if (*t == "uncompressed" || MetaIndexParser->Exists(string(Target->MetaKey).append(".").append(*t)) == true)
 764             CompressionExtension.append(*t).append(" ");
 765    }
 766    else
 767    {
 768       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 769          CompressionExtension.append(*t).append(" ");
 770    }
 771    if (CompressionExtension.empty() == false)
 772       CompressionExtension.erase(CompressionExtension.end()-1);
 773
 774    // only verify non-optional targets, see acquire-item.h for a FIXME
 775    // to make this more flexible
 776    if (Target->IsOptional())
 777      Verify = false;
 778    else
 779      Verify = true;
 780
 781    Init(Target->URI, Target->Description, Target->ShortDesc);
 782 }
 783                                                                         /*}}}*/
 784 // AcqIndex::Init - defered Constructor                                 /*{{{*/
 785 void pkgAcqIndex::Init(string const &URI, string const &URIDesc, string const &ShortDesc) {
 786    Decompression = false;
 787    Erase = false;
 788
 789    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 790    DestFile += URItoFileName(URI);
 791
 792    std::string const comprExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
 793    if (comprExt == "uncompressed")
 794       Desc.URI = URI;
 795    else
 796       Desc.URI = URI + '.' + comprExt;
 797
 798    Desc.Description = URIDesc;
 799    Desc.Owner = this;
 800    Desc.ShortDesc = ShortDesc;
 801
 802    QueueURI(Desc);
 803 }
 804                                                                         /*}}}*/
 805 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 806 // ---------------------------------------------------------------------
 807 /* The only header we use is the last-modified header. */
 808 string pkgAcqIndex::Custom600Headers()
 809 {
 810    string Final = _config->FindDir("Dir::State::lists");
 811    Final += URItoFileName(RealURI);
 812    if (_config->FindB("Acquire::GzipIndexes",false))
 813       Final += ".gz";
 814
 815    string msg = "\nIndex-File: true";
 816    // FIXME: this really should use "IndexTarget::IsOptional()" but that
 817    //        seems to be difficult without breaking ABI
 818    if (ShortDesc().find("Translation") != 0)
 819       msg += "\nFail-Ignore: true";
 820    struct stat Buf;
 821    if (stat(Final.c_str(),&Buf) == 0)
 822       msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 823
 824    return msg;
 825 }
 826                                                                         /*}}}*/
 827 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)  /*{{{*/
 828 {
 829    size_t const nextExt = CompressionExtension.find(' ');
 830    if (nextExt != std::string::npos)
 831    {
 832       CompressionExtension = CompressionExtension.substr(nextExt+1);
 833       Init(RealURI, Desc.Description, Desc.ShortDesc);
 834       return;
 835    }
 836
 837    // on decompression failure, remove bad versions in partial/
 838    if (Decompression && Erase) {
 839       string s = _config->FindDir("Dir::State::lists") + "partial/";
 840       s.append(URItoFileName(RealURI));
 841       unlink(s.c_str());
 842    }
 843
 844    Item::Failed(Message,Cnf);
 845 }
 846                                                                         /*}}}*/
 847 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 848 // ---------------------------------------------------------------------
 849 /* This goes through a number of states.. On the initial fetch the
 850    method could possibly return an alternate filename which points
 851    to the uncompressed version of the file. If this is so the file
 852    is copied into the partial directory. In all other cases the file
 853    is decompressed with a gzip uri. */
 854 void pkgAcqIndex::Done(string Message,unsigned long long Size,string Hash,
 855                        pkgAcquire::MethodConfig *Cfg)
 856 {
 857    Item::Done(Message,Size,Hash,Cfg);
 858
 859    if (Decompression == true)
 860    {
 861       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 862       {
 863          std::cerr << std::endl << RealURI << ": Computed Hash: " << Hash;
 864          std::cerr << "  Expected Hash: " << ExpectedHash.toStr() << std::endl;
 865       }
 866
 867       if (!ExpectedHash.empty() && ExpectedHash.toStr() != Hash)
 868       {
 869          Status = StatAuthError;
 870          ErrorText = _("Hash Sum mismatch");
 871          Rename(DestFile,DestFile + ".FAILED");
 872          ReportMirrorFailure("HashChecksumFailure");
 873          return;
 874       }
 875
 876       /* Verify the index file for correctness (all indexes must
 877        * have a Package field) (LP: #346386) (Closes: #627642) */
 878       if (Verify == true)
 879       {
 880          FileFd fd(DestFile, FileFd::ReadOnly);
 881          pkgTagSection sec;
 882          pkgTagFile tag(&fd);
 883
 884          // Only test for correctness if the file is not empty (empty is ok)
 885          if (fd.Size() > 0) {
 886             if (_error->PendingError() || !tag.Step(sec)) {
 887                Status = StatError;
 888                _error->DumpErrors();
 889                Rename(DestFile,DestFile + ".FAILED");
 890                return;
 891             } else if (!sec.Exists("Package")) {
 892                Status = StatError;
 893                ErrorText = ("Encountered a section with no Package: header");
 894                Rename(DestFile,DestFile + ".FAILED");
 895                return;
 896             }
 897          }
 898       }
 899
 900       // Done, move it into position
 901       string FinalFile = _config->FindDir("Dir::State::lists");
 902       FinalFile += URItoFileName(RealURI);
 903       Rename(DestFile,FinalFile);
 904       chmod(FinalFile.c_str(),0644);
 905
 906       /* We restore the original name to DestFile so that the clean operation
 907          will work OK */
 908       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 909       DestFile += URItoFileName(RealURI);
 910
 911       // Remove the compressed version.
 912       if (Erase == true)
 913          unlink(DestFile.c_str());
 914       return;
 915    }
 916
 917    Erase = false;
 918    Complete = true;
 919
 920    // Handle the unzipd case
 921    string FileName = LookupTag(Message,"Alt-Filename");
 922    if (FileName.empty() == false)
 923    {
 924       // The files timestamp matches
 925       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 926          return;
 927       Decompression = true;
 928       Local = true;
 929       DestFile += ".decomp";
 930       Desc.URI = "copy:" + FileName;
 931       QueueURI(Desc);
 932       Mode = "copy";
 933       return;
 934    }
 935
 936    FileName = LookupTag(Message,"Filename");
 937    if (FileName.empty() == true)
 938    {
 939       Status = StatError;
 940       ErrorText = "Method gave a blank filename";
 941    }
 942
 943    std::string const compExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
 944
 945    // The files timestamp matches
 946    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) {
 947        if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz")
 948           // Update DestFile for .gz suffix so that the clean operation keeps it
 949           DestFile += ".gz";
 950       return;
 951     }
 952
 953    if (FileName == DestFile)
 954       Erase = true;
 955    else
 956       Local = true;
 957
 958    string decompProg;
 959
 960    // If we enable compressed indexes and already have gzip, keep it
 961    if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz" && !Local) {
 962       string FinalFile = _config->FindDir("Dir::State::lists");
 963       FinalFile += URItoFileName(RealURI) + ".gz";
 964       Rename(DestFile,FinalFile);
 965       chmod(FinalFile.c_str(),0644);
 966
 967       // Update DestFile for .gz suffix so that the clean operation keeps it
 968       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 969       DestFile += URItoFileName(RealURI) + ".gz";
 970       return;
 971     }
 972
 973    // get the binary name for your used compression type
 974    decompProg = _config->Find(string("Acquire::CompressionTypes::").append(compExt),"");
 975    if(decompProg.empty() == false);
 976    else if(compExt == "uncompressed")
 977       decompProg = "copy";
 978    else {
 979       _error->Error("Unsupported extension: %s", compExt.c_str());
 980       return;
 981    }
 982
 983    Decompression = true;
 984    DestFile += ".decomp";
 985    Desc.URI = decompProg + ":" + FileName;
 986    QueueURI(Desc);
 987
 988    // FIXME: this points to a c++ string that goes out of scope
 989    Mode = decompProg.c_str();
 990 }
 991                                                                         /*}}}*/
 992 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                        /*{{{*/
 993 // ---------------------------------------------------------------------
 994 /* The Translation file is added to the queue */
 995 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 996                             string URI,string URIDesc,string ShortDesc)
 997   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashString(), "")
 998 {
 999 }
1000 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner, IndexTarget const *Target,
1001                          HashString const &ExpectedHash, indexRecords const *MetaIndexParser)
1002   : pkgAcqIndex(Owner, Target, ExpectedHash, MetaIndexParser)
1003 {
1004 }
1005                                                                         /*}}}*/
1006 // AcqIndexTrans::Custom600Headers - Insert custom request headers      /*{{{*/
1007 // ---------------------------------------------------------------------
1008 string pkgAcqIndexTrans::Custom600Headers()
1009 {
1010    string Final = _config->FindDir("Dir::State::lists");
1011    Final += URItoFileName(RealURI);
1012
1013    struct stat Buf;
1014    if (stat(Final.c_str(),&Buf) != 0)
1015       return "\nFail-Ignore: true\nIndex-File: true";
1016    return "\nFail-Ignore: true\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1017 }
1018                                                                         /*}}}*/
1019 // AcqIndexTrans::Failed - Silence failure messages for missing files   /*{{{*/
1020 // ---------------------------------------------------------------------
1021 /* */
1022 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1023 {
1024    size_t const nextExt = CompressionExtension.find(' ');
1025    if (nextExt != std::string::npos)
1026    {
1027       CompressionExtension = CompressionExtension.substr(nextExt+1);
1028       Init(RealURI, Desc.Description, Desc.ShortDesc);
1029       Status = StatIdle;
1030       return;
1031    }
1032
1033    if (Cnf->LocalOnly == true ||
1034        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
1035    {
1036       // Ignore this
1037       Status = StatDone;
1038       Complete = false;
1039       Dequeue();
1040       return;
1041    }
1042
1043    Item::Failed(Message,Cnf);
1044 }
1045                                                                         /*}}}*/
1046 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,                         /*{{{*/
1047                              string URI,string URIDesc,string ShortDesc,
1048                              string MetaIndexURI, string MetaIndexURIDesc,
1049                              string MetaIndexShortDesc,
1050                              const vector<IndexTarget*>* IndexTargets,
1051                              indexRecords* MetaIndexParser) :
1052    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
1053    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
1054    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
1055 {
1056    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1057    DestFile += URItoFileName(URI);
1058
1059    // remove any partial downloaded sig-file in partial/.
1060    // it may confuse proxies and is too small to warrant a
1061    // partial download anyway
1062    unlink(DestFile.c_str());
1063
1064    // Create the item
1065    Desc.Description = URIDesc;
1066    Desc.Owner = this;
1067    Desc.ShortDesc = ShortDesc;
1068    Desc.URI = URI;
1069
1070    string Final = _config->FindDir("Dir::State::lists");
1071    Final += URItoFileName(RealURI);
1072    if (RealFileExists(Final) == true)
1073    {
1074       // File was already in place.  It needs to be re-downloaded/verified
1075       // because Release might have changed, we do give it a differnt
1076       // name than DestFile because otherwise the http method will
1077       // send If-Range requests and there are too many broken servers
1078       // out there that do not understand them
1079       LastGoodSig = DestFile+".reverify";
1080       Rename(Final,LastGoodSig);
1081    }
1082
1083    QueueURI(Desc);
1084 }
1085                                                                         /*}}}*/
1086 pkgAcqMetaSig::~pkgAcqMetaSig()                                         /*{{{*/
1087 {
1088    // if the file was never queued undo file-changes done in the constructor
1089    if (QueueCounter == 1 && Status == StatIdle && FileSize == 0 && Complete == false &&
1090          LastGoodSig.empty() == false)
1091    {
1092       string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1093       if (RealFileExists(Final) == false && RealFileExists(LastGoodSig) == true)
1094          Rename(LastGoodSig, Final);
1095    }
1096
1097 }
1098                                                                         /*}}}*/
1099 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
1100 // ---------------------------------------------------------------------
1101 /* The only header we use is the last-modified header. */
1102 string pkgAcqMetaSig::Custom600Headers()
1103 {
1104    struct stat Buf;
1105    if (stat(LastGoodSig.c_str(),&Buf) != 0)
1106       return "\nIndex-File: true";
1107
1108    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1109 }
1110
1111 void pkgAcqMetaSig::Done(string Message,unsigned long long Size,string MD5,
1112                          pkgAcquire::MethodConfig *Cfg)
1113 {
1114    Item::Done(Message,Size,MD5,Cfg);
1115
1116    string FileName = LookupTag(Message,"Filename");
1117    if (FileName.empty() == true)
1118    {
1119       Status = StatError;
1120       ErrorText = "Method gave a blank filename";
1121       return;
1122    }
1123
1124    if (FileName != DestFile)
1125    {
1126       // We have to copy it into place
1127       Local = true;
1128       Desc.URI = "copy:" + FileName;
1129       QueueURI(Desc);
1130       return;
1131    }
1132
1133    Complete = true;
1134
1135    // put the last known good file back on i-m-s hit (it will
1136    // be re-verified again)
1137    // Else do nothing, we have the new file in DestFile then
1138    if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1139       Rename(LastGoodSig, DestFile);
1140
1141    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
1142    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc,
1143                        MetaIndexShortDesc,  DestFile, IndexTargets,
1144                        MetaIndexParser);
1145
1146 }
1147                                                                         /*}}}*/
1148 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
1149 {
1150    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1151
1152    // if we get a network error we fail gracefully
1153    if(Status == StatTransientNetworkError)
1154    {
1155       Item::Failed(Message,Cnf);
1156       // move the sigfile back on transient network failures
1157       if(FileExists(LastGoodSig))
1158          Rename(LastGoodSig,Final);
1159
1160       // set the status back to , Item::Failed likes to reset it
1161       Status = pkgAcquire::Item::StatTransientNetworkError;
1162       return;
1163    }
1164
1165    // Delete any existing sigfile when the acquire failed
1166    unlink(Final.c_str());
1167
1168    // queue a pkgAcqMetaIndex with no sigfile
1169    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
1170                        "", IndexTargets, MetaIndexParser);
1171
1172    if (Cnf->LocalOnly == true ||
1173        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
1174    {
1175       // Ignore this
1176       Status = StatDone;
1177       Complete = false;
1178       Dequeue();
1179       return;
1180    }
1181
1182    Item::Failed(Message,Cnf);
1183 }
1184                                                                         /*}}}*/
1185 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                     /*{{{*/
1186                                  string URI,string URIDesc,string ShortDesc,
1187                                  string SigFile,
1188                                  const vector<struct IndexTarget*>* IndexTargets,
1189                                  indexRecords* MetaIndexParser) :
1190    Item(Owner), RealURI(URI), SigFile(SigFile), IndexTargets(IndexTargets),
1191    MetaIndexParser(MetaIndexParser), AuthPass(false), IMSHit(false)
1192 {
1193    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1194    DestFile += URItoFileName(URI);
1195
1196    // Create the item
1197    Desc.Description = URIDesc;
1198    Desc.Owner = this;
1199    Desc.ShortDesc = ShortDesc;
1200    Desc.URI = URI;
1201
1202    QueueURI(Desc);
1203 }
1204                                                                         /*}}}*/
1205 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
1206 // ---------------------------------------------------------------------
1207 /* The only header we use is the last-modified header. */
1208 string pkgAcqMetaIndex::Custom600Headers()
1209 {
1210    string Final = _config->FindDir("Dir::State::lists");
1211    Final += URItoFileName(RealURI);
1212
1213    struct stat Buf;
1214    if (stat(Final.c_str(),&Buf) != 0)
1215       return "\nIndex-File: true";
1216
1217    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1218 }
1219                                                                         /*}}}*/
1220 void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,string Hash,  /*{{{*/
1221                            pkgAcquire::MethodConfig *Cfg)
1222 {
1223    Item::Done(Message,Size,Hash,Cfg);
1224
1225    // MetaIndexes are done in two passes: one to download the
1226    // metaindex with an appropriate method, and a second to verify it
1227    // with the gpgv method
1228
1229    if (AuthPass == true)
1230    {
1231       AuthDone(Message);
1232
1233       // all cool, move Release file into place
1234       Complete = true;
1235    }
1236    else
1237    {
1238       RetrievalDone(Message);
1239       if (!Complete)
1240          // Still more retrieving to do
1241          return;
1242
1243       if (SigFile == "")
1244       {
1245          // There was no signature file, so we are finished.  Download
1246          // the indexes and do only hashsum verification if possible
1247          MetaIndexParser->Load(DestFile);
1248          QueueIndexes(false);
1249       }
1250       else
1251       {
1252          // There was a signature file, so pass it to gpgv for
1253          // verification
1254
1255          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1256             std::cerr << "Metaindex acquired, queueing gpg verification ("
1257                       << SigFile << "," << DestFile << ")\n";
1258          AuthPass = true;
1259          Desc.URI = "gpgv:" + SigFile;
1260          QueueURI(Desc);
1261          Mode = "gpgv";
1262          return;
1263       }
1264    }
1265
1266    if (Complete == true)
1267    {
1268       string FinalFile = _config->FindDir("Dir::State::lists");
1269       FinalFile += URItoFileName(RealURI);
1270       if (SigFile == DestFile)
1271          SigFile = FinalFile;
1272       Rename(DestFile,FinalFile);
1273       chmod(FinalFile.c_str(),0644);
1274       DestFile = FinalFile;
1275    }
1276 }
1277                                                                         /*}}}*/
1278 void pkgAcqMetaIndex::RetrievalDone(string Message)                     /*{{{*/
1279 {
1280    // We have just finished downloading a Release file (it is not
1281    // verified yet)
1282
1283    string FileName = LookupTag(Message,"Filename");
1284    if (FileName.empty() == true)
1285    {
1286       Status = StatError;
1287       ErrorText = "Method gave a blank filename";
1288       return;
1289    }
1290
1291    if (FileName != DestFile)
1292    {
1293       Local = true;
1294       Desc.URI = "copy:" + FileName;
1295       QueueURI(Desc);
1296       return;
1297    }
1298
1299    // make sure to verify against the right file on I-M-S hit
1300    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
1301    if(IMSHit)
1302    {
1303       string FinalFile = _config->FindDir("Dir::State::lists");
1304       FinalFile += URItoFileName(RealURI);
1305       if (SigFile == DestFile)
1306       {
1307          SigFile = FinalFile;
1308          // constructor of pkgAcqMetaClearSig moved it out of the way,
1309          // now move it back in on IMS hit for the 'old' file
1310          string const OldClearSig = DestFile + ".reverify";
1311          if (RealFileExists(OldClearSig) == true)
1312             Rename(OldClearSig, FinalFile);
1313       }
1314       DestFile = FinalFile;
1315    }
1316    Complete = true;
1317 }
1318                                                                         /*}}}*/
1319 void pkgAcqMetaIndex::AuthDone(string Message)                          /*{{{*/
1320 {
1321    // At this point, the gpgv method has succeeded, so there is a
1322    // valid signature from a key in the trusted keyring.  We
1323    // perform additional verification of its contents, and use them
1324    // to verify the indexes we are about to download
1325
1326    if (!MetaIndexParser->Load(DestFile))
1327    {
1328       Status = StatAuthError;
1329       ErrorText = MetaIndexParser->ErrorText;
1330       return;
1331    }
1332
1333    if (!VerifyVendor(Message))
1334    {
1335       return;
1336    }
1337
1338    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1339       std::cerr << "Signature verification succeeded: "
1340                 << DestFile << std::endl;
1341
1342    // Download further indexes with verification
1343    QueueIndexes(true);
1344
1345    // is it a clearsigned MetaIndex file?
1346    if (DestFile == SigFile)
1347       return;
1348
1349    // Done, move signature file into position
1350    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
1351       URItoFileName(RealURI) + ".gpg";
1352    Rename(SigFile,VerifiedSigFile);
1353    chmod(VerifiedSigFile.c_str(),0644);
1354 }
1355                                                                         /*}}}*/
1356 void pkgAcqMetaIndex::QueueIndexes(bool verify)                         /*{{{*/
1357 {
1358 #if 0
1359    /* Reject invalid, existing Release files (LP: #346386) (Closes: #627642)
1360     * FIXME: Disabled; it breaks unsigned repositories without hashes */
1361    if (!verify && FileExists(DestFile) && !MetaIndexParser->Load(DestFile))
1362    {
1363       Status = StatError;
1364       ErrorText = MetaIndexParser->ErrorText;
1365       return;
1366    }
1367 #endif
1368    bool transInRelease = false;
1369    {
1370       std::vector<std::string> const keys = MetaIndexParser->MetaKeys();
1371       for (std::vector<std::string>::const_iterator k = keys.begin(); k != keys.end(); ++k)
1372          // FIXME: Feels wrong to check for hardcoded string here, but what should we do else…
1373          if (k->find("Translation-") != std::string::npos)
1374          {
1375             transInRelease = true;
1376             break;
1377          }
1378    }
1379
1380    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
1381         Target != IndexTargets->end();
1382         ++Target)
1383    {
1384       HashString ExpectedIndexHash;
1385       const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
1386       bool compressedAvailable = false;
1387       if (Record == NULL)
1388       {
1389          if ((*Target)->IsOptional() == true)
1390          {
1391             std::vector<std::string> types = APT::Configuration::getCompressionTypes();
1392             for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
1393                if (MetaIndexParser->Exists(string((*Target)->MetaKey).append(".").append(*t)) == true)
1394                {
1395                   compressedAvailable = true;
1396                   break;
1397                }
1398          }
1399          else if (verify == true)
1400          {
1401             Status = StatAuthError;
1402             strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), (*Target)->MetaKey.c_str());
1403             return;
1404          }
1405       }
1406       else
1407       {
1408          ExpectedIndexHash = Record->Hash;
1409          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1410          {
1411             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
1412             std::cerr << "Expected Hash: " << ExpectedIndexHash.toStr() << std::endl;
1413             std::cerr << "For: " << Record->MetaKeyFilename << std::endl;
1414          }
1415          if (verify == true && ExpectedIndexHash.empty() == true && (*Target)->IsOptional() == false)
1416          {
1417             Status = StatAuthError;
1418             strprintf(ErrorText, _("Unable to find hash sum for '%s' in Release file"), (*Target)->MetaKey.c_str());
1419             return;
1420          }
1421       }
1422
1423       if ((*Target)->IsOptional() == true)
1424       {
1425          if ((*Target)->IsSubIndex() == true)
1426             new pkgAcqSubIndex(Owner, (*Target)->URI, (*Target)->Description,
1427                                 (*Target)->ShortDesc, ExpectedIndexHash);
1428          else if (transInRelease == false || Record != NULL || compressedAvailable == true)
1429          {
1430             if (_config->FindB("Acquire::PDiffs",true) == true && transInRelease == true &&
1431                 MetaIndexParser->Exists(string((*Target)->MetaKey).append(".diff/Index")) == true)
1432                new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description,
1433                                    (*Target)->ShortDesc, ExpectedIndexHash);
1434             else
1435                new pkgAcqIndexTrans(Owner, *Target, ExpectedIndexHash, MetaIndexParser);
1436          }
1437          continue;
1438       }
1439
1440       /* Queue Packages file (either diff or full packages files, depending
1441          on the users option) - we also check if the PDiff Index file is listed
1442          in the Meta-Index file. Ideal would be if pkgAcqDiffIndex would test this
1443          instead, but passing the required info to it is to much hassle */
1444       if(_config->FindB("Acquire::PDiffs",true) == true && (verify == false ||
1445           MetaIndexParser->Exists(string((*Target)->MetaKey).append(".diff/Index")) == true))
1446          new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description,
1447                              (*Target)->ShortDesc, ExpectedIndexHash);
1448       else
1449          new pkgAcqIndex(Owner, *Target, ExpectedIndexHash, MetaIndexParser);
1450    }
1451 }
1452                                                                         /*}}}*/
1453 bool pkgAcqMetaIndex::VerifyVendor(string Message)                      /*{{{*/
1454 {
1455    string::size_type pos;
1456
1457    // check for missing sigs (that where not fatal because otherwise we had
1458    // bombed earlier)
1459    string missingkeys;
1460    string msg = _("There is no public key available for the "
1461                   "following key IDs:\n");
1462    pos = Message.find("NO_PUBKEY ");
1463    if (pos != std::string::npos)
1464    {
1465       string::size_type start = pos+strlen("NO_PUBKEY ");
1466       string Fingerprint = Message.substr(start, Message.find("\n")-start);
1467       missingkeys += (Fingerprint);
1468    }
1469    if(!missingkeys.empty())
1470       _error->Warning("%s", string(msg+missingkeys).c_str());
1471
1472    string Transformed = MetaIndexParser->GetExpectedDist();
1473
1474    if (Transformed == "../project/experimental")
1475    {
1476       Transformed = "experimental";
1477    }
1478
1479    pos = Transformed.rfind('/');
1480    if (pos != string::npos)
1481    {
1482       Transformed = Transformed.substr(0, pos);
1483    }
1484
1485    if (Transformed == ".")
1486    {
1487       Transformed = "";
1488    }
1489
1490    if (_config->FindB("Acquire::Check-Valid-Until", true) == true &&
1491        MetaIndexParser->GetValidUntil() > 0) {
1492       time_t const invalid_since = time(NULL) - MetaIndexParser->GetValidUntil();
1493       if (invalid_since > 0)
1494          // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
1495          // the time since then the file is invalid - formated in the same way as in
1496          // the download progress display (e.g. 7d 3h 42min 1s)
1497          return _error->Error(
1498             _("Release file for %s is expired (invalid since %s). "
1499               "Updates for this repository will not be applied."),
1500             RealURI.c_str(), TimeToStr(invalid_since).c_str());
1501    }
1502
1503    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1504    {
1505       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
1506       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
1507       std::cerr << "Transformed Dist: " << Transformed << std::endl;
1508    }
1509
1510    if (MetaIndexParser->CheckDist(Transformed) == false)
1511    {
1512       // This might become fatal one day
1513 //       Status = StatAuthError;
1514 //       ErrorText = "Conflicting distribution; expected "
1515 //          + MetaIndexParser->GetExpectedDist() + " but got "
1516 //          + MetaIndexParser->GetDist();
1517 //       return false;
1518       if (!Transformed.empty())
1519       {
1520          _error->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
1521                          Desc.Description.c_str(),
1522                          Transformed.c_str(),
1523                          MetaIndexParser->GetDist().c_str());
1524       }
1525    }
1526
1527    return true;
1528 }
1529                                                                         /*}}}*/
1530 // pkgAcqMetaIndex::Failed - no Release file present or no signature file present       /*{{{*/
1531 // ---------------------------------------------------------------------
1532 /* */
1533 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1534 {
1535    if (AuthPass == true)
1536    {
1537       // gpgv method failed, if we have a good signature
1538       string LastGoodSigFile = _config->FindDir("Dir::State::lists").append("partial/").append(URItoFileName(RealURI));
1539       if (DestFile != SigFile)
1540          LastGoodSigFile.append(".gpg");
1541       LastGoodSigFile.append(".reverify");
1542
1543       if(FileExists(LastGoodSigFile))
1544       {
1545          string VerifiedSigFile = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1546          if (DestFile != SigFile)
1547             VerifiedSigFile.append(".gpg");
1548          Rename(LastGoodSigFile, VerifiedSigFile);
1549          Status = StatTransientNetworkError;
1550          _error->Warning(_("An error occurred during the signature "
1551                            "verification. The repository is not updated "
1552                            "and the previous index files will be used. "
1553                            "GPG error: %s: %s\n"),
1554                          Desc.Description.c_str(),
1555                          LookupTag(Message,"Message").c_str());
1556          RunScripts("APT::Update::Auth-Failure");
1557          return;
1558       } else if (LookupTag(Message,"Message").find("NODATA") != string::npos) {
1559          /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
1560          _error->Error(_("GPG error: %s: %s"),
1561                          Desc.Description.c_str(),
1562                          LookupTag(Message,"Message").c_str());
1563          return;
1564       } else {
1565          _error->Warning(_("GPG error: %s: %s"),
1566                          Desc.Description.c_str(),
1567                          LookupTag(Message,"Message").c_str());
1568       }
1569       // gpgv method failed
1570       ReportMirrorFailure("GPGFailure");
1571    }
1572
1573    /* Always move the meta index, even if gpgv failed. This ensures
1574     * that PackageFile objects are correctly filled in */
1575    if (FileExists(DestFile)) {
1576       string FinalFile = _config->FindDir("Dir::State::lists");
1577       FinalFile += URItoFileName(RealURI);
1578       /* InRelease files become Release files, otherwise
1579        * they would be considered as trusted later on */
1580       if (SigFile == DestFile) {
1581          RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
1582                                        "Release");
1583          FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
1584                                        "Release");
1585          SigFile = FinalFile;
1586       }
1587       Rename(DestFile,FinalFile);
1588       chmod(FinalFile.c_str(),0644);
1589
1590       DestFile = FinalFile;
1591    }
1592
1593    // No Release file was present, or verification failed, so fall
1594    // back to queueing Packages files without verification
1595    QueueIndexes(false);
1596 }
1597                                                                         /*}}}*/
1598 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,               /*{{{*/
1599                 string const &URI, string const &URIDesc, string const &ShortDesc,
1600                 string const &MetaIndexURI, string const &MetaIndexURIDesc, string const &MetaIndexShortDesc,
1601                 string const &MetaSigURI, string const &MetaSigURIDesc, string const &MetaSigShortDesc,
1602                 const vector<struct IndexTarget*>* IndexTargets,
1603                 indexRecords* MetaIndexParser) :
1604         pkgAcqMetaIndex(Owner, URI, URIDesc, ShortDesc, "", IndexTargets, MetaIndexParser),
1605         MetaIndexURI(MetaIndexURI), MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
1606         MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc)
1607 {
1608    SigFile = DestFile;
1609
1610    // keep the old InRelease around in case of transistent network errors
1611    string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1612    if (RealFileExists(Final) == true)
1613    {
1614       string const LastGoodSig = DestFile + ".reverify";
1615       Rename(Final,LastGoodSig);
1616    }
1617 }
1618                                                                         /*}}}*/
1619 pkgAcqMetaClearSig::~pkgAcqMetaClearSig()                               /*{{{*/
1620 {
1621    // if the file was never queued undo file-changes done in the constructor
1622    if (QueueCounter == 1 && Status == StatIdle && FileSize == 0 && Complete == false)
1623    {
1624       string const Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1625       string const LastGoodSig = DestFile + ".reverify";
1626       if (RealFileExists(Final) == false && RealFileExists(LastGoodSig) == true)
1627          Rename(LastGoodSig, Final);
1628    }
1629 }
1630                                                                         /*}}}*/
1631 // pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers /*{{{*/
1632 // ---------------------------------------------------------------------
1633 // FIXME: this can go away once the InRelease file is used widely
1634 string pkgAcqMetaClearSig::Custom600Headers()
1635 {
1636    string Final = _config->FindDir("Dir::State::lists");
1637    Final += URItoFileName(RealURI);
1638
1639    struct stat Buf;
1640    if (stat(Final.c_str(),&Buf) != 0)
1641    {
1642       Final = DestFile + ".reverify";
1643       if (stat(Final.c_str(),&Buf) != 0)
1644          return "\nIndex-File: true\nFail-Ignore: true\n";
1645    }
1646
1647    return "\nIndex-File: true\nFail-Ignore: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1648 }
1649                                                                         /*}}}*/
1650 void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
1651 {
1652    if (AuthPass == false)
1653    {
1654       // Remove the 'old' InRelease file if we try Release.gpg now as otherwise
1655       // the file will stay around and gives a false-auth impression (CVE-2012-0214)
1656       string FinalFile = _config->FindDir("Dir::State::lists");
1657       FinalFile.append(URItoFileName(RealURI));
1658       if (FileExists(FinalFile))
1659          unlink(FinalFile.c_str());
1660
1661       new pkgAcqMetaSig(Owner,
1662                         MetaSigURI, MetaSigURIDesc, MetaSigShortDesc,
1663                         MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
1664                         IndexTargets, MetaIndexParser);
1665       if (Cnf->LocalOnly == true ||
1666           StringToBool(LookupTag(Message, "Transient-Failure"), false) == false)
1667          Dequeue();
1668    }
1669    else
1670       pkgAcqMetaIndex::Failed(Message, Cnf);
1671 }
1672                                                                         /*}}}*/
1673 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
1674 // ---------------------------------------------------------------------
1675 /* This just sets up the initial fetch environment and queues the first
1676    possibilitiy */
1677 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
1678                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
1679                              string &StoreFilename) :
1680                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
1681                StoreFilename(StoreFilename), Vf(Version.FileList()),
1682                Trusted(false)
1683 {
1684    Retries = _config->FindI("Acquire::Retries",0);
1685
1686    if (Version.Arch() == 0)
1687    {
1688       _error->Error(_("I wasn't able to locate a file for the %s package. "
1689                       "This might mean you need to manually fix this package. "
1690                       "(due to missing arch)"),
1691                     Version.ParentPkg().Name());
1692       return;
1693    }
1694
1695    /* We need to find a filename to determine the extension. We make the
1696       assumption here that all the available sources for this version share
1697       the same extension.. */
1698    // Skip not source sources, they do not have file fields.
1699    for (; Vf.end() == false; ++Vf)
1700    {
1701       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1702          continue;
1703       break;
1704    }
1705
1706    // Does not really matter here.. we are going to fail out below
1707    if (Vf.end() != true)
1708    {
1709       // If this fails to get a file name we will bomb out below.
1710       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1711       if (_error->PendingError() == true)
1712          return;
1713
1714       // Generate the final file name as: package_version_arch.foo
1715       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
1716                       QuoteString(Version.VerStr(),"_:") + '_' +
1717                       QuoteString(Version.Arch(),"_:.") +
1718                       "." + flExtension(Parse.FileName());
1719    }
1720
1721    // check if we have one trusted source for the package. if so, switch
1722    // to "TrustedOnly" mode
1723    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; ++i)
1724    {
1725       pkgIndexFile *Index;
1726       if (Sources->FindIndex(i.File(),Index) == false)
1727          continue;
1728       if (_config->FindB("Debug::pkgAcquire::Auth", false))
1729       {
1730          std::cerr << "Checking index: " << Index->Describe()
1731                    << "(Trusted=" << Index->IsTrusted() << ")\n";
1732       }
1733       if (Index->IsTrusted()) {
1734          Trusted = true;
1735          break;
1736       }
1737    }
1738
1739    // "allow-unauthenticated" restores apts old fetching behaviour
1740    // that means that e.g. unauthenticated file:// uris are higher
1741    // priority than authenticated http:// uris
1742    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
1743       Trusted = false;
1744
1745    // Select a source
1746    if (QueueNext() == false && _error->PendingError() == false)
1747       _error->Error(_("I wasn't able to locate a file for the %s package. "
1748                     "This might mean you need to manually fix this package."),
1749                     Version.ParentPkg().Name());
1750 }
1751                                                                         /*}}}*/
1752 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
1753 // ---------------------------------------------------------------------
1754 /* This queues the next available file version for download. It checks if
1755    the archive is already available in the cache and stashs the MD5 for
1756    checking later. */
1757 bool pkgAcqArchive::QueueNext()
1758 {
1759    string const ForceHash = _config->Find("Acquire::ForceHash");
1760    for (; Vf.end() == false; ++Vf)
1761    {
1762       // Ignore not source sources
1763       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1764          continue;
1765
1766       // Try to cross match against the source list
1767       pkgIndexFile *Index;
1768       if (Sources->FindIndex(Vf.File(),Index) == false)
1769             continue;
1770
1771       // only try to get a trusted package from another source if that source
1772       // is also trusted
1773       if(Trusted && !Index->IsTrusted())
1774          continue;
1775
1776       // Grab the text package record
1777       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1778       if (_error->PendingError() == true)
1779          return false;
1780
1781       string PkgFile = Parse.FileName();
1782       if (ForceHash.empty() == false)
1783       {
1784          if(stringcasecmp(ForceHash, "sha512") == 0)
1785             ExpectedHash = HashString("SHA512", Parse.SHA512Hash());
1786          else if(stringcasecmp(ForceHash, "sha256") == 0)
1787             ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
1788          else if (stringcasecmp(ForceHash, "sha1") == 0)
1789             ExpectedHash = HashString("SHA1", Parse.SHA1Hash());
1790          else
1791             ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1792       }
1793       else
1794       {
1795          string Hash;
1796          if ((Hash = Parse.SHA512Hash()).empty() == false)
1797             ExpectedHash = HashString("SHA512", Hash);
1798          else if ((Hash = Parse.SHA256Hash()).empty() == false)
1799             ExpectedHash = HashString("SHA256", Hash);
1800          else if ((Hash = Parse.SHA1Hash()).empty() == false)
1801             ExpectedHash = HashString("SHA1", Hash);
1802          else
1803             ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1804       }
1805       if (PkgFile.empty() == true)
1806          return _error->Error(_("The package index files are corrupted. No Filename: "
1807                               "field for package %s."),
1808                               Version.ParentPkg().Name());
1809
1810       Desc.URI = Index->ArchiveURI(PkgFile);
1811       Desc.Description = Index->ArchiveInfo(Version);
1812       Desc.Owner = this;
1813       Desc.ShortDesc = Version.ParentPkg().Name();
1814
1815       // See if we already have the file. (Legacy filenames)
1816       FileSize = Version->Size;
1817       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
1818       struct stat Buf;
1819       if (stat(FinalFile.c_str(),&Buf) == 0)
1820       {
1821          // Make sure the size matches
1822          if ((unsigned long long)Buf.st_size == Version->Size)
1823          {
1824             Complete = true;
1825             Local = true;
1826             Status = StatDone;
1827             StoreFilename = DestFile = FinalFile;
1828             return true;
1829          }
1830
1831          /* Hmm, we have a file and its size does not match, this means it is
1832             an old style mismatched arch */
1833          unlink(FinalFile.c_str());
1834       }
1835
1836       // Check it again using the new style output filenames
1837       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
1838       if (stat(FinalFile.c_str(),&Buf) == 0)
1839       {
1840          // Make sure the size matches
1841          if ((unsigned long long)Buf.st_size == Version->Size)
1842          {
1843             Complete = true;
1844             Local = true;
1845             Status = StatDone;
1846             StoreFilename = DestFile = FinalFile;
1847             return true;
1848          }
1849
1850          /* Hmm, we have a file and its size does not match, this shouldnt
1851             happen.. */
1852          unlink(FinalFile.c_str());
1853       }
1854
1855       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
1856
1857       // Check the destination file
1858       if (stat(DestFile.c_str(),&Buf) == 0)
1859       {
1860          // Hmm, the partial file is too big, erase it
1861          if ((unsigned long long)Buf.st_size > Version->Size)
1862             unlink(DestFile.c_str());
1863          else
1864             PartialSize = Buf.st_size;
1865       }
1866
1867       // Disables download of archives - useful if no real installation follows,
1868       // e.g. if we are just interested in proposed installation order
1869       if (_config->FindB("Debug::pkgAcqArchive::NoQueue", false) == true)
1870       {
1871          Complete = true;
1872          Local = true;
1873          Status = StatDone;
1874          StoreFilename = DestFile = FinalFile;
1875          return true;
1876       }
1877
1878       // Create the item
1879       Local = false;
1880       Desc.URI = Index->ArchiveURI(PkgFile);
1881       Desc.Description = Index->ArchiveInfo(Version);
1882       Desc.Owner = this;
1883       Desc.ShortDesc = Version.ParentPkg().Name();
1884       QueueURI(Desc);
1885
1886       ++Vf;
1887       return true;
1888    }
1889    return false;
1890 }
1891                                                                         /*}}}*/
1892 // AcqArchive::Done - Finished fetching                                 /*{{{*/
1893 // ---------------------------------------------------------------------
1894 /* */
1895 void pkgAcqArchive::Done(string Message,unsigned long long Size,string CalcHash,
1896                          pkgAcquire::MethodConfig *Cfg)
1897 {
1898    Item::Done(Message,Size,CalcHash,Cfg);
1899
1900    // Check the size
1901    if (Size != Version->Size)
1902    {
1903       Status = StatError;
1904       ErrorText = _("Size mismatch");
1905       return;
1906    }
1907
1908    // Check the hash
1909    if(ExpectedHash.toStr() != CalcHash)
1910    {
1911       Status = StatError;
1912       ErrorText = _("Hash Sum mismatch");
1913       if(FileExists(DestFile))
1914          Rename(DestFile,DestFile + ".FAILED");
1915       return;
1916    }
1917
1918    // Grab the output filename
1919    string FileName = LookupTag(Message,"Filename");
1920    if (FileName.empty() == true)
1921    {
1922       Status = StatError;
1923       ErrorText = "Method gave a blank filename";
1924       return;
1925    }
1926
1927    Complete = true;
1928
1929    // Reference filename
1930    if (FileName != DestFile)
1931    {
1932       StoreFilename = DestFile = FileName;
1933       Local = true;
1934       return;
1935    }
1936
1937    // Done, move it into position
1938    string FinalFile = _config->FindDir("Dir::Cache::Archives");
1939    FinalFile += flNotDir(StoreFilename);
1940    Rename(DestFile,FinalFile);
1941
1942    StoreFilename = DestFile = FinalFile;
1943    Complete = true;
1944 }
1945                                                                         /*}}}*/
1946 // AcqArchive::Failed - Failure handler                                 /*{{{*/
1947 // ---------------------------------------------------------------------
1948 /* Here we try other sources */
1949 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1950 {
1951    ErrorText = LookupTag(Message,"Message");
1952
1953    /* We don't really want to retry on failed media swaps, this prevents
1954       that. An interesting observation is that permanent failures are not
1955       recorded. */
1956    if (Cnf->Removable == true &&
1957        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1958    {
1959       // Vf = Version.FileList();
1960       while (Vf.end() == false) ++Vf;
1961       StoreFilename = string();
1962       Item::Failed(Message,Cnf);
1963       return;
1964    }
1965
1966    if (QueueNext() == false)
1967    {
1968       // This is the retry counter
1969       if (Retries != 0 &&
1970           Cnf->LocalOnly == false &&
1971           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1972       {
1973          Retries--;
1974          Vf = Version.FileList();
1975          if (QueueNext() == true)
1976             return;
1977       }
1978
1979       StoreFilename = string();
1980       Item::Failed(Message,Cnf);
1981    }
1982 }
1983                                                                         /*}}}*/
1984 // AcqArchive::IsTrusted - Determine whether this archive comes from a trusted source /*{{{*/
1985 // ---------------------------------------------------------------------
1986 bool pkgAcqArchive::IsTrusted()
1987 {
1988    return Trusted;
1989 }
1990                                                                         /*}}}*/
1991 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1992 // ---------------------------------------------------------------------
1993 /* */
1994 void pkgAcqArchive::Finished()
1995 {
1996    if (Status == pkgAcquire::Item::StatDone &&
1997        Complete == true)
1998       return;
1999    StoreFilename = string();
2000 }
2001                                                                         /*}}}*/
2002 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
2003 // ---------------------------------------------------------------------
2004 /* The file is added to the queue */
2005 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string Hash,
2006                        unsigned long long Size,string Dsc,string ShortDesc,
2007                        const string &DestDir, const string &DestFilename,
2008                        bool IsIndexFile) :
2009                        Item(Owner), ExpectedHash(Hash), IsIndexFile(IsIndexFile)
2010 {
2011    Retries = _config->FindI("Acquire::Retries",0);
2012
2013    if(!DestFilename.empty())
2014       DestFile = DestFilename;
2015    else if(!DestDir.empty())
2016       DestFile = DestDir + "/" + flNotDir(URI);
2017    else
2018       DestFile = flNotDir(URI);
2019
2020    // Create the item
2021    Desc.URI = URI;
2022    Desc.Description = Dsc;
2023    Desc.Owner = this;
2024
2025    // Set the short description to the archive component
2026    Desc.ShortDesc = ShortDesc;
2027
2028    // Get the transfer sizes
2029    FileSize = Size;
2030    struct stat Buf;
2031    if (stat(DestFile.c_str(),&Buf) == 0)
2032    {
2033       // Hmm, the partial file is too big, erase it
2034       if ((unsigned long long)Buf.st_size > Size)
2035          unlink(DestFile.c_str());
2036       else
2037          PartialSize = Buf.st_size;
2038    }
2039
2040    QueueURI(Desc);
2041 }
2042                                                                         /*}}}*/
2043 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
2044 // ---------------------------------------------------------------------
2045 /* */
2046 void pkgAcqFile::Done(string Message,unsigned long long Size,string CalcHash,
2047                       pkgAcquire::MethodConfig *Cnf)
2048 {
2049    Item::Done(Message,Size,CalcHash,Cnf);
2050
2051    // Check the hash
2052    if(!ExpectedHash.empty() && ExpectedHash.toStr() != CalcHash)
2053    {
2054       Status = StatError;
2055       ErrorText = _("Hash Sum mismatch");
2056       Rename(DestFile,DestFile + ".FAILED");
2057       return;
2058    }
2059
2060    string FileName = LookupTag(Message,"Filename");
2061    if (FileName.empty() == true)
2062    {
2063       Status = StatError;
2064       ErrorText = "Method gave a blank filename";
2065       return;
2066    }
2067
2068    Complete = true;
2069
2070    // The files timestamp matches
2071    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
2072       return;
2073
2074    // We have to copy it into place
2075    if (FileName != DestFile)
2076    {
2077       Local = true;
2078       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
2079           Cnf->Removable == true)
2080       {
2081          Desc.URI = "copy:" + FileName;
2082          QueueURI(Desc);
2083          return;
2084       }
2085
2086       // Erase the file if it is a symlink so we can overwrite it
2087       struct stat St;
2088       if (lstat(DestFile.c_str(),&St) == 0)
2089       {
2090          if (S_ISLNK(St.st_mode) != 0)
2091             unlink(DestFile.c_str());
2092       }
2093
2094       // Symlink the file
2095       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
2096       {
2097          ErrorText = "Link to " + DestFile + " failure ";
2098          Status = StatError;
2099          Complete = false;
2100       }
2101    }
2102 }
2103                                                                         /*}}}*/
2104 // AcqFile::Failed - Failure handler                                    /*{{{*/
2105 // ---------------------------------------------------------------------
2106 /* Here we try other sources */
2107 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
2108 {
2109    ErrorText = LookupTag(Message,"Message");
2110
2111    // This is the retry counter
2112    if (Retries != 0 &&
2113        Cnf->LocalOnly == false &&
2114        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
2115    {
2116       Retries--;
2117       QueueURI(Desc);
2118       return;
2119    }
2120
2121    Item::Failed(Message,Cnf);
2122 }
2123                                                                         /*}}}*/
2124 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
2125 // ---------------------------------------------------------------------
2126 /* The only header we use is the last-modified header. */
2127 string pkgAcqFile::Custom600Headers()
2128 {
2129    if (IsIndexFile)
2130       return "\nIndex-File: true";
2131    return "";
2132 }
2133                                                                         /*}}}*/