* apt-pkg/deb/dpkgpm.cc:

  - apport integration added, this means that a apport
    report is written on dpkg failures
* merged from debian/unstable, remaining changes:
  - maintainer field changed

* merged the debian/experimental changes back
  into the debian/sid branch
* merged from Christian Perrier:
  * mr.po: New Marathi translation  Closes: #416806
  * zh_CN.po: Updated by Eric Pareja  Closes: #416822
  * tl.po: Updated by Eric Pareja   Closes: #416638
  * gl.po: Updated by Jacobo Tarrio
  * da.po: Updated by Claus Hindsgaul
  * fr.po: Remove a non-breakable space for usability
  * ru.po: Updated Russian translation. Closes: #405476
  * *.po: Unfuzzy after upstream typo corrections
* buildlib/archtable:
  - added support for sh3/sh4 (closes: #424870)
  - added support for m32r (closes: #394096)
* buildlib/systemtable:
  - added support for lpia
* configure.in:
  - check systemtable for architecture mapping too
* fix error in AutocleanInterval, closes: #319339
  (thanks to Israel G. Lugo for the patch)
* add "purge" commandline argument, closes: #133421)
  (thanks to Julien Danjou for the patch)
* add "purge" commandline argument, closes: #133421)
  (thanks to Julien Danjou for the patch)
* fix FTBFS with gcc 4.3, closes: #417090
  (thanks to Martin Michlmayr for the patch)
* add --dsc-only option, thanks to K. Richard Pixley
* Removed the more leftover #pragma interface/implementation
  closes: #306937 (thanks to Andreas Henriksson for the patch)

* ABI library name change because its build against
  new glibc
* implement SourceVer() in pkgRecords 
   (thanks to Daniel Burrows for the patch!)
* apt-pkg/algorithm.cc:
  - use clog for all debugging
  - only increase the score of installed applications if they 
    are not obsolete 
  - fix resolver bug on removal triggered by weak-dependencies 
    with or-groups
* methods/http.cc:
  - send apt version in User-Agent
* apt-pkg/deb/debrecords.cc:
  - fix SHA1Hash() return value
* apt-pkg/cdrom.cc:
  - only unmount if APT::CDROM::NoMount is false
* methods/cdrom.cc:  
  - only umount if it was mounted by the method before
  - if decompression of a index fails, delete the index 
  * vi.po: Updated to 515t. Closes: #426976
  * eu.po: Updated to 515t. Closes: #423766
  * pt.po: 515t. Closes: #423111
  * fr.po: Updated by Christian Perrier
  * Update all PO and the POT. Gives 513t2f for formerly
    complete translations
* Package that contains tall the new features
* Removed all #pragma interface/implementation
* Branch that contains tall the new features:
* translated package descriptions
* task install support
* automatic dependency removal (thanks to Daniel Burrows)
* merged support for the new dpkg "Breaks" field 
  (thanks to Ian Jackson)
* handle network failures more gracefully on "update"
* support for unattended-upgrades (via unattended-upgrades
  package)
* added apt-transport-https method
  - ca.po: Updated to 514t
  - be.po: Updated to 514t
  - it.po: Updated to 514t
  - hu.po: Updated to 514t
  - zh_TW.po: Updated to 514t
  - ar.po: Updated to 293t221u.
  - ru.po: Updated to 514t. Closes: #392466
  - nb.po: Updated to 514t. Closes: #392466
  - pt.po: Updated to 514t. Closes: #393199
  - fr.po: One spelling error corrected: s/accèder/accéder
  - km.po: Updated to 514t.
  - ko.po: Updated to 514t.
  - bg.po: Updated to 514t.
  - de.po: Updated to 514t.
  - en_GB.po: Updated to 514t.
* debian/control:
  - depend on debian-archive-keyring to offer clean upgrade path 
    (closes: #386800)
* merged "install-recommends" branch (ABI break): 
  - new "--install-recommends"
  - install new recommends on "upgrade" if --install-recommends is 
    given
  - new "--fix-policy" option to install all packages with unmet
    important dependencies (usefull with --install-recommends to
    see what not-installed recommends are on the system)
  - fix of recommended packages display (only show CandidateVersion
    fix or-group handling)
* merged "install-task" branch (use with "apt-get install taskname^")
* Applied patch from Daniel Schepler to make apt bin-NMU able.
* apt-pkg/acquire-item.cc:
  - fix reversed logic of the "Acquire::PDiffs" option
* apt-pkg/contrib/sha256.cc:
  - applied patch to fix unaligned access problem. Closes: #367417
    (thanks to David Mosberger)
* apt-pkg/contrib/sha256.{cc,h},hashes.{cc,h}: support for sha256 
  (thanks to Anthony Towns)
* ftparchive/cachedb.{cc,h},writer.{cc,h}: optimizations 
  (thanks to Anthony Towns)
* apt pdiff support from experimental merged
* apt-pkg/deb/dpkgpm.cc: wording fixes (thanks to Matt Zimmerman)
  - fix error in dpkg interaction (closes: #364513, thanks to Martin Dickopp)

3 files changed, 277 insertions, 2 deletions

diff --git a/methods/http.h b/methods/http.h
index 5eac11401..a47cd961c 100644
--- a/methods/http.h
+++ b/methods/http.h
@@ -160,5 +160,4 @@ class HttpMethod : public pkgAcqMethod
    };
 };
 
-
 #endif
diff --git a/methods/makefile b/methods/makefile
index 610bd5b49..83bd8c7c9 100644
--- a/methods/makefile
+++ b/methods/makefile
@@ -7,7 +7,7 @@ include ../buildlib/defaults.mak
 BIN := $(BIN)/methods
 
 # FIXME..
-LIB_APT_PKG_MAJOR = 3.53
+LIB_APT_PKG_MAJOR = 4.4
 APT_DOMAIN := libapt-pkg$(LIB_APT_PKG_MAJOR)
 
 # The file method
@@ -59,6 +59,13 @@ LIB_MAKES = apt-pkg/makefile
 SOURCE = https.cc
 include $(PROGRAM_H)
 
+# The https method
+PROGRAM=https
+SLIBS = -lapt-pkg -lcurl
+LIB_MAKES = apt-pkg/makefile
+SOURCE = https.cc
+include $(PROGRAM_H)
+
 # The ftp method
 PROGRAM=ftp
 SLIBS = -lapt-pkg $(SOCKETLIBS)
@@ -66,6 +73,13 @@ LIB_MAKES = apt-pkg/makefile
 SOURCE = ftp.cc rfc2553emu.cc connect.cc
 include $(PROGRAM_H)
 
+# The rred method
+PROGRAM=rred
+SLIBS = -lapt-pkg $(SOCKETLIBS)
+LIB_MAKES = apt-pkg/makefile
+SOURCE = rred.cc
+include $(PROGRAM_H)
+
 # The rsh method
 PROGRAM=rsh
 SLIBS = -lapt-pkg
diff --git a/methods/rred.cc b/methods/rred.cc
new file mode 100644
index 000000000..6fa57f3a6
--- /dev/null
+++ b/methods/rred.cc
@@ -0,0 +1,262 @@
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/acquire-method.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/hashes.h>
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <utime.h>
+#include <stdio.h>
+#include <errno.h>
+#include <apti18n.h>
+
+/* this method implements a patch functionality similar to "patch --ed" that is
+ * used by the "tiffany" incremental packages download stuff. it differs from 
+ * "ed" insofar that it is way more restricted (and therefore secure). in the
+ * moment only the "c", "a" and "d" commands of ed are implemented (diff 
+ * doesn't output any other). additionally the records must be reverse sorted 
+ * by line number and may not overlap (diff *seems* to produce this kind of 
+ * output). 
+ * */
+
+const char *Prog;
+
+class RredMethod : public pkgAcqMethod
+{
+   bool Debug;
+   // the size of this doesn't really matter (except for performance)    
+   const static int BUF_SIZE = 1024;
+   // the ed commands
+   enum Mode {MODE_CHANGED, MODE_DELETED, MODE_ADDED};
+   // return values
+   enum State {ED_OK, ED_ORDERING, ED_PARSER, ED_FAILURE};
+   // this applies a single hunk, it uses a tail recursion to 
+   // reverse the hunks in the file
+   int ed_rec(FILE *ed_cmds, FILE *in_file, FILE *out_file, int line, 
+      char *buffer, unsigned int bufsize, Hashes *hash);
+   // apply a patch file
+   int ed_file(FILE *ed_cmds, FILE *in_file, FILE *out_file, Hashes *hash);
+   // the methods main method
+   virtual bool Fetch(FetchItem *Itm);
+   
+   public:
+   
+   RredMethod() : pkgAcqMethod("1.1",SingleInstance | SendConfig) {};
+};
+
+int RredMethod::ed_rec(FILE *ed_cmds, FILE *in_file, FILE *out_file, int line, 
+      char *buffer, unsigned int bufsize, Hashes *hash) {
+   int pos;
+   int startline;
+   int stopline;
+   int mode;
+   int written;
+   char *idx;
+
+   /* get the current command and parse it*/
+   if (fgets(buffer, bufsize, ed_cmds) == NULL) {
+      return line;
+   }
+   startline = strtol(buffer, &idx, 10);
+   if (startline < line) {
+      return ED_ORDERING;
+   }
+   if (*idx == ',') {
+      idx++;
+      stopline = strtol(idx, &idx, 10);
+   }
+   else {
+      stopline = startline;
+   }
+   if (*idx == 'c') {
+      mode = MODE_CHANGED;
+	   if (Debug == true) {
+		   std::clog << "changing from line " << startline 
+			     << " to " << stopline << std::endl;
+	   }
+   }
+   else if (*idx == 'a') {
+      mode = MODE_ADDED;
+	   if (Debug == true) {
+		   std::clog << "adding after line " << startline << std::endl;
+	   }
+   }
+   else if (*idx == 'd') {
+      mode = MODE_DELETED;
+	   if (Debug == true) {
+		   std::clog << "deleting from line " << startline 
+			     <<  " to " << stopline << std::endl;
+	   }
+   }
+   else {
+      return ED_PARSER;
+   }
+   /* get the current position */
+   pos = ftell(ed_cmds);
+   /* if this is add or change then go to the next full stop */
+   if ((mode == MODE_CHANGED) || (mode == MODE_ADDED)) {
+      do {
+         fgets(buffer, bufsize, ed_cmds);
+         while ((strlen(buffer) == (bufsize - 1)) 
+               && (buffer[bufsize - 2] != '\n')) {
+            fgets(buffer, bufsize, ed_cmds);
+            buffer[0] = ' ';
+         }
+      } while (strncmp(buffer, ".", 1) != 0);
+   }
+   /* do the recursive call */
+   line = ed_rec(ed_cmds, in_file, out_file, line, buffer, bufsize, 
+         hash);
+   /* pass on errors */
+   if (line < 0) {
+      return line;
+   }
+   /* apply our hunk */
+   fseek(ed_cmds, pos, SEEK_SET); 
+   /* first wind to the current position */
+   if (mode != MODE_ADDED) {
+      startline -= 1;
+   }
+   while (line < startline) {
+      fgets(buffer, bufsize, in_file);
+      written = fwrite(buffer, 1, strlen(buffer), out_file);
+      hash->Add((unsigned char*)buffer, written);
+      while ((strlen(buffer) == (bufsize - 1)) 
+            && (buffer[bufsize - 2] != '\n')) {
+         fgets(buffer, bufsize, in_file);
+         written = fwrite(buffer, 1, strlen(buffer), out_file);
+         hash->Add((unsigned char*)buffer, written);
+      }
+      line++;
+   }
+   /* include from ed script */
+   if ((mode == MODE_ADDED) || (mode == MODE_CHANGED)) {
+      do {
+         fgets(buffer, bufsize, ed_cmds);
+         if (strncmp(buffer, ".", 1) != 0) {
+            written = fwrite(buffer, 1, strlen(buffer), out_file);
+            hash->Add((unsigned char*)buffer, written);
+            while ((strlen(buffer) == (bufsize - 1)) 
+                  && (buffer[bufsize - 2] != '\n')) {
+               fgets(buffer, bufsize, ed_cmds);
+               written = fwrite(buffer, 1, strlen(buffer), out_file);
+               hash->Add((unsigned char*)buffer, written);
+            }
+         }
+         else {
+            break;
+         }
+      } while (1);
+   }
+   /* ignore the corresponding number of lines from input */
+   if ((mode == MODE_DELETED) || (mode == MODE_CHANGED)) {
+      while (line < stopline) {
+         fgets(buffer, bufsize, in_file);
+         while ((strlen(buffer) == (bufsize - 1)) 
+               && (buffer[bufsize - 2] != '\n')) {
+            fgets(buffer, bufsize, in_file);
+         }
+         line++;
+      }
+   }
+   return line;
+}
+
+int RredMethod::ed_file(FILE *ed_cmds, FILE *in_file, FILE *out_file, 
+      Hashes *hash) {
+   char buffer[BUF_SIZE];
+   int result;
+   int written;
+   
+   /* we do a tail recursion to read the commands in the right order */
+   result = ed_rec(ed_cmds, in_file, out_file, 0, buffer, BUF_SIZE, 
+         hash);
+   
+   /* read the rest from infile */
+   if (result > 0) {
+      while (fgets(buffer, BUF_SIZE, in_file) != NULL) {
+         written = fwrite(buffer, 1, strlen(buffer), out_file);
+         hash->Add((unsigned char*)buffer, written);
+      }
+   }
+   else {
+      return ED_FAILURE;
+   }
+   return ED_OK;
+}
+
+
+bool RredMethod::Fetch(FetchItem *Itm)
+{
+   Debug = _config->FindB("Debug::pkgAcquire::RRed",false);
+   URI Get = Itm->Uri;
+   string Path = Get.Host + Get.Path; // To account for relative paths
+   // Path contains the filename to patch
+   FetchResult Res;
+   Res.Filename = Itm->DestFile;
+   URIStart(Res);
+   // Res.Filename the destination filename
+
+   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;
+   
+   Hashes Hash;
+   FILE* fFrom = fdopen(From.Fd(), "r");
+   FILE* fPatch = fdopen(Patch.Fd(), "r");
+   FILE* fTo = fdopen(To.Fd(), "w");
+   // now do the actual patching
+   if (ed_file(fPatch, fFrom, fTo, &Hash) != ED_OK) {
+     _error->Errno("rred", _("Could not patch file"));  
+      return false;
+   }
+
+   // write out the result
+   fflush(fFrom);
+   fflush(fPatch);
+   fflush(fTo);
+   From.Close();
+   Patch.Close();
+   To.Close();
+
+   // Transfer the modification times
+   struct stat Buf;
+   if (stat(Path.c_str(),&Buf) != 0)
+      return _error->Errno("stat",_("Failed to stat"));
+
+   struct utimbuf TimeBuf;
+   TimeBuf.actime = Buf.st_atime;
+   TimeBuf.modtime = Buf.st_mtime;
+   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)
+      return _error->Errno("stat",_("Failed to stat"));
+
+   // return done
+   Res.LastModified = Buf.st_mtime;
+   Res.Size = Buf.st_size;
+   Res.TakeHashes(Hash);
+   URIDone(Res);
+
+   return true;
+}
+
+int main(int argc, char *argv[])
+{
+   RredMethod Mth;
+
+   Prog = strrchr(argv[0],'/');
+   Prog++;
+   
+   return Mth.Run();
+}