apt-pkg/acquire-item.cc

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