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