apt-pkg/indexcopy.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: indexcopy.cc,v 1.10 2002/03/26 07:38:58 jgg Exp $
   4 /* ######################################################################
   5
   6    Index Copying - Aid for copying and verifying the index files
   7
   8    This class helps apt-cache reconstruct a damaged index files.
   9
  10    ##################################################################### */
  11                                                                         /*}}}*/
  12 // Include Files                                                        /*{{{*/
  13 #include<config.h>
  14
  15 #include <apt-pkg/error.h>
  16 #include <apt-pkg/progress.h>
  17 #include <apt-pkg/strutl.h>
  18 #include <apt-pkg/fileutl.h>
  19 #include <apt-pkg/aptconfiguration.h>
  20 #include <apt-pkg/configuration.h>
  21 #include <apt-pkg/tagfile.h>
  22 #include <apt-pkg/indexrecords.h>
  23 #include <apt-pkg/md5.h>
  24 #include <apt-pkg/cdrom.h>
  25
  26 #include <iostream>
  27 #include <sstream>
  28 #include <unistd.h>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <fcntl.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34
  35 #include "indexcopy.h"
  36 #include <apti18n.h>
  37                                                                         /*}}}*/
  38
  39 using namespace std;
  40
  41 // IndexCopy::CopyPackages - Copy the package files from the CD         /*{{{*/
  42 // ---------------------------------------------------------------------
  43 /* */
  44 bool IndexCopy::CopyPackages(string CDROM,string Name,vector<string> &List,
  45                              pkgCdromStatus *log)
  46 {
  47    OpProgress *Progress = NULL;
  48    if (List.empty() == true)
  49       return true;
  50
  51    if(log)
  52       Progress = log->GetOpProgress();
  53
  54    bool NoStat = _config->FindB("APT::CDROM::Fast",false);
  55    bool Debug = _config->FindB("Debug::aptcdrom",false);
  56
  57    // Prepare the progress indicator
  58    off_t TotalSize = 0;
  59    std::vector<APT::Configuration::Compressor> const compressor = APT::Configuration::getCompressors();
  60    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
  61    {
  62       struct stat Buf;
  63       bool found = false;
  64       std::string file = std::string(*I).append(GetFileName());
  65       for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
  66            c != compressor.end(); ++c)
  67       {
  68          if (stat(std::string(file + c->Extension).c_str(), &Buf) != 0)
  69             continue;
  70          found = true;
  71          break;
  72       }
  73
  74       if (found == false)
  75          return _error->Errno("stat", "Stat failed for %s", file.c_str());
  76       TotalSize += Buf.st_size;
  77    }
  78
  79    off_t CurrentSize = 0;
  80    unsigned int NotFound = 0;
  81    unsigned int WrongSize = 0;
  82    unsigned int Packages = 0;
  83    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
  84    {
  85       string OrigPath = string(*I,CDROM.length());
  86
  87       // Open the package file
  88       FileFd Pkg(*I + GetFileName(), FileFd::ReadOnly, FileFd::Auto);
  89       off_t const FileSize = Pkg.Size();
  90
  91       pkgTagFile Parser(&Pkg);
  92       if (_error->PendingError() == true)
  93          return false;
  94
  95       // Open the output file
  96       char S[400];
  97       snprintf(S,sizeof(S),"cdrom:[%s]/%s%s",Name.c_str(),
  98                (*I).c_str() + CDROM.length(),GetFileName());
  99       string TargetF = _config->FindDir("Dir::State::lists") + "partial/";
 100       TargetF += URItoFileName(S);
 101       FileFd Target;
 102       if (_config->FindB("APT::CDROM::NoAct",false) == true)
 103       {
 104          TargetF = "/dev/null";
 105          Target.Open(TargetF,FileFd::WriteExists);
 106       } else {
 107          Target.Open(TargetF,FileFd::WriteAtomic);
 108       }
 109       FILE *TargetFl = fdopen(dup(Target.Fd()),"w");
 110       if (_error->PendingError() == true)
 111          return false;
 112       if (TargetFl == 0)
 113          return _error->Errno("fdopen","Failed to reopen fd");
 114
 115       // Setup the progress meter
 116       if(Progress)
 117          Progress->OverallProgress(CurrentSize,TotalSize,FileSize,
 118                                    string("Reading ") + Type() + " Indexes");
 119
 120       // Parse
 121       if(Progress)
 122          Progress->SubProgress(Pkg.Size());
 123       pkgTagSection Section;
 124       this->Section = &Section;
 125       string Prefix;
 126       unsigned long Hits = 0;
 127       unsigned long Chop = 0;
 128       while (Parser.Step(Section) == true)
 129       {
 130          if(Progress)
 131             Progress->Progress(Parser.Offset());
 132          string File;
 133          unsigned long long Size;
 134          if (GetFile(File,Size) == false)
 135          {
 136             fclose(TargetFl);
 137             return false;
 138          }
 139
 140          if (Chop != 0)
 141             File = OrigPath + ChopDirs(File,Chop);
 142
 143          // See if the file exists
 144          if (NoStat == false || Hits < 10)
 145          {
 146             // Attempt to fix broken structure
 147             if (Hits == 0)
 148             {
 149                if (ReconstructPrefix(Prefix,OrigPath,CDROM,File) == false &&
 150                    ReconstructChop(Chop,*I,File) == false)
 151                {
 152                   if (Debug == true)
 153                      clog << "Missed: " << File << endl;
 154                   NotFound++;
 155                   continue;
 156                }
 157                if (Chop != 0)
 158                   File = OrigPath + ChopDirs(File,Chop);
 159             }
 160
 161             // Get the size
 162             struct stat Buf;
 163             if (stat(string(CDROM + Prefix + File).c_str(),&Buf) != 0 ||
 164                 Buf.st_size == 0)
 165             {
 166                bool Mangled = false;
 167                // Attempt to fix busted symlink support for one instance
 168                string OrigFile = File;
 169                string::size_type Start = File.find("binary-");
 170                string::size_type End = File.find("/",Start+3);
 171                if (Start != string::npos && End != string::npos)
 172                {
 173                   File.replace(Start,End-Start,"binary-all");
 174                   Mangled = true;
 175                }
 176
 177                if (Mangled == false ||
 178                    stat(string(CDROM + Prefix + File).c_str(),&Buf) != 0)
 179                {
 180                   if (Debug == true)
 181                      clog << "Missed(2): " << OrigFile << endl;
 182                   NotFound++;
 183                   continue;
 184                }
 185             }
 186
 187             // Size match
 188             if ((unsigned long long)Buf.st_size != Size)
 189             {
 190                if (Debug == true)
 191                   clog << "Wrong Size: " << File << endl;
 192                WrongSize++;
 193                continue;
 194             }
 195          }
 196
 197          Packages++;
 198          Hits++;
 199
 200          if (RewriteEntry(TargetFl,File) == false)
 201          {
 202             fclose(TargetFl);
 203             return false;
 204          }
 205       }
 206       fclose(TargetFl);
 207
 208       if (Debug == true)
 209          cout << " Processed by using Prefix '" << Prefix << "' and chop " << Chop << endl;
 210
 211       if (_config->FindB("APT::CDROM::NoAct",false) == false)
 212       {
 213          // Move out of the partial directory
 214          Target.Close();
 215          string FinalF = _config->FindDir("Dir::State::lists");
 216          FinalF += URItoFileName(S);
 217          if (rename(TargetF.c_str(),FinalF.c_str()) != 0)
 218             return _error->Errno("rename","Failed to rename");
 219       }
 220
 221       /* Mangle the source to be in the proper notation with
 222          prefix dist [component] */
 223       *I = string(*I,Prefix.length());
 224       ConvertToSourceList(CDROM,*I);
 225       *I = Prefix + ' ' + *I;
 226
 227       CurrentSize += FileSize;
 228    }
 229    if(Progress)
 230       Progress->Done();
 231
 232    // Some stats
 233    if(log) {
 234       stringstream msg;
 235       if(NotFound == 0 && WrongSize == 0)
 236          ioprintf(msg, _("Wrote %i records.\n"), Packages);
 237       else if (NotFound != 0 && WrongSize == 0)
 238          ioprintf(msg, _("Wrote %i records with %i missing files.\n"),
 239                   Packages, NotFound);
 240       else if (NotFound == 0 && WrongSize != 0)
 241          ioprintf(msg, _("Wrote %i records with %i mismatched files\n"),
 242                   Packages, WrongSize);
 243       if (NotFound != 0 && WrongSize != 0)
 244          ioprintf(msg, _("Wrote %i records with %i missing files and %i mismatched files\n"), Packages, NotFound, WrongSize);
 245    }
 246
 247    if (Packages == 0)
 248       _error->Warning("No valid records were found.");
 249
 250    if (NotFound + WrongSize > 10)
 251       _error->Warning("A lot of entries were discarded, something may be wrong.\n");
 252
 253
 254    return true;
 255 }
 256                                                                         /*}}}*/
 257 // IndexCopy::ChopDirs - Chop off the leading directory components      /*{{{*/
 258 // ---------------------------------------------------------------------
 259 /* */
 260 string IndexCopy::ChopDirs(string Path,unsigned int Depth)
 261 {
 262    string::size_type I = 0;
 263    do
 264    {
 265       I = Path.find('/',I+1);
 266       Depth--;
 267    }
 268    while (I != string::npos && Depth != 0);
 269
 270    if (I == string::npos)
 271       return string();
 272
 273    return string(Path,I+1);
 274 }
 275                                                                         /*}}}*/
 276 // IndexCopy::ReconstructPrefix - Fix strange prefixing                 /*{{{*/
 277 // ---------------------------------------------------------------------
 278 /* This prepends dir components from the path to the package files to
 279    the path to the deb until it is found */
 280 bool IndexCopy::ReconstructPrefix(string &Prefix,string OrigPath,string CD,
 281                                   string File)
 282 {
 283    bool Debug = _config->FindB("Debug::aptcdrom",false);
 284    unsigned int Depth = 1;
 285    string MyPrefix = Prefix;
 286    while (1)
 287    {
 288       struct stat Buf;
 289       if (stat(string(CD + MyPrefix + File).c_str(),&Buf) != 0)
 290       {
 291          if (Debug == true)
 292             cout << "Failed, " << CD + MyPrefix + File << endl;
 293          if (GrabFirst(OrigPath,MyPrefix,Depth++) == true)
 294             continue;
 295
 296          return false;
 297       }
 298       else
 299       {
 300          Prefix = MyPrefix;
 301          return true;
 302       }
 303    }
 304    return false;
 305 }
 306                                                                         /*}}}*/
 307 // IndexCopy::ReconstructChop - Fixes bad source paths                  /*{{{*/
 308 // ---------------------------------------------------------------------
 309 /* This removes path components from the filename and prepends the location
 310    of the package files until a file is found */
 311 bool IndexCopy::ReconstructChop(unsigned long &Chop,string Dir,string File)
 312 {
 313    // Attempt to reconstruct the filename
 314    unsigned long Depth = 0;
 315    while (1)
 316    {
 317       struct stat Buf;
 318       if (stat(string(Dir + File).c_str(),&Buf) != 0)
 319       {
 320          File = ChopDirs(File,1);
 321          Depth++;
 322          if (File.empty() == false)
 323             continue;
 324          return false;
 325       }
 326       else
 327       {
 328          Chop = Depth;
 329          return true;
 330       }
 331    }
 332    return false;
 333 }
 334                                                                         /*}}}*/
 335 // IndexCopy::ConvertToSourceList - Convert a Path to a sourcelist      /*{{{*/
 336 // ---------------------------------------------------------------------
 337 /* We look for things in dists/ notation and convert them to
 338    <dist> <component> form otherwise it is left alone. This also strips
 339    the CD path.
 340
 341    This implements a regex sort of like:
 342     (.*)/dists/([^/]*)/(.*)/binary-*
 343      ^          ^      ^- Component
 344      |          |-------- Distribution
 345      |------------------- Path
 346
 347    It was deciced to use only a single word for dist (rather than say
 348    unstable/non-us) to increase the chance that each CD gets a single
 349    line in sources.list.
 350  */
 351 void IndexCopy::ConvertToSourceList(string CD,string &Path)
 352 {
 353    // Strip the cdrom base path
 354    Path = string(Path,CD.length());
 355    if (Path.empty() == true)
 356       Path = "/";
 357
 358    // Too short to be a dists/ type
 359    if (Path.length() < strlen("dists/"))
 360       return;
 361
 362    // Not a dists type.
 363    if (stringcmp(Path.c_str(),Path.c_str()+strlen("dists/"),"dists/") != 0)
 364       return;
 365
 366    // Isolate the dist
 367    string::size_type Slash = strlen("dists/");
 368    string::size_type Slash2 = Path.find('/',Slash + 1);
 369    if (Slash2 == string::npos || Slash2 + 2 >= Path.length())
 370       return;
 371    string Dist = string(Path,Slash,Slash2 - Slash);
 372
 373    // Isolate the component
 374    Slash = Slash2;
 375    for (unsigned I = 0; I != 10; I++)
 376    {
 377       Slash = Path.find('/',Slash+1);
 378       if (Slash == string::npos || Slash + 2 >= Path.length())
 379          return;
 380       string Comp = string(Path,Slash2+1,Slash - Slash2-1);
 381
 382       // Verify the trailing binary- bit
 383       string::size_type BinSlash = Path.find('/',Slash + 1);
 384       if (Slash == string::npos)
 385          return;
 386       string Binary = string(Path,Slash+1,BinSlash - Slash-1);
 387
 388       if (strncmp(Binary.c_str(), "binary-", strlen("binary-")) == 0)
 389       {
 390          Binary.erase(0, strlen("binary-"));
 391          if (APT::Configuration::checkArchitecture(Binary) == false)
 392             continue;
 393       }
 394       else if (Binary != "source")
 395          continue;
 396
 397       Path = Dist + ' ' + Comp;
 398       return;
 399    }
 400 }
 401                                                                         /*}}}*/
 402 // IndexCopy::GrabFirst - Return the first Depth path components        /*{{{*/
 403 // ---------------------------------------------------------------------
 404 /* */
 405 bool IndexCopy::GrabFirst(string Path,string &To,unsigned int Depth)
 406 {
 407    string::size_type I = 0;
 408    do
 409    {
 410       I = Path.find('/',I+1);
 411       Depth--;
 412    }
 413    while (I != string::npos && Depth != 0);
 414
 415    if (I == string::npos)
 416       return false;
 417
 418    To = string(Path,0,I+1);
 419    return true;
 420 }
 421                                                                         /*}}}*/
 422 // PackageCopy::GetFile - Get the file information from the section     /*{{{*/
 423 // ---------------------------------------------------------------------
 424 /* */
 425 bool PackageCopy::GetFile(string &File,unsigned long long &Size)
 426 {
 427    File = Section->FindS("Filename");
 428    Size = Section->FindI("Size");
 429    if (File.empty() || Size == 0)
 430       return _error->Error("Cannot find filename or size tag");
 431    return true;
 432 }
 433                                                                         /*}}}*/
 434 // PackageCopy::RewriteEntry - Rewrite the entry with a new filename    /*{{{*/
 435 // ---------------------------------------------------------------------
 436 /* */
 437 bool PackageCopy::RewriteEntry(FILE *Target,string File)
 438 {
 439    TFRewriteData Changes[] = {{"Filename",File.c_str()},
 440                               {}};
 441
 442    if (TFRewrite(Target,*Section,TFRewritePackageOrder,Changes) == false)
 443       return false;
 444    fputc('\n',Target);
 445    return true;
 446 }
 447                                                                         /*}}}*/
 448 // SourceCopy::GetFile - Get the file information from the section      /*{{{*/
 449 // ---------------------------------------------------------------------
 450 /* */
 451 bool SourceCopy::GetFile(string &File,unsigned long long &Size)
 452 {
 453    string Files = Section->FindS("Files");
 454    if (Files.empty() == true)
 455       return false;
 456
 457    // Stash the / terminated directory prefix
 458    string Base = Section->FindS("Directory");
 459    if (Base.empty() == false && Base[Base.length()-1] != '/')
 460       Base += '/';
 461
 462    // Read the first file triplet
 463    const char *C = Files.c_str();
 464    string sSize;
 465    string MD5Hash;
 466
 467    // Parse each of the elements
 468    if (ParseQuoteWord(C,MD5Hash) == false ||
 469        ParseQuoteWord(C,sSize) == false ||
 470        ParseQuoteWord(C,File) == false)
 471       return _error->Error("Error parsing file record");
 472
 473    // Parse the size and append the directory
 474    Size = strtoull(sSize.c_str(), NULL, 10);
 475    File = Base + File;
 476    return true;
 477 }
 478                                                                         /*}}}*/
 479 // SourceCopy::RewriteEntry - Rewrite the entry with a new filename     /*{{{*/
 480 // ---------------------------------------------------------------------
 481 /* */
 482 bool SourceCopy::RewriteEntry(FILE *Target,string File)
 483 {
 484    string Dir(File,0,File.rfind('/'));
 485    TFRewriteData Changes[] = {{"Directory",Dir.c_str()},
 486                               {}};
 487
 488    if (TFRewrite(Target,*Section,TFRewriteSourceOrder,Changes) == false)
 489       return false;
 490    fputc('\n',Target);
 491    return true;
 492 }
 493                                                                         /*}}}*/
 494 // SigVerify::Verify - Verify a files md5sum against its metaindex      /*{{{*/
 495 // ---------------------------------------------------------------------
 496 /* */
 497 bool SigVerify::Verify(string prefix, string file, indexRecords *MetaIndex)
 498 {
 499    const indexRecords::checkSum *Record = MetaIndex->Lookup(file);
 500    bool const Debug = _config->FindB("Debug::aptcdrom",false);
 501
 502    // we skip non-existing files in the verifcation of the Release file
 503    // as non-existing files do not harm, but a warning scares people and
 504    // makes it hard to strip unneeded files from an ISO like uncompressed
 505    // indexes as it is done on the mirrors (see also LP: #255545 )
 506    if(!RealFileExists(prefix+file))
 507    {
 508       if (Debug == true)
 509          cout << "Skipping nonexistent in " << prefix << " file " << file << std::endl;
 510       return true;
 511    }
 512
 513    if (!Record)
 514    {
 515       _error->Warning(_("Can't find authentication record for: %s"), file.c_str());
 516       return false;
 517    }
 518
 519    if (!Record->Hash.VerifyFile(prefix+file))
 520    {
 521       _error->Warning(_("Hash mismatch for: %s"),file.c_str());
 522       return false;
 523    }
 524
 525    if(Debug == true)
 526    {
 527       cout << "File: " << prefix+file << endl;
 528       cout << "Expected Hash " << Record->Hash.toStr() << endl;
 529    }
 530
 531    return true;
 532 }
 533                                                                         /*}}}*/
 534 bool SigVerify::CopyMetaIndex(string CDROM, string CDName,              /*{{{*/
 535                               string prefix, string file)
 536 {
 537       char S[400];
 538       snprintf(S,sizeof(S),"cdrom:[%s]/%s%s",CDName.c_str(),
 539                (prefix).c_str() + CDROM.length(),file.c_str());
 540       string TargetF = _config->FindDir("Dir::State::lists");
 541       TargetF += URItoFileName(S);
 542
 543       FileFd Target;
 544       FileFd Rel;
 545       Target.Open(TargetF,FileFd::WriteAtomic);
 546       Rel.Open(prefix + file,FileFd::ReadOnly);
 547       if (_error->PendingError() == true)
 548          return false;
 549       if (CopyFile(Rel,Target) == false)
 550          return false;
 551
 552       return true;
 553 }
 554                                                                         /*}}}*/
 555 bool SigVerify::CopyAndVerify(string CDROM,string Name,vector<string> &SigList, /*{{{*/
 556                               vector<string> PkgList,vector<string> SrcList)
 557 {
 558    if (SigList.empty() == true)
 559       return true;
 560
 561    bool Debug = _config->FindB("Debug::aptcdrom",false);
 562
 563    // Read all Release files
 564    for (vector<string>::iterator I = SigList.begin(); I != SigList.end(); ++I)
 565    {
 566       if(Debug)
 567          cout << "Signature verify for: " << *I << endl;
 568
 569       indexRecords *MetaIndex = new indexRecords;
 570       string prefix = *I;
 571
 572       string const releasegpg = *I+"Release.gpg";
 573       string const release = *I+"Release";
 574       string const inrelease = *I+"InRelease";
 575       bool useInRelease = true;
 576
 577       // a Release.gpg without a Release should never happen
 578       if (RealFileExists(inrelease) == true)
 579          ;
 580       else if(RealFileExists(release) == false || RealFileExists(releasegpg) == false)
 581       {
 582          delete MetaIndex;
 583          continue;
 584       }
 585       else
 586          useInRelease = false;
 587
 588       pid_t pid = ExecFork();
 589       if(pid < 0) {
 590          _error->Error("Fork failed");
 591          return false;
 592       }
 593       if(pid == 0)
 594       {
 595          if (useInRelease == true)
 596             RunGPGV(inrelease, inrelease);
 597          else
 598             RunGPGV(release, releasegpg);
 599       }
 600
 601       if(!ExecWait(pid, "gpgv")) {
 602          _error->Warning("Signature verification failed for: %s",
 603                          (useInRelease ? inrelease.c_str() : releasegpg.c_str()));
 604          // something went wrong, don't copy the Release.gpg
 605          // FIXME: delete any existing gpg file?
 606          continue;
 607       }
 608
 609       // Open the Release file and add it to the MetaIndex
 610       if(!MetaIndex->Load(release))
 611       {
 612          _error->Error("%s",MetaIndex->ErrorText.c_str());
 613          return false;
 614       }
 615
 616       // go over the Indexfiles and see if they verify
 617       // if so, remove them from our copy of the lists
 618       vector<string> keys = MetaIndex->MetaKeys();
 619       for (vector<string>::iterator I = keys.begin(); I != keys.end(); ++I)
 620       {
 621          if(!Verify(prefix,*I, MetaIndex)) {
 622             // something went wrong, don't copy the Release.gpg
 623             // FIXME: delete any existing gpg file?
 624             _error->Discard();
 625             continue;
 626          }
 627       }
 628
 629       // we need a fresh one for the Release.gpg
 630       delete MetaIndex;
 631
 632       // everything was fine, copy the Release and Release.gpg file
 633       if (useInRelease == true)
 634          CopyMetaIndex(CDROM, Name, prefix, "InRelease");
 635       else
 636       {
 637          CopyMetaIndex(CDROM, Name, prefix, "Release");
 638          CopyMetaIndex(CDROM, Name, prefix, "Release.gpg");
 639       }
 640    }
 641
 642    return true;
 643 }
 644                                                                         /*}}}*/
 645 // SigVerify::RunGPGV - returns the command needed for verify           /*{{{*/
 646 // ---------------------------------------------------------------------
 647 /* Generating the commandline for calling gpgv is somehow complicated as
 648    we need to add multiple keyrings and user supplied options. Also, as
 649    the cdrom code currently can not use the gpgv method we have two places
 650    these need to be done - so the place for this method is wrong but better
 651    than code duplication… */
 652 bool SigVerify::RunGPGV(std::string const &File, std::string const &FileGPG,
 653                         int const &statusfd, int fd[2])
 654 {
 655    if (File == FileGPG)
 656    {
 657       #define SIGMSG "-----BEGIN PGP SIGNED MESSAGE-----\n"
 658       char buffer[sizeof(SIGMSG)];
 659       FILE* gpg = fopen(File.c_str(), "r");
 660       if (gpg == NULL)
 661          return _error->Errno("RunGPGV", _("Could not open file %s"), File.c_str());
 662       char const * const test = fgets(buffer, sizeof(buffer), gpg);
 663       fclose(gpg);
 664       if (test == NULL || strcmp(buffer, SIGMSG) != 0)
 665          return _error->Error(_("File %s doesn't start with a clearsigned message"), File.c_str());
 666       #undef SIGMSG
 667    }
 668
 669
 670    string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv");
 671    // FIXME: remove support for deprecated APT::GPGV setting
 672    string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted"));
 673    string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts");
 674
 675    bool const Debug = _config->FindB("Debug::Acquire::gpgv", false);
 676
 677    if (Debug == true)
 678    {
 679       std::clog << "gpgv path: " << gpgvpath << std::endl;
 680       std::clog << "Keyring file: " << trustedFile << std::endl;
 681       std::clog << "Keyring path: " << trustedPath << std::endl;
 682    }
 683
 684    std::vector<string> keyrings;
 685    if (DirectoryExists(trustedPath))
 686      keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true);
 687    if (RealFileExists(trustedFile) == true)
 688      keyrings.push_back(trustedFile);
 689
 690    std::vector<const char *> Args;
 691    Args.reserve(30);
 692
 693    if (keyrings.empty() == true)
 694    {
 695       // TRANSLATOR: %s is the trusted keyring parts directory
 696       return _error->Error(_("No keyring installed in %s."),
 697                            _config->FindDir("Dir::Etc::TrustedParts").c_str());
 698    }
 699
 700    Args.push_back(gpgvpath.c_str());
 701    Args.push_back("--ignore-time-conflict");
 702
 703    if (statusfd != -1)
 704    {
 705       Args.push_back("--status-fd");
 706       char fd[10];
 707       snprintf(fd, sizeof(fd), "%i", statusfd);
 708       Args.push_back(fd);
 709    }
 710
 711    for (vector<string>::const_iterator K = keyrings.begin();
 712         K != keyrings.end(); ++K)
 713    {
 714       Args.push_back("--keyring");
 715       Args.push_back(K->c_str());
 716    }
 717
 718    Configuration::Item const *Opts;
 719    Opts = _config->Tree("Acquire::gpgv::Options");
 720    if (Opts != 0)
 721    {
 722       Opts = Opts->Child;
 723       for (; Opts != 0; Opts = Opts->Next)
 724       {
 725          if (Opts->Value.empty() == true)
 726             continue;
 727          Args.push_back(Opts->Value.c_str());
 728       }
 729    }
 730
 731    Args.push_back(FileGPG.c_str());
 732    if (FileGPG != File)
 733       Args.push_back(File.c_str());
 734    Args.push_back(NULL);
 735
 736    if (Debug == true)
 737    {
 738       std::clog << "Preparing to exec: " << gpgvpath;
 739       for (std::vector<const char *>::const_iterator a = Args.begin(); *a != NULL; ++a)
 740          std::clog << " " << *a;
 741       std::clog << std::endl;
 742    }
 743
 744    if (statusfd != -1)
 745    {
 746       int const nullfd = open("/dev/null", O_RDONLY);
 747       close(fd[0]);
 748       // Redirect output to /dev/null; we read from the status fd
 749       dup2(nullfd, STDOUT_FILENO);
 750       dup2(nullfd, STDERR_FILENO);
 751       // Redirect the pipe to the status fd (3)
 752       dup2(fd[1], statusfd);
 753
 754       putenv((char *)"LANG=");
 755       putenv((char *)"LC_ALL=");
 756       putenv((char *)"LC_MESSAGES=");
 757    }
 758
 759    execvp(gpgvpath.c_str(), (char **) &Args[0]);
 760    return true;
 761 }
 762                                                                         /*}}}*/
 763 bool TranslationsCopy::CopyTranslations(string CDROM,string Name,       /*{{{*/
 764                                 vector<string> &List, pkgCdromStatus *log)
 765 {
 766    OpProgress *Progress = NULL;
 767    if (List.empty() == true)
 768       return true;
 769
 770    if(log)
 771       Progress = log->GetOpProgress();
 772
 773    bool Debug = _config->FindB("Debug::aptcdrom",false);
 774
 775    // Prepare the progress indicator
 776    off_t TotalSize = 0;
 777    std::vector<APT::Configuration::Compressor> const compressor = APT::Configuration::getCompressors();
 778    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 779    {
 780       struct stat Buf;
 781       bool found = false;
 782       std::string file = *I;
 783       for (std::vector<APT::Configuration::Compressor>::const_iterator c = compressor.begin();
 784            c != compressor.end(); ++c)
 785       {
 786          if (stat(std::string(file + c->Extension).c_str(), &Buf) != 0)
 787             continue;
 788          found = true;
 789          break;
 790       }
 791
 792       if (found == false)
 793          return _error->Errno("stat", "Stat failed for %s", file.c_str());
 794       TotalSize += Buf.st_size;
 795    }
 796
 797    off_t CurrentSize = 0;
 798    unsigned int NotFound = 0;
 799    unsigned int WrongSize = 0;
 800    unsigned int Packages = 0;
 801    for (vector<string>::iterator I = List.begin(); I != List.end(); ++I)
 802    {
 803       // Open the package file
 804       FileFd Pkg(*I, FileFd::ReadOnly, FileFd::Auto);
 805       off_t const FileSize = Pkg.Size();
 806
 807       pkgTagFile Parser(&Pkg);
 808       if (_error->PendingError() == true)
 809          return false;
 810
 811       // Open the output file
 812       char S[400];
 813       snprintf(S,sizeof(S),"cdrom:[%s]/%s",Name.c_str(),
 814                (*I).c_str() + CDROM.length());
 815       string TargetF = _config->FindDir("Dir::State::lists") + "partial/";
 816       TargetF += URItoFileName(S);
 817       FileFd Target;
 818       if (_config->FindB("APT::CDROM::NoAct",false) == true)
 819       {
 820          TargetF = "/dev/null";
 821          Target.Open(TargetF,FileFd::WriteExists);
 822       } else {
 823          Target.Open(TargetF,FileFd::WriteAtomic);
 824       }
 825       FILE *TargetFl = fdopen(dup(Target.Fd()),"w");
 826       if (_error->PendingError() == true)
 827          return false;
 828       if (TargetFl == 0)
 829          return _error->Errno("fdopen","Failed to reopen fd");
 830
 831       // Setup the progress meter
 832       if(Progress)
 833          Progress->OverallProgress(CurrentSize,TotalSize,FileSize,
 834                                    string("Reading Translation Indexes"));
 835
 836       // Parse
 837       if(Progress)
 838          Progress->SubProgress(Pkg.Size());
 839       pkgTagSection Section;
 840       this->Section = &Section;
 841       string Prefix;
 842       unsigned long Hits = 0;
 843       while (Parser.Step(Section) == true)
 844       {
 845          if(Progress)
 846             Progress->Progress(Parser.Offset());
 847
 848          const char *Start;
 849          const char *Stop;
 850          Section.GetSection(Start,Stop);
 851          fwrite(Start,Stop-Start, 1, TargetFl);
 852          fputc('\n',TargetFl);
 853
 854          Packages++;
 855          Hits++;
 856       }
 857       fclose(TargetFl);
 858
 859       if (Debug == true)
 860          cout << " Processed by using Prefix '" << Prefix << "' and chop " << endl;
 861
 862       if (_config->FindB("APT::CDROM::NoAct",false) == false)
 863       {
 864          // Move out of the partial directory
 865          Target.Close();
 866          string FinalF = _config->FindDir("Dir::State::lists");
 867          FinalF += URItoFileName(S);
 868          if (rename(TargetF.c_str(),FinalF.c_str()) != 0)
 869             return _error->Errno("rename","Failed to rename");
 870       }
 871
 872
 873       CurrentSize += FileSize;
 874    }
 875    if(Progress)
 876       Progress->Done();
 877
 878    // Some stats
 879    if(log) {
 880       stringstream msg;
 881       if(NotFound == 0 && WrongSize == 0)
 882          ioprintf(msg, _("Wrote %i records.\n"), Packages);
 883       else if (NotFound != 0 && WrongSize == 0)
 884          ioprintf(msg, _("Wrote %i records with %i missing files.\n"),
 885                   Packages, NotFound);
 886       else if (NotFound == 0 && WrongSize != 0)
 887          ioprintf(msg, _("Wrote %i records with %i mismatched files\n"),
 888                   Packages, WrongSize);
 889       if (NotFound != 0 && WrongSize != 0)
 890          ioprintf(msg, _("Wrote %i records with %i missing files and %i mismatched files\n"), Packages, NotFound, WrongSize);
 891    }
 892
 893    if (Packages == 0)
 894       _error->Warning("No valid records were found.");
 895
 896    if (NotFound + WrongSize > 10)
 897       _error->Warning("A lot of entries were discarded, something may be wrong.\n");
 898
 899
 900    return true;
 901 }
 902                                                                         /*}}}*/