client_notify.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2001 Pekka Riikonen
+ Copyright (C) 1997 - 2006 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
*/
/* $Id$ */
-/* This file includes the Notify packet handling. Notify packets are
- important packets sent by the server. They tell different things to the
- client such as nick changes, mode changes etc. */
-#include "clientlibincludes.h"
+#include "silc.h"
+#include "silcclient.h"
#include "client_internal.h"
-/* Called when notify is received and some async operation (such as command)
- is required before processing the notify message. This calls again the
- silc_client_notify_by_server and reprocesses the original notify packet. */
+/************************** Types and definitions ***************************/
+
+#define NOTIFY conn->client->internal->ops->notify
+
+/************************ Static utility functions **************************/
+
+/* Entry resolving callback. This will continue processing the notify. */
-static void silc_client_notify_by_server_pending(void *context, void *context2)
+static void silc_client_notify_resolved(SilcClient client,
+ SilcClientConnection conn,
+ SilcStatus status,
+ SilcDList entries,
+ void *context)
{
- SilcPacketContext *p = (SilcPacketContext *)context;
- silc_client_notify_by_server(p->context, p->sock, p);
- silc_socket_free(p->sock);
+ /* If no entries found, just finish the notify processing, a silent error */
+ if (!entries)
+ silc_fsm_next(context, silc_client_notify_processed);
+
+ /* Continue processing the notify */
+ SILC_FSM_CALL_CONTINUE_SYNC(context);
}
-/* Destructor for the pending command callback */
+/********************************* Notify ***********************************/
+
+/* Process received notify packet */
-static void silc_client_notify_by_server_destructor(void *context)
+SILC_FSM_STATE(silc_client_notify)
{
- silc_packet_context_free((SilcPacketContext *)context);
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload;
+
+ payload = silc_notify_payload_parse(silc_buffer_data(&packet->buffer),
+ silc_buffer_len(&packet->buffer));
+ if (!payload) {
+ SILC_LOG_DEBUG(("Malformed notify payload"));
+ silc_packet_free(packet);
+ return SILC_FSM_FINISH;
+ }
+
+ if (!silc_notify_get_args(payload)) {
+ SILC_LOG_DEBUG(("Malformed notify"));
+ silc_notify_payload_free(payload);
+ silc_packet_free(packet);
+ return SILC_FSM_FINISH;
+ }
+
+ /* Save notify payload to packet context during processing */
+ packet->next = (void *)payload;
+
+ /* Process the notify */
+ switch (silc_notify_get_type(payload)) {
+
+ case SILC_NOTIFY_TYPE_NONE:
+ /** NONE */
+ silc_fsm_next(fsm, silc_client_notify_none);
+ break;
+
+ case SILC_NOTIFY_TYPE_INVITE:
+ /** INVITE */
+ silc_fsm_next(fsm, silc_client_notify_invite);
+ break;
+
+ case SILC_NOTIFY_TYPE_JOIN:
+ /** JOIN */
+ silc_fsm_next(fsm, silc_client_notify_join);
+ break;
+
+ case SILC_NOTIFY_TYPE_LEAVE:
+ /** LEAVE */
+ silc_fsm_next(fsm, silc_client_notify_leave);
+ break;
+
+ case SILC_NOTIFY_TYPE_SIGNOFF:
+ /** SIGNOFF */
+ silc_fsm_next(fsm, silc_client_notify_signoff);
+ break;
+
+ case SILC_NOTIFY_TYPE_TOPIC_SET:
+ /** TOPIC_SET */
+ silc_fsm_next(fsm, silc_client_notify_topic_set);
+ break;
+
+ case SILC_NOTIFY_TYPE_NICK_CHANGE:
+ /** NICK_CHANGE */
+ silc_fsm_next(fsm, silc_client_notify_nick_change);
+ break;
+
+ case SILC_NOTIFY_TYPE_CMODE_CHANGE:
+ /** CMODE_CHANGE */
+ silc_fsm_next(fsm, silc_client_notify_cmode_change);
+ break;
+
+ case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
+ /** CUMODE_CHANGE */
+ silc_fsm_next(fsm, silc_client_notify_cumode_change);
+ break;
+
+ case SILC_NOTIFY_TYPE_MOTD:
+ /** MOTD */
+ silc_fsm_next(fsm, silc_client_notify_motd);
+ break;
+
+ case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
+ /** CHANNEL_CHANGE */
+ silc_fsm_next(fsm, silc_client_notify_channel_change);
+ break;
+
+ case SILC_NOTIFY_TYPE_KICKED:
+ /** KICKED */
+ silc_fsm_next(fsm, silc_client_notify_kicked);
+ break;
+
+ case SILC_NOTIFY_TYPE_KILLED:
+ /** KILLED */
+ silc_fsm_next(fsm, silc_client_notify_killed);
+ break;
+
+ case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
+ /** SERVER_SIGNOFF */
+ silc_fsm_next(fsm, silc_client_notify_server_signoff);
+ break;
+
+ case SILC_NOTIFY_TYPE_ERROR:
+ /** ERROR */
+ silc_fsm_next(fsm, silc_client_notify_error);
+ break;
+
+ case SILC_NOTIFY_TYPE_WATCH:
+ /** WATCH */
+ silc_fsm_next(fsm, silc_client_notify_watch);
+ break;
+
+ default:
+ /** Unknown notify */
+ silc_notify_payload_free(payload);
+ silc_packet_free(packet);
+ return SILC_FSM_FINISH;
+ break;
+ }
+
+ return SILC_FSM_YIELD;
}
-/* Resolve client information from server by Client ID. */
+/* Notify processed, finish the packet processing thread */
-static void silc_client_notify_by_server_resolve(SilcClient client,
- SilcClientConnection conn,
- SilcPacketContext *packet,
- SilcClientID *client_id)
+SILC_FSM_STATE(silc_client_notify_processed)
{
- SilcPacketContext *p = silc_packet_context_dup(packet);
- SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
-
- p->context = (void *)client;
- p->sock = silc_socket_dup(conn->sock);
-
- silc_client_send_command(client, conn, SILC_COMMAND_WHOIS, ++conn->cmd_ident,
- 1, 3, idp->data, idp->len);
- silc_client_command_pending(conn, SILC_COMMAND_WHOIS, conn->cmd_ident,
- silc_client_notify_by_server_destructor,
- silc_client_notify_by_server_pending, p);
- silc_buffer_free(idp);
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ silc_notify_payload_free(payload);
+ silc_packet_free(packet);
+ return SILC_FSM_FINISH;
}
-/* Received notify message from server */
+/********************************** NONE ************************************/
-void silc_client_notify_by_server(SilcClient client,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+SILC_FSM_STATE(silc_client_notify_none)
{
- SilcBuffer buffer = packet->buffer;
- SilcClientConnection conn = (SilcClientConnection)sock->user_data;
- SilcNotifyPayload payload;
- SilcNotifyType type;
- SilcArgumentPayload args;
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+
+ /* Notify application */
+ NOTIFY(client, conn, type, silc_argument_get_arg_type(args, 1, NULL));
+
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/********************************* INVITE ***********************************/
- SilcIDPayload idp;
- SilcClientID *client_id = NULL;
- SilcChannelID *channel_id = NULL;
- SilcServerID *server_id = NULL;
+/* Someone invite me to a channel */
+
+SILC_FSM_STATE(silc_client_notify_invite)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
SilcClientEntry client_entry;
- SilcClientEntry client_entry2;
- SilcChannelEntry channel;
- SilcChannelUser chu;
- SilcServerEntry server;
- SilcIDCacheEntry id_cache = NULL;
+ SilcChannelEntry channel = NULL;
unsigned char *tmp;
- uint32 tmp_len, mode;
+ SilcUInt32 tmp_len;
+ SilcID id;
- payload = silc_notify_payload_parse(buffer);
- if (!payload)
+ SILC_LOG_DEBUG(("Notify: INVITE"));
+
+ /* Get Channel ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
- type = silc_notify_get_type(payload);
- args = silc_notify_get_args(payload);
- if (!args)
+ /* Get the channel name */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
goto out;
- switch(type) {
- case SILC_NOTIFY_TYPE_NONE:
- /* Notify application */
- client->ops->notify(client, conn, type,
- silc_argument_get_arg_type(args, 1, NULL));
- break;
+ /* Get the channel entry */
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
- case SILC_NOTIFY_TYPE_INVITE:
- /*
- * Someone invited me to a channel. Find Client and Channel entries
- * for the application.
- */
-
- /* Get Channel ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ /* Get sender Client ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!channel_id)
- goto out;
+ /* Find Client entry and if not found query it */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
- /* Get the channel entry */
- channel = NULL;
- if (silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- channel = (SilcChannelEntry)id_cache->context;
+ /* Notify application */
+ NOTIFY(client, conn, type, channel, tmp, client_entry);
- /* Get sender Client ID */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (!tmp)
- goto out;
+ silc_client_unref_client(client, conn, client_entry);
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- /* Find Client entry and if not found query it */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry) {
- silc_client_notify_by_server_resolve(client, conn, packet, client_id);
- goto out;
- }
+/********************************** JOIN ************************************/
- /* Get the channel name */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
+/* Someone joined a channel */
- /* Notify application */
- client->ops->notify(client, conn, type, channel, tmp, client_entry);
- break;
+SILC_FSM_STATE(silc_client_notify_join)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry;
+ SilcChannelEntry channel = NULL;
+ SilcID id;
- case SILC_NOTIFY_TYPE_JOIN:
- /*
- * Someone has joined to a channel. Get their ID and nickname and
- * cache them for later use.
- */
+ SILC_LOG_DEBUG(("Notify: JOIN"));
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ /* Get Channel ID */
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Get channel entry */
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
- /* Find Client entry and if not found query it */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry) {
- silc_client_notify_by_server_resolve(client, conn, packet, client_id);
- goto out;
- }
+ /* Get Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* If nickname or username hasn't been resolved, do so */
- if (!client_entry->nickname || !client_entry->username) {
- silc_client_notify_by_server_resolve(client, conn, packet, client_id);
- goto out;
- }
+ /* Find Client entry and if not found query it */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0] ||
+ !client_entry->username[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
- /* Get Channel ID */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
+ if (client_entry != conn->local_entry)
+ silc_client_nickname_format(client, conn, client_entry);
- channel_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!channel_id)
- goto out;
+ /* Join the client to channel */
+ silc_client_add_to_channel(channel, client_entry, 0);
- /* Get channel entry */
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
+ /* Notify application. */
+ NOTIFY(client, conn, type, client_entry, channel);
- channel = (SilcChannelEntry)id_cache->context;
+ silc_client_unref_client(client, conn, client_entry);
- /* Add client to channel */
- if (client_entry != conn->local_entry) {
- chu = silc_calloc(1, sizeof(*chu));
- chu->client = client_entry;
- silc_list_add(channel->clients, chu);
- }
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- /* XXX add support for multiple same nicks on same channel. Check
- for them here */
+/********************************** LEAVE ***********************************/
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, client_entry, channel);
- break;
+/* Someone left a channel */
- case SILC_NOTIFY_TYPE_LEAVE:
- /*
- * Someone has left a channel. We will remove it from the channel but
- * we'll keep it in the cache in case we'll need it later.
- */
-
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+SILC_FSM_STATE(silc_client_notify_leave)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL;
+ SilcChannelEntry channel = NULL;
+ SilcChannelUser chu;
+ SilcID id;
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ SILC_LOG_DEBUG(("Notify: LEAVE"));
- /* Find Client entry */
- client_entry =
- silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
+ /* Get channel entry */
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id.u.channel_id, sizeof(id.u.channel_id)))
+ goto out;
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
- /* Get channel entry */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- SILC_ID_CHANNEL);
- if (!channel_id)
- goto out;
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
-
- channel = (SilcChannelEntry)id_cache->context;
-
- /* Remove client from channel */
- silc_list_start(channel->clients);
- while ((chu = silc_list_get(channel->clients)) != SILC_LIST_END) {
- if (chu->client == client_entry) {
- silc_list_del(channel->clients, chu);
- silc_free(chu);
- break;
- }
- }
+ /* Get Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, client_entry, channel);
- break;
+ /* Find Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry)
+ goto out;
- case SILC_NOTIFY_TYPE_SIGNOFF:
- /*
- * Someone left SILC. We'll remove it from all channels and from cache.
- */
+ /* Remove client from channel */
+ chu = silc_client_on_channel(channel, client_entry);
+ if (chu) {
+ silc_hash_table_del(client_entry->channels, channel);
+ silc_hash_table_del(channel->user_list, client_entry);
+ silc_free(chu);
+ }
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+#if 0 /* Kind of useless, server will return error if client keeps using
+ non-existing client, and the entry is removed then. */
+ /* Some client implementations actually quit network by first doing
+ LEAVE and then immediately SIGNOFF. We'll check for this by doing
+ check for the client after 5 - 34 seconds. If it is not valid after
+ that we'll remove the client from cache. */
+ if (!silc_hash_table_count(client_entry->channels)) {
+ SilcClientNotifyResolve res = silc_calloc(1, sizeof(*res));
+ res->context = client;
+ res->sock = silc_socket_dup(conn->sock);
+ res->packet = silc_id_dup(client_id, SILC_ID_CLIENT);
+ silc_schedule_task_add(client->schedule, conn->sock->sock,
+ silc_client_notify_check_client, res,
+ (5 + (silc_rng_get_rn16(client->rng) % 29)),
+ 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
+ }
+#endif
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Notify application. */
+ NOTIFY(client, conn, type, client_entry, channel);
- /* Find Client entry */
- client_entry =
- silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
+ silc_client_unref_client(client, conn, client_entry);
- /* Remove from all channels */
- silc_client_remove_from_channels(client, conn, client_entry);
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- /* Remove from cache */
- silc_idcache_del_by_context(conn->client_cache, client_entry);
+/********************************* SIGNOFF **********************************/
- /* Get signoff message */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (tmp_len > 128)
- tmp = NULL;
+/* Someone quit SILC network */
- /* Notify application */
- client->ops->notify(client, conn, type, client_entry, tmp);
-
- /* Free data */
- if (client_entry->nickname)
- silc_free(client_entry->nickname);
- if (client_entry->server)
- silc_free(client_entry->server);
- if (client_entry->id)
- silc_free(client_entry->id);
- if (client_entry->send_key)
- silc_cipher_free(client_entry->send_key);
- if (client_entry->receive_key)
- silc_cipher_free(client_entry->receive_key);
- break;
+SILC_FSM_STATE(silc_client_notify_signoff)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len;
+ SilcID id;
- case SILC_NOTIFY_TYPE_TOPIC_SET:
- /*
- * Someone set the topic on a channel.
- */
+ SILC_LOG_DEBUG(("Notify: SIGNOFF"));
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ /* Get Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Find Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry)
+ goto out;
- /* Find Client entry */
- client_entry =
- silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
+ /* Get signoff message */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (tmp_len > 128)
+ tmp[128] = '\0';
- /* Get topic */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
+ /* Notify application */
+ NOTIFY(client, conn, type, client_entry, tmp);
- /* Get channel entry */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- SILC_ID_CHANNEL);
- if (!channel_id)
- goto out;
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
+ /* Remove from all channels */
+ silc_client_remove_from_channels(client, conn, client_entry);
- channel = (SilcChannelEntry)id_cache->context;
+#if 0
+ /* Remove from cache */
+ silc_idcache_del_by_context(conn->internal->client_cache, client_entry);
+#endif
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, client_entry, tmp, channel);
- break;
+ /* Free data */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_del_client_entry(client, conn, client_entry);
- case SILC_NOTIFY_TYPE_NICK_CHANGE:
- /*
- * Someone changed their nickname. If we don't have entry for the new
- * ID we will query it and return here after it's done. After we've
- * returned we fetch the old entry and free it and notify the
- * application.
- */
-
- /* Get old Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ out:
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+/******************************** TOPIC_SET *********************************/
- /* Ignore my ID */
- if (SILC_ID_CLIENT_COMPARE(client_id, conn->local_id))
- break;
+/* Someone set topic on a channel */
- /* Find old Client entry */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
- silc_free(client_id);
+SILC_FSM_STATE(silc_client_notify_topic_set)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL;
+ SilcChannelEntry channel = NULL, channel_entry = NULL;
+ SilcServerEntry server = NULL;
+ void *entry;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len;
+ SilcID id;
- /* Get new Client ID */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
+ SILC_LOG_DEBUG(("Notify: TOPIC_SET"));
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Get channel entry */
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id.u.channel_id, sizeof(id.u.channel_id)))
+ goto out;
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
- /* Find Client entry and if not found resolve it */
- client_entry2 = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry2) {
- silc_client_notify_by_server_resolve(client, conn, packet, client_id);
- goto out;
+ /* Get ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Get topic */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
+ goto out;
+
+ if (id.type == SILC_ID_CLIENT) {
+ /* Find Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
}
+ entry = client_entry;
+ } else if (id.type == SILC_ID_SERVER) {
+ /* Find Server entry */
+ server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
+ if (!server) {
+ /** Resolve server */
+ SILC_FSM_CALL(silc_client_get_server_by_id_resolve(
+ client, conn, &id.u.server_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = server;
+ } else {
+ /* Find Channel entry */
+ channel_entry = silc_client_get_channel_by_id(client, conn,
+ &id.u.channel_id);
+ if (!channel_entry) {
+ /** Resolve channel */
+ SILC_FSM_CALL(silc_client_get_channel_by_id_resolve(
+ client, conn, &id.u.channel_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = channel_entry;
+ }
- /* Remove the old from cache */
- silc_idcache_del_by_context(conn->client_cache, client_entry);
-
- /* Replace old ID entry with new one on all channels. */
- silc_client_replace_from_channels(client, conn, client_entry,
- client_entry2);
-
- /* Notify application */
- client->ops->notify(client, conn, type, client_entry, client_entry2);
-
- /* Free data */
- if (client_entry->nickname)
- silc_free(client_entry->nickname);
- if (client_entry->server)
- silc_free(client_entry->server);
- if (client_entry->id)
- silc_free(client_entry->id);
- if (client_entry->send_key)
- silc_cipher_free(client_entry->send_key);
- if (client_entry->receive_key)
- silc_cipher_free(client_entry->receive_key);
- silc_free(client_entry);
- break;
+ silc_free(channel->topic);
+ channel->topic = silc_memdup(tmp, strlen(tmp));
- case SILC_NOTIFY_TYPE_CMODE_CHANGE:
- /*
- * Someone changed a channel mode
- */
+ /* Notify application. */
+ NOTIFY(client, conn, type, id.type, entry, channel->topic, channel);
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ if (client_entry)
+ silc_client_unref_client(client, conn, client_entry);
+ if (server)
+ silc_client_unref_server(client, conn, server);
+ if (channel_entry)
+ silc_client_unref_channel(client, conn, channel_entry);
- idp = silc_id_payload_parse_data(tmp, tmp_len);
- if (!idp)
- goto out;
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/****************************** NICK_CHANGE *********************************/
+
+/* Someone changed their nickname on a channel */
+
+SILC_FSM_STATE(silc_client_notify_nick_change)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL;
+ unsigned char *tmp, *nick, oldnick[128 + 1];
+ SilcUInt32 tmp_len;
+ SilcID id;
+
+ SILC_LOG_DEBUG(("Notify: NICK_CHANGE"));
+
+ /* Get ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Ignore my ID */
+ if (conn->local_id &&
+ SILC_ID_CLIENT_COMPARE(&id.u.client_id, conn->local_id))
+ goto out;
+
+ /* Find old Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+
+ /* Get new Client ID */
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Take the new nickname */
+ tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
+ if (!tmp)
+ goto out;
+
+ /* Check whether nickname changed at all. It is possible that nick
+ change notify is received but nickname didn't change, only the
+ ID changes. If Client ID hash match, nickname didn't change. */
+ if (SILC_ID_COMPARE_HASH(&client_entry->id, &id.u.client_id) &&
+ silc_utf8_strcasecmp(tmp, client_entry->nickname)) {
+ /* Nickname didn't change. Update only Client ID. We don't notify
+ application because nickname didn't change. */
+ silc_idcache_update(conn->internal->client_cache, client_entry,
+ &client_entry->id, &id.u.client_id, NULL, NULL, FALSE);
+ goto out;
+ }
+
+ /* Normalize nickname */
+ nick = silc_identifier_check(tmp, tmp_len, SILC_STRING_UTF8, 128, NULL);
+ if (!nick)
+ goto out;
+ /* Update nickname */
+ if (!silc_idcache_update(conn->internal->client_cache, client_entry,
+ NULL, NULL, client_entry->nickname_normalized,
+ nick, TRUE)) {
+ silc_free(nick);
+ goto out;
+ }
+ memcpy(oldnick, client_entry->nickname, sizeof(client_entry->nickname));
+ memcpy(client_entry->nickname, tmp, tmp_len);
+ client_entry->nickname_normalized = nick;
+ silc_client_nickname_format(client, conn, client_entry);
+
+ /* Notify application */
+ NOTIFY(client, conn, type, client_entry, client_entry->nickname, oldnick);
+
+ out:
+ /** Notify processed */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/****************************** CMODE_CHANGE ********************************/
+
+/* Someone changed channel mode */
+
+SILC_FSM_STATE(silc_client_notify_cmode_change)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL;
+ SilcChannelEntry channel = NULL, channel_entry = NULL;
+ SilcServerEntry server = NULL;
+ void *entry;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len, mode;
+ SilcID id;
+ char *passphrase, *cipher, *hmac;
+ SilcPublicKey founder_key = NULL;
+ SilcDList chpks = NULL;
+
+ SILC_LOG_DEBUG(("Notify: CMODE_CHANGE"));
+
+ /* Get channel entry */
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id.u.channel_id, sizeof(id.u.channel_id)))
+ goto out;
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
+
+ /* Get the mode */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
+ goto out;
+ SILC_GET32_MSB(mode, tmp);
+
+ /* Get ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ if (id.type == SILC_ID_CLIENT) {
/* Find Client entry */
- if (silc_id_payload_get_type(idp) == SILC_ID_CLIENT) {
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id) {
- silc_id_payload_free(idp);
- goto out;
- }
-
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry) {
- silc_id_payload_free(idp);
- goto out;
- }
- } else {
- server_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!server_id) {
- silc_id_payload_free(idp);
- goto out;
- }
-
- server = silc_client_get_server_by_id(client, conn, server_id);
- if (!server) {
- silc_id_payload_free(idp);
- silc_free(server_id);
- goto out;
- }
-
- /* Save the pointer to the client_entry pointer */
- client_entry = (SilcClientEntry)server;
- silc_free(server_id);
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = client_entry;
+ } else if (id.type == SILC_ID_SERVER) {
+ /* Find Server entry */
+ server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
+ if (!server) {
+ /** Resolve server */
+ SILC_FSM_CALL(silc_client_get_server_by_id_resolve(
+ client, conn, &id.u.server_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
}
+ entry = server;
+ } else {
+ /* Find Channel entry */
+ channel_entry = silc_client_get_channel_by_id(client, conn,
+ &id.u.channel_id);
+ if (!channel_entry) {
+ /** Resolve channel */
+ SILC_FSM_CALL(silc_client_get_channel_by_id_resolve(
+ client, conn, &id.u.channel_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = channel_entry;
+ }
- /* Get the mode */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp) {
- silc_id_payload_free(idp);
+ /* Get the channel founder key if it was set */
+ tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
+ if (tmp) {
+ if (!silc_public_key_payload_decode(tmp, tmp_len, &founder_key))
goto out;
+ if (!channel->founder_key) {
+ channel->founder_key = founder_key;
+ founder_key = NULL;
}
+ }
- SILC_GET32_MSB(mode, tmp);
+ /* Get the cipher */
+ cipher = silc_argument_get_arg_type(args, 3, &tmp_len);
- /* Get channel entry */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- SILC_ID_CHANNEL);
- if (!channel_id) {
- silc_id_payload_free(idp);
- goto out;
- }
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache)) {
- silc_id_payload_free(idp);
+ /* Get the hmac */
+ hmac = silc_argument_get_arg_type(args, 4, &tmp_len);
+ if (hmac) {
+ unsigned char hash[SILC_HASH_MAXLEN];
+ SilcHmac newhmac;
+
+ if (!silc_hmac_alloc(hmac, NULL, &newhmac))
goto out;
+
+ /* Get HMAC key from the old HMAC context, and update it to the new one */
+ tmp = (unsigned char *)silc_hmac_get_key(channel->internal.hmac, &tmp_len);
+ if (tmp) {
+ silc_hash_make(silc_hmac_get_hash(newhmac), tmp, tmp_len, hash);
+ silc_hmac_set_key(newhmac, hash,
+ silc_hash_len(silc_hmac_get_hash(newhmac)));
+ if (channel->internal.hmac)
+ silc_hmac_free(channel->internal.hmac);
+ channel->internal.hmac = newhmac;
+ memset(hash, 0, sizeof(hash));
}
+ }
- channel = (SilcChannelEntry)id_cache->context;
+ /* Get the passphrase if it was set */
+ passphrase = silc_argument_get_arg_type(args, 5, &tmp_len);
- /* Save the new mode */
- channel->mode = mode;
+ /* Get user limit */
+ tmp = silc_argument_get_arg_type(args, 8, &tmp_len);
+ if (tmp && tmp_len == 4)
+ SILC_GET32_MSB(channel->user_limit, tmp);
+ if (!(channel->mode & SILC_CHANNEL_MODE_ULIMIT))
+ channel->user_limit = 0;
- /* Get the hmac */
- tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
- if (tmp) {
- unsigned char hash[32];
+ /* Save the new mode */
+ channel->mode = mode;
- if (channel->hmac)
- silc_hmac_free(channel->hmac);
- if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
- goto out;
+ /* Get the channel public key that was added or removed */
+ tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
+ if (tmp)
+ chpks = silc_argument_list_parse_decoded(tmp, tmp_len,
+ SILC_ARGUMENT_PUBLIC_KEY);
- silc_hash_make(channel->hmac->hash, channel->key, channel->key_len / 8,
- hash);
- silc_hmac_set_key(channel->hmac, hash,
- silc_hash_len(channel->hmac->hash));
- memset(hash, 0, sizeof(hash));
- }
+ /* Notify application. */
+ NOTIFY(client, conn, type, id.type, entry, mode, cipher, hmac,
+ passphrase, channel->founder_key, chpks, channel);
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, silc_id_payload_get_type(idp),
- client_entry, mode, NULL, tmp, channel);
+ out:
+ if (founder_key)
+ silc_pkcs_public_key_free(founder_key);
+ if (chpks)
+ silc_argument_list_free(chpks, SILC_ARGUMENT_PUBLIC_KEY);
+ if (client_entry)
+ silc_client_unref_client(client, conn, client_entry);
+ if (server)
+ silc_client_unref_server(client, conn, server);
+ if (channel_entry)
+ silc_client_unref_channel(client, conn, channel_entry);
+ silc_client_unref_channel(client, conn, channel);
+
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- silc_id_payload_free(idp);
- break;
+/***************************** CUMODE_CHANGE ********************************/
- case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
- /*
- * Someone changed user's mode on a channel
- */
+/* Someone changed a user's mode on a channel */
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+SILC_FSM_STATE(silc_client_notify_cumode_change)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL, client_entry2 = NULL;
+ SilcChannelEntry channel = NULL, channel_entry = NULL;
+ SilcServerEntry server = NULL;
+ SilcChannelUser chu;
+ void *entry;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len, mode;
+ SilcID id, id2;
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ SILC_LOG_DEBUG(("Notify: CUMODE_CHANGE"));
+
+ /* Get channel entry */
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id.u.channel_id, sizeof(id.u.channel_id)))
+ goto out;
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
+
+ /* Get the mode */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
+ goto out;
+ SILC_GET32_MSB(mode, tmp);
+
+ /* Get ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+ if (id.type == SILC_ID_CLIENT) {
/* Find Client entry */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry) {
- silc_client_notify_by_server_resolve(client, conn, packet, client_id);
- goto out;
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = client_entry;
+ } else if (id.type == SILC_ID_SERVER) {
+ /* Find Server entry */
+ server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
+ if (!server) {
+ /** Resolve server */
+ SILC_FSM_CALL(silc_client_get_server_by_id_resolve(
+ client, conn, &id.u.server_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = server;
+ } else {
+ /* Find Channel entry */
+ channel_entry = silc_client_get_channel_by_id(client, conn,
+ &id.u.channel_id);
+ if (!channel_entry) {
+ /** Resolve channel */
+ SILC_FSM_CALL(silc_client_get_channel_by_id_resolve(
+ client, conn, &id.u.channel_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
}
+ entry = channel_entry;
+ }
- /* Get the mode */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
+ /* Get target Client ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id2, NULL))
+ goto out;
- SILC_GET32_MSB(mode, tmp);
+ /* Find target Client entry */
+ client_entry2 = silc_client_get_client_by_id(client, conn, &id2.u.client_id);
+ if (!client_entry2 || !client_entry2->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry2);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id2.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
- /* Get target Client ID */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (!tmp)
- goto out;
+ /* Save the mode */
+ chu = silc_client_on_channel(channel, client_entry2);
+ if (chu)
+ chu->mode = mode;
- silc_free(client_id);
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Notify application. */
+ NOTIFY(client, conn, type, id.type, entry, mode, client_entry2, channel);
- /* Find target Client entry */
- client_entry2 =
- silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry2)
- goto out;
+ out:
+ silc_client_unref_client(client, conn, client_entry2);
+ if (client_entry)
+ silc_client_unref_client(client, conn, client_entry);
+ if (server)
+ silc_client_unref_server(client, conn, server);
+ if (channel_entry)
+ silc_client_unref_channel(client, conn, channel_entry);
+ silc_client_unref_channel(client, conn, channel);
+
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- /* Get channel entry */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- SILC_ID_CHANNEL);
- if (!channel_id)
- goto out;
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
-
- channel = (SilcChannelEntry)id_cache->context;
-
- /* Save the mode */
- silc_list_start(channel->clients);
- while ((chu = silc_list_get(channel->clients)) != SILC_LIST_END) {
- if (chu->client == client_entry) {
- chu->mode = mode;
- break;
- }
+/********************************* MOTD *************************************/
+
+/* Received Message of the day */
+
+SILC_FSM_STATE(silc_client_notify_motd)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ unsigned char *tmp;
+ SilcUInt32 tmp_len;
+
+ SILC_LOG_DEBUG(("Notify: MOTD"));
+
+ /* Get motd */
+ tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
+ if (!tmp)
+ goto out;
+
+ /* Notify application */
+ NOTIFY(client, conn, type, tmp);
+
+ out:
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/**************************** CHANNEL CHANGE ********************************/
+
+/* Router has enforced a new ID to a channel, change it */
+
+SILC_FSM_STATE(silc_client_notify_channel_change)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcChannelEntry channel = NULL;
+ SilcID id;
+
+ SILC_LOG_DEBUG(("Notify: CHANNEL_CHANGE"));
+
+ /* Get the old ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Get the channel entry */
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
+
+ /* Get the new ID */
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Replace the Channel ID */
+ if (!silc_client_replace_channel_id(client, conn, channel, &id.u.channel_id))
+ goto out;
+
+ /* Notify application */
+ NOTIFY(client, conn, type, channel, channel);
+
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/******************************** KICKED ************************************/
+
+/* Some client was kicked from a channel */
+
+SILC_FSM_STATE(silc_client_notify_kicked)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry, client_entry2;
+ SilcChannelEntry channel = NULL;
+ SilcChannelUser chu;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len;
+ SilcID id;
+
+ SILC_LOG_DEBUG(("Notify: KICKED"));
+
+ /* Get Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Find Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry)
+ goto out;
+
+ /* Get channel entry */
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id.u.channel_id, sizeof(id.u.channel_id)))
+ goto out;
+ channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+ if (!channel)
+ goto out;
+
+ /* Get kicker's Client ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ /* Find kicker's client entry and if not found resolve it */
+ client_entry2 = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry2 || !client_entry2->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry2);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+
+ /* Get comment */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+
+ /* Remove kicked client from channel */
+ if (client_entry != conn->local_entry) {
+ chu = silc_client_on_channel(channel, client_entry);
+ if (chu) {
+ silc_hash_table_del(client_entry->channels, channel);
+ silc_hash_table_del(channel->user_list, client_entry);
+ silc_free(chu);
}
+ }
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, client_entry, mode,
- client_entry2, channel);
- break;
+ /* Notify application. */
+ NOTIFY(client, conn, type, client_entry, tmp, client_entry2, channel);
- case SILC_NOTIFY_TYPE_MOTD:
- /*
- * Received Message of the day
- */
+ /* If I was kicked from channel, remove the channel */
+ if (client_entry == conn->local_entry) {
+ if (conn->current_channel == channel)
+ conn->current_channel = NULL;
+ silc_client_del_channel(client, conn, channel);
+ }
- /* Get motd */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
-
- /* Notify application */
- client->ops->notify(client, conn, type, tmp);
- break;
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry2);
- case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
- /*
- * Router has enforced a new ID to a channel. Let's change the old
- * ID to the one provided here.
- */
-
- /* Get the old ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!channel_id)
- goto out;
-
- /* Get the channel entry */
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
+ out:
+ /** Notify processed */
+ silc_client_unref_channel(client, conn, channel);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- channel = (SilcChannelEntry)id_cache->context;
+/******************************** KILLED ************************************/
- SILC_LOG_DEBUG(("Old Channel ID id(%s)",
- silc_id_render(channel->id, SILC_ID_CHANNEL)));
+/* Some client was killed from the network */
- /* Free the old ID */
- silc_free(channel->id);
+SILC_FSM_STATE(silc_client_notify_killed)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL, client_entry2 = NULL;
+ SilcChannelEntry channel_entry = NULL;
+ SilcServerEntry server = NULL;
+ void *entry;
+ char *comment;
+ SilcUInt32 comment_len;
+ SilcID id;
+
+ SILC_LOG_DEBUG(("Notify: KILLED"));
+
+ /* Get Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* Get the new ID */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
- channel->id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!channel->id)
- goto out;
+ /* Find Client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry)
+ goto out;
- SILC_LOG_DEBUG(("New Channel ID id(%s)",
- silc_id_render(channel->id, SILC_ID_CHANNEL)));
+ /* Get comment */
+ comment = silc_argument_get_arg_type(args, 2, &comment_len);
- /* Remove the old cache entry and create a new one */
- silc_idcache_del_by_context(conn->channel_cache, channel);
- silc_idcache_add(conn->channel_cache, channel->channel_name,
- channel->id, channel, FALSE);
+ /* Get killer's ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* Notify application */
- client->ops->notify(client, conn, type, channel, channel);
- break;
+ if (id.type == SILC_ID_CLIENT) {
+ /* Find Client entry */
+ client_entry2 = silc_client_get_client_by_id(client, conn,
+ &id.u.client_id);
+ if (!client_entry2 || !client_entry2->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry2);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = client_entry2;
+ } else if (id.type == SILC_ID_SERVER) {
+ /* Find Server entry */
+ server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
+ if (!server) {
+ /** Resolve server */
+ SILC_FSM_CALL(silc_client_get_server_by_id_resolve(
+ client, conn, &id.u.server_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = server;
+ } else {
+ /* Find Channel entry */
+ channel_entry = silc_client_get_channel_by_id(client, conn,
+ &id.u.channel_id);
+ if (!channel_entry) {
+ /** Resolve channel */
+ SILC_FSM_CALL(silc_client_get_channel_by_id_resolve(
+ client, conn, &id.u.channel_id,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
+ entry = channel_entry;
+ }
- case SILC_NOTIFY_TYPE_KICKED:
- /*
- * A client (maybe me) was kicked from a channel
- */
+ /* Notify application. */
+ NOTIFY(client, conn, type, client_entry, comment, id.type, entry);
+
+ /* Delete the killed client */
+ if (client_entry != conn->local_entry)
+ silc_client_del_client(client, conn, client_entry);
+
+ out:
+ silc_client_unref_client(client, conn, client_entry);
+ if (client_entry2)
+ silc_client_unref_client(client, conn, client_entry2);
+ if (server)
+ silc_client_unref_server(client, conn, server);
+ if (channel_entry)
+ silc_client_unref_channel(client, conn, channel_entry);
+
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/**************************** SERVER SIGNOFF ********************************/
+
+/* Some server quit SILC network. Remove its clients from channels. */
+
+SILC_FSM_STATE(silc_client_notify_server_signoff)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry;
+ SilcDList clients;
+ SilcID id;
+ int i;
+
+ SILC_LOG_DEBUG(("Notify: SIGNOFF"));
+
+ clients = silc_dlist_init();
+ if (!clients)
+ goto out;
+ for (i = 1; i < silc_argument_get_arg_num(args); i++) {
/* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
+ if (!silc_argument_get_decoded(args, i + 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+ /* Get the client entry */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (client_entry)
+ silc_dlist_add(clients, client_entry);
+ }
- /* Find Client entry */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
+ /* Notify application. We don't keep server entries so the server
+ entry is returned as NULL. The client's are returned as list. */
+ NOTIFY(client, conn, type, NULL, clients);
+
+ /* Delete the clients */
+ silc_dlist_start(clients);
+ while ((client_entry = silc_dlist_get(clients)))
+ silc_client_del_client(client, conn, client_entry);
+
+ out:
+ /** Notify processed */
+ silc_client_list_free(client, conn, clients);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
+
+/******************************** ERROR *************************************/
+
+/* Some error occurred */
+
+SILC_FSM_STATE(silc_client_notify_error)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len;
+ SilcID id;
+ SilcStatus error;
- /* Get channel entry */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- SILC_ID_CHANNEL);
- if (!channel_id)
+ /* Get error */
+ tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
+ if (!tmp && tmp_len != 1)
+ goto out;
+ error = (SilcStatus)tmp[0];
+
+ SILC_LOG_DEBUG(("Notify: ERROR (%d)", error));
+
+ /* Handle the error */
+ if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID) {
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
goto out;
- if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
- &id_cache))
- break;
-
- channel = (SilcChannelEntry)id_cache->context;
-
- /* Get comment */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
-
- /* Notify application. The channel entry is sent last as this notify
- is for channel but application don't know it from the arguments
- sent by server. */
- client->ops->notify(client, conn, type, client_entry, tmp, channel);
-
- /* If I was kicked from channel, remove the channel */
- if (client_entry == conn->local_entry) {
- if (conn->current_channel == channel)
- conn->current_channel = NULL;
- silc_idcache_del_by_id(conn->channel_cache, channel->id);
- silc_free(channel->channel_name);
- silc_free(channel->id);
- silc_free(channel->key);
- silc_cipher_free(channel->channel_key);
- silc_free(channel);
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (client_entry) {
+ silc_client_del_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry);
}
- break;
+ }
- case SILC_NOTIFY_TYPE_KILLED:
- /*
- * A client (maybe me) was killed from the network.
- */
+ /* Notify application. */
+ NOTIFY(client, conn, type, error);
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
+ out:
+ /** Notify processed */
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
+}
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
+/******************************** WATCH *************************************/
- /* Find Client entry */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (!client_entry)
- goto out;
+/* Received notify about some client we are watching */
- /* Get comment */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
-
- /* Notify application. */
- client->ops->notify(client, conn, type, client_entry, tmp);
-
- if (client_entry != conn->local_entry) {
- /* Remove client from all channels */
- silc_client_remove_from_channels(client, conn, client_entry);
- silc_idcache_del_by_context(conn->client_cache, client_entry);
- if (client_entry->nickname)
- silc_free(client_entry->nickname);
- if (client_entry->server)
- silc_free(client_entry->server);
- if (client_entry->id)
- silc_free(client_entry->id);
- if (client_entry->send_key)
- silc_cipher_free(client_entry->send_key);
- if (client_entry->receive_key)
- silc_cipher_free(client_entry->receive_key);
- silc_free(client_entry);
- }
+SILC_FSM_STATE(silc_client_notify_watch)
+{
+ SilcClientConnection conn = fsm_context;
+ SilcClient client = conn->client;
+ SilcPacket packet = state_context;
+ SilcNotifyPayload payload = (SilcNotifyPayload)packet->next;
+ SilcNotifyType type = silc_notify_get_type(payload);
+ SilcArgumentPayload args = silc_notify_get_args(payload);
+ SilcClientEntry client_entry = NULL;
+ SilcNotifyType notify = 0;
+ SilcBool del_client = FALSE;
+ unsigned char *pk, *tmp;
+ SilcUInt32 mode, pk_len, tmp_len;
+ SilcPublicKey public_key = NULL;
+ SilcID id;
+
+ SILC_LOG_DEBUG(("Notify: WATCH"));
+
+ /* Get sender Client ID */
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- break;
-
- case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
- {
- /*
- * A server quit the SILC network and some clients must be removed
- * from channels as they quit as well.
- */
- SilcClientEntry *clients = NULL;
- uint32 clients_count = 0;
- int i;
-
- for (i = 1; i < silc_argument_get_arg_num(args); i++) {
- /* Get Client ID */
- tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
- if (tmp) {
- client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
- goto out;
-
- /* Get the client entry */
- client_entry = silc_client_get_client_by_id(client, conn, client_id);
- if (client_entry) {
- clients = silc_realloc(clients, sizeof(*clients) *
- (clients_count + 1));
- clients[clients_count] = client_entry;
- clients_count++;
- }
- silc_free(client_id);
- }
- }
- client_id = NULL;
-
- /* Notify application. We don't keep server entries so the server
- entry is returned as NULL. The client's are returned as array
- of SilcClientEntry pointers. */
- client->ops->notify(client, conn, type, NULL, clients, clients_count);
-
- for (i = 0; i < clients_count; i++) {
- /* Remove client from all channels */
- client_entry = clients[i];
- if (client_entry == conn->local_entry)
- continue;
-
- silc_client_remove_from_channels(client, conn, client_entry);
- silc_idcache_del_by_context(conn->client_cache, client_entry);
- if (client_entry->nickname)
- silc_free(client_entry->nickname);
- if (client_entry->server)
- silc_free(client_entry->server);
- if (client_entry->id)
- silc_free(client_entry->id);
- if (client_entry->send_key)
- silc_cipher_free(client_entry->send_key);
- if (client_entry->receive_key)
- silc_cipher_free(client_entry->receive_key);
- silc_free(client_entry);
- }
- silc_free(clients);
+ /* Find Client entry and if not found resolve it */
+ client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
+ if (!client_entry || !client_entry->nickname[0]) {
+ /** Resolve client */
+ silc_client_unref_client(client, conn, client_entry);
+ SILC_FSM_CALL(silc_client_get_client_by_id_resolve(
+ client, conn, &id.u.client_id, NULL,
+ silc_client_notify_resolved,
+ fsm));
+ /* NOT REACHED */
+ }
- }
- break;
+ /* Get user mode */
+ tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
+ if (!tmp || tmp_len != 4)
+ goto out;
+ SILC_GET32_MSB(mode, tmp);
- default:
- break;
+ /* Get notify type */
+ tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
+ if (tmp && tmp_len != 2)
+ goto out;
+ if (tmp)
+ SILC_GET16_MSB(notify, tmp);
+
+ /* Get nickname */
+ tmp = silc_argument_get_arg_type(args, 2, NULL);
+ if (tmp) {
+ char *tmp_nick = NULL;
+
+ if (client->internal->params->nickname_parse)
+ client->internal->params->nickname_parse(client_entry->nickname,
+ &tmp_nick);
+ else
+ tmp_nick = strdup(tmp);
+
+ /* If same nick, the client was new to us and has become "present"
+ to network. Send NULL as nick to application. */
+ if (tmp_nick && silc_utf8_strcasecmp(tmp, tmp_nick))
+ tmp = NULL;
+
+ silc_free(tmp_nick);
+ }
+
+ /* Get public key, if present */
+ pk = silc_argument_get_arg_type(args, 5, &pk_len);
+ if (pk && !client_entry->public_key) {
+ if (silc_public_key_payload_decode(pk, pk_len, &public_key)) {
+ client_entry->public_key = public_key;
+ public_key = NULL;
+ }
}
+ /* Notify application. */
+ NOTIFY(client, conn, type, client_entry, tmp, mode, notify,
+ client_entry->public_key);
+
+ client_entry->mode = mode;
+
+ /* If nickname was changed, remove the client entry unless the
+ client is on some channel */
+ /* XXX, why do we need to remove the client entry?? */
+ if (tmp && notify == SILC_NOTIFY_TYPE_NICK_CHANGE &&
+ !silc_hash_table_count(client_entry->channels))
+ del_client = TRUE;
+ else if (notify == SILC_NOTIFY_TYPE_SIGNOFF ||
+ notify == SILC_NOTIFY_TYPE_SERVER_SIGNOFF ||
+ notify == SILC_NOTIFY_TYPE_KILLED)
+ del_client = TRUE;
+
+ if (del_client)
+ silc_client_del_client(client, conn, client_entry);
+
+ if (public_key)
+ silc_pkcs_public_key_free(public_key);
+
out:
- silc_notify_payload_free(payload);
- if (client_id)
- silc_free(client_id);
- if (channel_id)
- silc_free(channel_id);
+ /** Notify processed */
+ silc_client_unref_client(client, conn, client_entry);
+ silc_fsm_next(fsm, silc_client_notify_processed);
+ return SILC_FSM_CONTINUE;
}