apt-pkg/indexcopy.cc

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