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