- add pool_freetmpspace, pool_tmpappend, pool_bin2hex, sat_dupappend, sat_hex2bin...

diff --git a/src/pool.c b/src/pool.c
index 854bc68..a17f491 100644 (file)
--- a/src/pool.c
+++ b/src/pool.c
@@ -1221,6 +1221,43 @@ pool_alloctmpspace(Pool *pool, int len)
   return pool->tmpspacebuf[n];
 }
 
+static char *
+pool_alloctmpspace_free(Pool *pool, const char *space, int len)
+{
+  if (space)
+    {
+      int n, oldn;
+      n = oldn = pool->tmpspacen;
+      for (;;)
+       {
+         if (!n--)
+           n = POOL_TMPSPACEBUF - 1;
+         if (n == oldn)
+           break;
+         if (pool->tmpspacebuf[n] != space)
+           continue;
+         if (len > pool->tmpspacelen[n])
+           {
+             pool->tmpspacebuf[n] = sat_realloc(pool->tmpspacebuf[n], len + 32);
+             pool->tmpspacelen[n] = len + 32;
+           }
+          return pool->tmpspacebuf[n];
+       }
+    }
+  return 0;
+}
+
+void
+pool_freetmpspace(Pool *pool, const char *space)
+{
+  int n = pool->tmpspacen;
+  if (!space)
+    return;
+  n = (n + (POOL_TMPSPACEBUF - 1)) % POOL_TMPSPACEBUF;
+  if (pool->tmpspacebuf[n] == space)
+    pool->tmpspacen = n;
+}
+
 char *
 pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const char *str3)
 {
@@ -1249,6 +1286,51 @@ pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const char *str3)
   return str;
 }
 
+char *
+pool_tmpappend(Pool *pool, const char *str1, const char *str2, const char *str3)
+{
+  int l1, l2, l3;
+  char *s, *str;
+
+  l1 = str1 ? strlen(str1) : 0;
+  l2 = str2 ? strlen(str2) : 0;
+  l3 = str3 ? strlen(str3) : 0;
+  str = pool_alloctmpspace_free(pool, str1, l1 + l2 + l3 + 1);
+  if (str)
+    str1 = str;
+  else
+    str = pool_alloctmpspace(pool, l1 + l2 + l3 + 1);
+  s = str;
+  if (l1)
+    {
+      if (s != str1)
+        strcpy(s, str1);
+      s += l1;
+    }
+  if (l2)
+    {
+      strcpy(s, str2);
+      s += l2;
+    }
+  if (l3)
+    {
+      strcpy(s, str3);
+      s += l3;
+    }
+  *s = 0;
+  return str;
+}
+
+const char *
+pool_bin2hex(Pool *pool, const unsigned char *buf, int len)
+{
+  char *s;
+  if (!len)
+    return "";
+  s = pool_alloctmpspace(pool, 2 * len + 1);
+  sat_bin2hex(buf, len, s);
+  return s;
+}
 
 /*******************************************************************/
 

diff --git a/src/pool.h b/src/pool.h
index f5d1dfb..fc08d2f 100644 (file)
--- a/src/pool.h
+++ b/src/pool.h
@@ -194,7 +194,10 @@ extern void pool_setdisttype(Pool *pool, int disttype);
 extern void pool_debug(Pool *pool, int type, const char *format, ...) __attribute__((format(printf, 3, 4)));
 
 extern char *pool_alloctmpspace(Pool *pool, int len);
+extern void  pool_freetmpspace(Pool *pool, const char *space);
 extern char *pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const char *str3);
+extern char *pool_tmpappend(Pool *pool, const char *str1, const char *str2, const char *str3);
+extern const char *pool_bin2hex(Pool *pool, const unsigned char *buf, int len);
 
 extern void pool_set_installed(Pool *pool, struct _Repo *repo);
 

diff --git a/src/repodata.c b/src/repodata.c
index 958152d..bde6579 100644 (file)
--- a/src/repodata.c
+++ b/src/repodata.c
@@ -2102,31 +2102,6 @@ repodata_set_bin_checksum(Repodata *data, Id solvid, Id keyname, Id type,
   data->attrdatalen += l;
 }
 
-static int
-hexstr2bytes(unsigned char *buf, const char *str, int buflen)
-{
-  int i;
-  for (i = 0; i < buflen; i++)
-    {
-#define c2h(c) (((c)>='0' && (c)<='9') ? ((c)-'0')             \
-               : ((c)>='a' && (c)<='f') ? ((c)-('a'-10))       \
-               : ((c)>='A' && (c)<='F') ? ((c)-('A'-10))       \
-               : -1)
-      int v = c2h(*str);
-      str++;
-      if (v < 0)
-       return 0;
-      buf[i] = v;
-      v = c2h(*str);
-      str++;
-      if (v < 0)
-       return 0;
-      buf[i] = (buf[i] << 4) | v;
-#undef c2h
-    }
-  return buflen;
-}
-
 void
 repodata_set_checksum(Repodata *data, Id solvid, Id keyname, Id type,
                      const char *str)
@@ -2136,7 +2111,7 @@ repodata_set_checksum(Repodata *data, Id solvid, Id keyname, Id type,
 
   if (!(l = sat_chksum_len(type)))
     return;
-  if (hexstr2bytes(buf, str, l) != l)
+  if (l > sizeof(buf) || sat_hex2bin(&str, buf, l) != l)
     return;
   repodata_set_bin_checksum(data, solvid, keyname, type, buf);
 }
