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