/*
- client_channel.c
+ client_channel.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2001 Pekka Riikonen
+ Copyright (C) 1997 - 2002 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; either version 2 of the License, or
- (at your option) any later version.
-
+ 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
SilcMessageFlags flags,
unsigned char *data,
SilcUInt32 data_len,
- int force_send)
+ bool force_send)
{
- int i;
- SilcSocketConnection sock = conn->sock;
+ SilcSocketConnection sock;
SilcBuffer payload;
SilcPacketContext packetdata;
const SilcBufferStruct packet;
SilcCipher cipher;
SilcHmac hmac;
unsigned char *id_string;
- SilcUInt32 iv_len;
int block_len;
+ SilcChannelUser chu;
+ assert(client && conn && channel);
+ sock = conn->sock;
SILC_LOG_DEBUG(("Sending packet to channel"));
+ chu = silc_client_on_channel(channel, conn->local_entry);
+ if (!chu) {
+ SILC_LOG_ERROR(("Cannot send message to channel we are not joined"));
+ return;
+ }
+
+ /* Check if it is allowed to send messages to this channel by us. */
+ if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS && !chu->mode)
+ return;
+ if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
+ chu->mode & SILC_CHANNEL_UMODE_CHANOP &&
+ !(chu->mode & SILC_CHANNEL_UMODE_CHANFO))
+ return;
+ if (chu->mode & SILC_CHANNEL_UMODE_QUIET)
+ return;
+
/* Take the key to be used */
if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
if (key) {
block_len = silc_cipher_get_block_len(cipher);
- /* Generate IV */
- iv_len = silc_cipher_get_block_len(cipher);
- if (channel->iv[0] == '\0')
- for (i = 0; i < iv_len; i++) channel->iv[i] =
- silc_rng_get_byte(client->rng);
- else
- silc_hash_make(client->internal->md5hash, channel->iv, iv_len,
- channel->iv);
-
- /* 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,
- client->rng);
+ /* Encode the message payload. This also encrypts the message payload. */
+ payload = silc_message_payload_encode(flags, data, data_len, TRUE, FALSE,
+ cipher, hmac, client->rng, NULL,
+ client->private_key, client->sha1hash);
/* Get data used in packet header encryption, keys and stuff. */
- cipher = conn->send_key;
- hmac = conn->hmac_send;
+ cipher = conn->internal->send_key;
+ hmac = conn->internal->hmac_send;
id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
/* Set the packet context pointers. The destination ID is always
packetdata.dst_id_len);
packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
packetdata.src_id_len + packetdata.dst_id_len;
- packetdata.padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
- packetdata.src_id_len +
- packetdata.dst_id_len), block_len);
+ SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
+ packetdata.src_id_len +
+ packetdata.dst_id_len), block_len, packetdata.padlen);
/* Create the outgoing packet */
if (!silc_packet_assemble(&packetdata, client->rng, cipher, hmac, sock,
/* Encrypt the header and padding of the packet. This is encrypted
with normal session key shared with our server. */
- silc_packet_encrypt(cipher, hmac, conn->psn_send++,
+ silc_packet_encrypt(cipher, hmac, conn->internal->psn_send++,
(SilcBuffer)&packet, SILC_PACKET_HEADER_LEN +
packetdata.src_id_len + packetdata.dst_id_len +
packetdata.padlen);
/* Now actually send the packet */
silc_client_packet_send_real(client, sock, force_send);
+ /* Check for mandatory rekey */
+ if (conn->internal->psn_send == SILC_CLIENT_REKEY_THRESHOLD)
+ silc_schedule_task_add(client->schedule, sock->sock,
+ silc_client_rekey_callback, sock, 0, 1,
+ SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
+
out:
silc_buffer_free(payload);
silc_free(id_string);
}
typedef struct {
- SilcChannelMessagePayload payload;
+ SilcMessagePayload payload;
SilcChannelID *channel_id;
} *SilcChannelClientResolve;
if (clients_count == 1) {
SilcChannelEntry channel;
unsigned char *message;
+ SilcUInt32 message_len;
channel = silc_client_get_channel_by_id(client, conn, res->channel_id);
if (!channel)
silc_hash_table_add(clients[0]->channels, channel, chu);
}
- message = silc_channel_message_get_data(res->payload, NULL);
+ message = silc_message_get_data(res->payload, &message_len);
/* Pass the message to application */
client->internal->ops->channel_message(
- client, conn, clients[0], channel,
- silc_channel_message_get_flags(res->payload),
- message);
+ client, conn, clients[0], channel, res->payload,
+ silc_message_get_flags(res->payload),
+ message, message_len);
}
out:
- silc_channel_message_payload_free(res->payload);
+ silc_message_payload_free(res->payload);
silc_free(res->channel_id);
silc_free(res);
}
/* Process received message to a channel (or from a channel, really). This
decrypts the channel message with channel specific key and parses the
- channel payload. Finally it displays the message on the screen. */
+ message payload. Finally it displays the message on the screen. */
void silc_client_channel_message(SilcClient client,
SilcSocketConnection sock,
{
SilcClientConnection conn = (SilcClientConnection)sock->user_data;
SilcBuffer buffer = packet->buffer;
- SilcChannelMessagePayload payload = NULL;
+ SilcMessagePayload payload = NULL;
SilcChannelID *id = NULL;
SilcChannelEntry channel;
SilcClientEntry client_entry;
SilcClientID *client_id = NULL;
unsigned char *message;
+ SilcUInt32 message_len;
SILC_LOG_DEBUG(("Start"));
all private keys and check what decrypts correctly. */
if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
/* Parse the channel message payload. This also decrypts the payload */
- payload = silc_channel_message_payload_parse(buffer->data, buffer->len,
- channel->channel_key,
- channel->hmac);
+ payload = silc_message_payload_parse(buffer->data, buffer->len, FALSE,
+ FALSE, channel->channel_key,
+ channel->hmac);
/* If decryption failed and we have just performed channel key rekey
we will use the old key in decryption. If that fails too then we
goto out;
}
- payload = silc_channel_message_payload_parse(buffer->data, buffer->len,
- channel->old_channel_key,
- channel->old_hmac);
+ payload = silc_message_payload_parse(buffer->data, buffer->len,
+ FALSE, FALSE,
+ channel->old_channel_key,
+ channel->old_hmac);
if (!payload) {
goto out;
}
silc_dlist_start(channel->private_keys);
while ((entry = silc_dlist_get(channel->private_keys)) != SILC_LIST_END) {
- /* Parse the channel message payload. This also decrypts the payload */
- payload = silc_channel_message_payload_parse(buffer->data, buffer->len,
- entry->cipher,
- entry->hmac);
+ /* Parse the message payload. This also decrypts the payload */
+ payload = silc_message_payload_parse(buffer->data, buffer->len,
+ FALSE, FALSE,
+ entry->cipher, entry->hmac);
if (payload)
break;
}
/* Find client entry */
client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry || !client_entry->nickname) {
+ if (!client_entry || !client_entry->nickname ||
+ !silc_client_on_channel(channel, client_entry)) {
/* Resolve the client info */
SilcChannelClientResolve res = silc_calloc(1, sizeof(*res));
res->payload = payload;
res->channel_id = id;
- silc_client_get_client_by_id_resolve(client, conn, client_id,
+ silc_client_get_client_by_id_resolve(client, conn, client_id, NULL,
silc_client_channel_message_cb,
res);
payload = NULL;
goto out;
}
- if (!silc_client_on_channel(channel, client_entry)) {
- SILC_LOG_WARNING(("Received channel message from client not on channel"));
- goto out;
- }
-
- message = silc_channel_message_get_data(payload, NULL);
+ message = silc_message_get_data(payload, &message_len);
/* Pass the message to application */
client->internal->ops->channel_message(
- client, conn, client_entry, channel,
- silc_channel_message_get_flags(payload),
- message);
+ client, conn, client_entry, channel, payload,
+ silc_message_get_flags(payload),
+ message, message_len);
out:
silc_free(id);
silc_free(client_id);
if (payload)
- silc_channel_message_payload_free(payload);
+ silc_message_payload_free(payload);
}
/* Timeout callback that is called after a short period of time after the
currently it is not expected that the SKE key material would be used
as channel private key. However, this API allows it. */
-int silc_client_add_channel_private_key(SilcClient client,
+bool silc_client_add_channel_private_key(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
const char *name,
unsigned char hash[32];
SilcSKEKeyMaterial *keymat;
+ assert(client && channel);
+
if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY))
return FALSE;
/* Produce the key material */
keymat = silc_calloc(1, sizeof(*keymat));
if (silc_ske_process_key_material_data(key, key_len, 16, 256, 16,
- client->internal->md5hash, keymat)
+ client->sha1hash, keymat)
!= SILC_SKE_STATUS_OK)
return FALSE;
after calling this to protect the channel messages. Returns FALSE on
on error, TRUE otherwise. */
-int silc_client_del_channel_private_keys(SilcClient client,
+bool silc_client_del_channel_private_keys(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel)
{
SilcChannelPrivateKey entry;
+ assert(client && channel);
+
if (!channel->private_keys)
return FALSE;
old channel key is used hereafter to protect the channel messages. This
returns FALSE on error, TRUE otherwise. */
-int silc_client_del_channel_private_key(SilcClient client,
+bool silc_client_del_channel_private_key(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
SilcChannelPrivateKey key)
{
SilcChannelPrivateKey entry;
+ assert(client && channel);
+
if (!channel->private_keys)
return FALSE;
SilcChannelPrivateKey *keys = NULL, entry;
SilcUInt32 count = 0;
+ assert(client && channel);
+
if (!channel->private_keys)
return NULL;
SilcChannelEntry channel,
SilcChannelPrivateKey key)
{
+ assert(client && channel);
channel->curr_key = key;
}
projects / silc.git / blobdiff