Added SILC Thread Queue API

[silc.git] / lib / silccrypt / silchash.c

diff --git a/lib/silccrypt/silchash.c b/lib/silccrypt/silchash.c
index 59cdf7f94eb88d07efc93792a791f3f79e3a516a..67c149522d4eef9606930d792f9b081234cfb47f 100644 (file)
--- a/lib/silccrypt/silchash.c
+++ b/lib/silccrypt/silchash.c
@@ -23,6 +23,7 @@
 #include "md5.h"
 #include "sha1.h"
 #include "sha256.h"
+#include "sha512.h"
 
 /* The main SILC hash structure. */
 struct SilcHashStruct {
@@ -41,6 +42,9 @@ const SilcHashObject silc_default_hash[] =
   { "sha256", "2.16.840.1.101.3.4.2.1",
     32, 64, silc_sha256_init, silc_sha256_update, silc_sha256_final,
     silc_sha256_transform, silc_sha256_context_len },
+  { "sha512", "2.16.840.1.101.3.4.2.3",
+    32, 64, silc_sha512_init, silc_sha512_update, silc_sha512_final,
+    silc_sha512_transform, silc_sha512_context_len },
   { "sha1", "1.3.14.3.2.26",
     20, 64, silc_sha1_init, silc_sha1_update, silc_sha1_final,
     silc_sha1_transform, silc_sha1_context_len },
@@ -51,8 +55,7 @@ const SilcHashObject silc_default_hash[] =
   { NULL, NULL, 0, 0, NULL, NULL, NULL, NULL, NULL }
 };
 
-/* Registers a new hash function into the SILC. This function is used at
-   the initialization of the SILC. */
+/* Registers a new hash function */
 
 SilcBool silc_hash_register(const SilcHashObject *hash)
 {
@@ -101,7 +104,7 @@ SilcBool silc_hash_register(const SilcHashObject *hash)
   return TRUE;
 }
 
-/* Unregister a hash function from the SILC. */
+/* Unregister a hash function */
 
 SilcBool silc_hash_unregister(SilcHashObject *hash)
 {
@@ -134,22 +137,16 @@ SilcBool silc_hash_unregister(SilcHashObject *hash)
   return FALSE;
 }
 
-/* Function that registers all the default hash funcs (all builtin ones).
-   The application may use this to register the default hash funcs if
-   specific hash funcs in any specific order is not wanted. */
+/* Register default hash functions */
 
 SilcBool silc_hash_register_default(void)
 {
-#ifndef SILC_SYMBIAN
-  int i;
-
-  for (i = 0; silc_default_hash[i].name; i++)
-    silc_hash_register(&(silc_default_hash[i]));
-
-#endif /* SILC_SYMBIAN */
+  /* We use builtin hash functions */
   return TRUE;
 }
 
