apt-pkg/acquire-item.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire-item.cc,v 1.46.2.9 2004/01/16 18:51:11 mdz Exp $
   4 /* ######################################################################
   5
   6    Acquire Item - Item to acquire
   7
   8    Each item can download to exactly one file at a time. This means you
   9    cannot create an item that fetches two uri's to two files at the same
  10    time. The pkgAcqIndex class creates a second class upon instantiation
  11    to fetch the other index files because of this.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #ifdef __GNUG__
  17 #pragma implementation "apt-pkg/acquire-item.h"
  18 #endif
  19 #include <apt-pkg/acquire-item.h>
  20 #include <apt-pkg/configuration.h>
  21 #include <apt-pkg/sourcelist.h>
  22 #include <apt-pkg/vendorlist.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/strutl.h>
  25 #include <apt-pkg/fileutl.h>
  26 #include <apt-pkg/md5.h>
  27
  28 #include <apti18n.h>
  29
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <string>
  34 #include <stdio.h>
  35                                                                         /*}}}*/
  36
  37 using namespace std;
  38
  39 // Acquire::Item::Item - Constructor                                    /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* */
  42 pkgAcquire::Item::Item(pkgAcquire *Owner) : Owner(Owner), FileSize(0),
  43                        PartialSize(0), Mode(0), ID(0), Complete(false),
  44                        Local(false), QueueCounter(0)
  45 {
  46    Owner->Add(this);
  47    Status = StatIdle;
  48 }
  49                                                                         /*}}}*/
  50 // Acquire::Item::~Item - Destructor                                    /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* */
  53 pkgAcquire::Item::~Item()
  54 {
  55    Owner->Remove(this);
  56 }
  57                                                                         /*}}}*/
  58 // Acquire::Item::Failed - Item failed to download                      /*{{{*/
  59 // ---------------------------------------------------------------------
  60 /* We return to an idle state if there are still other queues that could
  61    fetch this object */
  62 void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
  63 {
  64    Status = StatIdle;
  65    ErrorText = LookupTag(Message,"Message");
  66    if (QueueCounter <= 1)
  67    {
  68       /* This indicates that the file is not available right now but might
  69          be sometime later. If we do a retry cycle then this should be
  70          retried [CDROMs] */
  71       if (Cnf->LocalOnly == true &&
  72           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
  73       {
  74          Status = StatIdle;
  75          Dequeue();
  76          return;
  77       }
  78
  79       Status = StatError;
  80       Dequeue();
  81    }
  82 }
  83                                                                         /*}}}*/
  84 // Acquire::Item::Start - Item has begun to download                    /*{{{*/
  85 // ---------------------------------------------------------------------
  86 /* Stash status and the file size. Note that setting Complete means
  87    sub-phases of the acquire process such as decompresion are operating */
  88 void pkgAcquire::Item::Start(string /*Message*/,unsigned long Size)
  89 {
  90    Status = StatFetching;
  91    if (FileSize == 0 && Complete == false)
  92       FileSize = Size;
  93 }
  94                                                                         /*}}}*/
  95 // Acquire::Item::Done - Item downloaded OK                             /*{{{*/
  96 // ---------------------------------------------------------------------
  97 /* */
  98 void pkgAcquire::Item::Done(string Message,unsigned long Size,string,
  99                             pkgAcquire::MethodConfig *Cnf)
 100 {
 101    // We just downloaded something..
 102    string FileName = LookupTag(Message,"Filename");
 103    if (Complete == false && FileName == DestFile)
 104    {
 105       if (Owner->Log != 0)
 106          Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
 107    }
 108
 109    if (FileSize == 0)
 110       FileSize= Size;
 111
 112    Status = StatDone;
 113    ErrorText = string();
 114    Owner->Dequeue(this);
 115 }
 116                                                                         /*}}}*/
 117 // Acquire::Item::Rename - Rename a file                                /*{{{*/
 118 // ---------------------------------------------------------------------
 119 /* This helper function is used by alot of item methods as thier final
 120    step */
 121 void pkgAcquire::Item::Rename(string From,string To)
 122 {
 123    if (rename(From.c_str(),To.c_str()) != 0)
 124    {
 125       char S[300];
 126       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
 127               From.c_str(),To.c_str());
 128       Status = StatError;
 129       ErrorText = S;
 130    }
 131 }
 132                                                                         /*}}}*/
 133
 134 // AcqIndex::AcqIndex - Constructor                                     /*{{{*/
 135 // ---------------------------------------------------------------------
 136 /* The package file is added to the queue and a second class is
 137    instantiated to fetch the revision file */
 138 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 139                          string URI,string URIDesc,string ShortDesc,
 140                          string ExpectedMD5, string comprExt) :
 141    Item(Owner), RealURI(URI), ExpectedMD5(ExpectedMD5)
 142 {
 143    Decompression = false;
 144    Erase = false;
 145
 146    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 147    DestFile += URItoFileName(URI);
 148
 149    if(comprExt.empty())
 150    {
 151       // autoselect the compression method
 152       if(FileExists("/bin/bzip2"))
 153          CompressionExtension = ".bz2";
 154       else
 155          CompressionExtension = ".gz";
 156    } else {
 157       CompressionExtension = comprExt;
 158    }
 159    Desc.URI = URI + CompressionExtension;
 160
 161    Desc.Description = URIDesc;
 162    Desc.Owner = this;
 163    Desc.ShortDesc = ShortDesc;
 164
 165    QueueURI(Desc);
 166 }
 167                                                                         /*}}}*/
 168 // AcqIndex::Custom600Headers - Insert custom request headers           /*{{{*/
 169 // ---------------------------------------------------------------------
 170 /* The only header we use is the last-modified header. */
 171 string pkgAcqIndex::Custom600Headers()
 172 {
 173    string Final = _config->FindDir("Dir::State::lists");
 174    Final += URItoFileName(RealURI);
 175
 176    struct stat Buf;
 177    if (stat(Final.c_str(),&Buf) != 0)
 178       return "\nIndex-File: true";
 179
 180    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 181 }
 182                                                                         /*}}}*/
 183
 184 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 185 {
 186    // no .bz2 found, retry with .gz
 187    if(Desc.URI.substr(Desc.URI.size()-3) == "bz2") {
 188       Desc.URI = Desc.URI.substr(0,Desc.URI.size()-3) + "gz";
 189
 190       // retry with a gzip one
 191       new pkgAcqIndex(Owner, RealURI, Desc.Description,Desc.ShortDesc,
 192                       ExpectedMD5, string(".gz"));
 193       Status = StatDone;
 194       Complete = false;
 195       Dequeue();
 196       return;
 197    }
 198
 199
 200    Item::Failed(Message,Cnf);
 201 }
 202
 203
 204 // AcqIndex::Done - Finished a fetch                                    /*{{{*/
 205 // ---------------------------------------------------------------------
 206 /* This goes through a number of states.. On the initial fetch the
 207    method could possibly return an alternate filename which points
 208    to the uncompressed version of the file. If this is so the file
 209    is copied into the partial directory. In all other cases the file
 210    is decompressed with a gzip uri. */
 211 void pkgAcqIndex::Done(string Message,unsigned long Size,string MD5,
 212                        pkgAcquire::MethodConfig *Cfg)
 213 {
 214    Item::Done(Message,Size,MD5,Cfg);
 215
 216    if (Decompression == true)
 217    {
 218       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 219       {
 220          std::cerr << std::endl << RealURI << ": Computed MD5: " << MD5;
 221          std::cerr << "  Expected MD5: " << ExpectedMD5 << std::endl;
 222       }
 223
 224       if (MD5.empty())
 225       {
 226          MD5Summation sum;
 227          FileFd Fd(DestFile, FileFd::ReadOnly);
 228          sum.AddFD(Fd.Fd(), Fd.Size());
 229          Fd.Close();
 230          MD5 = (string)sum.Result();
 231       }
 232
 233       if (!ExpectedMD5.empty() && MD5 != ExpectedMD5)
 234       {
 235          Status = StatAuthError;
 236          ErrorText = _("MD5Sum mismatch");
 237          Rename(DestFile,DestFile + ".FAILED");
 238          return;
 239       }
 240       // Done, move it into position
 241       string FinalFile = _config->FindDir("Dir::State::lists");
 242       FinalFile += URItoFileName(RealURI);
 243       Rename(DestFile,FinalFile);
 244       chmod(FinalFile.c_str(),0644);
 245
 246       /* We restore the original name to DestFile so that the clean operation
 247          will work OK */
 248       DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 249       DestFile += URItoFileName(RealURI);
 250
 251       // Remove the compressed version.
 252       if (Erase == true)
 253          unlink(DestFile.c_str());
 254       return;
 255    }
 256
 257    Erase = false;
 258    Complete = true;
 259
 260    // Handle the unzipd case
 261    string FileName = LookupTag(Message,"Alt-Filename");
 262    if (FileName.empty() == false)
 263    {
 264       // The files timestamp matches
 265       if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
 266       {
 267          unlink(FileName.c_str());
 268          return;
 269       }
 270       Decompression = true;
 271       Local = true;
 272       DestFile += ".decomp";
 273       Desc.URI = "copy:" + FileName;
 274       QueueURI(Desc);
 275       Mode = "copy";
 276       return;
 277    }
 278
 279    FileName = LookupTag(Message,"Filename");
 280    if (FileName.empty() == true)
 281    {
 282       Status = StatError;
 283       ErrorText = "Method gave a blank filename";
 284    }
 285
 286    // The files timestamp matches
 287    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
 288    {
 289       unlink(FileName.c_str());
 290       return;
 291    }
 292
 293    if (FileName == DestFile)
 294       Erase = true;
 295    else
 296       Local = true;
 297
 298    string compExt = Desc.URI.substr(Desc.URI.size()-3);
 299    char *decompProg;
 300    if(compExt == "bz2")
 301       decompProg = "bzip2";
 302    else if(compExt == ".gz")
 303       decompProg = "gzip";
 304    else {
 305       _error->Error("Unsupported extension: %s", compExt.c_str());
 306       return;
 307    }
 308
 309    Decompression = true;
 310    DestFile += ".decomp";
 311    Desc.URI = string(decompProg) + ":" + FileName;
 312    QueueURI(Desc);
 313    Mode = decompProg;
 314 }
 315
 316 pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
 317                              string URI,string URIDesc,string ShortDesc,
 318                              string MetaIndexURI, string MetaIndexURIDesc,
 319                              string MetaIndexShortDesc,
 320                              const vector<IndexTarget*>* IndexTargets,
 321                              indexRecords* MetaIndexParser) :
 322    Item(Owner), RealURI(URI), MetaIndexURI(MetaIndexURI),
 323    MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
 324    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets)
 325 {
 326    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 327    DestFile += URItoFileName(URI);
 328
 329    // remove any partial downloaded sig-file. it may confuse proxies
 330    // and is too small to warrant a partial download anyway
 331    unlink(DestFile.c_str());
 332
 333    // Create the item
 334    Desc.Description = URIDesc;
 335    Desc.Owner = this;
 336    Desc.ShortDesc = ShortDesc;
 337    Desc.URI = URI;
 338
 339
 340    string Final = _config->FindDir("Dir::State::lists");
 341    Final += URItoFileName(RealURI);
 342    struct stat Buf;
 343    if (stat(Final.c_str(),&Buf) == 0)
 344    {
 345       // File was already in place.  It needs to be re-verified
 346       // because Release might have changed, so Move it into partial
 347       Rename(Final,DestFile);
 348    }
 349
 350    QueueURI(Desc);
 351 }
 352                                                                         /*}}}*/
 353 // pkgAcqMetaSig::Custom600Headers - Insert custom request headers      /*{{{*/
 354 // ---------------------------------------------------------------------
 355 /* The only header we use is the last-modified header. */
 356 string pkgAcqMetaSig::Custom600Headers()
 357 {
 358    struct stat Buf;
 359    if (stat(DestFile.c_str(),&Buf) != 0)
 360       return "\nIndex-File: true";
 361
 362    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 363 }
 364
 365 void pkgAcqMetaSig::Done(string Message,unsigned long Size,string MD5,
 366                          pkgAcquire::MethodConfig *Cfg)
 367 {
 368    Item::Done(Message,Size,MD5,Cfg);
 369
 370    string FileName = LookupTag(Message,"Filename");
 371    if (FileName.empty() == true)
 372    {
 373       Status = StatError;
 374       ErrorText = "Method gave a blank filename";
 375       return;
 376    }
 377
 378    if (FileName != DestFile)
 379    {
 380       // We have to copy it into place
 381       Local = true;
 382       Desc.URI = "copy:" + FileName;
 383       QueueURI(Desc);
 384       return;
 385    }
 386
 387    Complete = true;
 388
 389    // queue a pkgAcqMetaIndex to be verified against the sig we just retrieved
 390    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 391                        DestFile, IndexTargets, MetaIndexParser);
 392
 393 }
 394                                                                         /*}}}*/
 395 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 396 {
 397
 398    // if we get a network error we fail gracefully
 399    if(LookupTag(Message,"FailReason") == "Timeout" ||
 400       LookupTag(Message,"FailReason") == "TmpResolveFailure" ||
 401       LookupTag(Message,"FailReason") == "ConnectionRefused") {
 402       Item::Failed(Message,Cnf);
 403       return;
 404    }
 405
 406    // Delete any existing sigfile when the acquire failed
 407    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 408    unlink(Final.c_str());
 409
 410    // queue a pkgAcqMetaIndex with no sigfile
 411    new pkgAcqMetaIndex(Owner, MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 412                        "", IndexTargets, MetaIndexParser);
 413
 414    if (Cnf->LocalOnly == true ||
 415        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
 416    {
 417       // Ignore this
 418       Status = StatDone;
 419       Complete = false;
 420       Dequeue();
 421       return;
 422    }
 423
 424    Item::Failed(Message,Cnf);
 425 }
 426
 427 pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,
 428                                  string URI,string URIDesc,string ShortDesc,
 429                                  string SigFile,
 430                                  const vector<struct IndexTarget*>* IndexTargets,
 431                                  indexRecords* MetaIndexParser) :
 432    Item(Owner), RealURI(URI), SigFile(SigFile), AuthPass(false),
 433    MetaIndexParser(MetaIndexParser), IndexTargets(IndexTargets), IMSHit(false)
 434 {
 435    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 436    DestFile += URItoFileName(URI);
 437
 438    // Create the item
 439    Desc.Description = URIDesc;
 440    Desc.Owner = this;
 441    Desc.ShortDesc = ShortDesc;
 442    Desc.URI = URI;
 443
 444    QueueURI(Desc);
 445 }
 446
 447                                                                         /*}}}*/
 448 // pkgAcqMetaIndex::Custom600Headers - Insert custom request headers    /*{{{*/
 449 // ---------------------------------------------------------------------
 450 /* The only header we use is the last-modified header. */
 451 string pkgAcqMetaIndex::Custom600Headers()
 452 {
 453    string Final = _config->FindDir("Dir::State::lists");
 454    Final += URItoFileName(RealURI);
 455
 456    struct stat Buf;
 457    if (stat(Final.c_str(),&Buf) != 0)
 458       return "\nIndex-File: true";
 459
 460    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 461 }
 462
 463 void pkgAcqMetaIndex::Done(string Message,unsigned long Size,string MD5,
 464                            pkgAcquire::MethodConfig *Cfg)
 465 {
 466    Item::Done(Message,Size,MD5,Cfg);
 467
 468    // MetaIndexes are done in two passes: one to download the
 469    // metaindex with an appropriate method, and a second to verify it
 470    // with the gpgv method
 471
 472    if (AuthPass == true)
 473    {
 474       AuthDone(Message);
 475    }
 476    else
 477    {
 478       RetrievalDone(Message);
 479       if (!Complete)
 480          // Still more retrieving to do
 481          return;
 482
 483       if (SigFile == "")
 484       {
 485          // There was no signature file, so we are finished.  Download
 486          // the indexes without verification.
 487          QueueIndexes(false);
 488       }
 489       else
 490       {
 491          // There was a signature file, so pass it to gpgv for
 492          // verification
 493
 494          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 495             std::cerr << "Metaindex acquired, queueing gpg verification ("
 496                       << SigFile << "," << DestFile << ")\n";
 497          AuthPass = true;
 498          Desc.URI = "gpgv:" + SigFile;
 499          QueueURI(Desc);
 500          Mode = "gpgv";
 501       }
 502    }
 503 }
 504
 505 void pkgAcqMetaIndex::RetrievalDone(string Message)
 506 {
 507    // We have just finished downloading a Release file (it is not
 508    // verified yet)
 509
 510    string FileName = LookupTag(Message,"Filename");
 511    if (FileName.empty() == true)
 512    {
 513       Status = StatError;
 514       ErrorText = "Method gave a blank filename";
 515       return;
 516    }
 517
 518    if (FileName != DestFile)
 519    {
 520       Local = true;
 521       Desc.URI = "copy:" + FileName;
 522       QueueURI(Desc);
 523       return;
 524    }
 525
 526    // see if the download was a IMSHit
 527    IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
 528    Complete = true;
 529
 530    string FinalFile = _config->FindDir("Dir::State::lists");
 531    FinalFile += URItoFileName(RealURI);
 532
 533    // If we get a IMS hit we can remove the empty file in partial
 534    // othersie we move the file in place
 535    if (IMSHit)
 536       unlink(DestFile.c_str());
 537    else
 538       Rename(DestFile,FinalFile);
 539
 540    chmod(FinalFile.c_str(),0644);
 541    DestFile = FinalFile;
 542 }
 543
 544 void pkgAcqMetaIndex::AuthDone(string Message)
 545 {
 546    // At this point, the gpgv method has succeeded, so there is a
 547    // valid signature from a key in the trusted keyring.  We
 548    // perform additional verification of its contents, and use them
 549    // to verify the indexes we are about to download
 550
 551    if (!MetaIndexParser->Load(DestFile))
 552    {
 553       Status = StatAuthError;
 554       ErrorText = MetaIndexParser->ErrorText;
 555       return;
 556    }
 557
 558    if (!VerifyVendor(Message))
 559    {
 560       return;
 561    }
 562
 563    if (_config->FindB("Debug::pkgAcquire::Auth", false))
 564       std::cerr << "Signature verification succeeded: "
 565                 << DestFile << std::endl;
 566
 567    // Download further indexes with verification
 568    QueueIndexes(true);
 569
 570    // Done, move signature file into position
 571
 572    string VerifiedSigFile = _config->FindDir("Dir::State::lists") +
 573       URItoFileName(RealURI) + ".gpg";
 574    Rename(SigFile,VerifiedSigFile);
 575    chmod(VerifiedSigFile.c_str(),0644);
 576 }
 577
 578 void pkgAcqMetaIndex::QueueIndexes(bool verify)
 579 {
 580    for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
 581         Target != IndexTargets->end();
 582         Target++)
 583    {
 584       string ExpectedIndexMD5;
 585       if (verify)
 586       {
 587          const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
 588          if (!Record)
 589          {
 590             Status = StatAuthError;
 591             ErrorText = "Unable to find expected entry  "
 592                + (*Target)->MetaKey + " in Meta-index file (malformed Release file?)";
 593             return;
 594          }
 595          ExpectedIndexMD5 = Record->MD5Hash;
 596          if (_config->FindB("Debug::pkgAcquire::Auth", false))
 597          {
 598             std::cerr << "Queueing: " << (*Target)->URI << std::endl;
 599             std::cerr << "Expected MD5: " << ExpectedIndexMD5 << std::endl;
 600          }
 601          if (ExpectedIndexMD5.empty())
 602          {
 603             Status = StatAuthError;
 604             ErrorText = "Unable to find MD5 sum for "
 605                + (*Target)->MetaKey + " in Meta-index file";
 606             return;
 607          }
 608       }
 609
 610       // Queue Packages file
 611       new pkgAcqIndex(Owner, (*Target)->URI, (*Target)->Description,
 612                       (*Target)->ShortDesc, ExpectedIndexMD5);
 613    }
 614 }
 615
 616 bool pkgAcqMetaIndex::VerifyVendor(string Message)
 617 {
 618 //    // Maybe this should be made available from above so we don't have
 619 //    // to read and parse it every time?
 620 //    pkgVendorList List;
 621 //    List.ReadMainList();
 622
 623 //    const Vendor* Vndr = NULL;
 624 //    for (std::vector<string>::const_iterator I = GPGVOutput.begin(); I != GPGVOutput.end(); I++)
 625 //    {
 626 //       string::size_type pos = (*I).find("VALIDSIG ");
 627 //       if (_config->FindB("Debug::Vendor", false))
 628 //          std::cerr << "Looking for VALIDSIG in \"" << (*I) << "\": pos " << pos
 629 //                    << std::endl;
 630 //       if (pos != std::string::npos)
 631 //       {
 632 //          string Fingerprint = (*I).substr(pos+sizeof("VALIDSIG"));
 633 //          if (_config->FindB("Debug::Vendor", false))
 634 //             std::cerr << "Looking for \"" << Fingerprint << "\" in vendor..." <<
 635 //                std::endl;
 636 //          Vndr = List.FindVendor(Fingerprint) != "";
 637 //          if (Vndr != NULL);
 638 //          break;
 639 //       }
 640 //    }
 641    string::size_type pos;
 642
 643    // check for missing sigs (that where not fatal because otherwise we had
 644    // bombed earlier)
 645    string missingkeys;
 646    string msg = _("There is no public key available for the "
 647                   "following key IDs:\n");
 648    pos = Message.find("NO_PUBKEY ");
 649    if (pos != std::string::npos)
 650    {
 651       string::size_type start = pos+strlen("NO_PUBKEY ");
 652       string Fingerprint = Message.substr(start, Message.find("\n")-start);
 653       missingkeys += (Fingerprint);
 654    }
 655    if(!missingkeys.empty())
 656       _error->Warning("%s", string(msg+missingkeys).c_str());
 657
 658    string Transformed = MetaIndexParser->GetExpectedDist();
 659
 660    if (Transformed == "../project/experimental")
 661    {
 662       Transformed = "experimental";
 663    }
 664
 665    pos = Transformed.rfind('/');
 666    if (pos != string::npos)
 667    {
 668       Transformed = Transformed.substr(0, pos);
 669    }
 670
 671    if (Transformed == ".")
 672    {
 673       Transformed = "";
 674    }
 675
 676    if (_config->FindB("Debug::pkgAcquire::Auth", false))
 677    {
 678       std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
 679       std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
 680       std::cerr << "Transformed Dist: " << Transformed << std::endl;
 681    }
 682
 683    if (MetaIndexParser->CheckDist(Transformed) == false)
 684    {
 685       // This might become fatal one day
 686 //       Status = StatAuthError;
 687 //       ErrorText = "Conflicting distribution; expected "
 688 //          + MetaIndexParser->GetExpectedDist() + " but got "
 689 //          + MetaIndexParser->GetDist();
 690 //       return false;
 691       if (!Transformed.empty())
 692       {
 693          _error->Warning("Conflicting distribution: %s (expected %s but got %s)",
 694                          Desc.Description.c_str(),
 695                          Transformed.c_str(),
 696                          MetaIndexParser->GetDist().c_str());
 697       }
 698    }
 699
 700    return true;
 701 }
 702                                                                 /*}}}*/
 703 // pkgAcqMetaIndex::Failed - no Release file present or no signature
 704 //      file present                                            /*{{{*/
 705 // ---------------------------------------------------------------------
 706 /* */
 707 void pkgAcqMetaIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 708 {
 709    if (AuthPass == true)
 710    {
 711       // if we fail the authentication but got the file via a IMS-Hit
 712       // this means that the file wasn't downloaded and that it might be
 713       // just stale (server problem, proxy etc). we delete what we have
 714       // queue it again without i-m-s
 715       // alternatively we could just unlink the file and let the user try again
 716       if (IMSHit)
 717       {
 718          Complete = false;
 719          Local = false;
 720          AuthPass = false;
 721          unlink(DestFile.c_str());
 722
 723          DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 724          DestFile += URItoFileName(RealURI);
 725          Desc.URI = RealURI;
 726          QueueURI(Desc);
 727          return;
 728       }
 729
 730       // gpgv method failed
 731       _error->Warning("GPG error: %s: %s",
 732                       Desc.Description.c_str(),
 733                       LookupTag(Message,"Message").c_str());
 734
 735    }
 736
 737    // No Release file was present, or verification failed, so fall
 738    // back to queueing Packages files without verification
 739    QueueIndexes(false);
 740 }
 741
 742                                                                         /*}}}*/
 743
 744 // AcqArchive::AcqArchive - Constructor                                 /*{{{*/
 745 // ---------------------------------------------------------------------
 746 /* This just sets up the initial fetch environment and queues the first
 747    possibilitiy */
 748 pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
 749                              pkgRecords *Recs,pkgCache::VerIterator const &Version,
 750                              string &StoreFilename) :
 751                Item(Owner), Version(Version), Sources(Sources), Recs(Recs),
 752                StoreFilename(StoreFilename), Vf(Version.FileList()),
 753                Trusted(false)
 754 {
 755    Retries = _config->FindI("Acquire::Retries",0);
 756
 757    if (Version.Arch() == 0)
 758    {
 759       _error->Error(_("I wasn't able to locate a file for the %s package. "
 760                       "This might mean you need to manually fix this package. "
 761                       "(due to missing arch)"),
 762                     Version.ParentPkg().Name());
 763       return;
 764    }
 765
 766    /* We need to find a filename to determine the extension. We make the
 767       assumption here that all the available sources for this version share
 768       the same extension.. */
 769    // Skip not source sources, they do not have file fields.
 770    for (; Vf.end() == false; Vf++)
 771    {
 772       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
 773          continue;
 774       break;
 775    }
 776
 777    // Does not really matter here.. we are going to fail out below
 778    if (Vf.end() != true)
 779    {
 780       // If this fails to get a file name we will bomb out below.
 781       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
 782       if (_error->PendingError() == true)
 783          return;
 784
 785       // Generate the final file name as: package_version_arch.foo
 786       StoreFilename = QuoteString(Version.ParentPkg().Name(),"_:") + '_' +
 787                       QuoteString(Version.VerStr(),"_:") + '_' +
 788                       QuoteString(Version.Arch(),"_:.") +
 789                       "." + flExtension(Parse.FileName());
 790    }
 791
 792    // check if we have one trusted source for the package. if so, switch
 793    // to "TrustedOnly" mode
 794    for (pkgCache::VerFileIterator i = Version.FileList(); i.end() == false; i++)
 795    {
 796       pkgIndexFile *Index;
 797       if (Sources->FindIndex(i.File(),Index) == false)
 798          continue;
 799       if (_config->FindB("Debug::pkgAcquire::Auth", false))
 800       {
 801          std::cerr << "Checking index: " << Index->Describe()
 802                    << "(Trusted=" << Index->IsTrusted() << ")\n";
 803       }
 804       if (Index->IsTrusted()) {
 805          Trusted = true;
 806          break;
 807       }
 808    }
 809
 810    // "allow-unauthenticated" restores apts old fetching behaviour
 811    // that means that e.g. unauthenticated file:// uris are higher
 812    // priority than authenticated http:// uris
 813    if (_config->FindB("APT::Get::AllowUnauthenticated",false) == true)
 814       Trusted = false;
 815
 816    // Select a source
 817    if (QueueNext() == false && _error->PendingError() == false)
 818       _error->Error(_("I wasn't able to locate file for the %s package. "
 819                     "This might mean you need to manually fix this package."),
 820                     Version.ParentPkg().Name());
 821 }
 822                                                                         /*}}}*/
 823 // AcqArchive::QueueNext - Queue the next file source                   /*{{{*/
 824 // ---------------------------------------------------------------------
 825 /* This queues the next available file version for download. It checks if
 826    the archive is already available in the cache and stashs the MD5 for
 827    checking later. */
 828 bool pkgAcqArchive::QueueNext()
 829 {
 830    for (; Vf.end() == false; Vf++)
 831    {
 832       // Ignore not source sources
 833       if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
 834          continue;
 835
 836       // Try to cross match against the source list
 837       pkgIndexFile *Index;
 838       if (Sources->FindIndex(Vf.File(),Index) == false)
 839             continue;
 840
 841       // only try to get a trusted package from another source if that source
 842       // is also trusted
 843       if(Trusted && !Index->IsTrusted())
 844          continue;
 845
 846       // Grab the text package record
 847       pkgRecords::Parser &Parse = Recs->Lookup(Vf);
 848       if (_error->PendingError() == true)
 849          return false;
 850
 851       string PkgFile = Parse.FileName();
 852       MD5 = Parse.MD5Hash();
 853       if (PkgFile.empty() == true)
 854          return _error->Error(_("The package index files are corrupted. No Filename: "
 855                               "field for package %s."),
 856                               Version.ParentPkg().Name());
 857
 858       Desc.URI = Index->ArchiveURI(PkgFile);
 859       Desc.Description = Index->ArchiveInfo(Version);
 860       Desc.Owner = this;
 861       Desc.ShortDesc = Version.ParentPkg().Name();
 862
 863       // See if we already have the file. (Legacy filenames)
 864       FileSize = Version->Size;
 865       string FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(PkgFile);
 866       struct stat Buf;
 867       if (stat(FinalFile.c_str(),&Buf) == 0)
 868       {
 869          // Make sure the size matches
 870          if ((unsigned)Buf.st_size == Version->Size)
 871          {
 872             Complete = true;
 873             Local = true;
 874             Status = StatDone;
 875             StoreFilename = DestFile = FinalFile;
 876             return true;
 877          }
 878
 879          /* Hmm, we have a file and its size does not match, this means it is
 880             an old style mismatched arch */
 881          unlink(FinalFile.c_str());
 882       }
 883
 884       // Check it again using the new style output filenames
 885       FinalFile = _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
 886       if (stat(FinalFile.c_str(),&Buf) == 0)
 887       {
 888          // Make sure the size matches
 889          if ((unsigned)Buf.st_size == Version->Size)
 890          {
 891             Complete = true;
 892             Local = true;
 893             Status = StatDone;
 894             StoreFilename = DestFile = FinalFile;
 895             return true;
 896          }
 897
 898          /* Hmm, we have a file and its size does not match, this shouldnt
 899             happen.. */
 900          unlink(FinalFile.c_str());
 901       }
 902
 903       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
 904
 905       // Check the destination file
 906       if (stat(DestFile.c_str(),&Buf) == 0)
 907       {
 908          // Hmm, the partial file is too big, erase it
 909          if ((unsigned)Buf.st_size > Version->Size)
 910             unlink(DestFile.c_str());
 911          else
 912             PartialSize = Buf.st_size;
 913       }
 914
 915       // Create the item
 916       Local = false;
 917       Desc.URI = Index->ArchiveURI(PkgFile);
 918       Desc.Description = Index->ArchiveInfo(Version);
 919       Desc.Owner = this;
 920       Desc.ShortDesc = Version.ParentPkg().Name();
 921       QueueURI(Desc);
 922
 923       Vf++;
 924       return true;
 925    }
 926    return false;
 927 }
 928                                                                         /*}}}*/
 929 // AcqArchive::Done - Finished fetching                                 /*{{{*/
 930 // ---------------------------------------------------------------------
 931 /* */
 932 void pkgAcqArchive::Done(string Message,unsigned long Size,string Md5Hash,
 933                          pkgAcquire::MethodConfig *Cfg)
 934 {
 935    Item::Done(Message,Size,Md5Hash,Cfg);
 936
 937    // Check the size
 938    if (Size != Version->Size)
 939    {
 940       Status = StatError;
 941       ErrorText = _("Size mismatch");
 942       return;
 943    }
 944
 945    // Check the md5
 946    if (Md5Hash.empty() == false && MD5.empty() == false)
 947    {
 948       if (Md5Hash != MD5)
 949       {
 950          Status = StatError;
 951          ErrorText = _("MD5Sum mismatch");
 952          if(FileExists(DestFile))
 953             Rename(DestFile,DestFile + ".FAILED");
 954          return;
 955       }
 956    }
 957
 958    // Grab the output filename
 959    string FileName = LookupTag(Message,"Filename");
 960    if (FileName.empty() == true)
 961    {
 962       Status = StatError;
 963       ErrorText = "Method gave a blank filename";
 964       return;
 965    }
 966
 967    Complete = true;
 968
 969    // Reference filename
 970    if (FileName != DestFile)
 971    {
 972       StoreFilename = DestFile = FileName;
 973       Local = true;
 974       return;
 975    }
 976
 977    // Done, move it into position
 978    string FinalFile = _config->FindDir("Dir::Cache::Archives");
 979    FinalFile += flNotDir(StoreFilename);
 980    Rename(DestFile,FinalFile);
 981
 982    StoreFilename = DestFile = FinalFile;
 983    Complete = true;
 984 }
 985                                                                         /*}}}*/
 986 // AcqArchive::Failed - Failure handler                                 /*{{{*/
 987 // ---------------------------------------------------------------------
 988 /* Here we try other sources */
 989 void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 990 {
 991    ErrorText = LookupTag(Message,"Message");
 992
 993    /* We don't really want to retry on failed media swaps, this prevents
 994       that. An interesting observation is that permanent failures are not
 995       recorded. */
 996    if (Cnf->Removable == true &&
 997        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
 998    {
 999       // Vf = Version.FileList();
1000       while (Vf.end() == false) Vf++;
1001       StoreFilename = string();
1002       Item::Failed(Message,Cnf);
1003       return;
1004    }
1005
1006    if (QueueNext() == false)
1007    {
1008       // This is the retry counter
1009       if (Retries != 0 &&
1010           Cnf->LocalOnly == false &&
1011           StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1012       {
1013          Retries--;
1014          Vf = Version.FileList();
1015          if (QueueNext() == true)
1016             return;
1017       }
1018
1019       StoreFilename = string();
1020       Item::Failed(Message,Cnf);
1021    }
1022 }
1023                                                                         /*}}}*/
1024 // AcqArchive::IsTrusted - Determine whether this archive comes from a
1025 // trusted source                                                       /*{{{*/
1026 // ---------------------------------------------------------------------
1027 bool pkgAcqArchive::IsTrusted()
1028 {
1029    return Trusted;
1030 }
1031
1032 // AcqArchive::Finished - Fetching has finished, tidy up                /*{{{*/
1033 // ---------------------------------------------------------------------
1034 /* */
1035 void pkgAcqArchive::Finished()
1036 {
1037    if (Status == pkgAcquire::Item::StatDone &&
1038        Complete == true)
1039       return;
1040    StoreFilename = string();
1041 }
1042                                                                         /*}}}*/
1043
1044 // AcqFile::pkgAcqFile - Constructor                                    /*{{{*/
1045 // ---------------------------------------------------------------------
1046 /* The file is added to the queue */
1047 pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI,string MD5,
1048                        unsigned long Size,string Dsc,string ShortDesc,
1049                        const string &DestDir, const string &DestFilename) :
1050                        Item(Owner), Md5Hash(MD5)
1051 {
1052    Retries = _config->FindI("Acquire::Retries",0);
1053
1054    if(!DestFilename.empty())
1055       DestFile = DestFilename;
1056    else if(!DestDir.empty())
1057       DestFile = DestDir + "/" + flNotDir(URI);
1058    else
1059       DestFile = flNotDir(URI);
1060
1061    // Create the item
1062    Desc.URI = URI;
1063    Desc.Description = Dsc;
1064    Desc.Owner = this;
1065
1066    // Set the short description to the archive component
1067    Desc.ShortDesc = ShortDesc;
1068
1069    // Get the transfer sizes
1070    FileSize = Size;
1071    struct stat Buf;
1072    if (stat(DestFile.c_str(),&Buf) == 0)
1073    {
1074       // Hmm, the partial file is too big, erase it
1075       if ((unsigned)Buf.st_size > Size)
1076          unlink(DestFile.c_str());
1077       else
1078          PartialSize = Buf.st_size;
1079    }
1080
1081    QueueURI(Desc);
1082 }
1083                                                                         /*}}}*/
1084 // AcqFile::Done - Item downloaded OK                                   /*{{{*/
1085 // ---------------------------------------------------------------------
1086 /* */
1087 void pkgAcqFile::Done(string Message,unsigned long Size,string MD5,
1088                       pkgAcquire::MethodConfig *Cnf)
1089 {
1090    // Check the md5
1091    if (Md5Hash.empty() == false && MD5.empty() == false)
1092    {
1093       if (Md5Hash != MD5)
1094       {
1095          Status = StatError;
1096          ErrorText = "MD5Sum mismatch";
1097          Rename(DestFile,DestFile + ".FAILED");
1098          return;
1099       }
1100    }
1101
1102    Item::Done(Message,Size,MD5,Cnf);
1103
1104    string FileName = LookupTag(Message,"Filename");
1105    if (FileName.empty() == true)
1106    {
1107       Status = StatError;
1108       ErrorText = "Method gave a blank filename";
1109       return;
1110    }
1111
1112    Complete = true;
1113
1114    // The files timestamp matches
1115    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
1116       return;
1117
1118    // We have to copy it into place
1119    if (FileName != DestFile)
1120    {
1121       Local = true;
1122       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
1123           Cnf->Removable == true)
1124       {
1125          Desc.URI = "copy:" + FileName;
1126          QueueURI(Desc);
1127          return;
1128       }
1129
1130       // Erase the file if it is a symlink so we can overwrite it
1131       struct stat St;
1132       if (lstat(DestFile.c_str(),&St) == 0)
1133       {
1134          if (S_ISLNK(St.st_mode) != 0)
1135             unlink(DestFile.c_str());
1136       }
1137
1138       // Symlink the file
1139       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
1140       {
1141          ErrorText = "Link to " + DestFile + " failure ";
1142          Status = StatError;
1143          Complete = false;
1144       }
1145    }
1146 }
1147                                                                         /*}}}*/
1148 // AcqFile::Failed - Failure handler                                    /*{{{*/
1149 // ---------------------------------------------------------------------
1150 /* Here we try other sources */
1151 void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
1152 {
1153    ErrorText = LookupTag(Message,"Message");
1154
1155    // This is the retry counter
1156    if (Retries != 0 &&
1157        Cnf->LocalOnly == false &&
1158        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
1159    {
1160       Retries--;
1161       QueueURI(Desc);
1162       return;
1163    }
1164
1165    Item::Failed(Message,Cnf);
1166 }
1167                                                                         /*}}}*/