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


4a7299e99beb9c1c48e06795797fc0df3af5ee0b
[apt.git] / apt-pkg / contrib / fileutl.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: fileutl.cc,v 1.42 2002/09/14 05:29:22 jgg Exp $
4 /* ######################################################################
5
6 File Utilities
7
8 CopyFile - Buffered copy of a single file
9 GetLock - dpkg compatible lock file manipulation (fcntl)
10
11 Most of this source is placed in the Public Domain, do with it what
12 you will
13 It was originally written by Jason Gunthorpe <jgg@debian.org>.
14 FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>
15
16 The exception is RunScripts() it is under the GPLv2
17
18 ##################################################################### */
19 /*}}}*/
20 // Include Files /*{{{*/
21 #include <config.h>
22
23 #include <apt-pkg/fileutl.h>
24 #include <apt-pkg/strutl.h>
25 #include <apt-pkg/error.h>
26 #include <apt-pkg/sptr.h>
27 #include <apt-pkg/aptconfiguration.h>
28 #include <apt-pkg/configuration.h>
29
30 #include <cstdlib>
31 #include <cstring>
32 #include <cstdio>
33
34 #include <iostream>
35 #include <unistd.h>
36 #include <fcntl.h>
37 #include <sys/stat.h>
38 #include <sys/types.h>
39 #include <sys/time.h>
40 #include <sys/wait.h>
41 #include <dirent.h>
42 #include <signal.h>
43 #include <errno.h>
44 #include <set>
45 #include <algorithm>
46
47 #ifdef HAVE_ZLIB
48 #include <zlib.h>
49 #endif
50 #ifdef HAVE_BZ2
51 #include <bzlib.h>
52 #endif
53
54 #ifdef WORDS_BIGENDIAN
55 #include <inttypes.h>
56 #endif
57
58 #include <apti18n.h>
59 /*}}}*/
60
61 using namespace std;
62
63 class FileFdPrivate {
64 public:
65 #ifdef HAVE_ZLIB
66 gzFile gz;
67 #else
68 void* gz;
69 #endif
70 #ifdef HAVE_BZ2
71 BZFILE* bz2;
72 #else
73 void* bz2;
74 #endif
75 int compressed_fd;
76 pid_t compressor_pid;
77 bool pipe;
78 APT::Configuration::Compressor compressor;
79 unsigned int openmode;
80 unsigned long long seekpos;
81 FileFdPrivate() : gz(NULL), bz2(NULL),
82 compressed_fd(-1), compressor_pid(-1), pipe(false),
83 openmode(0), seekpos(0) {};
84 bool CloseDown(std::string const &FileName)
85 {
86 bool Res = true;
87 #ifdef HAVE_ZLIB
88 if (gz != NULL) {
89 int const e = gzclose(gz);
90 gz = NULL;
91 // gzdclose() on empty files always fails with "buffer error" here, ignore that
92 if (e != 0 && e != Z_BUF_ERROR)
93 Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
94 }
95 #endif
96 #ifdef HAVE_BZ2
97 if (bz2 != NULL) {
98 BZ2_bzclose(bz2);
99 bz2 = NULL;
100 }
101 #endif
102 if (compressor_pid > 0)
103 ExecWait(compressor_pid, "FileFdCompressor", true);
104 compressor_pid = -1;
105
106 return Res;
107 }
108 ~FileFdPrivate() { CloseDown(""); }
109 };
110
111 // RunScripts - Run a set of scripts from a configuration subtree /*{{{*/
112 // ---------------------------------------------------------------------
113 /* */
114 bool RunScripts(const char *Cnf)
115 {
116 Configuration::Item const *Opts = _config->Tree(Cnf);
117 if (Opts == 0 || Opts->Child == 0)
118 return true;
119 Opts = Opts->Child;
120
121 // Fork for running the system calls
122 pid_t Child = ExecFork();
123
124 // This is the child
125 if (Child == 0)
126 {
127 if (_config->FindDir("DPkg::Chroot-Directory","/") != "/")
128 {
129 std::cerr << "Chrooting into "
130 << _config->FindDir("DPkg::Chroot-Directory")
131 << std::endl;
132 if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
133 _exit(100);
134 }
135
136 if (chdir("/tmp/") != 0)
137 _exit(100);
138
139 unsigned int Count = 1;
140 for (; Opts != 0; Opts = Opts->Next, Count++)
141 {
142 if (Opts->Value.empty() == true)
143 continue;
144
145 if (system(Opts->Value.c_str()) != 0)
146 _exit(100+Count);
147 }
148 _exit(0);
149 }
150
151 // Wait for the child
152 int Status = 0;
153 while (waitpid(Child,&Status,0) != Child)
154 {
155 if (errno == EINTR)
156 continue;
157 return _error->Errno("waitpid","Couldn't wait for subprocess");
158 }
159
160 // Restore sig int/quit
161 signal(SIGQUIT,SIG_DFL);
162 signal(SIGINT,SIG_DFL);
163
164 // Check for an error code.
165 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
166 {
167 unsigned int Count = WEXITSTATUS(Status);
168 if (Count > 100)
169 {
170 Count -= 100;
171 for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
172 _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
173 }
174
175 return _error->Error("Sub-process returned an error code");
176 }
177
178 return true;
179 }
180 /*}}}*/
181
182 // CopyFile - Buffered copy of a file /*{{{*/
183 // ---------------------------------------------------------------------
184 /* The caller is expected to set things so that failure causes erasure */
185 bool CopyFile(FileFd &From,FileFd &To)
186 {
187 if (From.IsOpen() == false || To.IsOpen() == false)
188 return false;
189
190 // Buffered copy between fds
191 SPtrArray<unsigned char> Buf = new unsigned char[64000];
192 unsigned long long Size = From.Size();
193 while (Size != 0)
194 {
195 unsigned long long ToRead = Size;
196 if (Size > 64000)
197 ToRead = 64000;
198
199 if (From.Read(Buf,ToRead) == false ||
200 To.Write(Buf,ToRead) == false)
201 return false;
202
203 Size -= ToRead;
204 }
205
206 return true;
207 }
208 /*}}}*/
209 // GetLock - Gets a lock file /*{{{*/
210 // ---------------------------------------------------------------------
211 /* This will create an empty file of the given name and lock it. Once this
212 is done all other calls to GetLock in any other process will fail with
213 -1. The return result is the fd of the file, the call should call
214 close at some time. */
215 int GetLock(string File,bool Errors)
216 {
217 // GetLock() is used in aptitude on directories with public-write access
218 // Use O_NOFOLLOW here to prevent symlink traversal attacks
219 int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
220 if (FD < 0)
221 {
222 // Read only .. cant have locking problems there.
223 if (errno == EROFS)
224 {
225 _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
226 return dup(0); // Need something for the caller to close
227 }
228
229 if (Errors == true)
230 _error->Errno("open",_("Could not open lock file %s"),File.c_str());
231
232 // Feh.. We do this to distinguish the lock vs open case..
233 errno = EPERM;
234 return -1;
235 }
236 SetCloseExec(FD,true);
237
238 // Aquire a write lock
239 struct flock fl;
240 fl.l_type = F_WRLCK;
241 fl.l_whence = SEEK_SET;
242 fl.l_start = 0;
243 fl.l_len = 0;
244 if (fcntl(FD,F_SETLK,&fl) == -1)
245 {
246 if (errno == ENOLCK)
247 {
248 _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
249 return dup(0); // Need something for the caller to close
250 }
251 if (Errors == true)
252 _error->Errno("open",_("Could not get lock %s"),File.c_str());
253
254 int Tmp = errno;
255 close(FD);
256 errno = Tmp;
257 return -1;
258 }
259
260 return FD;
261 }
262 /*}}}*/
263 // FileExists - Check if a file exists /*{{{*/
264 // ---------------------------------------------------------------------
265 /* Beware: Directories are also files! */
266 bool FileExists(string File)
267 {
268 struct stat Buf;
269 if (stat(File.c_str(),&Buf) != 0)
270 return false;
271 return true;
272 }
273 /*}}}*/
274 // RealFileExists - Check if a file exists and if it is really a file /*{{{*/
275 // ---------------------------------------------------------------------
276 /* */
277 bool RealFileExists(string File)
278 {
279 struct stat Buf;
280 if (stat(File.c_str(),&Buf) != 0)
281 return false;
282 return ((Buf.st_mode & S_IFREG) != 0);
283 }
284 /*}}}*/
285 // DirectoryExists - Check if a directory exists and is really one /*{{{*/
286 // ---------------------------------------------------------------------
287 /* */
288 bool DirectoryExists(string const &Path)
289 {
290 struct stat Buf;
291 if (stat(Path.c_str(),&Buf) != 0)
292 return false;
293 return ((Buf.st_mode & S_IFDIR) != 0);
294 }
295 /*}}}*/
296 // CreateDirectory - poor man's mkdir -p guarded by a parent directory /*{{{*/
297 // ---------------------------------------------------------------------
298 /* This method will create all directories needed for path in good old
299 mkdir -p style but refuses to do this if Parent is not a prefix of
300 this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
301 so it will create apt/archives if /var/cache exists - on the other
302 hand if the parent is /var/lib the creation will fail as this path
303 is not a parent of the path to be generated. */
304 bool CreateDirectory(string const &Parent, string const &Path)
305 {
306 if (Parent.empty() == true || Path.empty() == true)
307 return false;
308
309 if (DirectoryExists(Path) == true)
310 return true;
311
312 if (DirectoryExists(Parent) == false)
313 return false;
314
315 // we are not going to create directories "into the blue"
316 if (Path.find(Parent, 0) != 0)
317 return false;
318
319 vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
320 string progress = Parent;
321 for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
322 {
323 if (d->empty() == true)
324 continue;
325
326 progress.append("/").append(*d);
327 if (DirectoryExists(progress) == true)
328 continue;
329
330 if (mkdir(progress.c_str(), 0755) != 0)
331 return false;
332 }
333 return true;
334 }
335 /*}}}*/
336 // CreateAPTDirectoryIfNeeded - ensure that the given directory exists /*{{{*/
337 // ---------------------------------------------------------------------
338 /* a small wrapper around CreateDirectory to check if it exists and to
339 remove the trailing "/apt/" from the parent directory if needed */
340 bool CreateAPTDirectoryIfNeeded(string const &Parent, string const &Path)
341 {
342 if (DirectoryExists(Path) == true)
343 return true;
344
345 size_t const len = Parent.size();
346 if (len > 5 && Parent.find("/apt/", len - 6, 5) == len - 5)
347 {
348 if (CreateDirectory(Parent.substr(0,len-5), Path) == true)
349 return true;
350 }
351 else if (CreateDirectory(Parent, Path) == true)
352 return true;
353
354 return false;
355 }
356 /*}}}*/
357 // GetListOfFilesInDir - returns a vector of files in the given dir /*{{{*/
358 // ---------------------------------------------------------------------
359 /* If an extension is given only files with this extension are included
360 in the returned vector, otherwise every "normal" file is included. */
361 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
362 bool const &SortList, bool const &AllowNoExt)
363 {
364 std::vector<string> ext;
365 ext.reserve(2);
366 if (Ext.empty() == false)
367 ext.push_back(Ext);
368 if (AllowNoExt == true && ext.empty() == false)
369 ext.push_back("");
370 return GetListOfFilesInDir(Dir, ext, SortList);
371 }
372 std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
373 bool const &SortList)
374 {
375 // Attention debuggers: need to be set with the environment config file!
376 bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
377 if (Debug == true)
378 {
379 std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
380 if (Ext.empty() == true)
381 std::clog << "\tNO extension" << std::endl;
382 else
383 for (std::vector<string>::const_iterator e = Ext.begin();
384 e != Ext.end(); ++e)
385 std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
386 }
387
388 std::vector<string> List;
389
390 if (DirectoryExists(Dir) == false)
391 {
392 _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
393 return List;
394 }
395
396 Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");
397 DIR *D = opendir(Dir.c_str());
398 if (D == 0)
399 {
400 _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
401 return List;
402 }
403
404 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
405 {
406 // skip "hidden" files
407 if (Ent->d_name[0] == '.')
408 continue;
409
410 // Make sure it is a file and not something else
411 string const File = flCombine(Dir,Ent->d_name);
412 #ifdef _DIRENT_HAVE_D_TYPE
413 if (Ent->d_type != DT_REG)
414 #endif
415 {
416 if (RealFileExists(File) == false)
417 {
418 // do not show ignoration warnings for directories
419 if (
420 #ifdef _DIRENT_HAVE_D_TYPE
421 Ent->d_type == DT_DIR ||
422 #endif
423 DirectoryExists(File) == true)
424 continue;
425 if (SilentIgnore.Match(Ent->d_name) == false)
426 _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
427 continue;
428 }
429 }
430
431 // check for accepted extension:
432 // no extension given -> periods are bad as hell!
433 // extensions given -> "" extension allows no extension
434 if (Ext.empty() == false)
435 {
436 string d_ext = flExtension(Ent->d_name);
437 if (d_ext == Ent->d_name) // no extension
438 {
439 if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
440 {
441 if (Debug == true)
442 std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
443 if (SilentIgnore.Match(Ent->d_name) == false)
444 _error->Notice(_("Ignoring file '%s' in directory '%s' as it has no filename extension"), Ent->d_name, Dir.c_str());
445 continue;
446 }
447 }
448 else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
449 {
450 if (Debug == true)
451 std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
452 if (SilentIgnore.Match(Ent->d_name) == false)
453 _error->Notice(_("Ignoring file '%s' in directory '%s' as it has an invalid filename extension"), Ent->d_name, Dir.c_str());
454 continue;
455 }
456 }
457
458 // Skip bad filenames ala run-parts
459 const char *C = Ent->d_name;
460 for (; *C != 0; ++C)
461 if (isalpha(*C) == 0 && isdigit(*C) == 0
462 && *C != '_' && *C != '-') {
463 // no required extension -> dot is a bad character
464 if (*C == '.' && Ext.empty() == false)
465 continue;
466 break;
467 }
468
469 // we don't reach the end of the name -> bad character included
470 if (*C != 0)
471 {
472 if (Debug == true)
473 std::clog << "Bad file: " << Ent->d_name << " → bad character »"
474 << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;
475 continue;
476 }
477
478 // skip filenames which end with a period. These are never valid
479 if (*(C - 1) == '.')
480 {
481 if (Debug == true)
482 std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
483 continue;
484 }
485
486 if (Debug == true)
487 std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
488 List.push_back(File);
489 }
490 closedir(D);
491
492 if (SortList == true)
493 std::sort(List.begin(),List.end());
494 return List;
495 }
496 std::vector<string> GetListOfFilesInDir(string const &Dir, bool SortList)
497 {
498 bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
499 if (Debug == true)
500 std::clog << "Accept in " << Dir << " all regular files" << std::endl;
501
502 std::vector<string> List;
503
504 if (DirectoryExists(Dir) == false)
505 {
506 _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
507 return List;
508 }
509
510 DIR *D = opendir(Dir.c_str());
511 if (D == 0)
512 {
513 _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
514 return List;
515 }
516
517 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
518 {
519 // skip "hidden" files
520 if (Ent->d_name[0] == '.')
521 continue;
522
523 // Make sure it is a file and not something else
524 string const File = flCombine(Dir,Ent->d_name);
525 #ifdef _DIRENT_HAVE_D_TYPE
526 if (Ent->d_type != DT_REG)
527 #endif
528 {
529 if (RealFileExists(File) == false)
530 {
531 if (Debug == true)
532 std::clog << "Bad file: " << Ent->d_name << " → it is not a real file" << std::endl;
533 continue;
534 }
535 }
536
537 // Skip bad filenames ala run-parts
538 const char *C = Ent->d_name;
539 for (; *C != 0; ++C)
540 if (isalpha(*C) == 0 && isdigit(*C) == 0
541 && *C != '_' && *C != '-' && *C != '.')
542 break;
543
544 // we don't reach the end of the name -> bad character included
545 if (*C != 0)
546 {
547 if (Debug == true)
548 std::clog << "Bad file: " << Ent->d_name << " → bad character »" << *C << "« in filename" << std::endl;
549 continue;
550 }
551
552 // skip filenames which end with a period. These are never valid
553 if (*(C - 1) == '.')
554 {
555 if (Debug == true)
556 std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
557 continue;
558 }
559
560 if (Debug == true)
561 std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
562 List.push_back(File);
563 }
564 closedir(D);
565
566 if (SortList == true)
567 std::sort(List.begin(),List.end());
568 return List;
569 }
570 /*}}}*/
571 // SafeGetCWD - This is a safer getcwd that returns a dynamic string /*{{{*/
572 // ---------------------------------------------------------------------
573 /* We return / on failure. */
574 string SafeGetCWD()
575 {
576 // Stash the current dir.
577 char S[300];
578 S[0] = 0;
579 if (getcwd(S,sizeof(S)-2) == 0)
580 return "/";
581 unsigned int Len = strlen(S);
582 S[Len] = '/';
583 S[Len+1] = 0;
584 return S;
585 }
586 /*}}}*/
587 // GetModificationTime - Get the mtime of the given file or -1 on error /*{{{*/
588 // ---------------------------------------------------------------------
589 /* We return / on failure. */
590 time_t GetModificationTime(string const &Path)
591 {
592 struct stat St;
593 if (stat(Path.c_str(), &St) < 0)
594 return -1;
595 return St.st_mtime;
596 }
597 /*}}}*/
598 // flNotDir - Strip the directory from the filename /*{{{*/
599 // ---------------------------------------------------------------------
600 /* */
601 string flNotDir(string File)
602 {
603 string::size_type Res = File.rfind('/');
604 if (Res == string::npos)
605 return File;
606 Res++;
607 return string(File,Res,Res - File.length());
608 }
609 /*}}}*/
610 // flNotFile - Strip the file from the directory name /*{{{*/
611 // ---------------------------------------------------------------------
612 /* Result ends in a / */
613 string flNotFile(string File)
614 {
615 string::size_type Res = File.rfind('/');
616 if (Res == string::npos)
617 return "./";
618 Res++;
619 return string(File,0,Res);
620 }
621 /*}}}*/
622 // flExtension - Return the extension for the file /*{{{*/
623 // ---------------------------------------------------------------------
624 /* */
625 string flExtension(string File)
626 {
627 string::size_type Res = File.rfind('.');
628 if (Res == string::npos)
629 return File;
630 Res++;
631 return string(File,Res,Res - File.length());
632 }
633 /*}}}*/
634 // flNoLink - If file is a symlink then deref it /*{{{*/
635 // ---------------------------------------------------------------------
636 /* If the name is not a link then the returned path is the input. */
637 string flNoLink(string File)
638 {
639 struct stat St;
640 if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
641 return File;
642 if (stat(File.c_str(),&St) != 0)
643 return File;
644
645 /* Loop resolving the link. There is no need to limit the number of
646 loops because the stat call above ensures that the symlink is not
647 circular */
648 char Buffer[1024];
649 string NFile = File;
650 while (1)
651 {
652 // Read the link
653 int Res;
654 if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
655 (unsigned)Res >= sizeof(Buffer))
656 return File;
657
658 // Append or replace the previous path
659 Buffer[Res] = 0;
660 if (Buffer[0] == '/')
661 NFile = Buffer;
662 else
663 NFile = flNotFile(NFile) + Buffer;
664
665 // See if we are done
666 if (lstat(NFile.c_str(),&St) != 0)
667 return File;
668 if (S_ISLNK(St.st_mode) == 0)
669 return NFile;
670 }
671 }
672 /*}}}*/
673 // flCombine - Combine a file and a directory /*{{{*/
674 // ---------------------------------------------------------------------
675 /* If the file is an absolute path then it is just returned, otherwise
676 the directory is pre-pended to it. */
677 string flCombine(string Dir,string File)
678 {
679 if (File.empty() == true)
680 return string();
681
682 if (File[0] == '/' || Dir.empty() == true)
683 return File;
684 if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
685 return File;
686 if (Dir[Dir.length()-1] == '/')
687 return Dir + File;
688 return Dir + '/' + File;
689 }
690 /*}}}*/
691 // SetCloseExec - Set the close on exec flag /*{{{*/
692 // ---------------------------------------------------------------------
693 /* */
694 void SetCloseExec(int Fd,bool Close)
695 {
696 if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
697 {
698 cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
699 exit(100);
700 }
701 }
702 /*}}}*/
703 // SetNonBlock - Set the nonblocking flag /*{{{*/
704 // ---------------------------------------------------------------------
705 /* */
706 void SetNonBlock(int Fd,bool Block)
707 {
708 int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
709 if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
710 {
711 cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
712 exit(100);
713 }
714 }
715 /*}}}*/
716 // WaitFd - Wait for a FD to become readable /*{{{*/
717 // ---------------------------------------------------------------------
718 /* This waits for a FD to become readable using select. It is useful for
719 applications making use of non-blocking sockets. The timeout is
720 in seconds. */
721 bool WaitFd(int Fd,bool write,unsigned long timeout)
722 {
723 fd_set Set;
724 struct timeval tv;
725 FD_ZERO(&Set);
726 FD_SET(Fd,&Set);
727 tv.tv_sec = timeout;
728 tv.tv_usec = 0;
729 if (write == true)
730 {
731 int Res;
732 do
733 {
734 Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
735 }
736 while (Res < 0 && errno == EINTR);
737
738 if (Res <= 0)
739 return false;
740 }
741 else
742 {
743 int Res;
744 do
745 {
746 Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
747 }
748 while (Res < 0 && errno == EINTR);
749
750 if (Res <= 0)
751 return false;
752 }
753
754 return true;
755 }
756 /*}}}*/
757 // ExecFork - Magical fork that sanitizes the context before execing /*{{{*/
758 // ---------------------------------------------------------------------
759 /* This is used if you want to cleanse the environment for the forked
760 child, it fixes up the important signals and nukes all of the fds,
761 otherwise acts like normal fork. */
762 pid_t ExecFork()
763 {
764 // Fork off the process
765 pid_t Process = fork();
766 if (Process < 0)
767 {
768 cerr << "FATAL -> Failed to fork." << endl;
769 exit(100);
770 }
771
772 // Spawn the subprocess
773 if (Process == 0)
774 {
775 // Setup the signals
776 signal(SIGPIPE,SIG_DFL);
777 signal(SIGQUIT,SIG_DFL);
778 signal(SIGINT,SIG_DFL);
779 signal(SIGWINCH,SIG_DFL);
780 signal(SIGCONT,SIG_DFL);
781 signal(SIGTSTP,SIG_DFL);
782
783 set<int> KeepFDs;
784 Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
785 if (Opts != 0 && Opts->Child != 0)
786 {
787 Opts = Opts->Child;
788 for (; Opts != 0; Opts = Opts->Next)
789 {
790 if (Opts->Value.empty() == true)
791 continue;
792 int fd = atoi(Opts->Value.c_str());
793 KeepFDs.insert(fd);
794 }
795 }
796
797 // Close all of our FDs - just in case
798 for (int K = 3; K != 40; K++)
799 {
800 if(KeepFDs.find(K) == KeepFDs.end())
801 fcntl(K,F_SETFD,FD_CLOEXEC);
802 }
803 }
804
805 return Process;
806 }
807 /*}}}*/
808 // ExecWait - Fancy waitpid /*{{{*/
809 // ---------------------------------------------------------------------
810 /* Waits for the given sub process. If Reap is set then no errors are
811 generated. Otherwise a failed subprocess will generate a proper descriptive
812 message */
813 bool ExecWait(pid_t Pid,const char *Name,bool Reap)
814 {
815 if (Pid <= 1)
816 return true;
817
818 // Wait and collect the error code
819 int Status;
820 while (waitpid(Pid,&Status,0) != Pid)
821 {
822 if (errno == EINTR)
823 continue;
824
825 if (Reap == true)
826 return false;
827
828 return _error->Error(_("Waited for %s but it wasn't there"),Name);
829 }
830
831
832 // Check for an error code.
833 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
834 {
835 if (Reap == true)
836 return false;
837 if (WIFSIGNALED(Status) != 0)
838 {
839 if( WTERMSIG(Status) == SIGSEGV)
840 return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
841 else
842 return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
843 }
844
845 if (WIFEXITED(Status) != 0)
846 return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
847
848 return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
849 }
850
851 return true;
852 }
853 /*}}}*/
854
855 // FileFd::Open - Open a file /*{{{*/
856 // ---------------------------------------------------------------------
857 /* The most commonly used open mode combinations are given with Mode */
858 bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress, unsigned long const Perms)
859 {
860 if (Mode == ReadOnlyGzip)
861 return Open(FileName, ReadOnly, Gzip, Perms);
862
863 if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
864 return FileFdError("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
865
866 std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
867 std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
868 if (Compress == Auto)
869 {
870 for (; compressor != compressors.end(); ++compressor)
871 {
872 std::string file = std::string(FileName).append(compressor->Extension);
873 if (FileExists(file) == false)
874 continue;
875 FileName = file;
876 break;
877 }
878 }
879 else if (Compress == Extension)
880 {
881 std::string::size_type const found = FileName.find_last_of('.');
882 std::string ext;
883 if (found != std::string::npos)
884 {
885 ext = FileName.substr(found);
886 if (ext == ".new" || ext == ".bak")
887 {
888 std::string::size_type const found2 = FileName.find_last_of('.', found - 1);
889 if (found2 != std::string::npos)
890 ext = FileName.substr(found2, found - found2);
891 else
892 ext.clear();
893 }
894 }
895 for (; compressor != compressors.end(); ++compressor)
896 if (ext == compressor->Extension)
897 break;
898 // no matching extension - assume uncompressed (imagine files like 'example.org_Packages')
899 if (compressor == compressors.end())
900 for (compressor = compressors.begin(); compressor != compressors.end(); ++compressor)
901 if (compressor->Name == ".")
902 break;
903 }
904 else
905 {
906 std::string name;
907 switch (Compress)
908 {
909 case None: name = "."; break;
910 case Gzip: name = "gzip"; break;
911 case Bzip2: name = "bzip2"; break;
912 case Lzma: name = "lzma"; break;
913 case Xz: name = "xz"; break;
914 case Auto:
915 case Extension:
916 // Unreachable
917 return FileFdError("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());
918 }
919 for (; compressor != compressors.end(); ++compressor)
920 if (compressor->Name == name)
921 break;
922 if (compressor == compressors.end())
923 return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
924 }
925
926 if (compressor == compressors.end())
927 return FileFdError("Can't find a match for specified compressor mode for file %s", FileName.c_str());
928 return Open(FileName, Mode, *compressor, Perms);
929 }
930 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
931 {
932 Close();
933 Flags = AutoClose;
934
935 if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
936 return FileFdError("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());
937 if ((Mode & ReadWrite) == 0)
938 return FileFdError("No openmode provided in FileFd::Open for %s", FileName.c_str());
939
940 if ((Mode & Atomic) == Atomic)
941 {
942 Flags |= Replace;
943 char *name = strdup((FileName + ".XXXXXX").c_str());
944 TemporaryFileName = string(mktemp(name));
945 free(name);
946 }
947 else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
948 {
949 // for atomic, this will be done by rename in Close()
950 unlink(FileName.c_str());
951 }
952 if ((Mode & Empty) == Empty)
953 {
954 struct stat Buf;
955 if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
956 unlink(FileName.c_str());
957 }
958
959 int fileflags = 0;
960 #define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
961 if_FLAGGED_SET(ReadWrite, O_RDWR);
962 else if_FLAGGED_SET(ReadOnly, O_RDONLY);
963 else if_FLAGGED_SET(WriteOnly, O_WRONLY);
964
965 if_FLAGGED_SET(Create, O_CREAT);
966 if_FLAGGED_SET(Empty, O_TRUNC);
967 if_FLAGGED_SET(Exclusive, O_EXCL);
968 else if_FLAGGED_SET(Atomic, O_EXCL);
969 #undef if_FLAGGED_SET
970
971 if (TemporaryFileName.empty() == false)
972 iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
973 else
974 iFd = open(FileName.c_str(), fileflags, Perms);
975
976 this->FileName = FileName;
977 if (iFd == -1 || OpenInternDescriptor(Mode, compressor) == false)
978 {
979 if (iFd != -1)
980 {
981 close (iFd);
982 iFd = -1;
983 }
984 return FileFdErrno("open",_("Could not open file %s"), FileName.c_str());
985 }
986
987 SetCloseExec(iFd,true);
988 return true;
989 }
990 /*}}}*/
991 // FileFd::OpenDescriptor - Open a filedescriptor /*{{{*/
992 // ---------------------------------------------------------------------
993 /* */
994 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose)
995 {
996 std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
997 std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
998 std::string name;
999
1000 // compat with the old API
1001 if (Mode == ReadOnlyGzip && Compress == None)
1002 Compress = Gzip;
1003
1004 switch (Compress)
1005 {
1006 case None: name = "."; break;
1007 case Gzip: name = "gzip"; break;
1008 case Bzip2: name = "bzip2"; break;
1009 case Lzma: name = "lzma"; break;
1010 case Xz: name = "xz"; break;
1011 case Auto:
1012 case Extension:
1013 return FileFdError("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
1014 }
1015 for (; compressor != compressors.end(); ++compressor)
1016 if (compressor->Name == name)
1017 break;
1018 if (compressor == compressors.end())
1019 return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
1020
1021 return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
1022 }
1023 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
1024 {
1025 Close();
1026 Flags = (AutoClose) ? FileFd::AutoClose : 0;
1027 if (AutoClose == false && (
1028 #ifdef HAVE_ZLIB
1029 compressor.Name == "gzip" ||
1030 #endif
1031 #ifdef HAVE_BZ2
1032 compressor.Name == "bzip2" ||
1033 #endif
1034 false))
1035 {
1036 // Need to duplicate fd here or gzclose for cleanup will close the fd as well
1037 iFd = dup(Fd);
1038 }
1039 else
1040 iFd = Fd;
1041 this->FileName = "";
1042 if (OpenInternDescriptor(Mode, compressor) == false)
1043 {
1044 if (AutoClose)
1045 close (iFd);
1046 return FileFdErrno("gzdopen",_("Could not open file descriptor %d"), Fd);
1047 }
1048 return true;
1049 }
1050 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
1051 {
1052 if (compressor.Name == "." || compressor.Binary.empty() == true)
1053 return true;
1054
1055 if (d == NULL)
1056 {
1057 d = new FileFdPrivate();
1058 d->openmode = Mode;
1059 d->compressor = compressor;
1060 }
1061
1062 #ifdef HAVE_ZLIB
1063 if (compressor.Name == "gzip")
1064 {
1065 if (d->gz != NULL)
1066 {
1067 gzclose(d->gz);
1068 d->gz = NULL;
1069 }
1070 if ((Mode & ReadWrite) == ReadWrite)
1071 d->gz = gzdopen(iFd, "r+");
1072 else if ((Mode & WriteOnly) == WriteOnly)
1073 d->gz = gzdopen(iFd, "w");
1074 else
1075 d->gz = gzdopen(iFd, "r");
1076 if (d->gz == NULL)
1077 return false;
1078 Flags |= Compressed;
1079 return true;
1080 }
1081 #endif
1082 #ifdef HAVE_BZ2
1083 if (compressor.Name == "bzip2")
1084 {
1085 if (d->bz2 != NULL)
1086 {
1087 BZ2_bzclose(d->bz2);
1088 d->bz2 = NULL;
1089 }
1090 if ((Mode & ReadWrite) == ReadWrite)
1091 d->bz2 = BZ2_bzdopen(iFd, "r+");
1092 else if ((Mode & WriteOnly) == WriteOnly)
1093 d->bz2 = BZ2_bzdopen(iFd, "w");
1094 else
1095 d->bz2 = BZ2_bzdopen(iFd, "r");
1096 if (d->bz2 == NULL)
1097 return false;
1098 Flags |= Compressed;
1099 return true;
1100 }
1101 #endif
1102
1103 // collect zombies here in case we reopen
1104 if (d->compressor_pid > 0)
1105 ExecWait(d->compressor_pid, "FileFdCompressor", true);
1106
1107 if ((Mode & ReadWrite) == ReadWrite)
1108 return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1109
1110 bool const Comp = (Mode & WriteOnly) == WriteOnly;
1111 if (Comp == false)
1112 {
1113 // Handle 'decompression' of empty files
1114 struct stat Buf;
1115 fstat(iFd, &Buf);
1116 if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1117 return true;
1118
1119 // We don't need the file open - instead let the compressor open it
1120 // as he properly knows better how to efficiently read from 'his' file
1121 if (FileName.empty() == false)
1122 {
1123 close(iFd);
1124 iFd = -1;
1125 }
1126 }
1127
1128 // Create a data pipe
1129 int Pipe[2] = {-1,-1};
1130 if (pipe(Pipe) != 0)
1131 return FileFdErrno("pipe",_("Failed to create subprocess IPC"));
1132 for (int J = 0; J != 2; J++)
1133 SetCloseExec(Pipe[J],true);
1134
1135 d->compressed_fd = iFd;
1136 d->pipe = true;
1137
1138 if (Comp == true)
1139 iFd = Pipe[1];
1140 else
1141 iFd = Pipe[0];
1142
1143 // The child..
1144 d->compressor_pid = ExecFork();
1145 if (d->compressor_pid == 0)
1146 {
1147 if (Comp == true)
1148 {
1149 dup2(d->compressed_fd,STDOUT_FILENO);
1150 dup2(Pipe[0],STDIN_FILENO);
1151 }
1152 else
1153 {
1154 if (FileName.empty() == true)
1155 dup2(d->compressed_fd,STDIN_FILENO);
1156 dup2(Pipe[1],STDOUT_FILENO);
1157 }
1158 int const nullfd = open("/dev/null", O_WRONLY);
1159 if (nullfd != -1)
1160 {
1161 dup2(nullfd,STDERR_FILENO);
1162 close(nullfd);
1163 }
1164
1165 SetCloseExec(STDOUT_FILENO,false);
1166 SetCloseExec(STDIN_FILENO,false);
1167
1168 std::vector<char const*> Args;
1169 Args.push_back(compressor.Binary.c_str());
1170 std::vector<std::string> const * const addArgs =
1171 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1172 for (std::vector<std::string>::const_iterator a = addArgs->begin();
1173 a != addArgs->end(); ++a)
1174 Args.push_back(a->c_str());
1175 if (Comp == false && FileName.empty() == false)
1176 {
1177 Args.push_back("--stdout");
1178 if (TemporaryFileName.empty() == false)
1179 Args.push_back(TemporaryFileName.c_str());
1180 else
1181 Args.push_back(FileName.c_str());
1182 }
1183 Args.push_back(NULL);
1184
1185 execvp(Args[0],(char **)&Args[0]);
1186 cerr << _("Failed to exec compressor ") << Args[0] << endl;
1187 _exit(100);
1188 }
1189 if (Comp == true)
1190 close(Pipe[0]);
1191 else
1192 close(Pipe[1]);
1193
1194 return true;
1195 }
1196 /*}}}*/
1197 // FileFd::~File - Closes the file /*{{{*/
1198 // ---------------------------------------------------------------------
1199 /* If the proper modes are selected then we close the Fd and possibly
1200 unlink the file on error. */
1201 FileFd::~FileFd()
1202 {
1203 Close();
1204 if (d != NULL)
1205 {
1206 d->CloseDown(FileName);
1207 delete d;
1208 d = NULL;
1209 }
1210 }
1211 /*}}}*/
1212 // FileFd::Read - Read a bit of the file /*{{{*/
1213 // ---------------------------------------------------------------------
1214 /* We are carefull to handle interruption by a signal while reading
1215 gracefully. */
1216 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
1217 {
1218 int Res;
1219 errno = 0;
1220 if (Actual != 0)
1221 *Actual = 0;
1222 *((char *)To) = '\0';
1223 do
1224 {
1225 #ifdef HAVE_ZLIB
1226 if (d != NULL && d->gz != NULL)
1227 Res = gzread(d->gz,To,Size);
1228 else
1229 #endif
1230 #ifdef HAVE_BZ2
1231 if (d != NULL && d->bz2 != NULL)
1232 Res = BZ2_bzread(d->bz2,To,Size);
1233 else
1234 #endif
1235 Res = read(iFd,To,Size);
1236
1237 if (Res < 0)
1238 {
1239 if (errno == EINTR)
1240 continue;
1241 #ifdef HAVE_ZLIB
1242 if (d != NULL && d->gz != NULL)
1243 {
1244 int err;
1245 char const * const errmsg = gzerror(d->gz, &err);
1246 if (err != Z_ERRNO)
1247 return FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
1248 }
1249 #endif
1250 #ifdef HAVE_BZ2
1251 if (d != NULL && d->bz2 != NULL)
1252 {
1253 int err;
1254 char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1255 if (err != BZ_IO_ERROR)
1256 return FileFdError("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
1257 }
1258 #endif
1259 return FileFdErrno("read",_("Read error"));
1260 }
1261
1262 To = (char *)To + Res;
1263 Size -= Res;
1264 if (d != NULL)
1265 d->seekpos += Res;
1266 if (Actual != 0)
1267 *Actual += Res;
1268 }
1269 while (Res > 0 && Size > 0);
1270
1271 if (Size == 0)
1272 return true;
1273
1274 // Eof handling
1275 if (Actual != 0)
1276 {
1277 Flags |= HitEof;
1278 return true;
1279 }
1280
1281 return FileFdError(_("read, still have %llu to read but none left"), Size);
1282 }
1283 /*}}}*/
1284 // FileFd::ReadLine - Read a complete line from the file /*{{{*/
1285 // ---------------------------------------------------------------------
1286 /* Beware: This method can be quiet slow for big buffers on UNcompressed
1287 files because of the naive implementation! */
1288 char* FileFd::ReadLine(char *To, unsigned long long const Size)
1289 {
1290 *To = '\0';
1291 #ifdef HAVE_ZLIB
1292 if (d != NULL && d->gz != NULL)
1293 return gzgets(d->gz, To, Size);
1294 #endif
1295
1296 unsigned long long read = 0;
1297 while ((Size - 1) != read)
1298 {
1299 unsigned long long done = 0;
1300 if (Read(To + read, 1, &done) == false)
1301 return NULL;
1302 if (done == 0)
1303 break;
1304 if (To[read++] == '\n')
1305 break;
1306 }
1307 if (read == 0)
1308 return NULL;
1309 To[read] = '\0';
1310 return To;
1311 }
1312 /*}}}*/
1313 // FileFd::Write - Write to the file /*{{{*/
1314 // ---------------------------------------------------------------------
1315 /* */
1316 bool FileFd::Write(const void *From,unsigned long long Size)
1317 {
1318 int Res;
1319 errno = 0;
1320 do
1321 {
1322 #ifdef HAVE_ZLIB
1323 if (d != NULL && d->gz != NULL)
1324 Res = gzwrite(d->gz,From,Size);
1325 else
1326 #endif
1327 #ifdef HAVE_BZ2
1328 if (d != NULL && d->bz2 != NULL)
1329 Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
1330 else
1331 #endif
1332 Res = write(iFd,From,Size);
1333 if (Res < 0 && errno == EINTR)
1334 continue;
1335 if (Res < 0)
1336 {
1337 #ifdef HAVE_ZLIB
1338 if (d != NULL && d->gz != NULL)
1339 {
1340 int err;
1341 char const * const errmsg = gzerror(d->gz, &err);
1342 if (err != Z_ERRNO)
1343 return FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1344 }
1345 #endif
1346 #ifdef HAVE_BZ2
1347 if (d != NULL && d->bz2 != NULL)
1348 {
1349 int err;
1350 char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1351 if (err != BZ_IO_ERROR)
1352 return FileFdError("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1353 }
1354 #endif
1355 return FileFdErrno("write",_("Write error"));
1356 }
1357
1358 From = (char *)From + Res;
1359 Size -= Res;
1360 if (d != NULL)
1361 d->seekpos += Res;
1362 }
1363 while (Res > 0 && Size > 0);
1364
1365 if (Size == 0)
1366 return true;
1367
1368 return FileFdError(_("write, still have %llu to write but couldn't"), Size);
1369 }
1370 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1371 {
1372 int Res;
1373 errno = 0;
1374 do
1375 {
1376 Res = write(Fd,From,Size);
1377 if (Res < 0 && errno == EINTR)
1378 continue;
1379 if (Res < 0)
1380 return _error->Errno("write",_("Write error"));
1381
1382 From = (char *)From + Res;
1383 Size -= Res;
1384 }
1385 while (Res > 0 && Size > 0);
1386
1387 if (Size == 0)
1388 return true;
1389
1390 return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1391 }
1392 /*}}}*/
1393 // FileFd::Seek - Seek in the file /*{{{*/
1394 // ---------------------------------------------------------------------
1395 /* */
1396 bool FileFd::Seek(unsigned long long To)
1397 {
1398 if (d != NULL && (d->pipe == true
1399 #ifdef HAVE_BZ2
1400 || d->bz2 != NULL
1401 #endif
1402 ))
1403 {
1404 // Our poor man seeking in pipes is costly, so try to avoid it
1405 unsigned long long seekpos = Tell();
1406 if (seekpos == To)
1407 return true;
1408 else if (seekpos < To)
1409 return Skip(To - seekpos);
1410
1411 if ((d->openmode & ReadOnly) != ReadOnly)
1412 return FileFdError("Reopen is only implemented for read-only files!");
1413 #ifdef HAVE_BZ2
1414 if (d->bz2 != NULL)
1415 {
1416 BZ2_bzclose(d->bz2);
1417 d->bz2 = NULL;
1418 }
1419 #endif
1420 if (iFd != -1)
1421 close(iFd);
1422 iFd = -1;
1423 if (TemporaryFileName.empty() == false)
1424 iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1425 else if (FileName.empty() == false)
1426 iFd = open(FileName.c_str(), O_RDONLY);
1427 else
1428 {
1429 if (d->compressed_fd > 0)
1430 if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1431 iFd = d->compressed_fd;
1432 if (iFd < 0)
1433 return FileFdError("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
1434 }
1435
1436 if (OpenInternDescriptor(d->openmode, d->compressor) == false)
1437 return FileFdError("Seek on file %s because it couldn't be reopened", FileName.c_str());
1438
1439 if (To != 0)
1440 return Skip(To);
1441
1442 d->seekpos = To;
1443 return true;
1444 }
1445 int res;
1446 #ifdef HAVE_ZLIB
1447 if (d != NULL && d->gz)
1448 res = gzseek(d->gz,To,SEEK_SET);
1449 else
1450 #endif
1451 res = lseek(iFd,To,SEEK_SET);
1452 if (res != (signed)To)
1453 return FileFdError("Unable to seek to %llu", To);
1454
1455 if (d != NULL)
1456 d->seekpos = To;
1457 return true;
1458 }
1459 /*}}}*/
1460 // FileFd::Skip - Seek in the file /*{{{*/
1461 // ---------------------------------------------------------------------
1462 /* */
1463 bool FileFd::Skip(unsigned long long Over)
1464 {
1465 if (d != NULL && (d->pipe == true
1466 #ifdef HAVE_BZ2
1467 || d->bz2 != NULL
1468 #endif
1469 ))
1470 {
1471 d->seekpos += Over;
1472 char buffer[1024];
1473 while (Over != 0)
1474 {
1475 unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1476 if (Read(buffer, toread) == false)
1477 return FileFdError("Unable to seek ahead %llu",Over);
1478 Over -= toread;
1479 }
1480 return true;
1481 }
1482
1483 int res;
1484 #ifdef HAVE_ZLIB
1485 if (d != NULL && d->gz != NULL)
1486 res = gzseek(d->gz,Over,SEEK_CUR);
1487 else
1488 #endif
1489 res = lseek(iFd,Over,SEEK_CUR);
1490 if (res < 0)
1491 return FileFdError("Unable to seek ahead %llu",Over);
1492 if (d != NULL)
1493 d->seekpos = res;
1494
1495 return true;
1496 }
1497 /*}}}*/
1498 // FileFd::Truncate - Truncate the file /*{{{*/
1499 // ---------------------------------------------------------------------
1500 /* */
1501 bool FileFd::Truncate(unsigned long long To)
1502 {
1503 #if defined HAVE_ZLIB || defined HAVE_BZ2
1504 if (d != NULL && (d->gz != NULL || d->bz2 != NULL))
1505 return FileFdError("Truncating compressed files is not implemented (%s)", FileName.c_str());
1506 #endif
1507 if (ftruncate(iFd,To) != 0)
1508 return FileFdError("Unable to truncate to %llu",To);
1509
1510 return true;
1511 }
1512 /*}}}*/
1513 // FileFd::Tell - Current seek position /*{{{*/
1514 // ---------------------------------------------------------------------
1515 /* */
1516 unsigned long long FileFd::Tell()
1517 {
1518 // In theory, we could just return seekpos here always instead of
1519 // seeking around, but not all users of FileFd use always Seek() and co
1520 // so d->seekpos isn't always true and we can just use it as a hint if
1521 // we have nothing else, but not always as an authority…
1522 if (d != NULL && (d->pipe == true
1523 #ifdef HAVE_BZ2
1524 || d->bz2 != NULL
1525 #endif
1526 ))
1527 return d->seekpos;
1528
1529 off_t Res;
1530 #ifdef HAVE_ZLIB
1531 if (d != NULL && d->gz != NULL)
1532 Res = gztell(d->gz);
1533 else
1534 #endif
1535 Res = lseek(iFd,0,SEEK_CUR);
1536 if (Res == (off_t)-1)
1537 FileFdErrno("lseek","Failed to determine the current file position");
1538 if (d != NULL)
1539 d->seekpos = Res;
1540 return Res;
1541 }
1542 /*}}}*/
1543 // FileFd::FileSize - Return the size of the file /*{{{*/
1544 // ---------------------------------------------------------------------
1545 /* */
1546 unsigned long long FileFd::FileSize()
1547 {
1548 struct stat Buf;
1549 if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
1550 return FileFdErrno("fstat","Unable to determine the file size");
1551
1552 // for compressor pipes st_size is undefined and at 'best' zero
1553 if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
1554 {
1555 // we set it here, too, as we get the info here for free
1556 // in theory the Open-methods should take care of it already
1557 if (d != NULL)
1558 d->pipe = true;
1559 if (stat(FileName.c_str(), &Buf) != 0)
1560 return FileFdErrno("stat","Unable to determine the file size");
1561 }
1562
1563 return Buf.st_size;
1564 }
1565 /*}}}*/
1566 // FileFd::Size - Return the size of the content in the file /*{{{*/
1567 // ---------------------------------------------------------------------
1568 /* */
1569 unsigned long long FileFd::Size()
1570 {
1571 unsigned long long size = FileSize();
1572
1573 // for compressor pipes st_size is undefined and at 'best' zero,
1574 // so we 'read' the content and 'seek' back - see there
1575 if (d != NULL && (d->pipe == true
1576 #ifdef HAVE_BZ2
1577 || (d->bz2 && size > 0)
1578 #endif
1579 ))
1580 {
1581 unsigned long long const oldSeek = Tell();
1582 char ignore[1000];
1583 unsigned long long read = 0;
1584 do {
1585 Read(ignore, sizeof(ignore), &read);
1586 } while(read != 0);
1587 size = Tell();
1588 Seek(oldSeek);
1589 }
1590 #ifdef HAVE_ZLIB
1591 // only check gzsize if we are actually a gzip file, just checking for
1592 // "gz" is not sufficient as uncompressed files could be opened with
1593 // gzopen in "direct" mode as well
1594 else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
1595 {
1596 off_t const oldPos = lseek(iFd,0,SEEK_CUR);
1597 /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1598 * this ourselves; the original (uncompressed) file size is the last 32
1599 * bits of the file */
1600 // FIXME: Size for gz-files is limited by 32bit… no largefile support
1601 if (lseek(iFd, -4, SEEK_END) < 0)
1602 return FileFdErrno("lseek","Unable to seek to end of gzipped file");
1603 size = 0L;
1604 if (read(iFd, &size, 4) != 4)
1605 return FileFdErrno("read","Unable to read original size of gzipped file");
1606
1607 #ifdef WORDS_BIGENDIAN
1608 uint32_t tmp_size = size;
1609 uint8_t const * const p = (uint8_t const * const) &tmp_size;
1610 tmp_size = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
1611 size = tmp_size;
1612 #endif
1613
1614 if (lseek(iFd, oldPos, SEEK_SET) < 0)
1615 return FileFdErrno("lseek","Unable to seek in gzipped file");
1616
1617 return size;
1618 }
1619 #endif
1620
1621 return size;
1622 }
1623 /*}}}*/
1624 // FileFd::ModificationTime - Return the time of last touch /*{{{*/
1625 // ---------------------------------------------------------------------
1626 /* */
1627 time_t FileFd::ModificationTime()
1628 {
1629 struct stat Buf;
1630 if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
1631 {
1632 FileFdErrno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1633 return 0;
1634 }
1635
1636 // for compressor pipes st_size is undefined and at 'best' zero
1637 if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
1638 {
1639 // we set it here, too, as we get the info here for free
1640 // in theory the Open-methods should take care of it already
1641 if (d != NULL)
1642 d->pipe = true;
1643 if (stat(FileName.c_str(), &Buf) != 0)
1644 {
1645 FileFdErrno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1646 return 0;
1647 }
1648 }
1649
1650 return Buf.st_mtime;
1651 }
1652 /*}}}*/
1653 // FileFd::Close - Close the file if the close flag is set /*{{{*/
1654 // ---------------------------------------------------------------------
1655 /* */
1656 bool FileFd::Close()
1657 {
1658 if (iFd == -1)
1659 return true;
1660
1661 bool Res = true;
1662 if ((Flags & AutoClose) == AutoClose)
1663 {
1664 if ((Flags & Compressed) != Compressed && iFd > 0 && close(iFd) != 0)
1665 Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
1666
1667 if (d != NULL)
1668 {
1669 Res &= d->CloseDown(FileName);
1670 delete d;
1671 d = NULL;
1672 }
1673 }
1674
1675 if ((Flags & Replace) == Replace) {
1676 if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
1677 Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
1678
1679 FileName = TemporaryFileName; // for the unlink() below.
1680 TemporaryFileName.clear();
1681 }
1682
1683 iFd = -1;
1684
1685 if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
1686 FileName.empty() == false)
1687 if (unlink(FileName.c_str()) != 0)
1688 Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
1689
1690 if (Res == false)
1691 Flags |= Fail;
1692 return Res;
1693 }
1694 /*}}}*/
1695 // FileFd::Sync - Sync the file /*{{{*/
1696 // ---------------------------------------------------------------------
1697 /* */
1698 bool FileFd::Sync()
1699 {
1700 if (fsync(iFd) != 0)
1701 return FileFdErrno("sync",_("Problem syncing the file"));
1702 return true;
1703 }
1704 /*}}}*/
1705 // FileFd::FileFdErrno - set Fail and call _error->Errno *{{{*/
1706 bool FileFd::FileFdErrno(const char *Function, const char *Description,...)
1707 {
1708 Flags |= Fail;
1709 va_list args;
1710 size_t msgSize = 400;
1711 int const errsv = errno;
1712 while (true)
1713 {
1714 va_start(args,Description);
1715 if (_error->InsertErrno(GlobalError::ERROR, Function, Description, args, errsv, msgSize) == false)
1716 break;
1717 va_end(args);
1718 }
1719 return false;
1720 }
1721 /*}}}*/
1722 // FileFd::FileFdError - set Fail and call _error->Error *{{{*/
1723 bool FileFd::FileFdError(const char *Description,...) {
1724 Flags |= Fail;
1725 va_list args;
1726 size_t msgSize = 400;
1727 while (true)
1728 {
1729 va_start(args,Description);
1730 if (_error->Insert(GlobalError::ERROR, Description, args, msgSize) == false)
1731 break;
1732 va_end(args);
1733 }
1734 return false;
1735 }
1736 /*}}}*/
1737
1738 gzFile FileFd::gzFd() { return (gzFile) d->gz; }
APT (for Cydia)