port to use native RPM5 API

2 files changed, 350 insertions, 301 deletions

diff --git a/Makefile.PL b/Makefile.PL
index 0308b27..7c44699 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -27,7 +27,7 @@ $version =~ s/(-.*)|(\.DEVEL)//;
 chomp $version;
 $version =~ s/(RPM version )|(rpm \(RPM\) )//;
 my $hversion = hexversion($version);
-$hversion ge hexversion("4.2") or die "Unable to build URPM with too old (or undetected) rpm version $version\n";
+$hversion ge hexversion("5.0") or die "Unable to build URPM with too old (or undetected) rpm version $version\n";
 
 # to generate the ChangeLog depending on the checkout layout
 my $commonusername = "../common/";
@@ -51,11 +51,6 @@ ChangeLog:
 
 my @rpmflags;
 my $ldflags = `pkg-config --libs rpm`;
-if ($hversion ge hexversion("4.4.90") && $hversion lt hexversion("5.0")) {
-    # rpm.org version
-    push @rpmflags, "-DRPM_ORG";
-    $ldflags .= ' -lrpmbuild';
-}
 my $ccflags = join(' ', '-Wall -Wextra -fno-strict-aliasing', @rpmflags);
 
 print "Found RPM version $version (compiling with flags: $ccflags)\n";
diff --git a/URPM.xs b/URPM.xs
index ff6af0f..4b60b15 100644
--- a/URPM.xs
+++ b/URPM.xs
@@ -28,23 +28,16 @@
 #undef Stat
 #undef Fstat
 
-#ifdef RPM_ORG
-static inline void *_free(const void * p) { 
-  if (p != NULL) free((void *)p); 
-  return NULL;
-}
-typedef struct rpmSpec_s * Spec;
-#else
-#include <rpm/rpm46compat.h>
-#endif
+#define _RPMEVR_INTERNAL
+#define _RPMPS_INTERNAL
 
 #include <rpm/rpmio.h>
+#include <rpm/rpmtag.h>
 #include <rpm/rpmdb.h>
-#include <rpm/rpmts.h>
+#include <rpm/pkgio.h>
+#include <rpm/rpmcb.h>
 #include <rpm/rpmte.h>
 #include <rpm/rpmps.h>
-#include <rpm/rpmpgp.h>
-#include <rpm/rpmcli.h>
 #include <rpm/rpmbuild.h>
 #include <rpm/rpmlog.h>
 
@@ -160,22 +153,25 @@ get_fullname_parts(URPM__Package pkg, char **name, char **version, char **releas
   }
 }
 
