+
+/* 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. */
+
+SilcUInt32 silc_hash_string(void *key, void *user_context)
+{
+ char *s = (char *)key;
+ SilcUInt32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + tolower((int)*s);
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ s++;
+ }
+
+ return h;
+}
+
+/* Hash UTF-8 string */
+
+SilcUInt32 silc_hash_utf8_string(void *key, void *user_context)
+{
+ unsigned char *s = (unsigned char *)key;
+ SilcUInt32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + *s;
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ s++;
+ }
+
+ return h;
+}
+
+/* Basic hash function to hash integers. May be used with the SilcHashTable. */
+
+SilcUInt32 silc_hash_uint(void *key, void *user_context)
+{
+ 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 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)SILC_PTR_TO_32(user_context);
+ SilcUInt32 h = 0;
+ int i;
+
+ switch (id_type) {
+ case SILC_ID_CLIENT:
+ {
+ SilcClientID *id = (SilcClientID *)key;
+
+ /* 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. */
+ 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;
+ default:
+ 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 = SILC_PTR_TO_32(user_context), h = 0;
+ unsigned char *data = (unsigned char *)key;
+ int i;
+
+ h = (data[0] * data[len - 1] + 1) * len;
+ for (i = 0; i < len; i++)
+ h ^= data[i];
+
+ 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. */
+
+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.
+ 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. */
+
+SilcBool silc_hash_id_compare(void *key1, void *key2, void *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));
+}
+
+/* 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. */
+
+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. */
+
+SilcBool silc_hash_data_compare(void *key1, void *key2, void *user_context)
+{
+ SilcUInt32 len = SILC_PTR_TO_32(user_context);
+ return !memcmp(key1, key2, len);
+}
+
+/* Compares UTF-8 string. */
+
+SilcBool silc_hash_utf8_compare(void *key1, void *key2, void *user_context)
+{
+ int l1 = strlen((char *)key1);
+ int l2 = strlen((char *)key2);
+ if (l1 != l2)
+ return FALSE;
+ 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)
+{
+ char fingerprint[64], *cp;
+ int i;
+
+ 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 ((i + 1) % 2 == 0)
+ silc_silc_snprintf(cp++, sizeof(fingerprint), " ");
+
+ 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;
+
+ return strdup(fingerprint);
+}
+
+/* Return TRUE if the `data' is ASCII string. */
+
+SilcBool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
+{
+ int i;
+
+ for (i = 0; i < data_len; i++) {
+ if (!isascii(data[i]))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/* Displays input prompt on command line and takes input data from user */
+
+char *silc_get_input(const char *prompt, SilcBool echo_off)
+{
+#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;
+ }
+
+ signal(SIGINT, SIG_IGN);
+
+ /* Get terminal info */
+ tcgetattr(fd, &to);
+ to_old = to;
+
+ /* 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);
+
+ memset(input, 0, sizeof(input));
+
+ printf("%s", prompt);
+ fflush(stdout);
+
+ if ((read(fd, input, sizeof(input))) < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ tcsetattr(fd, TCSANOW, &to_old);
+ return NULL;
+ }
+
+ if (strlen(input) <= 1) {
+ tcsetattr(fd, TCSANOW, &to_old);
+ return NULL;
+ }
+
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
+
+ /* Restore old terminfo */
+ tcsetattr(fd, TCSANOW, &to_old);
+ signal(SIGINT, SIG_DFL);
+
+ 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;
+ }
+
+ memset(input, 0, sizeof(input));
+
+ printf("%s", prompt);
+ fflush(stdout);
+
+ if ((read(fd, input, sizeof(input))) < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ return NULL;
+ }
+
+ if (strlen(input) <= 1)
+ return NULL;
+
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
+
+ return strdup(input);
+ }
+#else
+ return NULL;
+#endif /* SILC_UNIX */
+}