]> git.saurik.com Git - apt.git/blame - apt-pkg/contrib/fileutl.cc
tests: fail testsuccess if notices are shown, too
[apt.git] / apt-pkg / contrib / fileutl.cc
CommitLineData
578bfd0a
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
578bfd0a
AL
3/* ######################################################################
4
5 File Utilities
6
7 CopyFile - Buffered copy of a single file
8 GetLock - dpkg compatible lock file manipulation (fcntl)
9
614adaa0
MV
10 Most of this source is placed in the Public Domain, do with it what
11 you will
7da2b375 12 It was originally written by Jason Gunthorpe <jgg@debian.org>.
a3a03f5d 13 FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>
578bfd0a 14
614adaa0
MV
15 The exception is RunScripts() it is under the GPLv2
16
578bfd0a
AL
17 ##################################################################### */
18 /*}}}*/
19// Include Files /*{{{*/
ea542140
DK
20#include <config.h>
21
094a497d 22#include <apt-pkg/fileutl.h>
1cd1c398 23#include <apt-pkg/strutl.h>
094a497d 24#include <apt-pkg/error.h>
b2e465d6 25#include <apt-pkg/sptr.h>
468720c5 26#include <apt-pkg/aptconfiguration.h>
75ef8f14 27#include <apt-pkg/configuration.h>
453b82a3 28#include <apt-pkg/macros.h>
b2e465d6 29
453b82a3
DK
30#include <ctype.h>
31#include <stdarg.h>
32#include <stddef.h>
33#include <sys/select.h>
34#include <time.h>
35#include <string>
36#include <vector>
152ab79e 37#include <cstdlib>
4f333a8b 38#include <cstring>
3010fb0e 39#include <cstdio>
4d055c05 40#include <iostream>
578bfd0a 41#include <unistd.h>
2c206aa4 42#include <fcntl.h>
578bfd0a 43#include <sys/stat.h>
cc2313b7 44#include <sys/time.h>
1ae93c94 45#include <sys/wait.h>
46e39c8e 46#include <dirent.h>
54676e1a 47#include <signal.h>
65a1e968 48#include <errno.h>
8d01b9d6 49#include <glob.h>
fc1a78d8 50#include <pwd.h>
3927c6da 51#include <grp.h>
8d01b9d6 52
75ef8f14 53#include <set>
46e39c8e 54#include <algorithm>
98cc7fd2 55#include <memory>
2cae0ccb 56
7efb8c8e
DK
57#ifdef HAVE_ZLIB
58 #include <zlib.h>
699b209e 59#endif
c4997486
DK
60#ifdef HAVE_BZ2
61 #include <bzlib.h>
62#endif
7f350a37
DK
63#ifdef HAVE_LZMA
64 #include <lzma.h>
2cae0ccb 65#endif
05eab8af
AC
66#include <endian.h>
67#include <stdint.h>
ea542140 68
3927c6da
MV
69#if __gnu_linux__
70#include <sys/prctl.h>
71#endif
72
ea542140 73#include <apti18n.h>
578bfd0a
AL
74 /*}}}*/
75
4d055c05
AL
76using namespace std;
77
614adaa0
MV
78// RunScripts - Run a set of scripts from a configuration subtree /*{{{*/
79// ---------------------------------------------------------------------
80/* */
81bool RunScripts(const char *Cnf)
82{
83 Configuration::Item const *Opts = _config->Tree(Cnf);
84 if (Opts == 0 || Opts->Child == 0)
85 return true;
86 Opts = Opts->Child;
87
88 // Fork for running the system calls
89 pid_t Child = ExecFork();
90
91 // This is the child
92 if (Child == 0)
93 {
cfba4f69
MV
94 if (_config->FindDir("DPkg::Chroot-Directory","/") != "/")
95 {
96 std::cerr << "Chrooting into "
97 << _config->FindDir("DPkg::Chroot-Directory")
98 << std::endl;
99 if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
100 _exit(100);
101 }
102
614adaa0
MV
103 if (chdir("/tmp/") != 0)
104 _exit(100);
105
106 unsigned int Count = 1;
107 for (; Opts != 0; Opts = Opts->Next, Count++)
108 {
109 if (Opts->Value.empty() == true)
110 continue;
e5b7e019
MV
111
112 if(_config->FindB("Debug::RunScripts", false) == true)
113 std::clog << "Running external script: '"
114 << Opts->Value << "'" << std::endl;
115
614adaa0
MV
116 if (system(Opts->Value.c_str()) != 0)
117 _exit(100+Count);
118 }
119 _exit(0);
120 }
121
122 // Wait for the child
123 int Status = 0;
124 while (waitpid(Child,&Status,0) != Child)
125 {
126 if (errno == EINTR)
127 continue;
128 return _error->Errno("waitpid","Couldn't wait for subprocess");
129 }
130
131 // Restore sig int/quit
132 signal(SIGQUIT,SIG_DFL);
133 signal(SIGINT,SIG_DFL);
134
135 // Check for an error code.
136 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
137 {
138 unsigned int Count = WEXITSTATUS(Status);
139 if (Count > 100)
140 {
141 Count -= 100;
142 for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
143 _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
144 }
145
146 return _error->Error("Sub-process returned an error code");
147 }
148
149 return true;
150}
151 /*}}}*/
152
578bfd0a
AL
153// CopyFile - Buffered copy of a file /*{{{*/
154// ---------------------------------------------------------------------
155/* The caller is expected to set things so that failure causes erasure */
8b89e57f 156bool CopyFile(FileFd &From,FileFd &To)
578bfd0a 157{
2128d3fc
DK
158 if (From.IsOpen() == false || To.IsOpen() == false ||
159 From.Failed() == true || To.Failed() == true)
578bfd0a 160 return false;
e977b8b9 161
578bfd0a 162 // Buffered copy between fds
98cc7fd2 163 std::unique_ptr<unsigned char[]> Buf(new unsigned char[64000]);
e977b8b9
DK
164 constexpr unsigned long long BufSize = sizeof(Buf.get())/sizeof(Buf.get()[0]);
165 unsigned long long ToRead = 0;
166 do {
167 if (From.Read(Buf.get(),BufSize, &ToRead) == false ||
98cc7fd2 168 To.Write(Buf.get(),ToRead) == false)
578bfd0a 169 return false;
e977b8b9 170 } while (ToRead != 0);
578bfd0a 171
ce1f3a2c
DK
172 return true;
173}
174 /*}}}*/
175bool RemoveFile(char const * const Function, std::string const &FileName)/*{{{*/
176{
177 if (FileName == "/dev/null")
178 return true;
179 errno = 0;
180 if (unlink(FileName.c_str()) != 0)
181 {
182 if (errno == ENOENT)
183 return true;
184
185 return _error->WarningE(Function,_("Problem unlinking the file %s"), FileName.c_str());
186 }
e977b8b9 187 return true;
578bfd0a
AL
188}
189 /*}}}*/
190// GetLock - Gets a lock file /*{{{*/
191// ---------------------------------------------------------------------
192/* This will create an empty file of the given name and lock it. Once this
193 is done all other calls to GetLock in any other process will fail with
194 -1. The return result is the fd of the file, the call should call
195 close at some time. */
196int GetLock(string File,bool Errors)
197{
f659b39a
OS
198 // GetLock() is used in aptitude on directories with public-write access
199 // Use O_NOFOLLOW here to prevent symlink traversal attacks
200 int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
578bfd0a
AL
201 if (FD < 0)
202 {
1e3f4083 203 // Read only .. can't have locking problems there.
b2e465d6
AL
204 if (errno == EROFS)
205 {
206 _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
207 return dup(0); // Need something for the caller to close
208 }
209
578bfd0a 210 if (Errors == true)
b2e465d6
AL
211 _error->Errno("open",_("Could not open lock file %s"),File.c_str());
212
213 // Feh.. We do this to distinguish the lock vs open case..
214 errno = EPERM;
578bfd0a
AL
215 return -1;
216 }
b2e465d6
AL
217 SetCloseExec(FD,true);
218
1e3f4083 219 // Acquire a write lock
578bfd0a 220 struct flock fl;
c71bc556
AL
221 fl.l_type = F_WRLCK;
222 fl.l_whence = SEEK_SET;
223 fl.l_start = 0;
224 fl.l_len = 0;
578bfd0a
AL
225 if (fcntl(FD,F_SETLK,&fl) == -1)
226 {
3d165906
MV
227 // always close to not leak resources
228 int Tmp = errno;
229 close(FD);
230 errno = Tmp;
231
d89df07a
AL
232 if (errno == ENOLCK)
233 {
b2e465d6
AL
234 _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
235 return dup(0); // Need something for the caller to close
3d165906
MV
236 }
237
578bfd0a 238 if (Errors == true)
b2e465d6
AL
239 _error->Errno("open",_("Could not get lock %s"),File.c_str());
240
578bfd0a
AL
241 return -1;
242 }
243
244 return FD;
245}
246 /*}}}*/
247// FileExists - Check if a file exists /*{{{*/
248// ---------------------------------------------------------------------
36f1098a 249/* Beware: Directories are also files! */
578bfd0a
AL
250bool FileExists(string File)
251{
252 struct stat Buf;
253 if (stat(File.c_str(),&Buf) != 0)
254 return false;
255 return true;
256}
257 /*}}}*/
36f1098a
DK
258// RealFileExists - Check if a file exists and if it is really a file /*{{{*/
259// ---------------------------------------------------------------------
260/* */
261bool RealFileExists(string File)
262{
263 struct stat Buf;
264 if (stat(File.c_str(),&Buf) != 0)
265 return false;
266 return ((Buf.st_mode & S_IFREG) != 0);
267}
268 /*}}}*/
1cd1c398
DK
269// DirectoryExists - Check if a directory exists and is really one /*{{{*/
270// ---------------------------------------------------------------------
271/* */
272bool DirectoryExists(string const &Path)
273{
274 struct stat Buf;
275 if (stat(Path.c_str(),&Buf) != 0)
276 return false;
277 return ((Buf.st_mode & S_IFDIR) != 0);
278}
279 /*}}}*/
280// CreateDirectory - poor man's mkdir -p guarded by a parent directory /*{{{*/
281// ---------------------------------------------------------------------
282/* This method will create all directories needed for path in good old
283 mkdir -p style but refuses to do this if Parent is not a prefix of
284 this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
285 so it will create apt/archives if /var/cache exists - on the other
286 hand if the parent is /var/lib the creation will fail as this path
287 is not a parent of the path to be generated. */
288bool CreateDirectory(string const &Parent, string const &Path)
289{
290 if (Parent.empty() == true || Path.empty() == true)
291 return false;
292
293 if (DirectoryExists(Path) == true)
294 return true;
295
296 if (DirectoryExists(Parent) == false)
297 return false;
298
299 // we are not going to create directories "into the blue"
9ce3cfc9 300 if (Path.compare(0, Parent.length(), Parent) != 0)
1cd1c398
DK
301 return false;
302
303 vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
304 string progress = Parent;
305 for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
306 {
307 if (d->empty() == true)
308 continue;
309
310 progress.append("/").append(*d);
311 if (DirectoryExists(progress) == true)
312 continue;
313
314 if (mkdir(progress.c_str(), 0755) != 0)
315 return false;
316 }
317 return true;
318}
319 /*}}}*/
7753e468 320// CreateAPTDirectoryIfNeeded - ensure that the given directory exists /*{{{*/
b29c3712
DK
321// ---------------------------------------------------------------------
322/* a small wrapper around CreateDirectory to check if it exists and to
323 remove the trailing "/apt/" from the parent directory if needed */
7753e468 324bool CreateAPTDirectoryIfNeeded(string const &Parent, string const &Path)
b29c3712
DK
325{
326 if (DirectoryExists(Path) == true)
327 return true;
328
329 size_t const len = Parent.size();
330 if (len > 5 && Parent.find("/apt/", len - 6, 5) == len - 5)
331 {
332 if (CreateDirectory(Parent.substr(0,len-5), Path) == true)
333 return true;
334 }
335 else if (CreateDirectory(Parent, Path) == true)
336 return true;
337
338 return false;
339}
340 /*}}}*/
46e39c8e
MV
341// GetListOfFilesInDir - returns a vector of files in the given dir /*{{{*/
342// ---------------------------------------------------------------------
343/* If an extension is given only files with this extension are included
344 in the returned vector, otherwise every "normal" file is included. */
b39c1859
MV
345std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
346 bool const &SortList, bool const &AllowNoExt)
347{
348 std::vector<string> ext;
349 ext.reserve(2);
350 if (Ext.empty() == false)
351 ext.push_back(Ext);
352 if (AllowNoExt == true && ext.empty() == false)
353 ext.push_back("");
354 return GetListOfFilesInDir(Dir, ext, SortList);
355}
356std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
357 bool const &SortList)
358{
359 // Attention debuggers: need to be set with the environment config file!
360 bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
361 if (Debug == true)
362 {
363 std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
364 if (Ext.empty() == true)
365 std::clog << "\tNO extension" << std::endl;
366 else
367 for (std::vector<string>::const_iterator e = Ext.begin();
368 e != Ext.end(); ++e)
369 std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
370 }
371
46e39c8e 372 std::vector<string> List;
36f1098a 373
69c2ecbd 374 if (DirectoryExists(Dir) == false)
36f1098a
DK
375 {
376 _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
377 return List;
378 }
379
1408e219 380 Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");
46e39c8e
MV
381 DIR *D = opendir(Dir.c_str());
382 if (D == 0)
383 {
384 _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
385 return List;
386 }
387
388 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
389 {
b39c1859 390 // skip "hidden" files
46e39c8e
MV
391 if (Ent->d_name[0] == '.')
392 continue;
393
491058e3
DK
394 // Make sure it is a file and not something else
395 string const File = flCombine(Dir,Ent->d_name);
396#ifdef _DIRENT_HAVE_D_TYPE
397 if (Ent->d_type != DT_REG)
398#endif
399 {
69c2ecbd 400 if (RealFileExists(File) == false)
491058e3 401 {
84e254d6
DK
402 // do not show ignoration warnings for directories
403 if (
404#ifdef _DIRENT_HAVE_D_TYPE
405 Ent->d_type == DT_DIR ||
406#endif
69c2ecbd 407 DirectoryExists(File) == true)
84e254d6 408 continue;
491058e3
DK
409 if (SilentIgnore.Match(Ent->d_name) == false)
410 _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
411 continue;
412 }
413 }
414
b39c1859
MV
415 // check for accepted extension:
416 // no extension given -> periods are bad as hell!
417 // extensions given -> "" extension allows no extension
418 if (Ext.empty() == false)
419 {
420 string d_ext = flExtension(Ent->d_name);
421 if (d_ext == Ent->d_name) // no extension
422 {
423 if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
424 {
425 if (Debug == true)
426 std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
5edc3966 427 if (SilentIgnore.Match(Ent->d_name) == false)
491058e3 428 _error->Notice(_("Ignoring file '%s' in directory '%s' as it has no filename extension"), Ent->d_name, Dir.c_str());
b39c1859
MV
429 continue;
430 }
431 }
432 else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
433 {
434 if (Debug == true)
435 std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
1408e219 436 if (SilentIgnore.Match(Ent->d_name) == false)
491058e3 437 _error->Notice(_("Ignoring file '%s' in directory '%s' as it has an invalid filename extension"), Ent->d_name, Dir.c_str());
b39c1859
MV
438 continue;
439 }
440 }
46e39c8e 441
b39c1859 442 // Skip bad filenames ala run-parts
46e39c8e
MV
443 const char *C = Ent->d_name;
444 for (; *C != 0; ++C)
445 if (isalpha(*C) == 0 && isdigit(*C) == 0
9d39208a 446 && *C != '_' && *C != '-' && *C != ':') {
b39c1859
MV
447 // no required extension -> dot is a bad character
448 if (*C == '.' && Ext.empty() == false)
449 continue;
46e39c8e 450 break;
b39c1859 451 }
46e39c8e 452
b39c1859 453 // we don't reach the end of the name -> bad character included
46e39c8e 454 if (*C != 0)
b39c1859
MV
455 {
456 if (Debug == true)
457 std::clog << "Bad file: " << Ent->d_name << " → bad character »"
458 << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;
459 continue;
460 }
461
fbb2c7e0
DK
462 // skip filenames which end with a period. These are never valid
463 if (*(C - 1) == '.')
464 {
465 if (Debug == true)
466 std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
467 continue;
468 }
469
470 if (Debug == true)
471 std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
472 List.push_back(File);
473 }
474 closedir(D);
475
476 if (SortList == true)
477 std::sort(List.begin(),List.end());
478 return List;
479}
480std::vector<string> GetListOfFilesInDir(string const &Dir, bool SortList)
481{
482 bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
483 if (Debug == true)
484 std::clog << "Accept in " << Dir << " all regular files" << std::endl;
485
486 std::vector<string> List;
487
69c2ecbd 488 if (DirectoryExists(Dir) == false)
fbb2c7e0
DK
489 {
490 _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
491 return List;
492 }
493
494 DIR *D = opendir(Dir.c_str());
495 if (D == 0)
496 {
497 _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
498 return List;
499 }
500
501 for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
502 {
503 // skip "hidden" files
504 if (Ent->d_name[0] == '.')
505 continue;
506
507 // Make sure it is a file and not something else
508 string const File = flCombine(Dir,Ent->d_name);
509#ifdef _DIRENT_HAVE_D_TYPE
510 if (Ent->d_type != DT_REG)
511#endif
512 {
69c2ecbd 513 if (RealFileExists(File) == false)
fbb2c7e0
DK
514 {
515 if (Debug == true)
516 std::clog << "Bad file: " << Ent->d_name << " → it is not a real file" << std::endl;
517 continue;
518 }
519 }
520
521 // Skip bad filenames ala run-parts
522 const char *C = Ent->d_name;
523 for (; *C != 0; ++C)
524 if (isalpha(*C) == 0 && isdigit(*C) == 0
525 && *C != '_' && *C != '-' && *C != '.')
526 break;
527
528 // we don't reach the end of the name -> bad character included
529 if (*C != 0)
530 {
531 if (Debug == true)
532 std::clog << "Bad file: " << Ent->d_name << " → bad character »" << *C << "« in filename" << std::endl;
533 continue;
534 }
535
b39c1859
MV
536 // skip filenames which end with a period. These are never valid
537 if (*(C - 1) == '.')
538 {
539 if (Debug == true)
540 std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
46e39c8e 541 continue;
b39c1859 542 }
46e39c8e 543
b39c1859
MV
544 if (Debug == true)
545 std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
46e39c8e
MV
546 List.push_back(File);
547 }
548 closedir(D);
549
550 if (SortList == true)
551 std::sort(List.begin(),List.end());
552 return List;
553}
554 /*}}}*/
578bfd0a
AL
555// SafeGetCWD - This is a safer getcwd that returns a dynamic string /*{{{*/
556// ---------------------------------------------------------------------
557/* We return / on failure. */
558string SafeGetCWD()
559{
560 // Stash the current dir.
561 char S[300];
562 S[0] = 0;
7f25bdff 563 if (getcwd(S,sizeof(S)-2) == 0)
578bfd0a 564 return "/";
7f25bdff
AL
565 unsigned int Len = strlen(S);
566 S[Len] = '/';
567 S[Len+1] = 0;
578bfd0a
AL
568 return S;
569}
570 /*}}}*/
2ec858bc
MV
571// GetModificationTime - Get the mtime of the given file or -1 on error /*{{{*/
572// ---------------------------------------------------------------------
573/* We return / on failure. */
574time_t GetModificationTime(string const &Path)
575{
576 struct stat St;
577 if (stat(Path.c_str(), &St) < 0)
578 return -1;
579 return St.st_mtime;
580}
581 /*}}}*/
8ce4327b
AL
582// flNotDir - Strip the directory from the filename /*{{{*/
583// ---------------------------------------------------------------------
584/* */
585string flNotDir(string File)
586{
587 string::size_type Res = File.rfind('/');
588 if (Res == string::npos)
589 return File;
590 Res++;
591 return string(File,Res,Res - File.length());
592}
593 /*}}}*/
d38b7b3d
AL
594// flNotFile - Strip the file from the directory name /*{{{*/
595// ---------------------------------------------------------------------
171c45bc 596/* Result ends in a / */
d38b7b3d
AL
597string flNotFile(string File)
598{
599 string::size_type Res = File.rfind('/');
600 if (Res == string::npos)
171c45bc 601 return "./";
d38b7b3d
AL
602 Res++;
603 return string(File,0,Res);
604}
605 /*}}}*/
b2e465d6
AL
606// flExtension - Return the extension for the file /*{{{*/
607// ---------------------------------------------------------------------
608/* */
609string flExtension(string File)
610{
611 string::size_type Res = File.rfind('.');
612 if (Res == string::npos)
613 return File;
614 Res++;
615 return string(File,Res,Res - File.length());
616}
617 /*}}}*/
421c8d10
AL
618// flNoLink - If file is a symlink then deref it /*{{{*/
619// ---------------------------------------------------------------------
620/* If the name is not a link then the returned path is the input. */
621string flNoLink(string File)
622{
623 struct stat St;
624 if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
625 return File;
626 if (stat(File.c_str(),&St) != 0)
627 return File;
628
629 /* Loop resolving the link. There is no need to limit the number of
630 loops because the stat call above ensures that the symlink is not
631 circular */
632 char Buffer[1024];
633 string NFile = File;
634 while (1)
635 {
636 // Read the link
3286ad13 637 ssize_t Res;
421c8d10 638 if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
3286ad13 639 (size_t)Res >= sizeof(Buffer))
421c8d10
AL
640 return File;
641
642 // Append or replace the previous path
643 Buffer[Res] = 0;
644 if (Buffer[0] == '/')
645 NFile = Buffer;
646 else
647 NFile = flNotFile(NFile) + Buffer;
648
649 // See if we are done
650 if (lstat(NFile.c_str(),&St) != 0)
651 return File;
652 if (S_ISLNK(St.st_mode) == 0)
653 return NFile;
654 }
655}
656 /*}}}*/
b2e465d6
AL
657// flCombine - Combine a file and a directory /*{{{*/
658// ---------------------------------------------------------------------
659/* If the file is an absolute path then it is just returned, otherwise
660 the directory is pre-pended to it. */
661string flCombine(string Dir,string File)
662{
663 if (File.empty() == true)
664 return string();
665
666 if (File[0] == '/' || Dir.empty() == true)
667 return File;
668 if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
669 return File;
670 if (Dir[Dir.length()-1] == '/')
671 return Dir + File;
672 return Dir + '/' + File;
673}
674 /*}}}*/
53ac87ac
MV
675// flAbsPath - Return the absolute path of the filename /*{{{*/
676// ---------------------------------------------------------------------
677/* */
678string flAbsPath(string File)
679{
680 char *p = realpath(File.c_str(), NULL);
681 if (p == NULL)
682 {
95278287 683 _error->Errno("realpath", "flAbsPath on %s failed", File.c_str());
53ac87ac
MV
684 return "";
685 }
686 std::string AbsPath(p);
687 free(p);
688 return AbsPath;
689}
690 /*}}}*/
3b5421b4
AL
691// SetCloseExec - Set the close on exec flag /*{{{*/
692// ---------------------------------------------------------------------
693/* */
694void 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/* */
706void SetNonBlock(int Fd,bool Block)
707{
0a8a80e5
AL
708 int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
709 if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
3b5421b4
AL
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// ---------------------------------------------------------------------
b2e465d6 718/* This waits for a FD to become readable using select. It is useful for
6d5dd02a
AL
719 applications making use of non-blocking sockets. The timeout is
720 in seconds. */
1084d58a 721bool WaitFd(int Fd,bool write,unsigned long timeout)
3b5421b4
AL
722{
723 fd_set Set;
cc2313b7 724 struct timeval tv;
3b5421b4
AL
725 FD_ZERO(&Set);
726 FD_SET(Fd,&Set);
6d5dd02a
AL
727 tv.tv_sec = timeout;
728 tv.tv_usec = 0;
1084d58a 729 if (write == true)
b0db36b1
AL
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;
1084d58a
AL
740 }
741 else
742 {
b0db36b1
AL
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;
cc2313b7 752 }
1084d58a 753
3b5421b4
AL
754 return true;
755}
756 /*}}}*/
96ae6de5 757// MergeKeepFdsFromConfiguration - Merge APT::Keep-Fds configuration /*{{{*/
54676e1a 758// ---------------------------------------------------------------------
96ae6de5
MV
759/* This is used to merge the APT::Keep-Fds with the provided KeepFDs
760 * set.
761 */
762void MergeKeepFdsFromConfiguration(std::set<int> &KeepFDs)
e45c4617 763{
e45c4617
MV
764 Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
765 if (Opts != 0 && Opts->Child != 0)
766 {
767 Opts = Opts->Child;
768 for (; Opts != 0; Opts = Opts->Next)
769 {
770 if (Opts->Value.empty() == true)
771 continue;
772 int fd = atoi(Opts->Value.c_str());
773 KeepFDs.insert(fd);
774 }
775 }
96ae6de5
MV
776}
777 /*}}}*/
54676e1a
AL
778// ExecFork - Magical fork that sanitizes the context before execing /*{{{*/
779// ---------------------------------------------------------------------
780/* This is used if you want to cleanse the environment for the forked
781 child, it fixes up the important signals and nukes all of the fds,
782 otherwise acts like normal fork. */
75ef8f14 783pid_t ExecFork()
96ae6de5
MV
784{
785 set<int> KeepFDs;
786 // we need to merge the Keep-Fds as external tools like
787 // debconf-apt-progress use it
788 MergeKeepFdsFromConfiguration(KeepFDs);
e45c4617
MV
789 return ExecFork(KeepFDs);
790}
791
792pid_t ExecFork(std::set<int> KeepFDs)
54676e1a
AL
793{
794 // Fork off the process
795 pid_t Process = fork();
796 if (Process < 0)
797 {
798 cerr << "FATAL -> Failed to fork." << endl;
799 exit(100);
800 }
801
802 // Spawn the subprocess
803 if (Process == 0)
804 {
805 // Setup the signals
806 signal(SIGPIPE,SIG_DFL);
807 signal(SIGQUIT,SIG_DFL);
808 signal(SIGINT,SIG_DFL);
809 signal(SIGWINCH,SIG_DFL);
810 signal(SIGCONT,SIG_DFL);
811 signal(SIGTSTP,SIG_DFL);
75ef8f14 812
be4d908f
JAK
813 DIR *dir = opendir("/proc/self/fd");
814 if (dir != NULL)
75ef8f14 815 {
be4d908f
JAK
816 struct dirent *ent;
817 while ((ent = readdir(dir)))
818 {
819 int fd = atoi(ent->d_name);
820 // If fd > 0, it was a fd number and not . or ..
821 if (fd >= 3 && KeepFDs.find(fd) == KeepFDs.end())
822 fcntl(fd,F_SETFD,FD_CLOEXEC);
823 }
824 closedir(dir);
825 } else {
826 long ScOpenMax = sysconf(_SC_OPEN_MAX);
827 // Close all of our FDs - just in case
828 for (int K = 3; K != ScOpenMax; K++)
829 {
830 if(KeepFDs.find(K) == KeepFDs.end())
831 fcntl(K,F_SETFD,FD_CLOEXEC);
832 }
75ef8f14 833 }
54676e1a
AL
834 }
835
836 return Process;
837}
838 /*}}}*/
ddc1d8d0
AL
839// ExecWait - Fancy waitpid /*{{{*/
840// ---------------------------------------------------------------------
2c9a72d1 841/* Waits for the given sub process. If Reap is set then no errors are
ddc1d8d0
AL
842 generated. Otherwise a failed subprocess will generate a proper descriptive
843 message */
3826564e 844bool ExecWait(pid_t Pid,const char *Name,bool Reap)
ddc1d8d0
AL
845{
846 if (Pid <= 1)
847 return true;
848
849 // Wait and collect the error code
850 int Status;
851 while (waitpid(Pid,&Status,0) != Pid)
852 {
853 if (errno == EINTR)
854 continue;
855
856 if (Reap == true)
857 return false;
858
db0db9fe 859 return _error->Error(_("Waited for %s but it wasn't there"),Name);
ddc1d8d0
AL
860 }
861
862
863 // Check for an error code.
864 if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
865 {
866 if (Reap == true)
867 return false;
ab7f4d7c 868 if (WIFSIGNALED(Status) != 0)
40e7fe0e 869 {
ab7f4d7c
MV
870 if( WTERMSIG(Status) == SIGSEGV)
871 return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
872 else
873 return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
40e7fe0e 874 }
ddc1d8d0
AL
875
876 if (WIFEXITED(Status) != 0)
b2e465d6 877 return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
ddc1d8d0 878
b2e465d6 879 return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
ddc1d8d0
AL
880 }
881
882 return true;
883}
884 /*}}}*/
f8aba23f 885// StartsWithGPGClearTextSignature - Check if a file is Pgp/GPG clearsigned /*{{{*/
fe5804fc 886bool StartsWithGPGClearTextSignature(string const &FileName)
0854ad8b
MV
887{
888 static const char* SIGMSG = "-----BEGIN PGP SIGNED MESSAGE-----\n";
1c89c98a 889 char buffer[strlen(SIGMSG)+1];
0854ad8b
MV
890 FILE* gpg = fopen(FileName.c_str(), "r");
891 if (gpg == NULL)
892 return false;
893
894 char const * const test = fgets(buffer, sizeof(buffer), gpg);
895 fclose(gpg);
896 if (test == NULL || strcmp(buffer, SIGMSG) != 0)
897 return false;
898
899 return true;
900}
f8aba23f 901 /*}}}*/
d84da499
DK
902// ChangeOwnerAndPermissionOfFile - set file attributes to requested values /*{{{*/
903bool ChangeOwnerAndPermissionOfFile(char const * const requester, char const * const file, char const * const user, char const * const group, mode_t const mode)
904{
905 if (strcmp(file, "/dev/null") == 0)
906 return true;
907 bool Res = true;
908 if (getuid() == 0 && strlen(user) != 0 && strlen(group) != 0) // if we aren't root, we can't chown, so don't try it
909 {
910 // ensure the file is owned by root and has good permissions
911 struct passwd const * const pw = getpwnam(user);
912 struct group const * const gr = getgrnam(group);
913 if (pw != NULL && gr != NULL && chown(file, pw->pw_uid, gr->gr_gid) != 0)
914 Res &= _error->WarningE(requester, "chown to %s:%s of file %s failed", user, group, file);
915 }
916 if (chmod(file, mode) != 0)
917 Res &= _error->WarningE(requester, "chmod 0%o of file %s failed", mode, file);
918 return Res;
919}
920 /*}}}*/
0854ad8b 921
4239dbca
DK
922class FileFdPrivate { /*{{{*/
923 public:
924#ifdef HAVE_ZLIB
925 gzFile gz;
926#endif
927#ifdef HAVE_BZ2
928 BZFILE* bz2;
929#endif
930#ifdef HAVE_LZMA
931 struct LZMAFILE {
932 FILE* file;
933 uint8_t buffer[4096];
934 lzma_stream stream;
935 lzma_ret err;
936 bool eof;
937 bool compressing;
938
25613a61 939 LZMAFILE() : file(NULL), eof(false), compressing(false) { buffer[0] = '\0'; }
4239dbca
DK
940 ~LZMAFILE() {
941 if (compressing == true)
942 {
943 for (;;) {
944 stream.avail_out = sizeof(buffer)/sizeof(buffer[0]);
945 stream.next_out = buffer;
946 err = lzma_code(&stream, LZMA_FINISH);
947 if (err != LZMA_OK && err != LZMA_STREAM_END)
948 {
949 _error->Error("~LZMAFILE: Compress finalisation failed");
950 break;
951 }
952 size_t const n = sizeof(buffer)/sizeof(buffer[0]) - stream.avail_out;
953 if (n && fwrite(buffer, 1, n, file) != n)
954 {
955 _error->Errno("~LZMAFILE",_("Write error"));
956 break;
957 }
958 if (err == LZMA_STREAM_END)
959 break;
960 }
961 }
962 lzma_end(&stream);
963 fclose(file);
964 }
965 };
966 LZMAFILE* lzma;
967#endif
968 int compressed_fd;
969 pid_t compressor_pid;
970 bool pipe;
971 APT::Configuration::Compressor compressor;
972 unsigned int openmode;
973 unsigned long long seekpos;
974 FileFdPrivate() :
975#ifdef HAVE_ZLIB
976 gz(NULL),
977#endif
978#ifdef HAVE_BZ2
979 bz2(NULL),
980#endif
981#ifdef HAVE_LZMA
982 lzma(NULL),
983#endif
984 compressed_fd(-1), compressor_pid(-1), pipe(false),
985 openmode(0), seekpos(0) {};
986 bool InternalClose(std::string const &FileName)
987 {
988 if (false)
989 /* dummy so that the rest can be 'else if's */;
990#ifdef HAVE_ZLIB
991 else if (gz != NULL) {
992 int const e = gzclose(gz);
993 gz = NULL;
994 // gzdclose() on empty files always fails with "buffer error" here, ignore that
995 if (e != 0 && e != Z_BUF_ERROR)
996 return _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
997 }
998#endif
999#ifdef HAVE_BZ2
1000 else if (bz2 != NULL) {
1001 BZ2_bzclose(bz2);
1002 bz2 = NULL;
1003 }
1004#endif
1005#ifdef HAVE_LZMA
1006 else if (lzma != NULL) {
1007 delete lzma;
1008 lzma = NULL;
1009 }
1010#endif
1011 return true;
1012 }
1013 bool CloseDown(std::string const &FileName)
1014 {
1015 bool const Res = InternalClose(FileName);
1016
1017 if (compressor_pid > 0)
1018 ExecWait(compressor_pid, "FileFdCompressor", true);
1019 compressor_pid = -1;
1020
1021 return Res;
1022 }
1023 bool InternalStream() const {
1024 return false
1025#ifdef HAVE_BZ2
1026 || bz2 != NULL
1027#endif
1028#ifdef HAVE_LZMA
1029 || lzma != NULL
1030#endif
1031 ;
1032 }
1033
1034
1035 ~FileFdPrivate() { CloseDown(""); }
1036};
1037 /*}}}*/
6c55f07a
DK
1038// FileFd Constructors /*{{{*/
1039FileFd::FileFd(std::string FileName,unsigned int const Mode,unsigned long AccessMode) : iFd(-1), Flags(0), d(NULL)
1040{
1041 Open(FileName,Mode, None, AccessMode);
1042}
1043FileFd::FileFd(std::string FileName,unsigned int const Mode, CompressMode Compress, unsigned long AccessMode) : iFd(-1), Flags(0), d(NULL)
1044{
1045 Open(FileName,Mode, Compress, AccessMode);
1046}
1047FileFd::FileFd() : iFd(-1), Flags(AutoClose), d(NULL) {}
1048FileFd::FileFd(int const Fd, unsigned int const Mode, CompressMode Compress) : iFd(-1), Flags(0), d(NULL)
1049{
1050 OpenDescriptor(Fd, Mode, Compress);
1051}
1052FileFd::FileFd(int const Fd, bool const AutoClose) : iFd(-1), Flags(0), d(NULL)
1053{
1054 OpenDescriptor(Fd, ReadWrite, None, AutoClose);
1055}
1056 /*}}}*/
13d87e2e 1057// FileFd::Open - Open a file /*{{{*/
578bfd0a
AL
1058// ---------------------------------------------------------------------
1059/* The most commonly used open mode combinations are given with Mode */
e5f3f8c1 1060bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress, unsigned long const AccessMode)
578bfd0a 1061{
257e8d66 1062 if (Mode == ReadOnlyGzip)
e5f3f8c1 1063 return Open(FileName, ReadOnly, Gzip, AccessMode);
257e8d66 1064
468720c5 1065 if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
ae635e3c 1066 return FileFdError("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
257e8d66 1067
468720c5
DK
1068 std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
1069 std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
1070 if (Compress == Auto)
1071 {
468720c5
DK
1072 for (; compressor != compressors.end(); ++compressor)
1073 {
e788a834 1074 std::string file = FileName + compressor->Extension;
468720c5
DK
1075 if (FileExists(file) == false)
1076 continue;
1077 FileName = file;
468720c5
DK
1078 break;
1079 }
1080 }
1081 else if (Compress == Extension)
1082 {
52b47296
DK
1083 std::string::size_type const found = FileName.find_last_of('.');
1084 std::string ext;
1085 if (found != std::string::npos)
1086 {
1087 ext = FileName.substr(found);
1088 if (ext == ".new" || ext == ".bak")
1089 {
1090 std::string::size_type const found2 = FileName.find_last_of('.', found - 1);
1091 if (found2 != std::string::npos)
1092 ext = FileName.substr(found2, found - found2);
1093 else
1094 ext.clear();
1095 }
1096 }
aee1aac6
DK
1097 for (; compressor != compressors.end(); ++compressor)
1098 if (ext == compressor->Extension)
1099 break;
1100 // no matching extension - assume uncompressed (imagine files like 'example.org_Packages')
1101 if (compressor == compressors.end())
1102 for (compressor = compressors.begin(); compressor != compressors.end(); ++compressor)
1103 if (compressor->Name == ".")
468720c5 1104 break;
468720c5 1105 }
aee1aac6 1106 else
468720c5
DK
1107 {
1108 std::string name;
1109 switch (Compress)
1110 {
aee1aac6 1111 case None: name = "."; break;
468720c5
DK
1112 case Gzip: name = "gzip"; break;
1113 case Bzip2: name = "bzip2"; break;
1114 case Lzma: name = "lzma"; break;
1115 case Xz: name = "xz"; break;
aee1aac6
DK
1116 case Auto:
1117 case Extension:
52b47296 1118 // Unreachable
ae635e3c 1119 return FileFdError("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());
468720c5
DK
1120 }
1121 for (; compressor != compressors.end(); ++compressor)
1122 if (compressor->Name == name)
1123 break;
aee1aac6 1124 if (compressor == compressors.end())
ae635e3c 1125 return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
468720c5
DK
1126 }
1127
aee1aac6 1128 if (compressor == compressors.end())
ae635e3c 1129 return FileFdError("Can't find a match for specified compressor mode for file %s", FileName.c_str());
e5f3f8c1 1130 return Open(FileName, Mode, *compressor, AccessMode);
aee1aac6 1131}
e5f3f8c1 1132bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const AccessMode)
aee1aac6
DK
1133{
1134 Close();
aee1aac6
DK
1135 Flags = AutoClose;
1136
1137 if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
ae635e3c 1138 return FileFdError("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());
aee1aac6 1139 if ((Mode & ReadWrite) == 0)
ae635e3c 1140 return FileFdError("No openmode provided in FileFd::Open for %s", FileName.c_str());
468720c5 1141
cd46d4eb
DK
1142 unsigned int OpenMode = Mode;
1143 if (FileName == "/dev/null")
1144 OpenMode = OpenMode & ~(Atomic | Exclusive | Create | Empty);
1145
1146 if ((OpenMode & Atomic) == Atomic)
257e8d66
DK
1147 {
1148 Flags |= Replace;
257e8d66 1149 }
cd46d4eb 1150 else if ((OpenMode & (Exclusive | Create)) == (Exclusive | Create))
257e8d66
DK
1151 {
1152 // for atomic, this will be done by rename in Close()
ce1f3a2c 1153 RemoveFile("FileFd::Open", FileName);
257e8d66 1154 }
cd46d4eb 1155 if ((OpenMode & Empty) == Empty)
578bfd0a 1156 {
257e8d66
DK
1157 struct stat Buf;
1158 if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
ce1f3a2c 1159 RemoveFile("FileFd::Open", FileName);
257e8d66 1160 }
c4fc2fd7 1161
561f860a 1162 int fileflags = 0;
cd46d4eb 1163 #define if_FLAGGED_SET(FLAG, MODE) if ((OpenMode & FLAG) == FLAG) fileflags |= MODE
561f860a
DK
1164 if_FLAGGED_SET(ReadWrite, O_RDWR);
1165 else if_FLAGGED_SET(ReadOnly, O_RDONLY);
1166 else if_FLAGGED_SET(WriteOnly, O_WRONLY);
4a9db827 1167
561f860a
DK
1168 if_FLAGGED_SET(Create, O_CREAT);
1169 if_FLAGGED_SET(Empty, O_TRUNC);
1170 if_FLAGGED_SET(Exclusive, O_EXCL);
561f860a 1171 #undef if_FLAGGED_SET
52b47296 1172
cd46d4eb 1173 if ((OpenMode & Atomic) == Atomic)
7335eebe
AGM
1174 {
1175 char *name = strdup((FileName + ".XXXXXX").c_str());
1176
dc545c0b 1177 if((iFd = mkstemp(name)) == -1)
7335eebe
AGM
1178 {
1179 free(name);
98b69f9d 1180 return FileFdErrno("mkstemp", "Could not create temporary file for %s", FileName.c_str());
7335eebe
AGM
1181 }
1182
1183 TemporaryFileName = string(name);
7335eebe 1184 free(name);
dc545c0b 1185
230e69d7
DK
1186 // umask() will always set the umask and return the previous value, so
1187 // we first set the umask and then reset it to the old value
1188 mode_t const CurrentUmask = umask(0);
1189 umask(CurrentUmask);
1190 // calculate the actual file permissions (just like open/creat)
1191 mode_t const FilePermissions = (AccessMode & ~CurrentUmask);
1192
1193 if(fchmod(iFd, FilePermissions) == -1)
dc545c0b 1194 return FileFdErrno("fchmod", "Could not change permissions for temporary file %s", TemporaryFileName.c_str());
7335eebe 1195 }
468720c5 1196 else
230e69d7 1197 iFd = open(FileName.c_str(), fileflags, AccessMode);
468720c5 1198
b711c01e 1199 this->FileName = FileName;
cd46d4eb 1200 if (iFd == -1 || OpenInternDescriptor(OpenMode, compressor) == false)
561f860a 1201 {
468720c5 1202 if (iFd != -1)
fc81e8f2 1203 {
561f860a
DK
1204 close (iFd);
1205 iFd = -1;
fc81e8f2 1206 }
ae635e3c 1207 return FileFdErrno("open",_("Could not open file %s"), FileName.c_str());
257e8d66 1208 }
578bfd0a 1209
13d87e2e
AL
1210 SetCloseExec(iFd,true);
1211 return true;
578bfd0a 1212}
257e8d66
DK
1213 /*}}}*/
1214// FileFd::OpenDescriptor - Open a filedescriptor /*{{{*/
1215// ---------------------------------------------------------------------
1216/* */
52b47296 1217bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose)
aee1aac6
DK
1218{
1219 std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
1220 std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
1221 std::string name;
bce778a3
MV
1222
1223 // compat with the old API
1224 if (Mode == ReadOnlyGzip && Compress == None)
1225 Compress = Gzip;
1226
aee1aac6
DK
1227 switch (Compress)
1228 {
1229 case None: name = "."; break;
1230 case Gzip: name = "gzip"; break;
1231 case Bzip2: name = "bzip2"; break;
1232 case Lzma: name = "lzma"; break;
1233 case Xz: name = "xz"; break;
1234 case Auto:
1235 case Extension:
f97bb523
DK
1236 if (AutoClose == true && Fd != -1)
1237 close(Fd);
ae635e3c 1238 return FileFdError("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
aee1aac6
DK
1239 }
1240 for (; compressor != compressors.end(); ++compressor)
1241 if (compressor->Name == name)
1242 break;
1243 if (compressor == compressors.end())
f97bb523
DK
1244 {
1245 if (AutoClose == true && Fd != -1)
1246 close(Fd);
ae635e3c 1247 return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
f97bb523 1248 }
aee1aac6
DK
1249 return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
1250}
52b47296 1251bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
144c0969
JAK
1252{
1253 Close();
1254 Flags = (AutoClose) ? FileFd::AutoClose : 0;
84baaae9 1255 iFd = Fd;
b711c01e 1256 this->FileName = "";
84baaae9 1257 if (OpenInternDescriptor(Mode, compressor) == false)
468720c5 1258 {
f97bb523 1259 if (iFd != -1 && (
84baaae9 1260 (Flags & Compressed) == Compressed ||
f97bb523
DK
1261 AutoClose == true))
1262 {
468720c5 1263 close (iFd);
f97bb523
DK
1264 iFd = -1;
1265 }
1266 return FileFdError(_("Could not open file descriptor %d"), Fd);
144c0969 1267 }
144c0969 1268 return true;
468720c5 1269}
52b47296 1270bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
468720c5 1271{
84baaae9
DK
1272 if (iFd == -1)
1273 return false;
ff477ee1
DK
1274 if (compressor.Name == "." || compressor.Binary.empty() == true)
1275 return true;
1276
7f350a37 1277#if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
69d6988a
DK
1278 // the API to open files is similar, so setup to avoid code duplicates later
1279 // and while at it ensure that we close before opening (if its a reopen)
1280 void* (*compress_open)(int, const char *) = NULL;
7f350a37
DK
1281 if (false)
1282 /* dummy so that the rest can be 'else if's */;
4239dbca 1283#define APT_COMPRESS_INIT(NAME,OPEN) \
7f350a37 1284 else if (compressor.Name == NAME) \
69d6988a
DK
1285 { \
1286 compress_open = (void*(*)(int, const char *)) OPEN; \
4239dbca 1287 if (d != NULL) d->InternalClose(FileName); \
69d6988a
DK
1288 }
1289#ifdef HAVE_ZLIB
4239dbca 1290 APT_COMPRESS_INIT("gzip", gzdopen)
69d6988a
DK
1291#endif
1292#ifdef HAVE_BZ2
4239dbca 1293 APT_COMPRESS_INIT("bzip2", BZ2_bzdopen)
69d6988a 1294#endif
7f350a37 1295#ifdef HAVE_LZMA
4239dbca
DK
1296 APT_COMPRESS_INIT("xz", fdopen)
1297 APT_COMPRESS_INIT("lzma", fdopen)
7f350a37 1298#endif
69d6988a
DK
1299#undef APT_COMPRESS_INIT
1300#endif
1301
ba667cf7
DK
1302 if (d == NULL)
1303 {
1304 d = new FileFdPrivate();
1305 d->openmode = Mode;
1306 d->compressor = compressor;
7f350a37 1307#if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
f6ffe501 1308 if ((Flags & AutoClose) != AutoClose && compress_open != NULL)
84baaae9
DK
1309 {
1310 // Need to duplicate fd here or gz/bz2 close for cleanup will close the fd as well
1311 int const internFd = dup(iFd);
1312 if (internFd == -1)
1313 return FileFdErrno("OpenInternDescriptor", _("Could not open file descriptor %d"), iFd);
1314 iFd = internFd;
1315 }
69d6988a 1316#endif
ba667cf7 1317 }
ff477ee1 1318
7f350a37 1319#if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
69d6988a 1320 if (compress_open != NULL)
468720c5 1321 {
69d6988a 1322 void* compress_struct = NULL;
468720c5 1323 if ((Mode & ReadWrite) == ReadWrite)
69d6988a 1324 compress_struct = compress_open(iFd, "r+");
468720c5 1325 else if ((Mode & WriteOnly) == WriteOnly)
69d6988a 1326 compress_struct = compress_open(iFd, "w");
468720c5 1327 else
69d6988a
DK
1328 compress_struct = compress_open(iFd, "r");
1329 if (compress_struct == NULL)
468720c5 1330 return false;
69d6988a 1331
7f350a37
DK
1332 if (false)
1333 /* dummy so that the rest can be 'else if's */;
69d6988a 1334#ifdef HAVE_ZLIB
7f350a37 1335 else if (compressor.Name == "gzip")
69d6988a 1336 d->gz = (gzFile) compress_struct;
699b209e 1337#endif
c4997486 1338#ifdef HAVE_BZ2
7f350a37 1339 else if (compressor.Name == "bzip2")
69d6988a 1340 d->bz2 = (BZFILE*) compress_struct;
7f350a37
DK
1341#endif
1342#ifdef HAVE_LZMA
1343 else if (compressor.Name == "xz" || compressor.Name == "lzma")
adbd7eb4 1344 {
7f350a37
DK
1345 uint32_t const xzlevel = 6;
1346 uint64_t const memlimit = UINT64_MAX;
1347 if (d->lzma == NULL)
1348 d->lzma = new FileFdPrivate::LZMAFILE;
1349 d->lzma->file = (FILE*) compress_struct;
21ea1dbb
MV
1350 lzma_stream tmp_stream = LZMA_STREAM_INIT;
1351 d->lzma->stream = tmp_stream;
7f350a37
DK
1352
1353 if ((Mode & ReadWrite) == ReadWrite)
1354 return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1355
1356 if ((Mode & WriteOnly) == WriteOnly)
1357 {
1358 if (compressor.Name == "xz")
1359 {
1360 if (lzma_easy_encoder(&d->lzma->stream, xzlevel, LZMA_CHECK_CRC32) != LZMA_OK)
1361 return false;
1362 }
1363 else
1364 {
1365 lzma_options_lzma options;
1366 lzma_lzma_preset(&options, xzlevel);
1367 if (lzma_alone_encoder(&d->lzma->stream, &options) != LZMA_OK)
1368 return false;
1369 }
1370 d->lzma->compressing = true;
1371 }
1372 else
1373 {
1374 if (compressor.Name == "xz")
1375 {
1376 if (lzma_auto_decoder(&d->lzma->stream, memlimit, 0) != LZMA_OK)
1377 return false;
1378 }
1379 else
1380 {
1381 if (lzma_alone_decoder(&d->lzma->stream, memlimit) != LZMA_OK)
1382 return false;
1383 }
1384 d->lzma->compressing = false;
1385 }
adbd7eb4 1386 }
69d6988a 1387#endif
c4997486
DK
1388 Flags |= Compressed;
1389 return true;
1390 }
1391#endif
1392
adbd7eb4
DK
1393 // collect zombies here in case we reopen
1394 if (d->compressor_pid > 0)
1395 ExecWait(d->compressor_pid, "FileFdCompressor", true);
561f860a
DK
1396
1397 if ((Mode & ReadWrite) == ReadWrite)
ae635e3c 1398 return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
561f860a
DK
1399
1400 bool const Comp = (Mode & WriteOnly) == WriteOnly;
561f860a
DK
1401 if (Comp == false)
1402 {
adbd7eb4 1403 // Handle 'decompression' of empty files
561f860a
DK
1404 struct stat Buf;
1405 fstat(iFd, &Buf);
1406 if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1407 return true;
1408
1409 // We don't need the file open - instead let the compressor open it
1410 // as he properly knows better how to efficiently read from 'his' file
1411 if (FileName.empty() == false)
afb093cd 1412 {
561f860a 1413 close(iFd);
afb093cd
DK
1414 iFd = -1;
1415 }
561f860a
DK
1416 }
1417
1418 // Create a data pipe
1419 int Pipe[2] = {-1,-1};
1420 if (pipe(Pipe) != 0)
ae635e3c 1421 return FileFdErrno("pipe",_("Failed to create subprocess IPC"));
561f860a
DK
1422 for (int J = 0; J != 2; J++)
1423 SetCloseExec(Pipe[J],true);
1424
1425 d->compressed_fd = iFd;
1426 d->pipe = true;
1427
1428 if (Comp == true)
1429 iFd = Pipe[1];
1430 else
1431 iFd = Pipe[0];
1432
1433 // The child..
1434 d->compressor_pid = ExecFork();
1435 if (d->compressor_pid == 0)
1436 {
1437 if (Comp == true)
1438 {
1439 dup2(d->compressed_fd,STDOUT_FILENO);
1440 dup2(Pipe[0],STDIN_FILENO);
1441 }
1442 else
1443 {
7f350a37 1444 if (d->compressed_fd != -1)
561f860a
DK
1445 dup2(d->compressed_fd,STDIN_FILENO);
1446 dup2(Pipe[1],STDOUT_FILENO);
1447 }
0b4895d3
DK
1448 int const nullfd = open("/dev/null", O_WRONLY);
1449 if (nullfd != -1)
1450 {
1451 dup2(nullfd,STDERR_FILENO);
1452 close(nullfd);
1453 }
561f860a
DK
1454
1455 SetCloseExec(STDOUT_FILENO,false);
1456 SetCloseExec(STDIN_FILENO,false);
1457
1458 std::vector<char const*> Args;
1459 Args.push_back(compressor.Binary.c_str());
1460 std::vector<std::string> const * const addArgs =
1461 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1462 for (std::vector<std::string>::const_iterator a = addArgs->begin();
1463 a != addArgs->end(); ++a)
1464 Args.push_back(a->c_str());
1465 if (Comp == false && FileName.empty() == false)
1466 {
bb93178b
DK
1467 // commands not needing arguments, do not need to be told about using standard output
1468 // in reality, only testcases with tools like cat, rev, rot13, … are able to trigger this
1469 if (compressor.CompressArgs.empty() == false && compressor.UncompressArgs.empty() == false)
1470 Args.push_back("--stdout");
561f860a
DK
1471 if (TemporaryFileName.empty() == false)
1472 Args.push_back(TemporaryFileName.c_str());
1473 else
1474 Args.push_back(FileName.c_str());
1475 }
1476 Args.push_back(NULL);
1477
1478 execvp(Args[0],(char **)&Args[0]);
1479 cerr << _("Failed to exec compressor ") << Args[0] << endl;
1480 _exit(100);
1481 }
1482 if (Comp == true)
1483 close(Pipe[0]);
468720c5 1484 else
561f860a 1485 close(Pipe[1]);
561f860a 1486
468720c5 1487 return true;
144c0969 1488}
578bfd0a 1489 /*}}}*/
8e06abb2 1490// FileFd::~File - Closes the file /*{{{*/
578bfd0a
AL
1491// ---------------------------------------------------------------------
1492/* If the proper modes are selected then we close the Fd and possibly
1493 unlink the file on error. */
8e06abb2 1494FileFd::~FileFd()
578bfd0a
AL
1495{
1496 Close();
500400fe 1497 if (d != NULL)
500400fe 1498 d->CloseDown(FileName);
96ab3c6f
MV
1499 delete d;
1500 d = NULL;
578bfd0a
AL
1501}
1502 /*}}}*/
8e06abb2 1503// FileFd::Read - Read a bit of the file /*{{{*/
578bfd0a 1504// ---------------------------------------------------------------------
1e3f4083 1505/* We are careful to handle interruption by a signal while reading
b0db36b1 1506 gracefully. */
650faab0 1507bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
578bfd0a 1508{
3286ad13 1509 ssize_t Res;
b0db36b1 1510 errno = 0;
f604cf55
AL
1511 if (Actual != 0)
1512 *Actual = 0;
699b209e 1513 *((char *)To) = '\0';
b0db36b1 1514 do
578bfd0a 1515 {
7f350a37
DK
1516 if (false)
1517 /* dummy so that the rest can be 'else if's */;
7efb8c8e 1518#ifdef HAVE_ZLIB
7f350a37 1519 else if (d != NULL && d->gz != NULL)
c4997486 1520 Res = gzread(d->gz,To,Size);
c4997486
DK
1521#endif
1522#ifdef HAVE_BZ2
7f350a37 1523 else if (d != NULL && d->bz2 != NULL)
c4997486 1524 Res = BZ2_bzread(d->bz2,To,Size);
699b209e 1525#endif
7f350a37
DK
1526#ifdef HAVE_LZMA
1527 else if (d != NULL && d->lzma != NULL)
1528 {
1529 if (d->lzma->eof == true)
1530 break;
1531
1532 d->lzma->stream.next_out = (uint8_t *) To;
1533 d->lzma->stream.avail_out = Size;
1534 if (d->lzma->stream.avail_in == 0)
1535 {
1536 d->lzma->stream.next_in = d->lzma->buffer;
1537 d->lzma->stream.avail_in = fread(d->lzma->buffer, 1, sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]), d->lzma->file);
1538 }
1539 d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1540 if (d->lzma->err == LZMA_STREAM_END)
1541 {
1542 d->lzma->eof = true;
1543 Res = Size - d->lzma->stream.avail_out;
1544 }
1545 else if (d->lzma->err != LZMA_OK)
1546 {
1547 Res = -1;
1548 errno = 0;
1549 }
1550 else
c4b113e6 1551 {
7f350a37 1552 Res = Size - d->lzma->stream.avail_out;
c4b113e6
DK
1553 if (Res == 0)
1554 {
1555 // lzma run was okay, but produced no output…
1556 Res = -1;
1557 errno = EINTR;
1558 }
1559 }
7f350a37
DK
1560 }
1561#endif
1562 else
a3a03f5d 1563 Res = read(iFd,To,Size);
b711c01e 1564
b0db36b1
AL
1565 if (Res < 0)
1566 {
b711c01e 1567 if (errno == EINTR)
c4b113e6
DK
1568 {
1569 // trick the while-loop into running again
1570 Res = 1;
1571 errno = 0;
b711c01e 1572 continue;
c4b113e6 1573 }
7f350a37
DK
1574 if (false)
1575 /* dummy so that the rest can be 'else if's */;
7efb8c8e 1576#ifdef HAVE_ZLIB
7f350a37 1577 else if (d != NULL && d->gz != NULL)
b711c01e
DK
1578 {
1579 int err;
1580 char const * const errmsg = gzerror(d->gz, &err);
1581 if (err != Z_ERRNO)
ae635e3c 1582 return FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
b711c01e 1583 }
c4997486
DK
1584#endif
1585#ifdef HAVE_BZ2
7f350a37 1586 else if (d != NULL && d->bz2 != NULL)
c4997486
DK
1587 {
1588 int err;
1589 char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1590 if (err != BZ_IO_ERROR)
c36db2b5 1591 return FileFdError("BZ2_bzread: %s %s (%d: %s)", FileName.c_str(), _("Read error"), err, errmsg);
c4997486 1592 }
7f350a37
DK
1593#endif
1594#ifdef HAVE_LZMA
1595 else if (d != NULL && d->lzma != NULL)
1596 return FileFdError("lzma_read: %s (%d)", _("Read error"), d->lzma->err);
b711c01e 1597#endif
ae635e3c 1598 return FileFdErrno("read",_("Read error"));
b0db36b1 1599 }
578bfd0a 1600
b0db36b1
AL
1601 To = (char *)To + Res;
1602 Size -= Res;
ff477ee1
DK
1603 if (d != NULL)
1604 d->seekpos += Res;
f604cf55
AL
1605 if (Actual != 0)
1606 *Actual += Res;
b0db36b1
AL
1607 }
1608 while (Res > 0 && Size > 0);
1609
1610 if (Size == 0)
1611 return true;
1612
ddc1d8d0 1613 // Eof handling
f604cf55 1614 if (Actual != 0)
ddc1d8d0
AL
1615 {
1616 Flags |= HitEof;
1617 return true;
1618 }
ae635e3c
DK
1619
1620 return FileFdError(_("read, still have %llu to read but none left"), Size);
578bfd0a
AL
1621}
1622 /*}}}*/
032bd56f
DK
1623// FileFd::ReadLine - Read a complete line from the file /*{{{*/
1624// ---------------------------------------------------------------------
1625/* Beware: This method can be quiet slow for big buffers on UNcompressed
1626 files because of the naive implementation! */
1627char* FileFd::ReadLine(char *To, unsigned long long const Size)
1628{
699b209e 1629 *To = '\0';
7efb8c8e 1630#ifdef HAVE_ZLIB
ff477ee1 1631 if (d != NULL && d->gz != NULL)
032bd56f 1632 return gzgets(d->gz, To, Size);
699b209e 1633#endif
032bd56f
DK
1634
1635 unsigned long long read = 0;
40468850
DK
1636 while ((Size - 1) != read)
1637 {
1638 unsigned long long done = 0;
1639 if (Read(To + read, 1, &done) == false)
1640 return NULL;
1641 if (done == 0)
1642 break;
1643 if (To[read++] == '\n')
1644 break;
1645 }
1646 if (read == 0)
032bd56f 1647 return NULL;
40468850 1648 To[read] = '\0';
032bd56f
DK
1649 return To;
1650}
1651 /*}}}*/
8e06abb2 1652// FileFd::Write - Write to the file /*{{{*/
578bfd0a
AL
1653// ---------------------------------------------------------------------
1654/* */
650faab0 1655bool FileFd::Write(const void *From,unsigned long long Size)
578bfd0a 1656{
3286ad13 1657 ssize_t Res;
b0db36b1
AL
1658 errno = 0;
1659 do
578bfd0a 1660 {
7f350a37
DK
1661 if (false)
1662 /* dummy so that the rest can be 'else if's */;
7efb8c8e 1663#ifdef HAVE_ZLIB
7f350a37
DK
1664 else if (d != NULL && d->gz != NULL)
1665 Res = gzwrite(d->gz,From,Size);
c4997486
DK
1666#endif
1667#ifdef HAVE_BZ2
7f350a37
DK
1668 else if (d != NULL && d->bz2 != NULL)
1669 Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
699b209e 1670#endif
7f350a37
DK
1671#ifdef HAVE_LZMA
1672 else if (d != NULL && d->lzma != NULL)
1673 {
1674 d->lzma->stream.next_in = (uint8_t *)From;
1675 d->lzma->stream.avail_in = Size;
1676 d->lzma->stream.next_out = d->lzma->buffer;
1677 d->lzma->stream.avail_out = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]);
1678 d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1679 if (d->lzma->err != LZMA_OK)
1680 return false;
1681 size_t const n = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]) - d->lzma->stream.avail_out;
1682 size_t const m = (n == 0) ? 0 : fwrite(d->lzma->buffer, 1, n, d->lzma->file);
1683 if (m != n)
1684 Res = -1;
1685 else
1686 Res = Size - d->lzma->stream.avail_in;
1687 }
699b209e 1688#endif
7f350a37
DK
1689 else
1690 Res = write(iFd,From,Size);
1691
b0db36b1
AL
1692 if (Res < 0 && errno == EINTR)
1693 continue;
1694 if (Res < 0)
1695 {
7f350a37
DK
1696 if (false)
1697 /* dummy so that the rest can be 'else if's */;
c4997486 1698#ifdef HAVE_ZLIB
7f350a37 1699 else if (d != NULL && d->gz != NULL)
c4997486
DK
1700 {
1701 int err;
1702 char const * const errmsg = gzerror(d->gz, &err);
1703 if (err != Z_ERRNO)
ae635e3c 1704 return FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
c4997486
DK
1705 }
1706#endif
1707#ifdef HAVE_BZ2
7f350a37 1708 else if (d != NULL && d->bz2 != NULL)
c4997486
DK
1709 {
1710 int err;
1711 char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1712 if (err != BZ_IO_ERROR)
ae635e3c 1713 return FileFdError("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
c4997486 1714 }
7f350a37
DK
1715#endif
1716#ifdef HAVE_LZMA
1717 else if (d != NULL && d->lzma != NULL)
1718 return FileFdErrno("lzma_fwrite", _("Write error"));
c4997486 1719#endif
ae635e3c 1720 return FileFdErrno("write",_("Write error"));
b0db36b1
AL
1721 }
1722
cf4ff3b7 1723 From = (char const *)From + Res;
b0db36b1 1724 Size -= Res;
ff477ee1
DK
1725 if (d != NULL)
1726 d->seekpos += Res;
578bfd0a 1727 }
b0db36b1 1728 while (Res > 0 && Size > 0);
578bfd0a 1729
b0db36b1
AL
1730 if (Size == 0)
1731 return true;
ae635e3c
DK
1732
1733 return FileFdError(_("write, still have %llu to write but couldn't"), Size);
d68d65ad
DK
1734}
1735bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1736{
3286ad13 1737 ssize_t Res;
d68d65ad
DK
1738 errno = 0;
1739 do
1740 {
1741 Res = write(Fd,From,Size);
1742 if (Res < 0 && errno == EINTR)
1743 continue;
1744 if (Res < 0)
1745 return _error->Errno("write",_("Write error"));
1746
cf4ff3b7 1747 From = (char const *)From + Res;
d68d65ad
DK
1748 Size -= Res;
1749 }
1750 while (Res > 0 && Size > 0);
1751
1752 if (Size == 0)
1753 return true;
1754
1755 return _error->Error(_("write, still have %llu to write but couldn't"), Size);
578bfd0a
AL
1756}
1757 /*}}}*/
8e06abb2 1758// FileFd::Seek - Seek in the file /*{{{*/
578bfd0a
AL
1759// ---------------------------------------------------------------------
1760/* */
650faab0 1761bool FileFd::Seek(unsigned long long To)
578bfd0a 1762{
bb93178b
DK
1763 Flags &= ~HitEof;
1764
4239dbca 1765 if (d != NULL && (d->pipe == true || d->InternalStream() == true))
699b209e 1766 {
1abbc47c
DK
1767 // Our poor man seeking in pipes is costly, so try to avoid it
1768 unsigned long long seekpos = Tell();
1769 if (seekpos == To)
1770 return true;
1771 else if (seekpos < To)
1772 return Skip(To - seekpos);
1773
561f860a 1774 if ((d->openmode & ReadOnly) != ReadOnly)
ae635e3c 1775 return FileFdError("Reopen is only implemented for read-only files!");
4239dbca 1776 d->InternalClose(FileName);
afb093cd
DK
1777 if (iFd != -1)
1778 close(iFd);
1779 iFd = -1;
561f860a
DK
1780 if (TemporaryFileName.empty() == false)
1781 iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1782 else if (FileName.empty() == false)
1783 iFd = open(FileName.c_str(), O_RDONLY);
1784 else
6fd947bd
DK
1785 {
1786 if (d->compressed_fd > 0)
1787 if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1788 iFd = d->compressed_fd;
500400fe 1789 if (iFd < 0)
ae635e3c 1790 return FileFdError("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
6fd947bd 1791 }
561f860a
DK
1792
1793 if (OpenInternDescriptor(d->openmode, d->compressor) == false)
ae635e3c 1794 return FileFdError("Seek on file %s because it couldn't be reopened", FileName.c_str());
561f860a
DK
1795
1796 if (To != 0)
1797 return Skip(To);
1abbc47c
DK
1798
1799 d->seekpos = To;
561f860a 1800 return true;
699b209e 1801 }
3286ad13 1802 off_t res;
7efb8c8e 1803#ifdef HAVE_ZLIB
ff477ee1 1804 if (d != NULL && d->gz)
032bd56f 1805 res = gzseek(d->gz,To,SEEK_SET);
a3a03f5d 1806 else
699b209e 1807#endif
a3a03f5d 1808 res = lseek(iFd,To,SEEK_SET);
3286ad13 1809 if (res != (off_t)To)
ae635e3c 1810 return FileFdError("Unable to seek to %llu", To);
1abbc47c 1811
ff477ee1
DK
1812 if (d != NULL)
1813 d->seekpos = To;
727f18af
AL
1814 return true;
1815}
1816 /*}}}*/
1817// FileFd::Skip - Seek in the file /*{{{*/
1818// ---------------------------------------------------------------------
1819/* */
650faab0 1820bool FileFd::Skip(unsigned long long Over)
727f18af 1821{
4239dbca 1822 if (d != NULL && (d->pipe == true || d->InternalStream() == true))
40468850 1823 {
40468850
DK
1824 char buffer[1024];
1825 while (Over != 0)
1826 {
1827 unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1828 if (Read(buffer, toread) == false)
ae635e3c 1829 return FileFdError("Unable to seek ahead %llu",Over);
40468850
DK
1830 Over -= toread;
1831 }
1832 return true;
1833 }
1834
3286ad13 1835 off_t res;
7efb8c8e 1836#ifdef HAVE_ZLIB
ff477ee1 1837 if (d != NULL && d->gz != NULL)
032bd56f 1838 res = gzseek(d->gz,Over,SEEK_CUR);
a3a03f5d 1839 else
699b209e 1840#endif
a3a03f5d 1841 res = lseek(iFd,Over,SEEK_CUR);
1842 if (res < 0)
ae635e3c 1843 return FileFdError("Unable to seek ahead %llu",Over);
ff477ee1
DK
1844 if (d != NULL)
1845 d->seekpos = res;
1abbc47c 1846
6d5dd02a
AL
1847 return true;
1848}
1849 /*}}}*/
1850// FileFd::Truncate - Truncate the file /*{{{*/
1851// ---------------------------------------------------------------------
1852/* */
650faab0 1853bool FileFd::Truncate(unsigned long long To)
6d5dd02a 1854{
ad5051ef
DK
1855 // truncating /dev/null is always successful - as we get an error otherwise
1856 if (To == 0 && FileName == "/dev/null")
1857 return true;
7f350a37 1858#if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
4239dbca 1859 if (d != NULL && (d->InternalStream() == true
7f350a37 1860#ifdef HAVE_ZLIB
4239dbca 1861 || d->gz != NULL
7f350a37 1862#endif
4239dbca 1863 ))
ae635e3c 1864 return FileFdError("Truncating compressed files is not implemented (%s)", FileName.c_str());
c4997486 1865#endif
6d5dd02a 1866 if (ftruncate(iFd,To) != 0)
ae635e3c
DK
1867 return FileFdError("Unable to truncate to %llu",To);
1868
578bfd0a
AL
1869 return true;
1870}
1871 /*}}}*/
7f25bdff
AL
1872// FileFd::Tell - Current seek position /*{{{*/
1873// ---------------------------------------------------------------------
1874/* */
650faab0 1875unsigned long long FileFd::Tell()
7f25bdff 1876{
1abbc47c
DK
1877 // In theory, we could just return seekpos here always instead of
1878 // seeking around, but not all users of FileFd use always Seek() and co
1879 // so d->seekpos isn't always true and we can just use it as a hint if
1880 // we have nothing else, but not always as an authority…
4239dbca 1881 if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1abbc47c
DK
1882 return d->seekpos;
1883
a3a03f5d 1884 off_t Res;
7efb8c8e 1885#ifdef HAVE_ZLIB
ff477ee1 1886 if (d != NULL && d->gz != NULL)
032bd56f 1887 Res = gztell(d->gz);
a3a03f5d 1888 else
699b209e 1889#endif
a3a03f5d 1890 Res = lseek(iFd,0,SEEK_CUR);
7f25bdff 1891 if (Res == (off_t)-1)
ae635e3c 1892 FileFdErrno("lseek","Failed to determine the current file position");
ff477ee1
DK
1893 if (d != NULL)
1894 d->seekpos = Res;
7f25bdff
AL
1895 return Res;
1896}
1897 /*}}}*/
8190b07a 1898static bool StatFileFd(char const * const msg, int const iFd, std::string const &FileName, struct stat &Buf, FileFdPrivate * const d) /*{{{*/
578bfd0a 1899{
6008b79a
DK
1900 bool ispipe = (d != NULL && d->pipe == true);
1901 if (ispipe == false)
1902 {
1903 if (fstat(iFd,&Buf) != 0)
8190b07a
DK
1904 // higher-level code will generate more meaningful messages,
1905 // even translated this would be meaningless for users
1906 return _error->Errno("fstat", "Unable to determine %s for fd %i", msg, iFd);
003c40d3
DK
1907 if (FileName.empty() == false)
1908 ispipe = S_ISFIFO(Buf.st_mode);
6008b79a 1909 }
699b209e
DK
1910
1911 // for compressor pipes st_size is undefined and at 'best' zero
6008b79a 1912 if (ispipe == true)
699b209e
DK
1913 {
1914 // we set it here, too, as we get the info here for free
1915 // in theory the Open-methods should take care of it already
ff477ee1
DK
1916 if (d != NULL)
1917 d->pipe = true;
699b209e 1918 if (stat(FileName.c_str(), &Buf) != 0)
8190b07a
DK
1919 return _error->Errno("fstat", "Unable to determine %s for file %s", msg, FileName.c_str());
1920 }
1921 return true;
1922}
1923 /*}}}*/
1924// FileFd::FileSize - Return the size of the file /*{{{*/
1925unsigned long long FileFd::FileSize()
1926{
1927 struct stat Buf;
1928 if (StatFileFd("file size", iFd, FileName, Buf, d) == false)
1929 {
1930 Flags |= Fail;
1931 return 0;
699b209e 1932 }
4260fd39
DK
1933 return Buf.st_size;
1934}
1935 /*}}}*/
8190b07a
DK
1936// FileFd::ModificationTime - Return the time of last touch /*{{{*/
1937time_t FileFd::ModificationTime()
1938{
1939 struct stat Buf;
1940 if (StatFileFd("modification time", iFd, FileName, Buf, d) == false)
1941 {
1942 Flags |= Fail;
1943 return 0;
1944 }
1945 return Buf.st_mtime;
1946}
1947 /*}}}*/
4260fd39
DK
1948// FileFd::Size - Return the size of the content in the file /*{{{*/
1949// ---------------------------------------------------------------------
1950/* */
650faab0 1951unsigned long long FileFd::Size()
4260fd39 1952{
650faab0 1953 unsigned long long size = FileSize();
44dc669e 1954
699b209e
DK
1955 // for compressor pipes st_size is undefined and at 'best' zero,
1956 // so we 'read' the content and 'seek' back - see there
4239dbca 1957 if (d != NULL && (d->pipe == true || (d->InternalStream() == true && size > 0)))
699b209e 1958 {
1abbc47c 1959 unsigned long long const oldSeek = Tell();
699b209e
DK
1960 char ignore[1000];
1961 unsigned long long read = 0;
1962 do {
638593bd
DK
1963 if (Read(ignore, sizeof(ignore), &read) == false)
1964 {
1965 Seek(oldSeek);
1966 return 0;
1967 }
699b209e 1968 } while(read != 0);
1abbc47c
DK
1969 size = Tell();
1970 Seek(oldSeek);
699b209e 1971 }
7efb8c8e 1972#ifdef HAVE_ZLIB
44dc669e 1973 // only check gzsize if we are actually a gzip file, just checking for
032bd56f 1974 // "gz" is not sufficient as uncompressed files could be opened with
44dc669e 1975 // gzopen in "direct" mode as well
ff477ee1 1976 else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
9c182afa 1977 {
65c72a4b 1978 off_t const oldPos = lseek(iFd,0,SEEK_CUR);
9c182afa
MP
1979 /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1980 * this ourselves; the original (uncompressed) file size is the last 32
1981 * bits of the file */
650faab0 1982 // FIXME: Size for gz-files is limited by 32bit… no largefile support
9c182afa 1983 if (lseek(iFd, -4, SEEK_END) < 0)
fbb89d94 1984 {
638593bd
DK
1985 FileFdErrno("lseek","Unable to seek to end of gzipped file");
1986 return 0;
fbb89d94 1987 }
05eab8af 1988 uint32_t size = 0;
9c182afa 1989 if (read(iFd, &size, 4) != 4)
fbb89d94 1990 {
638593bd
DK
1991 FileFdErrno("read","Unable to read original size of gzipped file");
1992 return 0;
fbb89d94 1993 }
05eab8af 1994 size = le32toh(size);
9c182afa 1995
65c72a4b 1996 if (lseek(iFd, oldPos, SEEK_SET) < 0)
fbb89d94 1997 {
638593bd
DK
1998 FileFdErrno("lseek","Unable to seek in gzipped file");
1999 return 0;
fbb89d94 2000 }
65c72a4b 2001
9c182afa
MP
2002 return size;
2003 }
699b209e 2004#endif
9c182afa 2005
44dc669e 2006 return size;
578bfd0a
AL
2007}
2008 /*}}}*/
8e06abb2 2009// FileFd::Close - Close the file if the close flag is set /*{{{*/
578bfd0a
AL
2010// ---------------------------------------------------------------------
2011/* */
8e06abb2 2012bool FileFd::Close()
578bfd0a 2013{
032bd56f
DK
2014 if (iFd == -1)
2015 return true;
2016
578bfd0a
AL
2017 bool Res = true;
2018 if ((Flags & AutoClose) == AutoClose)
d13c2d3f 2019 {
500400fe
DK
2020 if ((Flags & Compressed) != Compressed && iFd > 0 && close(iFd) != 0)
2021 Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
2da8aae5
JAK
2022 }
2023
2024 if (d != NULL)
2025 {
2026 Res &= d->CloseDown(FileName);
2027 delete d;
2028 d = NULL;
d13c2d3f 2029 }
3010fb0e 2030
d3aac32e 2031 if ((Flags & Replace) == Replace) {
3010fb0e 2032 if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
62d073d9
DK
2033 Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
2034
fd3b761e 2035 FileName = TemporaryFileName; // for the unlink() below.
257e8d66 2036 TemporaryFileName.clear();
3010fb0e 2037 }
62d073d9
DK
2038
2039 iFd = -1;
2040
578bfd0a
AL
2041 if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
2042 FileName.empty() == false)
ce1f3a2c 2043 Res &= RemoveFile("FileFd::Close", FileName);
3010fb0e 2044
fbb89d94
DK
2045 if (Res == false)
2046 Flags |= Fail;
578bfd0a
AL
2047 return Res;
2048}
2049 /*}}}*/
b2e465d6
AL
2050// FileFd::Sync - Sync the file /*{{{*/
2051// ---------------------------------------------------------------------
2052/* */
2053bool FileFd::Sync()
2054{
b2e465d6 2055 if (fsync(iFd) != 0)
ae635e3c
DK
2056 return FileFdErrno("sync",_("Problem syncing the file"));
2057 return true;
2058}
2059 /*}}}*/
2060// FileFd::FileFdErrno - set Fail and call _error->Errno *{{{*/
2061bool FileFd::FileFdErrno(const char *Function, const char *Description,...)
2062{
2063 Flags |= Fail;
2064 va_list args;
2065 size_t msgSize = 400;
2066 int const errsv = errno;
2067 while (true)
fbb89d94 2068 {
ae635e3c
DK
2069 va_start(args,Description);
2070 if (_error->InsertErrno(GlobalError::ERROR, Function, Description, args, errsv, msgSize) == false)
2071 break;
2072 va_end(args);
fbb89d94 2073 }
ae635e3c
DK
2074 return false;
2075}
2076 /*}}}*/
2077// FileFd::FileFdError - set Fail and call _error->Error *{{{*/
2078bool FileFd::FileFdError(const char *Description,...) {
2079 Flags |= Fail;
2080 va_list args;
2081 size_t msgSize = 400;
2082 while (true)
2083 {
2084 va_start(args,Description);
2085 if (_error->Insert(GlobalError::ERROR, Description, args, msgSize) == false)
2086 break;
2087 va_end(args);
2088 }
2089 return false;
b2e465d6
AL
2090}
2091 /*}}}*/
699b209e 2092
7f350a37
DK
2093APT_DEPRECATED gzFile FileFd::gzFd() {
2094#ifdef HAVE_ZLIB
2095 return d->gz;
2096#else
2097 return NULL;
2098#endif
2099}
8d01b9d6 2100
f8aba23f 2101// Glob - wrapper around "glob()" /*{{{*/
8d01b9d6
MV
2102std::vector<std::string> Glob(std::string const &pattern, int flags)
2103{
2104 std::vector<std::string> result;
2105 glob_t globbuf;
ec4835a1
ÁGM
2106 int glob_res;
2107 unsigned int i;
8d01b9d6
MV
2108
2109 glob_res = glob(pattern.c_str(), flags, NULL, &globbuf);
2110
2111 if (glob_res != 0)
2112 {
2113 if(glob_res != GLOB_NOMATCH) {
2114 _error->Errno("glob", "Problem with glob");
2115 return result;
2116 }
2117 }
2118
2119 // append results
2120 for(i=0;i<globbuf.gl_pathc;i++)
2121 result.push_back(string(globbuf.gl_pathv[i]));
2122
2123 globfree(&globbuf);
2124 return result;
2125}
2126 /*}}}*/
f8aba23f 2127std::string GetTempDir() /*{{{*/
68e01721
MV
2128{
2129 const char *tmpdir = getenv("TMPDIR");
2130
2131#ifdef P_tmpdir
2132 if (!tmpdir)
2133 tmpdir = P_tmpdir;
2134#endif
2135
68e01721 2136 struct stat st;
0d303f17 2137 if (!tmpdir || strlen(tmpdir) == 0 || // tmpdir is set
dd6da7d2
DK
2138 stat(tmpdir, &st) != 0 || (st.st_mode & S_IFDIR) == 0) // exists and is directory
2139 tmpdir = "/tmp";
2140 else if (geteuid() != 0 && // root can do everything anyway
2141 faccessat(-1, tmpdir, R_OK | W_OK | X_OK, AT_EACCESS | AT_SYMLINK_NOFOLLOW) != 0) // current user has rwx access to directory
68e01721
MV
2142 tmpdir = "/tmp";
2143
2144 return string(tmpdir);
dd6da7d2
DK
2145}
2146std::string GetTempDir(std::string const &User)
2147{
2148 // no need/possibility to drop privs
2149 if(getuid() != 0 || User.empty() || User == "root")
2150 return GetTempDir();
2151
2152 struct passwd const * const pw = getpwnam(User.c_str());
2153 if (pw == NULL)
2154 return GetTempDir();
2155
226c0f64
DK
2156 gid_t const old_euid = geteuid();
2157 gid_t const old_egid = getegid();
dd6da7d2
DK
2158 if (setegid(pw->pw_gid) != 0)
2159 _error->Errno("setegid", "setegid %u failed", pw->pw_gid);
2160 if (seteuid(pw->pw_uid) != 0)
2161 _error->Errno("seteuid", "seteuid %u failed", pw->pw_uid);
2162
2163 std::string const tmp = GetTempDir();
2164
226c0f64
DK
2165 if (seteuid(old_euid) != 0)
2166 _error->Errno("seteuid", "seteuid %u failed", old_euid);
2167 if (setegid(old_egid) != 0)
2168 _error->Errno("setegid", "setegid %u failed", old_egid);
dd6da7d2
DK
2169
2170 return tmp;
68e01721 2171}
f8aba23f 2172 /*}}}*/
c9443c01 2173FileFd* GetTempFile(std::string const &Prefix, bool ImmediateUnlink, FileFd * const TmpFd) /*{{{*/
0d29b9d4
MV
2174{
2175 char fn[512];
c9443c01 2176 FileFd * const Fd = TmpFd == NULL ? new FileFd() : TmpFd;
0d29b9d4 2177
c9443c01
DK
2178 std::string const tempdir = GetTempDir();
2179 snprintf(fn, sizeof(fn), "%s/%s.XXXXXX",
0d29b9d4 2180 tempdir.c_str(), Prefix.c_str());
c9443c01 2181 int const fd = mkstemp(fn);
0d29b9d4
MV
2182 if(ImmediateUnlink)
2183 unlink(fn);
c9443c01 2184 if (fd < 0)
0d29b9d4
MV
2185 {
2186 _error->Errno("GetTempFile",_("Unable to mkstemp %s"), fn);
2187 return NULL;
2188 }
c9443c01 2189 if (!Fd->OpenDescriptor(fd, FileFd::ReadWrite, FileFd::None, true))
0d29b9d4
MV
2190 {
2191 _error->Errno("GetTempFile",_("Unable to write to %s"),fn);
2192 return NULL;
2193 }
0d29b9d4
MV
2194 return Fd;
2195}
f8aba23f
DK
2196 /*}}}*/
2197bool Rename(std::string From, std::string To) /*{{{*/
c1409d1b
MV
2198{
2199 if (rename(From.c_str(),To.c_str()) != 0)
2200 {
2201 _error->Error(_("rename failed, %s (%s -> %s)."),strerror(errno),
2202 From.c_str(),To.c_str());
2203 return false;
f8aba23f 2204 }
c1409d1b
MV
2205 return true;
2206}
f8aba23f
DK
2207 /*}}}*/
2208bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode)/*{{{*/
7ad2a347
MV
2209{
2210 int fd;
2211 if (Mode != FileFd::ReadOnly && Mode != FileFd::WriteOnly)
2212 return _error->Error("Popen supports ReadOnly (x)or WriteOnly mode only");
2213
2214 int Pipe[2] = {-1, -1};
2215 if(pipe(Pipe) != 0)
7ad2a347 2216 return _error->Errno("pipe", _("Failed to create subprocess IPC"));
5e49cbb7 2217
7ad2a347
MV
2218 std::set<int> keep_fds;
2219 keep_fds.insert(Pipe[0]);
2220 keep_fds.insert(Pipe[1]);
2221 Child = ExecFork(keep_fds);
2222 if(Child < 0)
2223 return _error->Errno("fork", "Failed to fork");
2224 if(Child == 0)
2225 {
2226 if(Mode == FileFd::ReadOnly)
2227 {
2228 close(Pipe[0]);
2229 fd = Pipe[1];
2230 }
2231 else if(Mode == FileFd::WriteOnly)
2232 {
2233 close(Pipe[1]);
2234 fd = Pipe[0];
2235 }
2236
2237 if(Mode == FileFd::ReadOnly)
2238 {
2239 dup2(fd, 1);
2240 dup2(fd, 2);
2241 } else if(Mode == FileFd::WriteOnly)
2242 dup2(fd, 0);
2243
2244 execv(Args[0], (char**)Args);
2245 _exit(100);
2246 }
2247 if(Mode == FileFd::ReadOnly)
2248 {
2249 close(Pipe[1]);
2250 fd = Pipe[0];
8f5b67ae
DK
2251 }
2252 else if(Mode == FileFd::WriteOnly)
7ad2a347
MV
2253 {
2254 close(Pipe[0]);
2255 fd = Pipe[1];
2256 }
8f5b67ae
DK
2257 else
2258 return _error->Error("Popen supports ReadOnly (x)or WriteOnly mode only");
7ad2a347
MV
2259 Fd.OpenDescriptor(fd, Mode, FileFd::None, true);
2260
2261 return true;
2262}
f8aba23f
DK
2263 /*}}}*/
2264bool DropPrivileges() /*{{{*/
fc1a78d8 2265{
8f45798d
DK
2266 if(_config->FindB("Debug::NoDropPrivs", false) == true)
2267 return true;
2268
2269#if __gnu_linux__
2270#if defined(PR_SET_NO_NEW_PRIVS) && ( PR_SET_NO_NEW_PRIVS != 38 )
2271#error "PR_SET_NO_NEW_PRIVS is defined, but with a different value than expected!"
2272#endif
2273 // see prctl(2), needs linux3.5 at runtime - magic constant to avoid it at buildtime
2274 int ret = prctl(38, 1, 0, 0, 0);
2275 // ignore EINVAL - kernel is too old to understand the option
2276 if(ret < 0 && errno != EINVAL)
2277 _error->Warning("PR_SET_NO_NEW_PRIVS failed with %i", ret);
2278#endif
2279
990dd78a
DK
2280 // empty setting disables privilege dropping - this also ensures
2281 // backward compatibility, see bug #764506
2282 const std::string toUser = _config->Find("APT::Sandbox::User");
2283 if (toUser.empty())
2284 return true;
2285
f1e3c8f0 2286 // uid will be 0 in the end, but gid might be different anyway
8f45798d
DK
2287 uid_t const old_uid = getuid();
2288 gid_t const old_gid = getgid();
fc1a78d8 2289
5f2047ec
JAK
2290 if (old_uid != 0)
2291 return true;
3927c6da 2292
b8dae9a1 2293 struct passwd *pw = getpwnam(toUser.c_str());
fc1a78d8 2294 if (pw == NULL)
b8dae9a1 2295 return _error->Error("No user %s, can not drop rights", toUser.c_str());
3927c6da 2296
f1e3c8f0 2297 // Do not change the order here, it might break things
5a326439 2298 // Get rid of all our supplementary groups first
3b084f06 2299 if (setgroups(1, &pw->pw_gid))
3927c6da
MV
2300 return _error->Errno("setgroups", "Failed to setgroups");
2301
5a326439
JAK
2302 // Now change the group ids to the new user
2303#ifdef HAVE_SETRESGID
2304 if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) != 0)
2305 return _error->Errno("setresgid", "Failed to set new group ids");
2306#else
3927c6da 2307 if (setegid(pw->pw_gid) != 0)
5f2047ec
JAK
2308 return _error->Errno("setegid", "Failed to setegid");
2309
fc1a78d8
MV
2310 if (setgid(pw->pw_gid) != 0)
2311 return _error->Errno("setgid", "Failed to setgid");
5a326439 2312#endif
5f2047ec 2313
5a326439
JAK
2314 // Change the user ids to the new user
2315#ifdef HAVE_SETRESUID
2316 if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) != 0)
2317 return _error->Errno("setresuid", "Failed to set new user ids");
2318#else
fc1a78d8
MV
2319 if (setuid(pw->pw_uid) != 0)
2320 return _error->Errno("setuid", "Failed to setuid");
5f2047ec
JAK
2321 if (seteuid(pw->pw_uid) != 0)
2322 return _error->Errno("seteuid", "Failed to seteuid");
5a326439 2323#endif
5f2047ec 2324
f1e3c8f0 2325 // Verify that the user has only a single group, and the correct one
5f2047ec
JAK
2326 gid_t groups[1];
2327 if (getgroups(1, groups) != 1)
2328 return _error->Errno("getgroups", "Could not get new groups");
2329 if (groups[0] != pw->pw_gid)
2330 return _error->Error("Could not switch group");
f1e3c8f0
JAK
2331
2332 // Verify that gid, egid, uid, and euid changed
5f2047ec
JAK
2333 if (getgid() != pw->pw_gid)
2334 return _error->Error("Could not switch group");
2335 if (getegid() != pw->pw_gid)
2336 return _error->Error("Could not switch effective group");
2337 if (getuid() != pw->pw_uid)
2338 return _error->Error("Could not switch user");
2339 if (geteuid() != pw->pw_uid)
2340 return _error->Error("Could not switch effective user");
2341
550ab420 2342#ifdef HAVE_GETRESUID
48ed0977 2343 // verify that the saved set-user-id was changed as well
550ab420
JAK
2344 uid_t ruid = 0;
2345 uid_t euid = 0;
2346 uid_t suid = 0;
2347 if (getresuid(&ruid, &euid, &suid))
2348 return _error->Errno("getresuid", "Could not get saved set-user-ID");
2349 if (suid != pw->pw_uid)
2350 return _error->Error("Could not switch saved set-user-ID");
2351#endif
2352
2353#ifdef HAVE_GETRESGID
48ed0977 2354 // verify that the saved set-group-id was changed as well
550ab420
JAK
2355 gid_t rgid = 0;
2356 gid_t egid = 0;
2357 gid_t sgid = 0;
2358 if (getresgid(&rgid, &egid, &sgid))
2359 return _error->Errno("getresuid", "Could not get saved set-group-ID");
2360 if (sgid != pw->pw_gid)
2361 return _error->Error("Could not switch saved set-group-ID");
2362#endif
2363
bdc00df5
JAK
2364 // Check that uid and gid changes do not work anymore
2365 if (pw->pw_gid != old_gid && (setgid(old_gid) != -1 || setegid(old_gid) != -1))
2366 return _error->Error("Could restore a gid to root, privilege dropping did not work");
2367
2368 if (pw->pw_uid != old_uid && (setuid(old_uid) != -1 || seteuid(old_uid) != -1))
2369 return _error->Error("Could restore a uid to root, privilege dropping did not work");
2370
fc1a78d8
MV
2371 return true;
2372}
f8aba23f 2373 /*}}}*/