Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2003 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
argument begin is returned and should be passed again for the function. */
-int silc_gets(char *dest, int destlen, const char *src, int srclen,
- int *begin)
+int silc_gets(char *dest, int destlen, const char *src, int srclen, int begin)
{
- int off = *begin;
+ static int start = 0;
int i;
memset(dest, 0, destlen);
+ if (begin != start)
+ start = 0;
+
i = 0;
- for ( ; off <= srclen; i++) {
+ for ( ; start <= srclen; i++, start++) {
if (i > destlen)
return -1;
- dest[i] = src[off++];
+ dest[i] = src[start];
if (dest[i] == EOF)
return EOF;
if (dest[i] == '\n')
break;
}
- *begin = off;
- if (off + 1 >= srclen)
- return EOF;
+ start++;
- return off;
+ return start;
}
/* Checks line for illegal characters. Return -1 when illegal character
return 0;
}
-/* Returns time as string. If the the `timeval' is non-zero that
- value is returned as string. If it is zero the current time of the
- local machine is returned. */
-
-const char *silc_get_time(SilcUInt32 timeval)
-{
- time_t curtime;
- char *return_time;
-
- if (!timeval)
- curtime = time(NULL);
- else
- curtime = (time_t)timeval;
- return_time = ctime(&curtime);
- return_time[strlen(return_time) - 1] = '\0';
-
- return (const char *)return_time;
-}
-
/* Converts string to capital characters. */
-bool silc_to_upper(const char *string, char *dest, SilcUInt32 dest_size)
+SilcBool silc_to_upper(const char *string, char *dest, SilcUInt32 dest_size)
{
int i;
return FALSE;
for (i = 0; i < strlen(string); i++)
- dest[i] = toupper(string[i]);
+ dest[i] = (char)toupper((int)string[i]);
return TRUE;
}
/* Converts string to lower letter characters. */
-bool silc_to_lower(const char *string, char *dest, SilcUInt32 dest_size)
+SilcBool silc_to_lower(const char *string, char *dest, SilcUInt32 dest_size)
{
int i;
return FALSE;
for (i = 0; i < strlen(string); i++)
- dest[i] = tolower(string[i]);
+ dest[i] = (char)tolower((int)string[i]);
return TRUE;
}
/* Parse userfqdn string which is in user@fqdn format. */
-bool silc_parse_userfqdn(const char *string, char **left, char **right)
+int silc_parse_userfqdn(const char *string,
+ char *user, SilcUInt32 user_size,
+ char *fqdn, SilcUInt32 fqdn_size)
{
SilcUInt32 tlen;
+ if (!user && !fqdn)
+ return 0;
+
+ memset(user, 0, user_size);
+ memset(fqdn, 0, fqdn_size);
+
if (!string)
- return FALSE;
+ return 0;
if (string[0] == '@') {
- if (left)
- *left = strdup(string);
- return TRUE;
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
+
+ return 1;
}
if (strchr(string, '@')) {
tlen = strcspn(string, "@");
- if (left) {
- *left = silc_calloc(tlen + 1, sizeof(char));
- memcpy(*left, string, tlen);
- }
+ if (user)
+ silc_strncat(user, user_size, 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 (fqdn)
+ silc_strncat(fqdn, fqdn_size, string + tlen + 1,
+ strlen(string) - tlen - 1);
+
+ return 2;
}
- return TRUE;
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
+
+ return 1;
}
/* Parses command line. At most `max_args' is taken. Rest of the line
{
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));
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);
}
-/* 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;
-}
-#undef _PUT_STRING
-
-/* 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, slen2) && slen2 == slen1)
- 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;
+ char *s = (char *)key;
+ SilcUInt32 h = 0, g;
- 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;
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;
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. 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);
}
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;
+ 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));
}
-/* 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)
-{
- 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)
-{
- SilcUInt32 len = (SilcUInt32)user_context;
- return !memcmp(key1, key2, len);
-}
-
-/* Compares two SILC Public keys. It may be used as SilcHashTable
- comparison function. */
+/* Compares two ID's. Compares full IDs. */
-bool silc_hash_public_key_compare(void *key1, void *key2, void *user_context)
+SilcBool silc_hash_id_compare_full(void *key1, void *key2, void *user_context)
{
- return silc_pkcs_public_key_compare(key1, key2);
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ return SILC_ID_COMPARE_TYPE(key1, key2, id_type);
}
-/* Parses mode mask and returns the mode as string. */
+/* Compare two Client ID's entirely and not just the hash from the ID. */
-char *silc_client_chmode(SilcUInt32 mode, const char *cipher, const char *hmac)
+SilcBool silc_hash_client_id_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);
-
- if (mode & SILC_CHANNEL_MODE_PRIVKEY)
- strncat(string, "k", 1);
-
- if (mode & SILC_CHANNEL_MODE_INVITE)
- strncat(string, "i", 1);
-
- if (mode & SILC_CHANNEL_MODE_TOPIC)
- strncat(string, "t", 1);
-
- if (mode & SILC_CHANNEL_MODE_ULIMIT)
- strncat(string, "l", 1);
-
- if (mode & SILC_CHANNEL_MODE_PASSPHRASE)
- strncat(string, "a", 1);
-
- if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)
- strncat(string, "f", 1);
-
- if (mode & SILC_CHANNEL_MODE_SILENCE_USERS)
- strncat(string, "m", 1);
-
- if (mode & SILC_CHANNEL_MODE_SILENCE_OPERS)
- strncat(string, "M", 1);
-
- if (mode & SILC_CHANNEL_MODE_CIPHER)
- strncat(string, "c", 1);
-
- if (mode & SILC_CHANNEL_MODE_HMAC)
- strncat(string, "h", 1);
-
- if (mode & SILC_CHANNEL_MODE_CIPHER) {
- if (strlen(cipher) + strlen(string) + 1< sizeof(string)) {
- strncat(string, " ", 1);
- strncat(string, cipher, strlen(cipher));
- }
- }
-
- if (mode & SILC_CHANNEL_MODE_HMAC) {
- if (strlen(hmac) + strlen(string) + 1< sizeof(string)) {
- strncat(string, " ", 1);
- strncat(string, hmac, strlen(hmac));
- }
- }
-
- /* Rest of mode is ignored */
-
- return strdup(string);
+ return SILC_ID_COMPARE_TYPE(key1, key2, SILC_ID_CLIENT);
}
-/* Parses channel user mode mask and returns te mode as string */
+/* Compares binary data. May be used as SilcHashTable comparison function. */
-char *silc_client_chumode(SilcUInt32 mode)
+SilcBool silc_hash_data_compare(void *key1, void *key2, void *user_context)
{
- char string[64];
-
- if (!mode)
- return NULL;
-
- memset(string, 0, sizeof(string));
-
- if (mode & SILC_CHANNEL_UMODE_CHANFO)
- strncat(string, "f", 1);
-
- if (mode & SILC_CHANNEL_UMODE_CHANOP)
- strncat(string, "o", 1);
-
- if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
- strncat(string, "b", 1);
-
- if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS)
- strncat(string, "u", 1);
-
- if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS)
- strncat(string, "r", 1);
-
- if (mode & SILC_CHANNEL_UMODE_QUIET)
- strncat(string, "q", 1);
-
- return strdup(string);
+ SilcUInt32 len = SILC_PTR_TO_32(user_context);
+ return !memcmp(key1, key2, len);
}
-/* Parses channel user mode and returns it as special mode character. */
+/* Compares UTF-8 string. */
-char *silc_client_chumode_char(SilcUInt32 mode)
+SilcBool silc_hash_utf8_compare(void *key1, void *key2, void *user_context)
{
- char string[64];
-
- if (!mode)
- return NULL;
-
- memset(string, 0, sizeof(string));
-
- if (mode & SILC_CHANNEL_UMODE_CHANFO)
- strncat(string, "*", 1);
-
- if (mode & SILC_CHANNEL_UMODE_CHANOP)
- strncat(string, "@", 1);
-
- if (mode & SILC_CHANNEL_UMODE_QUIET)
- strncat(string, "&", 1);
-
- return strdup(string);
+ int l1 = strlen((char *)key1);
+ int l2 = strlen((char *)key2);
+ if (l1 != l2)
+ return FALSE;
+ return !memcmp(key1, key2, l2);
}
/* Creates fingerprint from data, usually used with SHA1 digests */
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 TRUE if the `data' is ASCII string. */
-bool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
+SilcBool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
{
int i;
return TRUE;
}
-/* Parses SILC protocol style version string. */
-
-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 (!strstr(version, "SILC-"))
- return FALSE;
-
- cp = (char *)version + 5;
- if (!cp)
- return FALSE;
-
- /* Take protocol version */
-
- maj = atoi(cp);
- if (!strchr(cp, '.'))
- return FALSE;
- cp = strchr(cp, '.') + 1;
- if (!cp || !(*cp))
- return FALSE;
- min = atoi(cp);
-
- 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);
-
- /* Take software version */
-
- maj = 0;
- min = 0;
- if (!strchr(cp, '-'))
- return FALSE;
- cp = strchr(cp, '-') + 1;
- if (!cp || !(*cp))
- return FALSE;
-
- maj = atoi(cp);
- if (strchr(cp, '.')) {
- cp = strchr(cp, '.') + 1;
- if (cp && *cp)
- min = atoi(cp);
- }
-
- 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);
-
- /* Take vendor string */
-
- if (strchr(cp, '.')) {
- cp = strchr(cp, '.') + 1;
- if (cp && *cp && vendor_version)
- *vendor_version = strdup(cp);
- }
-
- return TRUE;
-}
-
-/* Converts version string x.x into number representation. */
-
-SilcUInt32 silc_version_to_num(const char *version)
-{
- int maj = 0, min = 0;
- char *cp, buf[32];
-
- if (!version)
- return 0;
-
- cp = (char *)version;
- maj = atoi(cp);
- cp = strchr(cp, '.');
- if (cp)
- min = atoi(cp + 1);
-
- memset(buf, 0, sizeof(buf));
- snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
- return (SilcUInt32)atoi(buf);
-}
-
/* Displays input prompt on command line and takes input data from user */
-char *silc_get_input(const char *prompt, bool echo_off)
+char *silc_get_input(const char *prompt, SilcBool echo_off)
{
#ifdef SILC_UNIX
int fd;
#endif /* SILC_UNIX */
}
-/* Return mode list */
+/* Hexdump */
-bool silc_get_mode_list(SilcBuffer mode_list, SilcUInt32 mode_list_count,
- SilcUInt32 **list)
+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;
- if (mode_list->len / 4 != mode_list_count)
- return FALSE;
+ 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;
- *list = silc_calloc(mode_list_count, sizeof(**list));
+ if (count)
+ fprintf(output, "%08X ", k++ * 16);
- for (i = 0; i < mode_list_count; i++) {
- SILC_GET32_MSB((*list)[i], mode_list->data);
- silc_buffer_pull(mode_list, 4);
- }
+ for (i = 0; i < count; i++) {
+ fprintf(output, "%02X ", data[pos + i]);
- silc_buffer_push(mode_list, mode_list->data - mode_list->head);
+ if ((i + 1) % 4 == 0)
+ fprintf(output, " ");
+ }
- return TRUE;
+ 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;
+ }
}
-/* Status message structure. Messages are defined below. */
-typedef struct {
- SilcStatus status;
- const char *message;
-} SilcStatusMessage;
-
-#define STAT(x) SILC_STATUS_ERR_##x
-static const SilcStatusMessage silc_status_messages[] = {
-
- { STAT(NO_SUCH_NICK), "There was no such nickname" },
- { STAT(NO_SUCH_CHANNEL), "There was no such channel" },
- { STAT(NO_SUCH_SERVER), "There was no such server" },
- { STAT(INCOMPLETE_INFORMATION), "Incomplete registration information" },
- { STAT(NO_RECIPIENT), "No recipient given" },
- { STAT(UNKNOWN_COMMAND), "Unknown command" },
- { STAT(WILDCARDS), "Wilcrads not allowed" },
- { STAT(NO_CLIENT_ID), "No Client ID given" },
- { STAT(NO_CHANNEL_ID), "No Channel ID given" },
- { STAT(NO_SERVER_ID), "No Server ID given" },
- { STAT(BAD_CLIENT_ID), "Bad Client ID" },
- { STAT(BAD_CHANNEL_ID), "Bad Channel ID" },
- { STAT(NO_SUCH_CLIENT_ID), "There is no such client" },
- { STAT(NO_SUCH_CHANNEL_ID),"There is no such channel" },
- { STAT(NICKNAME_IN_USE), "Nickname already exists" },
- { STAT(NOT_ON_CHANNEL), "You are not on that channel" },
- { STAT(USER_NOT_ON_CHANNEL),"They are not on the channel" },
- { STAT(USER_ON_CHANNEL), "User already on the channel" },
- { STAT(NOT_REGISTERED), "You have not registered" },
- { STAT(NOT_ENOUGH_PARAMS), "Not enough parameters" },
- { STAT(TOO_MANY_PARAMS), "Too many parameters" },
- { STAT(PERM_DENIED), "Permission denied" },
- { STAT(BANNED_FROM_SERVER),"You are not allowed to connect" },
- { STAT(BAD_PASSWORD), "Cannot join channel. Incorrect password" },
- { STAT(CHANNEL_IS_FULL), "Cannot join channel. Channel is full" },
- { STAT(NOT_INVITED), "Cannot join channel. You have not been invited" },
- { STAT(BANNED_FROM_CHANNEL), "Cannot join channel. You have been banned" },
- { STAT(UNKNOWN_MODE), "Unknown mode" },
- { STAT(NOT_YOU), "Cannot change mode for other users" },
- { STAT(NO_CHANNEL_PRIV), "Permission denied. You are not channel operator" },
- { STAT(NO_CHANNEL_FOPRIV),"Permission denied. You are not channel founder" },
- { STAT(NO_SERVER_PRIV), "Permission denied. You are not server operator" },
- { STAT(NO_ROUTER_PRIV), "Permission denied. You are not SILC operator" },
- { STAT(BAD_NICKNAME), "Bad nickname" },
- { STAT(BAD_CHANNEL), "Bad channel name" },
- { STAT(AUTH_FAILED), "Authentication failed" },
- { STAT(UNKNOWN_ALGORITHM), "Unsupported algorithm" },
- { STAT(NO_SUCH_SERVER_ID), "No such Server ID" },
- { STAT(RESOURCE_LIMIT), "No more free resources" },
- { STAT(NO_SUCH_SERVICE), "Service doesn't exist" },
- { STAT(NOT_AUTHENTICATED), "You have not been authenticated" },
- { STAT(BAD_SERVER_ID), "Server ID is not valid" },
- { STAT(KEY_EXCHANGE_FAILED), "Key exchange failed" },
- { STAT(BAD_VERSION), "Bad version" },
- { STAT(TIMEDOUT), "Service timed out" },
- { STAT(UNSUPPORTED_PUBLIC_KEY), "Unsupported public key type" },
- { STAT(OPERATION_ALLOWED), "Operation is not allowed" },
-
- { 0, NULL }
-};
-
-/* Returns status message string */
-
-const char *silc_get_status_message(unsigned char status)
+/* 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;
- for (i = 0; silc_status_messages[i].message; i++) {
- if (silc_status_messages[i].status == status)
- break;
+ 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 (silc_status_messages[i].message == NULL)
- return "";
+ if (ret_data_len)
+ *ret_data_len = i;
- return silc_status_messages[i].message;
-}
+ SILC_LOG_HEXDUMP(("len %d", i), data, i);
-static const char *packet_name[] = {
- "NONE",
- "DISCONNECT",
- "SUCCESS",
- "FAILURE",
- "REJECT",
- "NOTIFY",
- "ERROR",
- "CHANNEL MESSAGE",
- "CHANNEL KEY",
- "PRIVATE MESSAGE",
- "PRIVATE MESSAGE KEY",
- "COMMAND",
- "COMMAND REPLY",
- "KEY EXCHANGE",
- "KEY EXCHANGE 1",
- "KEY EXCHANGE 2",
- "CONNECTION AUTH REQUEST",
- "CONNECTION AUTH",
- "NEW ID",
- "NEW CLIENT",
- "NEW SERVER",
- "NEW CHANNEL",
- "REKEY",
- "REKEY_DONE",
- "HEARTBEAT",
- "KEY AGREEMENT",
- "RESUME ROUTER",
- "FTP",
- "RESUME CLIENT",
-};
-
-/* Returns packet type name */
-
-const char *silc_get_packet_name(unsigned char type)
-{
- if (type >= SILC_PACKET_MAX)
- return "RESERVED";
- if (type >= SILC_PACKET_PRIVATE)
- return "PRIVATE RANGE";
- if (type > (sizeof(packet_name) / sizeof(*packet_name)))
- return "UNKNOWN";
- return packet_name[type];
+ return TRUE;
}
-static const char *command_name[] = {
- "NONE",
- "WHOIS",
- "WHOWAS",
- "IDENTIFY",
- "NICK",
- "LIST",
- "TOPIC",
- "INVITE",
- "QUIT",
- "KILL",
- "INFO",
- "STATS",
- "PING",
- "OPER",
- "JOIN",
- "MOTD",
- "UMODE",
- "CMODE",
- "CUMODE",
- "KICK",
- "BAN",
- "DETACH",
- "WATCH",
- "SILCOPER",
- "LEAVE",
- "USERS",
- "GETKEY",
- "SERVICE",
-};
-
-/* Returns command name */
-
-const char *silc_get_command_name(unsigned char command)
+/* Converts binary data to HEX string */
+
+SilcBool silc_data2hex(const unsigned char *data, SilcUInt32 data_len,
+ char *hex, SilcUInt32 hex_size)
{
- if (command >= SILC_COMMAND_RESERVED)
- return "RESERVED";
- if (command >= SILC_COMMAND_PRIVATE)
- return "PRIVATE RANGE";
- if (command > (sizeof(command_name) / sizeof(*command_name)))
- return "UNKNOWN";
- return command_name[command];
-}
+ unsigned char l, h;
+ char *cp = hex;
+ int i;
-/* Return TRUE if `smaller' is smaller than `bigger'. */
+ if (hex_size - 1 < data_len * 2)
+ return FALSE;
-bool silc_compare_timeval(struct timeval *smaller,
- struct timeval *bigger)
-{
- if ((smaller->tv_sec < bigger->tv_sec) ||
- ((smaller->tv_sec == bigger->tv_sec) &&
- (smaller->tv_usec < bigger->tv_usec)))
- return TRUE;
+ memset(hex, 0, hex_size);
- return FALSE;
+ 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;
}