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


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