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 <apt-pkg/acquire-item.h>
  17 #include <apt-pkg/configuration.h>
  18 #include <apt-pkg/sourcelist.h>
  19 #include <apt-pkg/vendorlist.h>
  20 #include <apt-pkg/error.h>
  21 #include <apt-pkg/strutl.h>
  22 #include <apt-pkg/fileutl.h>
  23 #include <apt-pkg/md5.h>
  24 #include <apt-pkg/sha1.h>
  25 #include <apt-pkg/tagfile.h>
  26
  27 #include <apti18n.h>
  28
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <string>
  33 #include <sstream>
  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    UsedMirror =  LookupTag(Message,"UsedMirror");
  67    if (QueueCounter <= 1)
  68    {
  69       /* This indicates that the file is not available right now but might
  70          be sometime later. If we do a retry cycle then this should be
  71          retried [CDROMs] */
  72       if (Cnf->LocalOnly == true &&
  73           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
  74       {
  75          Status = StatIdle;
  76          Dequeue();
  77          return;
  78       }
  79
  80       Status = StatError;
  81       Dequeue();
  82    }
  83
  84    // report mirror failure back to LP if we actually use a mirror
  85    string FailReason = LookupTag(Message, "FailReason");
  86    if(FailReason.size() != 0)
  87       ReportMirrorFailure(FailReason);
  88    else
  89       ReportMirrorFailure(ErrorText);
  90 }
  91                                                                         /*}}}*/
  92 // Acquire::Item::Start - Item has begun to download                    /*{{{*/
  93 // ---------------------------------------------------------------------
  94 /* Stash status and the file size. Note that setting Complete means
  95    sub-phases of the acquire process such as decompresion are operating */
  96 void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size)
  97 {
  98    Status = StatFetching;
  99    if (FileSize == 0 && Complete == false)
 100       FileSize = Size;
 101 }
 102                                                                         /*}}}*/
 103 // Acquire::Item::Done - Item downloaded OK                             /*{{{*/
 104 // ---------------------------------------------------------------------
 105 /* */
 106 void pkgAcquire::Item::Done(string Message,unsigned long Size,string Hash,
 107                             pkgAcquire::MethodConfig *Cnf)
 108 {
 109    // We just downloaded something..
 110    string FileName = LookupTag(Message,"Filename");
 111    UsedMirror =  LookupTag(Message,"UsedMirror");
 112    if (Complete == false && !Local && FileName == DestFile)
 113    {
 114       if (Owner->Log != 0)
 115          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 116    }
 117
 118    if (FileSize == 0)
 119       FileSize= Size;
 120    Status = StatDone;
 121    ErrorText = string();
 122    Owner->Dequeue(this);
 123 }
 124                                                                         /*}}}*/
 125 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 126 // ---------------------------------------------------------------------
 127 /* This helper function is used by alot of item methods as thier final
 128    step */
 129 void pkgAcquire::Item::Rename(string From,string To)
 130 {
 131    if (rename(From.c_str(),To.c_str()) != 0)
 132    {
 133       char S[300];
 134       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 135               From.c_str(),To.c_str());
 136       Status = StatError;
 137       ErrorText = S;
 138    }
 139 }
 140                                                                         /*}}}*/
 141
 142 void pkgAcquire::Item::ReportMirrorFailure(string FailCode)
 143 {
 144    // we only act if a mirror was used at all
 145    if(UsedMirror.empty())
 146       return;
 147 #if 0
 148    std::cerr << "\nReportMirrorFailure: "
 149              << UsedMirror
 150              << " Uri: " << DescURI()
 151              << " FailCode: "
 152              << FailCode << std::endl;
 153 #endif
 154    const char *Args[40];
 155    unsigned int i = 0;
 156    string report = _config->Find("Methods::Mirror::ProblemReporting",
 157                                  "/usr/lib/apt/apt-report-mirror-failure");
 158    if(!FileExists(report))
 159       return;
 160    Args[i++] = report.c_str();
 161    Args[i++] = UsedMirror.c_str();
 162    Args[i++] = DescURI().c_str();
 163    Args[i++] = FailCode.c_str();
 164    Args[i++] = NULL;
 165    pid_t pid = ExecFork();
 166    if(pid < 0)
 167    {
 168       _error->Error("ReportMirrorFailure Fork failed");
 169       return;
 170    }
 171    else if(pid == 0)
 172    {
 173       execvp(Args[0], (char**)Args);
 174       std::cerr << "Could not exec " << Args[0] << std::endl;
 175       _exit(100);
 176    }
 177    if(!ExecWait(pid, "report-mirror-failure"))
 178    {
 179       _error->Warning("Couldn't report problem to '%s'",
 180                       _config->Find("Methods::Mirror::ProblemReporting").c_str());
 181    }
 182 }
 183
 184
 185
 186 // AcqDiffIndex::AcqDiffIndex - Constructor
 187 // ---------------------------------------------------------------------
 188 /* Get the DiffIndex file first and see if there are patches availabe
 189  * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
 190  * patches. If anything goes wrong in that process, it will fall back to
 191  * the original packages file
 192  */
 193 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
 194                                  string URI,string URIDesc,string ShortDesc,
 195                                  HashString ExpectedHash)
 196    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 197      Description(URIDesc)
 198 {
 199
 200    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 201
 202    Desc.Description = URIDesc + "/DiffIndex";
 203    Desc.Owner = this;
 204    Desc.ShortDesc = ShortDesc;
 205    Desc.URI = URI + ".diff/Index";
 206
 207    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 208    DestFile += URItoFileName(URI) + string(".DiffIndex");
 209
 210    if(Debug)
 211       std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
 212
 213    // look for the current package file
 214    CurrentPackagesFile = _config->FindDir("Dir::State::lists");
 215    CurrentPackagesFile += URItoFileName(RealURI);
 216
 217    // FIXME: this file:/ check is a hack to prevent fetching
 218    //        from local sources. this is really silly, and
 219    //        should be fixed cleanly as soon as possible
 220    if(!FileExists(CurrentPackagesFile) ||
 221       Desc.URI.substr(0,strlen("file:/")) == "file:/")
 222    {
 223       // we don't have a pkg file or we don't want to queue
 224       if(Debug)
 225          std::clog << "No index file, local or canceld by user" << std::endl;
 226       Failed("", NULL);
 227       return;
 228    }
 229
 230    if(Debug)
 231       std::clog << "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): "
 232                 << CurrentPackagesFile << std::endl;
 233
 234    QueueURI(Desc);
 235
 236 }
 237
 238 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 239 // ---------------------------------------------------------------------
 240 /* The only header we use is the last-modified header. */
 241 string pkgAcqDiffIndex::Custom600Headers()
 242 {
 243    string Final = _config->FindDir("Dir::State::lists");
 244    Final += URItoFileName(RealURI) + string(".IndexDiff");
 245
 246    if(Debug)
 247       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 248
 249    struct stat Buf;
 250    if (stat(Final.c_str(),&Buf) != 0)
 251       return "\nIndex-File: true";
 252
 253    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 254 }
 255
 256
 257 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)
 258 {
 259    if(Debug)
 260       std::clog << "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile
 261                 << std::endl;
 262
 263    pkgTagSection Tags;
 264    string ServerSha1;
 265    vector<DiffInfo> available_patches;
 266
 267    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
 268    pkgTagFile TF(&Fd);
 269    if (_error->PendingError() == true)
 270       return false;
 271
 272    if(TF.Step(Tags) == true)
 273    {
 274       string local_sha1;
 275       bool found = false;
 276       DiffInfo d;
 277       string size;
 278
 279       string tmp = Tags.FindS("SHA1-Current");
 280       std::stringstream ss(tmp);
 281       ss >> ServerSha1;
 282
 283       FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
 284       SHA1Summation SHA1;
 285       SHA1.AddFD(fd.Fd(), fd.Size());
 286       local_sha1 = string(SHA1.Result());
 287
 288       if(local_sha1 == ServerSha1)
 289       {
 290          // we have the same sha1 as the server
 291          if(Debug)
 292             std::clog << "Package file is up-to-date" << std::endl;
 293          // set found to true, this will queue a pkgAcqIndexDiffs with
 294          // a empty availabe_patches
 295          found = true;
 296       }
 297       else
 298       {
 299          if(Debug)
 300             std::clog << "SHA1-Current: " << ServerSha1 << std::endl;
 301
 302          // check the historie and see what patches we need
 303          string history = Tags.FindS("SHA1-History");
 304          std::stringstream hist(history);
 305          while(hist >> d.sha1 >> size >> d.file)
 306          {
 307             d.size = atoi(size.c_str());
 308             // read until the first match is found
 309             if(d.sha1 == local_sha1)
 310                found=true;
 311             // from that point on, we probably need all diffs
 312             if(found)
 313             {
 314                if(Debug)
 315                   std::clog << "Need to get diff: " << d.file << std::endl;
 316                available_patches.push_back(d);
 317             }
 318          }
 319       }
 320
 321       // we have something, queue the next diff
 322       if(found)
 323       {
 324          // queue the diffs
 325          string::size_type last_space = Description.rfind(" ");
 326          if(last_space != string::npos)
 327             Description.erase(last_space, Description.size()-last_space);
 328          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 329                               ExpectedHash, available_patches);
 330          Complete = false;
 331          Status = StatDone;
 332          Dequeue();
 333          return true;
 334       }
 335    }
 336
 337    // Nothing found, report and return false
 338    // Failing here is ok, if we return false later, the full
 339    // IndexFile is queued
 340    if(Debug)
 341       std::clog << "Can't find a patch in the index file" << std::endl;
 342    return false;
 343 }
 344
 345 void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 346 {
 347    if(Debug)
 348       std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << std::endl
 349                 << "Falling back to normal index file aquire" << std::endl;
 350
 351    new pkgAcqIndex(Owner, RealURI, Description, Desc.ShortDesc,
 352                    ExpectedHash);
 353
 354    Complete = false;
 355    Status = StatDone;
 356    Dequeue();
 357 }
 358
 359 void pkgAcqDiffIndex::Done(string Message,unsigned long Size,string Md5Hash,
 360                            pkgAcquire::MethodConfig *Cnf)
 361 {
 362    if(Debug)
 363       std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
 364
 365    Item::Done(Message,Size,Md5Hash,Cnf);
 366
 367    string FinalFile;
 368    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 369
 370    // sucess in downloading the index
 371    // rename the index
 372    FinalFile += string(".IndexDiff");
 373    if(Debug)
 374       std::clog << "Renaming: " << DestFile << " -> " << FinalFile
 375                 << std::endl;
 376    Rename(DestFile,FinalFile);
 377    chmod(FinalFile.c_str(),0644);
 378    DestFile = FinalFile;
 379
 380    if(!ParseDiffIndex(DestFile))
 381       return Failed("", NULL);
 382
 383    Complete = true;
 384    Status = StatDone;
 385    Dequeue();
 386    return;
 387 }
 388
 389
 390
 391 // AcqIndexDiffs::AcqIndexDiffs - Constructor
 392 // ---------------------------------------------------------------------
 393 /* The package diff is added to the queue. one object is constructed
 394  * for each diff and the index
 395  */
 396 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
 397                                    string URI,string URIDesc,string ShortDesc,
 398                                    HashString ExpectedMD5,
 399                                    vector<DiffInfo> diffs)
 400    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 401      available_patches(diffs)
 402 {
 403
 404    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 405    DestFile += URItoFileName(URI);
 406
 407    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 408
 409    Description = URIDesc;
 410    Desc.Owner = this;
 411    Desc.ShortDesc = ShortDesc;
 412
 413    if(available_patches.size() == 0)
 414    {
 415       // we are done (yeah!)
 416       Finish(true);
 417    }
 418    else
 419    {
 420       // get the next diff
 421       State = StateFetchDiff;
 422       QueueNextDiff();
 423    }
 424 }
 425
 426
 427 void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 428 {
 429    if(Debug)
 430       std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << std::endl
 431                 << "Falling back to normal index file aquire" << std::endl;
 432    new pkgAcqIndex(Owner, RealURI, Description,Desc.ShortDesc,
 433                    ExpectedHash);
 434    Finish();
 435 }
 436
 437
 438 // helper that cleans the item out of the fetcher queue
 439 void pkgAcqIndexDiffs::Finish(bool allDone)
 440 {
 441    // we restore the original name, this is required, otherwise
 442    // the file will be cleaned
 443    if(allDone)
 444    {
 445       DestFile = _config->FindDir("Dir::State::lists");
 446       DestFile += URItoFileName(RealURI);
 447
 448       if(!ExpectedHash.empty() && !ExpectedHash.VerifyFile(DestFile))
 449       {
 450          Status = StatAuthError;
 451          ErrorText = _("MD5Sum mismatch");
 452          Rename(DestFile,DestFile + ".FAILED");
 453          Dequeue();
 454          return;
 455       }
 456
 457       // this is for the "real" finish
 458       Complete = true;
 459       Status = StatDone;
 460       Dequeue();
 461       if(Debug)
 462          std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
 463       return;
 464    }
 465
 466    if(Debug)
 467       std::clog << "Finishing: " << Desc.URI << std::endl;
 468    Complete = false;
 469    Status = StatDone;
 470    Dequeue();
 471    return;
 472 }
 473
 474
 475
 476 bool pkgAcqIndexDiffs::QueueNextDiff()
 477 {
 478
 479    // calc sha1 of the just patched file
 480    string FinalFile = _config->FindDir("Dir::State::lists");
 481    FinalFile += URItoFileName(RealURI);
 482
 483    FileFd fd(FinalFile, FileFd::ReadOnly);
 484    SHA1Summation SHA1;
 485    SHA1.AddFD(fd.Fd(), fd.Size());
 486    string local_sha1 = string(SHA1.Result());
 487    if(Debug)
 488       std::clog << "QueueNextDiff: "
 489                 << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 490
 491    // remove all patches until the next matching patch is found
 492    // this requires the Index file to be ordered
 493    for(vector<DiffInfo>::iterator I=available_patches.begin();
 494        available_patches.size() > 0 &&
 495           I != available_patches.end() &&
 496           (*I).sha1 != local_sha1;
 497        I++)
 498    {
 499       available_patches.erase(I);
 500    }
 501
 502    // error checking and falling back if no patch was found
 503    if(available_patches.size() == 0)
 504    {
 505       Failed("", NULL);
 506       return false;
 507    }
 508
 509    // queue the right diff
 510    Desc.URI = string(RealURI) + ".diff/" + available_patches[0].file + ".gz";
 511    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
 512    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 513    DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file);
 514
 515    if(Debug)
 516       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
 517
 518    QueueURI(Desc);
 519
 520    return true;
 521 }
 522
 523
 524
 525 void pkgAcqIndexDiffs::Done(string Message,unsigned long Size,string Md5Hash,
 526                             pkgAcquire::MethodConfig *Cnf)
 527 {
 528    if(Debug)
 529       std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
 530
 531    Item::Done(Message,Size,Md5Hash,Cnf);
 532
 533    string FinalFile;
 534    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 535
 536    // sucess in downloading a diff, enter ApplyDiff state
 537    if(State == StateFetchDiff)
 538    {
 539
 540       if(Debug)
 541          std::clog << "Sending to gzip method: " << FinalFile << std::endl;
 542
 543       string FileName = LookupTag(Message,"Filename");
 544       State = StateUnzipDiff;
 545       Local = true;
 546       Desc.URI = "gzip:" + FileName;
 547       DestFile += ".decomp";
 548       QueueURI(Desc);
 549       Mode = "gzip";
 550       return;
 551    }
 552
 553    // sucess in downloading a diff, enter ApplyDiff state
 554    if(State == StateUnzipDiff)
 555    {
 556
 557       // rred excepts the patch as $FinalFile.ed
 558       Rename(DestFile,FinalFile+".ed");
 559
 560       if(Debug)
 561          std::clog << "Sending to rred method: " << FinalFile << std::endl;
 562
 563       State = StateApplyDiff;
 564       Local = true;
 565       Desc.URI = "rred:" + FinalFile;
 566       QueueURI(Desc);
 567       Mode = "rred";
 568       return;
 569    }
 570
 571
 572    // success in download/apply a diff, queue next (if needed)
 573    if(State == StateApplyDiff)
 574    {
 575       // remove the just applied patch
 576       available_patches.erase(available_patches.begin());
 577
 578       // move into place
 579       if(Debug)
 580       {
 581          std::clog << "Moving patched file in place: " << std::endl
 582                    << DestFile << " -> " << FinalFile << std::endl;
 583       }
 584       Rename(DestFile,FinalFile);
 585       chmod(FinalFile.c_str(),0644);
 586
 587       // see if there is more to download
 588       if(available_patches.size() > 0) {
 589          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 590                               ExpectedHash, available_patches);
 591          return Finish();
 592       } else
 593          return Finish(true);
 594    }
 595 }
 596
 597
 598 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 599 // ---------------------------------------------------------------------
 600 /* The package file is added to the queue and a second class is
 601    instantiated to fetch the revision file */
 602 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 603                          string URI,string URIDesc,string ShortDesc,
 604                          HashString ExpectedHash, string comprExt)
 605    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash)
 606 {
 607    Decompression = false;
 608    Erase = false;
 609
 610    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 611    DestFile += URItoFileName(URI);
 612
 613    if(comprExt.empty())
 614    {
 615       // autoselect the compression method
 616       if(FileExists("/bin/bzip2"))
 617          CompressionExtension = ".bz2";
 618       else
 619          CompressionExtension = ".gz";
 620    } else {
 621       CompressionExtension = comprExt;
 622    }
 623    Desc.URI = URI + CompressionExtension;
 624
 625    Desc.Description = URIDesc;
 626    Desc.Owner = this;
 627    Desc.ShortDesc = ShortDesc;
 628
 629    QueueURI(Desc);
 630 }
 631                                                                         /*}}}*/
 632 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 633 // ---------------------------------------------------------------------
 634 /* The only header we use is the last-modified header. */
 635 string pkgAcqIndex::Custom600Headers()
 636 {
 637    string Final = _config->FindDir("Dir::State::lists");
 638    Final += URItoFileName(RealURI);
 639
 640    struct stat Buf;
 641    if (stat(Final.c_str(),&Buf) != 0)
 642       return "\nIndex-File: true";
 643    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 644 }
 645                                                                         /*}}}*/
 646
 647 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 648 {
 649    // no .bz2 found, retry with .gz
 650    if(Desc.URI.substr(Desc.URI.size()-3) == "bz2") {
 651       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz";
 652
 653       // retry with a gzip one
 654       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 655                       ExpectedHash, string(".gz"));
 656       Status = StatDone;
 657       Complete = false;
 658       Dequeue();
 659       return;
 660    }
 661
 662    // on decompression failure, remove bad versions in partial/
 663    if(Decompression && Erase) {
 664       string s = _config->FindDir("Dir::State::lists") + "partial/";
 665       s += URItoFileName(RealURI);
 666       unlink(s.c_str());
 667    }
 668
 669    Item::Failed(Message,Cnf);
 670 }
 671
 672
 673 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 674 // ---------------------------------------------------------------------
 675 /* This goes through a number of states.. On the initial fetch the
 676    method could possibly return an alternate filename which points
 677    to the uncompressed version of the file. If this is so the file
 678    is copied into the partial directory. In all other cases the file
 679    is decompressed with a gzip uri. */
 680 void pkgAcqIndex::Done(string Message,unsigned long Size,string Hash,
 681                        pkgAcquire::MethodConfig *Cfg)
 682 {
 683    Item::Done(Message,Size,Hash,Cfg);
 684
 685    if (Decompression == true)
 686    {
 687       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 688       {
 689          std::cerr << std::endl << RealURI << ": Computed Hash: " << Hash;
 690          std::cerr << "  Expected Hash: " << ExpectedHash.toStr() << std::endl;
 691       }
 692
 693       if (!ExpectedHash.empty() && ExpectedHash.toStr() != Hash)
 694       {
 695          Status = StatAuthError;
 696          ErrorText = _("Hash Sum mismatch");
 697          Rename(DestFile,DestFile + ".FAILED");
 698          ReportMirrorFailure("HashChecksumFailure");
 699          return;
 700       }
 701       // Done, move it into position
 702       string FinalFile = _config->FindDir("Dir::State::lists");
 703       FinalFile += URItoFileName(RealURI);
 704       Rename(DestFile,FinalFile);
 705       chmod(FinalFile.c_str(),0644);
 706
 707       /* We restore the original name to DestFile so that the clean operation
 708          will work OK */
 709       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 710       DestFile += URItoFileName(RealURI);
 711
 712       // Remove the compressed version.
 713       if (Erase == true)
 714          unlink(DestFile.c_str());
 715       return;
 716    }
 717
 718    Erase = false;
 719    Complete = true;
 720
 721    // Handle the unzipd case
 722    string FileName = LookupTag(Message,"Alt-Filename");
 723    if (FileName.empty() == false)
 724    {
 725       // The files timestamp matches
 726       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 727       {
 728          unlink(FileName.c_str());
 729          return;
 730       }
 731       Decompression = true;
 732       Local = true;
 733       DestFile += ".decomp";
 734       Desc.URI = "copy:" + FileName;
 735       QueueURI(Desc);
 736       Mode = "copy";
 737       return;
 738    }
 739
 740    FileName = LookupTag(Message,"Filename");
 741    if (FileName.empty() == true)
 742    {
 743       Status = StatError;
 744       ErrorText = "Method gave a blank filename";
 745    }
 746
 747    // The files timestamp matches
 748    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 749    {
 750       unlink(FileName.c_str());
 751       return;
 752    }
 753
 754    if (FileName == DestFile)
 755       Erase = true;
 756    else
 757       Local = true;
 758
 759    string compExt = Desc.URI.substr(Desc.URI.size()-3);
 760    char *decompProg;
 761    if(compExt == "bz2")
 762       decompProg = "bzip2";
 763    else if(compExt == ".gz")
 764       decompProg = "gzip";
 765    else {
 766       _error->Error("Unsupported extension: %s", compExt.c_str());
 767       return;
 768    }
 769
 770    Decompression = true;
 771    DestFile += ".decomp";
 772    Desc.URI = string(decompProg) + ":" + FileName;
 773    QueueURI(Desc);
 774    Mode = decompProg;
 775 }
 776
 777 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                        /*{{{*/
 778 // ---------------------------------------------------------------------
 779 /* The Translation file is added to the queue */
 780 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 781                             string URI,string URIDesc,string ShortDesc)
 782   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashString(), "")
 783 {
 784 }
 785
 786                                                                         /*}}}*/
 787 // AcqIndexTrans::Failed - Silence failure messages for missing files   /*{{{*/
 788 // ---------------------------------------------------------------------
 789 /* */
 790 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 791 {
 792    if (Cnf->LocalOnly == true ||
 793        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 794    {
 795       // Ignore this
 796       Status = StatDone;
 797       Complete = false;
 798       Dequeue();
 799       return;
 800    }
 801
 802    Item::Failed(Message,Cnf);
 803 }
 804                                                                         /*}}}*/
 805
 806 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
 807                              string URI,string URIDesc,string ShortDesc,
 808                              string MetaIndexURI, string MetaIndexURIDesc,
 809                              string MetaIndexShortDesc,
 810                              const vector<IndexTarget*>* IndexTargets,
 811                              indexRecords* MetaIndexParser) :
 812    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
 813    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
 814    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
 815 {
 816    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 817    DestFile += URItoFileName(URI);
 818
 819    // remove any partial downloaded sig-file in partial/.
 820    // it may confuse proxies and is too small to warrant a
 821    // partial download anyway
 822    unlink(DestFile.c_str());
 823
 824    // Create the item
 825    Desc.Description = URIDesc;
 826    Desc.Owner = this;
 827    Desc.ShortDesc = ShortDesc;
 828    Desc.URI = URI;
 829
 830
 831    string Final = _config->FindDir("Dir::State::lists");
 832    Final += URItoFileName(RealURI);
 833    struct stat Buf;
 834    if (stat(Final.c_str(),&Buf) == 0)
 835    {
 836       // File was already in place.  It needs to be re-verified
 837       // because Release might have changed, so Move it into partial
 838       Rename(Final,DestFile);
 839    }
 840
 841    QueueURI(Desc);
 842 }
 843                                                                         /*}}}*/
 844 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
 845 // ---------------------------------------------------------------------
 846 /* The only header we use is the last-modified header. */
 847 string pkgAcqMetaSig::Custom600Headers()
 848 {
 849    struct stat Buf;
 850    if (stat(DestFile.c_str(),&Buf) != 0)
 851       return "\nIndex-File: true";
 852
 853    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 854 }
 855
 856 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
 857                          pkgAcquire::MethodConfig *Cfg)
 858 {
 859    Item::Done(Message,Size,MD5,Cfg);
 860
 861    string FileName = LookupTag(Message,"Filename");
 862    if (FileName.empty() == true)
 863    {
 864       Status = StatError;
 865       ErrorText = "Method gave a blank filename";
 866       return;
 867    }
 868
 869    if (FileName != DestFile)
 870    {
 871       // We have to copy it into place
 872       Local = true;
 873       Desc.URI = "copy:" + FileName;
 874       QueueURI(Desc);
 875       return;
 876    }
 877
 878    Complete = true;
 879
 880    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
 881    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 882                        DestFile, IndexTargets, MetaIndexParser);
 883
 884 }
 885                                                                         /*}}}*/
 886 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 887 {
 888    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 889
 890    // if we get a network error we fail gracefully
 891    if(Status == StatTransientNetworkError)
 892    {
 893       Item::Failed(Message,Cnf);
 894       // move the sigfile back on transient network failures
 895       if(FileExists(DestFile))
 896          Rename(DestFile,Final);
 897
 898       // set the status back to , Item::Failed likes to reset it
 899       Status = pkgAcquire::Item::StatTransientNetworkError;
 900       return;
 901    }
 902
 903    // Delete any existing sigfile when the acquire failed
 904    unlink(Final.c_str());
 905
 906    // queue a pkgAcqMetaIndex with no sigfile
 907    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 908                        "", IndexTargets, MetaIndexParser);
 909
 910    if (Cnf->LocalOnly == true ||
 911        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 912    {
 913       // Ignore this
 914       Status = StatDone;
 915       Complete = false;
 916       Dequeue();
 917       return;
 918    }
 919
 920    Item::Failed(Message,Cnf);
 921 }
 922
 923 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,
 924                                  string URI,string URIDesc,string ShortDesc,
 925                                  string SigFile,
 926                                  const vector<struct IndexTarget*>* IndexTargets,
 927                                  indexRecords* MetaIndexParser) :
 928    Item(Owner), RealURI(URI), SigFile(SigFile), IndexTargets(IndexTargets),
 929    MetaIndexParser(MetaIndexParser), AuthPass(false), IMSHit(false)
 930 {
 931    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 932    DestFile += URItoFileName(URI);
 933
 934    // Create the item
 935    Desc.Description = URIDesc;
 936    Desc.Owner = this;
 937    Desc.ShortDesc = ShortDesc;
 938    Desc.URI = URI;
 939
 940    QueueURI(Desc);
 941 }
 942
 943                                                                         /*}}}*/
 944 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
 945 // ---------------------------------------------------------------------
 946 /* The only header we use is the last-modified header. */
 947 string pkgAcqMetaIndex::Custom600Headers()
 948 {
 949    string Final = _config->FindDir("Dir::State::lists");
 950    Final += URItoFileName(RealURI);
 951
 952    struct stat Buf;
 953    if (stat(Final.c_str(),&Buf) != 0)
 954       return "\nIndex-File: true";
 955
 956    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 957 }
 958
 959 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string Hash,
 960                            pkgAcquire::MethodConfig *Cfg)
 961 {
 962    Item::Done(Message,Size,Hash,Cfg);
 963
 964    // MetaIndexes are done in two passes: one to download the
 965    // metaindex with an appropriate method, and a second to verify it
 966    // with the gpgv method
 967
 968    if (AuthPass == true)
 969    {
 970       AuthDone(Message);
 971    }
 972    else
 973    {
 974       RetrievalDone(Message);
 975       if (!Complete)
 976          // Still more retrieving to do
 977          return;
 978
 979       if (SigFile == "")
 980       {
 981          // There was no signature file, so we are finished.  Download
 982          // the indexes without verification.
 983          QueueIndexes(false);
 984       }
 985       else
 986       {
 987          // There was a signature file, so pass it to gpgv for
 988          // verification
 989
 990          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 991             std::cerr << "Metaindex acquired, queueing gpg verification ("
 992                       << SigFile << "," << DestFile << ")\n";
 993          AuthPass = true;
 994          Desc.URI = "gpgv:" + SigFile;
 995          QueueURI(Desc);
 996          Mode = "gpgv";
 997       }
 998    }
 999 }
