/*
- silcutil.c
+ silcutil.c
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2002 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
*/
/* $Id$ */
-#include "silcincludes.h"
+#include "silc.h"
/* Gets line from a buffer. Stops reading when a newline or EOF occurs.
This doesn't remove the newline sign from the destination buffer. The
{
static int start = 0;
int i;
-
+
memset(dest, 0, destlen);
-
+
if (begin != start)
start = 0;
-
+
i = 0;
for ( ; start <= srclen; i++, start++) {
- if (i > destlen)
+ if (i > destlen) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return -1;
-
+ }
+
dest[i] = src[start];
-
- if (dest[i] == EOF)
+
+ if (dest[i] == EOF) {
+ silc_set_errno(SILC_ERR_EOF);
return EOF;
-
- if (dest[i] == '\n')
+ }
+
+ if (dest[i] == '\n')
break;
}
start++;
-
+
return start;
}
-/* Checks line for illegal characters. Return -1 when illegal character
- were found. This is used to check for bad lines when reading data from
- for example a configuration file. */
+/* Converts string to capital characters. */
-int silc_check_line(char *buf)
+SilcBool silc_to_upper(const char *string, char *dest, SilcUInt32 dest_size)
{
- /* Illegal characters in line */
- if (strchr(buf, '#')) return -1;
- if (strchr(buf, '\'')) return -1;
- if (strchr(buf, '\\')) return -1;
- if (strchr(buf, '\r')) return -1;
- if (strchr(buf, '\a')) return -1;
- if (strchr(buf, '\b')) return -1;
- if (strchr(buf, '\f')) return -1;
-
- /* Empty line */
- if (buf[0] == '\n')
- return -1;
-
- return 0;
-}
-
-/* Returns current time as string. */
+ int i;
-char *silc_get_time()
-{
- time_t curtime;
- char *return_time;
+ if (strlen(string) > dest_size) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
+ return FALSE;
+ }
- curtime = time(NULL);
- return_time = ctime(&curtime);
- return_time[strlen(return_time) - 1] = '\0';
+ for (i = 0; i < strlen(string); i++)
+ dest[i] = (char)toupper((int)string[i]);
- return return_time;
+ return TRUE;
}
-/* Converts string to capital characters */
+/* Converts string to lower letter characters. */
-char *silc_to_upper(char *string)
+SilcBool silc_to_lower(const char *string, char *dest, SilcUInt32 dest_size)
{
int i;
- char *ret = silc_calloc(strlen(string) + 1, sizeof(char));
- for (i = 0; i < strlen(string); i++)
- ret[i] = toupper(string[i]);
-
- return ret;
-}
-
-static unsigned char pem_enc[64] =
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/* Encodes data into PEM encoding. Returns NULL terminated PEM encoded
- data string. Note: This is originally public domain code and is
- still PD. */
-
-char *silc_encode_pem(unsigned char *data, SilcUInt32 len)
-{
- int i, j;
- SilcUInt32 bits, c, char_count;
- char *pem;
-
- char_count = 0;
- bits = 0;
- j = 0;
-
- pem = silc_calloc(((len * 8 + 5) / 6) + 5, sizeof(*pem));
-
- for (i = 0; i < len; i++) {
- c = data[i];
- bits += c;
- char_count++;
-
- if (char_count == 3) {
- pem[j++] = pem_enc[bits >> 18];
- pem[j++] = pem_enc[(bits >> 12) & 0x3f];
- pem[j++] = pem_enc[(bits >> 6) & 0x3f];
- pem[j++] = pem_enc[bits & 0x3f];
- bits = 0;
- char_count = 0;
- } else {
- bits <<= 8;
- }
+ if (strlen(string) > dest_size) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
+ return FALSE;
}
- if (char_count != 0) {
- bits <<= 16 - (8 * char_count);
- pem[j++] = pem_enc[bits >> 18];
- pem[j++] = pem_enc[(bits >> 12) & 0x3f];
-
- if (char_count == 1) {
- pem[j++] = '=';
- pem[j] = '=';
- } else {
- pem[j++] = pem_enc[(bits >> 6) & 0x3f];
- pem[j] = '=';
- }
- }
+ for (i = 0; i < strlen(string); i++)
+ dest[i] = (char)tolower((int)string[i]);
- return pem;
+ return TRUE;
}
-/* Same as above but puts newline ('\n') every 72 characters. */
+/* Parse userfqdn string which is in user@fqdn format. */
-char *silc_encode_pem_file(unsigned char *data, SilcUInt32 data_len)
+int silc_parse_userfqdn(const char *string,
+ char *user, SilcUInt32 user_size,
+ char *fqdn, SilcUInt32 fqdn_size)
{
- int i, j;
- SilcUInt32 len, cols;
- char *pem, *pem2;
-
- pem = silc_encode_pem(data, data_len);
- len = strlen(pem);
-
- pem2 = silc_calloc(len + (len / 72) + 1, sizeof(*pem2));
-
- for (i = 0, j = 0, cols = 1; i < len; i++, cols++) {
- if (cols == 72) {
- pem2[i] = '\n';
- cols = 0;
- len++;
- continue;
- }
+ SilcUInt32 tlen;
- pem2[i] = pem[j++];
+ if (!user && !fqdn) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return 0;
}
- silc_free(pem);
- return pem2;
-}
-
-/* Decodes PEM into data. Returns the decoded data. Note: This is
- originally public domain code and is still PD. */
+ memset(user, 0, user_size);
+ memset(fqdn, 0, fqdn_size);
-unsigned char *silc_decode_pem(unsigned char *pem, SilcUInt32 pem_len,
- SilcUInt32 *ret_len)
-{
- int i, j;
- SilcUInt32 len, c, char_count, bits;
- unsigned char *data;
- static char ialpha[256], decoder[256];
-
- for (i = 64 - 1; i >= 0; i--) {
- ialpha[pem_enc[i]] = 1;
- decoder[pem_enc[i]] = i;
+ if (!string) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return 0;
}
- char_count = 0;
- bits = 0;
- j = 0;
-
- if (!pem_len)
- len = strlen(pem);
- else
- len = pem_len;
-
- data = silc_calloc(((len * 6) / 8), sizeof(*data));
-
- for (i = 0; i < len; i++) {
- c = pem[i];
-
- if (c == '=')
- break;
-
- if (c > 127 || !ialpha[c])
- continue;
-
- bits += decoder[c];
- char_count++;
-
- if (char_count == 4) {
- data[j++] = bits >> 16;
- data[j++] = (bits >> 8) & 0xff;
- data[j++] = bits & 0xff;
- bits = 0;
- char_count = 0;
- } else {
- bits <<= 6;
- }
- }
+ if (string[0] == '@') {
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
- switch(char_count) {
- case 1:
- silc_free(data);
- return NULL;
- break;
- case 2:
- data[j++] = bits >> 10;
- break;
- case 3:
- data[j++] = bits >> 16;
- data[j++] = (bits >> 8) & 0xff;
- break;
+ return 1;
}
- if (ret_len)
- *ret_len = j;
-
- return data;
-}
-
-/* Parse userfqdn string which is in user@fqdn format */
+ if (strchr(string, '@')) {
+ tlen = strcspn(string, "@");
-bool silc_parse_userfqdn(const char *string, char **left, char **right)
-{
- SilcUInt32 tlen;
+ if (user)
+ silc_strncat(user, user_size, string, tlen);
- if (!string)
- return FALSE;
+ if (fqdn)
+ silc_strncat(fqdn, fqdn_size, string + tlen + 1,
+ strlen(string) - tlen - 1);
- if (string[0] == '@') {
- if (left)
- *left = strdup(string);
- return TRUE;
+ return 2;
}
- if (strchr(string, '@')) {
- tlen = strcspn(string, "@");
-
- if (left) {
- *left = silc_calloc(tlen + 1, sizeof(char));
- memcpy(*left, string, tlen);
- }
-
- if (right) {
- *right = silc_calloc((strlen(string) - tlen) + 1, sizeof(char));
- memcpy(*right, string + tlen + 1, strlen(string) - tlen - 1);
- }
- } else {
- if (left)
- *left = strdup(string);
- }
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
- return TRUE;
+ return 1;
}
/* Parses command line. At most `max_args' is taken. Rest of the line
arguments in the line. Note that the command name is counted as one
argument and is saved. */
-void silc_parse_command_line(unsigned char *buffer,
+void silc_parse_command_line(unsigned char *buffer,
unsigned char ***parsed,
SilcUInt32 **parsed_lens,
SilcUInt32 **parsed_types,
{
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));
/* Get the command first */
len = strcspn(cp, " ");
- tmp = silc_to_upper((char *)cp);
+ tmp = silc_calloc(strlen(cp) + 1, sizeof(*tmp));
+ if (!tmp)
+ return;
+ silc_to_upper(cp, tmp, strlen(cp));
(*parsed)[0] = silc_calloc(len + 1, sizeof(char));
memcpy((*parsed)[0], tmp, len);
silc_free(tmp);
len--;
if (!len)
break;
-
+
*parsed = silc_realloc(*parsed, sizeof(**parsed) * (argc + 1));
- *parsed_lens = silc_realloc(*parsed_lens,
+ *parsed_lens = silc_realloc(*parsed_lens,
sizeof(**parsed_lens) * (argc + 1));
(*parsed)[argc] = silc_calloc(len + 1, sizeof(char));
memcpy((*parsed)[argc], cp, len);
char *silc_format(char *fmt, ...)
{
va_list args;
- static char buf[8192];
+ char buf[8192];
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);
+ return silc_strdup(buf);
}
-/* Renders ID to suitable to print for example to log file. */
-
-static char rid[256];
-#define _PUT_STRING(d, s) \
-do { \
- int sp = (sizeof(d) - 1) - strlen(d); \
- if (sp < strlen(s)) { \
- if (sp) \
- strncat(d, s, (sizeof(d) - 1) - strlen(d)); \
- } else { \
- strncat(d, s, strlen(s)); \
- } \
-} while(0)
-
-char *silc_id_render(void *id, SilcUInt16 type)
-{
- char tmp[100];
- unsigned char tmps[2];
- char *cp;
-
- memset(rid, 0, sizeof(rid));
- switch(type) {
- case SILC_ID_SERVER:
- {
- SilcServerID *server_id = (SilcServerID *)id;
- if (server_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, server_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, server_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(server_id->port));
- _PUT_STRING(rid, tmp);
- SILC_PUT16_MSB(server_id->rnd, tmps);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
- _PUT_STRING(rid, tmp);
- }
- break;
- case SILC_ID_CLIENT:
- {
- SilcClientID *client_id = (SilcClientID *)id;
- if (client_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, client_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, client_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%02x,", client_id->rnd);
- _PUT_STRING(rid, tmp);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x %02x %02x...]",
- client_id->hash[0], client_id->hash[1],
- client_id->hash[2], client_id->hash[3]);
- _PUT_STRING(rid, tmp);
- }
- break;
- case SILC_ID_CHANNEL:
- {
- SilcChannelID *channel_id = (SilcChannelID *)id;
- if (channel_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct sockaddr_in6 ipv6;
- memset(&ipv6, 0, sizeof(ipv6));
- ipv6.sin6_family = AF_INET6;
- memmove(&ipv6.sin6_addr, channel_id->ip.data, sizeof(ipv6.sin6_addr));
- if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
- tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
- _PUT_STRING(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, channel_id->ip.data, 4);
- cp = inet_ntoa(ipv4);
- if (cp)
- _PUT_STRING(rid, cp);
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(channel_id->port));
- _PUT_STRING(rid, tmp);
- SILC_PUT16_MSB(channel_id->rnd, tmps);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
- _PUT_STRING(rid, tmp);
- }
- break;
- }
-
- return rid;
-}
-
-/* Compares two strings. Strings may include wildcards * and ?.
- Returns TRUE if strings match. */
+/* Basic has function to hash strings. May be used with the SilcHashTable.
+ Note that this lowers the characters of the string (with tolower()) so
+ this is used usually with nicknames, channel and server names to provide
+ case insensitive keys. */
-int silc_string_compare(char *string1, char *string2)
+SilcUInt32 silc_hash_string(void *key, void *user_context)
{
- int i;
- int slen1;
- int slen2;
- char *tmpstr1, *tmpstr2;
-
- if (!string1 || !string2)
- return FALSE;
-
- slen1 = strlen(string1);
- slen2 = strlen(string2);
-
- /* See if they are same already */
- if (!strncmp(string1, string2, strlen(string2)))
- return TRUE;
+ char *s = (char *)key;
+ SilcUInt32 h = 0, g;
- if (slen2 < slen1)
- if (!strchr(string1, '*'))
- return FALSE;
-
- /* Take copies of the original strings as we will change them */
- tmpstr1 = silc_calloc(slen1 + 1, sizeof(char));
- memcpy(tmpstr1, string1, slen1);
- tmpstr2 = silc_calloc(slen2 + 1, sizeof(char));
- memcpy(tmpstr2, string2, slen2);
-
- for (i = 0; i < slen1; i++) {
-
- /* * wildcard. Only one * wildcard is possible. */
- if (tmpstr1[i] == '*')
- if (!strncmp(tmpstr1, tmpstr2, i)) {
- memset(tmpstr2, 0, slen2);
- strncpy(tmpstr2, tmpstr1, i);
- break;
- }
-
- /* ? wildcard */
- if (tmpstr1[i] == '?') {
- if (!strncmp(tmpstr1, tmpstr2, i)) {
- if (!(slen1 < i + 1))
- if (tmpstr1[i + 1] != '?' &&
- tmpstr1[i + 1] != tmpstr2[i + 1])
- continue;
-
- if (!(slen1 < slen2))
- tmpstr2[i] = '?';
- }
+ while (*s != '\0') {
+ h = (h << 4) + tolower((int)*s);
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
}
+ s++;
}
-
- /* if using *, remove it */
- if (strchr(tmpstr1, '*'))
- *strchr(tmpstr1, '*') = 0;
-
- if (!strcmp(tmpstr1, tmpstr2)) {
- memset(tmpstr1, 0, slen1);
- memset(tmpstr2, 0, slen2);
- silc_free(tmpstr1);
- silc_free(tmpstr2);
- return TRUE;
- }
-
- memset(tmpstr1, 0, slen1);
- memset(tmpstr2, 0, slen2);
- silc_free(tmpstr1);
- silc_free(tmpstr2);
- return FALSE;
+
+ return h;
}
-/* Basic has function to hash strings. May be used with the SilcHashTable.
- Note that this lowers the characters of the string (with tolower()) so
- this is used usually with nicknames, channel and server names to provide
- case insensitive keys. */
+/* Hash UTF-8 string */
-SilcUInt32 silc_hash_string(void *key, void *user_context)
+SilcUInt32 silc_hash_utf8_string(void *key, void *user_context)
{
- char *s = (char *)key;
+ unsigned char *s = (unsigned char *)key;
SilcUInt32 h = 0, g;
-
+
while (*s != '\0') {
- h = (h << 4) + tolower(*s);
+ h = (h << 4) + *s;
if ((g = h & 0xf0000000)) {
h = h ^ (g >> 24);
h = h ^ g;
}
s++;
}
-
+
return h;
}
SilcUInt32 silc_hash_uint(void *key, void *user_context)
{
- return *(SilcUInt32 *)key;
+ return SILC_PTR_TO_32(key);
}
/* Basic hash funtion to hash pointers. May be used with the SilcHashTable. */
SilcUInt32 silc_hash_ptr(void *key, void *user_context)
{
- return (SilcUInt32)key;
+ return SILC_PTR_TO_32(key);
}
/* Hash a ID. The `user_context' is the ID type. */
SilcUInt32 silc_hash_id(void *key, void *user_context)
{
- SilcIdType id_type = (SilcIdType)(SilcUInt32)user_context;
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
SilcUInt32 h = 0;
int i;
case SILC_ID_CLIENT:
{
SilcClientID *id = (SilcClientID *)key;
- SilcUInt32 g;
-
- /* The client ID is hashed by hashing the hash of the ID
+
+ /* The client ID is hashed by hashing the hash of the ID
(which is a truncated MD5 hash of the nickname) so that we
can access the entry from the cache with both Client ID but
with just a hash from the ID as well. */
-
- for (i = 0; i < sizeof(id->hash); i++) {
- h = (h << 4) + id->hash[i];
- if ((g = h & 0xf0000000)) {
- h = h ^ (g >> 24);
- h = h ^ g;
- }
- }
-
- return h;
+ return silc_hash_client_id_hash(id->hash, NULL);
}
break;
case SILC_ID_SERVER:
{
SilcServerID *id = (SilcServerID *)key;
-
+
h = id->port * id->rnd;
for (i = 0; i < id->ip.data_len; i++)
h ^= id->ip.data[i];
-
+
return h;
}
break;
case SILC_ID_CHANNEL:
{
SilcChannelID *id = (SilcChannelID *)key;
-
+
h = id->port * id->rnd;
for (i = 0; i < id->ip.data_len; i++)
h ^= id->ip.data[i];
-
+
return h;
}
break;
return h;
}
+/* Hash Client ID's hash. */
+
+SilcUInt32 silc_hash_client_id_hash(void *key, void *user_context)
+{
+ int i;
+ unsigned char *hash = key;
+ SilcUInt32 h = 0, g;
+
+ for (i = 0; i < CLIENTID_HASH_LEN; i++) {
+ h = (h << 4) + hash[i];
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ }
+
+ return h;
+}
+
/* Hash binary data. The `user_context' is the data length. */
SilcUInt32 silc_hash_data(void *key, void *user_context)
{
- SilcUInt32 len = (SilcUInt32)user_context, h = 0;
+ SilcUInt32 len = SILC_PTR_TO_32(user_context), h = 0;
unsigned char *data = (unsigned char *)key;
int i;
return h;
}
-/* Hashed SILC Public key. */
-
-SilcUInt32 silc_hash_public_key(void *key, void *user_context)
-{
- SilcPublicKey pk = (SilcPublicKey)key;
- return (pk->len + silc_hash_string(pk->name, NULL) +
- silc_hash_string(pk->identifier, NULL) +
- silc_hash_data(pk->pk, (void *)pk->pk_len));
-}
-
-/* Compares two strings. May be used as SilcHashTable comparison function. */
+/* Compares two strings. It may be used as SilcHashTable comparison
+ function. */
-bool silc_hash_string_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_string_compare(void *key1, void *key2, void *user_context)
{
return !strcasecmp((char *)key1, (char *)key2);
}
-/* Compares two ID's. May be used as SilcHashTable comparison function.
+/* Compares two ID's. May be used as SilcHashTable comparison function.
The Client ID's compares only the hash of the Client ID not any other
part of the Client ID. Other ID's are fully compared. */
-bool silc_hash_id_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_id_compare(void *key1, void *key2, void *user_context)
{
- SilcIdType id_type = (SilcIdType)(SilcUInt32)user_context;
- return (id_type == SILC_ID_CLIENT ?
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ return (id_type == SILC_ID_CLIENT ?
SILC_ID_COMPARE_HASH((SilcClientID *)key1, (SilcClientID *)key2) :
SILC_ID_COMPARE_TYPE(key1, key2, id_type));
}
+/* Compares two ID's. Compares full IDs. */
+
+SilcBool silc_hash_id_compare_full(void *key1, void *key2, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ return SILC_ID_COMPARE_TYPE(key1, key2, id_type);
+}
+
/* Compare two Client ID's entirely and not just the hash from the ID. */
-bool silc_hash_client_id_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_client_id_compare(void *key1, void *key2,
+ void *user_context)
{
return SILC_ID_COMPARE_TYPE(key1, key2, SILC_ID_CLIENT);
}
/* Compares binary data. May be used as SilcHashTable comparison function. */
-bool silc_hash_data_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_data_compare(void *key1, void *key2, void *user_context)
{
- SilcUInt32 len = (SilcUInt32)user_context;
+ SilcUInt32 len = SILC_PTR_TO_32(user_context);
return !memcmp(key1, key2, len);
}
-/* Compares two SILC Public keys. May be used as SilcHashTable comparison
- function. */
+/* Compares UTF-8 string. */
-bool silc_hash_public_key_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_utf8_compare(void *key1, void *key2, void *user_context)
{
- return silc_pkcs_public_key_compare(key1, key2);
+ int l1 = strlen((char *)key1);
+ int l2 = strlen((char *)key2);
+ if (l1 != l2)
+ return FALSE;
+ return !memcmp(key1, key2, l2);
}
-/* Parses mode mask and returns the mode as string. */
+/* Creates fingerprint from data, usually used with SHA1 digests */
-char *silc_client_chmode(SilcUInt32 mode, const char *cipher, const char *hmac)
+char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
{
- char string[100];
-
- if (!mode)
- return NULL;
-
- memset(string, 0, sizeof(string));
-
- if (mode & SILC_CHANNEL_MODE_PRIVATE)
- strncat(string, "p", 1);
-
- if (mode & SILC_CHANNEL_MODE_SECRET)
- strncat(string, "s", 1);
-
- if (mode & SILC_CHANNEL_MODE_PRIVKEY)
- strncat(string, "k", 1);
-
- if (mode & SILC_CHANNEL_MODE_INVITE)
- strncat(string, "i", 1);
+ char fingerprint[64], *cp;
+ int i;
- if (mode & SILC_CHANNEL_MODE_TOPIC)
- strncat(string, "t", 1);
+ memset(fingerprint, 0, sizeof(fingerprint));
+ cp = fingerprint;
+ for (i = 0; i < data_len; i++) {
+ silc_snprintf(cp, sizeof(fingerprint), "%02X", data[i]);
+ cp += 2;
- if (mode & SILC_CHANNEL_MODE_ULIMIT)
- strncat(string, "l", 1);
+ if ((i + 1) % 2 == 0)
+ silc_snprintf(cp++, sizeof(fingerprint), " ");
- if (mode & SILC_CHANNEL_MODE_PASSPHRASE)
- strncat(string, "a", 1);
+ if ((i + 1) % 10 == 0)
+ silc_snprintf(cp++, sizeof(fingerprint), " ");
+ }
+ i--;
+ if ((i + 1) % 2 == 0)
+ cp[-2] = 0;
+ if ((i + 1) % 10 == 0)
+ cp[-1] = 0;
- if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)
- strncat(string, "f", 1);
+ return silc_strdup(fingerprint);
+}
- if (mode & SILC_CHANNEL_MODE_CIPHER)
- strncat(string, cipher, strlen(cipher));
+/* Return TRUE if the `data' is ASCII string. */
- if (mode & SILC_CHANNEL_MODE_HMAC)
- strncat(string, hmac, strlen(hmac));
+SilcBool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
+{
+ int i;
- /* Rest of mode is ignored */
+ for (i = 0; i < data_len; i++) {
+ if (!isascii(data[i]))
+ return FALSE;
+ }
- return strdup(string);
+ return TRUE;
}
-/* Parses channel user mode mask and returns te mode as string */
+/* Displays input prompt on command line and takes input data from user */
-char *silc_client_chumode(SilcUInt32 mode)
+char *silc_get_input(const char *prompt, SilcBool echo_off)
{
- char string[4];
+#ifdef SILC_UNIX
+ int fd;
+ char input[2048];
+
+ if (echo_off) {
+ char *ret = NULL;
+#ifdef HAVE_TERMIOS_H
+ struct termios to;
+ struct termios to_old;
+
+ fd = open("/dev/tty", O_RDONLY);
+ if (fd < 0) {
+ silc_set_errno_posix(errno);
+ return NULL;
+ }
- if (!mode)
- return NULL;
+ signal(SIGINT, SIG_IGN);
- memset(string, 0, sizeof(string));
+ /* Get terminal info */
+ tcgetattr(fd, &to);
+ to_old = to;
- if (mode & SILC_CHANNEL_UMODE_CHANFO)
- strncat(string, "f", 1);
+ /* Echo OFF, and assure we can prompt and get input */
+ to.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
+ to.c_lflag |= ICANON;
+ to.c_cc[VMIN] = 255;
+ tcsetattr(fd, TCSANOW, &to);
- if (mode & SILC_CHANNEL_UMODE_CHANOP)
- strncat(string, "o", 1);
+ memset(input, 0, sizeof(input));
- return strdup(string);
-}
+ printf("%s", prompt);
+ fflush(stdout);
-/* Parses channel user mode and returns it as special mode character. */
+ if ((read(fd, input, sizeof(input))) < 0) {
+ silc_set_errno_posix(errno);
+ tcsetattr(fd, TCSANOW, &to_old);
+ return NULL;
+ }
-char *silc_client_chumode_char(SilcUInt32 mode)
-{
- char string[4];
+ if (strlen(input) <= 1) {
+ tcsetattr(fd, TCSANOW, &to_old);
+ silc_set_errno(SILC_ERR_EOF);
+ return NULL;
+ }
- if (!mode)
- return NULL;
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
- memset(string, 0, sizeof(string));
+ /* Restore old terminfo */
+ tcsetattr(fd, TCSANOW, &to_old);
+ signal(SIGINT, SIG_DFL);
- if (mode & SILC_CHANNEL_UMODE_CHANFO)
- strncat(string, "*", 1);
+ ret = silc_memdup(input, strlen(input));
+ memset(input, 0, sizeof(input));
+#endif /* HAVE_TERMIOS_H */
+ return ret;
+ } else {
+ fd = open("/dev/tty", O_RDONLY);
+ if (fd < 0) {
+ silc_set_errno_posix(errno);
+ return NULL;
+ }
- if (mode & SILC_CHANNEL_UMODE_CHANOP)
- strncat(string, "@", 1);
+ memset(input, 0, sizeof(input));
- return strdup(string);
-}
+ printf("%s", prompt);
+ fflush(stdout);
-/* Creates fingerprint from data, usually used with SHA1 digests */
+ if ((read(fd, input, sizeof(input))) < 0) {
+ silc_set_errno_posix(errno);
+ return NULL;
+ }
-char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
-{
- char fingerprint[64], *cp;
- int i;
+ if (strlen(input) <= 1) {
+ silc_set_errno(SILC_ERR_EOF);
+ return NULL;
+ }
- memset(fingerprint, 0, sizeof(fingerprint));
- cp = fingerprint;
- for (i = 0; i < data_len; i++) {
- snprintf(cp, sizeof(fingerprint), "%02X", data[i]);
- cp += 2;
-
- if ((i + 1) % 2 == 0)
- snprintf(cp++, sizeof(fingerprint), " ");
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
- if ((i + 1) % 10 == 0)
- snprintf(cp++, sizeof(fingerprint), " ");
+ return silc_strdup(input);
}
- i--;
- if ((i + 1) % 2 == 0)
- cp[-2] = 0;
- if ((i + 1) % 10 == 0)
- cp[-1] = 0;
-
- return strdup(fingerprint);
+#else
+ return NULL;
+#endif /* SILC_UNIX */
}
-/* Return TRUE if the `data' is ASCII string. */
+/* Hexdump */
-bool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
+void silc_hexdump(const unsigned char *data, SilcUInt32 data_len,
+ FILE *output)
{
- int i;
+ 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;
- for (i = 0; i < data_len; i++) {
- if (!isascii(data[i]))
- return FALSE;
- }
+ if (count)
+ fprintf(output, "%08X ", k++ * 16);
- return TRUE;
-}
+ for (i = 0; i < count; i++) {
+ fprintf(output, "%02X ", data[pos + i]);
-/* Parses SILC protocol style version string. */
+ if ((i + 1) % 4 == 0)
+ fprintf(output, " ");
+ }
-bool silc_parse_version_string(const char *version,
- SilcUInt32 *protocol_version,
- char **protocol_version_string,
- SilcUInt32 *software_version,
- char **software_version_string,
- char **vendor_version)
-{
- char *cp, buf[32];
- int maj = 0, min = 0;
+ if (count && count < 16) {
+ int j;
- if (!strstr(version, "SILC-"))
- return FALSE;
+ for (j = 0; j < 16 - count; j++) {
+ fprintf(output, " ");
- cp = (char *)version + 5;
- if (!cp)
- return FALSE;
+ if ((j + count + 1) % 4 == 0)
+ fprintf(output, " ");
+ }
+ }
- /* Take protocol version */
+ for (i = 0; i < count; i++) {
+ char ch;
- maj = atoi(cp);
- cp = strchr(cp, '.');
- if (cp) {
- min = atoi(cp + 1);
- cp++;
+ 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;
}
+}
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
- if (protocol_version)
- *protocol_version = atoi(buf);
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
- if (protocol_version_string)
- *protocol_version_string = strdup(buf);
+/* Convert hex string to data. Each hex number must have two characters. */
- /* Take software version */
+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;
- maj = 0;
- min = 0;
- cp = strchr(cp, '-');
- if (!cp)
+ if (data_size < strlen(hex) / 2) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
return FALSE;
+ }
- maj = atoi(cp + 1);
- cp = strchr(cp, '.');
- if (cp)
- min = atoi(cp + 1);
-
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
- if (software_version)
- *software_version = atoi(buf);
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
- if (software_version_string)
- *software_version_string = strdup(buf);
+ for (i = 0; i < strlen(hex) / 2; i++) {
+ h = *cp++;
+ l = *cp++;
- /* Take vendor string */
+ h -= h < 'A' ? '0' : 'A' - 10;
+ l -= l < 'A' ? '0' : 'A' - 10;
- cp++;
- if (cp) {
- cp = strchr(cp, '.');
- if (cp && cp + 1 && vendor_version)
- *vendor_version = strdup(cp + 1);
+ 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 version string x.x into number representation. */
+/* Converts binary data to HEX string */
-SilcUInt32 silc_version_to_num(const char *version)
+SilcBool silc_data2hex(const unsigned char *data, SilcUInt32 data_len,
+ char *hex, SilcUInt32 hex_size)
{
- int maj = 0, min = 0;
- char *cp, buf[32];
+ unsigned char l, h;
+ char *cp = hex;
+ int i;
- if (!version)
- return 0;
+ if (hex_size - 1 < data_len * 2) {
+ silc_set_errno(SILC_ERR_OVERFLOW);
+ return FALSE;
+ }
- cp = (char *)version;
- maj = atoi(cp);
- cp = strchr(cp, '.');
- if (cp)
- min = atoi(cp + 1);
+ memset(hex, 0, hex_size);
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
- return (SilcUInt32)atoi(buf);
+ 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;
}
projects / silc.git / blobdiff