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 (FileExists(*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(!FileExists(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(FileExists(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    string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv");
 668    // FIXME: remove support for deprecated APT::GPGV setting
 669    string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted"));
 670    string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts");
 671
 672    bool const Debug = _config->FindB("Debug::Acquire::gpgv", false);
 673
 674    if (Debug == true)
 675    {
 676       std::clog << "gpgv path: " << gpgvpath << std::endl;
 677       std::clog << "Keyring file: " << trustedFile << std::endl;
 678       std::clog << "Keyring path: " << trustedPath << std::endl;
 679    }
 680
 681    std::vector<string> keyrings;
 682    if (DirectoryExists(trustedPath))
 683      keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true);
 684    if (FileExists(trustedFile) == true)
 685      keyrings.push_back(trustedFile);
 686
 687    std::vector<const char *> Args;
 688    Args.reserve(30);
 689
 690    if (keyrings.empty() == true)
 691       return false;
 692
 693    Args.push_back(gpgvpath.c_str());
 694    Args.push_back("--ignore-time-conflict");
 695
 696    if (statusfd != -1)
 697    {
 698       Args.push_back("--status-fd");
 699       char fd[10];
 700       snprintf(fd, sizeof(fd), "%i", statusfd);
 701       Args.push_back(fd);
 702    }
 703
 704    for (vector<string>::const_iterator K = keyrings.begin();
 705         K != keyrings.end(); ++K)
 706    {
 707       Args.push_back("--keyring");
 708       Args.push_back(K->c_str());
 709    }
 710
 711    Configuration::Item const *Opts;
 712    Opts = _config->Tree("Acquire::gpgv::Options");
 713    if (Opts != 0)
 714    {
 715       Opts = Opts->Child;
 716       for (; Opts != 0; Opts = Opts->Next)
 717       {
 718          if (Opts->Value.empty() == true)
 719             continue;
 720          Args.push_back(Opts->Value.c_str());
 721       }
 722    }
 723
 724    Args.push_back(FileGPG.c_str());
 725    Args.push_back(File.c_str());
 726    Args.push_back(NULL);
 727
 728    if (Debug == true)
 729    {
 730       std::clog << "Preparing to exec: " << gpgvpath;
 731       for (std::vector<const char *>::const_iterator a = Args.begin(); *a != NULL; ++a)
 732          std::clog << " " << *a;
 733       std::clog << std::endl;
 734    }
 735
 736    if (statusfd != -1)
 737    {
 738       int const nullfd = open("/dev/null", O_RDONLY);
 739       close(fd[0]);
 740       // Redirect output to /dev/null; we read from the status fd
 741       dup2(nullfd, STDOUT_FILENO);
 742       dup2(nullfd, STDERR_FILENO);
 743       // Redirect the pipe to the status fd (3)
 744       dup2(fd[1], statusfd);
 745
 746       putenv((char *)"LANG=");
 747       putenv((char *)"LC_ALL=");
 748       putenv((char *)"LC_MESSAGES=");
 749    }
 750
 751    execvp(gpgvpath.c_str(), (char **) &Args[0]);
 752    return true;
 753 }
 754                                                                         /*}}}*/
 755 bool TranslationsCopy::CopyTranslations(string CDROM,string Name,       /*{{{*/
 756                                 vector<string> &List, pkgCdromStatus *log)
 757 {
 758    OpProgress *Progress = NULL;
 759    if (List.size() == 0)
 760       return true;
 761
 762    if(log)
 763       Progress = log->GetOpProgress();
 764
 765    bool Debug = _config->FindB("Debug::aptcdrom",false);
 766
 767    // Prepare the progress indicator
 768    unsigned long TotalSize = 0;
 769    for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
 770    {
 771       struct stat Buf;
 772       if (stat(string(*I).c_str(),&Buf) != 0 &&
 773           stat(string(*I + ".gz").c_str(),&Buf) != 0)
 774          return _error->Errno("stat","Stat failed for %s",
 775                               string(*I).c_str());
 776       TotalSize += Buf.st_size;
 777    }
 778
 779    unsigned long CurrentSize = 0;
 780    unsigned int NotFound = 0;
 781    unsigned int WrongSize = 0;
 782    unsigned int Packages = 0;
 783    for (vector<string>::iterator I = List.begin(); I != List.end(); I++)
 784    {
 785       string OrigPath = string(*I,CDROM.length());
 786       unsigned long FileSize = 0;
 787
 788       // Open the package file
 789       FileFd Pkg;
 790       if (FileExists(*I) == true)
 791       {
 792          Pkg.Open(*I,FileFd::ReadOnly);
 793          FileSize = Pkg.Size();
 794       }
 795       else
 796       {
 797          FileFd From(*I + ".gz",FileFd::ReadOnly);
 798          if (_error->PendingError() == true)
 799             return false;
 800          FileSize = From.Size();
 801
 802          // Get a temp file
 803          FILE *tmp = tmpfile();
 804          if (tmp == 0)
 805             return _error->Errno("tmpfile","Unable to create a tmp file");
 806          Pkg.Fd(dup(fileno(tmp)));
 807          fclose(tmp);
 808
 809          // Fork gzip
 810          pid_t Process = fork();
 811          if (Process < 0)
 812             return _error->Errno("fork","Couldn't fork gzip");
 813
 814          // The child
 815          if (Process == 0)
 816          {
 817             dup2(From.Fd(),STDIN_FILENO);
 818             dup2(Pkg.Fd(),STDOUT_FILENO);
 819             SetCloseExec(STDIN_FILENO,false);
 820             SetCloseExec(STDOUT_FILENO,false);
 821
 822             const char *Args[3];
 823             string Tmp =  _config->Find("Dir::bin::gzip","gzip");
 824             Args[0] = Tmp.c_str();
 825             Args[1] = "-d";
 826             Args[2] = 0;
 827             execvp(Args[0],(char **)Args);
 828             exit(100);
 829          }
 830
 831          // Wait for gzip to finish
 832          if (ExecWait(Process,_config->Find("Dir::bin::gzip","gzip").c_str(),false) == false)
 833             return _error->Error("gzip failed, perhaps the disk is full.");
 834
 835          Pkg.Seek(0);
 836       }
 837       pkgTagFile Parser(&Pkg);
 838       if (_error->PendingError() == true)
 839          return false;
 840
 841       // Open the output file
 842       char S[400];
 843       snprintf(S,sizeof(S),"cdrom:[%s]/%s",Name.c_str(),
 844                (*I).c_str() + CDROM.length());
 845       string TargetF = _config->FindDir("Dir::State::lists") + "partial/";
 846       TargetF += URItoFileName(S);
 847       if (_config->FindB("APT::CDROM::NoAct",false) == true)
 848          TargetF = "/dev/null";
 849       FileFd Target(TargetF,FileFd::WriteAtomic);
 850       FILE *TargetFl = fdopen(dup(Target.Fd()),"w");
 851       if (_error->PendingError() == true)
 852          return false;
 853       if (TargetFl == 0)
 854          return _error->Errno("fdopen","Failed to reopen fd");
 855
 856       // Setup the progress meter
 857       if(Progress)
 858          Progress->OverallProgress(CurrentSize,TotalSize,FileSize,
 859                                    string("Reading Translation Indexes"));
 860
 861       // Parse
 862       if(Progress)
 863          Progress->SubProgress(Pkg.Size());
 864       pkgTagSection Section;
 865       this->Section = &Section;
 866       string Prefix;
 867       unsigned long Hits = 0;
 868       unsigned long Chop = 0;
 869       while (Parser.Step(Section) == true)
 870       {
 871          if(Progress)
 872             Progress->Progress(Parser.Offset());
 873
 874          const char *Start;
 875          const char *Stop;
 876          Section.GetSection(Start,Stop);
 877          fwrite(Start,Stop-Start, 1, TargetFl);
 878          fputc('\n',TargetFl);
 879
 880          Packages++;
 881          Hits++;
 882       }
 883       fclose(TargetFl);
 884
 885       if (Debug == true)
 886          cout << " Processed by using Prefix '" << Prefix << "' and chop " << Chop << endl;
 887
 888       if (_config->FindB("APT::CDROM::NoAct",false) == false)
 889       {
 890          // Move out of the partial directory
 891          Target.Close();
 892          string FinalF = _config->FindDir("Dir::State::lists");
 893          FinalF += URItoFileName(S);
 894          if (rename(TargetF.c_str(),FinalF.c_str()) != 0)
 895             return _error->Errno("rename","Failed to rename");
 896       }
 897
 898
 899       CurrentSize += FileSize;
 900    }
 901    if(Progress)
 902       Progress->Done();
 903
 904    // Some stats
 905    if(log) {
 906       stringstream msg;
 907       if(NotFound == 0 && WrongSize == 0)
 908          ioprintf(msg, _("Wrote %i records.\n"), Packages);
 909       else if (NotFound != 0 && WrongSize == 0)
 910          ioprintf(msg, _("Wrote %i records with %i missing files.\n"),
 911                   Packages, NotFound);
 912       else if (NotFound == 0 && WrongSize != 0)
 913          ioprintf(msg, _("Wrote %i records with %i mismatched files\n"),
 914                   Packages, WrongSize);
 915       if (NotFound != 0 && WrongSize != 0)
 916          ioprintf(msg, _("Wrote %i records with %i missing files and %i mismatched files\n"), Packages, NotFound, WrongSize);
 917    }
 918
 919    if (Packages == 0)
 920       _error->Warning("No valid records were found.");
 921
 922    if (NotFound + WrongSize > 10)
 923       _error->Warning("A lot of entries were discarded, something may be wrong.\n");
 924
 925
 926    return true;
 927 }
 928                                                                         /*}}}*/