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 == "plain" ? "" : 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    bool descChanged = false;
 601    // no .bz2 found, retry with .gz
 602    if(Desc.URI.substr(Desc.URI.size()-3) == "bz2") {
 603       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz";
 604
 605       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 606                       ExpectedHash, string(".gz"));
 607           descChanged = true;
 608    }
 609    // no .gz found, retry with uncompressed
 610    else if(Desc.URI.substr(Desc.URI.size()-2) == "gz") {
 611       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-2);
 612
 613       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 614                       ExpectedHash, string("plain"));
 615           descChanged = true;
 616    }
 617    if (descChanged) {
 618       Status = StatDone;
 619       Complete = false;
 620       Dequeue();
 621       return;
 622    }
 623
 624    // on decompression failure, remove bad versions in partial/
 625    if(Decompression && Erase) {
 626       string s = _config->FindDir("Dir::State::lists") + "partial/";
 627       s += URItoFileName(RealURI);
 628       unlink(s.c_str());
 629    }
 630
 631    Item::Failed(Message,Cnf);
 632 }
 633
 634
 635 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 636 // ---------------------------------------------------------------------
 637 /* This goes through a number of states.. On the initial fetch the
 638    method could possibly return an alternate filename which points
 639    to the uncompressed version of the file. If this is so the file
 640    is copied into the partial directory. In all other cases the file
 641    is decompressed with a gzip uri. */
 642 void pkgAcqIndex::Done(string Message,unsigned long Size,string Hash,
 643                        pkgAcquire::MethodConfig *Cfg)
 644 {
 645    Item::Done(Message,Size,Hash,Cfg);
 646
 647    if (Decompression == true)
 648    {
 649       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 650       {
 651          std::cerr << std::endl << RealURI << ": Computed Hash: " << Hash;
 652          std::cerr << "  Expected Hash: " << ExpectedHash.toStr() << std::endl;
 653       }
 654
 655       if (!ExpectedHash.empty() && ExpectedHash.toStr() != Hash)
 656       {
 657          Status = StatAuthError;
 658          ErrorText = _("Hash Sum mismatch");
 659          Rename(DestFile,DestFile + ".FAILED");
 660          return;
 661       }
 662       // Done, move it into position
 663       string FinalFile = _config->FindDir("Dir::State::lists");
 664       FinalFile += URItoFileName(RealURI);
 665       Rename(DestFile,FinalFile);
 666       chmod(FinalFile.c_str(),0644);
 667
 668       /* We restore the original name to DestFile so that the clean operation
 669          will work OK */
 670       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 671       DestFile += URItoFileName(RealURI);
 672
 673       // Remove the compressed version.
 674       if (Erase == true)
 675          unlink(DestFile.c_str());
 676       return;
 677    }
 678
 679    Erase = false;
 680    Complete = true;
 681
 682    // Handle the unzipd case
 683    string FileName = LookupTag(Message,"Alt-Filename");
 684    if (FileName.empty() == false)
 685    {
 686       // The files timestamp matches
 687       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 688          return;
 689       Decompression = true;
 690       Local = true;
 691       DestFile += ".decomp";
 692       Desc.URI = "copy:" + FileName;
 693       QueueURI(Desc);
 694       Mode = "copy";
 695       return;
 696    }
 697
 698    FileName = LookupTag(Message,"Filename");
 699    if (FileName.empty() == true)
 700    {
 701       Status = StatError;
 702       ErrorText = "Method gave a blank filename";
 703    }
 704
 705    // The files timestamp matches
 706    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 707       return;
 708
 709    if (FileName == DestFile)
 710       Erase = true;
 711    else
 712       Local = true;
 713
 714    string compExt = flExtension(flNotDir(URI(Desc.URI).Path));
 715    const char *decompProg;
 716    if(compExt == "bz2")
 717       decompProg = "bzip2";
 718    else if(compExt == "gz")
 719       decompProg = "gzip";
 720    // flExtensions returns the full name if no extension is found
 721    // this is why we have this complicated compare operation here
 722    // FIMXE: add a new flJustExtension() that return "" if no
 723    //        extension is found and use that above so that it can
 724    //        be tested against ""
 725    else if(compExt == flNotDir(URI(Desc.URI).Path))
 726       decompProg = "copy";
 727    else {
 728       _error->Error("Unsupported extension: %s", compExt.c_str());
 729       return;
 730    }
 731
 732    Decompression = true;
 733    DestFile += ".decomp";
 734    Desc.URI = string(decompProg) + ":" + FileName;
 735    QueueURI(Desc);
 736    Mode = decompProg;
 737 }
 738
 739 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                        /*{{{*/
 740 // ---------------------------------------------------------------------
 741 /* The Translation file is added to the queue */
 742 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 743                             string URI,string URIDesc,string ShortDesc)
 744   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashString(), "")
 745 {
 746 }
 747
 748                                                                         /*}}}*/
 749 // AcqIndexTrans::Failed - Silence failure messages for missing files   /*{{{*/
 750 // ---------------------------------------------------------------------
 751 /* */
 752 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 753 {
 754    if (Cnf->LocalOnly == true ||
 755        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 756    {
 757       // Ignore this
 758       Status = StatDone;
 759       Complete = false;
 760       Dequeue();
 761       return;
 762    }
 763
 764    Item::Failed(Message,Cnf);
 765 }
 766                                                                         /*}}}*/
 767
 768 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
 769                              string URI,string URIDesc,string ShortDesc,
 770                              string MetaIndexURI, string MetaIndexURIDesc,
 771                              string MetaIndexShortDesc,
 772                              const vector<IndexTarget*>* IndexTargets,
 773                              indexRecords* MetaIndexParser) :
 774    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
 775    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
 776    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
 777 {
 778    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 779    DestFile += URItoFileName(URI);
 780
 781    // remove any partial downloaded sig-file in partial/.
 782    // it may confuse proxies and is too small to warrant a
 783    // partial download anyway
 784    unlink(DestFile.c_str());
 785
 786    // Create the item
 787    Desc.Description = URIDesc;
 788    Desc.Owner = this;
 789    Desc.ShortDesc = ShortDesc;
 790    Desc.URI = URI;
 791
 792    string Final = _config->FindDir("Dir::State::lists");
 793    Final += URItoFileName(RealURI);
 794    struct stat Buf;
 795    if (stat(Final.c_str(),&Buf) == 0)
 796    {
 797       // File was already in place.  It needs to be re-downloaded/verified
 798       // because Release might have changed, we do give it a differnt
 799       // name than DestFile because otherwise the http method will
 800       // send If-Range requests and there are too many broken servers
 801       // out there that do not understand them
 802       LastGoodSig = DestFile+".reverify";
 803       Rename(Final,LastGoodSig);
 804    }
 805
 806    QueueURI(Desc);
 807 }
 808                                                                         /*}}}*/
 809 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
 810 // ---------------------------------------------------------------------
 811 /* The only header we use is the last-modified header. */
 812 string pkgAcqMetaSig::Custom600Headers()
 813 {
 814    struct stat Buf;
 815    if (stat(LastGoodSig.c_str(),&Buf) != 0)
 816       return "\nIndex-File: true";
 817
 818    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 819 }
 820
 821 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
 822                          pkgAcquire::MethodConfig *Cfg)
 823 {
 824    Item::Done(Message,Size,MD5,Cfg);
 825
 826    string FileName = LookupTag(Message,"Filename");
 827    if (FileName.empty() == true)
 828    {
 829       Status = StatError;
 830       ErrorText = "Method gave a blank filename";
 831       return;
 832    }
 833
 834    if (FileName != DestFile)
 835    {
 836       // We have to copy it into place
 837       Local = true;
 838       Desc.URI = "copy:" + FileName;
 839       QueueURI(Desc);
 840       return;
 841    }
 842
 843    Complete = true;
 844
 845    // put the last known good file back on i-m-s hit (it will
 846    // be re-verified again)
 847    // Else do nothing, we have the new file in DestFile then
 848    if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 849       Rename(LastGoodSig, DestFile);
 850
 851    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
 852    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 853                        DestFile, IndexTargets, MetaIndexParser);
 854
 855 }
 856                                                                         /*}}}*/
 857 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 858 {
 859    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 860
 861    // if we get a network error we fail gracefully
 862    if(Status == StatTransientNetworkError)
 863    {
 864       Item::Failed(Message,Cnf);
 865       // move the sigfile back on transient network failures
 866       if(FileExists(DestFile))
 867          Rename(LastGoodSig,Final);
 868
 869       // set the status back to , Item::Failed likes to reset it
 870       Status = pkgAcquire::Item::StatTransientNetworkError;
 871       return;
 872    }
 873
 874    // Delete any existing sigfile when the acquire failed
 875    unlink(Final.c_str());
 876
 877    // queue a pkgAcqMetaIndex with no sigfile
 878    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 879                        "", IndexTargets, MetaIndexParser);
 880
 881    if (Cnf->LocalOnly == true ||
 882        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 883    {
 884       // Ignore this
 885       Status = StatDone;
 886       Complete = false;
 887       Dequeue();
 888       return;
 889    }
 890
 891    Item::Failed(Message,Cnf);
 892 }
 893
 894 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,
 895                                  string URI,string URIDesc,string ShortDesc,
 896                                  string SigFile,
 897                                  const vector<struct IndexTarget*>* IndexTargets,
 898                                  indexRecords* MetaIndexParser) :
 899    Item(Owner), RealURI(URI), SigFile(SigFile), IndexTargets(IndexTargets),
 900    MetaIndexParser(MetaIndexParser), AuthPass(false), IMSHit(false)
 901 {
 902    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 903    DestFile += URItoFileName(URI);
 904
 905    // Create the item
 906    Desc.Description = URIDesc;
 907    Desc.Owner = this;
 908    Desc.ShortDesc = ShortDesc;
 909    Desc.URI = URI;
 910
 911    QueueURI(Desc);
 912 }
 913
 914                                                                         /*}}}*/
 915 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
 916 // ---------------------------------------------------------------------
 917 /* The only header we use is the last-modified header. */
 918 string pkgAcqMetaIndex::Custom600Headers()
 919 {
 920    string Final = _config->FindDir("Dir::State::lists");
 921    Final += URItoFileName(RealURI);
 922
 923    struct stat Buf;
 924    if (stat(Final.c_str(),&Buf) != 0)
 925       return "\nIndex-File: true";
 926
 927    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 928 }
 929
 930 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string Hash,
 931                            pkgAcquire::MethodConfig *Cfg)
 932 {
 933    Item::Done(Message,Size,Hash,Cfg);
 934
 935    // MetaIndexes are done in two passes: one to download the
 936    // metaindex with an appropriate method, and a second to verify it
 937    // with the gpgv method
 938
 939    if (AuthPass == true)
 940    {
 941       AuthDone(Message);
 942    }
 943    else
 944    {
 945       RetrievalDone(Message);
 946       if (!Complete)
 947          // Still more retrieving to do
 948          return;
 949
 950       if (SigFile == "")
 951       {
 952          // There was no signature file, so we are finished.  Download
 953          // the indexes without verification.
 954          QueueIndexes(false);
 955       }
 956       else
 957       {
 958          // There was a signature file, so pass it to gpgv for
 959          // verification
 960
 961          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 962             std::cerr << "Metaindex acquired, queueing gpg verification ("
 963                       << SigFile << "," << DestFile << ")\n";
 964          AuthPass = true;
 965          Desc.URI = "gpgv:" + SigFile;
 966          QueueURI(Desc);
 967          Mode = "gpgv";
 968       }
 969    }
 970 }
 971
 972 void pkgAcqMetaIndex::RetrievalDone(string Message)
 973 {
 974    // We have just finished downloading a Release file (it is not
 975    // verified yet)
 976
 977    string FileName = LookupTag(Message,"Filename");
 978    if (FileName.empty() == true)
 979    {
 980       Status = StatError;
 981       ErrorText = "Method gave a blank filename";
 982       return;
 983    }
 984
 985    if (FileName != DestFile)
 986    {
 987       Local = true;
 988       Desc.URI = "copy:" + FileName;
 989       QueueURI(Desc);
 990       return;
 991    }
 992
 993    // see if the download was a IMSHit
 994    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
 995    Complete = true;
 996
 997    string FinalFile = _config->FindDir("Dir::State::lists");
 998    FinalFile += URItoFileName(RealURI);
 999
1000    // If we get a IMS hit we can remove the empty file in partial
1001    // othersie we move the file in place
1002    if (IMSHit)
1003       unlink(DestFile.c_str());
1004    else
1005       Rename(DestFile,FinalFile);
1006
1007    chmod(FinalFile.c_str(),0644);
1008    DestFile = FinalFile;
1009 }
1010
1011 void pkgAcqMetaIndex::AuthDone(string Message)
1012 {
1013    // At this point, the gpgv method has succeeded, so there is a
1014    // valid signature from a key in the trusted keyring.  We
1015    // perform additional verification of its contents, and use them
1016    // to verify the indexes we are about to download
1017
1018    if (!MetaIndexParser->Load(DestFile))
1019    {
1020       Status = StatAuthError;
1021       ErrorText = MetaIndexParser->ErrorText;
1022       return;
1023    }
1024
1025    if (!VerifyVendor(Message))
1026    {
1027       return;
1028    }
1029
1030    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1031       std::cerr << "Signature verification succeeded: "
1032                 << DestFile << std::endl;
1033
1034    // Download further indexes with verification
1035    QueueIndexes(true);
1036
1037    // Done, move signature file into position
1038
1039    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
1040       URItoFileName(RealURI) + ".gpg";
1041    Rename(SigFile,VerifiedSigFile);
1042    chmod(VerifiedSigFile.c_str(),0644);
1043 }
1044
1045 void pkgAcqMetaIndex::QueueIndexes(bool verify)
1046 {
1047    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
1048         Target != IndexTargets->end();
1049         Target++)
1050    {
1051       HashString ExpectedIndexHash;
1052       if (verify)
1053       {
1054          const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
1055          if (!Record)
1056          {
1057             Status = StatAuthError;
1058             ErrorText = "Unable to find expected entry  "
1059                + (*Target)->MetaKey + " in Meta-index file (malformed Release file?)";
1060             return;
1061          }
1062          ExpectedIndexHash = Record->Hash;
1063          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1064          {
1065             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
1066             std::cerr << "Expected Hash: " << ExpectedIndexHash.toStr() << std::endl;
1067          }
1068          if (ExpectedIndexHash.empty())
1069          {
1070             Status = StatAuthError;
1071             ErrorText = "Unable to find hash sum for "
1072                + (*Target)->MetaKey + " in Meta-index file";
1073             return;
1074          }
1075       }
1076
1077       // Queue Packages file (either diff or full packages files, depending
1078       // on the users option)
1079       if(_config->FindB("Acquire::PDiffs",true) == true)
1080          new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description,
1081                              (*Target)->ShortDesc, ExpectedIndexHash);
1082       else
1083          new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
1084                             (*Target)->ShortDesc, ExpectedIndexHash);
1085    }
1086 }
1087
1088 bool pkgAcqMetaIndex::VerifyVendor(string Message)
1089 {
1090 //    // Maybe this should be made available from above so we don't have
1091 //    // to read and parse it every time?
1092 //    pkgVendorList List;
1093 //    List.ReadMainList();
1094
1095 //    const Vendor* Vndr = NULL;
1096 //    for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
1097 //    {
1098 //       string::size_type pos = (*I).find("VALIDSIG ");
1099 //       if (_config->FindB("Debug::Vendor", false))
1100 //          std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
1101 //                    << std::endl;
1102 //       if (pos != std::string::npos)
1103 //       {
1104 //          string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
1105 //          if (_config->FindB("Debug::Vendor", false))
1106 //             std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
1107 //                std::endl;
1108 //          Vndr = List.FindVendor(Fingerprint) != "";
1109 //          if (Vndr != NULL);
1110 //          break;
1111 //       }
1112 //    }
1113    string::size_type pos;
1114
1115    // check for missing sigs (that where not fatal because otherwise we had
1116    // bombed earlier)
1117    string missingkeys;
1118    string msg = _("There is no public key available for the "
1119                   "following key IDs:\n");
1120    pos = Message.find("NO_PUBKEY ");
1121    if (pos != std::string::npos)
1122    {
1123       string::size_type start = pos+strlen("NO_PUBKEY ");
1124       string Fingerprint = Message.substr(start, Message.find("\n")-start);
1125       missingkeys += (Fingerprint);
1126    }
1127    if(!missingkeys.empty())
1128       _error->Warning("%s", string(msg+missingkeys).c_str());
1129
1130    string Transformed = MetaIndexParser->GetExpectedDist();
1131
1132    if (Transformed == "../project/experimental")
1133    {
1134       Transformed = "experimental";
1135    }
1136
1137    pos = Transformed.rfind('/');
1138    if (pos != string::npos)
1139    {
1140       Transformed = Transformed.substr(0, pos);
1141    }
1142
1143    if (Transformed == ".")
1144    {
1145       Transformed = "";
1146    }
1147
1148    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1149    {
1150       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
1151       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
1152       std::cerr << "Transformed Dist: " << Transformed << std::endl;
1153    }
1154
1155    if (MetaIndexParser->CheckDist(Transformed) == false)
1156    {
1157       // This might become fatal one day
1158 //       Status = StatAuthError;
1159 //       ErrorText = "Conflicting distribution; expected "
1160 //          + MetaIndexParser->GetExpectedDist() + " but got "
1161 //          + MetaIndexParser->GetDist();
1162 //       return false;
1163       if (!Transformed.empty())
1164       {
1165          _error->Warning("Conflicting distribution: %s (expected %s but got %s)",
1166                          Desc.Description.c_str(),
1167                          Transformed.c_str(),
1168                          MetaIndexParser->GetDist().c_str());
1169       }
1170    }
1171
1172    return true;
1173 }
1174                                                                 /*}}}*/
1175 // pkgAcqMetaIndex::Failed - no Release file present or no signature
1176 //      file present                                            /*{{{*/
1177 // ---------------------------------------------------------------------
1178 /* */
1179 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1180 {
1181    if (AuthPass == true)
1182    {
1183       // if we fail the authentication but got the file via a IMS-Hit
1184       // this means that the file wasn't downloaded and that it might be
1185       // just stale (server problem, proxy etc). we delete what we have
1186       // queue it again without i-m-s
1187       // alternatively we could just unlink the file and let the user try again
1188       if (IMSHit)
1189       {
1190          Complete = false;
1191          Local = false;
1192          AuthPass = false;
1193          unlink(DestFile.c_str());
1194
1195          DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1196          DestFile += URItoFileName(RealURI);
1197          Desc.URI = RealURI;
1198          QueueURI(Desc);
1199          return;
1200       }
1201
1202       // gpgv method failed
1203       _error->Warning("GPG error: %s: %s",
1204                       Desc.Description.c_str(),
1205                       LookupTag(Message,"Message").c_str());
1206
1207    }
1208
1209    // No Release file was present, or verification failed, so fall
1210    // back to queueing Packages files without verification
1211    QueueIndexes(false);
1212 }
1213
1214                                                                         /*}}}*/
1215
1216 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
1217 // ---------------------------------------------------------------------
1218 /* This just sets up the initial fetch environment and queues the first
1219    possibilitiy */
1220 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
1221                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
1222                              string &StoreFilename) :
1223                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
1224                StoreFilename(StoreFilename), Vf(Version.FileList()),
1225                Trusted(false)
1226 {
1227    Retries = _config->FindI("Acquire::Retries",0);
1228
1229    if (Version.Arch() == 0)
1230    {
1231       _error->Error(_("I wasn't able to locate a file for the %s package. "
1232                       "This might mean you need to manually fix this package. "
1233                       "(due to missing arch)"),
1234                     Version.ParentPkg().Name());
1235       return;
1236    }
1237
1238    /* We need to find a filename to determine the extension. We make the
1239       assumption here that all the available sources for this version share
1240       the same extension.. */
1241    // Skip not source sources, they do not have file fields.
1242    for (; Vf.end() == false; Vf++)
1243    {
1244       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1245          continue;
1246       break;
1247    }
1248
1249    // Does not really matter here.. we are going to fail out below
1250    if (Vf.end() != true)
1251    {
1252       // If this fails to get a file name we will bomb out below.
1253       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1254       if (_error->PendingError() == true)
1255          return;
1256
1257       // Generate the final file name as: package_version_arch.foo
1258       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
1259                       QuoteString(Version.VerStr(),"_:") + '_' +
1260                       QuoteString(Version.Arch(),"_:.") +
1261                       "." + flExtension(Parse.FileName());
1262    }
1263
1264    // check if we have one trusted source for the package. if so, switch
1265    // to "TrustedOnly" mode
1266    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++)
1267    {
1268       pkgIndexFile *Index;
1269       if (Sources->FindIndex(i.File(),Index) == false)
1270          continue;
1271       if (_config->FindB("Debug::pkgAcquire::Auth", false))
1272       {
1273          std::cerr << "Checking index: " << Index->Describe()
1274                    << "(Trusted=" << Index->IsTrusted() << ")\n";
1275       }
1276       if (Index->IsTrusted()) {
1277          Trusted = true;
1278          break;
1279       }
1280    }
1281
1282    // "allow-unauthenticated" restores apts old fetching behaviour
1283    // that means that e.g. unauthenticated file:// uris are higher
1284    // priority than authenticated http:// uris
1285    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
1286       Trusted = false;
1287
1288    // Select a source
1289    if (QueueNext() == false && _error->PendingError() == false)
1290       _error->Error(_("I wasn't able to locate file for the %s package. "
1291                     "This might mean you need to manually fix this package."),
1292                     Version.ParentPkg().Name());
1293 }
1294                                                                         /*}}}*/
1295 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
1296 // ---------------------------------------------------------------------
1297 /* This queues the next available file version for download. It checks if
1298    the archive is already available in the cache and stashs the MD5 for
1299    checking later. */
1300 bool pkgAcqArchive::QueueNext()
1301 {
1302    for (; Vf.end() == false; Vf++)
1303    {
1304       // Ignore not source sources
1305       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1306          continue;
1307
1308       // Try to cross match against the source list
1309       pkgIndexFile *Index;
1310       if (Sources->FindIndex(Vf.File(),Index) == false)
1311             continue;
1312
1313       // only try to get a trusted package from another source if that source
1314       // is also trusted
1315       if(Trusted && !Index->IsTrusted())
1316          continue;
1317
1318       // Grab the text package record
1319       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1320       if (_error->PendingError() == true)
1321          return false;
1322
1323       string PkgFile = Parse.FileName();
1324       if(Parse.SHA256Hash() != "")
1325          ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
1326       else if (Parse.SHA1Hash() != "")
1327          ExpectedHash = HashString("SHA1", Parse.SHA1Hash());
1328       else
1329          ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1330       if (PkgFile.empty() == true)
1331          return _error->Error(_("The package index files are corrupted. No Filename: "
1332                               "field for package %s."),
1333                               Version.ParentPkg().Name());
1334
1335       Desc.URI = Index->ArchiveURI(PkgFile);
1336       Desc.Description = Index->ArchiveInfo(Version);
1337       Desc.Owner = this;
1338       Desc.ShortDesc = Version.ParentPkg().Name();
1339
1340       // See if we already have the file. (Legacy filenames)
1341       FileSize = Version->Size;
1342       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
1343       struct stat Buf;
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 means it is
1357             an old style mismatched arch */
1358          unlink(FinalFile.c_str());
1359       }
1360
1361       // Check it again using the new style output filenames
1362       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
1363       if (stat(FinalFile.c_str(),&Buf) == 0)
1364       {
1365          // Make sure the size matches
1366          if ((unsigned)Buf.st_size == Version->Size)
1367          {
1368             Complete = true;
1369             Local = true;
1370             Status = StatDone;
1371             StoreFilename = DestFile = FinalFile;
1372             return true;
1373          }
1374
1375          /* Hmm, we have a file and its size does not match, this shouldnt
1376             happen.. */
1377          unlink(FinalFile.c_str());
1378       }
1379
1380       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
1381
1382       // Check the destination file
1383       if (stat(DestFile.c_str(),&Buf) == 0)
1384       {
1385          // Hmm, the partial file is too big, erase it
1386          if ((unsigned)Buf.st_size > Version->Size)
1387             unlink(DestFile.c_str());
1388          else
1389             PartialSize = Buf.st_size;
1390       }
1391
1392       // Create the item
1393       Local = false;
1394       Desc.URI = Index->ArchiveURI(PkgFile);
1395       Desc.Description = Index->ArchiveInfo(Version);
1396       Desc.Owner = this;
1397       Desc.ShortDesc = Version.ParentPkg().Name();
1398       QueueURI(Desc);
1399
1400       Vf++;
1401       return true;
1402    }
1403    return false;
1404 }
1405                                                                         /*}}}*/
1406 // AcqArchive::Done - Finished fetching                                 /*{{{*/
1407 // ---------------------------------------------------------------------
1408 /* */
1409 void pkgAcqArchive::Done(string Message,unsigned long Size,string CalcHash,
1410                          pkgAcquire::MethodConfig *Cfg)
1411 {
1412    Item::Done(Message,Size,CalcHash,Cfg);
1413
1414    // Check the size
1415    if (Size != Version->Size)
1416    {
1417       Status = StatError;
1418       ErrorText = _("Size mismatch");
1419       return;
1420    }
1421
1422    // Check the hash
1423    if(ExpectedHash.toStr() != CalcHash)
1424    {
1425       Status = StatError;
1426       ErrorText = _("Hash Sum mismatch");
1427       if(FileExists(DestFile))
1428          Rename(DestFile,DestFile + ".FAILED");
1429       return;
1430    }
1431
1432    // Grab the output filename
1433    string FileName = LookupTag(Message,"Filename");
1434    if (FileName.empty() == true)
1435    {
1436       Status = StatError;
1437       ErrorText = "Method gave a blank filename";
1438       return;
1439    }
1440
1441    Complete = true;
1442
1443    // Reference filename
1444    if (FileName != DestFile)
1445    {
1446       StoreFilename = DestFile = FileName;
1447       Local = true;
1448       return;
1449    }
1450
1451    // Done, move it into position
1452    string FinalFile = _config->FindDir("Dir::Cache::Archives");
1453    FinalFile += flNotDir(StoreFilename);
1454    Rename(DestFile,FinalFile);
1455
1456    StoreFilename = DestFile = FinalFile;
1457    Complete = true;
1458 }
1459                                                                         /*}}}*/
1460 // AcqArchive::Failed - Failure handler                                 /*{{{*/
1461 // ---------------------------------------------------------------------
1462 /* Here we try other sources */
1463 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1464 {
1465    ErrorText = LookupTag(Message,"Message");
1466
1467    /* We don't really want to retry on failed media swaps, this prevents
1468       that. An interesting observation is that permanent failures are not
1469       recorded. */
1470    if (Cnf->Removable == true &&
1471        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1472    {
1473       // Vf = Version.FileList();
1474       while (Vf.end() == false) Vf++;
1475       StoreFilename = string();
1476       Item::Failed(Message,Cnf);
1477       return;
1478    }
1479
1480    if (QueueNext() == false)
1481    {
1482       // This is the retry counter
1483       if (Retries != 0 &&
1484           Cnf->LocalOnly == false &&
1485           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1486       {
1487          Retries--;
1488          Vf = Version.FileList();
1489          if (QueueNext() == true)
1490             return;
1491       }
1492
1493       StoreFilename = string();
1494       Item::Failed(Message,Cnf);
1495    }
1496 }
1497                                                                         /*}}}*/
1498 // AcqArchive::IsTrusted - Determine whether this archive comes from a
1499 // trusted source                                                       /*{{{*/
1500 // ---------------------------------------------------------------------
1501 bool pkgAcqArchive::IsTrusted()
1502 {
1503    return Trusted;
1504 }
1505
1506 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1507 // ---------------------------------------------------------------------
1508 /* */
1509 void pkgAcqArchive::Finished()
1510 {
1511    if (Status == pkgAcquire::Item::StatDone &&
1512        Complete == true)
1513       return;
1514    StoreFilename = string();
1515 }
1516                                                                         /*}}}*/
1517
1518 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1519 // ---------------------------------------------------------------------
1520 /* The file is added to the queue */
1521 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string Hash,
1522                        unsigned long Size,string Dsc,string ShortDesc,
1523                        const string &DestDir, const string &DestFilename) :
1524                        Item(Owner), ExpectedHash(Hash)
1525 {
1526    Retries = _config->FindI("Acquire::Retries",0);
1527
1528    if(!DestFilename.empty())
1529       DestFile = DestFilename;
1530    else if(!DestDir.empty())
1531       DestFile = DestDir + "/" + flNotDir(URI);
1532    else
1533       DestFile = flNotDir(URI);
1534
1535    // Create the item
1536    Desc.URI = URI;
1537    Desc.Description = Dsc;
1538    Desc.Owner = this;
1539
1540    // Set the short description to the archive component
1541    Desc.ShortDesc = ShortDesc;
1542
1543    // Get the transfer sizes
1544    FileSize = Size;
1545    struct stat Buf;
1546    if (stat(DestFile.c_str(),&Buf) == 0)
1547    {
1548       // Hmm, the partial file is too big, erase it
1549       if ((unsigned)Buf.st_size > Size)
1550          unlink(DestFile.c_str());
1551       else
1552          PartialSize = Buf.st_size;
1553    }
1554
1555    QueueURI(Desc);
1556 }
1557                                                                         /*}}}*/
1558 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1559 // ---------------------------------------------------------------------
1560 /* */
1561 void pkgAcqFile::Done(string Message,unsigned long Size,string CalcHash,
1562                       pkgAcquire::MethodConfig *Cnf)
1563 {
1564    Item::Done(Message,Size,CalcHash,Cnf);
1565
1566    // Check the hash
1567    if(!ExpectedHash.empty() && ExpectedHash.toStr() != CalcHash)
1568    {
1569       Status = StatError;
1570       ErrorText = "Hash Sum mismatch";
1571       Rename(DestFile,DestFile + ".FAILED");
1572       return;
1573    }
1574
1575    string FileName = LookupTag(Message,"Filename");
1576    if (FileName.empty() == true)
1577    {
1578       Status = StatError;
1579       ErrorText = "Method gave a blank filename";
1580       return;
1581    }
1582
1583    Complete = true;
1584
1585    // The files timestamp matches
1586    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1587       return;
1588
1589    // We have to copy it into place
1590    if (FileName != DestFile)
1591    {
1592       Local = true;
1593       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1594           Cnf->Removable == true)
1595       {
1596          Desc.URI = "copy:" + FileName;
1597          QueueURI(Desc);
1598          return;
1599       }
1600
1601       // Erase the file if it is a symlink so we can overwrite it
1602       struct stat St;
1603       if (lstat(DestFile.c_str(),&St) == 0)
1604       {
1605          if (S_ISLNK(St.st_mode) != 0)
1606             unlink(DestFile.c_str());
1607       }
1608
1609       // Symlink the file
1610       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1611       {
1612          ErrorText = "Link to " + DestFile + " failure ";
1613          Status = StatError;
1614          Complete = false;
1615       }
1616    }
1617 }
1618                                                                         /*}}}*/
1619 // AcqFile::Failed - Failure handler                                    /*{{{*/
1620 // ---------------------------------------------------------------------
1621 /* Here we try other sources */
1622 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1623 {
1624    ErrorText = LookupTag(Message,"Message");
1625
1626    // This is the retry counter
1627    if (Retries != 0 &&
1628        Cnf->LocalOnly == false &&
1629        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1630    {
1631       Retries--;
1632       QueueURI(Desc);
1633       return;
1634    }
1635
1636    Item::Failed(Message,Cnf);
1637 }
1638                                                                         /*}}}*/