SilcChannelPrivateKey key,
SilcMessageFlags flags,
unsigned char *data,
- uint32 data_len,
+ SilcUInt32 data_len,
int force_send)
{
int i;
SilcSocketConnection sock = conn->sock;
SilcBuffer payload;
SilcPacketContext packetdata;
+ const SilcBufferStruct packet;
SilcCipher cipher;
SilcHmac hmac;
unsigned char *id_string;
- uint32 iv_len;
+ SilcUInt32 iv_len;
int block_len;
+ SilcChannelUser chu;
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) {
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);
+ silc_hash_make(client->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);
+ channel->iv, cipher, hmac,
+ client->rng);
/* Get data used in packet header encryption, keys and stuff. */
cipher = conn->send_key;
/* Set the packet context pointers. The destination ID is always
the Channel ID of the channel. Server and router will handle the
distribution of the packet. */
+ data = payload->data;
+ data_len = payload->len;
packetdata.flags = 0;
packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
packetdata.src_id = conn->local_id_data;
packetdata.dst_id = id_string;
packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
packetdata.dst_id_type = SILC_ID_CHANNEL;
- packetdata.truelen = payload->len + SILC_PACKET_HEADER_LEN +
+ data_len = SILC_PACKET_DATALEN(data_len, SILC_PACKET_HEADER_LEN +
+ packetdata.src_id_len +
+ 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);
- /* Prepare outgoing data buffer for packet sending */
- silc_packet_send_prepare(sock,
- SILC_PACKET_HEADER_LEN +
- packetdata.src_id_len +
- packetdata.dst_id_len,
- packetdata.padlen,
- payload->len);
-
- packetdata.buffer = sock->outbuf;
-
- /* Put the channel message payload to the outgoing data buffer */
- silc_buffer_put(sock->outbuf, payload->data, payload->len);
-
/* Create the outgoing packet */
- silc_packet_assemble(&packetdata, cipher);
+ if (!silc_packet_assemble(&packetdata, client->rng, cipher, hmac, sock,
+ data, data_len, (const SilcBuffer)&packet)) {
+ SILC_LOG_ERROR(("Error assembling packet"));
+ goto out;
+ }
/* 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++,
- sock->outbuf, SILC_PACKET_HEADER_LEN +
+ (SilcBuffer)&packet, SILC_PACKET_HEADER_LEN +
packetdata.src_id_len + packetdata.dst_id_len +
packetdata.padlen);
- SILC_LOG_HEXDUMP(("Packet to channel, len %d", sock->outbuf->len),
- sock->outbuf->data, sock->outbuf->len);
+ SILC_LOG_HEXDUMP(("Packet to channel, len %d", packet.len),
+ packet.data, packet.len);
/* Now actually send the packet */
silc_client_packet_send_real(client, sock, force_send);
+
+ out:
silc_buffer_free(payload);
silc_free(id_string);
}
static void silc_client_channel_message_cb(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- uint32 clients_count,
+ SilcUInt32 clients_count,
void *context)
{
SilcChannelClientResolve res = (SilcChannelClientResolve)context;
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_channel_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);
+ message, message_len);
}
out:
SilcClientEntry client_entry;
SilcClientID *client_id = NULL;
unsigned char *message;
+ SilcUInt32 message_len;
SILC_LOG_DEBUG(("Start"));
/* 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_channel_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);
+ message, message_len);
out:
silc_free(id);
SilcChannelEntry channel)
{
unsigned char *id_string, *key, *cipher, *hmac, hash[32];
- uint32 tmp_len;
+ SilcUInt32 tmp_len;
SilcChannelID *id;
SilcChannelKeyPayload payload;
int silc_client_add_channel_private_key(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
+ const char *name,
char *cipher,
char *hmac,
unsigned char *key,
- uint32 key_len)
+ SilcUInt32 key_len)
{
SilcChannelPrivateKey entry;
unsigned char hash[32];
/* 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->md5hash, keymat)
!= SILC_SKE_STATUS_OK)
return FALSE;
/* Save the key */
entry = silc_calloc(1, sizeof(*entry));
+ entry->name = name ? strdup(name) : NULL;
entry->key = silc_memdup(keymat->send_enc_key, keymat->enc_key_len / 8);
entry->key_len = keymat->enc_key_len / 8;
silc_dlist_del(channel->private_keys, entry);
memset(entry->key, 0, entry->key_len);
silc_free(entry->key);
+ silc_free(entry->name);
silc_cipher_free(entry->cipher);
silc_hmac_free(entry->hmac);
silc_free(entry);
silc_dlist_del(channel->private_keys, entry);
memset(entry->key, 0, entry->key_len);
silc_free(entry->key);
+ silc_free(entry->name);
silc_cipher_free(entry->cipher);
silc_hmac_free(entry->hmac);
silc_free(entry);
silc_client_list_channel_private_keys(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
- uint32 *key_count)
+ SilcUInt32 *key_count)
{
SilcChannelPrivateKey *keys = NULL, entry;
- uint32 count = 0;
+ SilcUInt32 count = 0;
if (!channel->private_keys)
return NULL;
/* Frees the SilcChannelPrivateKey array. */
void silc_client_free_channel_private_keys(SilcChannelPrivateKey *keys,
- uint32 key_count)
+ SilcUInt32 key_count)
{
silc_free(keys);
}
+/* Sets the `key' to be used as current channel private key on the
+ `channel'. Packet sent after calling this function will be secured
+ with `key'. */
+
+void silc_client_current_channel_private_key(SilcClient client,
+ SilcClientConnection conn,
+ SilcChannelEntry channel,
+ SilcChannelPrivateKey key)
+{
+ channel->curr_key = key;
+}
+
/* Returns the SilcChannelUser entry if the `client_entry' is joined on the
channel indicated by the `channel'. NULL if client is not joined on
the channel. */