+/* Unregister all hash functions */
+
 SilcBool silc_hash_unregister_all(void)
 {
 #ifndef SILC_SYMBIAN
@@ -171,13 +168,15 @@ SilcBool silc_hash_unregister_all(void)
 /* Allocates a new SilcHash object. New object is returned into new_hash
    argument. */
 
-SilcBool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
+SilcBool silc_hash_alloc(const char *name, SilcHash *new_hash)
 {
   SilcHashObject *entry = NULL;
+  int i;
 
   SILC_LOG_DEBUG(("Allocating new hash %s", name));
 
 #ifndef SILC_SYMBIAN
+  /* Check list of registered hash functions */
   if (silc_hash_list) {
     silc_dlist_start(silc_hash_list);
     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
@@ -185,10 +184,10 @@ SilcBool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
        break;
     }
   }
-#else
-  {
-    /* On EPOC which don't have globals we check our constant hash list. */
-    int i;
+#endif /* SILC_SYMBIAN */
+
+  if (!entry) {
+    /* Check builtin hash function list */
     for (i = 0; silc_default_hash[i].name; i++) {
       if (!strcmp(silc_default_hash[i].name, name)) {
        entry = (SilcHashObject *)&(silc_default_hash[i]);
@@ -196,7 +195,6 @@ SilcBool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
       }
     }
   }
-#endif /* SILC_SYMBIAN */
 
   if (entry) {
     *new_hash = silc_calloc(1, sizeof(**new_hash));
@@ -219,10 +217,12 @@ SilcBool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
 SilcBool silc_hash_alloc_by_oid(const char *oid, SilcHash *new_hash)
 {
   SilcHashObject *entry = NULL;
+  int i;
 
   SILC_LOG_DEBUG(("Allocating new hash %s", oid));
 
 #ifndef SILC_SYMBIAN
+  /* Check list of registered hash functions */
   if (silc_hash_list) {
     silc_dlist_start(silc_hash_list);
     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
@@ -230,10 +230,10 @@ SilcBool silc_hash_alloc_by_oid(const char *oid, SilcHash *new_hash)
        break;
     }
   }
-#else
-  {
-    /* On EPOC which don't have globals we check our constant hash list. */
-    int i;
+#endif /* SILC_SYMBIAN */
+
+  if (!entry) {
+    /* Check builtin hash function list */
     for (i = 0; silc_default_hash[i].oid; i++) {
       if (!strcmp(silc_default_hash[i].oid, oid)) {
        entry = (SilcHashObject *)&(silc_default_hash[i]);
@@ -241,7 +241,6 @@ SilcBool silc_hash_alloc_by_oid(const char *oid, SilcHash *new_hash)
       }
     }
   }
-#endif /* SILC_SYMBIAN */
 
   if (entry) {
     *new_hash = silc_calloc(1, sizeof(**new_hash));
@@ -299,11 +298,12 @@ const char *silc_hash_get_oid(SilcHash hash)
 
 /* Returns TRUE if hash algorithm `name' is supported. */
 
-SilcBool silc_hash_is_supported(const unsigned char *name)
+SilcBool silc_hash_is_supported(const char *name)
 {
-#ifndef SILC_SYMBIAN
   SilcHashObject *entry;
+  int i;
 
+#ifndef SILC_SYMBIAN
   if (silc_hash_list) {
     silc_dlist_start(silc_hash_list);
     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
@@ -311,14 +311,12 @@ SilcBool silc_hash_is_supported(const unsigned char *name)
        return TRUE;
     }
   }
-#else
-  {
-    int i;
-    for (i = 0; silc_default_hash[i].name; i++)
-      if (!strcmp(silc_default_hash[i].name, name))
-       return TRUE;
-  }
 #endif /* SILC_SYMBIAN */
+
+  for (i = 0; silc_default_hash[i].name; i++)
+    if (!strcmp(silc_default_hash[i].name, name))
+      return TRUE;
+
   return FALSE;
 }
 
@@ -326,9 +324,9 @@ SilcBool silc_hash_is_supported(const unsigned char *name)
 
 char *silc_hash_get_supported(void)
 {
-  SilcHashObject *entry;
+  SilcHashObject *entry, *entry2;
   char *list = NULL;
-  int len = 0;
+  int i, len = 0;
 
 #ifndef SILC_SYMBIAN
   if (silc_hash_list) {
@@ -343,21 +341,29 @@ char *silc_hash_get_supported(void)
       len++;
     }
   }
-#else
-  {
-    int i;
-    for (i = 0; silc_default_hash[i].name; i++) {
-      entry = (SilcHashObject *)&(silc_default_hash[i]);
-      len += strlen(entry->name);
-      list = silc_realloc(list, len + 1);
+#endif /* SILC_SYMBIAN */
 
-      memcpy(list + (len - strlen(entry->name)),
-            entry->name, strlen(entry->name));
-      memcpy(list + len, ",", 1);
-      len++;
+  for (i = 0; silc_default_hash[i].name; i++) {
+    entry = (SilcHashObject *)&(silc_default_hash[i]);
+
+    if (silc_hash_list) {
+      silc_dlist_start(silc_hash_list);
+      while ((entry2 = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
+       if (!strcmp(entry2->name, entry->name))
+         break;
+      }
+      if (entry2)
+       continue;
     }
+
+    len += strlen(entry->name);
+    list = silc_realloc(list, len + 1);
+
+    memcpy(list + (len - strlen(entry->name)),
+          entry->name, strlen(entry->name));
+    memcpy(list + len, ",", 1);
+    len++;
   }
-#endif /* SILC_SYMBIAN */
 
   list[len - 1] = 0;
 
@@ -390,7 +396,7 @@ void silc_hash_final(SilcHash hash, unsigned char *return_hash)
   hash->hash->final(hash->context, return_hash);
 }
 
-void silc_hash_transform(SilcHash hash, SilcUInt32 *state,
+void silc_hash_transform(SilcHash hash, void *state,
                         const unsigned char *data)
 {
   hash->hash->transform(state, data);