correct IndexDiff vs DiffIndex in Debug output

[apt.git] / methods / rred.cc

diff --git a/methods/rred.cc b/methods/rred.cc
index 262c78cabdfa99a2425767199ae6ff7ff7fbc00f..bea8ed263c100931eda64494f38d125448b3bb35 100644 (file)
--- a/methods/rred.cc
+++ b/methods/rred.cc
@@ -1,13 +1,18 @@
 // Includes                                                                    /*{{{*/
 // Includes                                                                    /*{{{*/

+#include <config.h>
+

 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/mmap.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/acquire-method.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/hashes.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/mmap.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/acquire-method.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/hashes.h>

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

 
 #include <sys/stat.h>
 #include <sys/uio.h>
 
 #include <sys/stat.h>
 #include <sys/uio.h>

+#include <sys/types.h>
+#include <fcntl.h>

 #include <unistd.h>
 #include <utime.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <utime.h>
 #include <stdio.h>


@@ -33,10 +38,10 @@ class RredMethod : public pkgAcqMethod {
        // return values
        enum State {ED_OK, ED_ORDERING, ED_PARSER, ED_FAILURE, MMAP_FAILED};
 
        // return values
        enum State {ED_OK, ED_ORDERING, ED_PARSER, ED_FAILURE, MMAP_FAILED};
 

-       State applyFile(FILE *ed_cmds, FILE *in_file, FILE *out_file,
+       State applyFile(FileFd &ed_cmds, FileFd &in_file, FileFd &out_file,

                     unsigned long &line, char *buffer, Hashes *hash) const;
                     unsigned long &line, char *buffer, Hashes *hash) const;

-       void ignoreLineInFile(FILE *fin, char *buffer) const;
-       void copyLinesFromFileToFile(FILE *fin, FILE *fout, unsigned int lines,
+       void ignoreLineInFile(FileFd &fin, char *buffer) const;
+       void copyLinesFromFileToFile(FileFd &fin, FileFd &fout, unsigned int lines,

                                    Hashes *hash, char *buffer) const;
 
        State patchFile(FileFd &Patch, FileFd &From, FileFd &out_file, Hashes *hash) const;
                                    Hashes *hash, char *buffer) const;
 
        State patchFile(FileFd &Patch, FileFd &From, FileFd &out_file, Hashes *hash) const;


@@ -47,7 +52,7 @@ protected:
        virtual bool Fetch(FetchItem *Itm);
 
 public:
        virtual bool Fetch(FetchItem *Itm);
 
 public:

-       RredMethod() : pkgAcqMethod("1.1",SingleInstance | SendConfig) {};
+       RredMethod() : pkgAcqMethod("1.1",SingleInstance | SendConfig), Debug(false) {};

 };
                                                                                /*}}}*/
 /** \brief applyFile - in reverse order with a tail recursion                  {{{
 };
                                                                                /*}}}*/
 /** \brief applyFile - in reverse order with a tail recursion                  {{{


@@ -65,10 +70,10 @@ public:
  *  \param hash the created file for correctness
  *  \return the success State of the ed command executor
  */
  *  \param hash the created file for correctness
  *  \return the success State of the ed command executor
  */