-static char *
-get_name(Header header, int32_t tag) {
-  struct rpmtd_s val;
+static const char *
+get_name(Header header, rpmTag tag) {
+  HE_t val = (HE_t)memset(alloca(sizeof(*val)), 0, sizeof(*val));
 
-  headerGet(header, tag, &val, HEADERGET_MINMEM);
-  char *name = (char *) rpmtdGetString(&val);
-  return name ? name : "";
+  val->tag = tag;
+  headerGet(header, val, 0);
+  return (val->t == RPM_STRING_TYPE ||
+	    val->t == RPM_STRING_ARRAY_TYPE ||
+	    val->t == RPM_I18NSTRING_TYPE) ?
+	  val->p.str : "";
 }
 
 static int
-get_int(Header header, int32_t tag) {
-  struct rpmtd_s val;
+get_int(Header header, rpmTag tag) {
+  HE_t val = (HE_t)memset(alloca(sizeof(*val)), 0, sizeof(*val));
 
-  headerGet(header, tag, &val, HEADERGET_DEFAULT);
-  uint32_t *ep = rpmtdGetUint32(&val);
-  return ep ? *ep : 0;
+  val->tag = tag;
+  headerGet(header, val, 0);
+  return (val->t == RPM_UINT32_TYPE) ? *(val->p.ui32p) : 0;
 }
 
 static int
@@ -281,12 +277,12 @@ ranges_overlap(uint32_t aflags, char *sa, uint32_t bflags, char *sb, int b_nopro
 }
 
 static int has_old_suggests;
-int32_t is_old_suggests(int32_t flags) { 
-  int is = flags & RPMSENSE_MISSINGOK;
+rpmsenseFlags is_old_suggests(rpmsenseFlags flags) { 
+  rpmsenseFlags is = flags & RPMSENSE_MISSINGOK;
   if (is) has_old_suggests = is;
   return is;
 }
-int32_t is_not_old_suggests(int32_t flags) {
+rpmsenseFlags is_not_old_suggests(rpmsenseFlags flags) {
   return !is_old_suggests(flags);
 }
 
@@ -397,7 +393,7 @@ callback_list_str_overlap(char *s, int slen, const char *name, uint32_t flags, c
 }
 
 static int
-return_list_str(char *s, Header header, int32_t tag_name, int32_t tag_flags, int32_t tag_version, callback_list_str f, void *param) {
+return_list_str(char *s, Header header, rpmTag tag_name, rpmTag tag_flags, rpmTag tag_version, callback_list_str f, void *param) {
   int count = 0;
 
   if (s != NULL) {
@@ -424,94 +420,105 @@ return_list_str(char *s, Header header, int32_t tag_name, int32_t tag_flags, int
       if (f(s, eos ? eos-s : 0, NULL, 0, NULL, param)) return -count;
     }
   } else if (header) {
-    struct rpmtd_s list, flags, list_evr;
-
-    if (headerGet(header, tag_name, &list, HEADERGET_DEFAULT)) {
-      if (tag_flags) headerGet(header, tag_flags, &flags, HEADERGET_DEFAULT);
-      if (tag_version) headerGet(header, tag_version, &list_evr, HEADERGET_DEFAULT);
-      while (rpmtdNext(&list) >= 0) {
+    HE_t list = memset(alloca(sizeof(*list)), 0, sizeof(*list));
+
+    list->tag = tag_name;
+    if (headerGet(header, list, 0)) {
+      HE_t flags = memset(alloca(sizeof(*flags)), 0, sizeof(*flags));
+      HE_t list_evr = memset(alloca(sizeof(*list_evr)), 0, sizeof(*list_evr));
+      if (tag_flags) {
+        flags->tag = tag_flags;
+        headerGet(header, flags, 0);
+      }
+      if (tag_version) {
+        list_evr->tag = tag_version;
+        headerGet(header, list_evr, 0);
+      }
+      for (list->ix = 0; list->ix < (int)list->c; list->ix++) {
 	++count;
-	uint32_t *flag = rpmtdNextUint32(&flags);
-	if (f(NULL, 0, rpmtdGetString(&list), flag ? *flag : 0, 
-	      rpmtdNextString(&list_evr), param)) {
-	  rpmtdFreeData(&list);
-	  if (tag_flags) rpmtdFreeData(&flags);
-	  if (tag_version) rpmtdFreeData(&list_evr);
+	uint32_t *flag = (++flags->ix >= 0 && flags->ix < (int)flags->c) ? flags->p.ui32p : NULL;
+	if (f(NULL, 0, list->p.str, flag ? *flag : 0, 
+	      (++list_evr->ix >= 0 && list_evr->ix < (int)list_evr->c) ? list_evr->p.str : NULL,
+	      param)) {
+	  list->p.ptr = _free(list->p.ptr);
+	  if (tag_flags) flags->p.ui32p = _free(flags->p.ui32p);
+	  if (tag_version) list_evr->p.str = _free(list_evr->p.str);
 	  return -count;
 	}
       }
-      rpmtdFreeData(&list);
-      if (tag_flags) rpmtdFreeData(&flags);
-      if (tag_version) rpmtdFreeData(&list_evr);
+      list->p.ptr = _free(list->p.ptr);
+      if (tag_flags) flags->p.ui32p = _free(flags->p.ui32p);
+      if (tag_version) list_evr->p.str = _free(list_evr->p.str);
     }
   }
   return count;
 }
 
 static int
-xpush_simple_list_str(Header header, int32_t tag_name) {
+xpush_simple_list_str(Header header, rpmTag tag_name) {
   dSP;
   if (header) {
-    struct rpmtd_s list;
-    const char *val;
-    int size;
+    HE_t list = memset(alloca(sizeof(*list)), 0, sizeof(*list));
 
-    if (!headerGet(header, tag_name, &list, HEADERGET_DEFAULT)) return 0;
-    size = rpmtdCount(&list);
+    list->tag = tag_name;
+    if (!headerGet(header, list, 0)) return 0;
 
-    while ((val = rpmtdNextString(&list))) {
-        XPUSHs(sv_2mortal(newSVpv(val, 0)));
+    for (list->ix = 0; list->ix < (int)list->c; list->ix++) {
+        XPUSHs(sv_2mortal(newSVpv(list->p.str, 0)));
     }
-    rpmtdFreeData(&list);
+    list->p.ptr = _free(list->p.ptr);
     PUTBACK;
-    return size;
+    return list->c;
   } else return 0;
 }
 
 void
-return_list_int32_t(Header header, int32_t tag_name) {
+return_list_int32_t(Header header, rpmTag tag_name) {
   dSP;
   if (header) {
-    struct rpmtd_s list;
+    HE_t list = memset(alloca(sizeof(*list)), 0, sizeof(*list));
 
-    if (headerGet(header, tag_name, &list, HEADERGET_DEFAULT)) {
-      uint32_t *val;
-      while ((val = rpmtdNextUint32(&list)))
-	XPUSHs(sv_2mortal(newSViv(*val)));
-      rpmtdFreeData(&list);
+    list->tag = tag_name;
+    if (headerGet(header, list, 0)) {
+      for (list->ix = 0; list->ix < (int)list->c; list->ix++) {
+	XPUSHs(sv_2mortal(newSViv(*list->p.ui32p)));
+      }
+      list->p.ptr = _free(list->p.ptr);
     }
   }
   PUTBACK;
 }
 
 void
-return_list_uint_16(Header header, int32_t tag_name) {
+return_list_uint_16(Header header, rpmTag tag_name) {
   dSP;
   if (header) {
-    struct rpmtd_s list;
-    if (headerGet(header, tag_name, &list, HEADERGET_DEFAULT)) {
-      int count = rpmtdCount(&list);
+    HE_t list = memset(alloca(sizeof(*list)), 0, sizeof(*list));
+
+    list->tag = tag_name;
+    if (headerGet(header, list, 0)) {
       int i;
-      uint16_t *list_ = list.data;
-      for(i = 0; i < count; i++) {
+      uint16_t *list_ = list->p.ui16p;
+      for(i = 0; i < (int)list->c; i++) {
 	XPUSHs(sv_2mortal(newSViv(list_[i])));
       }
-      rpmtdFreeData(&list);
+      list->p.ptr = _free(list->p.ptr);
     }
   }
   PUTBACK;
 }
 
 void
-return_list_tag_modifier(Header header, int32_t tag_name) {
+return_list_tag_modifier(Header header, rpmTag tag_name) {
   dSP;
   int i;
-  struct rpmtd_s td;
-  if (!headerGet(header, tag_name, &td, HEADERGET_DEFAULT)) return;
-  int count = rpmtdCount(&td);
-  int32_t *list = td.data;
+  HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
+
+  he->tag = tag_name;
+  if (!headerGet(header, he, 0)) return;
+  uint32_t *list = he->p.ui32p;
 
-  for (i = 0; i < count; i++) {
+  for (i = 0; i < (int)he->c; i++) {
     char buff[15];
     char *s = buff;
     switch (tag_name) {
@@ -530,41 +537,37 @@ return_list_tag_modifier(Header header, int32_t tag_name) {
       if (list[i] & RPMFILE_PUBKEY)    *s++ = 'p';
     break;
     default:
-      rpmtdFreeData(&td);
+      he->p.ptr = _free(he->p.ptr);
       return;  
     }
     *s = '\0';
     XPUSHs(sv_2mortal(newSVpv(buff, strlen(buff))));
   }
-  rpmtdFreeData(&td);
+  he->p.ptr = _free(he->p.ptr);
   PUTBACK;
 }
 
 void
-return_list_tag(URPM__Package pkg, int32_t tag_name) {
+return_list_tag(URPM__Package pkg, rpmTag tag_name) {
   dSP;
   if (pkg->h != NULL) {
-    struct rpmtd_s td;
-    if (headerGet(pkg->h, tag_name, &td, HEADERGET_DEFAULT)) {
-      void *list = td.data;
-      int32_t count = rpmtdCount(&td);
+    HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
+
+    he->tag = tag_name;
+    if (headerGet(pkg->h, he, 0)) {
+      void *list = he->p.ptr;
       if (tag_name == RPMTAG_ARCH) {
 	XPUSHs(sv_2mortal(newSVpv(headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? (char *) list : "src", 0)));
       } else
-	switch (rpmtdType(&td)) {
-	  case RPM_NULL_TYPE:
-	    break;
-#ifdef RPM_ORG
-	  case RPM_CHAR_TYPE:
-#endif
-	  case RPM_INT8_TYPE:
-	  case RPM_INT16_TYPE:
-	  case RPM_INT32_TYPE:
+	switch (he->t) {
+	  case RPM_UINT8_TYPE:
+	  case RPM_UINT16_TYPE:
+	  case RPM_UINT32_TYPE:
 	    {
 	      int i;
 	      int *r;
 	      r = (int *)list;
-	      for (i=0; i < count; i++) {
+	      for (i=0; i < (int)he->c; i++) {
 		XPUSHs(sv_2mortal(newSViv(r[i])));
 	      }
 	    }
@@ -577,17 +580,17 @@ return_list_tag(URPM__Package pkg, int32_t tag_name) {
 	  case RPM_STRING_ARRAY_TYPE:
 	    {
 	      int i;
-	      char **s;
+	      const char **s;
 
-	      s = (char **)list;
-	      for (i = 0; i < count; i++) {
+	      s = (const char **)list;
+	      for (i = 0; i < (int)he->c; i++) {
 		XPUSHs(sv_2mortal(newSVpv(s[i], 0)));
 	      }
 	    }
 	    break;
 	  case RPM_I18NSTRING_TYPE:
 	    break;
-	  case RPM_INT64_TYPE:
+	  case RPM_UINT64_TYPE:
 	    break;
 	}
     }
@@ -628,6 +631,9 @@ return_list_tag(URPM__Package pkg, int32_t tag_name) {
       case RPMTAG_SUMMARY:
 	XPUSHs(sv_2mortal(newSVpv(pkg->summary, 0)));
 	break;
+      default:
+	croak("unexpected tag");
+	break;
     }
   }
   PUTBACK;
@@ -639,36 +645,50 @@ return_files(Header header, int filter_mode) {
   dSP;
   if (header) {
     char buff[4096];
-    char *p, *s;
+    char *p;
+    const char *s;
     STRLEN len;
     unsigned int i;
 
-    struct rpmtd_s td_flags, td_fmodes;
-    int32_t *flags = NULL;
+    uint32_t *flags = NULL;
     uint16_t *fmodes = NULL;
     if (filter_mode) {
-      headerGet(header, RPMTAG_FILEFLAGS, &td_flags, HEADERGET_DEFAULT);
-      headerGet(header, RPMTAG_FILEMODES, &td_fmodes, HEADERGET_DEFAULT);
-      flags = td_flags.data;
-      fmodes = td_fmodes.data;
+      HE_t he_flags = memset(alloca(sizeof(*he_flags)), 0, sizeof(*he_flags));
+      HE_t he_fmodes = memset(alloca(sizeof(*he_fmodes)), 0, sizeof(*he_fmodes));
+
+      he_flags->tag = RPMTAG_FILEFLAGS;
+      he_fmodes->tag = RPMTAG_FILEMODES;
+      headerGet(header, he_flags, 0);
+      headerGet(header, he_fmodes, 0);
+      flags = he_flags->p.ui32p;
+      fmodes = he_fmodes->p.ui16p;
     }
 
-    struct rpmtd_s td_baseNames, td_dirIndexes, td_dirNames, td_list;
-    headerGet(header, RPMTAG_BASENAMES, &td_baseNames, HEADERGET_DEFAULT);
-    headerGet(header, RPMTAG_DIRINDEXES, &td_dirIndexes, HEADERGET_DEFAULT);
-    headerGet(header, RPMTAG_DIRNAMES, &td_dirNames, HEADERGET_DEFAULT);
+    HE_t he_baseNames = memset(alloca(sizeof(*he_baseNames)), 0, sizeof(*he_baseNames));
+    HE_t he_dirIndexes = memset(alloca(sizeof(*he_dirIndexes)), 0, sizeof(*he_dirIndexes));
+    HE_t he_dirNames = memset(alloca(sizeof(*he_dirNames)), 0, sizeof(*he_dirNames));
 
-    char **baseNames = td_baseNames.data;
-    char **dirNames = td_dirNames.data;
-    int32_t *dirIndexes = td_dirIndexes.data;
+    he_baseNames->tag = RPMTAG_BASENAMES;
+    he_dirIndexes->tag = RPMTAG_DIRINDEXES;
+    he_dirNames->tag = RPMTAG_DIRNAMES;
+    headerGet(header, he_baseNames, 0);
+    headerGet(header, he_dirIndexes, 0);
+    headerGet(header, he_dirNames, 0);
 
-    char **list = NULL;
+    const char **baseNames = he_baseNames->p.argv;
+    const char **dirNames = he_dirNames->p.argv;
+    uint32_t *dirIndexes = he_dirIndexes->p.ui32p;
+
+    const char **list = NULL;
     if (!baseNames || !dirNames || !dirIndexes) {
-      if (!headerGet(header, RPMTAG_OLDFILENAMES, &td_list, HEADERGET_DEFAULT)) return;
-      list = td_list.data;
+      HE_t he_list = memset(alloca(sizeof(*he_list)), 0, sizeof(*he_list));
+
+      he_list->tag = RPMTAG_OLDFILENAMES;
+      if (!headerGet(header, he_list, 0)) return;
+      list = he_list->p.argv;
     }
 
-    for(i = 0; i < rpmtdCount(&td_baseNames); i++) {
+    for(i = 0; i < he_baseNames->c; i++) {
       if (list) {
 	s = list[i];
 	len = strlen(list[i]);
@@ -690,9 +710,9 @@ return_files(Header header, int filter_mode) {
       XPUSHs(sv_2mortal(newSVpv(s, len)));
     }
 
-    free(baseNames);
-    free(dirNames);
-    free(list);
+    baseNames = _free(baseNames);
+    dirNames = _free(dirNames);
+    list = _free(list);
   }
   PUTBACK;
 }
@@ -703,7 +723,7 @@ return_problems(rpmps ps, int translate_message, int raw_message) {
   if (ps && rpmpsNumProblems(ps) > 0) {
     rpmpsi iterator = rpmpsInitIterator(ps);
     while (rpmpsNextIterator(iterator) >= 0) {
-      rpmProblem p = rpmpsGetProblem(iterator);
+      rpmProblem p = rpmpsGetProblem(iterator->ps, iterator->ix);
 
       if (translate_message) {
 	/* translate error using rpm localization */
@@ -761,21 +781,31 @@ return_problems(rpmps ps, int translate_message, int raw_message) {
 }
 
 static char *
-pack_list(Header header, int32_t tag_name, int32_t tag_flags, int32_t tag_version, int32_t (*check_flag)(int32_t)) {
+pack_list(Header header, rpmTag tag_name, rpmTag tag_flags, rpmTag tag_version, rpmsenseFlags (*check_flag)(rpmsenseFlags)) {
   char buff[65536];
-  int32_t *flags = NULL;
-  char **list_evr = NULL;
+  uint32_t *flags = NULL;
+  const char **list_evr = NULL;
   unsigned int i;
   char *p = buff;
-
-  struct rpmtd_s td;
-  if (headerGet(header, tag_name, &td, HEADERGET_DEFAULT)) {
-    char **list = td.data;
-    
-    struct rpmtd_s td_flags, td_list_evr;
-    if (tag_flags   && headerGet(header, tag_flags,   &td_flags, HEADERGET_DEFAULT))    flags    = td_flags.data;
-    if (tag_version && headerGet(header, tag_version, &td_list_evr, HEADERGET_DEFAULT)) list_evr = td_list_evr.data;
-    for(i = 0; i < rpmtdCount(&td); i++) {
+  HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
+
+  he->tag = tag_name;
+  if (headerGet(header, he, 0)) {
+    const char **list = he->p.argv;
+   
+    if (tag_flags) {
+      HE_t he_flags = memset(alloca(sizeof(*he_flags)), 0, sizeof(*he_flags));
+      he_flags->tag = tag_flags;
+      if(headerGet(header, he_flags, 0))
+	flags = he_flags->p.ui32p;
+    }
+    if (tag_version) {
+      HE_t he_list_evr = memset(alloca(sizeof(*he_list_evr)), 0, sizeof(*he_list_evr));
+      he_list_evr->tag = tag_version;
+      if(headerGet(header, he_list_evr, 0))
+	list_evr = he_list_evr->p.argv;
+    }
+    for(i = 0; i < he->c; i++) {
       if (check_flag && !check_flag(flags[i])) continue;
       int len = print_list_entry(p, sizeof(buff)-(p-buff)-1, list[i], flags ? flags[i] : 0, list_evr ? list_evr[i] : NULL);
       if (len < 0) continue;
@@ -784,8 +814,8 @@ pack_list(Header header, int32_t tag_name, int32_t tag_flags, int32_t tag_versio
     }
     if (p > buff) p[-1] = 0;
 
-    free(list);
-    free(list_evr);
+    list = _free(list);
+    list_evr = _free(list_evr);
   }
 
   return p > buff ? memcpy(malloc(p-buff), buff, p-buff) : NULL;
@@ -797,10 +827,10 @@ pack_header(URPM__Package pkg) {
     if (pkg->info == NULL) {
       char buff[1024];
       char *p = buff;
-      char *name = get_name(pkg->h, RPMTAG_NAME);
-      char *version = get_name(pkg->h, RPMTAG_VERSION);
-      char *release = get_name(pkg->h, RPMTAG_RELEASE);
-      char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
+      const char *name = get_name(pkg->h, RPMTAG_NAME);
+      const char *version = get_name(pkg->h, RPMTAG_VERSION);
+      const char *release = get_name(pkg->h, RPMTAG_RELEASE);
+      const char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
 
       p += 1 + snprintf(buff, sizeof(buff), "%s-%s-%s.%s@%d@%d@%s", name, version, release, arch,
 		    get_int(pkg->h, RPMTAG_EPOCH), get_int(pkg->h, RPMTAG_SIZE), 
@@ -822,7 +852,7 @@ pack_header(URPM__Package pkg) {
     if (pkg->provides == NULL)
       pkg->provides = pack_list(pkg->h, RPMTAG_PROVIDENAME, RPMTAG_PROVIDEFLAGS, RPMTAG_PROVIDEVERSION, NULL);
     if (pkg->summary == NULL) {
-      char *summary = get_name(pkg->h, RPMTAG_SUMMARY);
+      const char *summary = get_name(pkg->h, RPMTAG_SUMMARY);
       int len = 1 + strlen(summary);
 
       pkg->summary = memcpy(malloc(len), summary, len);
@@ -834,7 +864,7 @@ pack_header(URPM__Package pkg) {
 }
 
 static void
-update_hash_entry(HV *hash, char *name, STRLEN len, int force, IV use_sense, URPM__Package pkg) {
+update_hash_entry(HV *hash, const char *name, STRLEN len, int force, IV use_sense, URPM__Package pkg) {
   SV** isv;
 
   if (!len) len = strlen(name);
@@ -860,7 +890,7 @@ update_hash_entry(HV *hash, char *name, STRLEN len, int force, IV use_sense, URP
 }
 
 static void
-update_provide_entry(char *name, STRLEN len, int force, IV use_sense, URPM__Package pkg, HV *provides) {
+update_provide_entry(const char *name, STRLEN len, int force, IV use_sense, URPM__Package pkg, HV *provides) {
   update_hash_entry(provides, name, len, force, use_sense, pkg);
 }
 
@@ -868,25 +898,31 @@ static void
 update_provides(URPM__Package pkg, HV *provides) {
   if (pkg->h) {
     int len;
-    struct rpmtd_s td, td_flags;
-    int32_t *flags = NULL;
+    HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
+    uint32_t *flags = NULL;
     unsigned int i;
 
     /* examine requires for files which need to be marked in provides */
-    if (headerGet(pkg->h, RPMTAG_REQUIRENAME, &td, HEADERGET_DEFAULT)) {
-      char **list = td.data;
-      for (i = 0; i < rpmtdCount(&td); ++i) {
+    he->tag = RPMTAG_REQUIRENAME;
+    if (headerGet(pkg->h, he, 0)) {
+      const char **list = he->p.argv;
+      for (i = 0; i < he->c; ++i) {
 	len = strlen(list[i]);
 	if (list[i][0] == '/') (void)hv_fetch(provides, list[i], len, 1);
       }
     }
 
     /* update all provides */
-    if (headerGet(pkg->h, RPMTAG_PROVIDENAME, &td, HEADERGET_DEFAULT)) {
-      char **list = td.data;
-      if (headerGet(pkg->h, RPMTAG_PROVIDEFLAGS, &td_flags, HEADERGET_DEFAULT))
-	flags = td_flags.data;
-      for (i = 0; i < rpmtdCount(&td); ++i) {
+    he->tag = RPMTAG_PROVIDENAME;
+    if (headerGet(pkg->h, he, 0)) {
+      const char **list = he->p.argv;
+
+      he->tag = RPMTAG_PROVIDEFLAGS;
+      if (headerGet(pkg->h, he, 0)) {
+        HE_t he_flags = memset(alloca(sizeof(*he_flags)), 0, sizeof(*he_flags));
+	flags = he_flags->p.ui32p;
+      }
+      for (i = 0; i < he->c; ++i) {
 	len = strlen(list[i]);
 	if (!strncmp(list[i], "rpmlib(", 7)) continue;
 	update_provide_entry(list[i], len, 1, flags && flags[i] & (RPMSENSE_PREREQ|RPMSENSE_SCRIPT_PREUN|RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_POSTUN|RPMSENSE_SCRIPT_POST|RPMSENSE_LESS|RPMSENSE_EQUAL|RPMSENSE_GREATER),
@@ -929,13 +965,14 @@ update_provides(URPM__Package pkg, HV *provides) {
 static void
 update_obsoletes(URPM__Package pkg, HV *obsoletes) {
   if (pkg->h) {
-    struct rpmtd_s td;
+    HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
 
     /* update all provides */
-    if (headerGet(pkg->h, RPMTAG_OBSOLETENAME, &td, HEADERGET_DEFAULT)) {
-      char **list = td.data;
+    he->tag = RPMTAG_OBSOLETENAME;
+    if (headerGet(pkg->h, he, 0)) {
+      const char **list = he->p.argv;
       unsigned int i;
-      for (i = 0; i < rpmtdCount(&td); ++i)
+      for (i = 0; i < he->c; ++i)
 	update_hash_entry(obsoletes, list[i], 0, 1, 0, pkg);
     }
   } else {
@@ -960,22 +997,28 @@ static void
 update_provides_files(URPM__Package pkg, HV *provides) {
   if (pkg->h) {
     STRLEN len;
-    char **list = NULL;
+    const char **list = NULL;
     unsigned int i;
+    HE_t he_baseNames = memset(alloca(sizeof(*he_baseNames)), 0, sizeof(*he_baseNames));
+    HE_t he_dirIndexes = memset(alloca(sizeof(*he_dirIndexes)), 0, sizeof(*he_dirIndexes));
+    HE_t he_dirNames = memset(alloca(sizeof(*he_dirNames)), 0, sizeof(*he_dirNames));
+
+    he_baseNames->tag = RPMTAG_BASENAMES;
+    he_dirIndexes->tag = RPMTAG_DIRINDEXES;
+    he_dirNames->tag = RPMTAG_DIRNAMES;
 
-    struct rpmtd_s td_baseNames, td_dirIndexes, td_dirNames;
-    if (headerGet(pkg->h, RPMTAG_BASENAMES, &td_baseNames, HEADERGET_DEFAULT) &&
-	headerGet(pkg->h, RPMTAG_DIRINDEXES, &td_dirIndexes, HEADERGET_DEFAULT) &&
-	headerGet(pkg->h, RPMTAG_DIRNAMES, &td_dirNames, HEADERGET_DEFAULT)) {
+    if (headerGet(pkg->h, he_baseNames, 0) &&
+	headerGet(pkg->h, he_dirIndexes, 0) &&
+	headerGet(pkg->h, he_dirNames, 0)) {
 
-      char **baseNames = td_baseNames.data;
-      char **dirNames = td_dirNames.data;
-      int32_t *dirIndexes = td_dirIndexes.data;
+      const char **baseNames = he_baseNames->p.argv;
+      const char **dirNames = he_dirNames->p.argv;
+      uint32_t *dirIndexes = he_dirIndexes->p.ui32p;
 
       char buff[4096];
       char *p;
 
-      for(i = 0; i < rpmtdCount(&td_baseNames); i++) {
+      for(i = 0; i < he_baseNames->c; i++) {
 	len = strlen(dirNames[dirIndexes[i]]);
 	if (len >= sizeof(buff)) continue;
 	memcpy(p = buff, dirNames[dirIndexes[i]], len + 1); p += len;
@@ -986,19 +1029,21 @@ update_provides_files(URPM__Package pkg, HV *provides) {
 	update_provide_entry(buff, p-buff, 0, 0, pkg, provides);
       }
 
-      free(baseNames);
-      free(dirNames);
+      baseNames = _free(baseNames);
+      baseNames = _free(dirNames);
     } else {
-      struct rpmtd_s td;
-      headerGet(pkg->h, RPMTAG_OLDFILENAMES, &td, HEADERGET_DEFAULT);
+      HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
+
+      he->tag = RPMTAG_OLDFILENAMES;
+      headerGet(pkg->h, he, 0);
       if (list) {
-	for (i = 0; i < rpmtdCount(&td); i++) {
+	for (i = 0; i < he->c; i++) {
 	  len = strlen(list[i]);
 
 	  update_provide_entry(list[i], len, 0, 0, pkg, provides);
 	}
 
-	free(list);
+	list = _free(list);
       }
     }
   }
@@ -1181,10 +1226,8 @@ static void drop_tags(Header *h) {
   headerDel(*h, RPMTAG_FILESIZES); /* ? */
   headerDel(*h, RPMTAG_FILERDEVS); /* it seems unused. always empty */
   headerDel(*h, RPMTAG_FILEVERIFYFLAGS); /* only used for -V */
-#ifndef RPM_ORG
   headerDel(*h, RPMTAG_FILEDIGESTALGOS); /* only used for -V */
   headerDel(*h, RPMTAG_FILEDIGESTS); /* only used for -V */ /* alias: RPMTAG_FILEMD5S */ 
-#endif
   /* keep RPMTAG_FILEFLAGS for %config (rpmnew) to work */
   /* keep RPMTAG_FILELANGS for %lang (_install_langs) to work */
   /* keep RPMTAG_FILELINKTOS for checking conflicts between symlinks */
@@ -1235,23 +1278,20 @@ update_header(char *filename, URPM__Package pkg, __attribute__((unused)) int kee
 	rpmtsSetVSFlags(ts, _RPMVSF_NOSIGNATURES | vsflags);
 	if (fd != NULL && rpmReadPackageFile(ts, fd, filename, &header) == 0 && header) {
 	  char *basename;
-#ifndef RPM_ORG
 	  struct stat sb;
-#else
-	  int32_t size;
-#endif
+	  HE_t he;
 
 	  basename = strrchr(filename, '/');
-#ifndef RPM_ORG
 	  Fstat(fd, &sb);
-#else
-	  size = fdSize(fd);
-#endif
 	  Fclose(fd);
 
 	  /* this is only kept for compatibility with older distros
 	     (where ->filename on "unpacked" URPM::Package rely on FILENAME_TAG) */
-	  headerPutString(header, FILENAME_TAG, basename != NULL ? basename + 1 : filename);
+	  he = (HE_t)memset(alloca(sizeof(*he)), 0, sizeof(*he));
+          he->tag = FILENAME_TAG;
+          he->p.str = basename != NULL ? basename + 1 : filename;
+          he->c = 1;
+	  headerPut(header, he, 0);
 
 	  if (pkg->h && !(pkg->flag & FLAG_NO_HEADER_FREE)) pkg->h = headerFree(pkg->h);
 	  pkg->h = header;
@@ -1268,7 +1308,20 @@ update_header(char *filename, URPM__Package pkg, __attribute__((unused)) int kee
 	close(d);
 	if (fd != NULL) {
 	  if (pkg->h && !(pkg->flag & FLAG_NO_HEADER_FREE)) pkg->h = headerFree(pkg->h);
-	  pkg->h = headerRead(fd, HEADER_MAGIC_YES);
+	  const char item[] = "Header";
+	  const char * msg = NULL;
+	  rpmRC rc = rpmpkgRead(item, fd, &pkg->h, &msg);
+
+	  switch (rc) {
+	  default:
+	    rpmlog(RPMLOG_ERR, "%s: %s: %s\n", "rpmpkgRead", item, msg);
+	  case RPMRC_NOTFOUND:
+	      pkg->h = NULL;
+	  case RPMRC_OK:
+	    break;
+	  }
+	  msg = (const char*)_free(msg);
+
 	  pkg->flag &= ~FLAG_NO_HEADER_FREE;
 	  Fclose(fd);
 	  return 1;
@@ -1298,8 +1351,8 @@ ts_nosignature(rpmts ts) {
 
 static void *rpmRunTransactions_callback(__attribute__((unused)) const void *h,
 					 const rpmCallbackType what, 
-					 const rpm_loff_t amount, 
-					 const rpm_loff_t total,
+					 const rpmuint64_t amount, 
+					 const rpmuint64_t total,
 					 fnpyKey pkgKey,
 					 rpmCallbackData data) {
   static struct timeval tprev;
@@ -1511,9 +1564,7 @@ int
 Pkg_is_arch_compat__XS(pkg)
   URPM::Package pkg
   INIT:
-#ifndef RPM_ORG
-  char * platform;
-#endif
+  const char * platform;
   CODE:
   read_config_files(0);
   if (pkg->info) {
@@ -1522,23 +1573,15 @@ Pkg_is_arch_compat__XS(pkg)
 
     get_fullname_parts(pkg, NULL, NULL, NULL, &arch, &eos);
     *eos = 0;
-#ifndef RPM_ORG
     platform = rpmExpand(arch, "-%{_target_vendor}-%{_target_os}%{?_gnu}", NULL);
     RETVAL = rpmPlatformScore(platform, NULL, 0);
     _free(platform);
-#else
-    RETVAL = rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch);
-#endif
     *eos = '@';
   } else if (pkg->h && headerIsEntry(pkg->h, RPMTAG_SOURCERPM)) {
-    char *arch = get_name(pkg->h, RPMTAG_ARCH);
-#ifndef RPM_ORG
+    const char *arch = get_name(pkg->h, RPMTAG_ARCH);
     platform = rpmExpand(arch, "-%{_target_vendor}-%{_target_os}%{?_gnu}", NULL);
     RETVAL = rpmPlatformScore(platform, NULL, 0);
     _free(platform);
-#else
-    RETVAL = rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch);
-#endif
   } else {
     RETVAL = 0;
   }
@@ -1549,18 +1592,17 @@ int
 Pkg_is_platform_compat(pkg)
   URPM::Package pkg
   INIT:
-#ifndef RPM_ORG
-  char * platform = NULL;
-  struct rpmtd_s val;
-#endif
+  const char * platform = NULL;
+  HE_t val = memset(alloca(sizeof(*val)), 0, sizeof(*val));
+
   CODE:
-#ifndef RPM_ORG
   read_config_files(0);
   if (pkg->h && headerIsEntry(pkg->h, RPMTAG_PLATFORM)) {
-    (void) headerGet(pkg->h, RPMTAG_PLATFORM, &val, HEADERGET_DEFAULT);
-    platform = (char *) rpmtdGetString(&val);
+    val->tag = RPMTAG_PLATFORM;
+    (void) headerGet(pkg->h, val, 0);
+    platform = val->p.str;
     RETVAL = rpmPlatformScore(platform, NULL, 0);
-    platform = headerFreeData(platform, val.type);
+    platform = _free(platform);
   } else if (pkg->info) {
     char *arch;
     char *eos;
@@ -1572,10 +1614,6 @@ Pkg_is_platform_compat(pkg)
     *eos = '@';
     _free(platform);
   } else { 
-#else
-    croak("is_platform_compat() is available only since rpm 4.4.8");
-    { /* to match last } and avoid another #ifdef for it */
-#endif
     RETVAL = 0;
     }
   
@@ -1720,10 +1758,10 @@ Pkg_fullname(pkg)
       PUSHs(sv_2mortal(newSVpv(arch, eos-arch)));
     }
   } else if (pkg->h) {
-    char *name = get_name(pkg->h, RPMTAG_NAME);
-    char *version = get_name(pkg->h, RPMTAG_VERSION);
-    char *release = get_name(pkg->h, RPMTAG_RELEASE);
-    char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
+    const char *name = get_name(pkg->h, RPMTAG_NAME);
+    const char *version = get_name(pkg->h, RPMTAG_VERSION);
+    const char *release = get_name(pkg->h, RPMTAG_RELEASE);
+    const char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
 
     if (gimme == G_SCALAR) {
       XPUSHs(sv_2mortal(newSVpvf("%s-%s-%s.%s", name, version, release, arch)));
@@ -1791,9 +1829,9 @@ Pkg_compare_pkg(lpkg, rpkg)
       larch[-1] = 0;
     } else if (lpkg->h) {
       lepoch = get_int(lpkg->h, RPMTAG_EPOCH);
-      lversion = get_name(lpkg->h, RPMTAG_VERSION);
-      lrelease = get_name(lpkg->h, RPMTAG_RELEASE);
-      larch = headerIsEntry(lpkg->h, RPMTAG_SOURCERPM) ? get_name(lpkg->h, RPMTAG_ARCH) : "src";
+      lversion = (char*)get_name(lpkg->h, RPMTAG_VERSION);
+      lrelease = (char*)get_name(lpkg->h, RPMTAG_RELEASE);
+      larch = headerIsEntry(lpkg->h, RPMTAG_SOURCERPM) ? (char*)get_name(lpkg->h, RPMTAG_ARCH) : "src";
     } else croak("undefined package");
     if (rpkg->info) {
       char *s;
@@ -1811,9 +1849,9 @@ Pkg_compare_pkg(lpkg, rpkg)
       rarch[-1] = 0;
     } else if (rpkg->h) {
       repoch = get_int(rpkg->h, RPMTAG_EPOCH);
-      rversion = get_name(rpkg->h, RPMTAG_VERSION);
-      rrelease = get_name(rpkg->h, RPMTAG_RELEASE);
-      rarch = headerIsEntry(rpkg->h, RPMTAG_SOURCERPM) ? get_name(rpkg->h, RPMTAG_ARCH) : "src";
+      rversion = (char*)get_name(rpkg->h, RPMTAG_VERSION);
+      rrelease = (char*)get_name(rpkg->h, RPMTAG_RELEASE);
+      rarch = headerIsEntry(rpkg->h, RPMTAG_SOURCERPM) ? (char*)get_name(rpkg->h, RPMTAG_ARCH) : "src";
     } else {
       /* restore info string modified */
       if (lpkg->info) {
@@ -1828,13 +1866,24 @@ Pkg_compare_pkg(lpkg, rpkg)
       if (!compare) {
 	compare = rpmvercmp(lrelease, rrelease);
 	if (!compare) {
-	  int lscore, rscore;
+	  int lscore = 0, rscore = 0;
 	  char *eolarch = strchr(larch, '@');
 	  char *eorarch = strchr(rarch, '@');
+	  char *platform = NULL;
 
 	  read_config_files(0);
-	  if (eolarch) *eolarch = 0; lscore = rpmMachineScore(RPM_MACHTABLE_INSTARCH, larch);
-	  if (eorarch) *eorarch = 0; rscore = rpmMachineScore(RPM_MACHTABLE_INSTARCH, rarch);
+	  if (eolarch) {
+	    *eolarch = 0;
+	    platform = rpmExpand(larch, "-%{_target_vendor}-%{_target_os}%{?_gnu}", NULL);
+	    lscore = rpmPlatformScore(platform, NULL, 0);
+	    platform = _free(platform);
+	  }
+	  if (eorarch) {
+	    *eolarch = 0;
+	    platform = rpmExpand(rarch, "-%{_target_vendor}-%{_target_os}%{?_gnu}", NULL);
+	    rscore = rpmPlatformScore(platform, NULL, 0);
+	    platform = _free(platform);
+	  }
 	  if (lscore == 0) {
 	    if (rscore == 0)
 #if 0
@@ -1917,7 +1966,7 @@ Pkg_compare(pkg, evr)
     }
     if (!compare) {
       if (!pkg->info)
-	_version = get_name(pkg->h, RPMTAG_VERSION);
+	_version = (char*)get_name(pkg->h, RPMTAG_VERSION);
       /* continue extracting release if any */
       if ((release = strrchr(version, '-')) != NULL) {
 	*release++ = 0;
@@ -1925,7 +1974,7 @@ Pkg_compare(pkg, evr)
 	if (!compare) {
 	  /* need to compare with release here */
 	  if (!pkg->info)
-	    _release = get_name(pkg->h, RPMTAG_RELEASE);
+	    _release = (char*)get_name(pkg->h, RPMTAG_RELEASE);
 	  compare = rpmvercmp(_release, release);
 	}
 	release[-1] = '-'; /* restore in memory modification */
@@ -2005,10 +2054,10 @@ Pkg_filename(pkg)
 	memcpy(eon, savbuf, 4);
     }
   } else if (pkg->h) {
-    char *name = get_name(pkg->h, RPMTAG_NAME);
-    char *version = get_name(pkg->h, RPMTAG_VERSION);
-    char *release = get_name(pkg->h, RPMTAG_RELEASE);
-    char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
+    const char *name = get_name(pkg->h, RPMTAG_NAME);
+    const char *version = get_name(pkg->h, RPMTAG_VERSION);
+    const char *release = get_name(pkg->h, RPMTAG_RELEASE);
+    const char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
 
     XPUSHs(sv_2mortal(newSVpvf("%s-%s-%s.%s.rpm", name, version, release, arch)));
   }
@@ -2027,10 +2076,10 @@ Pkg_header_filename(pkg)
   } else if (pkg->h) {
     char buff[1024];
     char *p = buff;
-    char *name = get_name(pkg->h, RPMTAG_NAME);
-    char *version = get_name(pkg->h, RPMTAG_VERSION);
-    char *release = get_name(pkg->h, RPMTAG_RELEASE);
-    char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
+    const char *name = get_name(pkg->h, RPMTAG_NAME);
+    const char *version = get_name(pkg->h, RPMTAG_VERSION);
+    const char *release = get_name(pkg->h, RPMTAG_RELEASE);
+    const char *arch = headerIsEntry(pkg->h, RPMTAG_SOURCERPM) ? get_name(pkg->h, RPMTAG_ARCH) : "src";
 
     p += snprintf(buff, sizeof(buff), "%s-%s-%s.%s", name, version, release, arch);
     XPUSHs(sv_2mortal(newSVpv(buff, p-buff)));
@@ -2391,7 +2440,7 @@ Pkg_queryformat(pkg, fmt)
   char *s;
   PPCODE:
   if (pkg->h) {
-    s = headerFormat(pkg->h, fmt, NULL);
+    s = headerSprintf(pkg->h, fmt, NULL, NULL, NULL);
       if (s) {
         XPUSHs(sv_2mortal(newSVpv_utf8(s,0)));
       }
@@ -2516,7 +2565,14 @@ Pkg_build_header(pkg, fileno)
     FD_t fd;
 
     if ((fd = fdDup(fileno)) != NULL) {
-      headerWrite(fd, pkg->h, HEADER_MAGIC_YES);
+      const char item[] = "Header";
+      const char * msg = NULL;
+      rpmRC rc = rpmpkgWrite(item, fd, pkg->h, &msg);
+      if (rc != RPMRC_OK) {
+	rpmlog(RPMLOG_ERR, "%s: %s: %s\n", "headerWrite", item, msg);
+	rc = RPMRC_FAIL;
+      }
+      msg = (const char*)_free(msg);
       Fclose(fd);
     } else croak("unable to get rpmio handle on fileno %d", fileno);
   } else croak("no header available for package");
@@ -2847,13 +2903,13 @@ Db_traverse(db,callback)
   SV *callback
   PREINIT:
   Header header;
-  rpmdbMatchIterator mi;
+  rpmmi mi;
   int count = 0;
   CODE:
   db->ts = rpmtsLink(db->ts, "URPM::DB::traverse");
   ts_nosignature(db->ts);
   mi = rpmtsInitIterator(db->ts, RPMDBI_PACKAGES, NULL, 0);
-  while ((header = rpmdbNextIterator(mi))) {
+  while ((header = rpmmiNext(mi))) {
     if (SvROK(callback)) {
       dSP;
       URPM__Package pkg = calloc(1, sizeof(struct s_Package));
@@ -2872,7 +2928,7 @@ Db_traverse(db,callback)
     }
     ++count;
   }
-  rpmdbFreeIterator(mi);
+  mi = rpmmiFree(mi);
   (void)rpmtsFree(db->ts);
   RETVAL = count;
   OUTPUT:
@@ -2886,7 +2942,7 @@ Db_traverse_tag(db,tag,names,callback)
   SV *callback
   PREINIT:
   Header header;
-  rpmdbMatchIterator mi;
+  rpmmi mi;
   int count = 0;
   CODE:
   if (SvROK(names) && SvTYPE(SvRV(names)) == SVt_PVAV) {
@@ -2903,7 +2959,7 @@ Db_traverse_tag(db,tag,names,callback)
       db->ts = rpmtsLink(db->ts, "URPM::DB::traverse_tag");
       ts_nosignature(db->ts);
       mi = rpmtsInitIterator(db->ts, rpmtag, name, str_len);
-      while ((header = rpmdbNextIterator(mi))) {
+      while ((header = rpmmiNext(mi))) {
 	if (SvROK(callback)) {
 	  dSP;
 	  URPM__Package pkg = calloc(1, sizeof(struct s_Package));
@@ -2922,7 +2978,7 @@ Db_traverse_tag(db,tag,names,callback)
 	}
 	++count;
       }
-      (void)rpmdbFreeIterator(mi);
+      (void)rpmmiFree(mi);
       (void)rpmtsFree(db->ts);
     } 
   } else croak("bad arguments list");
@@ -2938,7 +2994,7 @@ Db_traverse_tag_find(db,tag,name,callback)
   SV *callback
   PREINIT:
   Header header;
-  rpmdbMatchIterator mi;
+  rpmmi mi;
   CODE:
   int rpmtag = rpmtag_from_string(tag);
   int found = 0;
@@ -2946,7 +3002,7 @@ Db_traverse_tag_find(db,tag,name,callback)
   db->ts = rpmtsLink(db->ts, "URPM::DB::traverse_tag");
   ts_nosignature(db->ts);
   mi = rpmtsInitIterator(db->ts, rpmtag, name, 0);
-  while ((header = rpmdbNextIterator(mi))) {
+  while ((header = rpmmiNext(mi))) {
       dSP;
       URPM__Package pkg = calloc(1, sizeof(struct s_Package));
 
@@ -2967,7 +3023,7 @@ Db_traverse_tag_find(db,tag,name,callback)
 	break;
       }
   }
-  (void)rpmdbFreeIterator(mi);
+  (void)rpmmiFree(mi);
   (void)rpmtsFree(db->ts);
   RETVAL = found;
   OUTPUT:
@@ -3010,11 +3066,7 @@ Trans_add(trans, pkg, ...)
   CODE:
   if ((pkg->flag & FLAG_ID) <= FLAG_ID_MAX && pkg->h != NULL) {
     int update = 0;
-#ifndef RPM_ORG
     rpmRelocation  relocations = NULL;
-#else
-    rpmRelocation *relocations = NULL;
-#endif
     /* compability mode with older interface of add */
     if (items == 3) {
       update = SvIV(ST(2));
@@ -3030,20 +3082,12 @@ Trans_add(trans, pkg, ...)
 	  if (SvROK(ST(i+1)) && SvTYPE(SvRV(ST(i+1))) == SVt_PVAV) {
 	    AV *excludepath = (AV*)SvRV(ST(i+1));
 	    I32 j = 1 + av_len(excludepath);
-#ifndef RPM_ORG
 	    int relno = 0;
 	    relocations = malloc(sizeof(rpmRelocation));
-#else
-	    relocations = calloc(j + 1, sizeof(rpmRelocation));
-#endif
 	    while (--j >= 0) {
 	      SV **e = av_fetch(excludepath, j, 0);
 	      if (e != NULL && *e != NULL) {
-#ifndef RPM_ORG
 		rpmfiAddRelocation(&relocations, &relno, SvPV_nolen(*e), NULL);
-#else
-		relocations[j].oldPath = SvPV_nolen(*e);
-#endif
 	      }
 	    }
 	  }
@@ -3052,11 +3096,7 @@ Trans_add(trans, pkg, ...)
     }
     RETVAL = rpmtsAddInstallElement(trans->ts, pkg->h, (fnpyKey)(1+(long)(pkg->flag & FLAG_ID)), update, relocations) == 0;
     /* free allocated memory, check rpm is copying it just above, at least in 4.0.4 */
-#ifndef RPM_ORG
     rpmfiFreeRelocations(relocations);
-#else
-    free(relocations);
-#endif
   } else RETVAL = 0;
   OUTPUT:
   RETVAL
@@ -3067,7 +3107,7 @@ Trans_remove(trans, name)
   char *name
   PREINIT:
   Header h;
-  rpmdbMatchIterator mi;
+  rpmmi mi;
   int count = 0;
   char *boa = NULL, *bor = NULL;
   CODE:
@@ -3085,14 +3125,14 @@ Trans_remove(trans, name)
     }
   }
   mi = rpmtsInitIterator(trans->ts, RPMDBI_LABEL, name, 0);
-  while ((h = rpmdbNextIterator(mi))) {
-    unsigned int recOffset = rpmdbGetIteratorOffset(mi);
+  while ((h = rpmmiNext(mi))) {
+    unsigned int recOffset = rpmmiInstance(mi);
     if (recOffset != 0) {
       rpmtsAddEraseElement(trans->ts, h, recOffset);
       ++count;
     }
   }
-  rpmdbFreeIterator(mi);
+  mi = rpmmiFree(mi);
   if (boa) *boa = '.';
   RETVAL=count;
   OUTPUT:
@@ -3103,12 +3143,12 @@ Trans_traverse(trans, callback)
   URPM::Transaction trans
   SV *callback
   PREINIT:
-  rpmdbMatchIterator mi;
+  rpmmi mi;
   Header h;
   int c = 0;
   CODE:
   mi = rpmtsInitIterator(trans->ts, RPMDBI_PACKAGES, NULL, 0);
-  while ((h = rpmdbNextIterator(mi))) {
+  while ((h = rpmmiNext(mi))) {
     if (SvROK(callback)) {
       dSP;
       URPM__Package pkg = calloc(1, sizeof(struct s_Package));
@@ -3123,7 +3163,7 @@ Trans_traverse(trans, callback)
     }
     ++c;
   }
-  rpmdbFreeIterator(mi);
+  mi = rpmmiFree(mi);
   RETVAL = c;
   OUTPUT:
   RETVAL
@@ -3520,7 +3560,20 @@ Urpm_parse_hdlist__XS(urpm, filename, ...)
 
 	PUTBACK;
 	do {
-	  header=headerRead(fd, HEADER_MAGIC_YES);
+	  const char item[] = "Header";
+	  const char * msg = NULL;
+	  rpmRC rc = rpmpkgRead(item, fd, &header, &msg);
+
+	  switch (rc) {
+	    default:
+	      rpmlog(RPMLOG_ERR, "%s: %s: %s\n", "rpmpkgRead", item, msg);
+	    case RPMRC_NOTFOUND:
+	      header = NULL;
+	    case RPMRC_OK:
+	      break;
+	  }
+	  msg = (const char*)_free(msg);
+
 	  if (header != NULL) {
 	    struct s_Package pkg, *_pkg;
 	    SV *sv_pkg;
@@ -3752,10 +3805,12 @@ Urpm_verify_signature(filename, prefix="/")
     switch(rc) {
       case RPMRC_OK:
 	if (h) {
-	  char *fmtsig = headerFormat(
+	  char *fmtsig = headerSprintf(
 	      h,
 	      "%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:"
 	      "{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|",
+	      NULL,
+	      NULL,
 	      NULL);
 	  snprintf(result, sizeof(result), "OK (%s)", fmtsig);
 	  free(fmtsig);
@@ -3800,7 +3855,7 @@ Urpm_import_pubkey_file(db, filename)
         RETVAL = 0;
     } else if (rc != PGPARMOR_PUBKEY) {
         RETVAL = 0;
-    } else if (rpmtsImportPubkey(ts, pkt, pktlen) != RPMRC_OK) {
+    } else if (rpmcliImportPubkey(ts, pkt, pktlen) != RPMRC_OK) {
         RETVAL = 0;
     } else {
         RETVAL = 1;
@@ -3823,18 +3878,12 @@ int
 Urpm_archscore(arch)
   const char * arch
   PREINIT:
-#ifndef RPM_ORG
   char * platform = NULL;
-#endif
   CODE:
   read_config_files(0);
-#ifndef RPM_ORG
   platform = rpmExpand(arch, "-%{_target_vendor}-%{_target_os}%{?_gnu}", NULL);
   RETVAL=rpmPlatformScore(platform, NULL, 0);
   _free(platform);
-#else
-  RETVAL=rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch);
-#endif
   OUTPUT:
   RETVAL
 
@@ -3842,18 +3891,12 @@ int
 Urpm_osscore(os)
   const char * os
   PREINIT:
-#ifndef RPM_ORG
   char * platform = NULL;
-#endif
   CODE:
   read_config_files(0);
-#ifndef RPM_ORG
   platform = rpmExpand("%{_target_cpu}-%{_target_vendor}-", os, "%{?_gnu}", NULL);
   RETVAL=rpmPlatformScore(platform, NULL, 0);
   _free(platform);
-#else
-  RETVAL=rpmMachineScore(RPM_MACHTABLE_INSTOS, os);
-#endif
   OUTPUT:
   RETVAL
 
@@ -3862,13 +3905,7 @@ Urpm_platformscore(platform)
   const char * platform
   CODE:
   read_config_files(0);
-#ifndef RPM_ORG
   RETVAL=rpmPlatformScore(platform, NULL, 0);
-#else
-  unused_variable(platform);
-  croak("platformscore() is available only since rpm 4.4.8");
-  RETVAL=0;
-#endif
   OUTPUT:
   RETVAL
 
@@ -3880,9 +3917,23 @@ Urpm_stream2header(fp)
     URPM__Package pkg;
   PPCODE:
     if ((fd = fdDup(fileno(fp)))) {
+	const char item[] = "Header";
+	const char * msg = NULL;
+	rpmRC rc;
+
 	pkg = (URPM__Package)malloc(sizeof(struct s_Package));
 	memset(pkg, 0, sizeof(struct s_Package));
-        pkg->h = headerRead(fd, HEADER_MAGIC_YES);
+	rc = rpmpkgRead(item, fd, &pkg->h, &msg);
+
+	switch (rc) {
+	  default:
+	    rpmlog(RPMLOG_ERR, "%s: %s: %s\n", "rpmpkgRead", item, msg);
+	  case RPMRC_NOTFOUND:
+	    pkg->h = NULL;
+	  case RPMRC_OK:
+	    break;
+	}
+	msg = (const char*)_free(msg);
         if (pkg->h) {
             SV *sv_pkg;
             EXTEND(SP, 1);
@@ -3907,26 +3958,29 @@ Urpm_spec2srcheader(specfile)
 #define SPEC_ANYARCH 1
 /* Do not verify whether sources exist */
 #define SPEC_FORCE 1
-  if (!parseSpec(ts, specfile, "/", NULL, 0, NULL, NULL, SPEC_ANYARCH, SPEC_FORCE)) {
+  if (!parseSpec(ts, specfile, "/", 0, NULL, NULL, SPEC_ANYARCH, SPEC_FORCE, 0)) {
     SV *sv_pkg;
+    HE_t he;
+
     spec = rpmtsSetSpec(ts, NULL);
-#ifdef RPM_ORG
-    if (! spec->sourceHeader)
-#endif
-      initSourceHeader(spec);
+    initSourceHeader(spec, NULL);
     pkg = (URPM__Package)malloc(sizeof(struct s_Package));
     memset(pkg, 0, sizeof(struct s_Package));
-    headerPutString(spec->sourceHeader, RPMTAG_SOURCERPM, "");
+    he = (HE_t)memset(alloca(sizeof(*he)), 0, sizeof(*he));
+
+    he->tag = RPMTAG_SOURCERPM;
+    he->p.str = "";
+    he->c = 1;
+    headerPut(spec->sourceHeader, he, 0);
 
     {
-      struct rpmtd_s td = {
-	.tag = RPMTAG_ARCH,
-	.type = RPM_STRING_TYPE,
-	.data = (void *) "src",
-	.count = 1,
-      };
+      HE_t he = (HE_t)memset(alloca(sizeof(*he)), 0, sizeof(*he));
+      he->tag = RPMTAG_ARCH;
+      he->t = RPM_STRING_TYPE;
+      he->p.str = "src";
+      he->c = 1,
       /* parseSpec() sets RPMTAG_ARCH to %{_target_cpu} whereas we really a header similar to .src.rpm header */
-      headerMod(spec->sourceHeader, &td);
+      headerMod(spec->sourceHeader, he, 0);
     }
 
     pkg->h = headerLink(spec->sourceHeader);