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