-RredMethod::State RredMethod::applyFile(FILE *ed_cmds, FILE *in_file, FILE *out_file,
+RredMethod::State RredMethod::applyFile(FileFd &ed_cmds, FileFd &in_file, FileFd &out_file,

                        unsigned long &line, char *buffer, Hashes *hash) const {
        // get the current command and parse it
                        unsigned long &line, char *buffer, Hashes *hash) const {
        // get the current command and parse it

-       if (fgets(buffer, BUF_SIZE, ed_cmds) == NULL) {
+       if (ed_cmds.ReadLine(buffer, BUF_SIZE) == NULL) {

                if (Debug == true)
                        std::clog << "rred: encounter end of file - we can start patching now." << std::endl;
                line = 0;
                if (Debug == true)
                        std::clog << "rred: encounter end of file - we can start patching now." << std::endl;
                line = 0;


@@ -123,7 +128,7 @@ RredMethod::State RredMethod::applyFile(FILE *ed_cmds, FILE *in_file, FILE *out_
        unsigned char mode = *idx;
 
        // save the current position
        unsigned char mode = *idx;
 
        // save the current position

-       unsigned const long pos = ftell(ed_cmds);
+       unsigned const long long pos = ed_cmds.Tell();

 
        // if this is add or change then go to the next full stop
        unsigned int data_length = 0;
 
        // if this is add or change then go to the next full stop
        unsigned int data_length = 0;


@@ -157,7 +162,7 @@ RredMethod::State RredMethod::applyFile(FILE *ed_cmds, FILE *in_file, FILE *out_
 
        // include data from ed script
        if (mode == MODE_CHANGED || mode == MODE_ADDED) {
 
        // include data from ed script
        if (mode == MODE_CHANGED || mode == MODE_ADDED) {

-               fseek(ed_cmds, pos, SEEK_SET);
+               ed_cmds.Seek(pos);

                copyLinesFromFileToFile(ed_cmds, out_file, data_length, hash, buffer);
        }
 
                copyLinesFromFileToFile(ed_cmds, out_file, data_length, hash, buffer);
        }
 


@@ -171,23 +176,24 @@ RredMethod::State RredMethod::applyFile(FILE *ed_cmds, FILE *in_file, FILE *out_
        return ED_OK;
 }
                                                                                /*}}}*/
        return ED_OK;
 }
                                                                                /*}}}*/

-void RredMethod::copyLinesFromFileToFile(FILE *fin, FILE *fout, unsigned int lines,/*{{{*/
+void RredMethod::copyLinesFromFileToFile(FileFd &fin, FileFd &fout, unsigned int lines,/*{{{*/

                                        Hashes *hash, char *buffer) const {
        while (0 < lines--) {
                do {
                                        Hashes *hash, char *buffer) const {
        while (0 < lines--) {
                do {

-                       fgets(buffer, BUF_SIZE, fin);
-                       size_t const written = fwrite(buffer, 1, strlen(buffer), fout);
-                       hash->Add((unsigned char*)buffer, written);
+                       fin.ReadLine(buffer, BUF_SIZE);
+                       unsigned long long const towrite = strlen(buffer);
+                       fout.Write(buffer, towrite);
+                       hash->Add((unsigned char*)buffer, towrite);

                } while (strlen(buffer) == (BUF_SIZE - 1) &&
                       buffer[BUF_SIZE - 2] != '\n');
        }
 }
                                                                                /*}}}*/
                } while (strlen(buffer) == (BUF_SIZE - 1) &&
                       buffer[BUF_SIZE - 2] != '\n');
        }
 }
                                                                                /*}}}*/

-void RredMethod::ignoreLineInFile(FILE *fin, char *buffer) const {             /*{{{*/
-       fgets(buffer, BUF_SIZE, fin);
+void RredMethod::ignoreLineInFile(FileFd &fin, char *buffer) const {           /*{{{*/
+       fin.ReadLine(buffer, BUF_SIZE);

        while (strlen(buffer) == (BUF_SIZE - 1) &&
               buffer[BUF_SIZE - 2] != '\n') {
        while (strlen(buffer) == (BUF_SIZE - 1) &&
               buffer[BUF_SIZE - 2] != '\n') {

-               fgets(buffer, BUF_SIZE, fin);
+               fin.ReadLine(buffer, BUF_SIZE);

                buffer[0] = ' ';
        }
 }
                buffer[0] = ' ';
        }
 }


@@ -195,26 +201,25 @@ void RredMethod::ignoreLineInFile(FILE *fin, char *buffer) const {                /*{{{*/
 RredMethod::State RredMethod::patchFile(FileFd &Patch, FileFd &From,           /*{{{*/
                                        FileFd &out_file, Hashes *hash) const {
    char buffer[BUF_SIZE];
 RredMethod::State RredMethod::patchFile(FileFd &Patch, FileFd &From,           /*{{{*/
                                        FileFd &out_file, Hashes *hash) const {
    char buffer[BUF_SIZE];

-   FILE* fFrom = fdopen(From.Fd(), "r");
-   FILE* fPatch = fdopen(Patch.Fd(), "r");
-   FILE* fTo = fdopen(out_file.Fd(), "w");

 
    /* we do a tail recursion to read the commands in the right order */
    unsigned long line = -1; // assign highest possible value
 
    /* we do a tail recursion to read the commands in the right order */
    unsigned long line = -1; // assign highest possible value

-   State const result = applyFile(fPatch, fFrom, fTo, line, buffer, hash);
+   State const result = applyFile(Patch, From, out_file, line, buffer, hash);

    
    /* read the rest from infile */
    if (result == ED_OK) {
    
    /* read the rest from infile */
    if (result == ED_OK) {

-      while (fgets(buffer, BUF_SIZE, fFrom) != NULL) {
-         size_t const written = fwrite(buffer, 1, strlen(buffer), fTo);
-         hash->Add((unsigned char*)buffer, written);
+      while (From.ReadLine(buffer, BUF_SIZE) != NULL) {
+        unsigned long long const towrite = strlen(buffer);
+        out_file.Write(buffer, towrite);
+        hash->Add((unsigned char*)buffer, towrite);

       }
       }

-      fflush(fTo);

    }
    return result;
 }
                                                                                /*}}}*/
    }
    return result;
 }
                                                                                /*}}}*/

-struct EdCommand {                                                             /*{{{*/
+/* struct EdCommand                                                            {{{*/
+#ifdef _POSIX_MAPPED_FILES
+struct EdCommand {

   size_t data_start;
   size_t data_end;
   size_t data_lines;
   size_t data_start;
   size_t data_end;
   size_t data_lines;


@@ -223,6 +228,22 @@ struct EdCommand {                                                         /*{{{*/
   char type;
 };
 #define IOV_COUNT 1024 /* Don't really want IOV_MAX since it can be arbitrarily large */
   char type;
 };
 #define IOV_COUNT 1024 /* Don't really want IOV_MAX since it can be arbitrarily large */

+static ssize_t retry_writev(int fd, const struct iovec *iov, int iovcnt) {
+       ssize_t Res;
+       errno = 0;
+       ssize_t i = 0;
+       do {
+               Res = writev(fd, iov + i, iovcnt);
+               if (Res < 0 && errno == EINTR)
+                       continue;
+               if (Res < 0)
+                       return _error->Errno("writev",_("Write error"));
+               iovcnt -= Res;
+               i += Res;
+       } while (Res > 0 && iovcnt > 0);
+       return i;
+}
+#endif

                                                                                /*}}}*/
 RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,           /*{{{*/
                                        FileFd &out_file, Hashes *hash) const {
                                                                                /*}}}*/
 RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,           /*{{{*/
                                        FileFd &out_file, Hashes *hash) const {


@@ -230,7 +251,9 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,                /*{{{*/
        MMap ed_cmds(Patch, MMap::ReadOnly);
        MMap in_file(From, MMap::ReadOnly);
 
        MMap ed_cmds(Patch, MMap::ReadOnly);
        MMap in_file(From, MMap::ReadOnly);
 

-       if (ed_cmds.Size() == 0 || in_file.Size() == 0)
+       unsigned long long const ed_size = ed_cmds.Size();
+       unsigned long long const in_size = in_file.Size();
+       if (ed_size == 0 || in_size == 0)

                return MMAP_FAILED;
 
        EdCommand* commands = 0;
                return MMAP_FAILED;
 
        EdCommand* commands = 0;


@@ -239,10 +262,10 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,              /*{{{*/
 
        const char* begin = (char*) ed_cmds.Data();
        const char* end = begin;
 
        const char* begin = (char*) ed_cmds.Data();
        const char* end = begin;

-       const char* ed_end = (char*) ed_cmds.Data() + ed_cmds.Size();
+       const char* ed_end = (char*) ed_cmds.Data() + ed_size;

 
        const char* input = (char*) in_file.Data();
 
        const char* input = (char*) in_file.Data();

-       const char* input_end = (char*) in_file.Data() + in_file.Size();
+       const char* input_end = (char*) in_file.Data() + in_size;

 
        size_t i;
 
 
        size_t i;
 


@@ -326,7 +349,12 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,               /*{{{*/
                }
                if(command_count == command_alloc) {
                        command_alloc = (command_alloc + 64) * 3 / 2;
                }
                if(command_count == command_alloc) {
                        command_alloc = (command_alloc + 64) * 3 / 2;

-                       commands = (EdCommand*) realloc(commands, command_alloc * sizeof(EdCommand));
+                       EdCommand* newCommands = (EdCommand*) realloc(commands, command_alloc * sizeof(EdCommand));
+                       if (newCommands == NULL) {
+                               free(commands);
+                               return MMAP_FAILED;
+                       }
+                       commands = newCommands;

                }
                commands[command_count++] = cmd;
        }
                }
                commands[command_count++] = cmd;
        }


@@ -365,7 +393,7 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,                /*{{{*/
                        hash->Add((const unsigned char*) begin, input - begin);
 
                        if(++iov_size == IOV_COUNT) {
                        hash->Add((const unsigned char*) begin, input - begin);
 
                        if(++iov_size == IOV_COUNT) {

-                               writev(out_file.Fd(), iov, IOV_COUNT);
+                               retry_writev(out_file.Fd(), iov, IOV_COUNT);

                                iov_size = 0;
                        }
                }
                                iov_size = 0;
                        }
                }


@@ -390,7 +418,7 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,                /*{{{*/
                                iov[iov_size].iov_len);
 
                                if(++iov_size == IOV_COUNT) {
                                iov[iov_size].iov_len);
 
                                if(++iov_size == IOV_COUNT) {

-                                       writev(out_file.Fd(), iov, IOV_COUNT);
+                                       retry_writev(out_file.Fd(), iov, IOV_COUNT);

                                        iov_size = 0;
                                }
                        }
                                        iov_size = 0;
                                }
                        }


