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