* cmdline/apt-config.cc:

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

diff --git a/apt-pkg/contrib/fileutl.cc b/apt-pkg/contrib/fileutl.cc
index 50019872e3d3e16fbe81df2698025644e5eac4b3..d5e7192e3d4a854ed3319848602d5218736434ad 100644 (file)
--- a/apt-pkg/contrib/fileutl.cc
+++ b/apt-pkg/contrib/fileutl.cc
@@ -18,14 +18,14 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

+#include <config.h>
+

 #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/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/configuration.h>
 

-#include <apti18n.h>
-

 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>


@@ -43,10 +43,11 @@
 #include <set>
 #include <algorithm>
 
 #include <set>
 #include <algorithm>
 

-#include <config.h>

 #ifdef WORDS_BIGENDIAN
 #include <inttypes.h>
 #endif
 #ifdef WORDS_BIGENDIAN
 #include <inttypes.h>
 #endif

+
+#include <apti18n.h>

                                                                        /*}}}*/
 
 using namespace std;
                                                                        /*}}}*/
 
 using namespace std;


@@ -132,10 +133,10 @@ bool CopyFile(FileFd &From,FileFd &To)
    
    // Buffered copy between fds
    SPtrArray<unsigned char> Buf = new unsigned char[64000];
    
    // Buffered copy between fds
    SPtrArray<unsigned char> Buf = new unsigned char[64000];

-   unsigned long Size = From.Size();
+   unsigned long long Size = From.Size();

    while (Size != 0)
    {
    while (Size != 0)
    {

-      unsigned long ToRead = Size;
+      unsigned long long ToRead = Size;

       if (Size > 64000)
         ToRead = 64000;
       
       if (Size > 64000)
         ToRead = 64000;
       


@@ -446,6 +447,17 @@ string SafeGetCWD()
    return S;
 }
                                                                        /*}}}*/
    return S;
 }
                                                                        /*}}}*/

+// GetModificationTime - Get the mtime of the given file or -1 on error /*{{{*/
+// ---------------------------------------------------------------------
+/* We return / on failure. */
+time_t GetModificationTime(string const &Path)
+{
+   struct stat St;
+   if (stat(Path.c_str(), &St) < 0)
+      return -1;
+   return  St.st_mtime;
+}
+                                                                       /*}}}*/

 // flNotDir - Strip the directory from the filename                    /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // flNotDir - Strip the directory from the filename                    /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -706,69 +718,72 @@ bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 // FileFd::Open - Open a file                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* The most commonly used open mode combinations are given with Mode */
 // FileFd::Open - Open a file                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* The most commonly used open mode combinations are given with Mode */

-bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
+bool FileFd::Open(string FileName,OpenMode Mode,CompressMode Compress, unsigned long Perms)

 {
 {

+   if (Mode == ReadOnlyGzip)
+      return Open(FileName, ReadOnly, Gzip, Perms);

    Close();
    Flags = AutoClose;
    Close();
    Flags = AutoClose;

-   switch (Mode)
+
+   int fileflags = 0;
+#define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
+   if_FLAGGED_SET(ReadWrite, O_RDWR);
+   else if_FLAGGED_SET(ReadOnly, O_RDONLY);
+   else if_FLAGGED_SET(WriteOnly, O_WRONLY);
+   else return _error->Error("No openmode provided in FileFd::Open for %s", FileName.c_str());
+
+   if_FLAGGED_SET(Create, O_CREAT);
+   if_FLAGGED_SET(Exclusive, O_EXCL);
+   else if_FLAGGED_SET(Atomic, O_EXCL);
+   if_FLAGGED_SET(Empty, O_TRUNC);
+#undef if_FLAGGED_SET
+
+   if ((Mode & Atomic) == Atomic)
+   {
+      Flags |= Replace;
+      char *name = strdup((FileName + ".XXXXXX").c_str());
+      TemporaryFileName = string(mktemp(name));
+      free(name);
+   }
+   else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
+   {
+      // for atomic, this will be done by rename in Close()
+      unlink(FileName.c_str());
+   }
+   if ((Mode & Empty) == Empty)

    {
    {

-      case ReadOnly:
-      iFd = open(FileName.c_str(),O_RDONLY);
-      break;
+      struct stat Buf;
+      if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
+        unlink(FileName.c_str());
+   }

 
 

-      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 WriteAtomic:
-      {
-        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;
-      }
+   if (TemporaryFileName.empty() == false)
+      iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
+   else
+      iFd = open(FileName.c_str(), fileflags, Perms);

 
 

-      case WriteEmpty:
+   if (iFd != -1 && Compress == Gzip)
+   {
+      gz = gzdopen (iFd, "r");
+      if (gz == NULL)

       {
       {

-        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);
-        break;
+        close (iFd);
+        iFd = -1;

       }
       }

-      
-      case WriteExists:
-      iFd = open(FileName.c_str(),O_RDWR);
-      break;
-
-      case WriteAny:
-      iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
-      break;      
-
-      case WriteTemp:
-      unlink(FileName.c_str());
-      iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
-      break;
-   }  
+   }

 
 

-   if (iFd < 0)
+   if (iFd == -1)

       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());

