ROBODoc documented the SILC Hash Interface and improved

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

diff --git a/lib/silccrypt/silchash.c b/lib/silccrypt/silchash.c
index 66a6ab8ef5dcf8e0dbb06979c7686ddf666b9790..52419b0b296635091e1eff4b3cb2343d494242e3 100644 (file)
--- a/lib/silccrypt/silchash.c
+++ b/lib/silccrypt/silchash.c
@@ -24,8 +24,16 @@
 #include "md5.h"
 #include "sha1.h"
 
+/* The main SILC hash structure. */
+struct SilcHashStruct {
+  SilcHashObject *hash;
+  void *context;
+};
+
+#ifndef SILC_EPOC
 /* List of dynamically registered hash functions. */
 SilcDList silc_hash_list = NULL;
+#endif /* SILC_EPOC */
 
 /* Default hash functions for silc_hash_register_default(). */
 const SilcHashObject silc_default_hash[] = 
@@ -41,8 +49,9 @@ const SilcHashObject silc_default_hash[] =
 /* Registers a new hash function into the SILC. This function is used at
    the initialization of the SILC. */
 
-bool silc_hash_register(SilcHashObject *hash)
+bool silc_hash_register(const SilcHashObject *hash)
 {
+#ifndef SILC_EPOC
   SilcHashObject *new;
 
   SILC_LOG_DEBUG(("Registering new hash function `%s'", hash->name));
@@ -72,6 +81,7 @@ bool silc_hash_register(SilcHashObject *hash)
     silc_hash_list = silc_dlist_init();
   silc_dlist_add(silc_hash_list, new);
 
+#endif /* SILC_EPOC */
   return TRUE;
 }
 
@@ -79,6 +89,7 @@ bool silc_hash_register(SilcHashObject *hash)
 
 bool silc_hash_unregister(SilcHashObject *hash)
 {
+#ifndef SILC_EPOC
   SilcHashObject *entry;
 
   SILC_LOG_DEBUG(("Unregistering hash function"));
@@ -100,6 +111,7 @@ bool silc_hash_unregister(SilcHashObject *hash)
     }
   }
 
+#endif /* SILC_EPOC */
   return FALSE;
 }
 
@@ -109,11 +121,13 @@ bool silc_hash_unregister(SilcHashObject *hash)
 
 bool silc_hash_register_default(void)
 {
+#ifndef SILC_EPOC
   int i;
 
   for (i = 0; silc_default_hash[i].name; i++)
-    silc_hash_register((SilcHashObject *)&(silc_default_hash[i]));
+    silc_hash_register(&(silc_default_hash[i]));
 
+#endif /* SILC_EPOC */
   return TRUE;
 }
 
@@ -122,22 +136,37 @@ bool silc_hash_register_default(void)
 
 bool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
 {
-  SilcHashObject *entry;
+  SilcHashObject *entry = NULL;
   
   SILC_LOG_DEBUG(("Allocating new hash object"));
 
+#ifndef SILC_EPOC
   if (silc_hash_list) {
     silc_dlist_start(silc_hash_list);
     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
-      if (!strcmp(entry->name, name)) {
-       *new_hash = silc_calloc(1, sizeof(**new_hash));
-       (*new_hash)->hash = entry;
-       (*new_hash)->context = silc_calloc(1, entry->context_len());
-       (*new_hash)->make_hash = silc_hash_make;
-       return TRUE;
+      if (!strcmp(entry->name, name))
+       break;
+    }
+  }
+#else
+  {
+    /* On EPOC which don't have globals we check our constant hash list. */
+    int i;
+    for (i = 0; silc_default_hash[i].name; i++) {
+      if (!strcmp(silc_default_hash[i].name, name)) {
+       entry = (SilcHashObject *)&(silc_default_hash[i]);
+       break;
       }
     }
   }
+#endif /* SILC_EPOC */
+
+  if (entry) {
+    *new_hash = silc_calloc(1, sizeof(**new_hash));
+    (*new_hash)->hash = entry;
+    (*new_hash)->context = silc_calloc(1, entry->context_len());
+    return TRUE;
+  }
 
   return FALSE;
 }
@@ -159,10 +188,25 @@ SilcUInt32 silc_hash_len(SilcHash hash)
   return hash->hash->hash_len;
 }
 
+/* Returns the block lenght of the hash. */
+
+SilcUInt32 silc_hash_block_len(SilcHash hash)
+{
+  return hash->hash->block_len;
+}
+
+/* Returns the name of the hash function */
+
+const char *silc_hash_get_name(SilcHash hash)
+{
+  return hash->hash->name;
+}
+
 /* Returns TRUE if hash algorithm `name' is supported. */
 
 bool silc_hash_is_supported(const unsigned char *name)
 {
+#ifndef SILC_EPOC
   SilcHashObject *entry;
 
   if (silc_hash_list) {
@@ -172,7 +216,14 @@ bool 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_EPOC */
   return FALSE;
 }
 
@@ -182,9 +233,9 @@ char *silc_hash_get_supported(void)
 {
   SilcHashObject *entry;
   char *list = NULL;
-  int len;
+  int len = 0;
 
-  len = 0;
+#ifndef SILC_EPOC
   if (silc_hash_list) {
     silc_dlist_start(silc_hash_list);
     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
@@ -196,8 +247,24 @@ char *silc_hash_get_supported(void)
       memcpy(list + len, ",", 1);
       len++;
     }
-    list[len - 1] = 0;
   }
+#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);
+      
+      memcpy(list + (len - strlen(entry->name)), 
+            entry->name, strlen(entry->name));
+      memcpy(list + len, ",", 1);
+      len++;
+    }
+  }
+#endif /* SILC_EPOC */
+
+  list[len - 1] = 0;
 
   return list;
 }
@@ -206,14 +273,36 @@ char *silc_hash_get_supported(void)
 
 void silc_hash_make(SilcHash hash, const unsigned char *data, 
                    SilcUInt32 len, unsigned char *return_hash)
+{
+  silc_hash_init(hash);
+  silc_hash_update(hash, data, len);
+  silc_hash_final(hash, return_hash);
+}
+
+void silc_hash_init(SilcHash hash)
 {
   hash->hash->init(hash->context);
-  hash->hash->update(hash->context, (unsigned char *)data, len);
+}
+
+void silc_hash_update(SilcHash hash, const unsigned char *data,
+                     SilcUInt32 data_len)
+{
+  hash->hash->update(hash->context, (unsigned char *)data, data_len);
+}
+
+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,
+                        const unsigned char *data)
+{
+  hash->hash->transform(state, data);
+}
+
 /* Creates fingerprint of the data. If `hash' is NULL SHA1 is used as
-   default hash function. The returned fingerprint must be free's by the
+   default hash function. The returned fingerprint must be freed by the
    caller. */
 
 char *silc_hash_fingerprint(SilcHash hash, const unsigned char *data,