/*
- 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)
return -1;
-
+
dest[i] = src[start];
-
- if (dest[i] == EOF)
+
+ if (dest[i] == EOF)
return EOF;
-
- if (dest[i] == '\n')
+
+ if (dest[i] == '\n')
break;
}
start++;
-
+
return start;
}
were found. This is used to check for bad lines when reading data from
for example a configuration file. */
-int silc_check_line(char *buf)
+int silc_check_line(char *buf)
{
/* Illegal characters in line */
if (strchr(buf, '#')) 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. */
-
-char *silc_get_time()
-{
- time_t curtime;
- char *return_time;
- curtime = time(NULL);
- return_time = ctime(&curtime);
- return_time[strlen(return_time) - 1] = '\0';
-
- return return_time;
+ return 0;
}
-/* Converts string to capital characters */
+/* Converts string to capital characters. */
-char *silc_to_upper(char *string)
+SilcBool silc_to_upper(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)
+ 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)toupper((int)string[i]);
- return pem;
+ return TRUE;
}
-/* Same as above but puts newline ('\n') every 72 characters. */
+/* Converts string to lower letter characters. */
-char *silc_encode_pem_file(unsigned char *data, SilcUInt32 data_len)
+SilcBool silc_to_lower(const char *string, char *dest, SilcUInt32 dest_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));
+ int i;
- for (i = 0, j = 0, cols = 1; i < len; i++, cols++) {
- if (cols == 72) {
- pem2[i] = '\n';
- cols = 0;
- len++;
- continue;
- }
+ if (strlen(string) > dest_size)
+ return FALSE;
- pem2[i] = pem[j++];
- }
+ for (i = 0; i < strlen(string); i++)
+ dest[i] = (char)tolower((int)string[i]);
- silc_free(pem);
- return pem2;
+ return TRUE;
}
-/* Decodes PEM into data. Returns the decoded data. Note: This is
- originally public domain code and is still PD. */
+/* Parse userfqdn string which is in user@fqdn format. */
-unsigned char *silc_decode_pem(unsigned char *pem, SilcUInt32 pem_len,
- SilcUInt32 *ret_len)
+int silc_parse_userfqdn(const char *string,
+ char *user, SilcUInt32 user_size,
+ char *fqdn, SilcUInt32 fqdn_size)
{
- 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;
- }
-
- 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));
+ SilcUInt32 tlen;
- for (i = 0; i < len; i++) {
- c = pem[i];
+ if (!user && !fqdn)
+ return 0;
- if (c == '=')
- break;
+ memset(user, 0, user_size);
+ memset(fqdn, 0, fqdn_size);
- if (c > 127 || !ialpha[c])
- continue;
-
- bits += decoder[c];
- char_count++;
+ if (!string)
+ return 0;
- 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;
-}
+ if (strchr(string, '@')) {
+ tlen = strcspn(string, "@");
-/* Parse userfqdn string which is in user@fqdn format */
+ if (user)
+ silc_strncat(user, user_size, string, tlen);
-bool silc_parse_userfqdn(const char *string, char **left, char **right)
-{
- SilcUInt32 tlen;
+ if (fqdn)
+ silc_strncat(fqdn, fqdn_size, string + tlen + 1,
+ strlen(string) - tlen - 1);
- if (!string)
- return FALSE;
-
- 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,
/* 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);
+ vsilc_snprintf(buf, sizeof(buf) - 1, fmt, args);
va_end(args);
return strdup(buf);
}
-/* Renders ID to suitable to print for example to log file. */
-
-static char rid[256];
+/* 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. */
-char *silc_id_render(void *id, SilcUInt16 type)
+SilcUInt32 silc_hash_string(void *key, void *user_context)
{
- char tmp[100];
- unsigned char tmps[2];
+ char *s = (char *)key;
+ SilcUInt32 h = 0, g;
- 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 in6_addr ipv6;
- memmove(&ipv6, server_id->ip.data, sizeof(ipv6));
- if (!inet_ntop(AF_INET6, &ipv6, tmp, sizeof(tmp)))
- strcat(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, server_id->ip.data, 4);
- strcat(rid, inet_ntoa(ipv4));
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%d,", ntohs(server_id->port));
- strcat(rid, tmp);
- SILC_PUT16_MSB(server_id->rnd, tmps);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), "[%02x %02x]", tmps[0], tmps[1]);
- strcat(rid, tmp);
- }
- break;
- case SILC_ID_CLIENT:
- {
- SilcClientID *client_id = (SilcClientID *)id;
- if (client_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct in6_addr ipv6;
- memmove(&ipv6, client_id->ip.data, sizeof(ipv6));
- if (!inet_ntop(AF_INET6, &ipv6, tmp, sizeof(tmp)))
- strcat(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, client_id->ip.data, 4);
- strcat(rid, inet_ntoa(ipv4));
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%02x,", client_id->rnd);
- strcat(rid, tmp);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), "[%02x %02x %02x %02x...]",
- client_id->hash[0], client_id->hash[1],
- client_id->hash[2], client_id->hash[3]);
- strcat(rid, tmp);
- }
- break;
- case SILC_ID_CHANNEL:
- {
- SilcChannelID *channel_id = (SilcChannelID *)id;
- if (channel_id->ip.data_len > 4) {
-#ifdef HAVE_IPV6
- struct in6_addr ipv6;
- memmove(&ipv6, channel_id->ip.data, sizeof(ipv6));
- if (!inet_ntop(AF_INET6, &ipv6, tmp, sizeof(tmp)))
- strcat(rid, tmp);
-#endif
- } else {
- struct in_addr ipv4;
- memmove(&ipv4.s_addr, channel_id->ip.data, 4);
- strcat(rid, inet_ntoa(ipv4));
- }
-
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%d,", ntohs(channel_id->port));
- strcat(rid, tmp);
- SILC_PUT16_MSB(channel_id->rnd, tmps);
- memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), "[%02x %02x]", tmps[0], tmps[1]);
- strcat(rid, tmp);
+ while (*s != '\0') {
+ h = (h << 4) + tolower((int)*s);
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
}
- break;
+ s++;
}
- return rid;
-}
-
-/* Compares two strings. Strings may include wildcards * and ?.
- Returns TRUE if strings match. */
-
-int silc_string_compare(char *string1, char *string2)
-{
- 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;
-
- 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] = '?';
- }
- }
- }
-
- /* 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. */
+/* Hash public key of any type. */
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));
+ 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. 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. */
+/* Compares two SILC Public keys. It may be used as SilcHashTable
+ comparison function. */
-char *silc_client_chmode(SilcUInt32 mode, const char *cipher, const char *hmac)
+SilcBool silc_hash_public_key_compare(void *key1, void *key2,
+ void *user_context)
{
- 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);
+ return silc_pkcs_public_key_compare(key1, key2);
+}
- if (mode & SILC_CHANNEL_MODE_PRIVKEY)
- strncat(string, "k", 1);
+/* Creates fingerprint from data, usually used with SHA1 digests */
- if (mode & SILC_CHANNEL_MODE_INVITE)
- strncat(string, "i", 1);
+char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
+{
+ 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_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_silc_snprintf(cp++, sizeof(fingerprint), " ");
- if (mode & SILC_CHANNEL_MODE_PASSPHRASE)
- strncat(string, "a", 1);
+ if ((i + 1) % 10 == 0)
+ silc_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 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) {
+ fprintf(stderr, "silc: %s\n", strerror(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) {
+ fprintf(stderr, "silc: %s\n", strerror(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);
+ 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) {
+ fprintf(stderr, "silc: %s\n", strerror(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) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ return NULL;
+ }
-char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
-{
- char fingerprint[64], *cp;
- int i;
+ if (strlen(input) <= 1)
+ 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 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 */
}
projects / silc.git / blobdiff