uint32 arg_type,
unsigned char *arg,
uint32 arg_len);
+static bool
+silc_server_command_pending_error_check(SilcServerCommandContext cmd,
+ SilcServerCommandReplyContext cmdr,
+ SilcCommand command);
SILC_TASK_CALLBACK(silc_server_command_process_timeout);
/* Server command list. */
{ NULL, 0 },
};
-#define SILC_SERVER_COMMAND_CHECK_ARGC(command, context, min, max) \
+/* Performs several checks to the command. It first checks whether this
+ command was called as pending command callback. If it was then it checks
+ whether error occurred in the command reply where the pending command
+ callback was called.
+
+ It also checks that the requested command includes correct amount
+ of arguments. */
+#define SILC_SERVER_COMMAND_CHECK(command, context, min, max) \
do { \
- uint32 _argc = silc_argument_get_arg_num(cmd->args); \
+ uint32 _argc; \
\
SILC_LOG_DEBUG(("Start")); \
\
+ if (silc_server_command_pending_error_check(cmd, context2, command)) { \
+ silc_server_command_free(cmd); \
+ return; \
+ } \
+ \
+ _argc = silc_argument_get_arg_num(cmd->args); \
if (_argc < min) { \
silc_server_command_send_status_reply(cmd, command, \
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); \
client->last_command = time(NULL);
if (!(timeout->cmd->flags & SILC_CF_REG))
- timeout->cmd->cb(timeout->ctx);
+ timeout->cmd->cb(timeout->ctx, NULL);
else if (silc_server_is_registered(timeout->ctx->server,
timeout->ctx->sock,
timeout->ctx,
timeout->cmd->cmd))
- timeout->cmd->cb(timeout->ctx);
+ timeout->cmd->cb(timeout->ctx, NULL);
silc_free(timeout);
}
/* Execute for server */
if (!(cmd->flags & SILC_CF_REG))
- cmd->cb(ctx);
+ cmd->cb(ctx, NULL);
else if (silc_server_is_registered(server, sock, ctx, cmd->cmd))
- cmd->cb(ctx);
+ cmd->cb(ctx, NULL);
}
/* Allocate Command Context */
ctx->users));
if (ctx->users < 1) {
if (ctx->payload)
- silc_command_free_payload(ctx->payload);
+ silc_command_payload_free(ctx->payload);
if (ctx->packet)
silc_packet_context_free(ctx->packet);
if (ctx->sock)
silc_buffer_free(buffer);
}
+/* This function can be called to check whether in the command reply
+ an error occurred. This function has no effect if this is called
+ when the command function was not called as pending command callback.
+ This returns TRUE if error had occurred. */
+
+static bool
+silc_server_command_pending_error_check(SilcServerCommandContext cmd,
+ SilcServerCommandReplyContext cmdr,
+ SilcCommand command)
+{
+ SilcCommandStatus status;
+
+ if (!cmd->pending || !cmdr)
+ return FALSE;
+
+ SILC_GET16_MSB(status, silc_argument_get_arg_type(cmdr->args, 1, NULL));
+ if (status != SILC_STATUS_OK) {
+ /* Send the error message */
+ silc_server_command_send_status_reply(cmd, command, status);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
/******************************************************************************
WHOIS Functions
SilcClientEntry entry;
SilcCommandStatus status;
uint16 ident = silc_command_get_ident(cmd->payload);
- char nh[128], uh[128];
+ char nh[256], uh[256];
unsigned char idle[4], mode[4];
SilcSocketConnection hsock;
if (entry->data.registered == FALSE) {
if (clients_count == 1) {
- SilcBuffer idp = silc_id_payload_encode(entry->id, SILC_ID_CLIENT);
- silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 2, idp->data, idp->len);
- silc_buffer_free(idp);
+ if (entry->nickname) {
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
+ SILC_STATUS_ERR_NO_SUCH_NICK,
+ 3, entry->nickname,
+ strlen(entry->nickname));
+ } else {
+ SilcBuffer idp = silc_id_payload_encode(entry->id, SILC_ID_CLIENT);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 2, idp->data, idp->len);
+ silc_buffer_free(idp);
+ }
}
continue;
}
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
int ret = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_WHOIS, cmd, 1, 3328);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_WHOIS, cmd, 1, 3328);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
ret = silc_server_command_whois_from_client(cmd);
to our router if we are normal server, so let's do it now unless we
are standalone. We will not send any replies to the client until we
have received reply from the router. */
- if (server->server_type == SILC_SERVER &&
- !cmd->pending && !server->standalone) {
+ if (server->server_type == SILC_SERVER && !cmd->pending &&
+ !server->standalone) {
SilcBuffer tmpbuf;
uint16 old_ident;
nick, server->md5hash,
&clients, &clients_count);
+ if (!clients) {
+ /* Such a client really does not exist in the SILC network. */
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOWAS,
+ SILC_STATUS_ERR_NO_SUCH_NICK,
+ 3, nick, strlen(nick));
+ goto out;
+ }
+
if (!silc_server_command_whowas_check(cmd, clients, clients_count)) {
ret = -1;
goto out;
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
int ret = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_WHOWAS, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_WHOWAS, cmd, 1, 2);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
ret = silc_server_command_whowas_from_client(cmd);
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
int ret = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_IDENTIFY, cmd, 1, 3328);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_IDENTIFY, cmd, 1, 3328);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
ret = silc_server_command_identify_from_client(cmd);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_NICK, cmd, 1, 1);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_NICK, cmd, 1, 1);
/* Check nickname */
nick = silc_argument_get_arg_type(cmd->args, 1, NULL);
new_id);
/* Remove old cache entry */
- silc_idcache_del_by_id(server->local_list->clients, SILC_ID_CLIENT,
- client->id);
+ silc_idcache_del_by_context(server->local_list->clients, client);
oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
/* Update client cache */
silc_idcache_add(server->local_list->clients, client->nickname,
- strlen(client->nickname), SILC_ID_CLIENT, client->id,
- (void *)client, TRUE, FALSE);
+ client->id, (void *)client, FALSE);
nidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
memset(usercount, 0, sizeof(usercount));
} else {
topic = entry->topic;
- users = silc_list_count(entry->user_list);
+ users = silc_hash_table_count(entry->user_list);
SILC_PUT32_MSB(users, usercount);
}
memset(usercount, 0, sizeof(usercount));
} else {
topic = entry->topic;
- users = silc_list_count(entry->user_list);
+ users = silc_hash_table_count(entry->user_list);
SILC_PUT32_MSB(users, usercount);
}
SilcChannelEntry *lchannels = NULL, *gchannels = NULL;
uint32 lch_count = 0, gch_count = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LIST, cmd, 0, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_LIST, cmd, 0, 2);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
uint32 argc, tmp_len;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_TOPIC, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_TOPIC, cmd, 1, 2);
argc = silc_argument_get_arg_num(cmd->args);
goto out;
}
- /* See whether has rights to change topic */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
- if (chl->client == client)
- break;
+ /* See whether the client is on channel and has rights to change topic */
+ if (!silc_hash_table_find(channel->user_list, client, NULL,
+ (void *)&chl)) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL);
+ goto out;
+ }
if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
if (channel->mode & SILC_CHANNEL_MODE_TOPIC) {
uint32 len;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INVITE, cmd, 1, 4);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_INVITE, cmd, 1, 4);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
/* Check whether the channel is invite-only channel. If yes then the
sender of this command must be at least channel operator. */
if (channel->mode & SILC_CHANNEL_MODE_INVITE) {
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
- if (chl->client == sender) {
- if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV);
- goto out;
- }
- break;
- }
+ silc_hash_table_find(channel->user_list, sender, NULL, (void *)&chl);
+ if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV);
+ goto out;
+ }
}
/* Get destination client ID */
/* Get route to the client */
dest_sock = silc_server_get_client_route(server, NULL, 0, dest_id, &idata);
+ if (!dest_sock) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID);
+ goto out;
+ }
memset(invite, 0, sizeof(invite));
strncat(invite, dest->nickname, strlen(dest->nickname));
/* Send command reply */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INVITE,
- SILC_STATUS_OK, ident, 2,
- 2, tmp, len,
- 3, channel->invite_list,
- channel->invite_list ?
- strlen(channel->invite_list) :
- 0);
+
+ if (add || del)
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_INVITE,
+ SILC_STATUS_OK, ident, 2,
+ 2, tmp, len,
+ 3, channel->invite_list,
+ channel->invite_list ?
+ strlen(channel->invite_list) : 0);
+ else
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_INVITE,
+ SILC_STATUS_OK, ident, 1,
+ 2, tmp, len);
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
unsigned char *tmp = NULL;
uint32 len = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_QUIT, cmd, 0, 1);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_QUIT, cmd, 0, 1);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
unsigned char *tmp, *comment;
uint32 tmp_len, tmp_len2;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_KILL, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_KILL, cmd, 1, 2);
if (!client || cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
}
}
+ if (remote_client->data.registered == FALSE) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID);
+ goto out;
+ }
+
/* Get comment */
comment = silc_argument_get_arg_type(cmd->args, 2, &tmp_len2);
if (tmp_len2 > 128)
SilcServerEntry entry = NULL;
SilcServerID *server_id = NULL;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INFO, cmd, 0, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_INFO, cmd, 0, 2);
/* Get server name */
dest_server = silc_argument_get_arg_type(cmd->args, 1, NULL);
server_name = entry->server_name;
/* Send the reply */
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INFO,
- SILC_STATUS_OK, ident, 3,
- 2, idp->data, idp->len,
- 3, server_name,
- strlen(server_name),
- 4, server_info,
- strlen(server_info));
+ if (server_info)
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INFO,
+ SILC_STATUS_OK, ident, 3,
+ 2, idp->data, idp->len,
+ 3, server_name,
+ strlen(server_name),
+ 4, server_info,
+ strlen(server_info));
+ else
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INFO,
+ SILC_STATUS_OK, ident, 2,
+ 2, idp->data, idp->len,
+ 3, server_name,
+ strlen(server_name));
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
uint32 len;
unsigned char *tmp;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INFO, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_INFO, cmd, 1, 2);
/* Get Server ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
SilcChannelClientEntry chl;
SilcBuffer reply, chidp, clidp, keyp = NULL, user_list, mode_list;
uint16 ident = silc_command_get_ident(cmd->payload);
- char check[512];
+ char check[512], check2[512];
SILC_LOG_DEBUG(("Start"));
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT) {
client = (SilcClientEntry)sock->user_data;
} else {
- client = silc_idlist_find_client_by_id(server->local_list, client_id,
- NULL);
- if (!client)
- goto out;
+ client = silc_server_get_client_resolve(server, client_id);
+ if (!client) {
+ if (cmd->pending)
+ goto out;
+
+ /* The client info is being resolved. Reprocess this packet after
+ receiving the reply to the query. */
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ server->cmd_ident, NULL,
+ silc_server_command_join,
+ silc_server_command_dup(cmd));
+ cmd->pending = TRUE;
+ return;
+ }
+
+ cmd->pending = FALSE;
}
/*
* Check channel modes
*/
- if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT) {
- strncat(check, client->nickname, strlen(client->nickname));
- if (!strchr(client->nickname, '@')) {
- strncat(check, "@", 1);
- strncat(check, server->server_name, strlen(server->server_name));
- }
- strncat(check, "!", 1);
- strncat(check, client->username, strlen(client->username));
- if (!strchr(client->username, '@')) {
- strncat(check, "@", 1);
- strncat(check, cmd->sock->hostname, strlen(cmd->sock->hostname));
- }
+ memset(check, 0, sizeof(check));
+ memset(check2, 0, sizeof(check2));
+ strncat(check, client->nickname, strlen(client->nickname));
+ strncat(check, "!", 1);
+ strncat(check, client->username, strlen(client->username));
+ if (!strchr(client->username, '@')) {
+ strncat(check, "@", 1);
+ strncat(check, cmd->sock->hostname, strlen(cmd->sock->hostname));
}
- /* Check invite list if channel is invite-only channel */
- if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT &&
- channel->mode & SILC_CHANNEL_MODE_INVITE) {
- if (!channel->invite_list) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_NOT_INVITED);
- goto out;
- }
+ strncat(check2, client->nickname, strlen(client->nickname));
+ if (!strchr(client->nickname, '@')) {
+ strncat(check2, "@", 1);
+ strncat(check2, server->server_name, strlen(server->server_name));
+ }
+ strncat(check2, "!", 1);
+ strncat(check2, client->username, strlen(client->username));
+ if (!strchr(client->username, '@')) {
+ strncat(check2, "@", 1);
+ strncat(check2, cmd->sock->hostname, strlen(cmd->sock->hostname));
+ }
- if (!silc_string_match(channel->invite_list, check)) {
+ /* Check invite list if channel is invite-only channel */
+ if (channel->mode & SILC_CHANNEL_MODE_INVITE) {
+ if (!channel->invite_list ||
+ (!silc_string_match(channel->invite_list, check) &&
+ !silc_string_match(channel->invite_list, check2))) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_NOT_INVITED);
goto out;
/* Check ban list if it exists. If the client's nickname, server,
username and/or hostname is in the ban list the access to the
channel is denied. */
- if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT && channel->ban_list) {
- if (silc_string_match(channel->ban_list, check)) {
+ if (channel->ban_list) {
+ if (silc_string_match(channel->ban_list, check) ||
+ silc_string_match(channel->ban_list, check2)) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_BANNED_FROM_CHANNEL);
goto out;
/* Check user count limit if set. */
if (channel->mode & SILC_CHANNEL_MODE_ULIMIT) {
- if (silc_list_count(channel->user_list) + 1 >
+ if (silc_hash_table_count(channel->user_list) + 1 >
channel->user_limit) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_CHANNEL_IS_FULL);
}
/* Generate new channel key as protocol dictates */
- if ((!created && silc_list_count(channel->user_list) > 0) ||
+ if ((!created && silc_hash_table_count(channel->user_list) > 0) ||
!channel->channel_key)
silc_server_create_channel_key(server, channel, 0);
chl->mode = umode;
chl->client = client;
chl->channel = channel;
- silc_list_add(channel->user_list, chl);
- silc_list_add(client->channels, chl);
+ silc_hash_table_add(channel->user_list, client, chl);
+ silc_hash_table_add(client->channels, channel, chl);
/* Get users on the channel */
silc_server_get_users_on_channel(server, channel, &user_list, &mode_list,
int created = FALSE;
SilcClientID *client_id;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_JOIN, cmd, 1, 4);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_JOIN, cmd, 1, 4);
/* Get channel name */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
if (silc_server_command_bad_chars(channel_name) == TRUE) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_BAD_CHANNEL);
- silc_free(channel_name);
goto out;
}
if (server->server_type == SILC_SERVER) {
SilcBuffer tmpbuf;
uint16 old_ident;
+
+ /* If this is pending command callback then we've resolved
+ it and it didn't work, return since we've notified the
+ client already in the command reply callback. */
+ if (cmd->pending)
+ goto out;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
/* If the channel does not have global users and is also empty it means the
channel was created globally (by our router) and the client will be the
channel founder and operator. */
- if (!channel->global_users && silc_list_count(channel->user_list) == 0) {
+ if (!channel->global_users && !silc_hash_table_count(channel->user_list)) {
umode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
created = TRUE; /* Created globally by our router */
}
uint32 motd_len;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_MOTD, cmd, 1, 1);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_MOTD, cmd, 1, 1);
/* Get server name */
dest_server = silc_argument_get_arg_type(cmd->args, 1, NULL);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_UMODE, cmd, 2, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_UMODE, cmd, 2, 2);
/* Get the client's mode mask */
tmp_mask = silc_argument_get_arg_type(cmd->args, 2, NULL);
uint32 mode_mask, tmp_len, tmp_len2;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CMODE, cmd, 2, 7);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CMODE, cmd, 2, 7);
/* Get Channel ID */
tmp_id = silc_argument_get_arg_type(cmd->args, 1, &tmp_len2);
}
/* Get entry to the channel user list */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
- if (chl->client == client)
- break;
+ silc_hash_table_find(channel->user_list, client, NULL, (void *)&chl);
/* Check that client has rights to change any requested channel modes */
if (!silc_server_check_cmode_rights(channel, chl, mode_mask)) {
/* Send command reply to sender */
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_CMODE,
- SILC_STATUS_OK, ident, 1,
- 2, tmp_mask, 4);
+ SILC_STATUS_OK, ident, 2,
+ 2, tmp_id, tmp_len2,
+ 3, tmp_mask, 4);
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
int notify = FALSE;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CUMODE, cmd, 3, 4);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CUMODE, cmd, 3, 4);
/* Get Channel ID */
tmp_ch_id = silc_argument_get_arg_type(cmd->args, 1, &tmp_ch_len);
}
/* Check that client has rights to change other's rights */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
- if (chl->client == client) {
- sender_mask = chl->mode;
- break;
- }
- }
+ silc_hash_table_find(channel->user_list, client, NULL, (void *)&chl);
+ sender_mask = chl->mode;
/* Get the target client's channel mode mask */
tmp_mask = silc_argument_get_arg_type(cmd->args, 2, NULL);
}
/* Get entry to the channel user list */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
- if (chl->client == target_client)
- break;
+ silc_hash_table_find(channel->user_list, target_client, NULL,
+ (void *)&chl);
}
/*
/* Send command reply to sender */
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_CUMODE,
- SILC_STATUS_OK, ident, 2,
+ SILC_STATUS_OK, ident, 3,
2, tmp_mask, 4,
- 3, tmp_id, tmp_len);
+ 3, tmp_ch_id, tmp_ch_len,
+ 4, tmp_id, tmp_len);
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
uint32 tmp_len;
unsigned char *tmp, *comment;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LEAVE, cmd, 1, 3);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_LEAVE, cmd, 1, 3);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
}
/* Check that the kicker is channel operator or channel founder */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
- if (chl->client == client) {
- if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV);
- goto out;
- }
- break;
- }
+ silc_hash_table_find(channel->user_list, client, NULL, (void *)&chl);
+ if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV);
+ goto out;
}
/* Get target Client ID */
/* Check that the target client is not channel founder. Channel founder
cannot be kicked from the channel. */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
- if (chl->client == target_client) {
- if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CHANNEL_FOPRIV);
- goto out;
- }
- break;
- }
+ silc_hash_table_find(channel->user_list, target_client, NULL, (void *)&chl);
+ if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NO_CHANNEL_FOPRIV);
+ goto out;
}
/* Check whether target client is on the channel */
SilcServerConfigSectionAdminConnection *admin;
SilcIDListData idata = (SilcIDListData)client;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_OPER, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_OPER, cmd, 1, 2);
if (!client || cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
SilcServerConfigSectionAdminConnection *admin;
SilcIDListData idata = (SilcIDListData)client;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_SILCOPER, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_SILCOPER, cmd, 1, 2);
if (server->server_type == SILC_SERVER)
goto out;
uint32 tmp_len;
uint32 port = SILC_PORT;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CONNECT, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CONNECT, cmd, 1, 2);
if (!client || cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_BAN, cmd, 0, 3);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_BAN, cmd, 0, 3);
/* Get Channel ID */
id = silc_argument_get_arg_type(cmd->args, 1, &id_len);
}
/* Get entry to the channel user list */
- silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
- if (chl->client == client)
- break;
+ silc_hash_table_find(channel->user_list, client, NULL, (void *)&chl);
/* The client must be at least channel operator. */
if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP)) {
unsigned char *name;
uint32 port = SILC_PORT;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CLOSE, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CLOSE, cmd, 1, 2);
if (!client || cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_SHUTDOWN, cmd, 0, 0);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_SHUTDOWN, cmd, 0, 0);
if (!client || cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
uint32 len;
unsigned char *tmp;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LEAVE, cmd, 1, 2);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_LEAVE, cmd, 1, 2);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
uint32 list_count = 0;
uint16 ident = silc_command_get_ident(cmd->payload);
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_USERS, cmd, 1, 1);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_USERS, cmd, 1, 1);
/* Get Channel ID */
channel_id = silc_argument_get_arg_type(cmd->args, 1, &channel_id_len);
SilcBuffer pk;
SilcIdType id_type;
+ SILC_LOG_DEBUG(("Start"));
+
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
if (!tmp) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_GETKEY,
would be locally connected client so send the command further. */
client = silc_idlist_find_client_by_id(server->local_list,
client_id, NULL);
+ if (!client)
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
if ((!client && !cmd->pending && !server->standalone) ||
- (client && !client->connection)) {
+ (client && !client->connection && !cmd->pending &&
+ !server->standalone) ||
+ (client && !client->data.public_key && !cmd->pending &&
+ !server->standalone)) {
SilcBuffer tmpbuf;
uint16 old_ident;
SilcSocketConnection dest_sock;
would be locally connected server so send the command further. */
server_entry = silc_idlist_find_server_by_id(server->local_list,
server_id, NULL);
+ if (!server_entry)
+ server_entry = silc_idlist_find_server_by_id(server->global_list,
+ server_id, NULL);
if ((!server_entry && !cmd->pending && !server->standalone) ||
- (server_entry && !server_entry->connection)) {
+ (server_entry && !server_entry->connection && !cmd->pending &&
+ !server->standalone) ||
+ (server_entry && !server_entry->data.public_key && !cmd->pending &&
+ !server->standalone)) {
SilcBuffer tmpbuf;
uint16 old_ident;
projects / silc.git / blobdiff