@@ -405,15 +433,15 @@ RredMethod::State RredMethod::patchMMap(FileFd &Patch, FileFd &From,              /*{{{*/
        }
 
        if(iov_size) {
        }
 
        if(iov_size) {

-               writev(out_file.Fd(), iov, iov_size);
+               retry_writev(out_file.Fd(), iov, iov_size);

                iov_size = 0;
        }
 
        for(i = 0; i < iov_size; i += IOV_COUNT) {
                if(iov_size - i < IOV_COUNT)
                iov_size = 0;
        }
 
        for(i = 0; i < iov_size; i += IOV_COUNT) {
                if(iov_size - i < IOV_COUNT)

-                       writev(out_file.Fd(), iov + i, iov_size - i);
+                       retry_writev(out_file.Fd(), iov + i, iov_size - i);

                else
                else

-                       writev(out_file.Fd(), iov + i, IOV_COUNT);
+                       retry_writev(out_file.Fd(), iov + i, IOV_COUNT);

        }
 
        delete [] iov;
        }
 
        delete [] iov;


@@ -429,7 +457,7 @@ bool RredMethod::Fetch(FetchItem *Itm)                                              /*{{{*/
 {
    Debug = _config->FindB("Debug::pkgAcquire::RRed", false);
    URI Get = Itm->Uri;
 {
    Debug = _config->FindB("Debug::pkgAcquire::RRed", false);
    URI Get = Itm->Uri;

-   string Path = Get.Host + Get.Path; // To account for relative paths
+   std::string Path = Get.Host + Get.Path; // To account for relative paths

 
    FetchResult Res;
    Res.Filename = Itm->DestFile;
 
    FetchResult Res;
    Res.Filename = Itm->DestFile;


@@ -439,61 +467,126 @@ bool RredMethod::Fetch(FetchItem *Itm)                                           /*{{{*/
    } else
       URIStart(Res);
 
    } else
       URIStart(Res);
 

