SilcChannelEntry *
silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
SilcUInt32 *channels_count)
{
SilcList list;
SilcIDCacheEntry id_cache = NULL;
SilcChannelEntry *channels = NULL;
int i = 0;
SILC_LOG_DEBUG(("Start"));
if (!channel_id) {
if (!silc_idcache_get_all(id_list->channels, &list))
return NULL;
channels = silc_calloc(silc_list_count(list), sizeof(*channels));
i = 0;
silc_list_start(list);
while ((id_cache = silc_list_get(list)))
channels[i++] = (SilcChannelEntry)id_cache->context;
} else {
if (!silc_idcache_find_by_id_one(id_list->channels, channel_id, &id_cache))
return NULL;
i = 1;
channels = silc_calloc(1, sizeof(*channels));
channels[0] = (SilcChannelEntry)id_cache->context;
}
if (channels_count)
*channels_count = i;
return channels;
}
SilcClient silc_client_alloc(SilcClientOperations *ops,
SilcClientParams *params,
void *application,
const char *version_string)
{
SilcClient new_client;
new_client = silc_calloc(1, sizeof(*new_client));
if (!new_client)
return NULL;
new_client->application = application;
new_client->internal = silc_calloc(1, sizeof(*new_client->internal));
if (!new_client->internal) {
silc_free(new_client);
return NULL;
}
new_client->internal->ops = ops;
new_client->internal->params =
silc_calloc(1, sizeof(*new_client->internal->params));
if (!version_string)
version_string = silc_version_string;
new_client->internal->silc_client_version = strdup(version_string);
if (params)
memcpy(new_client->internal->params, params, sizeof(*params));
new_client->internal->params->
nickname_format[sizeof(new_client->internal->
params->nickname_format) - 1] = 0;
silc_atomic_init32(&new_client->internal->conns, 0);
return new_client;
}
SilcBuffer silc_command_payload_encode_vap(SilcCommand cmd,
SilcUInt16 ident,
SilcUInt32 argc, va_list ap)
{
unsigned char **argv = NULL;
SilcUInt32 *argv_lens = NULL, *argv_types = NULL;
unsigned char *x;
SilcUInt32 x_len;
SilcUInt32 x_type;
SilcBuffer buffer = NULL;
int i, k = 0;
if (argc) {
argv = silc_calloc(argc, sizeof(unsigned char *));
if (!argv)
return NULL;
argv_lens = silc_calloc(argc, sizeof(SilcUInt32));
if (!argv_lens)
return NULL;
argv_types = silc_calloc(argc, sizeof(SilcUInt32));
if (!argv_types)
return NULL;
for (i = 0, k = 0; i < argc; i++) {
x_type = va_arg(ap, SilcUInt32);
x = va_arg(ap, unsigned char *);
x_len = va_arg(ap, SilcUInt32);
if (!x_type || !x || !x_len)
continue;
argv[k] = silc_memdup(x, x_len);
if (!argv[k])
goto out;
argv_lens[k] = x_len;
argv_types[k] = x_type;
k++;
}
}
buffer = silc_command_payload_encode(cmd, k, argv, argv_lens,
argv_types, ident);
out:
for (i = 0; i < k; i++)
silc_free(argv[i]);
silc_free(argv);
silc_free(argv_lens);
silc_free(argv_types);
return buffer;
}
SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
SilcBool waitable)
{
#ifdef SILC_THREADS
int ret;
SilcOs2Thread thread = silc_calloc(1, sizeof(*thread));
if (!thread)
return NULL;
thread->start_func = start_func;
thread->context = context;
thread->waitable = waitable;
/* Create the thread, and run it */
thread->thread = _beginthread(silc_thread_os2_start, NULL, 65536, thread);
if (thread->thread < 0) {
SILC_LOG_ERROR(("Could not create new thread"));
silc_free(thread);
return NULL;
}
return (SilcThread)thread->thread;
#else
/* Call thread callback immediately */
(*start_func)(context);
return NULL;
#endif
}
PurpleWhiteboard *silcpurple_wb_init(SilcPurple sg, SilcClientEntry client_entry)
{
SilcClientConnection conn;
PurpleWhiteboard *wb;
SilcPurpleWb wbs;
conn = sg->conn;
wb = purple_whiteboard_get_session(sg->account, client_entry->nickname);
if (!wb)
wb = purple_whiteboard_create(sg->account, client_entry->nickname, 0);
if (!wb)
return NULL;
if (!wb->proto_data) {
wbs = silc_calloc(1, sizeof(*wbs));
if (!wbs)
return NULL;
wbs->type = 0;
wbs->u.client = client_entry;
wbs->width = SILCPURPLE_WB_WIDTH;
wbs->height = SILCPURPLE_WB_HEIGHT;
wbs->brush_size = SILCPURPLE_WB_BRUSH_SMALL;
wbs->brush_color = SILCPURPLE_WB_COLOR_BLACK;
wb->proto_data = wbs;
/* Start the whiteboard */
purple_whiteboard_start(wb);
purple_whiteboard_clear(wb);
}
return wb;
}
SilcServerCommand silc_server_command_alloc(SilcServerThread thread)
{
SilcServerCommand cmd;
silc_mutex_lock(thread->server->lock);
/* Get command context from freelist or allocate new one. */
cmd = silc_list_get(thread->server->command_pool);
if (!cmd) {
silc_mutex_unlock(thread->server->lock);
cmd = silc_calloc(1, sizeof(*cmd));
if (!cmd)
return NULL;
SILC_LOG_DEBUG(("Allocating command context %p", cmd));
cmd->thread = thread;
return cmd;
}
SILC_LOG_DEBUG(("Get command context %p", cmd));
/* Delete from freelist */
silc_list_del(thread->server->command_pool, cmd);
cmd->thread = thread;
silc_mutex_unlock(thread->server->lock);
return cmd;
}
SilcBool silc_client_add_to_channel(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
SilcClientEntry client_entry,
SilcUInt32 cumode)
{
SilcChannelUser chu;
if (silc_client_on_channel(channel, client_entry))
return TRUE;
SILC_LOG_DEBUG(("Add client %s to channel", client_entry->nickname));
chu = silc_calloc(1, sizeof(*chu));
if (!chu)
return FALSE;
chu->client = client_entry;
chu->channel = channel;
chu->mode = cumode;
silc_client_ref_client(client, conn, client_entry);
silc_client_ref_channel(client, conn, channel);
silc_hash_table_add(channel->user_list, client_entry, chu);
silc_hash_table_add(client_entry->channels, channel, chu);
return TRUE;
}
PurpleWhiteboard *silcpurple_wb_init_ch(SilcPurple sg, SilcChannelEntry channel)
{
PurpleWhiteboard *wb;
SilcPurpleWb wbs;
wb = purple_whiteboard_get_session(sg->account, channel->channel_name);
if (!wb)
wb = purple_whiteboard_create(sg->account, channel->channel_name, 0);
if (!wb)
return NULL;
if (!wb->proto_data) {
wbs = silc_calloc(1, sizeof(*wbs));
if (!wbs)
return NULL;
wbs->type = 1;
wbs->u.channel = channel;
wbs->width = SILCPURPLE_WB_WIDTH;
wbs->height = SILCPURPLE_WB_HEIGHT;
wbs->brush_size = SILCPURPLE_WB_BRUSH_SMALL;
wbs->brush_color = SILCPURPLE_WB_COLOR_BLACK;
wb->proto_data = wbs;
/* Start the whiteboard */
purple_whiteboard_start(wb);
purple_whiteboard_clear(wb);
}
return wb;
}
SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
SilcBool waitable)
{
#ifdef SILC_THREADS
SilcWin32Thread thread;
unsigned id;
SILC_LOG_DEBUG(("Creating new thread"));
thread = silc_calloc(1, sizeof(*thread));
thread->start_func = start_func;
thread->context = context;
thread->waitable = waitable;
thread->thread =
_beginthreadex(NULL, 0, (LPTHREAD_START_ROUTINE)silc_thread_win32_start,
(void *)thread, 0, &id);
if (!thread->thread) {
SILC_LOG_ERROR(("Could not create new thread"));
silc_free(thread);
return NULL;
}
return (SilcThread)thread;
#else
/* Call thread callback immediately */
(*start_func)(context);
return NULL;
#endif
}
static void event_joined(struct event *event)
{
struct channel *channel = event_get_control(event, channel);
struct channel_connection *chconn = channel_get_connection(channel);
struct i_silc_channel_connection *silc_chconn;
struct i_silc_gateway_connection *silc_gwconn;
SilcJoinResolve *r;
i_assert(chconn != NULL);
if( !IS_SILC_CHCONN(chconn) )
return;
silc_chconn = (struct i_silc_channel_connection *)chconn;
silc_gwconn = (struct i_silc_gateway_connection *)chconn->gwconn;
r = silc_calloc(1, sizeof(*r));
r->channel = silc_chconn->channel_entry;
r->retry = 0;
if( event_isset(event, "init") ) {
silc_client_get_clients_by_channel(silc_gwconn->client,
silc_gwconn->conn, silc_chconn->channel_entry,
refresh_nicklist_resolved, r);
}
}
static inline SilcBool
silc_hash_table_replace_internal(SilcHashTable ht, void *key, void *context,
SilcHashFunction hash,
void *hash_user_context)
{
SilcHashTableEntry *entry;
SilcUInt32 i = SILC_HASH_TABLE_HASH(hash, hash_user_context);
SILC_HT_DEBUG(("index %d key %p", i, key));
entry = &ht->table[i];
if (*entry) {
/* The entry exists already. We have a collision, replace the old
key and context. */
if (ht->destructor)
ht->destructor((*entry)->key, (*entry)->context,
ht->destructor_user_context);
} else {
/* New key */
*entry = silc_calloc(1, sizeof(**entry));
if (!(*entry))
return FALSE;
ht->entry_count++;
}
(*entry)->key = key;
(*entry)->context = context;
if (SILC_HASH_REHASH_INC)
silc_hash_table_rehash(ht, 0);
return TRUE;
}
SilcAttributePayload silc_attribute_payload_alloc(SilcAttribute attribute,
SilcAttributeFlags flags,
void *object,
SilcUInt32 object_size)
{
SilcAttributePayload attr;
SilcUInt32 tmp_len;
attr = silc_calloc(1, sizeof(*attr));
if (!attr)
return NULL;
attr->attribute = attribute;
attr->flags = flags;
attr->data =
silc_attribute_payload_encode_int(attribute, flags, object,
object_size, &tmp_len);
attr->data_len = (SilcUInt16)tmp_len;
if (!attr->data) {
silc_free(attr);
return NULL;
}
return attr;
}
SilcConnAuth silc_connauth_alloc(SilcSchedule schedule,
SilcSKE ske,
SilcUInt32 timeout_secs)
{
SilcConnAuth connauth;
if (!schedule || !ske)
return NULL;
connauth = silc_calloc(1, sizeof(*connauth));
if (!connauth)
return NULL;
connauth->fsm = silc_fsm_alloc(connauth, silc_connauth_fsm_destructor,
NULL, schedule);
if (!connauth->fsm) {
silc_connauth_free(connauth);
return NULL;
}
connauth->timeout_secs = timeout_secs;
connauth->ske = ske;
ske->refcnt++;
return connauth;
}
SilcServerEntry
silc_idlist_add_server(SilcIDList id_list,
char *server_name, int server_type,
SilcServerID *id, SilcServerEntry router,
void *connection)
{
SilcServerEntry server;
char *server_namec = NULL;
SILC_LOG_DEBUG(("Adding new server entry"));
/* Normalize name. This is cached, original is in server context. */
if (server_name) {
server_namec = silc_identifier_check(server_name, strlen(server_name),
SILC_STRING_UTF8, 256, NULL);
if (!server_namec)
return NULL;
}
server = silc_calloc(1, sizeof(*server));
server->server_name = server_name;
server->server_type = server_type;
server->id = id;
server->router = router;
server->connection = connection;
if (!silc_idcache_add(id_list->servers, server_namec,
(void *)server->id, (void *)server)) {
silc_free(server);
silc_free(server_namec);
return NULL;
}
return server;
}
SilcSFTP silc_sftp_server_start(SilcStream stream,
SilcSchedule schedule,
SilcSFTPErrorCallback error_cb,
void *context,
SilcSFTPFilesystem fs)
{
SilcSFTPServer server;
if (!schedule)
schedule = silc_schedule_get_global();
server = silc_calloc(1, sizeof(*server));
if (!server)
return NULL;
server->stream = stream;
server->schedule = schedule;
server->error = error_cb;
server->context = context;
server->fs = fs;
/* We handle the stream now */
silc_stream_set_notifier(stream, schedule, silc_sftp_server_io, server);
SILC_LOG_DEBUG(("Starting SFTP server %p", server));
return (SilcSFTP)server;
}
void silcpurple_buddy_keyagr_request(SilcClient client,
SilcClientConnection conn,
SilcClientEntry client_entry,
const char *hostname, SilcUInt16 port)
{
char tmp[128], tmp2[128];
SilcPurpleKeyAgrAsk a;
PurpleConnection *gc = client->application;
g_snprintf(tmp, sizeof(tmp),
_("Key agreement request received from %s. Would you like to "
"perform the key agreement?"), client_entry->nickname);
if (hostname)
g_snprintf(tmp2, sizeof(tmp2),
_("The remote user is waiting key agreement on:\n"
"Remote host: %s\nRemote port: %d"), hostname, port);
a = silc_calloc(1, sizeof(*a));
if (!a)
return;
a->client = client;
a->conn = conn;
a->client_id = *client_entry->id;
if (hostname)
a->hostname = strdup(hostname);
a->port = port;
purple_request_action(client->application, _("Key Agreement Request"), tmp,
hostname ? tmp2 : NULL, 1, gc->account, client_entry->nickname,
NULL, a, 2, _("Yes"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb),
_("No"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb));
}
int main(int argc, char **argv)
{
Client client = silc_calloc(1, sizeof(*client));
gclient = client;
if (argc > 1) {
if (!strcmp(argv[1], "-d"))
silc_log_debug(TRUE);
if (argc > 2 && !strcmp(argv[2], "-x"))
silc_log_debug_hexdump(TRUE);
silc_log_set_debug_string("*");
}
client->schedule = silc_schedule_init(0, NULL);
if (!client->schedule)
return -1;
/* Connecto to server */
silc_net_tcp_connect(NULL, "127.0.0.1", 5000, client->schedule,
connect_callback, client);
silc_schedule(client->schedule);
return 0;
}
static inline SilcBool
silc_hash_table_add_internal(SilcHashTable ht, void *key, void *context,
SilcHashFunction hash,
void *hash_user_context)
{
SilcHashTableEntry *entry;
SilcUInt32 i = SILC_HASH_TABLE_HASH(hash, hash_user_context);
SILC_HT_DEBUG(("index %d key %p", i, key));
entry = &ht->table[i];
if (*entry) {
/* The entry exists already. We have a collision, add it to the
list to avoid collision. */
SilcHashTableEntry e, tmp;
e = *entry;
tmp = e->next;
while (tmp) {
e = tmp;
tmp = tmp->next;
}
SILC_HT_DEBUG(("Collision; adding new key to list"));
e->next = silc_calloc(1, sizeof(*e->next));
if (!e->next)
return FALSE;
e->next->key = key;
e->next->context = context;
ht->entry_count++;
} else {
/* New key */
SILC_HT_DEBUG(("New key"));
*entry = silc_calloc(1, sizeof(**entry));
if (!(*entry))
return FALSE;
(*entry)->key = key;
(*entry)->context = context;
ht->entry_count++;
}
if (SILC_HASH_REHASH_INC)
silc_hash_table_rehash(ht, 0);
return TRUE;
}
SilcVCard silc_vcard_alloc(void)
{
SilcVCard vcard = silc_calloc(1, sizeof(*vcard));
if (!vcard)
return NULL;
vcard->dynamic = TRUE;
return vcard;
}
static void
silcpurple_wb_request(SilcClient client, const unsigned char *message,
SilcUInt32 message_len, SilcClientEntry sender,
SilcChannelEntry channel)
{
char tmp[256];
SilcPurpleWbRequest req;
PurpleConnection *gc;
SilcPurple sg;
gc = client->application;
sg = gc->proto_data;
/* Open whiteboard automatically if requested */
if (purple_account_get_bool(sg->account, "open-wb", FALSE)) {
PurpleWhiteboard *wb;
if (!channel)
wb = silcpurple_wb_init(sg, sender);
else
wb = silcpurple_wb_init_ch(sg, channel);
silcpurple_wb_parse(wb->proto_data, wb,
(unsigned char *)message,
message_len);
return;
}
/* Close any previous unaccepted requests */
purple_request_close_with_handle(sender);
if (!channel) {
g_snprintf(tmp, sizeof(tmp),
_("%s sent message to whiteboard. Would you like "
"to open the whiteboard?"), sender->nickname);
} else {
g_snprintf(tmp, sizeof(tmp),
_("%s sent message to whiteboard on %s channel. "
"Would you like to open the whiteboard?"),
sender->nickname, channel->channel_name);
}
req = silc_calloc(1, sizeof(*req));
if (!req)
return;
req->message = silc_memdup(message, message_len);
req->message_len = message_len;
req->sender = sender;
req->channel = channel;
req->sg = sg;
purple_request_action(gc, _("Whiteboard"), tmp, NULL, 1,
sg->account, sender->nickname, NULL, req, 2,
_("Yes"), G_CALLBACK(silcpurple_wb_request_cb),
_("No"), G_CALLBACK(silcpurple_wb_request_cb));
}
SilcCommandPayload silc_command_payload_parse(const unsigned char *payload,
SilcUInt32 payload_len)
{
SilcBufferStruct buffer;
SilcCommandPayload newp;
unsigned char args_num;
SilcUInt16 p_len;
int ret;
SILC_LOG_DEBUG(("Parsing command payload"));
silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
newp = silc_calloc(1, sizeof(*newp));
if (!newp)
return NULL;
/* Parse the Command Payload */
ret = silc_buffer_unformat(&buffer,
SILC_STR_UI_SHORT(&p_len),
SILC_STR_UI_CHAR(&newp->cmd),
SILC_STR_UI_CHAR(&args_num),
SILC_STR_UI_SHORT(&newp->ident),
SILC_STR_END);
if (ret == -1) {
SILC_LOG_ERROR(("Incorrect command payload in packet"));
silc_free(newp);
return NULL;
}
if (p_len != silc_buffer_len(&buffer)) {
SILC_LOG_ERROR(("Incorrect command payload in packet"));
silc_free(newp);
return NULL;
}
if (newp->cmd == 0) {
SILC_LOG_ERROR(("Incorrect command type in command payload"));
silc_free(newp);
return NULL;
}
silc_buffer_pull(&buffer, SILC_COMMAND_PAYLOAD_LEN);
if (args_num) {
newp->args = silc_argument_payload_parse(buffer.data,
silc_buffer_len(&buffer),
args_num);
if (!newp->args) {
silc_free(newp);
return NULL;
}
}
silc_buffer_push(&buffer, SILC_COMMAND_PAYLOAD_LEN);
return newp;
}
void silc_server_command_reply_process(SilcServer server,
SilcPacketStream sock,
SilcBuffer buffer)
{
SilcIDListData idata = silc_packet_get_context(sock);
SilcServerCommandReply *cmd;
SilcServerCommandReplyContext ctx;
SilcCommandPayload payload;
SilcCommand command;
SILC_LOG_DEBUG(("Start"));
/* Get command reply payload from packet */
payload = silc_command_payload_parse(buffer->data, silc_buffer_len(buffer));
if (!payload) {
/* Silently ignore bad reply packet */
SILC_LOG_DEBUG(("Bad command reply packet"));
return;
}
/* Allocate command reply context. This must be free'd by the
command reply routine receiving it. */
ctx = silc_calloc(1, sizeof(*ctx));
ctx->server = server;
ctx->sock = sock;
ctx->payload = payload;
ctx->args = silc_command_get_args(ctx->payload);
ctx->ident = silc_command_get_ident(ctx->payload);
command = silc_command_get(ctx->payload);
silc_packet_stream_ref(sock);
/* Client is not allowed to send reply to all commands */
if (idata->conn_type == SILC_CONN_CLIENT &&
command != SILC_COMMAND_WHOIS) {
silc_server_command_reply_free(ctx);
return;
}
/* Check for pending commands and mark to be exeucted */
ctx->callbacks =
silc_server_command_pending_check(server, command,
ctx->ident, &ctx->callbacks_count);
/* Execute command reply */
for (cmd = silc_command_reply_list; cmd->cb; cmd++)
if (cmd->cmd == command)
break;
if (cmd == NULL || !cmd->cb) {
silc_server_command_reply_free(ctx);
return;
}
cmd->cb(ctx, NULL);
}
SilcClientEntry
silc_idlist_add_client(SilcIDList id_list, char *nickname, char *username,
char *userinfo, SilcClientID *id,
SilcServerEntry router, void *connection)
{
SilcClientEntry client;
char *nicknamec = NULL;
SILC_LOG_DEBUG(("Adding new client entry"));
/* Normalize name. This is cached, original is in client context. */
if (nickname) {
nicknamec = silc_identifier_check(nickname, strlen(nickname),
SILC_STRING_UTF8, 128, NULL);
if (!nicknamec)
return NULL;
}
/* Check username. */
if (username) {
char u[128 + 1], h[256 + 1];
int ret;
ret = silc_parse_userfqdn(username, u, sizeof(u), h, sizeof(h));
if (!ret)
return NULL;
if (!silc_identifier_verify(u, strlen(u), SILC_STRING_UTF8, 128))
return NULL;
if (ret > 1 && !silc_identifier_verify(h, strlen(h),
SILC_STRING_UTF8, 256))
return NULL;
}
client = silc_calloc(1, sizeof(*client));
if (!client)
return NULL;
client->nickname = nickname;
client->username = username ? strdup(username) : NULL;
client->userinfo = userinfo;
client->id = id;
client->router = router;
client->connection = connection;
client->channels = silc_hash_table_alloc(3, silc_hash_ptr, NULL,
NULL, NULL, NULL, NULL, TRUE);
if (!silc_idcache_add(id_list->clients, nicknamec, (void *)client->id,
(void *)client)) {
silc_hash_table_free(client->channels);
silc_free(client);
silc_free(nicknamec);
return NULL;
}
return client;
}
SilcSFTPName silc_sftp_name_decode(SilcUInt32 count, SilcBuffer buffer)
{
SilcSFTPName name;
int i;
int ret;
name = silc_calloc(1, sizeof(*name));
if (!name)
return NULL;
name->filename = silc_calloc(count, sizeof(*name->filename));
name->long_filename = silc_calloc(count, sizeof(*name->filename));
name->attrs = silc_calloc(count, sizeof(*name->attrs));
if (!name->filename || !name->long_filename || !name->attrs) {
silc_sftp_name_free(name);
return NULL;
}
name->count = count;
for (i = 0; i < count; i++) {
ret =
silc_buffer_unformat(buffer,
SILC_STR_UI32_STRING_ALLOC(&name->filename[i]),
SILC_STR_UI32_STRING_ALLOC(&name->long_filename[i]),
SILC_STR_END);
if (ret < 0) {
silc_sftp_name_free(name);
return NULL;
}
silc_buffer_pull(buffer, ret);
/* Decode attributes, this will pull the `buffer' to correct place
for next round automatically. */
name->attrs[i] = silc_sftp_attr_decode(buffer);
if (!name->attrs[i]) {
silc_sftp_name_free(name);
return NULL;
}
}
return name;
}
SilcBool silc_rwlock_alloc(SilcRwLock *rwlock)
{
#ifdef SILC_THREADS
*rwlock = silc_calloc(1, sizeof(**rwlock));
if (*rwlock == NULL)
return FALSE;
pthread_rwlock_init(&(*rwlock)->rwlock, NULL);
return TRUE;
#else
return FALSE;
#endif /* SILC_THREADS */
}
int silc_pkcs1_import_private_key(unsigned char *key,
SilcUInt32 key_len,
void **ret_private_key)
{
SilcAsn1 asn1;
SilcBufferStruct alg_key;
RsaPrivateKey *privkey;
SilcUInt32 ver;
if (!ret_private_key)
return 0;
asn1 = silc_asn1_alloc();
if (!asn1)
return 0;
/* Allocate RSA private key */
*ret_private_key = privkey = silc_calloc(1, sizeof(*privkey));
if (!privkey)
goto err;
/* Parse the PKCS #1 private key */
silc_buffer_set(&alg_key, key, key_len);
if (!silc_asn1_decode(asn1, &alg_key,
SILC_ASN1_OPTS(SILC_ASN1_ALLOC),
SILC_ASN1_SEQUENCE,
SILC_ASN1_SHORT_INT(&ver),
SILC_ASN1_INT(&privkey->n),
SILC_ASN1_INT(&privkey->e),
SILC_ASN1_INT(&privkey->d),
SILC_ASN1_INT(&privkey->p),
SILC_ASN1_INT(&privkey->q),
SILC_ASN1_INT(&privkey->dP),
SILC_ASN1_INT(&privkey->dQ),
SILC_ASN1_INT(&privkey->qP),
SILC_ASN1_END, SILC_ASN1_END))
goto err;
if (ver != 0)
goto err;
/* Set key length */
privkey->bits = ((silc_mp_sizeinbase(&privkey->n, 2) + 7) / 8) * 8;
silc_asn1_free(asn1);
return key_len;
err:
silc_free(privkey);
silc_asn1_free(asn1);
return 0;
}
SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
SilcBool waitable)
{
#ifdef SILC_THREADS
SilcSymbianThread *tc;
RThread *thread;
TInt ret;
char tmp[24];
SilcUInt16 wname[24];
SILC_LOG_DEBUG(("Creating new thread"));
tc = (SilcSymbianThread *)silc_calloc(1, sizeof(*tc));
if (!tc)
return NULL;
tc->start_func = start_func;
tc->context = context;
tc->waitable = waitable;
/* Allocate thread */
thread = new RThread;
if (!thread) {
silc_free(tc);
return NULL;
}
/* Create the thread */
silc_snprintf(tmp, sizeof(tmp), "thread-%p", tc);
silc_utf8_c2w((const unsigned char *)tmp, strlen(tmp), wname,
sizeof(wname) / sizeof(wname[0]));
TBuf<24> name((unsigned short *)wname);
name.PtrZ();
ret = thread->Create(name, silc_thread_start, 8192, NULL, tc);
if (ret != KErrNone) {
SILC_LOG_ERROR(("Could not create new thread, error %d", ret));
delete thread;
silc_free(tc);
return NULL;
}
/* Start the thread */
thread->Resume();
/* Close our instance to the thread */
thread->Close();
return (SilcThread)thread;
#else
/* Call thread callback immediately */
(*start_func)(context);
return NULL;
#endif
}
void silc_hash_table_rehash_ext(SilcHashTable ht, SilcUInt32 new_size,
SilcHashFunction hash,
void *hash_user_context)
{
int i;
SilcHashTableEntry *table, e, tmp;
SilcUInt32 table_size, size_index;
SilcBool auto_rehash;
SILC_HT_DEBUG(("Start"));
if (new_size)
silc_hash_table_primesize(new_size, &size_index);
else
silc_hash_table_primesize(ht->entry_count, &size_index);
if (size_index == ht->table_size)
return;
SILC_HT_DEBUG(("Rehashing"));
/* Take old hash table */
table = ht->table;
table_size = ht->table_size;
auto_rehash = ht->auto_rehash;
ht->auto_rehash = FALSE;
/* Allocate new table */
ht->table = silc_calloc(primesize[size_index], sizeof(*ht->table));
if (!ht->table)
return;
ht->table_size = size_index;
ht->entry_count = 0;
/* Rehash */
for (i = 0; i < primesize[table_size]; i++) {
e = table[i];
while (e) {
silc_hash_table_add_ext(ht, e->key, e->context, hash,
hash_user_context);
tmp = e;
e = e->next;
/* Remove old entry */
silc_free(tmp);
}
}
ht->auto_rehash = auto_rehash;
/* Remove old table */
silc_free(table);
}
SilcBool silc_cond_alloc(SilcCond *cond)
{
#ifdef SILC_THREADS
*cond = silc_calloc(1, sizeof(**cond));
if (*cond == NULL)
return FALSE;
pthread_cond_init(&(*cond)->cond, NULL);
return TRUE;
#else
return FALSE;
#endif /* SILC_THREADS*/
}
/* Start the MyBot, by creating the SILC Client entity by using the
SILC Client Library API. */
int mybot_start(void)
{
MyBot mybot;
SilcClientParams params;
/* Allocate the MyBot structure */
mybot = silc_calloc(1, sizeof(*mybot));
if (!mybot) {
perror("Out of memory");
return 1;
}
memset(¶ms, 0, sizeof(params));
params.threads = TRUE;
mybot->client = silc_client_alloc(&ops, ¶ms, mybot, NULL);
if (!mybot->client) {
perror("Could not allocate SILC Client");
return 1;
}
/* Now we initialize the client. */
if (!silc_client_init(mybot->client, silc_get_username(),
silc_net_localhost(), "I am the MyBot",
silc_running, mybot)) {
perror("Could not init client");
return 1;
}
if (!silc_load_key_pair("mybot.pub", "mybot.prv", "",
&mybot->public_key,
&mybot->private_key)) {
/* The keys don't exist. Let's generate us a key pair then! There's
nice ready routine for that too. Let's do 2048 bit RSA key pair. */
fprintf(stdout, "MyBot: Key pair does not exist, generating it.\n");
if (!silc_create_key_pair("rsa", 2048, "mybot.pub", "mybot.prv", NULL, "",
&mybot->public_key,
&mybot->private_key, FALSE)) {
perror("Could not generated key pair");
return 1;
}
}
/* And, then we are ready to go. Since we are really simple client we
don't have user interface and we don't have to deal with message loops
or interactivity. That's why we can just hand over the execution
to the library by calling silc_client_run. */
silc_client_run(mybot->client);
/* When we get here, we have quit the client, so clean up and exit */
silc_client_free(mybot->client);
silc_free(mybot);
return 0;
}