@@ -2144,22 +2119,11 @@ repodata_set_checksum(Repodata *data, Id solvid, Id keyname, Id type,
 const char *
 repodata_chk2str(Repodata *data, Id type, const unsigned char *buf)
 {
-  int i, l;
-  char *str, *s;
+  int l;
 
   if (!(l = sat_chksum_len(type)))
     return "";
-  s = str = pool_alloctmpspace(data->repo->pool, 2 * l + 1);
-  for (i = 0; i < l; i++)
-    {
-      unsigned char v = buf[i];
-      unsigned char w = v >> 4;
-      *s++ = w >= 10 ? w + ('a' - 10) : w + '0';
-      w = v & 15;
-      *s++ = w >= 10 ? w + ('a' - 10) : w + '0';
-    }
-  *s = 0;
-  return str;
+  return pool_bin2hex(data->repo->pool, buf, l);
 }
 
 /* rpm filenames don't contain the epoch, so strip it */

diff --git a/src/solvable.c b/src/solvable.c
index 56c3942..6a2889c 100644 (file)
--- a/src/solvable.c
+++ b/src/solvable.c
@@ -20,6 +20,7 @@
 #include "pool.h"
 #include "repo.h"
 #include "util.h"
+#include "chksum.h"
 
 const char *
 solvable2str(Pool *pool, Solvable *s)
@@ -220,8 +221,7 @@ const char *
 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
 {
   const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
-  /* we need the repodata just as a reference for a pool */
-  return chk ? repodata_chk2str(s->repo->repodata, *typep, chk) : 0;
+  return chk ? pool_bin2hex(s->repo->pool, chk, sat_chksum_len(*typep)) : 0;
 }
 
 static inline const char *

diff --git a/src/solverdebug.c b/src/solverdebug.c
index f2d2232..e3eb147 100644 (file)
--- a/src/solverdebug.c
+++ b/src/solverdebug.c
@@ -812,16 +812,17 @@ solver_select2str(Pool *pool, Id select, Id what)
   if (select == SOLVER_SOLVABLE_ONE_OF)
     {
       Id p;
-      char *b2;
-      b = "";
+      b = 0;
       while ((p = pool->whatprovidesdata[what++]) != 0)
        {
          s = solvid2str(pool, p);
-         b2 = pool_alloctmpspace(pool, strlen(b) + strlen(s) + 3);
-         sprintf(b2, "%s, %s", b, s);
-         b = b2;
+         if (b)
+           b = pool_tmpappend(pool, b, ", ", s);
+         else
+           b = pool_tmpjoin(pool, s, 0, 0);
+         pool_freetmpspace(pool, s);
        }
-      return *b ? b + 2 : "nothing";
+      return b ? b : "nothing";
     }
   if (select == SOLVER_SOLVABLE_REPO)
     {

diff --git a/src/util.c b/src/util.c
index f728e92..b04771e 100644 (file)
--- a/src/util.c
+++ b/src/util.c
@@ -174,3 +174,63 @@ sat_dupjoin(const char *str1, const char *str2, const char *str3)
   *s = 0;
   return str;
 }
+
+char *
+sat_dupappend(const char *str1, const char *str2, const char *str3)
+{
+  char *str = sat_dupjoin(str1, str2, str3);
+  sat_free((void *)str1);
+  return str;
+}
+
+int
+sat_hex2bin(const char **strp, unsigned char *buf, int bufl)
+{
+  const char *str = *strp;
+  int i;
+
+  for (i = 0; i < bufl; i++)
+    {
+      int c = *str;
+      int d;
+      if (c >= '0' && c <= '9')
+        d = c - '0';
+      else if (c >= 'a' && c <= 'f')
+        d = c - ('a' - 10);
+      else if (c >= 'A' && c <= 'F')
+        d = c - ('A' - 10);
+      else
+       break;
+      c = *++str;
+      d <<= 4;
+      if (c >= '0' && c <= '9')
+        d |= c - '0';
+      else if (c >= 'a' && c <= 'f')
+        d |= c - ('a' - 10);
+      else if (c >= 'A' && c <= 'F')
+        d |= c - ('A' - 10);
+      else
+       break;
+      buf[i] = d;
+      ++str;
+    }
+  *strp = str;
+  return i;
+}
+
+char *
+sat_bin2hex(const unsigned char *buf, int l, char *str)
+{
+  int i;
+  for (i = 0; i < l; i++, buf++)
+    {
+      int c = *buf >> 4;
+      *str++ = c < 10 ? c + '0' : c + ('a' - 10);
+      c = *buf & 15;
+      *str++ = c < 10 ? c + '0' : c + ('a' - 10);
+    }
+  *str = 0;
+  return str;
+}
+
+

diff --git a/src/util.h b/src/util.h
index 6191d43..ebc2bc8 100644 (file)
--- a/src/util.h
+++ b/src/util.h
@@ -30,6 +30,10 @@ extern void sat_oom(size_t, size_t);
 extern unsigned int sat_timems(unsigned int subtract);
 extern void sat_sort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *compard);
 extern char *sat_dupjoin(const char *str1, const char *str2, const char *str3);
+extern char *sat_dupappend(const char *str1, const char *str2, const char *str3);
+extern int sat_hex2bin(const char **strp, unsigned char *buf, int bufl);
+extern char *sat_bin2hex(const unsigned char *buf, int l, char *str);
+
 
 static inline void *sat_extend(void *buf, size_t len, size_t nmemb, size_t size, size_t block)
 {