-   if (Debug == true) 
-      std::clog << "Patching " << Path << " with " << Path 
-         << ".ed and putting result into " << Itm->DestFile << std::endl;
-   // Open the source and destination files (the d'tor of FileFd will do 
-   // the cleanup/closing of the fds)
-   FileFd From(Path,FileFd::ReadOnly);
-   FileFd Patch(Path+".ed",FileFd::ReadOnly);
-   FileFd To(Itm->DestFile,FileFd::WriteEmpty);   
-   To.EraseOnFailure();
-   if (_error->PendingError() == true)
-      return false;
-   
+   std::string lastPatchName;

    Hashes Hash;
    Hashes Hash;

-   // now do the actual patching
-   State const result = patchMMap(Patch, From, To, &Hash);
-   if (result == MMAP_FAILED) {
-      // retry with patchFile
-      lseek(Patch.Fd(), 0, SEEK_SET);
-      lseek(From.Fd(), 0, SEEK_SET);
-      To.Open(Itm->DestFile,FileFd::WriteEmpty);
+
+   // check for a single ed file
+   if (FileExists(Path+".ed") == true)
+   {
+      if (Debug == true)
+        std::clog << "Patching " << Path << " with " << Path
+           << ".ed and putting result into " << Itm->DestFile << std::endl;
+
+      // Open the source and destination files
+      lastPatchName = Path + ".ed";
+      FileFd From(Path,FileFd::ReadOnly);
+      FileFd To(Itm->DestFile,FileFd::WriteAtomic);
+      To.EraseOnFailure();
+      FileFd Patch(lastPatchName, FileFd::ReadOnly, FileFd::Gzip);

       if (_error->PendingError() == true)
       if (_error->PendingError() == true)

-         return false;
-      if (patchFile(Patch, From, To, &Hash) != ED_OK) {
-        return _error->WarningE("rred", _("Could not patch %s with mmap and with file operation usage - the patch seems to be corrupt."), Path.c_str());
+        return false;
+
+      // now do the actual patching
+      State const result = patchMMap(Patch, From, To, &Hash);
+      if (result == MMAP_FAILED) {
+        // retry with patchFile
+        Patch.Seek(0);
+        From.Seek(0);
+        To.Open(Itm->DestFile,FileFd::WriteAtomic);
+        if (_error->PendingError() == true)
+           return false;
+        if (patchFile(Patch, From, To, &Hash) != ED_OK) {
+           return _error->WarningE("rred", _("Could not patch %s with mmap and with file operation usage - the patch seems to be corrupt."), Path.c_str());
+        } else if (Debug == true) {
+           std::clog << "rred: finished file patching of " << Path  << " after mmap failed." << std::endl;
+        }
+      } else if (result != ED_OK) {
+        return _error->Errno("rred", _("Could not patch %s with mmap (but no mmap specific fail) - the patch seems to be corrupt."), Path.c_str());

       } else if (Debug == true) {
       } else if (Debug == true) {

-        std::clog << "rred: finished file patching of " << Path  << " after mmap failed." << std::endl;
+        std::clog << "rred: finished mmap patching of " << Path << std::endl;

       }
       }

-   } else if (result != ED_OK) {
-      return _error->Errno("rred", _("Could not patch %s with mmap (but no mmap specific fail) - the patch seems to be corrupt."), Path.c_str());
-   } else if (Debug == true) {
-      std::clog << "rred: finished mmap patching of " << Path << std::endl;
+
+      // write out the result
+      From.Close();
+      Patch.Close();
+      To.Close();

    }
    }

