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