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    // we only inform the Log class if it was actually not a local thing
 107    if (Complete == false && !Local && FileName == DestFile)
 108    {
 109       if (Owner->Log != 0)
 110          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 111    }
 112
 113    if (FileSize == 0)
 114       FileSize= Size;
 115
 116    Status = StatDone;
 117    ErrorText = string();
 118    Owner->Dequeue(this);
 119 }
 120                                                                         /*}}}*/
 121 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 122 // ---------------------------------------------------------------------
 123 /* This helper function is used by alot of item methods as thier final
 124    step */
 125 void pkgAcquire::Item::Rename(string From,string To)
 126 {
 127    if (rename(From.c_str(),To.c_str()) != 0)
 128    {
 129       char S[300];
 130       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 131               From.c_str(),To.c_str());
 132       Status = StatError;
 133       ErrorText = S;
 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    // FIXME: this file:/ check is a hack to prevent fetching
 169    //        from local sources. this is really silly, and
 170    //        should be fixed cleanly as soon as possible
 171    if(!FileExists(CurrentPackagesFile) ||
 172       Desc.URI.substr(0,strlen("file:/")) == "file:/")
 173    {
 174       // we don't have a pkg file or we don't want to queue
 175       if(Debug)
 176          std::clog << "No index file, local or canceld by user" << std::endl;
 177       Failed("", NULL);
 178       return;
 179    }
 180
 181    if(Debug)
 182       std::clog << "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): "
 183                 << CurrentPackagesFile << std::endl;
 184
 185    QueueURI(Desc);
 186
 187 }
 188
 189 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 190 // ---------------------------------------------------------------------
 191 /* The only header we use is the last-modified header. */
 192 string pkgAcqDiffIndex::Custom600Headers()
 193 {
 194    string Final = _config->FindDir("Dir::State::lists");
 195    Final += URItoFileName(RealURI) + string(".IndexDiff");
 196
 197    if(Debug)
 198       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 199
 200    struct stat Buf;
 201    if (stat(Final.c_str(),&Buf) != 0)
 202       return "\nIndex-File: true";
 203
 204    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 205 }
 206
 207
 208 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)
 209 {
 210    if(Debug)
 211       std::clog << "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile
 212                 << std::endl;
 213
 214    pkgTagSection Tags;
 215    string ServerSha1;
 216    vector<DiffInfo> available_patches;
 217
 218    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
 219    pkgTagFile TF(&Fd);
 220    if (_error->PendingError() == true)
 221       return false;
 222
 223    if(TF.Step(Tags) == true)
 224    {
 225       string local_sha1;
 226       bool found = false;
 227       DiffInfo d;
 228       string size;
 229
 230       string tmp = Tags.FindS("SHA1-Current");
 231       std::stringstream ss(tmp);
 232       ss >> ServerSha1;
 233
 234       FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
 235       SHA1Summation SHA1;
 236       SHA1.AddFD(fd.Fd(), fd.Size());
 237       local_sha1 = string(SHA1.Result());
 238
 239       if(local_sha1 == ServerSha1)
 240       {
 241          // we have the same sha1 as the server
 242          if(Debug)
 243             std::clog << "Package file is up-to-date" << std::endl;
 244          // set found to true, this will queue a pkgAcqIndexDiffs with
 245          // a empty availabe_patches
 246          found = true;
 247       }
 248       else
 249       {
 250          if(Debug)
 251             std::clog << "SHA1-Current: " << ServerSha1 << std::endl;
 252
 253          // check the historie and see what patches we need
 254          string history = Tags.FindS("SHA1-History");
 255          std::stringstream hist(history);
 256          while(hist >> d.sha1 >> size >> d.file)
 257          {
 258             d.size = atoi(size.c_str());
 259             // read until the first match is found
 260             if(d.sha1 == local_sha1)
 261                found=true;
 262             // from that point on, we probably need all diffs
 263             if(found)
 264             {
 265                if(Debug)
 266                   std::clog << "Need to get diff: " << d.file << std::endl;
 267                available_patches.push_back(d);
 268             }
 269          }
 270       }
 271
 272       // no information how to get the patches, bail out
 273       if(!found)
 274       {
 275          if(Debug)
 276             std::clog << "Can't find a patch in the index file" << std::endl;
 277          // Failed will queue a big package file
 278          Failed("", NULL);
 279       }
 280       else
 281       {
 282          // queue the diffs
 283          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 284                               ExpectedMD5, available_patches);
 285          Complete = false;
 286          Status = StatDone;
 287          Dequeue();
 288          return true;
 289       }
 290    }
 291
 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                    ExpectedMD5);
 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                                    string ExpectedMD5, vector<DiffInfo> diffs)
 349    : Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5),
 350      available_patches(diffs)
 351 {
 352
 353    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 354    DestFile += URItoFileName(URI);
 355
 356    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 357
 358    Desc.Description = URIDesc;
 359    Desc.Owner = this;
 360    Desc.ShortDesc = ShortDesc;
 361
 362    if(available_patches.size() == 0)
 363    {
 364       // we are done (yeah!)
 365       Finish(true);
 366    }
 367    else
 368    {
 369       // get the next diff
 370       State = StateFetchDiff;
 371       QueueNextDiff();
 372    }
 373 }
 374
 375
 376 void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 377 {
 378    if(Debug)
 379       std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << std::endl
 380                 << "Falling back to normal index file aquire" << std::endl;
 381    new pkgAcqIndex(Owner, RealURI, Description,Desc.ShortDesc,
 382                    ExpectedMD5);
 383    Finish();
 384 }
 385
 386
 387 // helper that cleans the item out of the fetcher queue
 388 void pkgAcqIndexDiffs::Finish(bool allDone)
 389 {
 390    // we restore the original name, this is required, otherwise
 391    // the file will be cleaned
 392    if(allDone)
 393    {
 394       DestFile = _config->FindDir("Dir::State::lists");
 395       DestFile += URItoFileName(RealURI);
 396
 397       // do the final md5sum checking
 398       MD5Summation sum;
 399       FileFd Fd(DestFile, FileFd::ReadOnly);
 400       sum.AddFD(Fd.Fd(), Fd.Size());
 401       Fd.Close();
 402       string MD5 = (string)sum.Result();
 403
 404       if (!ExpectedMD5.empty() && MD5 != ExpectedMD5)
 405       {
 406          Status = StatAuthError;
 407          ErrorText = _("MD5Sum mismatch");
 408          Rename(DestFile,DestFile + ".FAILED");
 409          Dequeue();
 410          return;
 411       }
 412
 413       // this is for the "real" finish
 414       Complete = true;
 415       Status = StatDone;
 416       Dequeue();
 417       if(Debug)
 418          std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
 419       return;
 420    }
 421
 422    if(Debug)
 423       std::clog << "Finishing: " << Desc.URI << std::endl;
 424    Complete = false;
 425    Status = StatDone;
 426    Dequeue();
 427    return;
 428 }
 429
 430
 431
 432 bool pkgAcqIndexDiffs::QueueNextDiff()
 433 {
 434
 435    // calc sha1 of the just patched file
 436    string FinalFile = _config->FindDir("Dir::State::lists");
 437    FinalFile += URItoFileName(RealURI);
 438
 439    FileFd fd(FinalFile, FileFd::ReadOnly);
 440    SHA1Summation SHA1;
 441    SHA1.AddFD(fd.Fd(), fd.Size());
 442    string local_sha1 = string(SHA1.Result());
 443    if(Debug)
 444       std::clog << "QueueNextDiff: "
 445                 << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 446
 447    // remove all patches until the next matching patch is found
 448    // this requires the Index file to be ordered
 449    for(vector<DiffInfo>::iterator I=available_patches.begin();
 450        available_patches.size() > 0 &&
 451           I != available_patches.end() &&
 452           (*I).sha1 != local_sha1;
 453        I++)
 454    {
 455       available_patches.erase(I);
 456    }
 457
 458    // error checking and falling back if no patch was found
 459    if(available_patches.size() == 0)
 460    {
 461       Failed("", NULL);
 462       return false;
 463    }
 464
 465    // queue the right diff
 466    Desc.URI = string(RealURI) + ".diff/" + available_patches[0].file + ".gz";
 467    Desc.Description = available_patches[0].file + string(".pdiff");
 468
 469    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 470    DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file);
 471
 472    if(Debug)
 473       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
 474
 475    QueueURI(Desc);
 476
 477    return true;
 478 }
 479
 480
 481
 482 void pkgAcqIndexDiffs::Done(string Message,unsigned long Size,string Md5Hash,
 483                             pkgAcquire::MethodConfig *Cnf)
 484 {
 485    if(Debug)
 486       std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
 487
 488    Item::Done(Message,Size,Md5Hash,Cnf);
 489
 490    string FinalFile;
 491    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 492
 493    // sucess in downloading a diff, enter ApplyDiff state
 494    if(State == StateFetchDiff)
 495    {
 496
 497       if(Debug)
 498          std::clog << "Sending to gzip method: " << FinalFile << std::endl;
 499
 500       string FileName = LookupTag(Message,"Filename");
 501       State = StateUnzipDiff;
 502       Local = true;
 503       Desc.URI = "gzip:" + FileName;
 504       DestFile += ".decomp";
 505       QueueURI(Desc);
 506       Mode = "gzip";
 507       return;
 508    }
 509
 510    // sucess in downloading a diff, enter ApplyDiff state
 511    if(State == StateUnzipDiff)
 512    {
 513
 514       // rred excepts the patch as $FinalFile.ed
 515       Rename(DestFile,FinalFile+".ed");
 516
 517       if(Debug)
 518          std::clog << "Sending to rred method: " << FinalFile << std::endl;
 519
 520       State = StateApplyDiff;
 521       Local = true;
 522       Desc.URI = "rred:" + FinalFile;
 523       QueueURI(Desc);
 524       Mode = "rred";
 525       return;
 526    }
 527
 528
 529    // success in download/apply a diff, queue next (if needed)
 530    if(State == StateApplyDiff)
 531    {
 532       // remove the just applied patch
 533       available_patches.erase(available_patches.begin());
 534
 535       // move into place
 536       if(Debug)
 537       {
 538          std::clog << "Moving patched file in place: " << std::endl
 539                    << DestFile << " -> " << FinalFile << std::endl;
 540       }
 541       Rename(DestFile,FinalFile);
 542
 543       // see if there is more to download
 544       if(available_patches.size() > 0) {
 545          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 546                               ExpectedMD5, available_patches);
 547          return Finish();
 548       } else
 549          return Finish(true);
 550    }
 551 }
 552
 553
 554 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 555 // ---------------------------------------------------------------------
 556 /* The package file is added to the queue and a second class is
 557    instantiated to fetch the revision file */
 558 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 559                          string URI,string URIDesc,string ShortDesc,
 560                          string ExpectedMD5, string comprExt)
 561    : Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5)
 562 {
 563    Decompression = false;
 564    Erase = false;
 565
 566    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 567    DestFile += URItoFileName(URI);
 568
 569    if(comprExt.empty())
 570    {
 571       // autoselect the compression method
 572       if(FileExists("/usr/bin/bzip2"))
 573          CompressionExtension = ".bz2";
 574       else
 575          CompressionExtension = ".gz";
 576    } else {
 577       CompressionExtension = comprExt;
 578    }
 579    Desc.URI = URI + CompressionExtension;
 580
 581    Desc.Description = URIDesc;
 582    Desc.Owner = this;
 583    Desc.ShortDesc = ShortDesc;
 584
 585    QueueURI(Desc);
 586 }
 587                                                                         /*}}}*/
 588 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 589 // ---------------------------------------------------------------------
 590 /* The only header we use is the last-modified header. */
 591 string pkgAcqIndex::Custom600Headers()
 592 {
 593    string Final = _config->FindDir("Dir::State::lists");
 594    Final += URItoFileName(RealURI);
 595
 596    struct stat Buf;
 597    if (stat(Final.c_str(),&Buf) != 0)
 598       return "\nIndex-File: true";
 599
 600    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 601 }
 602                                                                         /*}}}*/
 603
 604 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 605 {
 606    // no .bz2 found, retry with .gz
 607    if(Desc.URI.substr(Desc.URI.size()-3) == "bz2") {
 608       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz";
 609
 610       // retry with a gzip one
 611       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 612                       ExpectedMD5, string(".gz"));
 613       Status = StatDone;
 614       Complete = false;
 615       Dequeue();
 616       return;
 617    }
 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 MD5,
 632                        pkgAcquire::MethodConfig *Cfg)
 633 {
 634    Item::Done(Message,Size,MD5,Cfg);
 635
 636    if (Decompression == true)
 637    {
 638       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 639       {
 640          std::cerr << std::endl << RealURI << ": Computed MD5: " << MD5;
 641          std::cerr << "  Expected MD5: " << ExpectedMD5 << std::endl;
 642       }
 643
 644       if (MD5.empty())
 645       {
 646          MD5Summation sum;
 647          FileFd Fd(DestFile, FileFd::ReadOnly);
 648          sum.AddFD(Fd.Fd(), Fd.Size());
 649          Fd.Close();
 650          MD5 = (string)sum.Result();
 651       }
 652
 653       if (!ExpectedMD5.empty() && MD5 != ExpectedMD5)
 654       {
 655          Status = StatAuthError;
 656          ErrorText = _("MD5Sum mismatch");
 657          Rename(DestFile,DestFile + ".FAILED");
 658          return;
 659       }
 660       // Done, move it into position
 661       string FinalFile = _config->FindDir("Dir::State::lists");
 662       FinalFile += URItoFileName(RealURI);
 663       Rename(DestFile,FinalFile);
 664       chmod(FinalFile.c_str(),0644);
 665
 666       /* We restore the original name to DestFile so that the clean operation
 667          will work OK */
 668       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 669       DestFile += URItoFileName(RealURI);
 670
 671       // Remove the compressed version.
 672       if (Erase == true)
 673          unlink(DestFile.c_str());
 674       return;
 675    }
 676
 677    Erase = false;
 678    Complete = true;
 679
 680    // Handle the unzipd case
 681    string FileName = LookupTag(Message,"Alt-Filename");
 682    if (FileName.empty() == false)
 683    {
 684       // The files timestamp matches
 685       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 686          return;
 687
 688       Decompression = true;
 689       Local = true;
 690       DestFile += ".decomp";
 691       Desc.URI = "copy:" + FileName;
 692       QueueURI(Desc);
 693       Mode = "copy";
 694       return;
 695    }
 696
 697    FileName = LookupTag(Message,"Filename");
 698    if (FileName.empty() == true)
 699    {
 700       Status = StatError;
 701       ErrorText = "Method gave a blank filename";
 702    }
 703
 704    // The files timestamp matches
 705    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 706       return;
 707
 708    if (FileName == DestFile)
 709       Erase = true;
 710    else
 711       Local = true;
 712
 713    string compExt = Desc.URI.substr(Desc.URI.size()-3);
 714    char *decompProg;
 715    if(compExt == "bz2")
 716       decompProg = "bzip2";
 717    else if(compExt == ".gz")
 718       decompProg = "gzip";
 719    else {
 720       _error->Error("Unsupported extension: %s", compExt.c_str());
 721       return;
 722    }
 723
 724    Decompression = true;
 725    DestFile += ".decomp";
 726    Desc.URI = string(decompProg) + ":" + FileName;
 727    QueueURI(Desc);
 728    Mode = decompProg;
 729 }
 730
 731 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                        /*{{{*/
 732 // ---------------------------------------------------------------------
 733 /* The Translation file is added to the queue */
 734 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 735                             string URI,string URIDesc,string ShortDesc) :
 736                       pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, "", "")
 737 {
 738 }
 739
 740                                                                         /*}}}*/
 741 // AcqIndexTrans::Failed - Silence failure messages for missing files   /*{{{*/
 742 // ---------------------------------------------------------------------
 743 /* */
 744 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 745 {
 746    if (Cnf->LocalOnly == true ||
 747        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 748    {
 749       // Ignore this
 750       Status = StatDone;
 751       Complete = false;
 752       Dequeue();
 753       return;
 754    }
 755
 756    Item::Failed(Message,Cnf);
 757 }
 758                                                                         /*}}}*/
 759
 760 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
 761                              string URI,string URIDesc,string ShortDesc,
 762                              string MetaIndexURI, string MetaIndexURIDesc,
 763                              string MetaIndexShortDesc,
 764                              const vector<IndexTarget*>* IndexTargets,
 765                              indexRecords* MetaIndexParser) :
 766    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
 767    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
 768    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
 769 {
 770    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 771    DestFile += URItoFileName(URI);
 772
 773    // remove any partial downloaded sig-file. it may confuse proxies
 774    // and is too small to warrant a partial download anyway
 775    unlink(DestFile.c_str());
 776
 777    // Create the item
 778    Desc.Description = URIDesc;
 779    Desc.Owner = this;
 780    Desc.ShortDesc = ShortDesc;
 781    Desc.URI = URI;
 782
 783
 784    string Final = _config->FindDir("Dir::State::lists");
 785    Final += URItoFileName(RealURI);
 786    struct stat Buf;
 787    if (stat(Final.c_str(),&Buf) == 0)
 788    {
 789       // File was already in place.  It needs to be re-verified
 790       // because Release might have changed, so Move it into partial
 791       Rename(Final,DestFile);
 792    }
 793
 794    QueueURI(Desc);
 795 }
 796                                                                         /*}}}*/
 797 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
 798 // ---------------------------------------------------------------------
 799 /* The only header we use is the last-modified header. */
 800 string pkgAcqMetaSig::Custom600Headers()
 801 {
 802    struct stat Buf;
 803    if (stat(DestFile.c_str(),&Buf) != 0)
 804       return "\nIndex-File: true";
 805
 806    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 807 }
 808
 809 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
 810                          pkgAcquire::MethodConfig *Cfg)
 811 {
 812    Item::Done(Message,Size,MD5,Cfg);
 813
 814    string FileName = LookupTag(Message,"Filename");
 815    if (FileName.empty() == true)
 816    {
 817       Status = StatError;
 818       ErrorText = "Method gave a blank filename";
 819       return;
 820    }
 821
 822    if (FileName != DestFile)
 823    {
 824       // We have to copy it into place
 825       Local = true;
 826       Desc.URI = "copy:" + FileName;
 827       QueueURI(Desc);
 828       return;
 829    }
 830
 831    Complete = true;
 832
 833    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
 834    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 835                        DestFile, IndexTargets, MetaIndexParser);
 836
 837 }
 838                                                                         /*}}}*/
 839 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 840 {
 841
 842    // if we get a network error we fail gracefully
 843    if(LookupTag(Message,"FailReason") == "Timeout" ||
 844       LookupTag(Message,"FailReason") == "TmpResolveFailure" ||
 845       LookupTag(Message,"FailReason") == "ConnectionRefused") {
 846       Item::Failed(Message,Cnf);
 847       return;
 848    }
 849
 850    // Delete any existing sigfile when the acquire failed
 851    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 852    unlink(Final.c_str());
 853
 854    // queue a pkgAcqMetaIndex with no sigfile
 855    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 856                        "", IndexTargets, MetaIndexParser);
 857
 858    if (Cnf->LocalOnly == true ||
 859        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 860    {
 861       // Ignore this
 862       Status = StatDone;
 863       Complete = false;
 864       Dequeue();
 865       return;
 866    }
 867
 868    Item::Failed(Message,Cnf);
 869 }
 870
 871 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,
 872                                  string URI,string URIDesc,string ShortDesc,
 873                                  string SigFile,
 874                                  const vector<struct IndexTarget*>* IndexTargets,
 875                                  indexRecords* MetaIndexParser) :
 876    Item(Owner), RealURI(URI), SigFile(SigFile), AuthPass(false),
 877    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets), IMSHit(false)
 878 {
 879    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 880    DestFile += URItoFileName(URI);
 881
 882    // Create the item
 883    Desc.Description = URIDesc;
 884    Desc.Owner = this;
 885    Desc.ShortDesc = ShortDesc;
 886    Desc.URI = URI;
 887
 888    QueueURI(Desc);
 889 }
 890
 891                                                                         /*}}}*/
 892 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
 893 // ---------------------------------------------------------------------
 894 /* The only header we use is the last-modified header. */
 895 string pkgAcqMetaIndex::Custom600Headers()
 896 {
 897    string Final = _config->FindDir("Dir::State::lists");
 898    Final += URItoFileName(RealURI);
 899
 900    struct stat Buf;
 901    if (stat(Final.c_str(),&Buf) != 0)
 902       return "\nIndex-File: true";
 903
 904    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 905 }
 906
 907 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string MD5,
 908                            pkgAcquire::MethodConfig *Cfg)
 909 {
 910    Item::Done(Message,Size,MD5,Cfg);
 911
 912    // MetaIndexes are done in two passes: one to download the
 913    // metaindex with an appropriate method, and a second to verify it
 914    // with the gpgv method
 915
 916    if (AuthPass == true)
 917    {
 918       AuthDone(Message);
 919    }
 920    else
 921    {
 922       RetrievalDone(Message);
 923       if (!Complete)
 924          // Still more retrieving to do
 925          return;
 926
 927       if (SigFile == "")
 928       {
 929          // There was no signature file, so we are finished.  Download
 930          // the indexes without verification.
 931          QueueIndexes(false);
 932       }
 933       else
 934       {
 935          // There was a signature file, so pass it to gpgv for
 936          // verification
 937
 938          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 939             std::cerr << "Metaindex acquired, queueing gpg verification ("
 940                       << SigFile << "," << DestFile << ")\n";
 941          AuthPass = true;
 942          Desc.URI = "gpgv:" + SigFile;
 943          QueueURI(Desc);
 944          Mode = "gpgv";
 945       }
 946    }
 947 }
 948
 949 void pkgAcqMetaIndex::RetrievalDone(string Message)
 950 {
 951    // We have just finished downloading a Release file (it is not
 952    // verified yet)
 953
 954    string FileName = LookupTag(Message,"Filename");
 955    if (FileName.empty() == true)
 956    {
 957       Status = StatError;
 958       ErrorText = "Method gave a blank filename";
 959       return;
 960    }
 961
 962    if (FileName != DestFile)
 963    {
 964       Local = true;
 965       Desc.URI = "copy:" + FileName;
 966       QueueURI(Desc);
 967       return;
 968    }
 969
 970    // see if the download was a IMSHit
 971    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
 972
 973    Complete = true;
 974
 975    string FinalFile = _config->FindDir("Dir::State::lists");
 976    FinalFile += URItoFileName(RealURI);
 977
 978    // The files timestamp matches
 979    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == false)
 980    {
 981       // Move it into position
 982       Rename(DestFile,FinalFile);
 983    }
 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       string ExpectedIndexMD5;
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          ExpectedIndexMD5 = Record->MD5Hash;
1039          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1040          {
1041             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
1042             std::cerr << "Expected MD5: " << ExpectedIndexMD5 << std::endl;
1043          }
1044          if (ExpectedIndexMD5.empty())
1045          {
1046             Status = StatAuthError;
1047             ErrorText = "Unable to find MD5 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, ExpectedIndexMD5);
1058       else
1059          new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
1060                             (*Target)->ShortDesc, ExpectedIndexMD5);
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 are 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       MD5 = Parse.MD5Hash();
1301       if (PkgFile.empty() == true)
1302          return _error->Error(_("The package index files are corrupted. No Filename: "
1303                               "field for package %s."),
1304                               Version.ParentPkg().Name());
1305
1306       Desc.URI = Index->ArchiveURI(PkgFile);
1307       Desc.Description = Index->ArchiveInfo(Version);
1308       Desc.Owner = this;
1309       Desc.ShortDesc = Version.ParentPkg().Name();
1310
1311       // See if we already have the file. (Legacy filenames)
1312       FileSize = Version->Size;
1313       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
1314       struct stat Buf;
1315       if (stat(FinalFile.c_str(),&Buf) == 0)
1316       {
1317          // Make sure the size matches
1318          if ((unsigned)Buf.st_size == Version->Size)
1319          {
1320             Complete = true;
1321             Local = true;
1322             Status = StatDone;
1323             StoreFilename = DestFile = FinalFile;
1324             return true;
1325          }
1326
1327          /* Hmm, we have a file and its size does not match, this means it is
1328             an old style mismatched arch */
1329          unlink(FinalFile.c_str());
1330       }
1331
1332       // Check it again using the new style output filenames
1333       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
1334       if (stat(FinalFile.c_str(),&Buf) == 0)
1335       {
1336          // Make sure the size matches
1337          if ((unsigned)Buf.st_size == Version->Size)
1338          {
1339             Complete = true;
1340             Local = true;
1341             Status = StatDone;
1342             StoreFilename = DestFile = FinalFile;
1343             return true;
1344          }
1345
1346          /* Hmm, we have a file and its size does not match, this shouldnt
1347             happen.. */
1348          unlink(FinalFile.c_str());
1349       }
1350
1351       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
1352
1353       // Check the destination file
1354       if (stat(DestFile.c_str(),&Buf) == 0)
1355       {
1356          // Hmm, the partial file is too big, erase it
1357          if ((unsigned)Buf.st_size > Version->Size)
1358             unlink(DestFile.c_str());
1359          else
1360             PartialSize = Buf.st_size;
1361       }
1362
1363       // Create the item
1364       Local = false;
1365       Desc.URI = Index->ArchiveURI(PkgFile);
1366       Desc.Description = Index->ArchiveInfo(Version);
1367       Desc.Owner = this;
1368       Desc.ShortDesc = Version.ParentPkg().Name();
1369       QueueURI(Desc);
1370
1371       Vf++;
1372       return true;
1373    }
1374    return false;
1375 }
1376                                                                         /*}}}*/
1377 // AcqArchive::Done - Finished fetching                                 /*{{{*/
1378 // ---------------------------------------------------------------------
1379 /* */
1380 void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash,
1381                          pkgAcquire::MethodConfig *Cfg)
1382 {
1383    Item::Done(Message,Size,Md5Hash,Cfg);
1384
1385    // Check the size
1386    if (Size != Version->Size)
1387    {
1388       Status = StatError;
1389       ErrorText = _("Size mismatch");
1390       return;
1391    }
1392
1393    // Check the md5
1394    if (Md5Hash.empty() == false && MD5.empty() == false)
1395    {
1396       if (Md5Hash != MD5)
1397       {
1398          Status = StatError;
1399          ErrorText = _("MD5Sum mismatch");
1400          if(FileExists(DestFile))
1401             Rename(DestFile,DestFile + ".FAILED");
1402          return;
1403       }
1404    }
1405
1406    // Grab the output filename
1407    string FileName = LookupTag(Message,"Filename");
1408    if (FileName.empty() == true)
1409    {
1410       Status = StatError;
1411       ErrorText = "Method gave a blank filename";
1412       return;
1413    }
1414
1415    Complete = true;
1416
1417    // Reference filename
1418    if (FileName != DestFile)
1419    {
1420       StoreFilename = DestFile = FileName;
1421       Local = true;
1422       return;
1423    }
1424
1425    // Done, move it into position
1426    string FinalFile = _config->FindDir("Dir::Cache::Archives");
1427    FinalFile += flNotDir(StoreFilename);
1428    Rename(DestFile,FinalFile);
1429
1430    StoreFilename = DestFile = FinalFile;
1431    Complete = true;
1432 }
1433                                                                         /*}}}*/
1434 // AcqArchive::Failed - Failure handler                                 /*{{{*/
1435 // ---------------------------------------------------------------------
1436 /* Here we try other sources */
1437 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1438 {
1439    ErrorText = LookupTag(Message,"Message");
1440
1441    /* We don't really want to retry on failed media swaps, this prevents
1442       that. An interesting observation is that permanent failures are not
1443       recorded. */
1444    if (Cnf->Removable == true &&
1445        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1446    {
1447       // Vf = Version.FileList();
1448       while (Vf.end() == false) Vf++;
1449       StoreFilename = string();
1450       Item::Failed(Message,Cnf);
1451       return;
1452    }
1453
1454    if (QueueNext() == false)
1455    {
1456       // This is the retry counter
1457       if (Retries != 0 &&
1458           Cnf->LocalOnly == false &&
1459           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1460       {
1461          Retries--;
1462          Vf = Version.FileList();
1463          if (QueueNext() == true)
1464             return;
1465       }
1466
1467       StoreFilename = string();
1468       Item::Failed(Message,Cnf);
1469    }
1470 }
1471                                                                         /*}}}*/
1472 // AcqArchive::IsTrusted - Determine whether this archive comes from a
1473 // trusted source                                                       /*{{{*/
1474 // ---------------------------------------------------------------------
1475 bool pkgAcqArchive::IsTrusted()
1476 {
1477    return Trusted;
1478 }
1479
1480 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1481 // ---------------------------------------------------------------------
1482 /* */
1483 void pkgAcqArchive::Finished()
1484 {
1485    if (Status == pkgAcquire::Item::StatDone &&
1486        Complete == true)
1487       return;
1488    StoreFilename = string();
1489 }
1490                                                                         /*}}}*/
1491
1492 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1493 // ---------------------------------------------------------------------
1494 /* The file is added to the queue */
1495 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string MD5,
1496                        unsigned long Size,string Dsc,string ShortDesc,
1497                        const string &DestDir, const string &DestFilename) :
1498                        Item(Owner), Md5Hash(MD5)
1499 {
1500    Retries = _config->FindI("Acquire::Retries",0);
1501
1502    if(!DestFilename.empty())
1503       DestFile = DestFilename;
1504    else if(!DestDir.empty())
1505       DestFile = DestDir + "/" + flNotDir(URI);
1506    else
1507       DestFile = flNotDir(URI);
1508
1509    // Create the item
1510    Desc.URI = URI;
1511    Desc.Description = Dsc;
1512    Desc.Owner = this;
1513
1514    // Set the short description to the archive component
1515    Desc.ShortDesc = ShortDesc;
1516
1517    // Get the transfer sizes
1518    FileSize = Size;
1519    struct stat Buf;
1520    if (stat(DestFile.c_str(),&Buf) == 0)
1521    {
1522       // Hmm, the partial file is too big, erase it
1523       if ((unsigned)Buf.st_size > Size)
1524          unlink(DestFile.c_str());
1525       else
1526          PartialSize = Buf.st_size;
1527    }
1528
1529    QueueURI(Desc);
1530 }
1531                                                                         /*}}}*/
1532 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1533 // ---------------------------------------------------------------------
1534 /* */
1535 void pkgAcqFile::Done(string Message,unsigned long Size,string MD5,
1536                       pkgAcquire::MethodConfig *Cnf)
1537 {
1538    // Check the md5
1539    if (Md5Hash.empty() == false && MD5.empty() == false)
1540    {
1541       if (Md5Hash != MD5)
1542       {
1543          Status = StatError;
1544          ErrorText = "MD5Sum mismatch";
1545          Rename(DestFile,DestFile + ".FAILED");
1546          return;
1547       }
1548    }
1549
1550    Item::Done(Message,Size,MD5,Cnf);
1551
1552    string FileName = LookupTag(Message,"Filename");
1553    if (FileName.empty() == true)
1554    {
1555       Status = StatError;
1556       ErrorText = "Method gave a blank filename";
1557       return;
1558    }
1559
1560    Complete = true;
1561
1562    // The files timestamp matches
1563    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1564       return;
1565
1566    // We have to copy it into place
1567    if (FileName != DestFile)
1568    {
1569       Local = true;
1570       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1571           Cnf->Removable == true)
1572       {
1573          Desc.URI = "copy:" + FileName;
1574          QueueURI(Desc);
1575          return;
1576       }
1577
1578       // Erase the file if it is a symlink so we can overwrite it
1579       struct stat St;
1580       if (lstat(DestFile.c_str(),&St) == 0)
1581       {
1582          if (S_ISLNK(St.st_mode) != 0)
1583             unlink(DestFile.c_str());
1584       }
1585
1586       // Symlink the file
1587       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1588       {
1589          ErrorText = "Link to " + DestFile + " failure ";
1590          Status = StatError;
1591          Complete = false;
1592       }
1593    }
1594 }
1595                                                                         /*}}}*/
1596 // AcqFile::Failed - Failure handler                                    /*{{{*/
1597 // ---------------------------------------------------------------------
1598 /* Here we try other sources */
1599 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1600 {
1601    ErrorText = LookupTag(Message,"Message");
1602
1603    // This is the retry counter
1604    if (Retries != 0 &&
1605        Cnf->LocalOnly == false &&
1606        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1607    {
1608       Retries--;
1609       QueueURI(Desc);
1610       return;
1611    }
1612
1613    Item::Failed(Message,Cnf);
1614 }
1615                                                                         /*}}}*/