+   else
+   {
+      if (Debug == true)
+        std::clog << "Patching " << Path << " with all " << Path << ".ed.*.gz files and "
+           << "putting result into " << Itm->DestFile << std::endl;
+
+      int From = open(Path.c_str(), O_RDONLY);
+      unlink(Itm->DestFile.c_str());
+      int To = open(Itm->DestFile.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0644);
+      SetCloseExec(From, false);
+      SetCloseExec(To, false);
+
+      _error->PushToStack();
+      std::vector<std::string> patches = GetListOfFilesInDir(flNotFile(Path), "gz", true, false);
+      _error->RevertToStack();
+
+      std::string externalrred = _config->Find("Dir::Bin::rred", "/usr/bin/diffindex-rred");
+      std::vector<const char *> Args;
+      Args.reserve(22);
+      Args.push_back(externalrred.c_str());
+
+      std::string const baseName = Path + ".ed.";
+      for (std::vector<std::string>::const_iterator p = patches.begin();
+           p != patches.end(); ++p)
+        if (p->compare(0, baseName.length(), baseName) == 0)
+           Args.push_back(p->c_str());
+
+      Args.push_back(NULL);
+
+      pid_t Patcher = ExecFork();
+      if (Patcher == 0) {
+        dup2(From, STDIN_FILENO);
+        dup2(To, STDOUT_FILENO);
+
+        execvp(Args[0], (char **) &Args[0]);
+        std::cerr << "Failed to execute patcher " << Args[0] << "!" << std::endl;
+        _exit(100);
+      }
+      // last is NULL, so the one before is the last patch
+      lastPatchName = Args[Args.size() - 2];
+
+      if (ExecWait(Patcher, "rred") == false)
+        return _error->Errno("rred", "Patching via external rred failed");

 
 

-   // write out the result
-   From.Close();
-   Patch.Close();
-   To.Close();
+      close(From);
+      close(To);
+
+      struct stat Buf;
+      if (stat(Itm->DestFile.c_str(), &Buf) != 0)
+        return _error->Errno("stat",_("Failed to stat"));
+
+      To = open(Path.c_str(), O_RDONLY);
+      Hash.AddFD(To, Buf.st_size);
+      close(To);
+   }

 
 