-   
+

    this->FileName = FileName;
    SetCloseExec(iFd,true);
    return true;
 }
    this->FileName = FileName;
    SetCloseExec(iFd,true);
    return true;
 }

-
-bool FileFd::OpenDescriptor(int Fd, OpenMode Mode, bool AutoClose)
+                                                                       /*}}}*/
+// FileFd::OpenDescriptor - Open a filedescriptor                      /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool FileFd::OpenDescriptor(int Fd, OpenMode Mode, CompressMode Compress, bool AutoClose)

 {
    Close();
    Flags = (AutoClose) ? FileFd::AutoClose : 0;
 {
    Close();
    Flags = (AutoClose) ? FileFd::AutoClose : 0;


@@ -799,7 +814,7 @@ FileFd::~FileFd()
 // ---------------------------------------------------------------------
 /* We are carefull to handle interruption by a signal while reading 
    gracefully. */
 // ---------------------------------------------------------------------
 /* We are carefull to handle interruption by a signal while reading 
    gracefully. */

-bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
+bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)

 {
    int Res;
    errno = 0;
 {
    int Res;
    errno = 0;


@@ -838,13 +853,13 @@ bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
    }
    
    Flags |= Fail;
    }
    
    Flags |= Fail;

-   return _error->Error(_("read, still have %lu to read but none left"),Size);
+   return _error->Error(_("read, still have %llu to read but none left"), Size);

 }
                                                                        /*}}}*/
 // FileFd::Write - Write to the file                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 }
                                                                        /*}}}*/
 // FileFd::Write - Write to the file                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool FileFd::Write(const void *From,unsigned long Size)
