* Swedish translation update. Closes: #592366

[apt.git] / apt-pkg / contrib / fileutl.cc

diff --git a/apt-pkg/contrib/fileutl.cc b/apt-pkg/contrib/fileutl.cc
index cce8a451284b6fb1277e56d0f9f3071d1b87ab10..2a3b8a87daa0b062ea484f1b5d432a121e86658a 100644 (file)
--- a/apt-pkg/contrib/fileutl.cc
+++ b/apt-pkg/contrib/fileutl.cc
@@ -11,6 +11,7 @@
    Most of this source is placed in the Public Domain, do with it what 
    you will
    It was originally written by Jason Gunthorpe <jgg@debian.org>.
    Most of this source is placed in the Public Domain, do with it what 
    you will
    It was originally written by Jason Gunthorpe <jgg@debian.org>.

+   FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>

    
    The exception is RunScripts() it is under the GPLv2
 
    
    The exception is RunScripts() it is under the GPLv2
 


@@ -18,6 +19,7 @@
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/fileutl.h>
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/fileutl.h>

+#include <apt-pkg/strutl.h>

 #include <apt-pkg/error.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/configuration.h>


@@ -26,6 +28,7 @@
 
 #include <cstdlib>
 #include <cstring>
 
 #include <cstdlib>
 #include <cstring>

+#include <cstdio>

 
 #include <iostream>
 #include <unistd.h>
 
 #include <iostream>
 #include <unistd.h>


@@ -197,14 +200,90 @@ bool FileExists(string File)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// DirectoryExists - Check if a directory exists and is really one     /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool DirectoryExists(string const &Path)
+{
+   struct stat Buf;
+   if (stat(Path.c_str(),&Buf) != 0)
+      return false;
+   return ((Buf.st_mode & S_IFDIR) != 0);
+}
+                                                                       /*}}}*/
+// CreateDirectory - poor man's mkdir -p guarded by a parent directory /*{{{*/
+// ---------------------------------------------------------------------
+/* This method will create all directories needed for path in good old
+   mkdir -p style but refuses to do this if Parent is not a prefix of
+   this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
+   so it will create apt/archives if /var/cache exists - on the other
+   hand if the parent is /var/lib the creation will fail as this path
+   is not a parent of the path to be generated. */
+bool CreateDirectory(string const &Parent, string const &Path)
+{
+   if (Parent.empty() == true || Path.empty() == true)
+      return false;
+
+   if (DirectoryExists(Path) == true)
+      return true;
+
+   if (DirectoryExists(Parent) == false)
+      return false;
+
+   // we are not going to create directories "into the blue"
+   if (Path.find(Parent, 0) != 0)
+      return false;
+
+   vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
+   string progress = Parent;
+   for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
+   {
+      if (d->empty() == true)
+        continue;
+
+      progress.append("/").append(*d);
+      if (DirectoryExists(progress) == true)
+        continue;
+
+      if (mkdir(progress.c_str(), 0755) != 0)
+        return false;
+   }
+   return true;
+}
+                                                                       /*}}}*/

 // GetListOfFilesInDir - returns a vector of files in the given dir    /*{{{*/
 // ---------------------------------------------------------------------
 /* If an extension is given only files with this extension are included
    in the returned vector, otherwise every "normal" file is included. */
 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
 // GetListOfFilesInDir - returns a vector of files in the given dir    /*{{{*/
 // ---------------------------------------------------------------------
 /* If an extension is given only files with this extension are included
    in the returned vector, otherwise every "normal" file is included. */
 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,