-   // Transfer the modification times
-   struct stat Buf;
-   if (stat(Path.c_str(),&Buf) != 0)
+   /* Transfer the modification times from the patch file
+      to be able to see in which state the file should be
+      and use the access time from the "old" file */
+   struct stat BufBase, BufPatch;
+   if (stat(Path.c_str(),&BufBase) != 0 ||
+        stat(lastPatchName.c_str(), &BufPatch) != 0)

       return _error->Errno("stat",_("Failed to stat"));
 
    struct utimbuf TimeBuf;
       return _error->Errno("stat",_("Failed to stat"));
 
    struct utimbuf TimeBuf;

-   TimeBuf.actime = Buf.st_atime;
-   TimeBuf.modtime = Buf.st_mtime;
+   TimeBuf.actime = BufBase.st_atime;
+   TimeBuf.modtime = BufPatch.st_mtime;

    if (utime(Itm->DestFile.c_str(),&TimeBuf) != 0)
       return _error->Errno("utime",_("Failed to set modification time"));
 
    if (utime(Itm->DestFile.c_str(),&TimeBuf) != 0)
       return _error->Errno("utime",_("Failed to set modification time"));
 

-   if (stat(Itm->DestFile.c_str(),&Buf) != 0)
+   if (stat(Itm->DestFile.c_str(),&BufBase) != 0)

       return _error->Errno("stat",_("Failed to stat"));
 
    // return done
       return _error->Errno("stat",_("Failed to stat"));
 
    // return done

-   Res.LastModified = Buf.st_mtime;
-   Res.Size = Buf.st_size;
+   Res.LastModified = BufBase.st_mtime;
+   Res.Size = BufBase.st_size;

    Res.TakeHashes(Hash);
    URIDone(Res);
 
    Res.TakeHashes(Hash);
    URIDone(Res);