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