apt-pkg/acquire-item.cc

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