apt-pkg/acquire-item.cc

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