]> git.saurik.com Git - apt-legacy.git/blob - apt-pkg/indexcopy.cc
projects / apt-legacy.git / blob
? search:


53eb111722fc9f9c383f4eddcef12ffb34ea4958
[apt-legacy.git] / 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 /*}}}*/
APT (for Telesphoreo)