+Sat Mar 16 18:04:30 EET 2002 Pekka Riikonen <priikone@silcnet.org>
+
+ * Changed all library interfaces that use Global RNG to also
+ accept SilcRng as argument. Affected files are
+ lib/silcclient/command.c, lib/silccore/silcauth.[ch],
+ lib/silccore/silcchanel.[ch], lib/silcclient/client_channel.c,
+ silcd/packet_send.c, lib/silccore/silcprivate.[ch],
+ lib/silcmath/silcprimegen.c, lib/silcmath/silcmath.h, and
+ lib/silccrypt/rsa.c.
+
+ * Added function silc_pkcs_generate_key to the
+ lib/silccrypt/silcpkcs.[ch] for applications so that they
+ don't need to do pkcs->pkcs->init calls anymore.
+
+ * Remove SilcSocketConnection from the SFTP API since it really
+ wasn't needed there. The application has the information
+ saved in its contexts anyway and the SFTP layer doesn't need
+ know about it. Affected files lib/silcsft/silcsftp.h and
+ lib/silcsftp/sftp_[server/client].c.
+
+ * Rewrote the SILC SIM (modules) interface in lib/silcsim.[ch].
+ The SilcSimContext is not SilcSim.
+
+ * Fixed possible buffer overflows in silc_id_render in the
+ lib/silcutil/silcutil.c.
+
+ * On EPOC the global crypto module lists are not used at all
+ in the crypto library. Added support for using the constant
+ algorithm list on EPOC. Affected files are
+ lib/silccrypt/silccipher.c, silchash.c, silchmac.c and
+ silcpkcs.c.
+
Sat Mar 16 09:07:27 EET 2002 Pekka Riikonen <priikone@silcnet.org>
* Handled CHANNEL_CHANGE notify (ignore it) in Irssi SILC
TODO/bugs In SILC Libraries
===========================
- o Fix possible buffer overflows in silc_id_render function.
-
o WIN32 silc_net_create_connection_async does not work the same way
than on Unix. Do it with threads on WIN32. The function works but
is not actually async currently.
- o Rewrite the lib/silcsim/silcsim.h. The SilcSimContext should be
- private and silc_sim_alloc should take necessary arguments.
-
- o SILC RNG does not implement random seed files, and they should be
- implemented.
-
- o The SilcSocketConnection in the SFTP interface is actually redundant
- and should perhaps be removed. The application can save it in the
- context it provides, which is delivered by SFTP libary to all
- callback functions.
-
o EPOC specific additions/changes required:
o lib/silcutil/epoc routines missing or not completed.
- o Rewrite the lib/silcutil/silcprotocol.[ch] not to have
- [un]register functions, but to make it context based all the
- way. The alloc should take as argument the protocol type and
- its callback (not only final callback). It is not good that we
- have now global list of registered protocols.
-
- o Global RNG should not be allowed on EPOC, since it won't
- work. Every function in library that calls the global RNG must
- also take the RNG context as argument so that application can
- provide it if it doesn't want to use global RNG.
-
- o Think some solution to the global crypto lists in lib/silccrypt.
- They won't work on EPOC.
-
- o Something needs to be thought to the logging globals as well,
- like silc_debug etc. They won't work on EPOC. Perhaps logging
- and debugging is to be disabled on EPOC.
-
TODO in Toolkit Documentation
=============================
12. The router to router connection diagram in spec-xx is showing the
primary routers direction to wrong direction. Swap it.
+
+ 13. Add the killer's client ID to the KILLED notify. To be included in
+ protocol version 1.1.
SERVER_SIGNOFF away entirely).
o Add SilcAsyncOperation to utility library. Any function that takes
- callback as an argument must return SilcAsyncOperation.
+ callback as an argument must/should return SilcAsyncOperation (see
+ ~/silcasync).
+
+ o Rewrite SilcProtocol to be SilcFSM (see ~/silcfsm).
+
+ o Change SILC_TASK_CALLBACK to non-static, and remove the macro
+ SILC_TASK_CALLBACK_GLOBAL.
o Add DSS support.
+ o SILC RNG does not implement random seed files, and they should be
+ implemented.
+
o Cipher optimizations (asm, that this) at least for i386 would be nice.
o Add builtin SOCKS and HTTP Proxy support, well the SOCKS at least.
SILC currently supports SOCKS4 and SOCKS5 but it needs to be compiled
in separately.
+
+ o EPOC specific additions/changes required:
+
+ o In lib/silccore/silcpacket.c global RNG is used. Change the
+ interface for that function. The PKCS#1 also calls global RNG
+ (even though it is not used currently in SILC, the interface
+ allows its use).
+
+ o Something needs to be thought to the logging globals as well,
+ like silc_debug etc. They won't work on EPOC. Perhaps logging
+ and debugging is to be disabled on EPOC.
/* Generate keys */
silc_pkcs_alloc(pkcs_name, &pkcs);
- pkcs->pkcs->init(pkcs->context, bits, rng);
+ silc_pkcs_generate_key(pkcs, bits, rng);
/* Save public key into file */
key = silc_pkcs_get_public_key(pkcs, &key_len);
extern SilcClientOperations ops;
extern bool silc_debug;
extern bool silc_debug_hexdump;
-#ifdef SILC_SIM
-/* SIM (SILC Module) table */
-SilcSimContext **sims = NULL;
-SilcUInt32 sims_count = 0;
-#endif
void silc_expandos_init(void);
void silc_expandos_deinit(void);
extern SilcClient silc_client;
-#ifdef SILC_SIM
-/* SIM (SILC Module) table */
-extern SilcSimContext **sims;
-extern SilcUInt32 sims_count;
-#endif
-
#define IS_SILC_ITEM(rec) (IS_SILC_CHANNEL(rec) || IS_SILC_QUERY(rec))
#endif
chp = silc_channel_message_payload_encode(flags, dlen, data + 4,
iv_len, channel->iv,
channel->channel_key,
- channel->hmac);
+ channel->hmac, NULL);
memcpy(data, chp->data, chp->len);
silc_buffer_free(chp);
}
{
if (server) {
#ifdef SILC_SIM
- SilcSimContext *sim;
+ SilcSim sim;
#endif
silc_free(server->local_list);
/* Load (try at least) the crypto SIM module */
char buf[1023], *alg_name;
SilcCipherObject cipher_obj;
- SilcSimContext *sim;
+ SilcSim sim;
memset(&cipher_obj, 0, sizeof(cipher_obj));
cipher_obj.name = cipher->name;
/* build the libname */
snprintf(buf, sizeof(buf), "%s/%s", config->module_path,
cipher->module);
- sim = silc_sim_alloc();
- sim->type = SILC_SIM_CIPHER;
- sim->libname = buf;
+ sim = silc_sim_alloc(SILC_SIM_CIPHER, buf, 0);
alg_name = strdup(cipher->name);
if (strchr(alg_name, '-'))
#ifdef SILC_SIM
/* Load (try at least) the hash SIM module */
SilcHashObject hash_obj;
- SilcSimContext *sim;
+ SilcSim sim;
memset(&hash_obj, 0, sizeof(hash_obj));
hash_obj.name = hash->name;
hash_obj.block_len = hash->block_length;
hash_obj.hash_len = hash->digest_length;
- sim = silc_sim_alloc();
- sim->type = SILC_SIM_HASH;
- sim->libname = hash->module;
+ sim = silc_sim_alloc(SILC_SIM_HASH, hash->module, 0);
if ((silc_sim_load(sim))) {
hash_obj.init =
/* Generate keys */
silc_pkcs_alloc(pkcs_name, &pkcs);
- pkcs->pkcs->init(pkcs->context, bits, rng);
+ silc_pkcs_generate_key(pkcs, bits, rng);
/* Save public key into file */
key = silc_pkcs_get_public_key(pkcs, &key_len);
/* Encode the channel payload. This also encrypts the message payload. */
payload = silc_channel_message_payload_encode(flags, data_len, data, iv_len,
- channel->iv, cipher, hmac);
+ channel->iv, cipher, hmac,
+ client->rng);
/* Get data used in packet header encryption, keys and stuff. */
cipher = conn->send_key;
/* SFTP packet send callback. This will use preallocated buffer to avoid
reallocation of outgoing data buffer everytime. */
-static void silc_client_ftp_send_packet(SilcSocketConnection sock,
- SilcBuffer packet, void *context)
+static void silc_client_ftp_send_packet(SilcBuffer packet, void *context)
{
SilcClientFtpSession session = (SilcClientFtpSession)context;
SilcClient client = session->client;
SILC_STR_END);
/* Send the packet immediately */
- silc_client_packet_send(client, sock, SILC_PACKET_FTP, NULL, 0, NULL, NULL,
- session->packet->data, session->packet->len, TRUE);
+ silc_client_packet_send(client, session->sock, SILC_PACKET_FTP, NULL,
+ 0, NULL, NULL, session->packet->data,
+ session->packet->len, TRUE);
/* Clear buffer */
session->packet->data = session->packet->tail = session->packet->head;
if (!session->server) {
/* If we are the SFTP client then start the SFTP session and retrieve
the info about the file available for download. */
- session->sftp = silc_sftp_client_start(conn->sock,
- silc_client_ftp_send_packet,
- session,
- silc_client_ftp_version, session);
+ session->sftp = silc_sftp_client_start(silc_client_ftp_send_packet,
+ session, silc_client_ftp_version,
+ session);
} else {
/* Start SFTP server */
- session->sftp = silc_sftp_server_start(conn->sock,
- silc_client_ftp_send_packet,
+ session->sftp = silc_sftp_server_start(silc_client_ftp_send_packet,
session, session->fs);
/* Monitor transmission */
/* Encode private message payload */
buffer = silc_private_message_payload_encode(flags,
data_len, data,
- client_entry->send_key);
+ client_entry->send_key,
+ client->rng);
/* If we don't have private message specific key then private messages
are just as any normal packet thus call normal packet sending. If
if (!strcasecmp(cmd->argv[i + 1], "-pubkey")) {
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
- conn->hash,
+ cmd->client->rng, conn->hash,
conn->local_id,
SILC_ID_CLIENT);
} else {
if (!strcasecmp(cmd->argv[3], "-pubkey")) {
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
+ cmd->client->rng,
conn->hash,
conn->local_id,
SILC_ID_CLIENT);
if (!strcasecmp(cmd->argv[4], "-pubkey")) {
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
+ cmd->client->rng,
conn->hash,
conn->local_id,
SILC_ID_CLIENT);
/* Encode the public key authentication payload */
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
- conn->hash,
+ cmd->client->rng, conn->hash,
conn->local_id,
SILC_ID_CLIENT);
} else {
/* Encode the public key authentication payload */
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
- conn->hash,
+ cmd->client->rng, conn->hash,
conn->local_id,
SILC_ID_CLIENT);
} else {
SilcBuffer silc_auth_public_key_auth_generate(SilcPublicKey public_key,
SilcPrivateKey private_key,
- SilcHash hash,
+ SilcRng rng, SilcHash hash,
const void *id, SilcIdType type)
{
unsigned char *random;
SILC_LOG_DEBUG(("Generating Authentication Payload with data"));
/* Get 256 bytes of random data */
- random = silc_rng_global_get_rn_data(256);
+ if (rng)
+ random = silc_rng_get_rn_data(rng, 256);
+ else
+ random = silc_rng_global_get_rn_data(256);
if (!random)
return NULL;
*
* SilcBuffer silc_auth_public_key_auth_generate(SilcPublicKey public_key,
* SilcPrivateKey private_key,
+ * SilcRng rng,
* SilcHash hash,
* const void *id,
* SilcIdType type);
* and the actual authentication data. Returns NULL on error and the
* encoded Authentication Payload on success.
*
+ * The `private_key' is used to sign the payload. The `public_key', the
+ * and the `id' is encoded in the payload and signed. If the `rng' is
+ * NULL then global RNG is used, if non-NULL then `rng' is used as
+ * random number generator. Also random number is encoded in the
+ * payload before signing it with `private_key'.
+ *
***/
SilcBuffer silc_auth_public_key_auth_generate(SilcPublicKey public_key,
SilcPrivateKey private_key,
- SilcHash hash,
+ SilcRng rng, SilcHash hash,
const void *id, SilcIdType type);
/****f* silccore/SilcAuthAPI/silc_auth_public_key_auth_verify
SilcUInt16 iv_len,
unsigned char *iv,
SilcCipher cipher,
- SilcHmac hmac)
+ SilcHmac hmac,
+ SilcRng rng)
{
int i;
SilcBuffer buffer;
return NULL;
/* Generate padding */
- for (i = 0; i < pad_len; i++) pad[i] = silc_rng_global_get_byte();
+ if (rng) {
+ for (i = 0; i < pad_len; i++) pad[i] = silc_rng_get_byte(rng);
+ } else {
+ for (i = 0; i < pad_len; i++) pad[i] = silc_rng_global_get_byte();
+ }
/* Encode the Channel Message Payload */
silc_buffer_pull_tail(buffer, 6 + data_len + pad_len);
* SilcUInt16 iv_len,
* unsigned char *iv,
* SilcCipher cipher,
- * SilcHmac hmac);
+ * SilcHmac hmac.
+ * SilcRng rng);
*
* DESCRIPTION
*
* must be applied to the payload. The function generates the padding
* automatically from random data. The `cipher' is the cipher used
* encrypt the payload and `hmac' is used to compute the MAC for the
- * payload.
+ * payload. If `rng' is NULL then global RNG is used, if non-NULL then
+ * the `rng' is used.
*
***/
SilcBuffer silc_channel_message_payload_encode(SilcUInt16 flags,
SilcUInt16 iv_len,
unsigned char *iv,
SilcCipher cipher,
- SilcHmac hmac);
+ SilcHmac hmac,
+ SilcRng rng);
/****f* silccore/SilcChannelAPI/silc_channel_message_payload_free
*
SilcBuffer silc_private_message_payload_encode(SilcUInt16 flags,
SilcUInt16 data_len,
const unsigned char *data,
- SilcCipher cipher)
+ SilcCipher cipher,
+ SilcRng rng)
{
int i;
SilcBuffer buffer;
* SilcBuffer silc_private_message_payload_encode(SilcUInt16 flags,
* SilcUInt16 data_len,
* const unsigned char *data,
- * SilcCipher cipher);
+ * SilcCipher cipher,
+ * SilcRng rng);
*
* DESCRIPTION
*
* Encodes private message payload into a buffer and returns it. If
* the cipher is provided the packet is also encrypted here. It is provided
- * if the private message private keys are used.
+ * if the private message private keys are used. If the `rng' is NULL
+ * then global RNG is used, if non-NULL then `rng' is used.
*
***/
SilcBuffer silc_private_message_payload_encode(SilcUInt16 flags,
SilcUInt16 data_len,
const unsigned char *data,
- SilcCipher cipher);
+ SilcCipher cipher,
+ SilcRng rng);
/****f* silccore/SilcPrivateAPI/silc_private_message_payload_free
*
The `tmplen' in encrypt, decrypt, sign and verify PKCS API functions
is now calculated by (key->bits + 7) / 8. It is the length of one block.
+ o Sat Mar 16 18:27:19 EET 2002 Pekka
+
+ Use the SilcRng sent as argument to SILC_PKCS_API_INIT in prime
+ generation.
+
*/
#include "silcincludes.h"
/* Find p and q */
while (!found) {
printf("Finding p: ");
- silc_math_gen_prime(&p, prime_bits, TRUE);
+ silc_math_gen_prime(&p, prime_bits, TRUE, rng);
printf("\nFinding q: ");
- silc_math_gen_prime(&q, prime_bits, TRUE);
+ silc_math_gen_prime(&q, prime_bits, TRUE, rng);
if ((silc_mp_cmp(&p, &q)) == 0)
printf("\nFound equal primes, not good, retrying...\n");
/* $Id$ */
#include "silcincludes.h"
-
#include "ciphers.h" /* Includes cipher definitions */
+#ifndef SILC_EPOC
/* Dynamically registered list of ciphers. */
SilcDList silc_cipher_list = NULL;
+#endif /* SILC_EPOC */
/* Static list of ciphers for silc_cipher_register_default(). */
const SilcCipherObject silc_default_ciphers[] =
bool silc_cipher_register(SilcCipherObject *cipher)
{
+#ifndef SILC_EPOC
SilcCipherObject *new;
SILC_LOG_DEBUG(("Registering new cipher `%s'", cipher->name));
silc_cipher_list = silc_dlist_init();
silc_dlist_add(silc_cipher_list, new);
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_cipher_unregister(SilcCipherObject *cipher)
{
+#ifndef SILC_EPOC
SilcCipherObject *entry;
SILC_LOG_DEBUG(("Unregistering cipher"));
}
}
+#endif /* SILC_EPOC */
return FALSE;
}
bool silc_cipher_register_default(void)
{
+#ifndef SILC_EPOC
int i;
for (i = 0; silc_default_ciphers[i].name; i++)
silc_cipher_register((SilcCipherObject *)&(silc_default_ciphers[i]));
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_cipher_alloc(const unsigned char *name, SilcCipher *new_cipher)
{
- SilcCipherObject *entry;
+ SilcCipherObject *entry = NULL;
SILC_LOG_DEBUG(("Allocating new cipher object"));
+#ifndef SILC_EPOC
if (silc_cipher_list) {
silc_dlist_start(silc_cipher_list);
while ((entry = silc_dlist_get(silc_cipher_list)) != SILC_LIST_END) {
- if (!strcmp(entry->name, name)) {
- *new_cipher = silc_calloc(1, sizeof(**new_cipher));
- (*new_cipher)->cipher = entry;
- (*new_cipher)->context = silc_calloc(1, entry->context_len());
- (*new_cipher)->set_iv = silc_cipher_set_iv;
- (*new_cipher)->get_iv = silc_cipher_get_iv;
- (*new_cipher)->get_key_len = silc_cipher_get_key_len;
- (*new_cipher)->get_block_len = silc_cipher_get_block_len;
- return TRUE;
+ if (!strcmp(entry->name, name))
+ break;
+ }
+ }
+#else
+ {
+ /* On EPOC which don't have globals we check our constant cipher list. */
+ int i;
+ for (i = 0; silc_default_ciphers[i].name; i++) {
+ if (!strcmp(silc_default_ciphers[i].name, name)) {
+ entry = (SilcCipherObject *)&(silc_default_ciphers[i]);
+ break;
}
}
}
+#endif /* SILC_EPOC */
+
+ if (entry) {
+ *new_cipher = silc_calloc(1, sizeof(**new_cipher));
+ (*new_cipher)->cipher = entry;
+ (*new_cipher)->context = silc_calloc(1, entry->context_len());
+ (*new_cipher)->set_iv = silc_cipher_set_iv;
+ (*new_cipher)->get_iv = silc_cipher_get_iv;
+ (*new_cipher)->get_key_len = silc_cipher_get_key_len;
+ (*new_cipher)->get_block_len = silc_cipher_get_block_len;
+ return TRUE;
+ }
return FALSE;
}
bool silc_cipher_is_supported(const unsigned char *name)
{
+#ifndef SILC_EPOC
SilcCipherObject *entry;
if (silc_cipher_list) {
return TRUE;
}
}
-
+#else
+ {
+ int i;
+ for (i = 0; silc_default_ciphers[i].name; i++)
+ if (!strcmp(silc_default_ciphers[i].name, name))
+ return TRUE;
+ }
+#endif /* SILC_EPOC */
return FALSE;
}
{
SilcCipherObject *entry;
char *list = NULL;
- int len;
+ int len = 0;
- len = 0;
+#ifndef SILC_EPOC
if (silc_cipher_list) {
silc_dlist_start(silc_cipher_list);
while ((entry = silc_dlist_get(silc_cipher_list)) != SILC_LIST_END) {
memcpy(list + len, ",", 1);
len++;
}
- list[len - 1] = 0;
}
+#else
+ {
+ int i;
+ for (i = 0; silc_default_ciphers[i].name; i++) {
+ entry = (SilcCipherObject *)&(silc_default_ciphers[i]);
+ len += strlen(entry->name);
+ list = silc_realloc(list, len + 1);
+
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
+ memcpy(list + len, ",", 1);
+ len++;
+ }
+ }
+#endif /* SILC_EPOC */
+
+ list[len - 1] = 0;
return list;
}
#include "md5.h"
#include "sha1.h"
+#ifndef SILC_EPOC
/* List of dynamically registered hash functions. */
SilcDList silc_hash_list = NULL;
+#endif /* SILC_EPOC */
/* Default hash functions for silc_hash_register_default(). */
const SilcHashObject silc_default_hash[] =
bool silc_hash_register(SilcHashObject *hash)
{
+#ifndef SILC_EPOC
SilcHashObject *new;
SILC_LOG_DEBUG(("Registering new hash function `%s'", hash->name));
silc_hash_list = silc_dlist_init();
silc_dlist_add(silc_hash_list, new);
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_hash_unregister(SilcHashObject *hash)
{
+#ifndef SILC_EPOC
SilcHashObject *entry;
SILC_LOG_DEBUG(("Unregistering hash function"));
}
}
+#endif /* SILC_EPOC */
return FALSE;
}
bool silc_hash_register_default(void)
{
+#ifndef SILC_EPOC
int i;
for (i = 0; silc_default_hash[i].name; i++)
silc_hash_register((SilcHashObject *)&(silc_default_hash[i]));
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
{
- SilcHashObject *entry;
+ SilcHashObject *entry = NULL;
SILC_LOG_DEBUG(("Allocating new hash object"));
+#ifndef SILC_EPOC
if (silc_hash_list) {
silc_dlist_start(silc_hash_list);
while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
- if (!strcmp(entry->name, name)) {
- *new_hash = silc_calloc(1, sizeof(**new_hash));
- (*new_hash)->hash = entry;
- (*new_hash)->context = silc_calloc(1, entry->context_len());
- (*new_hash)->make_hash = silc_hash_make;
- return TRUE;
+ if (!strcmp(entry->name, name))
+ break;
+ }
+ }
+#else
+ {
+ /* On EPOC which don't have globals we check our constant hash list. */
+ int i;
+ for (i = 0; silc_default_hash[i].name; i++) {
+ if (!strcmp(silc_default_hash[i].name, name)) {
+ entry = (SilcHashObject *)&(silc_default_hash[i]);
+ break;
}
}
}
+#endif /* SILC_EPOC */
+
+ if (entry) {
+ *new_hash = silc_calloc(1, sizeof(**new_hash));
+ (*new_hash)->hash = entry;
+ (*new_hash)->context = silc_calloc(1, entry->context_len());
+ (*new_hash)->make_hash = silc_hash_make;
+ }
return FALSE;
}
bool silc_hash_is_supported(const unsigned char *name)
{
+#ifndef SILC_EPOC
SilcHashObject *entry;
if (silc_hash_list) {
return TRUE;
}
}
-
+#else
+ {
+ int i;
+ for (i = 0; silc_default_hash[i].name; i++)
+ if (!strcmp(silc_default_hash[i].name, name))
+ return TRUE;
+ }
+#endif /* SILC_EPOC */
return FALSE;
}
{
SilcHashObject *entry;
char *list = NULL;
- int len;
+ int len = 0;
- len = 0;
+#ifndef SILC_EPOC
if (silc_hash_list) {
silc_dlist_start(silc_hash_list);
while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
memcpy(list + len, ",", 1);
len++;
}
- list[len - 1] = 0;
}
+#else
+ {
+ int i;
+ for (i = 0; silc_default_hash[i].name; i++) {
+ entry = (SilcHashObject *)&(silc_default_hash[i]);
+ len += strlen(entry->name);
+ list = silc_realloc(list, len + 1);
+
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
+ memcpy(list + len, ",", 1);
+ len++;
+ }
+ }
+#endif /* SILC_EPOC */
+
+ list[len - 1] = 0;
return list;
}
void *hash_context;
};
+#ifndef SILC_EPOC
/* List of dynamically registered HMACs. */
SilcDList silc_hmac_list = NULL;
+#endif /* SILC_EPOC */
/* Default hmacs for silc_hmac_register_default(). */
const SilcHmacObject silc_default_hmacs[] =
bool silc_hmac_register(SilcHmacObject *hmac)
{
+#ifndef SILC_EPOC
SilcHmacObject *new;
SILC_LOG_DEBUG(("Registering new HMAC `%s'", hmac->name));
silc_hmac_list = silc_dlist_init();
silc_dlist_add(silc_hmac_list, new);
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_hmac_unregister(SilcHmacObject *hmac)
{
+#ifndef SILC_EPOC
SilcHmacObject *entry;
SILC_LOG_DEBUG(("Unregistering HMAC"));
}
}
+#endif /* SILC_EPOC */
return FALSE;
}
bool silc_hmac_register_default(void)
{
+#ifndef SILC_EPOC
int i;
for (i = 0; silc_default_hmacs[i].name; i++)
silc_hmac_register((SilcHmacObject *)&(silc_default_hmacs[i]));
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_hmac_alloc(char *name, SilcHash hash, SilcHmac *new_hmac)
{
- SilcHmacObject *entry;
-
SILC_LOG_DEBUG(("Allocating new HMAC"));
/* Allocate the new object */
(*new_hmac)->hash = hash;
+#ifndef SILC_EPOC
if (silc_hmac_list) {
+ SilcHmacObject *entry;
silc_dlist_start(silc_hmac_list);
while ((entry = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) {
if (!strcmp(entry->name, name)) {
}
}
}
+#else
+ {
+ /* On EPOC which don't have globals we check our constant hash list. */
+ int i;
+ for (i = 0; silc_default_hmacs[i].name; i++) {
+ if (!strcmp(silc_default_hmacs[i].name, name)) {
+ (*new_hmac)->hmac = (SilcHmacObject *)&(silc_default_hmacs[i]);
+ return TRUE;
+ }
+ }
+ }
+#endif /* SILC_EPOC */
silc_free(*new_hmac);
*new_hmac = NULL;
bool silc_hmac_is_supported(const char *name)
{
+#ifndef SILC_EPOC
SilcHmacObject *entry;
if (!name)
return TRUE;
}
}
-
+#else
+ {
+ int i;
+ for (i = 0; silc_default_hmacs[i].name; i++)
+ if (!strcmp(silc_default_hmacs[i].name, name))
+ return TRUE;
+ }
+#endif /* SILC_EPOC */
return FALSE;
}
{
SilcHmacObject *entry;
char *list = NULL;
- int len;
+ int len = 0;
- len = 0;
+#ifndef SILC_EPOC
if (silc_hmac_list) {
silc_dlist_start(silc_hmac_list);
while ((entry = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) {
memcpy(list + len, ",", 1);
len++;
}
- list[len - 1] = 0;
}
+#else
+ {
+ int i;
+ for (i = 0; silc_default_hmacs[i].name; i++) {
+ entry = (SilcHmacObject *)&(silc_default_hmacs[i]);
+ len += strlen(entry->name);
+ list = silc_realloc(list, len + 1);
+
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
+ memcpy(list + len, ",", 1);
+ len++;
+ }
+ }
+#endif /* SILC_EPOC */
+
+ list[len - 1] = 0;
return list;
}
#include "rsa.h"
#include "pkcs1.h"
+#ifndef SILC_EPOC
/* Dynamically registered list of PKCS. */
SilcDList silc_pkcs_list = NULL;
+#define SILC_PKCS_LIST silc_pkcs_list
+#else
+#define SILC_PKCS_LIST TRUE
+#endif /* SILC_EPOC */
/* Static list of PKCS for silc_pkcs_register_default(). */
const SilcPKCSObject silc_default_pkcs[] =
bool silc_pkcs_register(SilcPKCSObject *pkcs)
{
+#ifndef SILC_EPOC
SilcPKCSObject *new;
SILC_LOG_DEBUG(("Registering new PKCS `%s'", pkcs->name));
silc_pkcs_list = silc_dlist_init();
silc_dlist_add(silc_pkcs_list, new);
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_pkcs_unregister(SilcPKCSObject *pkcs)
{
+#ifndef SILC_EPOC
SilcPKCSObject *entry;
SILC_LOG_DEBUG(("Unregistering PKCS"));
}
}
+#endif /* SILC_EPOC */
return FALSE;
}
bool silc_pkcs_register_default(void)
{
+#ifndef SILC_EPOC
int i;
for (i = 0; silc_default_pkcs[i].name; i++)
silc_pkcs_register((SilcPKCSObject *)&(silc_default_pkcs[i]));
+#endif /* SILC_EPOC */
return TRUE;
}
bool silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs)
{
- SilcPKCSObject *entry;
+ SilcPKCSObject *entry = NULL;
SILC_LOG_DEBUG(("Allocating new PKCS object"));
+#ifndef SILC_EPOC
if (silc_pkcs_list) {
silc_dlist_start(silc_pkcs_list);
while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
- if (!strcmp(entry->name, name)) {
- *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
- (*new_pkcs)->pkcs = entry;
- (*new_pkcs)->context = silc_calloc(1, entry->context_len());
- (*new_pkcs)->get_key_len = silc_pkcs_get_key_len;
- return TRUE;
+ if (!strcmp(entry->name, name))
+ break;
+ }
+ }
+#else
+ {
+ /* On EPOC which don't have globals we check our constant hash list. */
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++) {
+ if (!strcmp(silc_default_pkcs[i].name, name)) {
+ entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+ break;
}
}
}
+#endif /* SILC_EPOC */
+
+ if (entry) {
+ *new_pkcs = silc_calloc(1, sizeof(**new_pkcs));
+ (*new_pkcs)->pkcs = entry;
+ (*new_pkcs)->context = silc_calloc(1, entry->context_len());
+ (*new_pkcs)->get_key_len = silc_pkcs_get_key_len;
+ return TRUE;
+ }
return FALSE;
}
int silc_pkcs_is_supported(const unsigned char *name)
{
+#ifndef SILC_EPOC
SilcPKCSObject *entry;
if (silc_pkcs_list) {
return TRUE;
}
}
-
+#else
+ {
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++)
+ if (!strcmp(silc_default_pkcs[i].name, name))
+ return TRUE;
+ }
+#endif /* SILC_EPOC */
return FALSE;
}
{
SilcPKCSObject *entry;
char *list = NULL;
- int len;
+ int len = 0;
- len = 0;
+#ifndef SILC_EPOC
if (silc_pkcs_list) {
silc_dlist_start(silc_pkcs_list);
while ((entry = silc_dlist_get(silc_pkcs_list)) != SILC_LIST_END) {
memcpy(list + len, ",", 1);
len++;
}
- list[len - 1] = 0;
}
+#else
+ {
+ int i;
+ for (i = 0; silc_default_pkcs[i].name; i++) {
+ entry = (SilcPKCSObject *)&(silc_default_pkcs[i]);
+ len += strlen(entry->name);
+ list = silc_realloc(list, len + 1);
+
+ memcpy(list + (len - strlen(entry->name)),
+ entry->name, strlen(entry->name));
+ memcpy(list + len, ",", 1);
+ len++;
+ }
+ }
+#endif /* SILC_EPOC */
+
+ list[len - 1] = 0;
return list;
}
+/* Generate new key pair into the `pkcs' context. */
+
+int silc_pkcs_generate_key(SilcPKCS pkcs, SilcUInt32 bits_key_len,
+ SilcRng rng)
+{
+ return pkcs->pkcs->init(pkcs->context, bits_key_len, rng);
+}
+
/* Returns the length of the key */
SilcUInt32 silc_pkcs_get_key_len(SilcPKCS pkcs)
goto err;
/* See if we support this algorithm (check only if PKCS are registered) */
- if (silc_pkcs_list && !silc_pkcs_is_supported(pkcs_name)) {
+ if (SILC_PKCS_LIST && !silc_pkcs_is_supported(pkcs_name)) {
SILC_LOG_DEBUG(("Unknown PKCS %s", pkcs_name));
goto err;
}
/* Try to set the key. If this fails the key must be malformed. This
code assumes that the PKCS routine checks the format of the key.
(check only if PKCS are registered) */
- if (silc_pkcs_list) {
+ if (SILC_PKCS_LIST) {
silc_pkcs_alloc(pkcs_name, &alg);
if (!alg->pkcs->set_public_key(alg->context, key_data, key_len))
goto err;
goto err;
/* See if we support this algorithm (check only if PKCS are registered). */
- if (silc_pkcs_list && !silc_pkcs_is_supported(pkcs_name)) {
+ if (SILC_PKCS_LIST && !silc_pkcs_is_supported(pkcs_name)) {
SILC_LOG_DEBUG(("Unknown PKCS `%s'", pkcs_name));
goto err;
}
/* Try to set the key. If this fails the key must be malformed. This
code assumes that the PKCS routine checks the format of the key.
(check only if PKCS are registered) */
- if (silc_pkcs_list) {
+ if (SILC_PKCS_LIST) {
silc_pkcs_alloc(pkcs_name, &alg);
if (!alg->pkcs->set_private_key(alg->context, key_data, key_len))
goto err;
void silc_pkcs_free(SilcPKCS pkcs);
int silc_pkcs_is_supported(const unsigned char *name);
char *silc_pkcs_get_supported(void);
+int silc_pkcs_generate_key(SilcPKCS pkcs, SilcUInt32 bits_key_len,
+ SilcRng rng);
SilcUInt32 silc_pkcs_get_key_len(SilcPKCS self);
unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, SilcUInt32 *len);
unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, SilcUInt32 *len);
#ifndef SILCMATH_H
#define SILCMATH_H
+#include "silcrng.h"
+
/****f* silcmath/SilcMathAPI/silc_math_gen_prime
*
* SYNOPSIS
* (r.joosten@pijnenburg.nl) for such a good help with prime tests.
*
* If argument verbose is TRUE this will display some status information
- * about the progress of generation.
+ * about the progress of generation. If the `rng' is NULL then global
+ * RNG is used, if non-NULL then `rng' is used to generate the random
+ * number number.
*
***/
-bool silc_math_gen_prime(SilcMPInt *prime, SilcUInt32 bits, bool verbose);
+bool silc_math_gen_prime(SilcMPInt *prime, SilcUInt32 bits, bool verbose,
+ SilcRng rng);
/****f* silcmath/SilcMathAPI/silc_math_prime_test
*
If argument verbose is TRUE this will display some status information
about the progress of generation. */
-bool silc_math_gen_prime(SilcMPInt *prime, SilcUInt32 bits, bool verbose)
+bool silc_math_gen_prime(SilcMPInt *prime, SilcUInt32 bits, bool verbose,
+ SilcRng rng)
{
unsigned char *numbuf = NULL;
SilcUInt32 i, b, k;
memset(numbuf, 0, (bits / 8));
silc_free(numbuf);
}
- numbuf = silc_rng_global_get_rn_string((bits / 8));
+ if (rng)
+ numbuf = silc_rng_get_rn_string(rng, (bits / 8));
+ else
+ numbuf = silc_rng_global_get_rn_string((bits / 8));
if (!numbuf)
return FALSE;
} while (numbuf[0] == '0');
/* SFTP client context */
typedef struct {
- SilcSocketConnection sock;
SilcSFTPSendPacketCallback send_packet;
void *send_context;
SilcSFTPVersionCallback version;
sftp->packet->len);
/* Send the packet */
- (*sftp->send_packet)(sftp->sock, sftp->packet, sftp->send_context);
+ (*sftp->send_packet)(sftp->packet, sftp->send_context);
/* Clear packet */
sftp->packet->data = sftp->packet->tail = sftp->packet->head;
va_end(vp);
}
-/* Starts SFTP client by associating the socket connection `sock' to the
- created SFTP client context. The version callback indicated by the
- `callback' will be called after the SFTP session has been started
- and server has returned the version of the protocol. The SFTP client
- context is returned in the callback too. This returns the allocated
- SFTP client context or NULL on error. */
+/* Starts SFTP client and returns context for it. The version callback
+ indicated by the `callback' will be called after the SFTP session has
+ been started and server has returned the version of the protocol. The
+ SFTP client context is returned in the callback too. This returns
+ allocated SFTP client context or NULL on error. */
-SilcSFTP silc_sftp_client_start(SilcSocketConnection sock,
- SilcSFTPSendPacketCallback send_packet,
+SilcSFTP silc_sftp_client_start(SilcSFTPSendPacketCallback send_packet,
void *send_context,
SilcSFTPVersionCallback callback,
void *context)
return NULL;
sftp = silc_calloc(1, sizeof(*sftp));
- sftp->sock = sock;
sftp->send_packet = send_packet;
sftp->send_context = send_context;
sftp->version = callback;
/* SFTP Server context */
typedef struct {
- SilcSocketConnection sock;
SilcSFTPSendPacketCallback send_packet;
void *send_context;
SilcSFTPMonitors monitors;
sftp->packet->len);
/* Send the packet */
- (*sftp->send_packet)(sftp->sock, sftp->packet, sftp->send_context);
+ (*sftp->send_packet)(sftp->packet, sftp->send_context);
/* Clear packet */
sftp->packet->data = sftp->packet->tail = sftp->packet->head;
SILC_STR_END);
}
-/* Starts SFTP server by associating the socket connection `sock' to the
- created SFTP server context. This function returns the allocated
- SFTP client context or NULL on error. The `send_packet' is called
+/* Starts SFTP server and returns context to it. This function returns the
+ allocated SFTP client context or NULL on error. The `send_packet' is called
by the library when it needs to send a packet. The `fs' is the
structure containing filesystem access callbacks. */
-SilcSFTP silc_sftp_server_start(SilcSocketConnection sock,
- SilcSFTPSendPacketCallback send_packet,
+SilcSFTP silc_sftp_server_start(SilcSFTPSendPacketCallback send_packet,
void *send_context,
SilcSFTPFilesystem fs)
{
SilcSFTPServer server;
server = silc_calloc(1, sizeof(*server));
- server->sock = sock;
server->send_packet = send_packet;
server->send_context = send_context;
server->fs = fs;
*
* SYNOPSIS
*
- * typedef void (*SilcSFTPSendPacketCallback)(SilcSocketConnection sock,
- * SilcBuffer packet,
+ * typedef void (*SilcSFTPSendPacketCallback)(SilcBuffer packet,
* void *context);
*
* DESCRIPTION
*
* Packet sending callback. The caller of this interface will provide this
* function for the library. The libary will call this function everytime
- * it needs to send a packet to the socket connection indicated by the
- * `sock'.
+ * it needs to send a packet to the remote host.
*
***/
-typedef void (*SilcSFTPSendPacketCallback)(SilcSocketConnection sock,
- SilcBuffer packet, void *context);
+typedef void (*SilcSFTPSendPacketCallback)(SilcBuffer packet, void *context);
/****f* silcsftp/SilcSFTPAPI/SilcSFTPVersionCallback
*
*
* SYNOPSIS
*
- * SilcSFTP silc_sftp_client_start(SilcSocketConnection sock,
- * SilcSFTPSendPacketCallback send_packet,
+ * SilcSFTP silc_sftp_client_start(SilcSFTPSendPacketCallback send_packet,
* void *send_context,
* SilcSFTPVersionCallback callback,
* void *context);
*
* DESCRIPTION
*
- * Starts SFTP client by associating the socket connection `sock' to the
- * created SFTP client context. The version callback indicated by the
- * `callback' will be called after the SFTP session has been started
- * and server has returned the version of the protocol. The SFTP client
- * context is returned in the callback too. This returns the allocated
- * SFTP client context or NULL on error.
+ * Starts SFTP client and returns context to it. The version callback
+ * indicated by the `callback' will be called after the SFTP session has
+ * been started and server has returned the version of the protocol. The
+ * SFTP client context is returned in the callback too. This returns the
+ * allocated SFTP client context or NULL on error. Each socket connection
+ * should allocate their own SFTP client by calling this function.
*
***/
-SilcSFTP silc_sftp_client_start(SilcSocketConnection sock,
- SilcSFTPSendPacketCallback send_packet,
+SilcSFTP silc_sftp_client_start(SilcSFTPSendPacketCallback send_packet,
void *send_context,
SilcSFTPVersionCallback callback,
void *context);
*
* SYNOPSIS
*
- * SilcSFTP silc_sftp_server_start(SilcSocketConnection sock,
- * SilcSFTPSendPacketCallback send_packet,
+ * SilcSFTP silc_sftp_server_start(SilcSFTPSendPacketCallback send_packet,
* void *send_context,
* SilcSFTPFilesystem fs);
*
* DESCRIPTION
*
- * Starts SFTP server by associating the socket connection `sock' to the
- * created SFTP server context. This function returns the allocated
- * SFTP client context or NULL on error. The `send_packet' is called
- * by the library when it needs to send a packet. The `fs' is the
- * filesystem context allocated by the application.
+ * Starts SFTP server and returns a context to it. This function returns
+ * the allocated SFTP client context or NULL on error. The `send_packet'
+ * is called by the library when it needs to send a packet. The `fs' is the
+ * filesystem context allocated by the application. Each socket connection
+ * should start its own server by calling this function.
*
***/
-SilcSFTP silc_sftp_server_start(SilcSocketConnection sock,
- SilcSFTPSendPacketCallback send_packet,
+SilcSFTP silc_sftp_server_start(SilcSFTPSendPacketCallback send_packet,
void *send_context,
SilcSFTPFilesystem fs);
#include "silcincludes.h"
+/*
+ SILC Module (SIM) Context.
+
+ This context holds relevant information about the SIM loaded into
+ the system. Following short description of the fields.
+
+ void *handle
+
+ Pointer to the SIM. This is used to get the symbols out of
+ the SIM. This is initalized by system specific routine.
+
+ SilcSimType type
+
+ Type of the SIM.
+
+ char *libname;
+
+ Filename and path to the SIM library file.
+
+ int flags
+
+ Flags used with the SIM. These are system specific flags.
+ See below for more information.
+
+*/
+struct SilcSimStruct {
+ void *handle;
+ SilcSimType type;
+ char *libname;
+ int flags;
+};
+
#ifdef SILC_SIM /* SIM upport enabled */
/* Allocates new SIM context. This is later send to all SIM
routines. */
-SilcSimContext *silc_sim_alloc()
+SilcSim silc_sim_alloc(SilcSimType type, const char *libname,
+ SilcUInt32 flags)
{
- SilcSimContext *new;
+ SilcSim sim;
SILC_LOG_DEBUG(("Initializing new SIM context"));
- new = silc_calloc(1, sizeof(*new));
- if (!new) {
+ sim = silc_calloc(1, sizeof(*sim));
+ if (!sim) {
SILC_LOG_ERROR(("Could not allocate new SIM context"));
return NULL;
}
- new->handle = NULL;
- new->type = SILC_SIM_NONE;
- new->libname = NULL;
- new->flags = SILC_SIM_FLAGS;
+ sim->handle = NULL;
+ sim->type = type;
+ sim->libname = strdup(libname);
+ sim->flags = !flags ? SILC_SIM_FLAGS : flags;
- return new;
+ return sim;
}
/* Free's SIM context. SIM must be closed with silc_sim_close before
calling this. */
-void silc_sim_free(SilcSimContext *sim)
+void silc_sim_free(SilcSim sim)
{
assert(sim->handle == NULL);
-
- if (sim)
- silc_free(sim);
+ silc_free(sim->libname);
+ silc_free(sim);
}
/* Loads SIM into the SILC system. */
-int silc_sim_load(SilcSimContext *sim)
+int silc_sim_load(SilcSim sim)
{
assert(sim != NULL);
/* Load the library */
sim->handle = dlopen(sim->libname, sim->flags);
if (!sim->handle) {
- SILC_LOG_ERROR(("Error loading SIM: %s", silc_sim_error()));
+ SILC_LOG_ERROR(("Error loading SIM: %s", silc_sim_error(sim)));
return FALSE;
}
/* Closes SIM. This is called when execution of program is ending or
one explicitly wants to remove this SIM from SILC. */
-int silc_sim_close(SilcSimContext *sim)
+int silc_sim_close(SilcSim sim)
{
assert(sim != NULL);
/* Returns error string if error has occured while processing SIM's. */
-char *silc_sim_error()
+char *silc_sim_error(SilcSim sim)
{
return dlerror();
}
symbols they want to get from SIM and use the returned pointer to
what ever it is intended. */
-void *silc_sim_getsym(SilcSimContext *sim, const char *symbol)
+void *silc_sim_getsym(SilcSim sim, const char *symbol)
{
assert(sim != NULL);
#ifndef SILCSIM_H
#define SILCSIM_H
+typedef struct SilcSimStruct *SilcSim;
+
/* All SIM types. New types maybe freely added. */
typedef enum {
SILC_SIM_NONE = 0,
SILC_SIM_HASH,
} SilcSimType;
-/*
- SILC Module (SIM) Context.
-
- This context holds relevant information about the SIM loaded into
- the system. Following short description of the fields.
-
- void *handle
-
- Pointer to the SIM. This is used to get the symbols out of
- the SIM. This is initalized by system specific routine.
-
- SilcSimType type
-
- Type of the SIM.
-
- char *libname;
-
- Filename and path to the SIM library file.
-
- int flags
-
- Flags used with the SIM. These are system specific flags.
- See below for more information.
-
-*/
-typedef struct {
- void *handle;
- SilcSimType type;
- char *libname;
- int flags;
-} SilcSimContext;
-
/* Flags used to retrieve the symbols from the library file. Default
is that the symbols are resolved as they are loaded. However, if
system doesn't support this we have no other choice but to do it lazy
/*#define SILC_SIM_FLAGS RTLD_LAZY */
/* Prototypes */
-SilcSimContext *silc_sim_alloc();
-void silc_sim_free(SilcSimContext *sim);
-int silc_sim_load(SilcSimContext *sim);
-int silc_sim_close(SilcSimContext *sim);
-char *silc_sim_error();
-void *silc_sim_getsym(SilcSimContext *sim, const char *symbol);
+SilcSim silc_sim_alloc(SilcSimType type, const char *libname,
+ SilcUInt32 flags);
+void silc_sim_free(SilcSim sim);
+int silc_sim_load(SilcSim sim);
+int silc_sim_close(SilcSim sim);
+char *silc_sim_error(SilcSim sim);
+void *silc_sim_getsym(SilcSim sim, const char *symbol);
#endif
return FALSE;
#else
struct sockaddr_in remote;
+ char *host_ip;
*hostname = NULL;
*ip = NULL;
return FALSE;
#else
struct sockaddr_in local;
+ char *host_ip;
*hostname = NULL;
*ip = NULL;
/* 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) {
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), NULL, 0, NI_NUMERICHOST))
- strcat(rid, tmp);
+ 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);
- strcat(rid, inet_ntoa(ipv4));
+ cp = inet_ntoa(ipv4);
+ if (cp)
+ _PUT_STRING(rid, cp);
}
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%d,", ntohs(server_id->port));
- strcat(rid, 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), "[%02x %02x]", tmps[0], tmps[1]);
- strcat(rid, tmp);
+ snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+ _PUT_STRING(rid, tmp);
}
break;
case SILC_ID_CLIENT:
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), NULL, 0, NI_NUMERICHOST))
- strcat(rid, tmp);
+ 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);
- strcat(rid, inet_ntoa(ipv4));
+ cp = inet_ntoa(ipv4);
+ if (cp)
+ _PUT_STRING(rid, cp);
}
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%02x,", client_id->rnd);
- strcat(rid, tmp);
+ snprintf(tmp, sizeof(tmp) - 1, ",%02x,", client_id->rnd);
+ _PUT_STRING(rid, tmp);
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), "[%02x %02x %02x %02x...]",
+ 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]);
- strcat(rid, tmp);
+ _PUT_STRING(rid, tmp);
}
break;
case SILC_ID_CHANNEL:
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), NULL, 0, NI_NUMERICHOST))
- strcat(rid, tmp);
+ 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);
- strcat(rid, inet_ntoa(ipv4));
+ cp = inet_ntoa(ipv4);
+ if (cp)
+ _PUT_STRING(rid, cp);
}
memset(tmp, 0, sizeof(tmp));
- snprintf(tmp, sizeof(tmp), ",%d,", ntohs(channel_id->port));
- strcat(rid, 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), "[%02x %02x]", tmps[0], tmps[1]);
- strcat(rid, tmp);
+ snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+ _PUT_STRING(rid, tmp);
}
break;
}
projects / silc.git / commitdiff