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
return FALSE;
for (i = 0; i < strlen(string); i++)
- dest[i] = toupper(string[i]);
+ dest[i] = (char)toupper((int)string[i]);
return TRUE;
}
return FALSE;
for (i = 0; i < strlen(string); i++)
- dest[i] = tolower(string[i]);
+ dest[i] = (char)tolower((int)string[i]);
return TRUE;
}
{
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));
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);
SilcUInt32 h = 0, g;
while (*s != '\0') {
- h = (h << 4) + tolower(*s);
+ h = (h << 4) + tolower((int)*s);
if ((g = h & 0xf0000000)) {
h = h ^ (g >> 24);
h = h ^ g;
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. */
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)
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)
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;
+}