int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry)
{
if (entry) {
/* Remove from cache */
if (!silc_idcache_del_by_context(id_list->channels, entry, NULL)) {
SILC_LOG_DEBUG(("Unknown channel, did not delete"));
return FALSE;
}
SILC_LOG_DEBUG(("Deleting channel %s", entry->channel_name));
/* Free all client entrys from the users list. The silc_hash_table_free
will free all the entries so they are not freed at the foreach
callback. */
silc_hash_table_foreach(entry->user_list, silc_idlist_del_channel_foreach,
NULL);
silc_hash_table_free(entry->user_list);
/* Free data */
silc_free(entry->channel_name);
silc_free(entry->id);
silc_free(entry->topic);
if (entry->invite_list)
silc_hash_table_free(entry->invite_list);
if (entry->ban_list)
silc_hash_table_free(entry->ban_list);
if (entry->send_key)
silc_cipher_free(entry->send_key);
if (entry->receive_key)
silc_cipher_free(entry->receive_key);
if (entry->key) {
memset(entry->key, 0, entry->key_len / 8);
silc_free(entry->key);
}
silc_free(entry->cipher);
if (entry->hmac)
silc_hmac_free(entry->hmac);
silc_free(entry->hmac_name);
silc_free(entry->rekey);
if (entry->founder_key)
silc_pkcs_public_key_free(entry->founder_key);
if (entry->channel_pubkeys)
silc_hash_table_free(entry->channel_pubkeys);
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
return TRUE;
}
return FALSE;
}
SilcBool silc_client_attribute_del(SilcClient client,
SilcClientConnection conn,
SilcAttribute attribute,
SilcAttributePayload attr)
{
SilcBool ret;
if (!conn->internal->attrs)
return FALSE;
if (attr) {
attribute = silc_attribute_get_attribute(attr);
ret = silc_hash_table_del_by_context(conn->internal->attrs,
SILC_32_TO_PTR(attribute), attr);
} else if (attribute) {
silc_hash_table_find_foreach(conn->internal->attrs,
SILC_32_TO_PTR(attribute),
silc_client_attribute_del_foreach, conn);
ret = TRUE;
} else{
return FALSE;
}
if (ret)
if (!silc_hash_table_count(conn->internal->attrs)) {
silc_hash_table_free(conn->internal->attrs);
conn->internal->attrs = NULL;
}
return ret;
}
void silc_idlist_client_destructor(SilcIDCache cache,
SilcIDCacheEntry entry,
void *dest_context,
void *app_context)
{
SilcServer server = dest_context;
SilcClientEntry client;
client = (SilcClientEntry)entry->context;
if (client) {
/* Remove client's public key from repository, this will free it too. */
if (client->data.public_key)
silc_skr_del_public_key(server->repository, client->data.public_key,
client);
assert(!silc_hash_table_count(client->channels));
silc_free(client->nickname);
silc_free(client->servername);
silc_free(client->username);
silc_free(client->userinfo);
silc_free(client->id);
silc_free(client->attrs);
silc_hash_table_free(client->channels);
memset(client, 'A', sizeof(*client));
silc_free(client);
}
}
void silc_thread_tls_uninit(void)
{
SilcTls tls = silc_thread_get_tls();
if (!tls || tls->shared_data)
return;
if (tls->tls_variables)
silc_hash_table_free(tls->tls_variables);
if (tls->variables)
silc_hash_table_free(tls->variables);
if (tls->lock)
silc_mutex_free(tls->lock);
tls->variables = NULL;
tls->lock = 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;
}
SilcChannelEntry
silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode,
SilcChannelID *id, SilcServerEntry router,
SilcCipher send_key, SilcCipher receive_key,
SilcHmac hmac)
{
SilcChannelEntry channel;
char *channel_namec = NULL;
SILC_LOG_DEBUG(("Adding new channel %s", channel_name));
/* Normalize name. This is cached, original is in client context. */
if (channel_name) {
channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
SILC_STRING_UTF8, 256, NULL);
if (!channel_namec)
return NULL;
}
channel = silc_calloc(1, sizeof(*channel));
channel->channel_name = channel_name;
channel->mode = mode;
channel->id = id;
channel->router = router;
channel->send_key = send_key;
channel->receive_key = receive_key;
channel->hmac = hmac;
channel->created = channel->updated = time(0);
if (!channel->hmac)
if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
silc_free(channel);
return NULL;
}
channel->user_list = silc_hash_table_alloc(3, silc_hash_ptr, NULL, NULL,
NULL, NULL, NULL, TRUE);
if (!silc_idcache_add(id_list->channels, channel_namec,
(void *)channel->id, (void *)channel)) {
silc_hmac_free(channel->hmac);
silc_hash_table_free(channel->user_list);
silc_free(channel);
silc_free(channel_namec);
return NULL;
}
return channel;
}
void silc_mime_free(SilcMime mime)
{
SilcMime m;
if (mime->fields)
silc_hash_table_free(mime->fields);
if (mime->multiparts) {
silc_dlist_start(mime->multiparts);
while ((m = silc_dlist_get(mime->multiparts)) != SILC_LIST_END)
silc_mime_free(m);
silc_dlist_uninit(mime->multiparts);
}
silc_free(mime->boundary);
silc_free(mime->multitype);
silc_free(mime->data);
silc_free(mime);
}
static TInt silc_thread_start(TAny *context)
{
#ifdef SILC_THREADS
SilcSymbianThread *tc = (SilcSymbianThread *)context;
SilcThreadStart start_func = tc->start_func;
void *user_context = tc->context;
SilcBool waitable = tc->waitable;
SilcTls tls, other = tc->tls;
void *ret = NULL;
silc_free(tc);
tls = silc_thread_tls_init_shared(other);
CTrapCleanup *cs = CTrapCleanup::New();
if (cs) {
CActiveScheduler *s = new CActiveScheduler;
if(s) {
CActiveScheduler::Install(s);
/* Call the thread function */
TRAPD(ret_val, ret = start_func(user_context));
delete s;
}
delete cs;
}
if (tls->tls_variables)
silc_hash_table_free(tls->tls_variables);
silc_free(tls);
silc_thread_exit(ret);
#endif
return KErrNone;
}
static void silc_mime_assembler_dest(void *key, void *context,
void *user_context)
{
silc_free(key);
silc_hash_table_free(context);
}
void silc_mime_assembler_free(SilcMimeAssembler assembler)
{
silc_hash_table_free(assembler->fragments);
silc_free(assembler);
}
