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