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