-                                       bool const &SortList) 
+                                       bool const &SortList, bool const &AllowNoExt)

 {
 {

+   std::vector<string> ext;
+   ext.reserve(2);
+   if (Ext.empty() == false)
+      ext.push_back(Ext);
+   if (AllowNoExt == true && ext.empty() == false)
+      ext.push_back("");
+   return GetListOfFilesInDir(Dir, ext, SortList);
+}
+std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
+                                       bool const &SortList)
+{
+   // Attention debuggers: need to be set with the environment config file!
+   bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
+   if (Debug == true)
+   {
+      std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
+      if (Ext.empty() == true)
+        std::clog << "\tNO extension" << std::endl;
+      else
+        for (std::vector<string>::const_iterator e = Ext.begin();
+             e != Ext.end(); ++e)
+           std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
+   }
+

    std::vector<string> List;
    std::vector<string> List;

+   Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");

    DIR *D = opendir(Dir.c_str());
    if (D == 0) 
    {
    DIR *D = opendir(Dir.c_str());
    if (D == 0) 
    {


@@ -214,28 +293,76 @@ std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
 
    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) 
    {
 
    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) 
    {

+      // skip "hidden" files

       if (Ent->d_name[0] == '.')
         continue;
 
       if (Ent->d_name[0] == '.')
         continue;
 

-      if (Ext.empty() == false && flExtension(Ent->d_name) != Ext)
-        continue;
+      // check for accepted extension:
+      // no extension given -> periods are bad as hell!
+      // extensions given -> "" extension allows no extension
+      if (Ext.empty() == false)
+      {
+        string d_ext = flExtension(Ent->d_name);
+        if (d_ext == Ent->d_name) // no extension
+        {
+           if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
+           {
+              if (Debug == true)
+                 std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
+              _error->Notice("Ignoring file '%s' in directory '%s' as it has no filename extension", Ent->d_name, Dir.c_str());
+              continue;
+           }
+        }
+        else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
+        {
+           if (Debug == true)
+              std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
+           if (SilentIgnore.Match(Ent->d_name) == false)
+              _error->Notice("Ignoring file '%s' in directory '%s' as it has an invalid filename extension", Ent->d_name, Dir.c_str());
+           continue;
+        }
+      }

 
 

-      // Skip bad file names ala run-parts
+      // Skip bad filenames ala run-parts

       const char *C = Ent->d_name;
       for (; *C != 0; ++C)
         if (isalpha(*C) == 0 && isdigit(*C) == 0
       const char *C = Ent->d_name;
       for (; *C != 0; ++C)
         if (isalpha(*C) == 0 && isdigit(*C) == 0

-            && *C != '_' && *C != '-' && *C != '.')
+            && *C != '_' && *C != '-') {
+           // no required extension -> dot is a bad character
+           if (*C == '.' && Ext.empty() == false)
+              continue;

            break;
            break;

+        }

 
 

+      // we don't reach the end of the name -> bad character included

       if (*C != 0)
       if (*C != 0)

+      {
+        if (Debug == true)
+           std::clog << "Bad file: " << Ent->d_name << " → bad character »"
+              << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;

         continue;
         continue;

+      }
+
+      // skip filenames which end with a period. These are never valid
+      if (*(C - 1) == '.')
+      {
+        if (Debug == true)
+           std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
+        continue;
+      }

 
       // Make sure it is a file and not something else
       string const File = flCombine(Dir,Ent->d_name);
       struct stat St;
       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 
       // Make sure it is a file and not something else
       string const File = flCombine(Dir,Ent->d_name);
       struct stat St;
       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)

+      {
+        if (Debug == true)
+           std::clog << "Bad file: " << Ent->d_name << " → stat says not a good file" << std::endl;

         continue;
         continue;

+      }

 
 

+      if (Debug == true)
+        std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;

       List.push_back(File);
    }
    closedir(D);
       List.push_back(File);
    }
    closedir(D);


@@ -530,13 +657,25 @@ bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
       case ReadOnly:
       iFd = open(FileName.c_str(),O_RDONLY);
       break;
       case ReadOnly:
       iFd = open(FileName.c_str(),O_RDONLY);
       break;

+
+      case ReadOnlyGzip:
+      iFd = open(FileName.c_str(),O_RDONLY);
+      if (iFd > 0) {
+        gz = gzdopen (iFd, "r");
+        if (gz == NULL) {
+            close (iFd);
+            iFd = -1;
+        }
+      }
+      break;

       
       case WriteEmpty:
       {
       
       case WriteEmpty:
       {

-        struct stat Buf;
-        if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
-           unlink(FileName.c_str());
-        iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_TRUNC,Perms);
+        Flags |= Replace;
+        char *name = strdup((FileName + ".XXXXXX").c_str());
+        TemporaryFileName = string(mktemp(name));
+        iFd = open(TemporaryFileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
+        free(name);

         break;
       }
       
         break;
       }
       


@@ -561,6 +700,24 @@ bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
    SetCloseExec(iFd,true);
    return true;
 }
    SetCloseExec(iFd,true);
    return true;
 }

+
+bool FileFd::OpenDescriptor(int Fd, OpenMode Mode, bool AutoClose)
+{
+   Close();
+   Flags = (AutoClose) ? FileFd::AutoClose : 0;
+   iFd = Fd;
+   if (Mode == ReadOnlyGzip) {
+      gz = gzdopen (iFd, "r");
+      if (gz == NULL) {
+        if (AutoClose)
+           close (iFd);
+        return _error->Errno("gzdopen",_("Could not open file descriptor %d"),
+                             Fd);
+      }
+   }
+   this->FileName = "";
+   return true;
+}

                                                                        /*}}}*/
 // FileFd::~File - Closes the file                                     /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // FileFd::~File - Closes the file                                     /*{{{*/
 // ---------------------------------------------------------------------


