contrib \
silccore \
silcutil \
+ silcapputil \
silccrypt \
#ifdef SILC_DIST_SKR
silcskr \
#ifdef SILC_DIST_HTTP
silchttp \
#endif SILC_DIST_HTTP
-#ifdef SILC_DIST_IDCACHE
- silcidcache \
-#endif SILC_DIST_IDCACHE
#ifdef SILC_DIST_IDCACHE
silcvcard \
#endif SILC_DIST_IDCACHE
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcmath"
#endif SILC_DIST_MATH
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcutil"
+SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcapputil"
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcske"
#ifdef SILC_DIST_SFTP
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcsftp"
#ifdef SILC_DIST_HTTP
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silchttp"
#endif SILC_DIST_HTTP
-#ifdef SILC_DIST_IDCACHE
-SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcidcache"
-#endif SILC_DIST_IDCACHE
#ifdef SILC_DIST_VCARD
SILC_LIB_INCLUDES="$SILC_LIB_INCLUDES -I$SILC_TOP_SRCDIR/lib/silcvcard"
#endif SILC_DIST_VCARD
lib/silcutil/beos/Makefile
lib/silcutil/os2/Makefile
lib/silcutil/epoc/Makefile
+lib/silcapputil/Makefile
#ifdef SILC_DIST_SFTP
lib/silcsftp/Makefile
#endif SILC_DIST_SFTP
)
#endif SILC_DIST_HTTP
-#ifdef SILC_DIST_IDCACHE
-AC_CONFIG_FILES(
-lib/silcidcache/Makefile
-)
-#endif SILC_DIST_IDCACHE
-
#ifdef SILC_DIST_VCARD
AC_CONFIG_FILES(
lib/silcvcard/Makefile
--- /dev/null
+<!--
+@LIBRARY=SILC Application Utility Library
+@FILENAME=silcaputillib.html
+@LINK=silcapputil.html:SILC Application Utilities
+@LINK=silcidcache.html:SILC ID Cache Interface
+-->
+
+<big><b>SILC Application Utility Library</b></big>
+<br />
+<small>Directory: lib/silcapputil/</small>
+<br />
+<small>Library: libsilc.a, libsilc.lib</small>
+<br /><br />
+<b>Introduction</b>
+
+<br /><br />
+SILC Application Utility library provides various SILC application
+specific utility functions. For example, it provides routines for
+creating and loading SILC key pair.
+
+<br /><br />
+@LINKS@
--- /dev/null
+#
+# Makefile.ad
+#
+# Author: Pekka Riikonen <priikone@silcnet.org>
+#
+# Copyright (C) 2006 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
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+
+AUTOMAKE_OPTIONS = 1.0 no-dependencies foreign
+
+noinst_LTLIBRARIES = libsilcapputil.la
+
+libsilcapputil_la_SOURCES = \
+ silcapputil.c \
+#ifdef SILC_DIST_IDCACHE
+ silcidcache.c
+#endif SILC_DIST_IDCACHE
+
+#ifdef SILC_DIST_TOOLKIT
+include_HEADERS = \
+ silcapputil.h \
+#ifdef SILC_DIST_IDCACHE
+ silcidcache.h
+#endif SILC_DIST_IDCACHE
+
+SILC_EXTRA_DIST = tests
+#endif SILC_DIST_TOOLKIT
+
+EXTRA_DIST = *.h $(SILC_EXTRA_DIST)
+
+include $(top_srcdir)/Makefile.defines.in
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2002 - 2005 Pekka Riikonen
+ Copyright (C) 2002 - 2006 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 TRUE;
}
+
+/* Checks that the 'identifier' string is valid identifier string
+ and does not contain any unassigned or prohibited character. This
+ function is used to check for valid nicknames, channel names,
+ server names, usernames, hostnames, service names, algorithm names,
+ other security property names, and SILC Public Key name. */
+
+unsigned char *silc_identifier_check(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length,
+ SilcUInt32 *out_len)
+{
+ unsigned char *utf8s;
+ SilcUInt32 utf8s_len;
+ SilcStringprepStatus status;
+
+ if (!identifier || !identifier_len)
+ return NULL;
+
+ if (max_allowed_length && identifier_len > max_allowed_length)
+ return NULL;
+
+ status = silc_stringprep(identifier, identifier_len,
+ identifier_encoding, SILC_IDENTIFIER_PREP, 0,
+ &utf8s, &utf8s_len, SILC_STRING_UTF8);
+ if (status != SILC_STRINGPREP_OK) {
+ SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
+ return NULL;
+ }
+
+ if (out_len)
+ *out_len = utf8s_len;
+
+ return utf8s;
+}
+
+/* Same as above but does not allocate memory, just checks the
+ validity of the string. */
+
+SilcBool silc_identifier_verify(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length)
+{
+ SilcStringprepStatus status;
+
+ if (!identifier || !identifier_len)
+ return FALSE;
+
+ if (max_allowed_length && identifier_len > max_allowed_length)
+ return FALSE;
+
+ status = silc_stringprep(identifier, identifier_len,
+ identifier_encoding, SILC_IDENTIFIER_PREP, 0,
+ NULL, NULL, SILC_STRING_UTF8);
+ if (status != SILC_STRINGPREP_OK) {
+ SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+unsigned char *silc_channel_name_check(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length,
+ SilcUInt32 *out_len)
+{
+ unsigned char *utf8s;
+ SilcUInt32 utf8s_len;
+ SilcStringprepStatus status;
+
+ if (!identifier || !identifier_len)
+ return NULL;
+
+ if (max_allowed_length && identifier_len > max_allowed_length)
+ return NULL;
+
+ status = silc_stringprep(identifier, identifier_len,
+ identifier_encoding, SILC_IDENTIFIER_CH_PREP, 0,
+ &utf8s, &utf8s_len, SILC_STRING_UTF8);
+ if (status != SILC_STRINGPREP_OK) {
+ SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
+ return NULL;
+ }
+
+ if (out_len)
+ *out_len = utf8s_len;
+
+ return utf8s;
+}
+
+/* Same as above but does not allocate memory, just checks the
+ validity of the string. */
+
+SilcBool silc_channel_name_verify(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length)
+{
+ SilcStringprepStatus status;
+
+ if (!identifier || !identifier_len)
+ return FALSE;
+
+ if (max_allowed_length && identifier_len > max_allowed_length)
+ return FALSE;
+
+ status = silc_stringprep(identifier, identifier_len,
+ identifier_encoding, SILC_IDENTIFIER_CH_PREP, 0,
+ NULL, NULL, SILC_STRING_UTF8);
+ if (status != SILC_STRINGPREP_OK) {
+ SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
+ return FALSE;
+ }
+
+ return TRUE;
+}
--- /dev/null
+/*
+
+ silcapputil.h
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 2002 - 2006 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
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+*/
+
+/****h* silcutil/SILC Application Utilities
+ *
+ * DESCRIPTION
+ *
+ * This interface provides utility functions for applications'
+ * convenience. It provides functions that may be used for example by
+ * command line applications but also other applications may find some
+ * routines helpful. None of these routines are mandatory in any other
+ * SILC routines or libraries, and are purely provided for convenience.
+ * These routines for example provide simple public key and private key
+ * pair generation, public key and private key file saving and loading
+ * for application, and other similar routines.
+ *
+ ***/
+
+#ifndef SILCAPPUTIL_H
+#define SILCAPPUTIL_H
+
+/****f* silcapputil/SilcAppUtil/silc_create_key_pair
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_create_key_pair(const char *pkcs_name,
+ * SilcUInt32 key_len_bits,
+ * const char *pub_filename,
+ * const char *prv_filename,
+ * const char *pub_identifier,
+ * const char *passphrase,
+ * SilcPublicKey *return_public_key,
+ * SilcPrivateKey *return_private_key,
+ * SilcBool interactive);
+ *
+ * DESCRIPTION
+ *
+ * This routine can be used to generate new public key and private key
+ * pair. The `pkcs_name' is the name of public key algorithm, or if
+ * NULL it defaults to "rsa". The `key_len_bits' is the key length
+ * in bits and if zero (0) it defaults to 2048 bits. The `pub_filename'
+ * and `prv_filename' is the public key and private key filenames.
+ * The `pub_identifier' is the public key identifier (for example:
+ * "UN=foobar, HN=hostname"), or if NULL the routine generates it
+ * automatically.
+ *
+ * The `passphrase' is the passphrase that is used to encrypt the
+ * private key file. It is recommended that you would protect your
+ * private key file with a passphrase.
+ *
+ * If the `interactive' is TRUE then this asks the user (by blocking
+ * the process for input) some questions about key generation (like
+ * public key algorithm, key length, filenames, etc). If all
+ * arguments are provided to this function already then `interactive'
+ * has no effect.
+ *
+ * NOTES
+ *
+ * Before calling this function the application must have initialized
+ * the crypto library by registering the public key algorithms with
+ * silc_pkcs_register_default function.
+ *
+ ***/
+SilcBool silc_create_key_pair(const char *pkcs_name,
+ SilcUInt32 key_len_bits,
+ const char *pub_filename,
+ const char *prv_filename,
+ const char *pub_identifier,
+ const char *passphrase,
+ SilcPublicKey *return_public_key,
+ SilcPrivateKey *return_private_key,
+ SilcBool interactive);
+
+/****f* silcapputil/SilcAppUtil/silc_load_key_pair
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_load_key_pair(const char *pub_filename,
+ * const char *prv_filename,
+ * const char *passphrase,
+ * SilcPublicKey *return_public_key,
+ * SilcPrivateKey *return_private_key);
+ *
+ * DESCRIPTION
+ *
+ * This routine can be used to load the public key and private key
+ * from files. This retuns FALSE it either of the key could not be
+ * loaded. This function returns TRUE on success and returns the
+ * public key into `return_public_key' pointer and private key into
+ * `return_private_key'. The `passphrase' is the passphrase which
+ * will be used to decrypt the private key file.
+ *
+ ***/
+SilcBool silc_load_key_pair(const char *pub_filename,
+ const char *prv_filename,
+ const char *passphrase,
+ SilcPublicKey *return_public_key,
+ SilcPrivateKey *return_private_key);
+
+/****f* silcapputil/SilcAppUtil/silc_show_public_key
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_show_public_key(const char *pub_filename);
+ *
+ * DESCRIPTION
+ *
+ * This routine can be used to dump the contents of the public key
+ * in the public key file `pub_filename'. This dumps the public key
+ * into human readable form into stdout. Returns FALSE on error.
+ *
+ ***/
+SilcBool silc_show_public_key(const char *pub_filename);
+
+/****f* silcapputil/SilcAppUtil/silc_change_private_key_passphrase
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_change_private_key_passphrase(const char *prv_filename,
+ * const char *old_passphrase,
+ * const char *new_passphrase);
+ *
+ * DESCRIPTION
+ *
+ * This routine can be used to change the passphrase of the private
+ * key file, which is used to encrypt the private key. If the old
+ * and new passphrase is not provided for this function this will
+ * prompt for them.
+ *
+ ***/
+SilcBool silc_change_private_key_passphrase(const char *prv_filename,
+ const char *old_passphrase,
+ const char *new_passphrase);
+
+
+/****f* silcapputil/SilcAppUtil/silc_identifier_check
+ *
+ * SYNOPSIS
+ *
+ * unsigned char *
+ * silc_identifier_check(const unsigned char *identifier,
+ * SilcUInt32 identifier_len,
+ * SilcStringEncoding identifier_encoding,
+ * SilcUInt32 max_allowed_length,
+ * SilcUInt32 *out_len);
+ *
+ * DESCRIPTION
+ *
+ * Checks that the 'identifier' string is valid identifier string
+ * and does not contain any unassigned or prohibited character. This
+ * function is used to check for valid nicknames, server names,
+ * usernames, hostnames, service names, algorithm names, other security
+ * property names, and SILC Public Key name.
+ *
+ * If the 'max_allowed_length' is non-zero the identifier cannot be
+ * longer than that, and NULL is returned if it is. If zero (0), no
+ * length limit exist. For nicknames the max length must be 128 bytes.
+ * Other identifiers has no default limit, but application may choose
+ * one anyway.
+ *
+ * Returns the validated string, that the caller must free. Returns
+ * NULL if the identifier string is not valid or contain unassigned or
+ * prohibited characters. Such identifier strings must not be used
+ * SILC protocol. The returned string is always in UTF-8 encoding.
+ * The length of the returned string is in 'out_len'.
+ *
+ * NOTES
+ *
+ * In addition of validating the identifier string, this function
+ * may map characters to other characters or remove characters from the
+ * original string. This is done as defined in the SILC protocol. Error
+ * is returned only if the string contains unassigned or prohibited
+ * characters. The original 'identifier' is not modified at any point.
+ *
+ ***/
+unsigned char *silc_identifier_check(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length,
+ SilcUInt32 *out_len);
+
+/****f* silcapputil/SilcAppUtil/silc_identifier_verify
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_identifier_check(const unsigned char *identifier,
+ * SilcUInt32 identifier_len,
+ * SilcStringEncoding identifier_encoding,
+ * SilcUInt32 max_allowed_length);
+ *
+ * DESCRIPTION
+ *
+ * Checks that the 'identifier' string is valid identifier string
+ * and does not contain any unassigned or prohibited character. This
+ * function is used to check for valid nicknames, server names,
+ * usernames, hostnames, service names, algorithm names, other security
+ * property names, and SILC Public Key name.
+ *
+ * If the 'max_allowed_length' is non-zero the identifier cannot be
+ * longer than that, and NULL is returned if it is. If zero (0), no
+ * length limit exist. For nicknames the max length must be 128 bytes.
+ * Other identifiers has no default limit, but application may choose
+ * one anyway.
+ *
+ * Returns TRUE if the string is valid and FALSE if it is prohibited.
+ *
+ ***/
+SilcBool silc_identifier_verify(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length);
+
+/****f* silcapputil/SilcAppUtil/silc_channel_name_check
+ *
+ * SYNOPSIS
+ *
+ * unsigned char *
+ * silc_channel_name_check(const unsigned char *identifier,
+ * SilcUInt32 identifier_len,
+ * SilcStringEncoding identifier_encoding,
+ * SilcUInt32 max_allowed_length,
+ * SilcUInt32 *out_len);
+ *
+ * DESCRIPTION
+ *
+ * Checks that the 'identifier' string is valid channel name string
+ * and does not contain any unassigned or prohibited character.
+ *
+ * If the 'max_allowed_length' is non-zero the identifier cannot be
+ * longer than that, and NULL is returned if it is. If zero (0), no
+ * length limit exist. For channel names the max length must be 256
+ * bytes.
+ *
+ * Returns the validated string, that the caller must free. Returns
+ * NULL if the identifier string is not valid or contain unassigned or
+ * prohibited characters. Such identifier strings must not be used
+ * SILC protocol. The returned string is always in UTF-8 encoding.
+ * The length of the returned string is in 'out_len'.
+ *
+ * NOTES
+ *
+ * In addition of validating the channel name string, this function
+ * may map characters to other characters or remove characters from the
+ * original string. This is done as defined in the SILC protocol. Error
+ * is returned only if the string contains unassigned or prohibited
+ * characters. The original 'identifier' is not modified at any point.
+ *
+ ***/
+unsigned char *silc_channel_name_check(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length,
+ SilcUInt32 *out_len);
+
+/****f* silcapputil/SilcAppUtil/silc_channel_name_verify
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_channel_name_check(const unsigned char *identifier,
+ * SilcUInt32 identifier_len,
+ * SilcStringEncoding identifier_encoding,
+ * SilcUInt32 max_allowed_length);
+ *
+ * DESCRIPTION
+ *
+ * Checks that the 'identifier' string is valid channel name string
+ * and does not contain any unassigned or prohibited character.
+ *
+ * If the 'max_allowed_length' is non-zero the identifier cannot be
+ * longer than that, and NULL is returned if it is. If zero (0), no
+ * length limit exist. For channel names the max length must be 256
+ * bytes.
+ *
+ * Returns TRUE if the string is valid and FALSE if it is prohibited.
+ *
+ ***/
+SilcBool silc_channel_name_verify(const unsigned char *identifier,
+ SilcUInt32 identifier_len,
+ SilcStringEncoding identifier_encoding,
+ SilcUInt32 max_allowed_length);
+
+#endif /* SILCAPPUTIL_H */
--- /dev/null
+/*
+
+ silcidcache.c
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 2000 - 2006 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
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+*/
+/* $Id$ */
+
+#include "silc.h"
+#include "silcidcache.h"
+
+/************************** Types and definitions ***************************/
+
+/* ID Cache context */
+struct SilcIDCacheStruct {
+ SilcHashTable id_table; /* ID hash table */
+ SilcHashTable name_table; /* Name hash table */
+ SilcHashTable context_table; /* Context hash table */
+ SilcIDCacheDestructor destructor; /* Entry destructor */
+ void *context; /* Destructor context */
+ SilcIdType id_type; /* Type of ID cache */
+};
+
+
+/************************ Static utility functions **************************/
+
+/* Callback that is called by the hash table routine when traversing
+ entries in the hash table. */
+
+static void silc_idcache_get_all_foreach(void *key, void *context,
+ void *user_context)
+{
+ SilcList *list = user_context;
+ if (!context)
+ return;
+ silc_list_add(*list, context);
+}
+
+/* Cache entry destructor */
+
+static void silc_idcache_destructor(SilcIDCache cache,
+ SilcIDCacheEntry entry,
+ void *app_context)
+{
+ if (cache->destructor)
+ cache->destructor(cache, entry, cache->destructor, app_context);
+
+ memset(entry, 'F', sizeof(*entry));
+ silc_free(entry);
+}
+
+
+/****************************** Public API **********************************/
+
+/* Allocates new ID cache object. */
+
+SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
+ SilcIDCacheDestructor destructor,
+ void *destructor_context)
+{
+ SilcIDCache cache;
+
+ SILC_LOG_DEBUG(("Allocating new cache"));
+
+ cache = silc_calloc(1, sizeof(*cache));
+ if (!cache)
+ return NULL;
+
+ cache->id_table = silc_hash_table_alloc(count, silc_hash_id,
+ SILC_32_TO_PTR(id_type),
+ silc_hash_id_compare,
+ SILC_32_TO_PTR(id_type),
+ NULL, NULL, TRUE);
+ cache->name_table = silc_hash_table_alloc(count, silc_hash_utf8_string, NULL,
+ silc_hash_utf8_compare, NULL,
+ NULL, NULL, TRUE);
+ cache->context_table = silc_hash_table_alloc(count, silc_hash_ptr, NULL,
+ NULL, NULL, NULL, NULL, TRUE);
+ cache->destructor = destructor;
+ cache->context = destructor_context;
+ cache->id_type = id_type;
+
+ if (!cache->id_table || !cache->name_table || !cache->context_table) {
+ if (cache->id_table)
+ silc_hash_table_free(cache->id_table);
+ if (cache->name_table)
+ silc_hash_table_free(cache->name_table);
+ if (cache->context_table)
+ silc_hash_table_free(cache->context_table);
+ silc_free(cache);
+ return NULL;
+ }
+
+ return cache;
+}
+
+/* Frees ID cache object and cache entries */
+
+void silc_idcache_free(SilcIDCache cache)
+{
+ silc_hash_table_free(cache->id_table);
+ silc_hash_table_free(cache->name_table);
+ silc_hash_table_free(cache->context_table);
+ silc_free(cache);
+}
+
+/* Add new entry to cache */
+
+SilcIDCacheEntry
+silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context)
+{
+ SilcIDCacheEntry c;
+
+ if (!id)
+ return NULL;
+
+ /* Allocate new cache entry */
+ c = silc_calloc(1, sizeof(*c));
+ if (!c)
+ return NULL;
+
+ c->id = id;
+ c->name = name;
+ c->context = context;
+
+ SILC_LOG_DEBUG(("Adding cache entry %p", c));
+
+ /* Add the new entry to the hash tables */
+
+ if (id) {
+ if (silc_idcache_find_by_id_one(cache, id, NULL)) {
+ SILC_LOG_ERROR(("Attempted to add same ID twice to ID Cache"));
+ goto err;
+ }
+ if (!silc_hash_table_add(cache->id_table, id, c))
+ goto err;
+ }
+ if (name)
+ if (!silc_hash_table_add(cache->name_table, name, c))
+ goto err;
+ if (context)
+ if (!silc_hash_table_add(cache->context_table, context, c))
+ goto err;
+
+ return c;
+
+ err:
+ if (c->name)
+ silc_hash_table_del_by_context(cache->name_table, c->name, c);
+ if (c->context)
+ silc_hash_table_del_by_context(cache->context_table, c->context, c);
+ if (c->id)
+ silc_hash_table_del_by_context(cache->id_table, c->id, c);
+ silc_free(c);
+
+ return NULL;
+}
+
+/* Delete cache entry from cache. */
+
+SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *app_context)
+{
+ SilcBool ret = FALSE;
+
+ SILC_LOG_DEBUG(("Deleting cache entry %p", entry));
+
+ if (entry->name)
+ ret = silc_hash_table_del_by_context(cache->name_table, entry->name,
+ entry);
+ if (entry->context)
+ ret = silc_hash_table_del_by_context(cache->context_table, entry->context,
+ entry);
+ if (entry->id)
+ ret = silc_hash_table_del_by_context(cache->id_table, entry->id,
+ entry);
+
+ if (ret)
+ silc_idcache_destructor(cache, entry, app_context);
+
+ return ret;
+}
+
+/* Deletes ID cache entry by ID. */
+
+SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
+ void *app_context)
+{
+ SilcIDCacheEntry c;
+
+ if (!silc_hash_table_find(cache->id_table, id, NULL, (void **)&c))
+ return FALSE;
+
+ return silc_idcache_del(cache, c, app_context);
+}
+
+/* Deletes ID cache entry by context. */
+
+SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context,
+ void *app_context)
+{
+ SilcIDCacheEntry c;
+
+ if (!silc_hash_table_find(cache->context_table, context, NULL, (void **)&c))
+ return FALSE;
+
+ return silc_idcache_del(cache, c, app_context);
+}
+
+/* Update entry */
+
+SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *old_id, void *new_id,
+ char *old_name, char *new_name)
+{
+ if (old_id && new_id) {
+ if (!silc_hash_table_del_by_context(cache->id_table, old_id, entry))
+ return FALSE;
+
+ if (cache->id_type == SILC_ID_CLIENT)
+ *(SilcClientID *)entry->id = *(SilcClientID *)new_id;
+ if (cache->id_type == SILC_ID_SERVER)
+ *(SilcServerID *)entry->id = *(SilcServerID *)new_id;
+ if (cache->id_type == SILC_ID_CHANNEL)
+ *(SilcChannelID *)entry->id = *(SilcChannelID *)new_id;
+
+ if (!silc_hash_table_add(cache->id_table, entry->id, entry))
+ return FALSE;
+ }
+
+ if (old_name && new_name) {
+ if (!silc_hash_table_del_by_context(cache->name_table, old_name, entry))
+ return FALSE;
+
+ entry->name = new_name;
+
+ if (!silc_hash_table_add(cache->name_table, entry->name, entry))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/* Returns all cache entrys from the ID cache to the `ret' ID Cache List. */
+
+SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list)
+{
+ if (!ret_list)
+ return FALSE;
+
+ if (!silc_hash_table_count(cache->id_table))
+ return FALSE;
+
+ silc_hash_table_foreach(cache->id_table, silc_idcache_get_all_foreach,
+ ret_list);
+
+ if (!silc_list_count(*ret_list))
+ return FALSE;
+
+ return TRUE;
+}
+
+/* Find ID Cache entry by ID. May return multiple entries. */
+
+SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
+ SilcList *ret_list)
+{
+ if (!ret_list)
+ return FALSE;
+
+ if (!silc_hash_table_count(cache->id_table))
+ return FALSE;
+
+ silc_hash_table_find_foreach(cache->id_table, id,
+ silc_idcache_get_all_foreach, ret_list);
+
+ if (!silc_list_count(*ret_list))
+ return FALSE;
+
+ return TRUE;
+}
+
+/* Find one specific ID entry. Compare full IDs */
+
+SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
+ SilcIDCacheEntry *ret)
+{
+ return silc_hash_table_find_ext(cache->id_table, id, NULL, (void *)ret,
+ NULL, NULL,
+ silc_hash_id_compare_full,
+ SILC_32_TO_PTR(cache->id_type));
+}
+
+/* Finds cache entry by context. */
+
+SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
+ SilcIDCacheEntry *ret)
+{
+ return silc_hash_table_find(cache->context_table, context, NULL,
+ (void *)ret);
+}
+
+/* Find ID Cache entry by name. Returns list of cache entries. */
+
+SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
+ SilcList *ret_list)
+{
+ if (!ret_list)
+ return FALSE;
+
+ if (!silc_hash_table_count(cache->name_table))
+ return FALSE;
+
+ silc_hash_table_find_foreach(cache->name_table, name,
+ silc_idcache_get_all_foreach, ret_list);
+
+ if (!silc_list_count(*ret_list))
+ return FALSE;
+
+ return TRUE;
+}
+
+/* Find ID Cache entry by name. Returns one cache entry. */
+
+SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
+ SilcIDCacheEntry *ret)
+{
+ return silc_hash_table_find(cache->name_table, name, NULL, (void *)ret);
+}
--- /dev/null
+/*
+
+ silcidcache.h
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 2000 - 2006 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
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+*/
+
+/****h* silcidcache/SILC ID Cache Interface
+ *
+ * DESCRIPTION
+ *
+ * SILC ID Cache is an cache for all kinds of ID's used in the SILC
+ * protocol. Application can save here the ID's it uses and the interface
+ * provides fast retrieval of the ID's from the cache.
+ *
+ * SILC ID Cache is not thread-safe. If the same cache context must be
+ * used in multithreaded environment concurrency control must be employed.
+ *
+ ***/
+
+#ifndef SILCIDCACHE_H
+#define SILCIDCACHE_H
+
+/****s* silcidcache/SilcIDCacheAPI/SilcIDCacheEntry
+ *
+ * NAME
+ *
+ * typedef struct SilcIDCacheEntryStruct { ... } SilcIDCacheEntry;
+ *
+ * DESCRIPTION
+ *
+ * This is an entry in the SILC ID Cache system. This context is
+ * allocated by adding new entry to ID cache by calling silc_idcache_add.
+ * Each of the fields in the structure are allocated by the caller.
+ *
+ * SOURCE
+ */
+typedef struct SilcIDCacheEntryStruct {
+ struct SilcIDCacheEntryStruct *next;
+ void *id; /* Associated ID */
+ char *name; /* Associated entry name */
+ void *context; /* Associated context */
+} *SilcIDCacheEntry;
+/***/
+
+/****s* silcidcache/SilcIDCacheAPI/SilcIDCache
+ *
+ * NAME
+ *
+ * typedef struct SilcIDCacheStruct *SilcIDCache;
+ *
+ * DESCRIPTION
+ *
+ * This context is the actual ID Cache and is allocated by
+ * silc_idcache_alloc and given as argument usually to all
+ * silc_idcache_* functions. It is freed by the
+ * silc_idcache_free function.
+ *
+ ***/
+typedef struct SilcIDCacheStruct *SilcIDCache;
+
+/****f* silcidcache/SilcIDCacheAPI/SilcIDCacheDestructor
+ *
+ * SYNOPSIS
+ *
+ * typedef void (*SilcIDCacheDestructor)(SilcIDCache cache,
+ * const SilcIDCacheEntry entry,
+ * void *destructor_context,
+ * void *app_context);
+ *
+ * DESCRIPTION
+ *
+ * Destructor callback given as argument to silc_idcache_alloc. This
+ * is called when an entry is deleted from the cache. Application
+ * must free the contents of the `entry'.
+ *
+ ***/
+typedef void (*SilcIDCacheDestructor)(SilcIDCache cache,
+ const SilcIDCacheEntry entry,
+ void *destructor_context,
+ void *app_context);
+
+/* Prototypes */
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_alloc
+ *
+ * SYNOPSIS
+ *
+ * SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
+ * SilcIDCacheDestructor destructor,
+ * void *destructor_context,
+ * SilcBool delete_id, SilcBool delete_name);
+ *
+ * DESCRIPTION
+ *
+ * Allocates new ID cache object. The initial amount of allocated entries
+ * can be sent as argument. If `count' is 0 the system uses default values.
+ * The `id_type' defines the types of the ID's that will be saved to the
+ * cache.
+ *
+ ***/
+SilcIDCache silc_idcache_alloc(SilcUInt32 count, SilcIdType id_type,
+ SilcIDCacheDestructor destructor,
+ void *destructor_context);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_free
+ *
+ * SYNOPSIS
+ *
+ * void silc_idcache_free(SilcIDCache cache);
+ *
+ * DESCRIPTION
+ *
+ * Frees ID cache context and all cache entries.
+ *
+ ***/
+void silc_idcache_free(SilcIDCache cache);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_add
+ *
+ * SYNOPSIS
+ *
+ * SilcIDCacheEntry
+ * silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context);
+ *
+ * DESCRIPTION
+ *
+ * Add new entry to the cache. Returns the allocated cache entry if the
+ * entry was added successfully, or NULL if error occurred. The `name' is
+ * the name associated with the ID, the `id' the actual ID and the
+ * `context' a caller specific context.
+ *
+ * The `name', `id' and `context' pointers will be stored in the cache,
+ * and if the caller frees these pointers the caller is also responsible
+ * of deleting the cache entry.
+ *
+ ***/
+SilcIDCacheEntry
+silc_idcache_add(SilcIDCache cache, char *name, void *id, void *context);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_del
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
+ * void *app_context);
+ *
+ * DESCRIPTION
+ *
+ * Delete cache entry from cache. Returns TRUE if the entry was deleted.
+ * The destructor will be called for the entry. The `app_context' is
+ * delivered to the destructor.
+ *
+ ***/
+SilcBool silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *app_context);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_del_by_id
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
+ * void *app_context);
+ *
+ * DESCRIPTION
+ *
+ * Delete cache entry by ID. Returns TRUE if the entry was deleted.
+ * The destructor will be called for the entry. The `app_context' is
+ * delivered to the destructor.
+ *
+ ***/
+SilcBool silc_idcache_del_by_id(SilcIDCache cache, void *id,
+ void *app_context);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_del_by_context
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context);
+ *
+ * DESCRIPTION
+ *
+ * Deletes cachen entry by the user specified context. Returns TRUE
+ * if the entry was deleted. The destructor will be called for the
+ * entry. The `app_context' is delivered to the destructor.
+ *
+ ***/
+SilcBool silc_idcache_del_by_context(SilcIDCache cache, void *context,
+ void *app_context);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_update_id
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
+ * void *old_id, void *new_id,
+ * char *old_name, char *new_name);
+ *
+ * DESCRIPTION
+ *
+ * Updates cache `entry' with new values. If the `new_id' is non-NULL
+ * then the new value will be copied over the old value in the `entry'.
+ * If the `new_name' is non-NULL then the `entry' will be updated with
+ * `new_name'. The caller is responsible of freeing the old name if it
+ * was updated with new one. The old ID value does not need to be freed
+ * as the new value is copied over the old value.
+ *
+ ***/
+SilcBool silc_idcache_update(SilcIDCache cache, SilcIDCacheEntry entry,
+ void *old_id, void *new_id,
+ char *old_name, char *new_name);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_get_all
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list);
+ *
+ * DESCRIPTION
+ *
+ * Returns all cache entries into the SilcList `ret_list' pointer. Each
+ * entry in the list is SilcIDCacheEntry. Returns FALSE if the cache
+ * is empty.
+ *
+ ***/
+SilcBool silc_idcache_get_all(SilcIDCache cache, SilcList *ret_list);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_find_by_id
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
+ * SilcList *ret_list);
+ *
+ * DESCRIPTION
+ *
+ * Find ID Cache entry by ID. This may return multiple entries.
+ * The entires are returned into the `ret_list' SilcList context.
+ * Returns TRUE if entry was found.
+ *
+ * NOTES
+ *
+ * If this function is used to find Client ID (SilcClientID), only the
+ * hash portion of the Client ID is compared. Use the function
+ * silc_idcache_find_by_id_one to find exact match for Client ID (full
+ * ID is compared and not only the hash).
+ *
+ * Comparing only the hash portion of Client ID allows searching of
+ * Client ID's by nickname, because the hash is based on the nickname.
+ * As nicknames are not unique, multiple entries may be found.
+ *
+ ***/
+SilcBool silc_idcache_find_by_id(SilcIDCache cache, void *id,
+ SilcList *ret_list);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_find_by_id_one
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
+ * SilcIDCacheEntry *ret);
+ *
+ * DESCRIPTION
+ *
+ * Find ID Cache entry by ID. Returns only one entry from the cache
+ * and the found entry is considered to be exact match. Returns TRUE
+ * if the entry was found.
+ *
+ ***/
+SilcBool silc_idcache_find_by_id_one(SilcIDCache cache, void *id,
+ SilcIDCacheEntry *ret);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_find_by_context
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
+ * SilcIDCacheEntry *ret);
+ *
+ * DESCRIPTION
+ *
+ * Find cache entry by user specified context. Returns TRUE if the
+ * entry was found.
+ *
+ ***/
+SilcBool silc_idcache_find_by_context(SilcIDCache cache, void *context,
+ SilcIDCacheEntry *ret);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_find_by_name
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
+ * SilcList *ret_list);
+ *
+ * DESCRIPTION
+ *
+ * Find cache entries by the name associated with the ID. This may
+ * return multiple entries to the `ret_list' SilcList context. Returns
+ * TRUE if the entry was found.
+ *
+ ***/
+SilcBool silc_idcache_find_by_name(SilcIDCache cache, char *name,
+ SilcList *ret_list);
+
+/****f* silcidcache/SilcIDCacheAPI/silc_idcache_find_by_name_one
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
+ * SilcIDCacheEntry *ret);
+ *
+ * DESCRIPTION
+ *
+ * Find cache entry by the name associated with the ID. This returns
+ * one entry and the found entry is considered to be exact match.
+ * Returns TRUE if the entry was found.
+ *
+ ***/
+SilcBool silc_idcache_find_by_name_one(SilcIDCache cache, char *name,
+ SilcIDCacheEntry *ret);
+
+#endif /* SILCIDCACHE_H */
@LINK=silcutil.html:SILC Util Interface
@LINK=silclist.html:SILC List Interface
@LINK=silcdlist.html:SILC Dynamic List Interface
-@LINK=silcapputil.html:SILC Application Utilities
-->
<big><b>SILC Utility Library</b></big>
silcstrutil.c \
silcutil.c \
silchashtable.c \
- silcapputil.c \
silcutf8.c \
silcstringprep.c \
silcstream.c \
silcfileutil.h \
silcutil.h \
silcstrutil.h \
- silcapputil.h \
silcutf8.h \
silcstringprep.h \
silctypes.h \
+++ /dev/null
-/*
-
- silcapputil.h
-
- Author: Pekka Riikonen <priikone@silcnet.org>
-
- Copyright (C) 2002 - 2005 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
- the Free Software Foundation; version 2 of the License.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
-*/
-
-/****h* silcutil/SILC Application Utilities
- *
- * DESCRIPTION
- *
- * This interface provides utility functions for applications'
- * convenience. It provides functions that may be used for example by
- * command line applications but also other applications may find some
- * routines helpful. None of these routines are mandatory in any other
- * SILC routines or libraries, and are purely provided for convenience.
- * These routines for example provide simple public key and private key
- * pair generation, public key and private key file saving and loading
- * for application, and other similar routines.
- *
- ***/
-
-#ifndef SILCAPPUTIL_H
-#define SILCAPPUTIL_H
-
-/****f* silcutil/SilcAppUtil/silc_create_key_pair
- *
- * SYNOPSIS
- *
- * SilcBool silc_create_key_pair(const char *pkcs_name,
- * SilcUInt32 key_len_bits,
- * const char *pub_filename,
- * const char *prv_filename,
- * const char *pub_identifier,
- * const char *passphrase,
- * SilcPublicKey *return_public_key,
- * SilcPrivateKey *return_private_key,
- * SilcBool interactive);
- *
- * DESCRIPTION
- *
- * This routine can be used to generate new public key and private key
- * pair. The `pkcs_name' is the name of public key algorithm, or if
- * NULL it defaults to "rsa". The `key_len_bits' is the key length
- * in bits and if zero (0) it defaults to 2048 bits. The `pub_filename'
- * and `prv_filename' is the public key and private key filenames.
- * The `pub_identifier' is the public key identifier (for example:
- * "UN=foobar, HN=hostname"), or if NULL the routine generates it
- * automatically.
- *
- * The `passphrase' is the passphrase that is used to encrypt the
- * private key file. It is recommended that you would protect your
- * private key file with a passphrase.
- *
- * If the `interactive' is TRUE then this asks the user (by blocking
- * the process for input) some questions about key generation (like
- * public key algorithm, key length, filenames, etc). If all
- * arguments are provided to this function already then `interactive'
- * has no effect.
- *
- * NOTES
- *
- * Before calling this function the application must have initialized
- * the crypto library by registering the public key algorithms with
- * silc_pkcs_register_default function.
- *
- ***/
-SilcBool silc_create_key_pair(const char *pkcs_name,
- SilcUInt32 key_len_bits,
- const char *pub_filename,
- const char *prv_filename,
- const char *pub_identifier,
- const char *passphrase,
- SilcPublicKey *return_public_key,
- SilcPrivateKey *return_private_key,
- SilcBool interactive);
-
-/****f* silcutil/SilcAppUtil/silc_load_key_pair
- *
- * SYNOPSIS
- *
- * SilcBool silc_load_key_pair(const char *pub_filename,
- * const char *prv_filename,
- * const char *passphrase,
- * SilcPublicKey *return_public_key,
- * SilcPrivateKey *return_private_key);
- *
- * DESCRIPTION
- *
- * This routine can be used to load the public key and private key
- * from files. This retuns FALSE it either of the key could not be
- * loaded. This function returns TRUE on success and returns the
- * public key into `return_public_key' pointer and private key into
- * `return_private_key'. The `passphrase' is the passphrase which
- * will be used to decrypt the private key file.
- *
- ***/
-SilcBool silc_load_key_pair(const char *pub_filename,
- const char *prv_filename,
- const char *passphrase,
- SilcPublicKey *return_public_key,
- SilcPrivateKey *return_private_key);
-
-/****f* silcutil/SilcAppUtil/silc_show_public_key
- *
- * SYNOPSIS
- *
- * SilcBool silc_show_public_key(const char *pub_filename);
- *
- * DESCRIPTION
- *
- * This routine can be used to dump the contents of the public key
- * in the public key file `pub_filename'. This dumps the public key
- * into human readable form into stdout. Returns FALSE on error.
- *
- ***/
-SilcBool silc_show_public_key(const char *pub_filename);
-
-/****f* silcutil/SilcAppUtil/silc_change_private_key_passphrase
- *
- * SYNOPSIS
- *
- * SilcBool silc_change_private_key_passphrase(const char *prv_filename,
- * const char *old_passphrase,
- * const char *new_passphrase);
- *
- * DESCRIPTION
- *
- * This routine can be used to change the passphrase of the private
- * key file, which is used to encrypt the private key. If the old
- * and new passphrase is not provided for this function this will
- * prompt for them.
- *
- ***/
-SilcBool silc_change_private_key_passphrase(const char *prv_filename,
- const char *old_passphrase,
- const char *new_passphrase);
-
-#endif /* SILCAPPUTIL_H */
/* Set and initialize the specified log file. */
-SilcBool silc_log_set_file(SilcLogType type, char *filename, SilcUInt32 maxsize,
- SilcSchedule scheduler)
+SilcBool silc_log_set_file(SilcLogType type, char *filename,
+ SilcUInt32 maxsize, SilcSchedule scheduler)
{
FILE *fp = NULL;
SilcLog log;
return dest;
}
-
-/* Checks that the 'identifier' string is valid identifier string
- and does not contain any unassigned or prohibited character. This
- function is used to check for valid nicknames, channel names,
- server names, usernames, hostnames, service names, algorithm names,
- other security property names, and SILC Public Key name. */
-
-unsigned char *silc_identifier_check(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length,
- SilcUInt32 *out_len)
-{
- unsigned char *utf8s;
- SilcUInt32 utf8s_len;
- SilcStringprepStatus status;
-
- if (!identifier || !identifier_len)
- return NULL;
-
- if (max_allowed_length && identifier_len > max_allowed_length)
- return NULL;
-
- status = silc_stringprep(identifier, identifier_len,
- identifier_encoding, SILC_IDENTIFIER_PREP, 0,
- &utf8s, &utf8s_len, SILC_STRING_UTF8);
- if (status != SILC_STRINGPREP_OK) {
- SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
- return NULL;
- }
-
- if (out_len)
- *out_len = utf8s_len;
-
- return utf8s;
-}
-
-/* Same as above but does not allocate memory, just checks the
- validity of the string. */
-
-SilcBool silc_identifier_verify(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length)
-{
- SilcStringprepStatus status;
-
- if (!identifier || !identifier_len)
- return FALSE;
-
- if (max_allowed_length && identifier_len > max_allowed_length)
- return FALSE;
-
- status = silc_stringprep(identifier, identifier_len,
- identifier_encoding, SILC_IDENTIFIER_PREP, 0,
- NULL, NULL, SILC_STRING_UTF8);
- if (status != SILC_STRINGPREP_OK) {
- SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
- return FALSE;
- }
-
- return TRUE;
-}
-
-unsigned char *silc_channel_name_check(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length,
- SilcUInt32 *out_len)
-{
- unsigned char *utf8s;
- SilcUInt32 utf8s_len;
- SilcStringprepStatus status;
-
- if (!identifier || !identifier_len)
- return NULL;
-
- if (max_allowed_length && identifier_len > max_allowed_length)
- return NULL;
-
- status = silc_stringprep(identifier, identifier_len,
- identifier_encoding, SILC_IDENTIFIER_CH_PREP, 0,
- &utf8s, &utf8s_len, SILC_STRING_UTF8);
- if (status != SILC_STRINGPREP_OK) {
- SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
- return NULL;
- }
-
- if (out_len)
- *out_len = utf8s_len;
-
- return utf8s;
-}
-
-/* Same as above but does not allocate memory, just checks the
- validity of the string. */
-
-SilcBool silc_channel_name_verify(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length)
-{
- SilcStringprepStatus status;
-
- if (!identifier || !identifier_len)
- return FALSE;
-
- if (max_allowed_length && identifier_len > max_allowed_length)
- return FALSE;
-
- status = silc_stringprep(identifier, identifier_len,
- identifier_encoding, SILC_IDENTIFIER_CH_PREP, 0,
- NULL, NULL, SILC_STRING_UTF8);
- if (status != SILC_STRINGPREP_OK) {
- SILC_LOG_DEBUG(("silc_stringprep() status error %d", status));
- return FALSE;
- }
-
- return TRUE;
-}
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2002 - 2005 Pekka Riikonen
+ Copyright (C) 2002 - 2006 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
char *silc_strncat(char *dest, SilcUInt32 dest_size,
const char *src, SilcUInt32 src_len);
-/****f* silcutil/SilcStrUtilAPI/silc_identifier_check
- *
- * SYNOPSIS
- *
- * unsigned char *
- * silc_identifier_check(const unsigned char *identifier,
- * SilcUInt32 identifier_len,
- * SilcStringEncoding identifier_encoding,
- * SilcUInt32 max_allowed_length,
- * SilcUInt32 *out_len);
- *
- * DESCRIPTION
- *
- * Checks that the 'identifier' string is valid identifier string
- * and does not contain any unassigned or prohibited character. This
- * function is used to check for valid nicknames, server names,
- * usernames, hostnames, service names, algorithm names, other security
- * property names, and SILC Public Key name.
- *
- * If the 'max_allowed_length' is non-zero the identifier cannot be
- * longer than that, and NULL is returned if it is. If zero (0), no
- * length limit exist. For nicknames the max length must be 128 bytes.
- * Other identifiers has no default limit, but application may choose
-* one anyway.
- *
- * Returns the validated string, that the caller must free. Returns
- * NULL if the identifier string is not valid or contain unassigned or
- * prohibited characters. Such identifier strings must not be used
- * SILC protocol. The returned string is always in UTF-8 encoding.
- * The length of the returned string is in 'out_len'.
- *
- * NOTES
- *
- * In addition of validating the identifier string, this function
- * may map characters to other characters or remove characters from the
- * original string. This is done as defined in the SILC protocol. Error
- * is returned only if the string contains unassigned or prohibited
- * characters. The original 'identifier' is not modified at any point.
- *
- ***/
-unsigned char *silc_identifier_check(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length,
- SilcUInt32 *out_len);
-
-/****f* silcutil/SilcStrUtilAPI/silc_identifier_verify
- *
- * SYNOPSIS
- *
- * SilcBool
- * silc_identifier_check(const unsigned char *identifier,
- * SilcUInt32 identifier_len,
- * SilcStringEncoding identifier_encoding,
- * SilcUInt32 max_allowed_length);
- *
- * DESCRIPTION
- *
- * Checks that the 'identifier' string is valid identifier string
- * and does not contain any unassigned or prohibited character. This
- * function is used to check for valid nicknames, server names,
- * usernames, hostnames, service names, algorithm names, other security
- * property names, and SILC Public Key name.
- *
- * If the 'max_allowed_length' is non-zero the identifier cannot be
- * longer than that, and NULL is returned if it is. If zero (0), no
- * length limit exist. For nicknames the max length must be 128 bytes.
- * Other identifiers has no default limit, but application may choose
- * one anyway.
- *
- * Returns TRUE if the string is valid and FALSE if it is prohibited.
- *
- ***/
-SilcBool silc_identifier_verify(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length);
-
-/****f* silcutil/SilcStrUtilAPI/silc_channel_name_check
- *
- * SYNOPSIS
- *
- * unsigned char *
- * silc_channel_name_check(const unsigned char *identifier,
- * SilcUInt32 identifier_len,
- * SilcStringEncoding identifier_encoding,
- * SilcUInt32 max_allowed_length,
- * SilcUInt32 *out_len);
- *
- * DESCRIPTION
- *
- * Checks that the 'identifier' string is valid channel name string
- * and does not contain any unassigned or prohibited character.
- *
- * If the 'max_allowed_length' is non-zero the identifier cannot be
- * longer than that, and NULL is returned if it is. If zero (0), no
- * length limit exist. For channel names the max length must be 256
- * bytes.
- *
- * Returns the validated string, that the caller must free. Returns
- * NULL if the identifier string is not valid or contain unassigned or
- * prohibited characters. Such identifier strings must not be used
- * SILC protocol. The returned string is always in UTF-8 encoding.
- * The length of the returned string is in 'out_len'.
- *
- * NOTES
- *
- * In addition of validating the channel name string, this function
- * may map characters to other characters or remove characters from the
- * original string. This is done as defined in the SILC protocol. Error
- * is returned only if the string contains unassigned or prohibited
- * characters. The original 'identifier' is not modified at any point.
- *
- ***/
-unsigned char *silc_channel_name_check(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length,
- SilcUInt32 *out_len);
-
-/****f* silcutil/SilcStrUtilAPI/silc_channel_name_verify
- *
- * SYNOPSIS
- *
- * SilcBool
- * silc_channel_name_check(const unsigned char *identifier,
- * SilcUInt32 identifier_len,
- * SilcStringEncoding identifier_encoding,
- * SilcUInt32 max_allowed_length);
- *
- * DESCRIPTION
- *
- * Checks that the 'identifier' string is valid channel name string
- * and does not contain any unassigned or prohibited character.
- *
- * If the 'max_allowed_length' is non-zero the identifier cannot be
- * longer than that, and NULL is returned if it is. If zero (0), no
- * length limit exist. For channel names the max length must be 256
- * bytes.
- *
- * Returns TRUE if the string is valid and FALSE if it is prohibited.
- *
- ***/
-SilcBool silc_channel_name_verify(const unsigned char *identifier,
- SilcUInt32 identifier_len,
- SilcStringEncoding identifier_encoding,
- SilcUInt32 max_allowed_length);
-
#endif /* SILCSTRUTIL_H */
projects / silc.git / commitdiff