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