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