1000
1001 void pkgAcqMetaIndex::RetrievalDone(string Message)
1002 {
1003    // We have just finished downloading a Release file (it is not
1004    // verified yet)
1005
1006    string FileName = LookupTag(Message,"Filename");
1007    if (FileName.empty() == true)
1008    {
1009       Status = StatError;
1010       ErrorText = "Method gave a blank filename";
1011       return;
1012    }
1013
1014    if (FileName != DestFile)
1015    {
1016       Local = true;
1017       Desc.URI = "copy:" + FileName;
1018       QueueURI(Desc);
1019       return;
1020    }
1021
1022    // see if the download was a IMSHit
1023    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
1024    Complete = true;
1025
1026    string FinalFile = _config->FindDir("Dir::State::lists");
1027    FinalFile += URItoFileName(RealURI);
1028
1029    // If we get a IMS hit we can remove the empty file in partial
1030    // othersie we move the file in place
1031    if (IMSHit)
1032       unlink(DestFile.c_str());
1033    else
1034       Rename(DestFile,FinalFile);
1035
1036    chmod(FinalFile.c_str(),0644);
1037    DestFile = FinalFile;
1038 }
1039
1040 void pkgAcqMetaIndex::AuthDone(string Message)
1041 {
1042    // At this point, the gpgv method has succeeded, so there is a
1043    // valid signature from a key in the trusted keyring.  We
1044    // perform additional verification of its contents, and use them
1045    // to verify the indexes we are about to download
1046
1047    if (!MetaIndexParser->Load(DestFile))
1048    {
1049       Status = StatAuthError;
1050       ErrorText = MetaIndexParser->ErrorText;
1051       return;
1052    }
1053
1054    if (!VerifyVendor(Message))
1055    {
1056       return;
1057    }
1058
1059    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1060       std::cerr << "Signature verification succeeded: "
1061                 << DestFile << std::endl;
1062
1063    // Download further indexes with verification
1064    QueueIndexes(true);
1065
1066    // Done, move signature file into position
1067
1068    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
1069       URItoFileName(RealURI) + ".gpg";
1070    Rename(SigFile,VerifiedSigFile);
1071    chmod(VerifiedSigFile.c_str(),0644);
1072 }
1073
1074 void pkgAcqMetaIndex::QueueIndexes(bool verify)
1075 {
1076    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
1077         Target != IndexTargets->end();
1078         Target++)
1079    {
1080       HashString ExpectedIndexHash;
1081       if (verify)
1082       {
1083          const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
1084          if (!Record)
1085          {
1086             Status = StatAuthError;
1087             ErrorText = "Unable to find expected entry  "
1088                + (*Target)->MetaKey + " in Meta-index file (malformed Release file?)";
1089             return;
1090          }
1091          ExpectedIndexHash = Record->Hash;
1092          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1093          {
1094             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
1095             std::cerr << "Expected Hash: " << ExpectedIndexHash.toStr() << std::endl;
1096          }
1097          if (ExpectedIndexHash.empty())
1098          {
1099             Status = StatAuthError;
1100             ErrorText = "Unable to find hash sum for "
1101                + (*Target)->MetaKey + " in Meta-index file";
1102             return;
1103          }
1104       }
1105
1106       // Queue Packages file (either diff or full packages files, depending
1107       // on the users option)
1108       if(_config->FindB("Acquire::PDiffs",false) == true)
1109          new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description,
1110                              (*Target)->ShortDesc, ExpectedIndexHash);
1111       else
1112          new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
1113                             (*Target)->ShortDesc, ExpectedIndexHash);
1114    }
1115 }
1116
1117 bool pkgAcqMetaIndex::VerifyVendor(string Message)
1118 {
1119 //    // Maybe this should be made available from above so we don't have
1120 //    // to read and parse it every time?
1121 //    pkgVendorList List;
1122 //    List.ReadMainList();
1123
1124 //    const Vendor* Vndr = NULL;
1125 //    for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
1126 //    {
1127 //       string::size_type pos = (*I).find("VALIDSIG ");
1128 //       if (_config->FindB("Debug::Vendor", false))
1129 //          std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
1130 //                    << std::endl;
1131 //       if (pos != std::string::npos)
1132 //       {
1133 //          string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
1134 //          if (_config->FindB("Debug::Vendor", false))
1135 //             std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
1136 //                std::endl;
1137 //          Vndr = List.FindVendor(Fingerprint) != "";
1138 //          if (Vndr != NULL);
1139 //          break;
1140 //       }
1141 //    }
1142    string::size_type pos;
1143
1144    // check for missing sigs (that where not fatal because otherwise we had
1145    // bombed earlier)
1146    string missingkeys;
1147    string msg = _("There is no public key available for the "
1148                   "following key IDs:\n");
1149    pos = Message.find("NO_PUBKEY ");
1150    if (pos != std::string::npos)
1151    {
1152       string::size_type start = pos+strlen("NO_PUBKEY ");
1153       string Fingerprint = Message.substr(start, Message.find("\n")-start);
1154       missingkeys += (Fingerprint);
1155    }
1156    if(!missingkeys.empty())
1157       _error->Warning("%s", string(msg+missingkeys).c_str());
1158
1159    string Transformed = MetaIndexParser->GetExpectedDist();
1160
1161    if (Transformed == "../project/experimental")
1162    {
1163       Transformed = "experimental";
1164    }
1165
1166    pos = Transformed.rfind('/');
1167    if (pos != string::npos)
1168    {
1169       Transformed = Transformed.substr(0, pos);
1170    }
1171
1172    if (Transformed == ".")
1173    {
1174       Transformed = "";
1175    }
1176
1177    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1178    {
1179       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
1180       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
1181       std::cerr << "Transformed Dist: " << Transformed << std::endl;
1182    }
1183
1184    if (MetaIndexParser->CheckDist(Transformed) == false)
1185    {
1186       // This might become fatal one day
1187 //       Status = StatAuthError;
1188 //       ErrorText = "Conflicting distribution; expected "
1189 //          + MetaIndexParser->GetExpectedDist() + " but got "
1190 //          + MetaIndexParser->GetDist();
1191 //       return false;
1192       if (!Transformed.empty())
1193       {
1194          _error->Warning("Conflicting distribution: %s (expected %s but got %s)",
1195                          Desc.Description.c_str(),
1196                          Transformed.c_str(),
1197                          MetaIndexParser->GetDist().c_str());
1198       }
1199    }
1200
1201    return true;
1202 }
1203                                                                 /*}}}*/
1204 // pkgAcqMetaIndex::Failed - no Release file present or no signature
1205 //      file present                                            /*{{{*/
1206 // ---------------------------------------------------------------------
1207 /* */
1208 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1209 {
1210    if (AuthPass == true)
1211    {
1212       // if we fail the authentication but got the file via a IMS-Hit
1213       // this means that the file wasn't downloaded and that it might be
1214       // just stale (server problem, proxy etc). we delete what we have
1215       // queue it again without i-m-s
1216       // alternatively we could just unlink the file and let the user try again
1217       if (IMSHit)
1218       {
1219          Complete = false;
1220          Local = false;
1221          AuthPass = false;
1222          unlink(DestFile.c_str());
1223
1224          DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1225          DestFile += URItoFileName(RealURI);
1226          Desc.URI = RealURI;
1227          QueueURI(Desc);
1228          return;
1229       }
1230
1231       // gpgv method failed
1232       ReportMirrorFailure("GPGFailure");
1233       _error->Warning("GPG error: %s: %s",
1234                       Desc.Description.c_str(),
1235                       LookupTag(Message,"Message").c_str());
1236
1237    }
1238
1239    // No Release file was present, or verification failed, so fall
1240    // back to queueing Packages files without verification
1241    QueueIndexes(false);
1242 }
1243
1244                                                                         /*}}}*/
1245
1246 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
1247 // ---------------------------------------------------------------------
1248 /* This just sets up the initial fetch environment and queues the first
1249    possibilitiy */
1250 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
1251                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
1252                              string &StoreFilename) :
1253                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
1254                StoreFilename(StoreFilename), Vf(Version.FileList()),
1255                Trusted(false)
1256 {
1257    Retries = _config->FindI("Acquire::Retries",0);
1258
1259    if (Version.Arch() == 0)
1260    {
1261       _error->Error(_("I wasn't able to locate a file for the %s package. "
1262                       "This might mean you need to manually fix this package. "
1263                       "(due to missing arch)"),
1264                     Version.ParentPkg().Name());
1265       return;
1266    }
1267
1268    /* We need to find a filename to determine the extension. We make the
1269       assumption here that all the available sources for this version share
1270       the same extension.. */
1271    // Skip not source sources, they do not have file fields.
1272    for (; Vf.end() == false; Vf++)
1273    {
1274       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1275          continue;
1276       break;
1277    }
1278
1279    // Does not really matter here.. we are going to fail out below
1280    if (Vf.end() != true)
1281    {
1282       // If this fails to get a file name we will bomb out below.
1283       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1284       if (_error->PendingError() == true)
1285          return;
1286
1287       // Generate the final file name as: package_version_arch.foo
1288       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
1289                       QuoteString(Version.VerStr(),"_:") + '_' +
1290                       QuoteString(Version.Arch(),"_:.") +
1291                       "." + flExtension(Parse.FileName());
1292    }
1293
1294    // check if we have one trusted source for the package. if so, switch
1295    // to "TrustedOnly" mode
1296    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++)
1297    {
1298       pkgIndexFile *Index;
1299       if (Sources->FindIndex(i.File(),Index) == false)
1300          continue;
1301       if (_config->FindB("Debug::pkgAcquire::Auth", false))
1302       {
1303          std::cerr << "Checking index: " << Index->Describe()
1304                    << "(Trusted=" << Index->IsTrusted() << ")\n";
1305       }
1306       if (Index->IsTrusted()) {
1307          Trusted = true;
1308          break;
1309       }
1310    }
1311
1312    // "allow-unauthenticated" restores apts old fetching behaviour
1313    // that means that e.g. unauthenticated file:// uris are higher
1314    // priority than authenticated http:// uris
1315    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
1316       Trusted = false;
1317
1318    // Select a source
1319    if (QueueNext() == false && _error->PendingError() == false)
1320       _error->Error(_("I wasn't able to locate file for the %s package. "
1321                     "This might mean you need to manually fix this package."),
1322                     Version.ParentPkg().Name());
1323 }
1324                                                                         /*}}}*/
1325 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
1326 // ---------------------------------------------------------------------
1327 /* This queues the next available file version for download. It checks if
1328    the archive is already available in the cache and stashs the MD5 for
1329    checking later. */
1330 bool pkgAcqArchive::QueueNext()
1331 {
1332    for (; Vf.end() == false; Vf++)
1333    {
1334       // Ignore not source sources
1335       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1336          continue;
1337
1338       // Try to cross match against the source list
1339       pkgIndexFile *Index;
1340       if (Sources->FindIndex(Vf.File(),Index) == false)
1341             continue;
1342
1343       // only try to get a trusted package from another source if that source
1344       // is also trusted
1345       if(Trusted && !Index->IsTrusted())
1346          continue;
1347
1348       // Grab the text package record
1349       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1350       if (_error->PendingError() == true)
1351          return false;
1352
1353       string PkgFile = Parse.FileName();
1354       if(Parse.SHA256Hash() != "")
1355          ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
1356       else if (Parse.SHA1Hash() != "")
1357          ExpectedHash = HashString("SHA1", Parse.SHA1Hash());
1358       else
1359          ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1360       if (PkgFile.empty() == true)
1361          return _error->Error(_("The package index files are corrupted. No Filename: "
1362                               "field for package %s."),
1363                               Version.ParentPkg().Name());
1364
1365       Desc.URI = Index->ArchiveURI(PkgFile);
1366       Desc.Description = Index->ArchiveInfo(Version);
1367       Desc.Owner = this;
1368       Desc.ShortDesc = Version.ParentPkg().Name();
1369
1370       // See if we already have the file. (Legacy filenames)
1371       FileSize = Version->Size;
1372       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
1373       struct stat Buf;
1374       if (stat(FinalFile.c_str(),&Buf) == 0)
1375       {
1376          // Make sure the size matches
1377          if ((unsigned)Buf.st_size == Version->Size)
1378          {
1379             Complete = true;
1380             Local = true;
1381             Status = StatDone;
1382             StoreFilename = DestFile = FinalFile;
1383             return true;
1384          }
1385
1386          /* Hmm, we have a file and its size does not match, this means it is
1387             an old style mismatched arch */
1388          unlink(FinalFile.c_str());
1389       }
1390
1391       // Check it again using the new style output filenames
1392       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
1393       if (stat(FinalFile.c_str(),&Buf) == 0)
1394       {
1395          // Make sure the size matches
1396          if ((unsigned)Buf.st_size == Version->Size)
1397          {
1398             Complete = true;
1399             Local = true;
1400             Status = StatDone;
1401             StoreFilename = DestFile = FinalFile;
1402             return true;
1403          }
1404
1405          /* Hmm, we have a file and its size does not match, this shouldnt
1406             happen.. */
1407          unlink(FinalFile.c_str());
1408       }
1409
1410       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
1411
1412       // Check the destination file
1413       if (stat(DestFile.c_str(),&Buf) == 0)
1414       {
1415          // Hmm, the partial file is too big, erase it
1416          if ((unsigned)Buf.st_size > Version->Size)
1417             unlink(DestFile.c_str());
1418          else
1419             PartialSize = Buf.st_size;
1420       }
1421
1422       // Create the item
1423       Local = false;
1424       Desc.URI = Index->ArchiveURI(PkgFile);
1425       Desc.Description = Index->ArchiveInfo(Version);
1426       Desc.Owner = this;
1427       Desc.ShortDesc = Version.ParentPkg().Name();
1428       QueueURI(Desc);
1429
1430       Vf++;
1431       return true;
1432    }
1433    return false;
1434 }
1435                                                                         /*}}}*/
1436 // AcqArchive::Done - Finished fetching                                 /*{{{*/
1437 // ---------------------------------------------------------------------
1438 /* */
1439 void pkgAcqArchive::Done(string Message,unsigned long Size,string CalcHash,
1440                          pkgAcquire::MethodConfig *Cfg)
1441 {
1442    Item::Done(Message,Size,CalcHash,Cfg);
1443
1444    // Check the size
1445    if (Size != Version->Size)
1446    {
1447       Status = StatError;
1448       ErrorText = _("Size mismatch");
1449       return;
1450    }
1451
1452    // Check the hash
1453    if(ExpectedHash.toStr() != CalcHash)
1454    {
1455       Status = StatError;
1456       ErrorText = _("Hash Sum mismatch");
1457       if(FileExists(DestFile))
1458          Rename(DestFile,DestFile + ".FAILED");
1459       return;
1460    }
1461
1462    // Grab the output filename
1463    string FileName = LookupTag(Message,"Filename");
1464    if (FileName.empty() == true)
1465    {
1466       Status = StatError;
1467       ErrorText = "Method gave a blank filename";
1468       return;
1469    }
1470
1471    Complete = true;
1472
1473    // Reference filename
1474    if (FileName != DestFile)
1475    {
1476       StoreFilename = DestFile = FileName;
1477       Local = true;
1478       return;
1479    }
1480
1481    // Done, move it into position
1482    string FinalFile = _config->FindDir("Dir::Cache::Archives");
1483    FinalFile += flNotDir(StoreFilename);
1484    Rename(DestFile,FinalFile);
1485
1486    StoreFilename = DestFile = FinalFile;
1487    Complete = true;
1488 }
1489                                                                         /*}}}*/
1490 // AcqArchive::Failed - Failure handler                                 /*{{{*/
1491 // ---------------------------------------------------------------------
1492 /* Here we try other sources */
1493 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1494 {
1495    ErrorText = LookupTag(Message,"Message");
1496
1497    /* We don't really want to retry on failed media swaps, this prevents
1498       that. An interesting observation is that permanent failures are not
1499       recorded. */
1500    if (Cnf->Removable == true &&
1501        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1502    {
1503       // Vf = Version.FileList();
1504       while (Vf.end() == false) Vf++;
1505       StoreFilename = string();
1506       Item::Failed(Message,Cnf);
1507       return;
1508    }
1509
1510    if (QueueNext() == false)
1511    {
1512       // This is the retry counter
1513       if (Retries != 0 &&
1514           Cnf->LocalOnly == false &&
1515           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1516       {
1517          Retries--;
1518          Vf = Version.FileList();
1519          if (QueueNext() == true)
1520             return;
1521       }
1522
1523       StoreFilename = string();
1524       Item::Failed(Message,Cnf);
1525    }
1526 }
1527                                                                         /*}}}*/
1528 // AcqArchive::IsTrusted - Determine whether this archive comes from a
1529 // trusted source                                                       /*{{{*/
1530 // ---------------------------------------------------------------------
1531 bool pkgAcqArchive::IsTrusted()
1532 {
1533    return Trusted;
1534 }
1535
1536 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1537 // ---------------------------------------------------------------------
1538 /* */
1539 void pkgAcqArchive::Finished()
1540 {
1541    if (Status == pkgAcquire::Item::StatDone &&
1542        Complete == true)
1543       return;
1544    StoreFilename = string();
1545 }
1546                                                                         /*}}}*/
1547
1548 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1549 // ---------------------------------------------------------------------
1550 /* The file is added to the queue */
1551 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string Hash,
1552                        unsigned long Size,string Dsc,string ShortDesc,
1553                        const string &DestDir, const string &DestFilename) :
1554                        Item(Owner), ExpectedHash(Hash)
1555 {
1556    Retries = _config->FindI("Acquire::Retries",0);
1557
1558    if(!DestFilename.empty())
1559       DestFile = DestFilename;
1560    else if(!DestDir.empty())
1561       DestFile = DestDir + "/" + flNotDir(URI);
1562    else
1563       DestFile = flNotDir(URI);
1564
1565    // Create the item
1566    Desc.URI = URI;
1567    Desc.Description = Dsc;
1568    Desc.Owner = this;
1569
1570    // Set the short description to the archive component
1571    Desc.ShortDesc = ShortDesc;
1572
1573    // Get the transfer sizes
1574    FileSize = Size;
1575    struct stat Buf;
1576    if (stat(DestFile.c_str(),&Buf) == 0)
1577    {
1578       // Hmm, the partial file is too big, erase it
1579       if ((unsigned)Buf.st_size > Size)
1580          unlink(DestFile.c_str());
1581       else
1582          PartialSize = Buf.st_size;
1583    }
1584
1585    QueueURI(Desc);
1586 }
1587                                                                         /*}}}*/
1588 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1589 // ---------------------------------------------------------------------
1590 /* */
1591 void pkgAcqFile::Done(string Message,unsigned long Size,string CalcHash,
1592                       pkgAcquire::MethodConfig *Cnf)
1593 {
1594    Item::Done(Message,Size,CalcHash,Cnf);
1595
1596    // Check the hash
1597    if(!ExpectedHash.empty() && ExpectedHash.toStr() != CalcHash)
1598    {
1599       Status = StatError;
1600       ErrorText = "Hash Sum mismatch";
1601       Rename(DestFile,DestFile + ".FAILED");
1602       return;
1603    }
1604
1605    string FileName = LookupTag(Message,"Filename");
1606    if (FileName.empty() == true)
1607    {
1608       Status = StatError;
1609       ErrorText = "Method gave a blank filename";
1610       return;
1611    }
1612
1613    Complete = true;
1614
1615    // The files timestamp matches
1616    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1617       return;
1618
1619    // We have to copy it into place
1620    if (FileName != DestFile)
1621    {
1622       Local = true;
1623       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1624           Cnf->Removable == true)
1625       {
1626          Desc.URI = "copy:" + FileName;
1627          QueueURI(Desc);
1628          return;
1629       }
1630
1631       // Erase the file if it is a symlink so we can overwrite it
1632       struct stat St;
1633       if (lstat(DestFile.c_str(),&St) == 0)
1634       {
1635          if (S_ISLNK(St.st_mode) != 0)
1636             unlink(DestFile.c_str());
1637       }
1638
1639       // Symlink the file
1640       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1641       {
1642          ErrorText = "Link to " + DestFile + " failure ";
1643          Status = StatError;
1644          Complete = false;
1645       }
1646    }
1647 }
1648                                                                         /*}}}*/
1649 // AcqFile::Failed - Failure handler                                    /*{{{*/
1650 // ---------------------------------------------------------------------
1651 /* Here we try other sources */
1652 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1653 {
1654    ErrorText = LookupTag(Message,"Message");
1655
1656    // This is the retry counter
1657    if (Retries != 0 &&
1658        Cnf->LocalOnly == false &&
1659        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1660    {
1661       Retries--;
1662       QueueURI(Desc);
1663       return;
1664    }
1665
1666    Item::Failed(Message,Cnf);
1667 }
1668                                                                         /*}}}*/