+bool FileFd::Write(const void *From,unsigned long long Size)

 {
    int Res;
    errno = 0;
 {
    int Res;
    errno = 0;


@@ -871,13 +886,13 @@ bool FileFd::Write(const void *From,unsigned long Size)
       return true;
    
    Flags |= Fail;
       return true;
    
    Flags |= Fail;

-   return _error->Error(_("write, still have %lu to write but couldn't"),Size);
+   return _error->Error(_("write, still have %llu to write but couldn't"), Size);

 }
                                                                        /*}}}*/
 // FileFd::Seek - Seek in the file                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 }
                                                                        /*}}}*/
 // FileFd::Seek - Seek in the file                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool FileFd::Seek(unsigned long To)
+bool FileFd::Seek(unsigned long long To)

 {
    int res;
    if (gz)
 {
    int res;
    if (gz)


@@ -887,7 +902,7 @@ bool FileFd::Seek(unsigned long To)
    if (res != (signed)To)
    {
       Flags |= Fail;
    if (res != (signed)To)
    {
       Flags |= Fail;

-      return _error->Error("Unable to seek to %lu",To);
+      return _error->Error("Unable to seek to %llu", To);

    }
    
    return true;
    }
    
    return true;


@@ -896,7 +911,7 @@ bool FileFd::Seek(unsigned long To)
 // FileFd::Skip - Seek in the file                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Skip - Seek in the file                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool FileFd::Skip(unsigned long Over)
+bool FileFd::Skip(unsigned long long Over)

 {
    int res;
    if (gz)
 {
    int res;
    if (gz)


@@ -906,7 +921,7 @@ bool FileFd::Skip(unsigned long Over)
    if (res < 0)
    {
       Flags |= Fail;
    if (res < 0)
    {
       Flags |= Fail;

-      return _error->Error("Unable to seek ahead %lu",Over);
+      return _error->Error("Unable to seek ahead %llu",Over);

    }
    
    return true;
    }
    
    return true;


@@ -915,7 +930,7 @@ bool FileFd::Skip(unsigned long Over)
 // FileFd::Truncate - Truncate the file                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Truncate - Truncate the file                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool FileFd::Truncate(unsigned long To)
+bool FileFd::Truncate(unsigned long long To)

 {
    if (gz)
    {
 {
    if (gz)
    {


@@ -925,7 +940,7 @@ bool FileFd::Truncate(unsigned long To)
    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;
    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;

-      return _error->Error("Unable to truncate to %lu",To);
+      return _error->Error("Unable to truncate to %llu",To);

    }
    
    return true;
    }
    
    return true;


@@ -934,7 +949,7 @@ bool FileFd::Truncate(unsigned long To)
 // FileFd::Tell - Current seek position                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Tell - Current seek position                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-unsigned long FileFd::Tell()
+unsigned long long FileFd::Tell()

 {
    off_t Res;
    if (gz)
 {
    off_t Res;
    if (gz)


@@ -949,7 +964,7 @@ unsigned long FileFd::Tell()
 // FileFd::FileSize - Return the size of the file                      /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::FileSize - Return the size of the file                      /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-unsigned long FileFd::FileSize()
+unsigned long long FileFd::FileSize()

 {
    struct stat Buf;
 
 {
    struct stat Buf;
 


@@ -961,9 +976,9 @@ unsigned long FileFd::FileSize()
 // FileFd::Size - Return the size of the content in the file           /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Size - Return the size of the content in the file           /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-unsigned long FileFd::Size()
+unsigned long long FileFd::Size()

 {
 {

-   unsigned long size = FileSize();
+   unsigned long long size = FileSize();

 
    // only check gzsize if we are actually a gzip file, just checking for
    // "gz" is not sufficient as uncompressed files will be opened with
 
    // only check gzsize if we are actually a gzip file, just checking for
    // "gz" is not sufficient as uncompressed files will be opened with


@@ -973,6 +988,7 @@ unsigned long FileFd::Size()
        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
        * this ourselves; the original (uncompressed) file size is the last 32
        * bits of the file */
        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
        * this ourselves; the original (uncompressed) file size is the last 32
        * bits of the file */

+       // FIXME: Size for gz-files is limited by 32bit… no largefile support

        off_t orig_pos = lseek(iFd, 0, SEEK_CUR);
        if (lseek(iFd, -4, SEEK_END) < 0)
           return _error->Errno("lseek","Unable to seek to end of gzipped file");
        off_t orig_pos = lseek(iFd, 0, SEEK_CUR);
        if (lseek(iFd, -4, SEEK_END) < 0)
           return _error->Errno("lseek","Unable to seek to end of gzipped file");


@@ -1018,6 +1034,7 @@ bool FileFd::Close()
         Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
 
       FileName = TemporaryFileName; // for the unlink() below.
         Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
 
       FileName = TemporaryFileName; // for the unlink() below.

+      TemporaryFileName.clear();

    }
 
    iFd = -1;
    }
 
    iFd = -1;