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