X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fchksum.c;h=1f8ab471e207f615ab32101fb9c709fd5e1dbdf3;hb=18ebbaf4f619e79231f5ad18a2ab8c135d22ef56;hp=e2043f3829f245d6323ac814b3e70d9d84802fb3;hpb=981af045ed19c8d6d00117f47ac2187b63c754bd;p=platform%2Fupstream%2Flibsolv.git

diff --git a/src/chksum.c b/src/chksum.c
index e2043f3..1f8ab47 100644
--- a/src/chksum.c
+++ b/src/chksum.c
@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) 2008-2012, Novell Inc.
+ *
+ * This program is licensed under the BSD license, read LICENSE.BSD
+ * for further information
+ */
+
 #include <sys/types.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -12,96 +19,260 @@
 #include "sha1.h"
 #include "sha2.h"
 
-struct ctxhandle {
+#ifdef _WIN32
+  #include "strfncs.h"
+#endif
+
+struct s_Chksum {
   Id type;
   int done;
   unsigned char result[64];
   union {
     MD5_CTX md5;
     SHA1_CTX sha1;
+    SHA224_CTX sha224;
     SHA256_CTX sha256;
+    SHA384_CTX sha384;
+    SHA512_CTX sha512;
   } c;
 };
 
-void *
-sat_chksum_create(Id type)
+Chksum *
+solv_chksum_create(Id type)
 {
-  struct ctxhandle *h;
-  h = sat_calloc(1, sizeof(*h));
-  h->type = type;
+  Chksum *chk;
+  chk = solv_calloc(1, sizeof(*chk));
+  chk->type = type;
   switch(type)
     {
     case REPOKEY_TYPE_MD5:
-      sat_MD5_Init(&h->c.md5);
-      return h;
+      solv_MD5_Init(&chk->c.md5);
+      return chk;
     case REPOKEY_TYPE_SHA1:
-      sat_SHA1_Init(&h->c.sha1);
-      return h;
+      solv_SHA1_Init(&chk->c.sha1);
+      return chk;
+    case REPOKEY_TYPE_SHA224:
+      solv_SHA224_Init(&chk->c.sha224);
+      return chk;
     case REPOKEY_TYPE_SHA256:
-      sat_SHA256_Init(&h->c.sha256);
-      return h;
+      solv_SHA256_Init(&chk->c.sha256);
+      return chk;
+    case REPOKEY_TYPE_SHA384:
+      solv_SHA384_Init(&chk->c.sha384);
+      return chk;
+    case REPOKEY_TYPE_SHA512:
+      solv_SHA512_Init(&chk->c.sha512);
+      return chk;
+    default:
+      break;
     }
-  free(h);
+  free(chk);
   return 0;
 }
 
+Chksum *
+solv_chksum_create_clone(Chksum *chk)
+{
+  return solv_memdup(chk, sizeof(*chk));
+}
+
+int
+solv_chksum_len(Id type)
+{
+  switch (type)
+    {
+    case REPOKEY_TYPE_MD5:
+      return 16;
+    case REPOKEY_TYPE_SHA1:
+      return 20;
+    case REPOKEY_TYPE_SHA224:
+      return 28;
+    case REPOKEY_TYPE_SHA256:
+      return 32;
+    case REPOKEY_TYPE_SHA384:
+      return 48;
+    case REPOKEY_TYPE_SHA512:
+      return 64;
+    default:
+      return 0;
+    }
+}
+
+Chksum *
+solv_chksum_create_from_bin(Id type, const unsigned char *buf)
+{
+  Chksum *chk;
+  int l = solv_chksum_len(type);
+  if (buf == 0 || l == 0)
+    return 0;
+  chk = solv_calloc(1, sizeof(*chk));
+  chk->type = type;
+  chk->done = 1;
+  memcpy(chk->result, buf, l);
+  return chk;
+}
+
 void
-sat_chksum_add(void *handle, const void *data, int len)
+solv_chksum_add(Chksum *chk, const void *data, int len)
 {
-  struct ctxhandle *h = handle;
-  switch(h->type)
+  if (chk->done)
+    return;
+  switch(chk->type)
     {
     case REPOKEY_TYPE_MD5:
-      sat_MD5_Update(&h->c.md5, (void *)data, len);
+      solv_MD5_Update(&chk->c.md5, (void *)data, len);
       return;
     case REPOKEY_TYPE_SHA1:
-      sat_SHA1_Update(&h->c.sha1, data, len);
+      solv_SHA1_Update(&chk->c.sha1, data, len);
+      return;
+    case REPOKEY_TYPE_SHA224:
+      solv_SHA224_Update(&chk->c.sha224, data, len);
       return;
     case REPOKEY_TYPE_SHA256:
-      sat_SHA256_Update(&h->c.sha256, data, len);
+      solv_SHA256_Update(&chk->c.sha256, data, len);
+      return;
+    case REPOKEY_TYPE_SHA384:
+      solv_SHA384_Update(&chk->c.sha384, data, len);
+      return;
+    case REPOKEY_TYPE_SHA512:
+      solv_SHA512_Update(&chk->c.sha512, data, len);
       return;
     default:
       return;
     }
 }
 
-unsigned char *
-sat_chksum_get(void *handle, int *lenp)
+const unsigned char *
+solv_chksum_get(Chksum *chk, int *lenp)
 {
-  struct ctxhandle *h = handle;
-  if (h->done)
-    return h->result;
-  switch(h->type)
+  if (chk->done)
+    {
+      if (lenp)
+        *lenp = solv_chksum_len(chk->type);
+      return chk->result;
+    }
+  switch(chk->type)
     {
     case REPOKEY_TYPE_MD5:
-      sat_MD5_Final(h->result, &h->c.md5);
-      h->done = 1;
-      if (*lenp)
+      solv_MD5_Final(chk->result, &chk->c.md5);
+      chk->done = 1;
+      if (lenp)
 	*lenp = 16;
-      return h->result;
+      return chk->result;
     case REPOKEY_TYPE_SHA1:
-      sat_SHA1_Final(&h->c.sha1, h->result);
-      h->done = 1;
-      if (*lenp)
+      solv_SHA1_Final(&chk->c.sha1, chk->result);
+      chk->done = 1;
+      if (lenp)
 	*lenp = 20;
-      return h->result;
+      return chk->result;
+    case REPOKEY_TYPE_SHA224:
+      solv_SHA224_Final(chk->result, &chk->c.sha224);
+      chk->done = 1;
+      if (lenp)
+	*lenp = 28;
+      return chk->result;
     case REPOKEY_TYPE_SHA256:
-      sat_SHA256_Final(h->result, &h->c.sha256);
-      h->done = 1;
-      if (*lenp)
+      solv_SHA256_Final(chk->result, &chk->c.sha256);
+      chk->done = 1;
+      if (lenp)
 	*lenp = 32;
-      return h->result;
+      return chk->result;
+    case REPOKEY_TYPE_SHA384:
+      solv_SHA384_Final(chk->result, &chk->c.sha384);
+      chk->done = 1;
+      if (lenp)
+	*lenp = 48;
+      return chk->result;
+    case REPOKEY_TYPE_SHA512:
+      solv_SHA512_Final(chk->result, &chk->c.sha512);
+      chk->done = 1;
+      if (lenp)
+	*lenp = 64;
+      return chk->result;
     default:
-      if (*lenp)
+      if (lenp)
 	*lenp = 0;
       return 0;
     }
 }
 
+Id
+solv_chksum_get_type(Chksum *chk)
+{
+  return chk->type;
+}
+
+int
+solv_chksum_isfinished(Chksum *chk)
+{
+  return chk->done != 0;
+}
+
+const char *
+solv_chksum_type2str(Id type)
+{
+  switch(type)
+    {
+    case REPOKEY_TYPE_MD5:
+      return "md5";
+    case REPOKEY_TYPE_SHA1:
+      return "sha1";
+    case REPOKEY_TYPE_SHA224:
+      return "sha224";
+    case REPOKEY_TYPE_SHA256:
+      return "sha256";
+    case REPOKEY_TYPE_SHA384:
+      return "sha384";
+    case REPOKEY_TYPE_SHA512:
+      return "sha512";
+    default:
+      return 0;
+    }
+}
+
+Id
+solv_chksum_str2type(const char *str)
+{
+  if (!strcasecmp(str, "md5"))
+    return REPOKEY_TYPE_MD5;
+  if (!strcasecmp(str, "sha") || !strcasecmp(str, "sha1"))
+    return REPOKEY_TYPE_SHA1;
+  if (!strcasecmp(str, "sha224"))
+    return REPOKEY_TYPE_SHA224;
+  if (!strcasecmp(str, "sha256"))
+    return REPOKEY_TYPE_SHA256;
+  if (!strcasecmp(str, "sha384"))
+    return REPOKEY_TYPE_SHA384;
+  if (!strcasecmp(str, "sha512"))
+    return REPOKEY_TYPE_SHA512;
+  return 0;
+}
+
 void *
-sat_chksum_free(void *handle)
+solv_chksum_free(Chksum *chk, unsigned char *cp)
 {
-  sat_free(handle);
+  if (cp)
+    {
+      const unsigned char *res;
+      int l;
+      res = solv_chksum_get(chk, &l);
+      if (l && res)
+        memcpy(cp, res, l);
+    }
+  solv_free(chk);
   return 0;
 }
 
+int
+solv_chksum_cmp(Chksum *chk, Chksum *chk2)
+{
+  int len;
+  const unsigned char *res1, *res2;
+  if (chk == chk2)
+    return 1;
+  if (!chk || !chk2 || chk->type != chk2->type)
+    return 0;
+  res1 = solv_chksum_get(chk, &len);
+  res2 = solv_chksum_get(chk2, 0);
+  return memcmp(res1, res2, len) == 0 ? 1 : 0;
+}