@@ -584,7 +741,10 @@ bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
    
    do
    {
    
    do
    {

-      Res = read(iFd,To,Size);
+      if (gz != NULL)
+         Res = gzread(gz,To,Size);
+      else
+         Res = read(iFd,To,Size);

       if (Res < 0 && errno == EINTR)
         continue;
       if (Res < 0)
       if (Res < 0 && errno == EINTR)
         continue;
       if (Res < 0)


@@ -623,7 +783,10 @@ bool FileFd::Write(const void *From,unsigned long Size)
    errno = 0;
    do
    {
    errno = 0;
    do
    {

-      Res = write(iFd,From,Size);
+      if (gz != NULL)
+         Res = gzwrite(gz,From,Size);
+      else
+         Res = write(iFd,From,Size);

       if (Res < 0 && errno == EINTR)
         continue;
       if (Res < 0)
       if (Res < 0 && errno == EINTR)
         continue;
       if (Res < 0)


@@ -649,7 +812,12 @@ bool FileFd::Write(const void *From,unsigned long Size)
 /* */
 bool FileFd::Seek(unsigned long To)
 {
 /* */
 bool FileFd::Seek(unsigned long To)
 {

-   if (lseek(iFd,To,SEEK_SET) != (signed)To)
+   int res;
+   if (gz)
+      res = gzseek(gz,To,SEEK_SET);
+   else
+      res = lseek(iFd,To,SEEK_SET);
+   if (res != (signed)To)

    {
       Flags |= Fail;
       return _error->Error("Unable to seek to %lu",To);
    {
       Flags |= Fail;
       return _error->Error("Unable to seek to %lu",To);


@@ -663,7 +831,12 @@ bool FileFd::Seek(unsigned long To)
 /* */
 bool FileFd::Skip(unsigned long Over)
 {
 /* */
 bool FileFd::Skip(unsigned long Over)
 {

-   if (lseek(iFd,Over,SEEK_CUR) < 0)
+   int res;
+   if (gz)
+      res = gzseek(gz,Over,SEEK_CUR);
+   else
+      res = lseek(iFd,Over,SEEK_CUR);
+   if (res < 0)

    {
       Flags |= Fail;
       return _error->Error("Unable to seek ahead %lu",Over);
    {
       Flags |= Fail;
       return _error->Error("Unable to seek ahead %lu",Over);


@@ -677,6 +850,11 @@ bool FileFd::Skip(unsigned long Over)
 /* */
 bool FileFd::Truncate(unsigned long To)
 {
 /* */
 bool FileFd::Truncate(unsigned long To)
 {

+   if (gz)
+   {
+      Flags |= Fail;
+      return _error->Error("Truncating gzipped files is not implemented (%s)", FileName.c_str());
+   }

    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;
    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;


@@ -691,7 +869,11 @@ bool FileFd::Truncate(unsigned long To)
 /* */
 unsigned long FileFd::Tell()
 {
 /* */
 unsigned long FileFd::Tell()
 {

-   off_t Res = lseek(iFd,0,SEEK_CUR);
+   off_t Res;
+   if (gz)
+     Res = gztell(gz);
+   else
+     Res = lseek(iFd,0,SEEK_CUR);

    if (Res == (off_t)-1)
       _error->Errno("lseek","Failed to determine the current file position");
    return Res;
    if (Res == (off_t)-1)
       _error->Errno("lseek","Failed to determine the current file position");
    return Res;


@@ -702,6 +884,7 @@ unsigned long FileFd::Tell()
 /* */
 unsigned long FileFd::Size()
 {
 /* */
 unsigned long FileFd::Size()
 {

+   //TODO: For gz, do we need the actual file size here or the uncompressed length?

    struct stat Buf;
    if (fstat(iFd,&Buf) != 0)
       return _error->Errno("fstat","Unable to determine the file size");
    struct stat Buf;
    if (fstat(iFd,&Buf) != 0)
       return _error->Errno("fstat","Unable to determine the file size");


@@ -715,14 +898,33 @@ bool FileFd::Close()
 {
    bool Res = true;
    if ((Flags & AutoClose) == AutoClose)
 {
    bool Res = true;
    if ((Flags & AutoClose) == AutoClose)

-      if (iFd >= 0 && close(iFd) != 0)
-        Res &= _error->Errno("close",_("Problem closing the file"));
+   {
+      if (gz != NULL) {
+        int const e = gzclose(gz);
+        // gzdopen() on empty files always fails with "buffer error" here, ignore that
+        if (e != 0 && e != Z_BUF_ERROR)
+           Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
+      } else
+        if (iFd > 0 && close(iFd) != 0)
+           Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
+   }
+
+   if ((Flags & Replace) == Replace && iFd >= 0) {
+      if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
+        Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
+
+      FileName = TemporaryFileName; // for the unlink() below.
+   }
+

    iFd = -1;
    iFd = -1;

-   
+   gz = NULL;
+

    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
        FileName.empty() == false)
       if (unlink(FileName.c_str()) != 0)
    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
        FileName.empty() == false)
       if (unlink(FileName.c_str()) != 0)

-        Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
+        Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
+
+

    return Res;
 }
                                                                        /*}}}*/
    return Res;
 }
                                                                        /*}}}*/