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 #include <apt-pkg/acquire-item.h>
  17 #include <apt-pkg/configuration.h>
  18 #include <apt-pkg/aptconfiguration.h>
  19 #include <apt-pkg/sourcelist.h>
  20 #include <apt-pkg/vendorlist.h>
  21 #include <apt-pkg/error.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/fileutl.h>
  24 #include <apt-pkg/md5.h>
  25 #include <apt-pkg/sha1.h>
  26 #include <apt-pkg/tagfile.h>
  27
  28 #include <apti18n.h>
  29
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <string>
  34 #include <sstream>
  35 #include <stdio.h>
  36 #include <ctime>
  37                                                                         /*}}}*/
  38
  39 using namespace std;
  40
  41 // Acquire::Item::Item - Constructor                                    /*{{{*/
  42 // ---------------------------------------------------------------------
  43 /* */
  44 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),
  45                        PartialSize(0), Mode(0), ID(0), Complete(false),
  46                        Local(false), QueueCounter(0)
  47 {
  48    Owner->Add(this);
  49    Status = StatIdle;
  50 }
  51                                                                         /*}}}*/
  52 // Acquire::Item::~Item - Destructor                                    /*{{{*/
  53 // ---------------------------------------------------------------------
  54 /* */
  55 pkgAcquire::Item::~Item()
  56 {
  57    Owner->Remove(this);
  58 }
  59                                                                         /*}}}*/
  60 // Acquire::Item::Failed - Item failed to download                      /*{{{*/
  61 // ---------------------------------------------------------------------
  62 /* We return to an idle state if there are still other queues that could
  63    fetch this object */
  64 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
  65 {
  66    Status = StatIdle;
  67    ErrorText = LookupTag(Message,"Message");
  68    UsedMirror =  LookupTag(Message,"UsedMirror");
  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    // report mirror failure back to LP if we actually use a mirror
  87    string FailReason = LookupTag(Message, "FailReason");
  88    if(FailReason.size() != 0)
  89       ReportMirrorFailure(FailReason);
  90    else
  91       ReportMirrorFailure(ErrorText);
  92 }
  93                                                                         /*}}}*/
  94 // Acquire::Item::Start - Item has begun to download                    /*{{{*/
  95 // ---------------------------------------------------------------------
  96 /* Stash status and the file size. Note that setting Complete means
  97    sub-phases of the acquire process such as decompresion are operating */
  98 void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size)
  99 {
 100    Status = StatFetching;
 101    if (FileSize == 0 && Complete == false)
 102       FileSize = Size;
 103 }
 104                                                                         /*}}}*/
 105 // Acquire::Item::Done - Item downloaded OK                             /*{{{*/
 106 // ---------------------------------------------------------------------
 107 /* */
 108 void pkgAcquire::Item::Done(string Message,unsigned long Size,string Hash,
 109                             pkgAcquire::MethodConfig *Cnf)
 110 {
 111    // We just downloaded something..
 112    string FileName = LookupTag(Message,"Filename");
 113    UsedMirror =  LookupTag(Message,"UsedMirror");
 114    if (Complete == false && !Local && FileName == DestFile)
 115    {
 116       if (Owner->Log != 0)
 117          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 118    }
 119
 120    if (FileSize == 0)
 121       FileSize= Size;
 122    Status = StatDone;
 123    ErrorText = string();
 124    Owner->Dequeue(this);
 125 }
 126                                                                         /*}}}*/
 127 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 128 // ---------------------------------------------------------------------
 129 /* This helper function is used by alot of item methods as thier final
 130    step */
 131 void pkgAcquire::Item::Rename(string From,string To)
 132 {
 133    if (rename(From.c_str(),To.c_str()) != 0)
 134    {
 135       char S[300];
 136       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 137               From.c_str(),To.c_str());
 138       Status = StatError;
 139       ErrorText = S;
 140    }
 141 }
 142                                                                         /*}}}*/
 143 // Acquire::Item::ReportMirrorFailure                                   /*{{{*/
 144 // ---------------------------------------------------------------------
 145 void pkgAcquire::Item::ReportMirrorFailure(string FailCode)
 146 {
 147    // we only act if a mirror was used at all
 148    if(UsedMirror.empty())
 149       return;
 150 #if 0
 151    std::cerr << "\nReportMirrorFailure: "
 152              << UsedMirror
 153              << " Uri: " << DescURI()
 154              << " FailCode: "
 155              << FailCode << std::endl;
 156 #endif
 157    const char *Args[40];
 158    unsigned int i = 0;
 159    string report = _config->Find("Methods::Mirror::ProblemReporting",
 160                                  "/usr/lib/apt/apt-report-mirror-failure");
 161    if(!FileExists(report))
 162       return;
 163    Args[i++] = report.c_str();
 164    Args[i++] = UsedMirror.c_str();
 165    Args[i++] = DescURI().c_str();
 166    Args[i++] = FailCode.c_str();
 167    Args[i++] = NULL;
 168    pid_t pid = ExecFork();
 169    if(pid < 0)
 170    {
 171       _error->Error("ReportMirrorFailure Fork failed");
 172       return;
 173    }
 174    else if(pid == 0)
 175    {
 176       execvp(Args[0], (char**)Args);
 177       std::cerr << "Could not exec " << Args[0] << std::endl;
 178       _exit(100);
 179    }
 180    if(!ExecWait(pid, "report-mirror-failure"))
 181    {
 182       _error->Warning("Couldn't report problem to '%s'",
 183                       _config->Find("Methods::Mirror::ProblemReporting").c_str());
 184    }
 185 }
 186                                                                         /*}}}*/
 187 // AcqSubIndex::AcqSubIndex - Constructor                               /*{{{*/
 188 // ---------------------------------------------------------------------
 189 /* Get the Index file first and see if there are languages available
 190  * If so, create a pkgAcqIndexTrans for the found language(s).
 191  */
 192 pkgAcqSubIndex::pkgAcqSubIndex(pkgAcquire *Owner, string const &URI,
 193                                  string const &URIDesc, string const &ShortDesc,
 194                                  HashString const &ExpectedHash)
 195    : Item(Owner), ExpectedHash(ExpectedHash)
 196 {
 197    Debug = _config->FindB("Debug::pkgAcquire::SubIndex",false);
 198
 199    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 200    DestFile += URItoFileName(URI);
 201
 202    Desc.URI = URI;
 203    Desc.Description = URIDesc;
 204    Desc.Owner = this;
 205    Desc.ShortDesc = ShortDesc;
 206
 207    QueueURI(Desc);
 208
 209    if(Debug)
 210       std::clog << "pkgAcqSubIndex: " << Desc.URI << std::endl;
 211 }
 212                                                                         /*}}}*/
 213 // AcqSubIndex::Custom600Headers - Insert custom request headers        /*{{{*/
 214 // ---------------------------------------------------------------------
 215 /* The only header we use is the last-modified header. */
 216 string pkgAcqSubIndex::Custom600Headers()
 217 {
 218    string Final = _config->FindDir("Dir::State::lists");
 219    Final += URItoFileName(Desc.URI);
 220
 221    struct stat Buf;
 222    if (stat(Final.c_str(),&Buf) != 0)
 223       return "\nIndex-File: true";
 224    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 225 }
 226                                                                         /*}}}*/
 227 void pkgAcqSubIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)       /*{{{*/
 228 {
 229    if(Debug)
 230       std::clog << "pkgAcqSubIndex failed: " << Desc.URI << std::endl;
 231
 232    Complete = false;
 233    Status = StatDone;
 234    Dequeue();
 235
 236    // No good Index is provided, so try guessing
 237    std::vector<std::string> langs = APT::Configuration::getLanguages(true);
 238    for (std::vector<std::string>::const_iterator l = langs.begin();
 239         l != langs.end(); ++l)
 240    {
 241       if (*l == "none") continue;
 242       string const file = "Translation-" + *l;
 243       new pkgAcqIndexTrans(Owner, Desc.URI.substr(0, Desc.URI.rfind('/')+1).append(file),
 244                 Desc.Description.erase(Desc.Description.rfind(' ')+1).append(file),
 245                 file);
 246    }
 247 }
 248                                                                         /*}}}*/
 249 void pkgAcqSubIndex::Done(string Message,unsigned long Size,string Md5Hash,     /*{{{*/
 250                            pkgAcquire::MethodConfig *Cnf)
 251 {
 252    if(Debug)
 253       std::clog << "pkgAcqSubIndex::Done(): " << Desc.URI << std::endl;
 254
 255    string FileName = LookupTag(Message,"Filename");
 256    if (FileName.empty() == true)
 257    {
 258       Status = StatError;
 259       ErrorText = "Method gave a blank filename";
 260       return;
 261    }
 262
 263    if (FileName != DestFile)
 264    {
 265       Local = true;
 266       Desc.URI = "copy:" + FileName;
 267       QueueURI(Desc);
 268       return;
 269    }
 270
 271    Item::Done(Message,Size,Md5Hash,Cnf);
 272
 273    string FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(Desc.URI);
 274
 275    // sucess in downloading the index
 276    // rename the index
 277    if(Debug)
 278       std::clog << "Renaming: " << DestFile << " -> " << FinalFile << std::endl;
 279    Rename(DestFile,FinalFile);
 280    chmod(FinalFile.c_str(),0644);
 281    DestFile = FinalFile;
 282
 283    if(ParseIndex(DestFile) == false)
 284       return Failed("", NULL);
 285
 286    Complete = true;
 287    Status = StatDone;
 288    Dequeue();
 289    return;
 290 }
 291                                                                         /*}}}*/
 292 bool pkgAcqSubIndex::ParseIndex(string const &IndexFile)                /*{{{*/
 293 {
 294    indexRecords SubIndexParser;
 295    if (FileExists(IndexFile) == false || SubIndexParser.Load(IndexFile) == false)
 296       return false;
 297
 298    std::vector<std::string> lang = APT::Configuration::getLanguages(true);
 299    for (std::vector<std::string>::const_iterator l = lang.begin();
 300         l != lang.end(); ++l)
 301    {
 302       if (*l == "none")
 303          continue;
 304
 305       string file = "Translation-" + *l;
 306       indexRecords::checkSum const *Record = SubIndexParser.Lookup(file);
 307       HashString expected;
 308       if (Record == NULL)
 309       {
 310          // FIXME: the Index file provided by debian currently only includes bz2 records
 311          Record = SubIndexParser.Lookup(file + ".bz2");
 312          if (Record == NULL)
 313             continue;
 314       }
 315       else
 316       {
 317          expected = Record->Hash;
 318          if (expected.empty() == true)
 319             continue;
 320       }
 321
 322       IndexTarget target;
 323       target.Description = Desc.Description.erase(Desc.Description.rfind(' ')+1).append(file);
 324       target.MetaKey = file;
 325       target.ShortDesc = file;
 326       target.URI = Desc.URI.substr(0, Desc.URI.rfind('/')+1).append(file);
 327       new pkgAcqIndexTrans(Owner, &target, expected, &SubIndexParser);
 328    }
 329    return true;
 330 }
 331                                                                         /*}}}*/
 332 // AcqDiffIndex::AcqDiffIndex - Constructor                             /*{{{*/
 333 // ---------------------------------------------------------------------
 334 /* Get the DiffIndex file first and see if there are patches availabe
 335  * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
 336  * patches. If anything goes wrong in that process, it will fall back to
 337  * the original packages file
 338  */
 339 pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
 340                                  string URI,string URIDesc,string ShortDesc,
 341                                  HashString ExpectedHash)
 342    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 343      Description(URIDesc)
 344 {
 345
 346    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 347
 348    Desc.Description = URIDesc + "/DiffIndex";
 349    Desc.Owner = this;
 350    Desc.ShortDesc = ShortDesc;
 351    Desc.URI = URI + ".diff/Index";
 352
 353    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 354    DestFile += URItoFileName(URI) + string(".DiffIndex");
 355
 356    if(Debug)
 357       std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
 358
 359    // look for the current package file
 360    CurrentPackagesFile = _config->FindDir("Dir::State::lists");
 361    CurrentPackagesFile += URItoFileName(RealURI);
 362
 363    // FIXME: this file:/ check is a hack to prevent fetching
 364    //        from local sources. this is really silly, and
 365    //        should be fixed cleanly as soon as possible
 366    if(!FileExists(CurrentPackagesFile) ||
 367       Desc.URI.substr(0,strlen("file:/")) == "file:/")
 368    {
 369       // we don't have a pkg file or we don't want to queue
 370       if(Debug)
 371          std::clog << "No index file, local or canceld by user" << std::endl;
 372       Failed("", NULL);
 373       return;
 374    }
 375
 376    if(Debug)
 377       std::clog << "pkgAcqIndexDiffs::pkgAcqIndexDiffs(): "
 378                 << CurrentPackagesFile << std::endl;
 379
 380    QueueURI(Desc);
 381
 382 }
 383                                                                         /*}}}*/
 384 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 385 // ---------------------------------------------------------------------
 386 /* The only header we use is the last-modified header. */
 387 string pkgAcqDiffIndex::Custom600Headers()
 388 {
 389    string Final = _config->FindDir("Dir::State::lists");
 390    Final += URItoFileName(RealURI) + string(".IndexDiff");
 391
 392    if(Debug)
 393       std::clog << "Custom600Header-IMS: " << Final << std::endl;
 394
 395    struct stat Buf;
 396    if (stat(Final.c_str(),&Buf) != 0)
 397       return "\nIndex-File: true";
 398
 399    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 400 }
 401                                                                         /*}}}*/
 402 bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)              /*{{{*/
 403 {
 404    if(Debug)
 405       std::clog << "pkgAcqIndexDiffs::ParseIndexDiff() " << IndexDiffFile
 406                 << std::endl;
 407
 408    pkgTagSection Tags;
 409    string ServerSha1;
 410    vector<DiffInfo> available_patches;
 411
 412    FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
 413    pkgTagFile TF(&Fd);
 414    if (_error->PendingError() == true)
 415       return false;
 416
 417    if(TF.Step(Tags) == true)
 418    {
 419       bool found = false;
 420       DiffInfo d;
 421       string size;
 422
 423       string const tmp = Tags.FindS("SHA1-Current");
 424       std::stringstream ss(tmp);
 425       ss >> ServerSha1 >> size;
 426       unsigned long const ServerSize = atol(size.c_str());
 427
 428       FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
 429       SHA1Summation SHA1;
 430       SHA1.AddFD(fd.Fd(), fd.Size());
 431       string const local_sha1 = SHA1.Result();
 432
 433       if(local_sha1 == ServerSha1)
 434       {
 435          // we have the same sha1 as the server
 436          if(Debug)
 437             std::clog << "Package file is up-to-date" << std::endl;
 438          // set found to true, this will queue a pkgAcqIndexDiffs with
 439          // a empty availabe_patches
 440          found = true;
 441       }
 442       else
 443       {
 444          if(Debug)
 445             std::clog << "SHA1-Current: " << ServerSha1 << " and we start at "<< fd.Name() << " " << fd.Size() << " " << local_sha1 << std::endl;
 446
 447          // check the historie and see what patches we need
 448          string const history = Tags.FindS("SHA1-History");
 449          std::stringstream hist(history);
 450          while(hist >> d.sha1 >> size >> d.file)
 451          {
 452             // read until the first match is found
 453             // from that point on, we probably need all diffs
 454             if(d.sha1 == local_sha1)
 455                found=true;
 456             else if (found == false)
 457                continue;
 458
 459             if(Debug)
 460                std::clog << "Need to get diff: " << d.file << std::endl;
 461             available_patches.push_back(d);
 462          }
 463
 464          if (available_patches.empty() == false)
 465          {
 466             // patching with too many files is rather slow compared to a fast download
 467             unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
 468             if (fileLimit != 0 && fileLimit < available_patches.size())
 469             {
 470                if (Debug)
 471                   std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
 472                         << ") so fallback to complete download" << std::endl;
 473                return false;
 474             }
 475
 476             // see if the patches are too big
 477             found = false; // it was true and it will be true again at the end
 478             d = *available_patches.begin();
 479             string const firstPatch = d.file;
 480             unsigned long patchesSize = 0;
 481             std::stringstream patches(Tags.FindS("SHA1-Patches"));
 482             while(patches >> d.sha1 >> size >> d.file)
 483             {
 484                if (firstPatch == d.file)
 485                   found = true;
 486                else if (found == false)
 487                   continue;
 488
 489                patchesSize += atol(size.c_str());
 490             }
 491             unsigned long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
 492             if (sizeLimit > 0 && (sizeLimit/100) < patchesSize)
 493             {
 494                if (Debug)
 495                   std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
 496                         << ") so fallback to complete download" << std::endl;
 497                return false;
 498             }
 499          }
 500       }
 501
 502       // we have something, queue the next diff
 503       if(found)
 504       {
 505          // queue the diffs
 506          string::size_type const last_space = Description.rfind(" ");
 507          if(last_space != string::npos)
 508             Description.erase(last_space, Description.size()-last_space);
 509          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 510                               ExpectedHash, ServerSha1, available_patches);
 511          Complete = false;
 512          Status = StatDone;
 513          Dequeue();
 514          return true;
 515       }
 516    }
 517
 518    // Nothing found, report and return false
 519    // Failing here is ok, if we return false later, the full
 520    // IndexFile is queued
 521    if(Debug)
 522       std::clog << "Can't find a patch in the index file" << std::endl;
 523    return false;
 524 }
 525                                                                         /*}}}*/
 526 void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)      /*{{{*/
 527 {
 528    if(Debug)
 529       std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << std::endl
 530                 << "Falling back to normal index file aquire" << std::endl;
 531
 532    new pkgAcqIndex(Owner, RealURI, Description, Desc.ShortDesc,
 533                    ExpectedHash);
 534
 535    Complete = false;
 536    Status = StatDone;
 537    Dequeue();
 538 }
 539                                                                         /*}}}*/
 540 void pkgAcqDiffIndex::Done(string Message,unsigned long Size,string Md5Hash,    /*{{{*/
 541                            pkgAcquire::MethodConfig *Cnf)
 542 {
 543    if(Debug)
 544       std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
 545
 546    Item::Done(Message,Size,Md5Hash,Cnf);
 547
 548    string FinalFile;
 549    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 550
 551    // sucess in downloading the index
 552    // rename the index
 553    FinalFile += string(".IndexDiff");
 554    if(Debug)
 555       std::clog << "Renaming: " << DestFile << " -> " << FinalFile
 556                 << std::endl;
 557    Rename(DestFile,FinalFile);
 558    chmod(FinalFile.c_str(),0644);
 559    DestFile = FinalFile;
 560
 561    if(!ParseDiffIndex(DestFile))
 562       return Failed("", NULL);
 563
 564    Complete = true;
 565    Status = StatDone;
 566    Dequeue();
 567    return;
 568 }
 569                                                                         /*}}}*/
 570 // AcqIndexDiffs::AcqIndexDiffs - Constructor                           /*{{{*/
 571 // ---------------------------------------------------------------------
 572 /* The package diff is added to the queue. one object is constructed
 573  * for each diff and the index
 574  */
 575 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
 576                                    string URI,string URIDesc,string ShortDesc,
 577                                    HashString ExpectedHash,
 578                                    string ServerSha1,
 579                                    vector<DiffInfo> diffs)
 580    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash),
 581      available_patches(diffs), ServerSha1(ServerSha1)
 582 {
 583
 584    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 585    DestFile += URItoFileName(URI);
 586
 587    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 588
 589    Description = URIDesc;
 590    Desc.Owner = this;
 591    Desc.ShortDesc = ShortDesc;
 592
 593    if(available_patches.size() == 0)
 594    {
 595       // we are done (yeah!)
 596       Finish(true);
 597    }
 598    else
 599    {
 600       // get the next diff
 601       State = StateFetchDiff;
 602       QueueNextDiff();
 603    }
 604 }
 605                                                                         /*}}}*/
 606 void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig *Cnf)     /*{{{*/
 607 {
 608    if(Debug)
 609       std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << std::endl
 610                 << "Falling back to normal index file aquire" << std::endl;
 611    new pkgAcqIndex(Owner, RealURI, Description,Desc.ShortDesc,
 612                    ExpectedHash);
 613    Finish();
 614 }
 615                                                                         /*}}}*/
 616 // Finish - helper that cleans the item out of the fetcher queue        /*{{{*/
 617 void pkgAcqIndexDiffs::Finish(bool allDone)
 618 {
 619    // we restore the original name, this is required, otherwise
 620    // the file will be cleaned
 621    if(allDone)
 622    {
 623       DestFile = _config->FindDir("Dir::State::lists");
 624       DestFile += URItoFileName(RealURI);
 625
 626       if(!ExpectedHash.empty() && !ExpectedHash.VerifyFile(DestFile))
 627       {
 628          Status = StatAuthError;
 629          ErrorText = _("MD5Sum mismatch");
 630          Rename(DestFile,DestFile + ".FAILED");
 631          Dequeue();
 632          return;
 633       }
 634
 635       // this is for the "real" finish
 636       Complete = true;
 637       Status = StatDone;
 638       Dequeue();
 639       if(Debug)
 640          std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
 641       return;
 642    }
 643
 644    if(Debug)
 645       std::clog << "Finishing: " << Desc.URI << std::endl;
 646    Complete = false;
 647    Status = StatDone;
 648    Dequeue();
 649    return;
 650 }
 651                                                                         /*}}}*/
 652 bool pkgAcqIndexDiffs::QueueNextDiff()                                  /*{{{*/
 653 {
 654
 655    // calc sha1 of the just patched file
 656    string FinalFile = _config->FindDir("Dir::State::lists");
 657    FinalFile += URItoFileName(RealURI);
 658
 659    FileFd fd(FinalFile, FileFd::ReadOnly);
 660    SHA1Summation SHA1;
 661    SHA1.AddFD(fd.Fd(), fd.Size());
 662    string local_sha1 = string(SHA1.Result());
 663    if(Debug)
 664       std::clog << "QueueNextDiff: "
 665                 << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 666
 667    // final file reached before all patches are applied
 668    if(local_sha1 == ServerSha1)
 669    {
 670       Finish(true);
 671       return true;
 672    }
 673
 674    // remove all patches until the next matching patch is found
 675    // this requires the Index file to be ordered
 676    for(vector<DiffInfo>::iterator I=available_patches.begin();
 677        available_patches.size() > 0 &&
 678           I != available_patches.end() &&
 679           (*I).sha1 != local_sha1;
 680        I++)
 681    {
 682       available_patches.erase(I);
 683    }
 684
 685    // error checking and falling back if no patch was found
 686    if(available_patches.size() == 0)
 687    {
 688       Failed("", NULL);
 689       return false;
 690    }
 691
 692    // queue the right diff
 693    Desc.URI = string(RealURI) + ".diff/" + available_patches[0].file + ".gz";
 694    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
 695    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 696    DestFile += URItoFileName(RealURI + ".diff/" + available_patches[0].file);
 697
 698    if(Debug)
 699       std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
 700
 701    QueueURI(Desc);
 702
 703    return true;
 704 }
 705                                                                         /*}}}*/
 706 void pkgAcqIndexDiffs::Done(string Message,unsigned long Size,string Md5Hash,   /*{{{*/
 707                             pkgAcquire::MethodConfig *Cnf)
 708 {
 709    if(Debug)
 710       std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
 711
 712    Item::Done(Message,Size,Md5Hash,Cnf);
 713
 714    string FinalFile;
 715    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 716
 717    // sucess in downloading a diff, enter ApplyDiff state
 718    if(State == StateFetchDiff)
 719    {
 720
 721       // rred excepts the patch as $FinalFile.ed
 722       Rename(DestFile,FinalFile+".ed");
 723
 724       if(Debug)
 725          std::clog << "Sending to rred method: " << FinalFile << std::endl;
 726
 727       State = StateApplyDiff;
 728       Local = true;
 729       Desc.URI = "rred:" + FinalFile;
 730       QueueURI(Desc);
 731       Mode = "rred";
 732       return;
 733    }
 734
 735
 736    // success in download/apply a diff, queue next (if needed)
 737    if(State == StateApplyDiff)
 738    {
 739       // remove the just applied patch
 740       available_patches.erase(available_patches.begin());
 741
 742       // move into place
 743       if(Debug)
 744       {
 745          std::clog << "Moving patched file in place: " << std::endl
 746                    << DestFile << " -> " << FinalFile << std::endl;
 747       }
 748       Rename(DestFile,FinalFile);
 749       chmod(FinalFile.c_str(),0644);
 750
 751       // see if there is more to download
 752       if(available_patches.size() > 0) {
 753          new pkgAcqIndexDiffs(Owner, RealURI, Description, Desc.ShortDesc,
 754                               ExpectedHash, ServerSha1, available_patches);
 755          return Finish();
 756       } else
 757          return Finish(true);
 758    }
 759 }
 760                                                                         /*}}}*/
 761 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 762 // ---------------------------------------------------------------------
 763 /* The package file is added to the queue and a second class is
 764    instantiated to fetch the revision file */
 765 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 766                          string URI,string URIDesc,string ShortDesc,
 767                          HashString ExpectedHash, string comprExt)
 768    : Item(Owner), RealURI(URI), ExpectedHash(ExpectedHash)
 769 {
 770    if(comprExt.empty() == true)
 771    {
 772       // autoselect the compression method
 773       std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 774       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 775          comprExt.append(*t).append(" ");
 776       if (comprExt.empty() == false)
 777          comprExt.erase(comprExt.end()-1);
 778    }
 779    CompressionExtension = comprExt;
 780
 781    Init(URI, URIDesc, ShortDesc);
 782 }
 783 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner, IndexTarget const *Target,
 784                          HashString const &ExpectedHash, indexRecords const *MetaIndexParser)
 785    : Item(Owner), RealURI(Target->URI), ExpectedHash(ExpectedHash)
 786 {
 787    // autoselect the compression method
 788    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 789    CompressionExtension = "";
 790    if (ExpectedHash.empty() == false)
 791    {
 792       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 793          if (*t == "uncompressed" || MetaIndexParser->Exists(string(Target->MetaKey).append(".").append(*t)) == true)
 794             CompressionExtension.append(*t).append(" ");
 795    }
 796    else
 797    {
 798       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
 799          CompressionExtension.append(*t).append(" ");
 800    }
 801    if (CompressionExtension.empty() == false)
 802       CompressionExtension.erase(CompressionExtension.end()-1);
 803
 804    Init(Target->URI, Target->Description, Target->ShortDesc);
 805 }
 806                                                                         /*}}}*/
 807 // AcqIndex::Init - defered Constructor                                 /*{{{*/
 808 void pkgAcqIndex::Init(string const &URI, string const &URIDesc, string const &ShortDesc) {
 809    Decompression = false;
 810    Erase = false;
 811
 812    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 813    DestFile += URItoFileName(URI);
 814
 815    std::string const comprExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
 816    if (comprExt == "uncompressed")
 817       Desc.URI = URI;
 818    else
 819       Desc.URI = URI + '.' + comprExt;
 820
 821    Desc.Description = URIDesc;
 822    Desc.Owner = this;
 823    Desc.ShortDesc = ShortDesc;
 824
 825    QueueURI(Desc);
 826 }
 827                                                                         /*}}}*/
 828 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 829 // ---------------------------------------------------------------------
 830 /* The only header we use is the last-modified header. */
 831 string pkgAcqIndex::Custom600Headers()
 832 {
 833    string Final = _config->FindDir("Dir::State::lists");
 834    Final += URItoFileName(RealURI);
 835    if (_config->FindB("Acquire::GzipIndexes",false))
 836       Final += ".gz";
 837
 838    struct stat Buf;
 839    if (stat(Final.c_str(),&Buf) != 0)
 840       return "\nIndex-File: true";
 841    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 842 }
 843                                                                         /*}}}*/
 844 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)  /*{{{*/
 845 {
 846    size_t const nextExt = CompressionExtension.find(' ');
 847    if (nextExt != std::string::npos)
 848    {
 849       CompressionExtension = CompressionExtension.substr(nextExt+1);
 850       Init(RealURI, Desc.Description, Desc.ShortDesc);
 851       return;
 852    }
 853
 854    // on decompression failure, remove bad versions in partial/
 855    if (Decompression && Erase) {
 856       string s = _config->FindDir("Dir::State::lists") + "partial/";
 857       s.append(URItoFileName(RealURI));
 858       unlink(s.c_str());
 859    }
 860
 861    Item::Failed(Message,Cnf);
 862 }
 863                                                                         /*}}}*/
 864 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 865 // ---------------------------------------------------------------------
 866 /* This goes through a number of states.. On the initial fetch the
 867    method could possibly return an alternate filename which points
 868    to the uncompressed version of the file. If this is so the file
 869    is copied into the partial directory. In all other cases the file
 870    is decompressed with a gzip uri. */
 871 void pkgAcqIndex::Done(string Message,unsigned long Size,string Hash,
 872                        pkgAcquire::MethodConfig *Cfg)
 873 {
 874    Item::Done(Message,Size,Hash,Cfg);
 875
 876    if (Decompression == true)
 877    {
 878       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 879       {
 880          std::cerr << std::endl << RealURI << ": Computed Hash: " << Hash;
 881          std::cerr << "  Expected Hash: " << ExpectedHash.toStr() << std::endl;
 882       }
 883
 884       if (!ExpectedHash.empty() && ExpectedHash.toStr() != Hash)
 885       {
 886          Status = StatAuthError;
 887          ErrorText = _("Hash Sum mismatch");
 888          Rename(DestFile,DestFile + ".FAILED");
 889          ReportMirrorFailure("HashChecksumFailure");
 890          return;
 891       }
 892       // Done, move it into position
 893       string FinalFile = _config->FindDir("Dir::State::lists");
 894       FinalFile += URItoFileName(RealURI);
 895       Rename(DestFile,FinalFile);
 896       chmod(FinalFile.c_str(),0644);
 897
 898       /* We restore the original name to DestFile so that the clean operation
 899          will work OK */
 900       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 901       DestFile += URItoFileName(RealURI);
 902
 903       // Remove the compressed version.
 904       if (Erase == true)
 905          unlink(DestFile.c_str());
 906       return;
 907    }
 908
 909    Erase = false;
 910    Complete = true;
 911
 912    // Handle the unzipd case
 913    string FileName = LookupTag(Message,"Alt-Filename");
 914    if (FileName.empty() == false)
 915    {
 916       // The files timestamp matches
 917       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 918          return;
 919       Decompression = true;
 920       Local = true;
 921       DestFile += ".decomp";
 922       Desc.URI = "copy:" + FileName;
 923       QueueURI(Desc);
 924       Mode = "copy";
 925       return;
 926    }
 927
 928    FileName = LookupTag(Message,"Filename");
 929    if (FileName.empty() == true)
 930    {
 931       Status = StatError;
 932       ErrorText = "Method gave a blank filename";
 933    }
 934
 935    std::string const compExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
 936
 937    // The files timestamp matches
 938    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true) {
 939        if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz")
 940           // Update DestFile for .gz suffix so that the clean operation keeps it
 941           DestFile += ".gz";
 942       return;
 943     }
 944
 945    if (FileName == DestFile)
 946       Erase = true;
 947    else
 948       Local = true;
 949
 950    string decompProg;
 951
 952    // If we enable compressed indexes and already have gzip, keep it
 953    if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz" && !Local) {
 954       string FinalFile = _config->FindDir("Dir::State::lists");
 955       FinalFile += URItoFileName(RealURI) + ".gz";
 956       Rename(DestFile,FinalFile);
 957       chmod(FinalFile.c_str(),0644);
 958
 959       // Update DestFile for .gz suffix so that the clean operation keeps it
 960       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 961       DestFile += URItoFileName(RealURI) + ".gz";
 962       return;
 963     }
 964
 965    // get the binary name for your used compression type
 966    decompProg = _config->Find(string("Acquire::CompressionTypes::").append(compExt),"");
 967    if(decompProg.empty() == false);
 968    else if(compExt == "uncompressed")
 969       decompProg = "copy";
 970    else {
 971       _error->Error("Unsupported extension: %s", compExt.c_str());
 972       return;
 973    }
 974
 975    Decompression = true;
 976    DestFile += ".decomp";
 977    Desc.URI = decompProg + ":" + FileName;
 978    QueueURI(Desc);
 979    Mode = decompProg.c_str();
 980 }
 981                                                                         /*}}}*/
 982 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                        /*{{{*/
 983 // ---------------------------------------------------------------------
 984 /* The Translation file is added to the queue */
 985 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 986                             string URI,string URIDesc,string ShortDesc)
 987   : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashString(), "")
 988 {
 989 }
 990 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner, IndexTarget const *Target,
 991                          HashString const &ExpectedHash, indexRecords const *MetaIndexParser)
 992   : pkgAcqIndex(Owner, Target, ExpectedHash, MetaIndexParser)
 993 {
 994 }
 995                                                                         /*}}}*/
 996 // AcqIndexTrans::Custom600Headers - Insert custom request headers      /*{{{*/
 997 // ---------------------------------------------------------------------
 998 string pkgAcqIndexTrans::Custom600Headers()
 999 {
1000    string Final = _config->FindDir("Dir::State::lists");
1001    Final += URItoFileName(RealURI);
1002
1003    struct stat Buf;
1004    if (stat(Final.c_str(),&Buf) != 0)
1005       return "\nFail-Ignore: true";
1006    return "\nFail-Ignore: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1007 }
1008                                                                         /*}}}*/
1009 // AcqIndexTrans::Failed - Silence failure messages for missing files   /*{{{*/
1010 // ---------------------------------------------------------------------
1011 /* */
1012 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1013 {
1014    size_t const nextExt = CompressionExtension.find(' ');
1015    if (nextExt != std::string::npos)
1016    {
1017       CompressionExtension = CompressionExtension.substr(nextExt+1);
1018       Init(RealURI, Desc.Description, Desc.ShortDesc);
1019       Status = StatIdle;
1020       return;
1021    }
1022
1023    if (Cnf->LocalOnly == true ||
1024        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
1025    {
1026       // Ignore this
1027       Status = StatDone;
1028       Complete = false;
1029       Dequeue();
1030       return;
1031    }
1032
1033    Item::Failed(Message,Cnf);
1034 }
1035                                                                         /*}}}*/
1036 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,                         /*{{{*/
1037                              string URI,string URIDesc,string ShortDesc,
1038                              string MetaIndexURI, string MetaIndexURIDesc,
1039                              string MetaIndexShortDesc,
1040                              const vector<IndexTarget*>* IndexTargets,
1041                              indexRecords* MetaIndexParser) :
1042    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
1043    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
1044    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
1045 {
1046    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1047    DestFile += URItoFileName(URI);
1048
1049    // remove any partial downloaded sig-file in partial/.
1050    // it may confuse proxies and is too small to warrant a
1051    // partial download anyway
1052    unlink(DestFile.c_str());
1053
1054    // Create the item
1055    Desc.Description = URIDesc;
1056    Desc.Owner = this;
1057    Desc.ShortDesc = ShortDesc;
1058    Desc.URI = URI;
1059
1060    string Final = _config->FindDir("Dir::State::lists");
1061    Final += URItoFileName(RealURI);
1062    struct stat Buf;
1063    if (stat(Final.c_str(),&Buf) == 0)
1064    {
1065       // File was already in place.  It needs to be re-downloaded/verified
1066       // because Release might have changed, we do give it a differnt
1067       // name than DestFile because otherwise the http method will
1068       // send If-Range requests and there are too many broken servers
1069       // out there that do not understand them
1070       LastGoodSig = DestFile+".reverify";
1071       Rename(Final,LastGoodSig);
1072    }
1073
1074    QueueURI(Desc);
1075 }
1076                                                                         /*}}}*/
1077 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
1078 // ---------------------------------------------------------------------
1079 /* The only header we use is the last-modified header. */
1080 string pkgAcqMetaSig::Custom600Headers()
1081 {
1082    struct stat Buf;
1083    if (stat(LastGoodSig.c_str(),&Buf) != 0)
1084       return "\nIndex-File: true";
1085
1086    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1087 }
1088
1089 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
1090                          pkgAcquire::MethodConfig *Cfg)
1091 {
1092    Item::Done(Message,Size,MD5,Cfg);
1093
1094    string FileName = LookupTag(Message,"Filename");
1095    if (FileName.empty() == true)
1096    {
1097       Status = StatError;
1098       ErrorText = "Method gave a blank filename";
1099       return;
1100    }
1101
1102    if (FileName != DestFile)
1103    {
1104       // We have to copy it into place
1105       Local = true;
1106       Desc.URI = "copy:" + FileName;
1107       QueueURI(Desc);
1108       return;
1109    }
1110
1111    Complete = true;
1112
1113    // put the last known good file back on i-m-s hit (it will
1114    // be re-verified again)
1115    // Else do nothing, we have the new file in DestFile then
1116    if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1117       Rename(LastGoodSig, DestFile);
1118
1119    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
1120    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc,
1121                        MetaIndexShortDesc,  DestFile, IndexTargets,
1122                        MetaIndexParser);
1123
1124 }
1125                                                                         /*}}}*/
1126 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
1127 {
1128    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
1129
1130    // if we get a network error we fail gracefully
1131    if(Status == StatTransientNetworkError)
1132    {
1133       Item::Failed(Message,Cnf);
1134       // move the sigfile back on transient network failures
1135       if(FileExists(LastGoodSig))
1136          Rename(LastGoodSig,Final);
1137
1138       // set the status back to , Item::Failed likes to reset it
1139       Status = pkgAcquire::Item::StatTransientNetworkError;
1140       return;
1141    }
1142
1143    // Delete any existing sigfile when the acquire failed
1144    unlink(Final.c_str());
1145
1146    // queue a pkgAcqMetaIndex with no sigfile
1147    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
1148                        "", IndexTargets, MetaIndexParser);
1149
1150    if (Cnf->LocalOnly == true ||
1151        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
1152    {
1153       // Ignore this
1154       Status = StatDone;
1155       Complete = false;
1156       Dequeue();
1157       return;
1158    }
1159
1160    Item::Failed(Message,Cnf);
1161 }
1162                                                                         /*}}}*/
1163 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                     /*{{{*/
1164                                  string URI,string URIDesc,string ShortDesc,
1165                                  string SigFile,
1166                                  const vector<struct IndexTarget*>* IndexTargets,
1167                                  indexRecords* MetaIndexParser) :
1168    Item(Owner), RealURI(URI), SigFile(SigFile), IndexTargets(IndexTargets),
1169    MetaIndexParser(MetaIndexParser), AuthPass(false), IMSHit(false)
1170 {
1171    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
1172    DestFile += URItoFileName(URI);
1173
1174    // Create the item
1175    Desc.Description = URIDesc;
1176    Desc.Owner = this;
1177    Desc.ShortDesc = ShortDesc;
1178    Desc.URI = URI;
1179
1180    QueueURI(Desc);
1181 }
1182                                                                         /*}}}*/
1183 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
1184 // ---------------------------------------------------------------------
1185 /* The only header we use is the last-modified header. */
1186 string pkgAcqMetaIndex::Custom600Headers()
1187 {
1188    string Final = _config->FindDir("Dir::State::lists");
1189    Final += URItoFileName(RealURI);
1190
1191    struct stat Buf;
1192    if (stat(Final.c_str(),&Buf) != 0)
1193       return "\nIndex-File: true";
1194
1195    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
1196 }
1197                                                                         /*}}}*/
1198 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string Hash,       /*{{{*/
1199                            pkgAcquire::MethodConfig *Cfg)
1200 {
1201    Item::Done(Message,Size,Hash,Cfg);
1202
1203    // MetaIndexes are done in two passes: one to download the
1204    // metaindex with an appropriate method, and a second to verify it
1205    // with the gpgv method
1206
1207    if (AuthPass == true)
1208    {
1209       AuthDone(Message);
1210
1211       // all cool, move Release file into place
1212       Complete = true;
1213    }
1214    else
1215    {
1216       RetrievalDone(Message);
1217       if (!Complete)
1218          // Still more retrieving to do
1219          return;
1220
1221       if (SigFile == "")
1222       {
1223          // There was no signature file, so we are finished.  Download
1224          // the indexes without verification.
1225          QueueIndexes(false);
1226       }
1227       else
1228       {
1229          // There was a signature file, so pass it to gpgv for
1230          // verification
1231
1232          if (_config->FindB("Debug::pkgAcquire::Auth", false))
1233             std::cerr << "Metaindex acquired, queueing gpg verification ("
1234                       << SigFile << "," << DestFile << ")\n";
1235          AuthPass = true;
1236          Desc.URI = "gpgv:" + SigFile;
1237          QueueURI(Desc);
1238          Mode = "gpgv";
1239          return;
1240       }
1241    }
1242
1243    if (Complete == true)
1244    {
1245       string FinalFile = _config->FindDir("Dir::State::lists");
1246       FinalFile += URItoFileName(RealURI);
1247       if (SigFile == DestFile)
1248          SigFile = FinalFile;
1249       Rename(DestFile,FinalFile);
1250       chmod(FinalFile.c_str(),0644);
1251       DestFile = FinalFile;
1252    }
1253 }
1254                                                                         /*}}}*/
1255 void pkgAcqMetaIndex::RetrievalDone(string Message)                     /*{{{*/
1256 {
1257    // We have just finished downloading a Release file (it is not
1258    // verified yet)
1259
1260    string FileName = LookupTag(Message,"Filename");
1261    if (FileName.empty() == true)
1262    {
1263       Status = StatError;
1264       ErrorText = "Method gave a blank filename";
1265       return;
1266    }
1267
1268    if (FileName != DestFile)
1269    {
1270       Local = true;
1271       Desc.URI = "copy:" + FileName;
1272       QueueURI(Desc);
1273       return;
1274    }
1275
1276    // make sure to verify against the right file on I-M-S hit
1277    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
1278    if(IMSHit)
1279    {
1280       string FinalFile = _config->FindDir("Dir::State::lists");
1281       FinalFile += URItoFileName(RealURI);
1282       if (SigFile == DestFile)
1283          SigFile = FinalFile;
1284       DestFile = FinalFile;
1285    }
1286    Complete = true;
1287 }
1288                                                                         /*}}}*/
1289 void pkgAcqMetaIndex::AuthDone(string Message)                          /*{{{*/
1290 {
1291    // At this point, the gpgv method has succeeded, so there is a
1292    // valid signature from a key in the trusted keyring.  We
1293    // perform additional verification of its contents, and use them
1294    // to verify the indexes we are about to download
1295
1296    if (!MetaIndexParser->Load(DestFile))
1297    {
1298       Status = StatAuthError;
1299       ErrorText = MetaIndexParser->ErrorText;
1300       return;
1301    }
1302
1303    if (!VerifyVendor(Message))
1304    {
1305       return;
1306    }
1307
1308    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1309       std::cerr << "Signature verification succeeded: "
1310                 << DestFile << std::endl;
1311
1312    // Download further indexes with verification
1313    QueueIndexes(true);
1314
1315    // is it a clearsigned MetaIndex file?
1316    if (DestFile == SigFile)
1317       return;
1318
1319    // Done, move signature file into position
1320    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
1321       URItoFileName(RealURI) + ".gpg";
1322    Rename(SigFile,VerifiedSigFile);
1323    chmod(VerifiedSigFile.c_str(),0644);
1324 }
1325                                                                         /*}}}*/
1326 void pkgAcqMetaIndex::QueueIndexes(bool verify)                         /*{{{*/
1327 {
1328    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
1329         Target != IndexTargets->end();
1330         Target++)
1331    {
1332       HashString ExpectedIndexHash;
1333       if (verify)
1334       {
1335          const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
1336          if (Record == NULL)
1337          {
1338             if ((*Target)->IsOptional() == false)
1339             {
1340                Status = StatAuthError;
1341                strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), (*Target)->MetaKey.c_str());
1342                return;
1343             }
1344          }
1345          else
1346          {
1347             ExpectedIndexHash = Record->Hash;
1348             if (_config->FindB("Debug::pkgAcquire::Auth", false))
1349             {
1350                std::cerr << "Queueing: " << (*Target)->URI << std::endl;
1351                std::cerr << "Expected Hash: " << ExpectedIndexHash.toStr() << std::endl;
1352             }
1353             if (ExpectedIndexHash.empty() == true && (*Target)->IsOptional() == false)
1354             {
1355                Status = StatAuthError;
1356                strprintf(ErrorText, _("Unable to find hash sum for '%s' in Release file"), (*Target)->MetaKey.c_str());
1357                return;
1358             }
1359          }
1360       }
1361
1362       if ((*Target)->IsOptional() == true)
1363       {
1364          if ((*Target)->IsSubIndex() == true)
1365             new pkgAcqSubIndex(Owner, (*Target)->URI, (*Target)->Description,
1366                                 (*Target)->ShortDesc, ExpectedIndexHash);
1367          else
1368             new pkgAcqIndexTrans(Owner, *Target, ExpectedIndexHash, MetaIndexParser);
1369          continue;
1370       }
1371
1372       /* Queue Packages file (either diff or full packages files, depending
1373          on the users option) - we also check if the PDiff Index file is listed
1374          in the Meta-Index file. Ideal would be if pkgAcqDiffIndex would test this
1375          instead, but passing the required info to it is to much hassle */
1376       if(_config->FindB("Acquire::PDiffs",true) == true && (verify == false ||
1377           MetaIndexParser->Exists(string((*Target)->MetaKey).append(".diff/Index")) == true))
1378          new pkgAcqDiffIndex(Owner, (*Target)->URI, (*Target)->Description,
1379                              (*Target)->ShortDesc, ExpectedIndexHash);
1380       else
1381          new pkgAcqIndex(Owner, *Target, ExpectedIndexHash, MetaIndexParser);
1382    }
1383 }
1384                                                                         /*}}}*/
1385 bool pkgAcqMetaIndex::VerifyVendor(string Message)                      /*{{{*/
1386 {
1387 //    // Maybe this should be made available from above so we don't have
1388 //    // to read and parse it every time?
1389 //    pkgVendorList List;
1390 //    List.ReadMainList();
1391
1392 //    const Vendor* Vndr = NULL;
1393 //    for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
1394 //    {
1395 //       string::size_type pos = (*I).find("VALIDSIG ");
1396 //       if (_config->FindB("Debug::Vendor", false))
1397 //          std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
1398 //                    << std::endl;
1399 //       if (pos != std::string::npos)
1400 //       {
1401 //          string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
1402 //          if (_config->FindB("Debug::Vendor", false))
1403 //             std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
1404 //                std::endl;
1405 //          Vndr = List.FindVendor(Fingerprint) != "";
1406 //          if (Vndr != NULL);
1407 //          break;
1408 //       }
1409 //    }
1410    string::size_type pos;
1411
1412    // check for missing sigs (that where not fatal because otherwise we had
1413    // bombed earlier)
1414    string missingkeys;
1415    string msg = _("There is no public key available for the "
1416                   "following key IDs:\n");
1417    pos = Message.find("NO_PUBKEY ");
1418    if (pos != std::string::npos)
1419    {
1420       string::size_type start = pos+strlen("NO_PUBKEY ");
1421       string Fingerprint = Message.substr(start, Message.find("\n")-start);
1422       missingkeys += (Fingerprint);
1423    }
1424    if(!missingkeys.empty())
1425       _error->Warning("%s", string(msg+missingkeys).c_str());
1426
1427    string Transformed = MetaIndexParser->GetExpectedDist();
1428
1429    if (Transformed == "../project/experimental")
1430    {
1431       Transformed = "experimental";
1432    }
1433
1434    pos = Transformed.rfind('/');
1435    if (pos != string::npos)
1436    {
1437       Transformed = Transformed.substr(0, pos);
1438    }
1439
1440    if (Transformed == ".")
1441    {
1442       Transformed = "";
1443    }
1444
1445    if (_config->FindB("Acquire::Check-Valid-Until", true) == true &&
1446        MetaIndexParser->GetValidUntil() > 0) {
1447       time_t const invalid_since = time(NULL) - MetaIndexParser->GetValidUntil();
1448       if (invalid_since > 0)
1449          // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
1450          // the time since then the file is invalid - formated in the same way as in
1451          // the download progress display (e.g. 7d 3h 42min 1s)
1452          return _error->Error(_("Release file expired, ignoring %s (invalid since %s)"),
1453                               RealURI.c_str(), TimeToStr(invalid_since).c_str());
1454    }
1455
1456    if (_config->FindB("Debug::pkgAcquire::Auth", false))
1457    {
1458       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
1459       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
1460       std::cerr << "Transformed Dist: " << Transformed << std::endl;
1461    }
1462
1463    if (MetaIndexParser->CheckDist(Transformed) == false)
1464    {
1465       // This might become fatal one day
1466 //       Status = StatAuthError;
1467 //       ErrorText = "Conflicting distribution; expected "
1468 //          + MetaIndexParser->GetExpectedDist() + " but got "
1469 //          + MetaIndexParser->GetDist();
1470 //       return false;
1471       if (!Transformed.empty())
1472       {
1473          _error->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
1474                          Desc.Description.c_str(),
1475                          Transformed.c_str(),
1476                          MetaIndexParser->GetDist().c_str());
1477       }
1478    }
1479
1480    return true;
1481 }
1482                                                                         /*}}}*/
1483 // pkgAcqMetaIndex::Failed - no Release file present or no signature file present       /*{{{*/
1484 // ---------------------------------------------------------------------
1485 /* */
1486 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1487 {
1488    if (AuthPass == true)
1489    {
1490       // gpgv method failed, if we have a good signature
1491       string LastGoodSigFile = _config->FindDir("Dir::State::lists");
1492       if (DestFile == SigFile)
1493          LastGoodSigFile.append(URItoFileName(RealURI));
1494       else
1495          LastGoodSigFile.append("partial/").append(URItoFileName(RealURI)).append(".gpg.reverify");
1496
1497       if(FileExists(LastGoodSigFile))
1498       {
1499          if (DestFile != SigFile)
1500          {
1501             string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
1502                                         URItoFileName(RealURI) + ".gpg";
1503             Rename(LastGoodSigFile,VerifiedSigFile);
1504          }
1505          Status = StatTransientNetworkError;
1506          _error->Warning(_("A error occurred during the signature "
1507                            "verification. The repository is not updated "
1508                            "and the previous index files will be used. "
1509                            "GPG error: %s: %s\n"),
1510                          Desc.Description.c_str(),
1511                          LookupTag(Message,"Message").c_str());
1512          RunScripts("APT::Update::Auth-Failure");
1513          return;
1514       } else {
1515          _error->Warning(_("GPG error: %s: %s"),
1516                          Desc.Description.c_str(),
1517                          LookupTag(Message,"Message").c_str());
1518       }
1519       // gpgv method failed
1520       ReportMirrorFailure("GPGFailure");
1521    }
1522
1523    // No Release file was present, or verification failed, so fall
1524    // back to queueing Packages files without verification
1525    QueueIndexes(false);
1526 }
1527                                                                         /*}}}*/
1528 pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,               /*{{{*/
1529                 string const &URI, string const &URIDesc, string const &ShortDesc,
1530                 string const &MetaIndexURI, string const &MetaIndexURIDesc, string const &MetaIndexShortDesc,
1531                 string const &MetaSigURI, string const &MetaSigURIDesc, string const &MetaSigShortDesc,
1532                 const vector<struct IndexTarget*>* IndexTargets,
1533                 indexRecords* MetaIndexParser) :
1534         pkgAcqMetaIndex(Owner, URI, URIDesc, ShortDesc, "", IndexTargets, MetaIndexParser),
1535         MetaIndexURI(MetaIndexURI), MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
1536         MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc)
1537 {
1538    SigFile = DestFile;
1539 }
1540                                                                         /*}}}*/
1541 void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
1542 {
1543    if (AuthPass == false)
1544    {
1545       new pkgAcqMetaSig(Owner,
1546                         MetaSigURI, MetaSigURIDesc, MetaSigShortDesc,
1547                         MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
1548                         IndexTargets, MetaIndexParser);
1549       if (Cnf->LocalOnly == true ||
1550           StringToBool(LookupTag(Message, "Transient-Failure"), false) == false)
1551          Dequeue();
1552    }
1553    else
1554       pkgAcqMetaIndex::Failed(Message, Cnf);
1555 }
1556                                                                         /*}}}*/
1557 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
1558 // ---------------------------------------------------------------------
1559 /* This just sets up the initial fetch environment and queues the first
1560    possibilitiy */
1561 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
1562                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
1563                              string &StoreFilename) :
1564                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
1565                StoreFilename(StoreFilename), Vf(Version.FileList()),
1566                Trusted(false)
1567 {
1568    Retries = _config->FindI("Acquire::Retries",0);
1569
1570    if (Version.Arch() == 0)
1571    {
1572       _error->Error(_("I wasn't able to locate a file for the %s package. "
1573                       "This might mean you need to manually fix this package. "
1574                       "(due to missing arch)"),
1575                     Version.ParentPkg().Name());
1576       return;
1577    }
1578
1579    /* We need to find a filename to determine the extension. We make the
1580       assumption here that all the available sources for this version share
1581       the same extension.. */
1582    // Skip not source sources, they do not have file fields.
1583    for (; Vf.end() == false; Vf++)
1584    {
1585       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1586          continue;
1587       break;
1588    }
1589
1590    // Does not really matter here.. we are going to fail out below
1591    if (Vf.end() != true)
1592    {
1593       // If this fails to get a file name we will bomb out below.
1594       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1595       if (_error->PendingError() == true)
1596          return;
1597
1598       // Generate the final file name as: package_version_arch.foo
1599       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
1600                       QuoteString(Version.VerStr(),"_:") + '_' +
1601                       QuoteString(Version.Arch(),"_:.") +
1602                       "." + flExtension(Parse.FileName());
1603    }
1604
1605    // check if we have one trusted source for the package. if so, switch
1606    // to "TrustedOnly" mode
1607    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++)
1608    {
1609       pkgIndexFile *Index;
1610       if (Sources->FindIndex(i.File(),Index) == false)
1611          continue;
1612       if (_config->FindB("Debug::pkgAcquire::Auth", false))
1613       {
1614          std::cerr << "Checking index: " << Index->Describe()
1615                    << "(Trusted=" << Index->IsTrusted() << ")\n";
1616       }
1617       if (Index->IsTrusted()) {
1618          Trusted = true;
1619          break;
1620       }
1621    }
1622
1623    // "allow-unauthenticated" restores apts old fetching behaviour
1624    // that means that e.g. unauthenticated file:// uris are higher
1625    // priority than authenticated http:// uris
1626    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
1627       Trusted = false;
1628
1629    // Select a source
1630    if (QueueNext() == false && _error->PendingError() == false)
1631       _error->Error(_("I wasn't able to locate file for the %s package. "
1632                     "This might mean you need to manually fix this package."),
1633                     Version.ParentPkg().Name());
1634 }
1635                                                                         /*}}}*/
1636 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
1637 // ---------------------------------------------------------------------
1638 /* This queues the next available file version for download. It checks if
1639    the archive is already available in the cache and stashs the MD5 for
1640    checking later. */
1641 bool pkgAcqArchive::QueueNext()
1642 {
1643    string const ForceHash = _config->Find("Acquire::ForceHash");
1644    for (; Vf.end() == false; Vf++)
1645    {
1646       // Ignore not source sources
1647       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
1648          continue;
1649
1650       // Try to cross match against the source list
1651       pkgIndexFile *Index;
1652       if (Sources->FindIndex(Vf.File(),Index) == false)
1653             continue;
1654
1655       // only try to get a trusted package from another source if that source
1656       // is also trusted
1657       if(Trusted && !Index->IsTrusted())
1658          continue;
1659
1660       // Grab the text package record
1661       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
1662       if (_error->PendingError() == true)
1663          return false;
1664
1665       string PkgFile = Parse.FileName();
1666       if (ForceHash.empty() == false)
1667       {
1668          if(stringcasecmp(ForceHash, "sha256") == 0)
1669             ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
1670          else if (stringcasecmp(ForceHash, "sha1") == 0)
1671             ExpectedHash = HashString("SHA1", Parse.SHA1Hash());
1672          else
1673             ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1674       }
1675       else
1676       {
1677          string Hash;
1678          if ((Hash = Parse.SHA256Hash()).empty() == false)
1679             ExpectedHash = HashString("SHA256", Hash);
1680          else if ((Hash = Parse.SHA1Hash()).empty() == false)
1681             ExpectedHash = HashString("SHA1", Hash);
1682          else
1683             ExpectedHash = HashString("MD5Sum", Parse.MD5Hash());
1684       }
1685       if (PkgFile.empty() == true)
1686          return _error->Error(_("The package index files are corrupted. No Filename: "
1687                               "field for package %s."),
1688                               Version.ParentPkg().Name());
1689
1690       Desc.URI = Index->ArchiveURI(PkgFile);
1691       Desc.Description = Index->ArchiveInfo(Version);
1692       Desc.Owner = this;
1693       Desc.ShortDesc = Version.ParentPkg().Name();
1694
1695       // See if we already have the file. (Legacy filenames)
1696       FileSize = Version->Size;
1697       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
1698       struct stat Buf;
1699       if (stat(FinalFile.c_str(),&Buf) == 0)
1700       {
1701          // Make sure the size matches
1702          if ((unsigned)Buf.st_size == Version->Size)
1703          {
1704             Complete = true;
1705             Local = true;
1706             Status = StatDone;
1707             StoreFilename = DestFile = FinalFile;
1708             return true;
1709          }
1710
1711          /* Hmm, we have a file and its size does not match, this means it is
1712             an old style mismatched arch */
1713          unlink(FinalFile.c_str());
1714       }
1715
1716       // Check it again using the new style output filenames
1717       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
1718       if (stat(FinalFile.c_str(),&Buf) == 0)
1719       {
1720          // Make sure the size matches
1721          if ((unsigned)Buf.st_size == Version->Size)
1722          {
1723             Complete = true;
1724             Local = true;
1725             Status = StatDone;
1726             StoreFilename = DestFile = FinalFile;
1727             return true;
1728          }
1729
1730          /* Hmm, we have a file and its size does not match, this shouldnt
1731             happen.. */
1732          unlink(FinalFile.c_str());
1733       }
1734
1735       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
1736
1737       // Check the destination file
1738       if (stat(DestFile.c_str(),&Buf) == 0)
1739       {
1740          // Hmm, the partial file is too big, erase it
1741          if ((unsigned)Buf.st_size > Version->Size)
1742             unlink(DestFile.c_str());
1743          else
1744             PartialSize = Buf.st_size;
1745       }
1746
1747       // Create the item
1748       Local = false;
1749       Desc.URI = Index->ArchiveURI(PkgFile);
1750       Desc.Description = Index->ArchiveInfo(Version);
1751       Desc.Owner = this;
1752       Desc.ShortDesc = Version.ParentPkg().Name();
1753       QueueURI(Desc);
1754
1755       Vf++;
1756       return true;
1757    }
1758    return false;
1759 }
1760                                                                         /*}}}*/
1761 // AcqArchive::Done - Finished fetching                                 /*{{{*/
1762 // ---------------------------------------------------------------------
1763 /* */
1764 void pkgAcqArchive::Done(string Message,unsigned long Size,string CalcHash,
1765                          pkgAcquire::MethodConfig *Cfg)
1766 {
1767    Item::Done(Message,Size,CalcHash,Cfg);
1768
1769    // Check the size
1770    if (Size != Version->Size)
1771    {
1772       Status = StatError;
1773       ErrorText = _("Size mismatch");
1774       return;
1775    }
1776
1777    // Check the hash
1778    if(ExpectedHash.toStr() != CalcHash)
1779    {
1780       Status = StatError;
1781       ErrorText = _("Hash Sum mismatch");
1782       if(FileExists(DestFile))
1783          Rename(DestFile,DestFile + ".FAILED");
1784       return;
1785    }
1786
1787    // Grab the output filename
1788    string FileName = LookupTag(Message,"Filename");
1789    if (FileName.empty() == true)
1790    {
1791       Status = StatError;
1792       ErrorText = "Method gave a blank filename";
1793       return;
1794    }
1795
1796    Complete = true;
1797
1798    // Reference filename
1799    if (FileName != DestFile)
1800    {
1801       StoreFilename = DestFile = FileName;
1802       Local = true;
1803       return;
1804    }
1805
1806    // Done, move it into position
1807    string FinalFile = _config->FindDir("Dir::Cache::Archives");
1808    FinalFile += flNotDir(StoreFilename);
1809    Rename(DestFile,FinalFile);
1810
1811    StoreFilename = DestFile = FinalFile;
1812    Complete = true;
1813 }
1814                                                                         /*}}}*/
1815 // AcqArchive::Failed - Failure handler                                 /*{{{*/
1816 // ---------------------------------------------------------------------
1817 /* Here we try other sources */
1818 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1819 {
1820    ErrorText = LookupTag(Message,"Message");
1821
1822    /* We don't really want to retry on failed media swaps, this prevents
1823       that. An interesting observation is that permanent failures are not
1824       recorded. */
1825    if (Cnf->Removable == true &&
1826        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1827    {
1828       // Vf = Version.FileList();
1829       while (Vf.end() == false) Vf++;
1830       StoreFilename = string();
1831       Item::Failed(Message,Cnf);
1832       return;
1833    }
1834
1835    if (QueueNext() == false)
1836    {
1837       // This is the retry counter
1838       if (Retries != 0 &&
1839           Cnf->LocalOnly == false &&
1840           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1841       {
1842          Retries--;
1843          Vf = Version.FileList();
1844          if (QueueNext() == true)
1845             return;
1846       }
1847
1848       StoreFilename = string();
1849       Item::Failed(Message,Cnf);
1850    }
1851 }
1852                                                                         /*}}}*/
1853 // AcqArchive::IsTrusted - Determine whether this archive comes from a trusted source /*{{{*/
1854 // ---------------------------------------------------------------------
1855 bool pkgAcqArchive::IsTrusted()
1856 {
1857    return Trusted;
1858 }
1859                                                                         /*}}}*/
1860 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1861 // ---------------------------------------------------------------------
1862 /* */
1863 void pkgAcqArchive::Finished()
1864 {
1865    if (Status == pkgAcquire::Item::StatDone &&
1866        Complete == true)
1867       return;
1868    StoreFilename = string();
1869 }
1870                                                                         /*}}}*/
1871 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1872 // ---------------------------------------------------------------------
1873 /* The file is added to the queue */
1874 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string Hash,
1875                        unsigned long Size,string Dsc,string ShortDesc,
1876                        const string &DestDir, const string &DestFilename,
1877                        bool IsIndexFile) :
1878                        Item(Owner), ExpectedHash(Hash), IsIndexFile(IsIndexFile)
1879 {
1880    Retries = _config->FindI("Acquire::Retries",0);
1881
1882    if(!DestFilename.empty())
1883       DestFile = DestFilename;
1884    else if(!DestDir.empty())
1885       DestFile = DestDir + "/" + flNotDir(URI);
1886    else
1887       DestFile = flNotDir(URI);
1888
1889    // Create the item
1890    Desc.URI = URI;
1891    Desc.Description = Dsc;
1892    Desc.Owner = this;
1893
1894    // Set the short description to the archive component
1895    Desc.ShortDesc = ShortDesc;
1896
1897    // Get the transfer sizes
1898    FileSize = Size;
1899    struct stat Buf;
1900    if (stat(DestFile.c_str(),&Buf) == 0)
1901    {
1902       // Hmm, the partial file is too big, erase it
1903       if ((unsigned)Buf.st_size > Size)
1904          unlink(DestFile.c_str());
1905       else
1906          PartialSize = Buf.st_size;
1907    }
1908
1909    QueueURI(Desc);
1910 }
1911                                                                         /*}}}*/
1912 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1913 // ---------------------------------------------------------------------
1914 /* */
1915 void pkgAcqFile::Done(string Message,unsigned long Size,string CalcHash,
1916                       pkgAcquire::MethodConfig *Cnf)
1917 {
1918    Item::Done(Message,Size,CalcHash,Cnf);
1919
1920    // Check the hash
1921    if(!ExpectedHash.empty() && ExpectedHash.toStr() != CalcHash)
1922    {
1923       Status = StatError;
1924       ErrorText = _("Hash Sum mismatch");
1925       Rename(DestFile,DestFile + ".FAILED");
1926       return;
1927    }
1928
1929    string FileName = LookupTag(Message,"Filename");
1930    if (FileName.empty() == true)
1931    {
1932       Status = StatError;
1933       ErrorText = "Method gave a blank filename";
1934       return;
1935    }
1936
1937    Complete = true;
1938
1939    // The files timestamp matches
1940    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1941       return;
1942
1943    // We have to copy it into place
1944    if (FileName != DestFile)
1945    {
1946       Local = true;
1947       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1948           Cnf->Removable == true)
1949       {
1950          Desc.URI = "copy:" + FileName;
1951          QueueURI(Desc);
1952          return;
1953       }
1954
1955       // Erase the file if it is a symlink so we can overwrite it
1956       struct stat St;
1957       if (lstat(DestFile.c_str(),&St) == 0)
1958       {
1959          if (S_ISLNK(St.st_mode) != 0)
1960             unlink(DestFile.c_str());
1961       }
1962
1963       // Symlink the file
1964       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1965       {
1966          ErrorText = "Link to " + DestFile + " failure ";
1967          Status = StatError;
1968          Complete = false;
1969       }
1970    }
1971 }
1972                                                                         /*}}}*/
1973 // AcqFile::Failed - Failure handler                                    /*{{{*/
1974 // ---------------------------------------------------------------------
1975 /* Here we try other sources */
1976 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1977 {
1978    ErrorText = LookupTag(Message,"Message");
1979
1980    // This is the retry counter
1981    if (Retries != 0 &&
1982        Cnf->LocalOnly == false &&
1983        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1984    {
1985       Retries--;
1986       QueueURI(Desc);
1987       return;
1988    }
1989
1990    Item::Failed(Message,Cnf);
1991 }
1992                                                                         /*}}}*/
1993 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
1994 // ---------------------------------------------------------------------
1995 /* The only header we use is the last-modified header. */
1996 string pkgAcqFile::Custom600Headers()
1997 {
1998    if (IsIndexFile)
1999       return "\nIndex-File: true";
2000    return "";
2001 }
2002                                                                         /*}}}*/
2003 bool IndexTarget::IsOptional() const {
2004    if (strncmp(ShortDesc.c_str(), "Translation", 11) != 0)
2005       return false;
2006    return true;
2007 }
2008 bool IndexTarget::IsSubIndex() const {
2009    if (ShortDesc != "TranslationIndex")
2010       return false;
2011    return true;
2012 }