Added.

[silc.git] / lib / silcutil / silcutil.c

diff --git a/lib/silcutil/silcutil.c b/lib/silcutil/silcutil.c
index c412262452e550c2673c0f49950825bf7f497f7a..a191f46b0a24e7444577b914daa306791822d64d 100644 (file)
--- a/lib/silcutil/silcutil.c
+++ b/lib/silcutil/silcutil.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2006 Pekka Riikonen
+  Copyright (C) 1997 - 2007 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -165,7 +165,7 @@ void silc_parse_command_line(unsigned char *buffer,
 {
   int i, len = 0;
   int argc = 0;
-  const char *cp = buffer;
+  const char *cp = (const char *)buffer;
   char *tmp;
 
   *parsed = silc_calloc(1, sizeof(**parsed));
@@ -236,7 +236,7 @@ char *silc_format(char *fmt, ...)
 
   memset(buf, 0, sizeof(buf));
   va_start(args, fmt);
-  vsnprintf(buf, sizeof(buf) - 1, fmt, args);
+  silc_vsnprintf(buf, sizeof(buf) - 1, fmt, args);
   va_end(args);
 
   return strdup(buf);
@@ -380,25 +380,6 @@ SilcUInt32 silc_hash_data(void *key, void *user_context)
   return h;
 }
 
-/* Hash public key of any type. */
-
-SilcUInt32 silc_hash_public_key(void *key, void *user_context)
-{
-  SilcPublicKey public_key = key;
-  unsigned char *pk;
-  SilcUInt32 pk_len;
-  SilcUInt32 hash = 0;
-
-  pk = silc_pkcs_public_key_encode(public_key, &pk_len);
-  if (!pk)
-    return hash;
-
-  hash = silc_hash_data(pk, SILC_32_TO_PTR(pk_len));
-  silc_free(pk);
-
-  return hash;
-}
-
 /* Compares two strings. It may be used as SilcHashTable comparison
    function. */
 
@@ -454,15 +435,6 @@ SilcBool silc_hash_utf8_compare(void *key1, void *key2, void *user_context)
   return !memcmp(key1, key2, l2);
 }
 
-/* Compares two SILC Public keys. It may be used as SilcHashTable
-   comparison function. */
-
-SilcBool silc_hash_public_key_compare(void *key1, void *key2,
-                                     void *user_context)
-{
-  return silc_pkcs_public_key_compare(key1, key2);
-}
-
 /* Creates fingerprint from data, usually used with SHA1 digests */
 
 char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
@@ -473,14 +445,14 @@ char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
   memset(fingerprint, 0, sizeof(fingerprint));
   cp = fingerprint;
   for (i = 0; i < data_len; i++) {
-    snprintf(cp, sizeof(fingerprint), "%02X", data[i]);
+    silc_snprintf(cp, sizeof(fingerprint), "%02X", data[i]);
     cp += 2;
 
     if ((i + 1) % 2 == 0)
-      snprintf(cp++, sizeof(fingerprint), " ");
+      silc_snprintf(cp++, sizeof(fingerprint), " ");
 
     if ((i + 1) % 10 == 0)
-      snprintf(cp++, sizeof(fingerprint), " ");
+      silc_snprintf(cp++, sizeof(fingerprint), " ");
   }
   i--;
   if ((i + 1) % 2 == 0)
@@ -593,3 +565,126 @@ char *silc_get_input(const char *prompt, SilcBool echo_off)
   return NULL;
 #endif /* SILC_UNIX */
 }
+
+/* Hexdump */
+
+void silc_hexdump(const unsigned char *data, SilcUInt32 data_len,
+                 FILE *output)
+{
+  int i, k;
+  int off, pos, count;
+  int len = data_len;
+
+  k = 0;
+  pos = 0;
+  count = 16;
+  off = len % 16;
+  while (1) {
+    if (off) {
+      if ((len - pos) < 16 && (len - pos <= len - off))
+       count = off;
+    } else {
+      if (pos == len)
+       count = 0;
+    }
+    if (off == len)
+      count = len;
+
+    if (count)
+      fprintf(output, "%08X  ", k++ * 16);
+
+    for (i = 0; i < count; i++) {
+      fprintf(output, "%02X ", data[pos + i]);
+
+      if ((i + 1) % 4 == 0)
+       fprintf(output, " ");
+    }
+
+    if (count && count < 16) {
+      int j;
+
+      for (j = 0; j < 16 - count; j++) {
+       fprintf(output, "   ");
+
+       if ((j + count + 1) % 4 == 0)
+         fprintf(output, " ");
+      }
+    }
+
+    for (i = 0; i < count; i++) {
+      char ch;
+
+      if (data[pos] < 32 || data[pos] >= 127)
+       ch = '.';
+      else
+       ch = data[pos];
+
+      fprintf(output, "%c", ch);
+      pos++;
+    }
+
+    if (count)
+      fprintf(output, "\n");
+
+    if (count < 16)
+      break;
+  }
+}
+
+/* Convert hex string to data.  Each hex number must have two characters. */
+
+SilcBool silc_hex2data(const char *hex, unsigned char *data,
+                      SilcUInt32 data_size, SilcUInt32 *ret_data_len)
+{
+  char *cp = (char *)hex;
+  unsigned char l, h;
+  int i;
+
+  if (data_size < strlen(hex) / 2)
+    return FALSE;
+
+  for (i = 0; i < strlen(hex) / 2; i++) {
+    h = *cp++;
+    l = *cp++;
+
+    h -= h < 'A' ? '0' : 'A' - 10;
+    l -= l < 'A' ? '0' : 'A' - 10;
+
+    data[i] = (h << 4) | (l & 0xf);
+  }
+
+  if (ret_data_len)
+    *ret_data_len = i;
+
+  SILC_LOG_HEXDUMP(("len %d", i), data, i);
+
+  return TRUE;
+}
+
+/* Converts binary data to HEX string */
+
+SilcBool silc_data2hex(const unsigned char *data, SilcUInt32 data_len,
+                      char *hex, SilcUInt32 hex_size)
+{
+  unsigned char l, h;
+  char *cp = hex;
+  int i;
+
+  if (hex_size - 1 < data_len * 2)
+    return FALSE;
+
+  memset(hex, 0, hex_size);
+
+  for (i = 0; i < data_len; i++) {
+    l = data[i];
+    h = l >> 4;
+    l &= 0xf;
+
+    *cp++ = h + (h > 9 ? 'A' - 10 : '0');
+    *cp++ = l + (l > 9 ? 'A' - 10 : '0');
+  }
+
+  SILC_LOG_DEBUG(("HEX string: '%s'", hex));
+
+  return TRUE;
+}