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